github.com/jasoet/gopki@v1.15.0/cert/certificate_der_test.go (about)

     1  package cert
     2  
     3  import (
     4  	"bytes"
     5  	"crypto/ecdsa"
     6  	"crypto/ed25519"
     7  	"crypto/rsa"
     8  	"crypto/x509/pkix"
     9  	"os"
    10  	"testing"
    11  	"time"
    12  
    13  	"github.com/jasoet/gopki/keypair"
    14  	"github.com/jasoet/gopki/keypair/algo"
    15  )
    16  
    17  // TestDERFormatSupport tests all DER format functionality
    18  func TestDERFormatSupport(t *testing.T) {
    19  	// Generate test key pair
    20  	manager, err := keypair.Generate[algo.KeySize, *algo.RSAKeyPair, *rsa.PrivateKey, *rsa.PublicKey](algo.KeySize2048)
    21  	if err != nil {
    22  		t.Fatalf("Failed to generate key pair: %v", err)
    23  	}
    24  	keyPair := manager.KeyPair()
    25  
    26  	// Create test certificate
    27  	certificate, err := CreateSelfSignedCertificate(keyPair, CertificateRequest{
    28  		Subject: pkix.Name{
    29  			CommonName: "DER Test Certificate",
    30  		},
    31  		ValidFor: 24 * time.Hour,
    32  	})
    33  	if err != nil {
    34  		t.Fatalf("Failed to create certificate: %v", err)
    35  	}
    36  
    37  	// Verify both PEM and DER data are populated
    38  	if len(certificate.PEMData) == 0 {
    39  		t.Error("PEMData should be populated")
    40  	}
    41  	if len(certificate.DERData) == 0 {
    42  		t.Error("DERData should be populated")
    43  	}
    44  
    45  	t.Logf("PEM data length: %d bytes", len(certificate.PEMData))
    46  	t.Logf("DER data length: %d bytes", len(certificate.DERData))
    47  
    48  	// DER should be smaller than PEM
    49  	if len(certificate.DERData) >= len(certificate.PEMData) {
    50  		t.Error("DER data should be smaller than PEM data")
    51  	}
    52  }
    53  
    54  // TestDERFileSaveAndLoad tests saving and loading DER files
    55  func TestDERFileSaveAndLoad(t *testing.T) {
    56  	// Generate test certificate
    57  	manager, err := keypair.Generate[algo.ECDSACurve, *algo.ECDSAKeyPair, *ecdsa.PrivateKey, *ecdsa.PublicKey](algo.P256)
    58  	if err != nil {
    59  		t.Fatalf("Failed to generate key pair: %v", err)
    60  	}
    61  	keyPair := manager.KeyPair()
    62  
    63  	originalCert, err := CreateSelfSignedCertificate(keyPair, CertificateRequest{
    64  		Subject: pkix.Name{
    65  			CommonName: "DER File Test",
    66  		},
    67  		ValidFor: 24 * time.Hour,
    68  	})
    69  	if err != nil {
    70  		t.Fatalf("Failed to create certificate: %v", err)
    71  	}
    72  
    73  	// Test DER file operations
    74  	derFilename := "/tmp/test_cert.der"
    75  	defer os.Remove(derFilename)
    76  
    77  	// Save to DER file
    78  	err = originalCert.SaveToDERFile(derFilename)
    79  	if err != nil {
    80  		t.Fatalf("Failed to save DER file: %v", err)
    81  	}
    82  
    83  	// Check file exists and has content
    84  	fileInfo, err := os.Stat(derFilename)
    85  	if err != nil {
    86  		t.Fatalf("DER file was not created: %v", err)
    87  	}
    88  	if fileInfo.Size() == 0 {
    89  		t.Error("DER file is empty")
    90  	}
    91  
    92  	// Load from DER file
    93  	loadedCert, err := LoadCertificateFromDERFile(derFilename)
    94  	if err != nil {
    95  		t.Fatalf("Failed to load DER file: %v", err)
    96  	}
    97  
    98  	// Verify loaded certificate matches original
    99  	if !originalCert.Certificate.Equal(loadedCert.Certificate) {
   100  		t.Error("Loaded certificate doesn't match original")
   101  	}
   102  
   103  	// Verify both PEM and DER data are populated in loaded certificate
   104  	if len(loadedCert.PEMData) == 0 {
   105  		t.Error("Loaded certificate should have PEMData populated")
   106  	}
   107  	if len(loadedCert.DERData) == 0 {
   108  		t.Error("Loaded certificate should have DERData populated")
   109  	}
   110  
   111  	// Verify DER data matches
   112  	if !bytes.Equal(originalCert.DERData, loadedCert.DERData) {
   113  		t.Error("DER data doesn't match between original and loaded certificate")
   114  	}
   115  }
   116  
   117  // TestDERParsing tests direct DER data parsing
   118  func TestDERParsing(t *testing.T) {
   119  	// Create test certificate
   120  	manager, err := keypair.Generate[algo.Ed25519Config, *algo.Ed25519KeyPair, ed25519.PrivateKey, ed25519.PublicKey]("")
   121  	if err != nil {
   122  		t.Fatalf("Failed to generate key pair: %v", err)
   123  	}
   124  	keyPair := manager.KeyPair()
   125  
   126  	originalCert, err := CreateSelfSignedCertificate(keyPair, CertificateRequest{
   127  		Subject: pkix.Name{
   128  			CommonName:   "DER Parsing Test",
   129  			Organization: []string{"Test Org"},
   130  		},
   131  		DNSNames: []string{"test.example.com"},
   132  		ValidFor: 24 * time.Hour,
   133  	})
   134  	if err != nil {
   135  		t.Fatalf("Failed to create certificate: %v", err)
   136  	}
   137  
   138  	// Parse certificate from DER data
   139  	parsedCert, err := ParseCertificateFromDER(originalCert.DERData)
   140  	if err != nil {
   141  		t.Fatalf("Failed to parse DER certificate: %v", err)
   142  	}
   143  
   144  	// Verify parsed certificate matches original
   145  	if !originalCert.Certificate.Equal(parsedCert.Certificate) {
   146  		t.Error("Parsed certificate doesn't match original")
   147  	}
   148  
   149  	// Verify subject information
   150  	if parsedCert.Certificate.Subject.CommonName != "DER Parsing Test" {
   151  		t.Errorf("Expected CommonName 'DER Parsing Test', got '%s'", parsedCert.Certificate.Subject.CommonName)
   152  	}
   153  
   154  	if len(parsedCert.Certificate.DNSNames) != 1 || parsedCert.Certificate.DNSNames[0] != "test.example.com" {
   155  		t.Errorf("Expected DNSNames ['test.example.com'], got %v", parsedCert.Certificate.DNSNames)
   156  	}
   157  }
   158  
   159  // TestToDERToPEMMethods tests the ToDER() and ToPEM() methods
   160  func TestToDERToPEMMethods(t *testing.T) {
   161  	manager, err := keypair.Generate[algo.KeySize, *algo.RSAKeyPair, *rsa.PrivateKey, *rsa.PublicKey](algo.KeySize2048)
   162  	if err != nil {
   163  		t.Fatalf("Failed to generate key pair: %v", err)
   164  	}
   165  	keyPair := manager.KeyPair()
   166  
   167  	certificate, err := CreateSelfSignedCertificate(keyPair, CertificateRequest{
   168  		Subject: pkix.Name{
   169  			CommonName: "Method Test Certificate",
   170  		},
   171  		ValidFor: 24 * time.Hour,
   172  	})
   173  	if err != nil {
   174  		t.Fatalf("Failed to create certificate: %v", err)
   175  	}
   176  
   177  	// Test ToDER() method
   178  	derData := certificate.ToDER()
   179  	if !bytes.Equal(derData, certificate.DERData) {
   180  		t.Error("ToDER() should return the same data as DERData field")
   181  	}
   182  
   183  	// Test ToPEM() method
   184  	pemData := certificate.ToPEM()
   185  	if !bytes.Equal(pemData, certificate.PEMData) {
   186  		t.Error("ToPEM() should return the same data as PEMData field")
   187  	}
   188  
   189  	// Verify DER is binary (not printable text)
   190  	for _, b := range derData[:min(10, len(derData))] {
   191  		if b > 127 {
   192  			// Found non-ASCII byte, this is good for DER
   193  			break
   194  		}
   195  		if b < 32 && b != 9 && b != 10 && b != 13 {
   196  			// Found control character (except tab, LF, CR), this is good for DER
   197  			break
   198  		}
   199  	}
   200  
   201  	// Verify PEM contains header
   202  	pemString := string(pemData)
   203  	if !bytes.Contains(pemData, []byte("-----BEGIN CERTIFICATE-----")) {
   204  		t.Error("PEM data should contain BEGIN CERTIFICATE header")
   205  	}
   206  	if !bytes.Contains(pemData, []byte("-----END CERTIFICATE-----")) {
   207  		t.Error("PEM data should contain END CERTIFICATE header")
   208  	}
   209  
   210  	t.Logf("PEM preview: %s", pemString[:min(100, len(pemString))])
   211  }
   212  
   213  // TestPEMToDERConversion tests format conversion functions
   214  func TestPEMToDERConversion(t *testing.T) {
   215  	manager, err := keypair.Generate[algo.KeySize, *algo.RSAKeyPair, *rsa.PrivateKey, *rsa.PublicKey](algo.KeySize2048)
   216  	if err != nil {
   217  		t.Fatalf("Failed to generate key pair: %v", err)
   218  	}
   219  	keyPair := manager.KeyPair()
   220  
   221  	originalCert, err := CreateSelfSignedCertificate(keyPair, CertificateRequest{
   222  		Subject: pkix.Name{
   223  			CommonName: "Conversion Test",
   224  		},
   225  		ValidFor: 24 * time.Hour,
   226  	})
   227  	if err != nil {
   228  		t.Fatalf("Failed to create certificate: %v", err)
   229  	}
   230  
   231  	// Test PEM to DER conversion
   232  	derFromPEM, err := ConvertPEMToDER(originalCert.PEMData)
   233  	if err != nil {
   234  		t.Fatalf("Failed to convert PEM to DER: %v", err)
   235  	}
   236  
   237  	if !bytes.Equal(derFromPEM, originalCert.DERData) {
   238  		t.Error("Converted DER doesn't match original DER data")
   239  	}
   240  
   241  	// Test DER to PEM conversion
   242  	pemFromDER, err := ConvertDERToPEM(originalCert.DERData)
   243  	if err != nil {
   244  		t.Fatalf("Failed to convert DER to PEM: %v", err)
   245  	}
   246  
   247  	// Parse both PEM versions to verify they represent the same certificate
   248  	originalParsed, err := ParseCertificateFromPEM(originalCert.PEMData)
   249  	if err != nil {
   250  		t.Fatalf("Failed to parse original PEM: %v", err)
   251  	}
   252  
   253  	convertedParsed, err := ParseCertificateFromPEM(pemFromDER)
   254  	if err != nil {
   255  		t.Fatalf("Failed to parse converted PEM: %v", err)
   256  	}
   257  
   258  	if !originalParsed.Certificate.Equal(convertedParsed.Certificate) {
   259  		t.Error("Original and converted certificates don't match")
   260  	}
   261  
   262  	t.Logf("Original PEM size: %d bytes", len(originalCert.PEMData))
   263  	t.Logf("DER size: %d bytes", len(originalCert.DERData))
   264  	t.Logf("Converted PEM size: %d bytes", len(pemFromDER))
   265  	t.Logf("DER is %.1f%% smaller than PEM", float64(len(originalCert.DERData))/float64(len(originalCert.PEMData))*100)
   266  }
   267  
   268  // TestDERConversionErrors tests error handling in conversion functions
   269  func TestDERConversionErrors(t *testing.T) {
   270  	// Test invalid PEM data
   271  	invalidPEM := []byte("This is not PEM data")
   272  	_, err := ConvertPEMToDER(invalidPEM)
   273  	if err == nil {
   274  		t.Error("Expected error for invalid PEM data")
   275  	}
   276  
   277  	// Test invalid DER data
   278  	invalidDER := []byte("This is not DER data")
   279  	_, err = ConvertDERToPEM(invalidDER)
   280  	if err == nil {
   281  		t.Error("Expected error for invalid DER data")
   282  	}
   283  
   284  	// Test wrong PEM block type
   285  	wrongTypePEM := []byte(`-----BEGIN PRIVATE KEY-----
   286  MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAg==
   287  -----END PRIVATE KEY-----`)
   288  	_, err = ConvertPEMToDER(wrongTypePEM)
   289  	if err == nil {
   290  		t.Error("Expected error for wrong PEM block type")
   291  	}
   292  }
   293  
   294  // Helper function for min (Go 1.21+)
   295  func min(a, b int) int {
   296  	if a < b {
   297  		return a
   298  	}
   299  	return b
   300  }