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  }