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 }