github.com/jasoet/gopki@v1.15.0/cert/certificate_test.go (about) 1 package cert 2 3 import ( 4 "crypto/x509" 5 "crypto/x509/pkix" 6 "github.com/jasoet/gopki/keypair/algo" 7 "net" 8 "os" 9 "path/filepath" 10 "testing" 11 "time" 12 ) 13 14 func TestCreateSelfSignedCertificate(t *testing.T) { 15 t.Run("RSA self-signed certificate", func(t *testing.T) { 16 keyPair, err := algo.GenerateRSAKeyPair(algo.KeySize2048) 17 if err != nil { 18 t.Fatalf("Failed to generate RSA key pair: %v", err) 19 } 20 21 request := CertificateRequest{ 22 Subject: pkix.Name{ 23 Country: []string{"US"}, 24 Organization: []string{"Test Organization"}, 25 CommonName: "test.example.com", 26 }, 27 DNSNames: []string{"test.example.com", "www.test.example.com"}, 28 ValidFrom: time.Now(), 29 ValidFor: 365 * 24 * time.Hour, 30 } 31 32 cert, err := CreateSelfSignedCertificate(keyPair, request) 33 if err != nil { 34 t.Fatalf("Failed to create self-signed certificate: %v", err) 35 } 36 37 if cert.Certificate == nil { 38 t.Fatal("Certificate is nil") 39 } 40 41 if len(cert.PEMData) == 0 { 42 t.Fatal("PEM data is empty") 43 } 44 45 if cert.Certificate.Subject.CommonName != "test.example.com" { 46 t.Fatalf("Expected CommonName 'test.example.com', got '%s'", cert.Certificate.Subject.CommonName) 47 } 48 49 if len(cert.Certificate.DNSNames) != 2 { 50 t.Fatalf("Expected 2 DNS names, got %d", len(cert.Certificate.DNSNames)) 51 } 52 }) 53 54 t.Run("ECDSA self-signed certificate", func(t *testing.T) { 55 keyPair, err := algo.GenerateECDSAKeyPair(algo.P256) 56 if err != nil { 57 t.Fatalf("Failed to generate ECDSA key pair: %v", err) 58 } 59 60 request := CertificateRequest{ 61 Subject: pkix.Name{ 62 CommonName: "ecdsa.example.com", 63 }, 64 ValidFor: 30 * 24 * time.Hour, 65 } 66 67 cert, err := CreateSelfSignedCertificate(keyPair, request) 68 if err != nil { 69 t.Fatalf("Failed to create ECDSA self-signed certificate: %v", err) 70 } 71 72 if cert.Certificate.Subject.CommonName != "ecdsa.example.com" { 73 t.Fatalf("Expected CommonName 'ecdsa.example.com', got '%s'", cert.Certificate.Subject.CommonName) 74 } 75 }) 76 77 t.Run("Ed25519 self-signed certificate", func(t *testing.T) { 78 keyPair, err := algo.GenerateEd25519KeyPair() 79 if err != nil { 80 t.Fatalf("Failed to generate Ed25519 key pair: %v", err) 81 } 82 83 request := CertificateRequest{ 84 Subject: pkix.Name{ 85 CommonName: "ed25519.example.com", 86 }, 87 IPAddresses: []net.IP{net.IPv4(127, 0, 0, 1)}, 88 ValidFor: 24 * time.Hour, 89 } 90 91 cert, err := CreateSelfSignedCertificate(keyPair, request) 92 if err != nil { 93 t.Fatalf("Failed to create Ed25519 self-signed certificate: %v", err) 94 } 95 96 if len(cert.Certificate.IPAddresses) != 1 { 97 t.Fatalf("Expected 1 IP address, got %d", len(cert.Certificate.IPAddresses)) 98 } 99 }) 100 } 101 102 func TestCreateCACertificate(t *testing.T) { 103 keyPair, err := algo.GenerateRSAKeyPair(algo.KeySize2048) 104 if err != nil { 105 t.Fatalf("Failed to generate RSA key pair: %v", err) 106 } 107 108 request := CertificateRequest{ 109 Subject: pkix.Name{ 110 Country: []string{"US"}, 111 Organization: []string{"Test CA"}, 112 CommonName: "Test Root CA", 113 }, 114 ValidFor: 10 * 365 * 24 * time.Hour, 115 } 116 117 caCert, err := CreateCACertificate(keyPair, request) 118 if err != nil { 119 t.Fatalf("Failed to create CA certificate: %v", err) 120 } 121 122 if !caCert.Certificate.IsCA { 123 t.Fatal("Certificate is not marked as CA") 124 } 125 126 if caCert.Certificate.Subject.CommonName != "Test Root CA" { 127 t.Fatalf("Expected CommonName 'Test Root CA', got '%s'", caCert.Certificate.Subject.CommonName) 128 } 129 130 expectedKeyUsage := caCert.Certificate.KeyUsage 131 if expectedKeyUsage&x509.KeyUsageCertSign == 0 { 132 t.Fatal("CA certificate missing CertSign key usage") 133 } 134 135 if expectedKeyUsage&x509.KeyUsageCRLSign == 0 { 136 t.Fatal("CA certificate missing CRLSign key usage") 137 } 138 } 139 140 func TestSignCertificate(t *testing.T) { 141 // Create CA 142 caKeyPair, err := algo.GenerateRSAKeyPair(algo.KeySize2048) 143 if err != nil { 144 t.Fatalf("Failed to generate CA key pair: %v", err) 145 } 146 147 caRequest := CertificateRequest{ 148 Subject: pkix.Name{ 149 CommonName: "Test CA", 150 }, 151 ValidFor: 10 * 365 * 24 * time.Hour, 152 } 153 154 caCert, err := CreateCACertificate(caKeyPair, caRequest) 155 if err != nil { 156 t.Fatalf("Failed to create CA certificate: %v", err) 157 } 158 159 // Create server key pair 160 serverKeyPair, err := algo.GenerateRSAKeyPair(algo.KeySize2048) 161 if err != nil { 162 t.Fatalf("Failed to generate server key pair: %v", err) 163 } 164 165 serverRequest := CertificateRequest{ 166 Subject: pkix.Name{ 167 CommonName: "server.example.com", 168 }, 169 DNSNames: []string{"server.example.com", "api.example.com"}, 170 EmailAddress: []string{"admin@example.com"}, 171 ValidFor: 365 * 24 * time.Hour, 172 } 173 174 // Sign server certificate 175 serverCert, err := SignCertificate(caCert, caKeyPair, serverRequest, serverKeyPair.PublicKey) 176 if err != nil { 177 t.Fatalf("Failed to sign server certificate: %v", err) 178 } 179 180 if serverCert.Certificate.Subject.CommonName != "server.example.com" { 181 t.Fatalf("Expected CommonName 'server.example.com', got '%s'", serverCert.Certificate.Subject.CommonName) 182 } 183 184 if serverCert.Certificate.IsCA { 185 t.Fatal("Server certificate should not be marked as CA") 186 } 187 188 if len(serverCert.Certificate.DNSNames) != 2 { 189 t.Fatalf("Expected 2 DNS names, got %d", len(serverCert.Certificate.DNSNames)) 190 } 191 192 if len(serverCert.Certificate.EmailAddresses) != 1 { 193 t.Fatalf("Expected 1 email address, got %d", len(serverCert.Certificate.EmailAddresses)) 194 } 195 } 196 197 func TestVerifyCertificate(t *testing.T) { 198 // Create CA 199 caKeyPair, err := algo.GenerateRSAKeyPair(algo.KeySize2048) 200 if err != nil { 201 t.Fatalf("Failed to generate CA key pair: %v", err) 202 } 203 204 caRequest := CertificateRequest{ 205 Subject: pkix.Name{ 206 CommonName: "Test CA", 207 }, 208 ValidFor: 10 * 365 * 24 * time.Hour, 209 } 210 211 caCert, err := CreateCACertificate(caKeyPair, caRequest) 212 if err != nil { 213 t.Fatalf("Failed to create CA certificate: %v", err) 214 } 215 216 // Create and sign a certificate 217 serverKeyPair, err := algo.GenerateRSAKeyPair(algo.KeySize2048) 218 if err != nil { 219 t.Fatalf("Failed to generate server key pair: %v", err) 220 } 221 222 serverRequest := CertificateRequest{ 223 Subject: pkix.Name{ 224 CommonName: "server.example.com", 225 }, 226 ValidFor: 365 * 24 * time.Hour, 227 } 228 229 serverCert, err := SignCertificate(caCert, caKeyPair, serverRequest, serverKeyPair.PublicKey) 230 if err != nil { 231 t.Fatalf("Failed to sign server certificate: %v", err) 232 } 233 234 // Verify the certificate 235 err = VerifyCertificate(serverCert, caCert) 236 if err != nil { 237 t.Fatalf("Certificate verification failed: %v", err) 238 } 239 240 // Test verification with wrong CA 241 wrongCaKeyPair, _ := algo.GenerateRSAKeyPair(algo.KeySize2048) 242 wrongCaRequest := CertificateRequest{ 243 Subject: pkix.Name{ 244 CommonName: "Wrong CA", 245 }, 246 ValidFor: 10 * 365 * 24 * time.Hour, 247 } 248 249 wrongCaCert, err := CreateCACertificate(wrongCaKeyPair, wrongCaRequest) 250 if err != nil { 251 t.Fatalf("Failed to create wrong CA certificate: %v", err) 252 } 253 254 err = VerifyCertificate(serverCert, wrongCaCert) 255 if err == nil { 256 t.Fatal("Expected verification to fail with wrong CA") 257 } 258 } 259 260 func TestCertificateFileOperations(t *testing.T) { 261 tempDir := t.TempDir() 262 certFile := filepath.Join(tempDir, "test.pem") 263 264 keyPair, err := algo.GenerateRSAKeyPair(algo.KeySize2048) 265 if err != nil { 266 t.Fatalf("Failed to generate key pair: %v", err) 267 } 268 269 request := CertificateRequest{ 270 Subject: pkix.Name{ 271 CommonName: "file-test.example.com", 272 }, 273 ValidFor: 365 * 24 * time.Hour, 274 } 275 276 cert, err := CreateSelfSignedCertificate(keyPair, request) 277 if err != nil { 278 t.Fatalf("Failed to create certificate: %v", err) 279 } 280 281 // Save certificate to file 282 err = cert.SaveToFile(certFile) 283 if err != nil { 284 t.Fatalf("Failed to save certificate to file: %v", err) 285 } 286 287 // Check if file exists 288 if _, err := os.Stat(certFile); os.IsNotExist(err) { 289 t.Fatal("Certificate file was not created") 290 } 291 292 // Load certificate from file 293 loadedCert, err := LoadCertificateFromFile(certFile) 294 if err != nil { 295 t.Fatalf("Failed to load certificate from file: %v", err) 296 } 297 298 if loadedCert.Certificate.Subject.CommonName != cert.Certificate.Subject.CommonName { 299 t.Fatal("Loaded certificate doesn't match original") 300 } 301 302 if string(loadedCert.PEMData) != string(cert.PEMData) { 303 t.Fatal("Loaded PEM data doesn't match original") 304 } 305 } 306 307 func TestParseCertificateFromPEM(t *testing.T) { 308 keyPair, err := algo.GenerateRSAKeyPair(algo.KeySize2048) 309 if err != nil { 310 t.Fatalf("Failed to generate key pair: %v", err) 311 } 312 313 request := CertificateRequest{ 314 Subject: pkix.Name{ 315 CommonName: "parse-test.example.com", 316 }, 317 ValidFor: 365 * 24 * time.Hour, 318 } 319 320 originalCert, err := CreateSelfSignedCertificate(keyPair, request) 321 if err != nil { 322 t.Fatalf("Failed to create certificate: %v", err) 323 } 324 325 // Parse from PEM data 326 parsedCert, err := ParseCertificateFromPEM(originalCert.PEMData) 327 if err != nil { 328 t.Fatalf("Failed to parse certificate from PEM: %v", err) 329 } 330 331 if parsedCert.Certificate.Subject.CommonName != originalCert.Certificate.Subject.CommonName { 332 t.Fatal("Parsed certificate doesn't match original") 333 } 334 335 // Test with invalid PEM data 336 invalidPEM := []byte("invalid pem data") 337 _, err = ParseCertificateFromPEM(invalidPEM) 338 if err == nil { 339 t.Fatal("Expected error when parsing invalid PEM data") 340 } 341 342 // Test with wrong PEM type 343 wrongTypePEM := []byte(`-----BEGIN PRIVATE KEY----- 344 MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQC7 345 -----END PRIVATE KEY-----`) 346 _, err = ParseCertificateFromPEM(wrongTypePEM) 347 if err == nil { 348 t.Fatal("Expected error when parsing wrong PEM type") 349 } 350 } 351 352 func TestCertificateDefaultValues(t *testing.T) { 353 keyPair, err := algo.GenerateRSAKeyPair(algo.KeySize2048) 354 if err != nil { 355 t.Fatalf("Failed to generate key pair: %v", err) 356 } 357 358 // Test with minimal request (should use defaults) 359 request := CertificateRequest{ 360 Subject: pkix.Name{ 361 CommonName: "default-test.example.com", 362 }, 363 } 364 365 cert, err := CreateSelfSignedCertificate(keyPair, request) 366 if err != nil { 367 t.Fatalf("Failed to create certificate with defaults: %v", err) 368 } 369 370 // Check that ValidFrom was set to current time (within 1 minute) 371 timeDiff := time.Now().Sub(cert.Certificate.NotBefore) 372 if timeDiff > time.Minute || timeDiff < 0 { 373 t.Fatal("ValidFrom was not set to current time") 374 } 375 376 // Check that ValidFor was set to 1 year (default) 377 expectedValidFor := 365 * 24 * time.Hour 378 actualValidFor := cert.Certificate.NotAfter.Sub(cert.Certificate.NotBefore) 379 380 // Allow some tolerance for time differences 381 tolerance := time.Minute 382 if actualValidFor > expectedValidFor+tolerance || actualValidFor < expectedValidFor-tolerance { 383 t.Fatalf("Expected ValidFor ~%v, got %v", expectedValidFor, actualValidFor) 384 } 385 }