github.com/jasoet/gopki@v1.15.0/encryption/certificate/certificate_test.go (about)

     1  package certificate
     2  
     3  import (
     4  	"crypto/rand"
     5  	"crypto/x509"
     6  	"crypto/x509/pkix"
     7  	"math/big"
     8  	"testing"
     9  	"time"
    10  
    11  	"github.com/jasoet/gopki/cert"
    12  	"github.com/jasoet/gopki/encryption"
    13  	"github.com/jasoet/gopki/keypair/algo"
    14  	"github.com/stretchr/testify/assert"
    15  )
    16  
    17  // Helper function to create test certificate
    18  func createTestCertificate(t *testing.T, keyPair interface{}) *cert.Certificate {
    19  	template := x509.Certificate{
    20  		SerialNumber: big.NewInt(1),
    21  		Subject: pkix.Name{
    22  			CommonName:   "Test Certificate",
    23  			Organization: []string{"Test Org"},
    24  		},
    25  		NotBefore:             time.Now().Add(-time.Hour),
    26  		NotAfter:              time.Now().Add(365 * 24 * time.Hour),
    27  		KeyUsage:              x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature | x509.KeyUsageKeyAgreement,
    28  		ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth, x509.ExtKeyUsageClientAuth},
    29  		BasicConstraintsValid: true,
    30  	}
    31  
    32  	var publicKey interface{}
    33  	var privateKey interface{}
    34  
    35  	switch kp := keyPair.(type) {
    36  	case *algo.RSAKeyPair:
    37  		publicKey = kp.PublicKey
    38  		privateKey = kp.PrivateKey
    39  	case *algo.ECDSAKeyPair:
    40  		publicKey = kp.PublicKey
    41  		privateKey = kp.PrivateKey
    42  	case *algo.Ed25519KeyPair:
    43  		publicKey = kp.PublicKey
    44  		privateKey = kp.PrivateKey
    45  	default:
    46  		t.Fatalf("Unsupported key pair type: %T", keyPair)
    47  	}
    48  
    49  	certDER, err := x509.CreateCertificate(rand.Reader, &template, &template, publicKey, privateKey)
    50  	assert.NoError(t, err)
    51  
    52  	parsedCert, err := x509.ParseCertificate(certDER)
    53  	assert.NoError(t, err)
    54  
    55  	return &cert.Certificate{
    56  		Certificate: parsedCert,
    57  	}
    58  }
    59  
    60  // Helper function to create expired certificate
    61  func createExpiredCertificate(t *testing.T, keyPair interface{}) *cert.Certificate {
    62  	template := x509.Certificate{
    63  		SerialNumber: big.NewInt(1),
    64  		Subject: pkix.Name{
    65  			CommonName: "Expired Certificate",
    66  		},
    67  		NotBefore:             time.Now().Add(-48 * time.Hour),
    68  		NotAfter:              time.Now().Add(-24 * time.Hour), // Expired
    69  		KeyUsage:              x509.KeyUsageKeyEncipherment,
    70  		BasicConstraintsValid: true,
    71  	}
    72  
    73  	var publicKey interface{}
    74  	var privateKey interface{}
    75  
    76  	switch kp := keyPair.(type) {
    77  	case *algo.RSAKeyPair:
    78  		publicKey = kp.PublicKey
    79  		privateKey = kp.PrivateKey
    80  	default:
    81  		t.Fatalf("Unsupported key pair type: %T", keyPair)
    82  	}
    83  
    84  	certDER, err := x509.CreateCertificate(rand.Reader, &template, &template, publicKey, privateKey)
    85  	assert.NoError(t, err)
    86  
    87  	parsedCert, err := x509.ParseCertificate(certDER)
    88  	assert.NoError(t, err)
    89  
    90  	return &cert.Certificate{
    91  		Certificate: parsedCert,
    92  	}
    93  }
    94  
    95  // Helper function to create certificate without encryption key usage
    96  func createNonEncryptionCertificate(t *testing.T, keyPair interface{}) *cert.Certificate {
    97  	template := x509.Certificate{
    98  		SerialNumber: big.NewInt(1),
    99  		Subject: pkix.Name{
   100  			CommonName: "Non-Encryption Certificate",
   101  		},
   102  		NotBefore:             time.Now().Add(-time.Hour),
   103  		NotAfter:              time.Now().Add(365 * 24 * time.Hour),
   104  		KeyUsage:              x509.KeyUsageDigitalSignature, // No KeyEncipherment or KeyAgreement
   105  		BasicConstraintsValid: true,
   106  	}
   107  
   108  	var publicKey interface{}
   109  	var privateKey interface{}
   110  
   111  	switch kp := keyPair.(type) {
   112  	case *algo.RSAKeyPair:
   113  		publicKey = kp.PublicKey
   114  		privateKey = kp.PrivateKey
   115  	default:
   116  		t.Fatalf("Unsupported key pair type: %T", keyPair)
   117  	}
   118  
   119  	certDER, err := x509.CreateCertificate(rand.Reader, &template, &template, publicKey, privateKey)
   120  	assert.NoError(t, err)
   121  
   122  	parsedCert, err := x509.ParseCertificate(certDER)
   123  	assert.NoError(t, err)
   124  
   125  	return &cert.Certificate{
   126  		Certificate: parsedCert,
   127  	}
   128  }
   129  
   130  func TestEncryptDocument(t *testing.T) {
   131  	testData := []byte("test document for encryption")
   132  	opts := encryption.DefaultEncryptOptions()
   133  
   134  	t.Run("RSA Certificate", func(t *testing.T) {
   135  		rsaKeys, err := algo.GenerateRSAKeyPair(algo.KeySize2048)
   136  		assert.NoError(t, err)
   137  
   138  		testCert := createTestCertificate(t, rsaKeys)
   139  
   140  		encrypted, err := EncryptDocument(testData, testCert, opts)
   141  		assert.NoError(t, err)
   142  		assert.NotNil(t, encrypted)
   143  		assert.NotEmpty(t, encrypted.Data)
   144  	})
   145  
   146  	t.Run("ECDSA Certificate", func(t *testing.T) {
   147  		ecdsaKeys, err := algo.GenerateECDSAKeyPair(algo.P256)
   148  		assert.NoError(t, err)
   149  
   150  		testCert := createTestCertificate(t, ecdsaKeys)
   151  
   152  		// ECDSA should now work for certificate encryption
   153  		encrypted, err := EncryptDocument(testData, testCert, opts)
   154  		assert.NoError(t, err) // ECDSA should work now
   155  		assert.NotNil(t, encrypted)
   156  	})
   157  
   158  	t.Run("Ed25519 Certificate", func(t *testing.T) {
   159  		ed25519Keys, err := algo.GenerateEd25519KeyPair()
   160  		assert.NoError(t, err)
   161  
   162  		testCert := createTestCertificate(t, ed25519Keys)
   163  
   164  		// Ed25519 has partial implementation (may fail with certain key formats)
   165  		encrypted, err := EncryptDocument(testData, testCert, opts)
   166  		if err == nil {
   167  			// Success case
   168  			assert.NotNil(t, encrypted)
   169  			assert.Equal(t, encryption.AlgorithmX25519, encrypted.Algorithm)
   170  		} else {
   171  			// Expected failure case
   172  			assert.Error(t, err)
   173  			assert.Contains(t, err.Error(), "Ed25519 public-key-only encryption failed")
   174  		}
   175  	})
   176  
   177  	t.Run("Nil Certificate", func(t *testing.T) {
   178  		encrypted, err := EncryptDocument(testData, nil, opts)
   179  		assert.Error(t, err)
   180  		assert.Nil(t, encrypted)
   181  		assert.Contains(t, err.Error(), "certificate is required")
   182  	})
   183  
   184  	t.Run("With Certificate Metadata", func(t *testing.T) {
   185  		rsaKeys, err := algo.GenerateRSAKeyPair(algo.KeySize2048)
   186  		assert.NoError(t, err)
   187  
   188  		testCert := createTestCertificate(t, rsaKeys)
   189  
   190  		opts := encryption.DefaultEncryptOptions()
   191  		opts.IncludeCertificate = true
   192  
   193  		encrypted, err := EncryptDocument(testData, testCert, opts)
   194  		assert.NoError(t, err)
   195  		assert.NotNil(t, encrypted)
   196  		assert.NotNil(t, encrypted.Metadata)
   197  		assert.Contains(t, encrypted.Metadata, "certificate_subject")
   198  		assert.Contains(t, encrypted.Metadata, "certificate_serial")
   199  	})
   200  }
   201  
   202  func TestDecryptDocument(t *testing.T) {
   203  	testData := []byte("test document for decryption")
   204  	opts := encryption.DefaultEncryptOptions()
   205  	decryptOpts := encryption.DefaultDecryptOptions()
   206  
   207  	t.Run("RSA Round Trip", func(t *testing.T) {
   208  		rsaKeys, err := algo.GenerateRSAKeyPair(algo.KeySize2048)
   209  		assert.NoError(t, err)
   210  
   211  		testCert := createTestCertificate(t, rsaKeys)
   212  
   213  		encrypted, err := EncryptDocument(testData, testCert, opts)
   214  		assert.NoError(t, err)
   215  
   216  		decrypted, err := DecryptDocument(encrypted, rsaKeys, decryptOpts)
   217  		assert.NoError(t, err)
   218  		assert.Equal(t, testData, decrypted)
   219  	})
   220  
   221  	t.Run("ECDSA Round Trip", func(t *testing.T) {
   222  		ecdsaKeys, err := algo.GenerateECDSAKeyPair(algo.P256)
   223  		assert.NoError(t, err)
   224  
   225  		testCert := createTestCertificate(t, ecdsaKeys)
   226  
   227  		// ECDSA should now work for certificate encryption
   228  		encrypted, err := EncryptDocument(testData, testCert, opts)
   229  		assert.NoError(t, err) // ECDSA should work now
   230  		assert.NotNil(t, encrypted)
   231  	})
   232  
   233  	t.Run("Ed25519 Round Trip", func(t *testing.T) {
   234  		ed25519Keys, err := algo.GenerateEd25519KeyPair()
   235  		assert.NoError(t, err)
   236  
   237  		testCert := createTestCertificate(t, ed25519Keys)
   238  
   239  		// Ed25519 has partial implementation (may fail with certain key formats)
   240  		encrypted, err := EncryptDocument(testData, testCert, opts)
   241  		if err == nil {
   242  			// Success case
   243  			assert.NotNil(t, encrypted)
   244  			assert.Equal(t, encryption.AlgorithmX25519, encrypted.Algorithm)
   245  		} else {
   246  			// Expected failure case
   247  			assert.Error(t, err)
   248  			assert.Contains(t, err.Error(), "Ed25519 public-key-only encryption failed")
   249  		}
   250  	})
   251  
   252  	t.Run("Nil Encrypted Data", func(t *testing.T) {
   253  		rsaKeys, err := algo.GenerateRSAKeyPair(algo.KeySize2048)
   254  		assert.NoError(t, err)
   255  
   256  		decrypted, err := DecryptDocument[*algo.RSAKeyPair](nil, rsaKeys, decryptOpts)
   257  		assert.Error(t, err)
   258  		assert.Nil(t, decrypted)
   259  		assert.Contains(t, err.Error(), "encrypted data is required")
   260  	})
   261  
   262  	t.Run("Invalid Decrypt Options", func(t *testing.T) {
   263  		rsaKeys, err := algo.GenerateRSAKeyPair(algo.KeySize2048)
   264  		assert.NoError(t, err)
   265  
   266  		testCert := createTestCertificate(t, rsaKeys)
   267  		encrypted, err := EncryptDocument(testData, testCert, opts)
   268  		assert.NoError(t, err)
   269  
   270  		invalidDecryptOpts := encryption.DecryptOptions{
   271  			MaxAge: -time.Hour, // Invalid negative max age
   272  		}
   273  
   274  		decrypted, err := DecryptDocument(encrypted, rsaKeys, invalidDecryptOpts)
   275  		assert.Error(t, err)
   276  		assert.Nil(t, decrypted)
   277  		assert.Contains(t, err.Error(), "invalid encryption parameters")
   278  	})
   279  }
   280  
   281  func TestEncryptForMultipleCertificates(t *testing.T) {
   282  	testData := []byte("test document for multiple recipients")
   283  	opts := encryption.DefaultEncryptOptions()
   284  
   285  	t.Run("Multiple RSA Certificates", func(t *testing.T) {
   286  		// Generate multiple key pairs
   287  		rsaKeys1, err := algo.GenerateRSAKeyPair(algo.KeySize2048)
   288  		assert.NoError(t, err)
   289  		rsaKeys2, err := algo.GenerateRSAKeyPair(algo.KeySize2048)
   290  		assert.NoError(t, err)
   291  		rsaKeys3, err := algo.GenerateRSAKeyPair(algo.KeySize2048)
   292  		assert.NoError(t, err)
   293  
   294  		// Create certificates
   295  		cert1 := createTestCertificate(t, rsaKeys1)
   296  		cert2 := createTestCertificate(t, rsaKeys2)
   297  		cert3 := createTestCertificate(t, rsaKeys3)
   298  
   299  		certificates := []*cert.Certificate{cert1, cert2, cert3}
   300  
   301  		encrypted, err := EncryptForMultipleCertificates(testData, certificates, opts)
   302  		assert.NoError(t, err)
   303  		assert.NotNil(t, encrypted)
   304  		assert.NotEmpty(t, encrypted.Data)
   305  		assert.Len(t, encrypted.Recipients, 3)
   306  	})
   307  
   308  	t.Run("Mixed Key Types", func(t *testing.T) {
   309  		rsaKeys1, err := algo.GenerateRSAKeyPair(algo.KeySize2048)
   310  		assert.NoError(t, err)
   311  		rsaKeys2, err := algo.GenerateRSAKeyPair(algo.KeySize2048)
   312  		assert.NoError(t, err)
   313  
   314  		cert1 := createTestCertificate(t, rsaKeys1)
   315  		cert2 := createTestCertificate(t, rsaKeys2)
   316  
   317  		// Only use RSA certificates since ECDSA and Ed25519 are not yet supported
   318  		certificates := []*cert.Certificate{cert1, cert2}
   319  
   320  		encrypted, err := EncryptForMultipleCertificates(testData, certificates, opts)
   321  		assert.NoError(t, err)
   322  		assert.NotNil(t, encrypted)
   323  		assert.Len(t, encrypted.Recipients, 2)
   324  	})
   325  
   326  	t.Run("Empty Certificate List", func(t *testing.T) {
   327  		encrypted, err := EncryptForMultipleCertificates(testData, []*cert.Certificate{}, opts)
   328  		assert.Error(t, err)
   329  		assert.Nil(t, encrypted)
   330  		assert.Contains(t, err.Error(), "at least one certificate is required")
   331  	})
   332  
   333  	t.Run("Nil Certificate in List", func(t *testing.T) {
   334  		rsaKeys, err := algo.GenerateRSAKeyPair(algo.KeySize2048)
   335  		assert.NoError(t, err)
   336  
   337  		cert1 := createTestCertificate(t, rsaKeys)
   338  		certificates := []*cert.Certificate{cert1, nil}
   339  
   340  		encrypted, err := EncryptForMultipleCertificates(testData, certificates, opts)
   341  		assert.Error(t, err)
   342  		assert.Nil(t, encrypted)
   343  		assert.Contains(t, err.Error(), "certificate at index 1 is nil")
   344  	})
   345  
   346  	t.Run("With Recipient Metadata", func(t *testing.T) {
   347  		rsaKeys1, err := algo.GenerateRSAKeyPair(algo.KeySize2048)
   348  		assert.NoError(t, err)
   349  		rsaKeys2, err := algo.GenerateRSAKeyPair(algo.KeySize2048)
   350  		assert.NoError(t, err)
   351  
   352  		cert1 := createTestCertificate(t, rsaKeys1)
   353  		cert2 := createTestCertificate(t, rsaKeys2)
   354  
   355  		certificates := []*cert.Certificate{cert1, cert2}
   356  
   357  		opts := encryption.DefaultEncryptOptions()
   358  		opts.IncludeCertificate = true
   359  
   360  		encrypted, err := EncryptForMultipleCertificates(testData, certificates, opts)
   361  		assert.NoError(t, err)
   362  		assert.NotNil(t, encrypted.Metadata)
   363  		assert.Contains(t, encrypted.Metadata, "recipient_subjects")
   364  	})
   365  }
   366  
   367  func TestDecryptForCertificateHolder(t *testing.T) {
   368  	testData := []byte("test document for multiple recipients")
   369  	opts := encryption.DefaultEncryptOptions()
   370  	decryptOpts := encryption.DefaultDecryptOptions()
   371  
   372  	t.Run("Decrypt by Different Recipients", func(t *testing.T) {
   373  		// Generate multiple key pairs
   374  		rsaKeys1, err := algo.GenerateRSAKeyPair(algo.KeySize2048)
   375  		assert.NoError(t, err)
   376  		rsaKeys2, err := algo.GenerateRSAKeyPair(algo.KeySize2048)
   377  		assert.NoError(t, err)
   378  		rsaKeys3, err := algo.GenerateRSAKeyPair(algo.KeySize2048)
   379  		assert.NoError(t, err)
   380  
   381  		// Create certificates
   382  		cert1 := createTestCertificate(t, rsaKeys1)
   383  		cert2 := createTestCertificate(t, rsaKeys2)
   384  		cert3 := createTestCertificate(t, rsaKeys3)
   385  
   386  		certificates := []*cert.Certificate{cert1, cert2, cert3}
   387  
   388  		encrypted, err := EncryptForMultipleCertificates(testData, certificates, opts)
   389  		assert.NoError(t, err)
   390  
   391  		// Each recipient should be able to decrypt
   392  		decrypted1, err := DecryptForCertificateHolder(encrypted, rsaKeys1, 0, decryptOpts)
   393  		assert.NoError(t, err)
   394  		assert.Equal(t, testData, decrypted1)
   395  
   396  		decrypted2, err := DecryptForCertificateHolder(encrypted, rsaKeys2, 1, decryptOpts)
   397  		assert.NoError(t, err)
   398  		assert.Equal(t, testData, decrypted2)
   399  
   400  		decrypted3, err := DecryptForCertificateHolder(encrypted, rsaKeys3, 2, decryptOpts)
   401  		assert.NoError(t, err)
   402  		assert.Equal(t, testData, decrypted3)
   403  	})
   404  
   405  	t.Run("Invalid Recipient Index", func(t *testing.T) {
   406  		rsaKeys, err := algo.GenerateRSAKeyPair(algo.KeySize2048)
   407  		assert.NoError(t, err)
   408  
   409  		cert := createTestCertificate(t, rsaKeys)
   410  		encrypted, err := EncryptDocument(testData, cert, opts)
   411  		assert.NoError(t, err)
   412  
   413  		// Try to decrypt with invalid index
   414  		decrypted, err := DecryptForCertificateHolder(encrypted, rsaKeys, 5, decryptOpts)
   415  		assert.Error(t, err)
   416  		assert.Nil(t, decrypted)
   417  	})
   418  
   419  	t.Run("Nil Encrypted Data", func(t *testing.T) {
   420  		rsaKeys, err := algo.GenerateRSAKeyPair(algo.KeySize2048)
   421  		assert.NoError(t, err)
   422  
   423  		decrypted, err := DecryptForCertificateHolder[*algo.RSAKeyPair](nil, rsaKeys, 0, decryptOpts)
   424  		assert.Error(t, err)
   425  		assert.Nil(t, decrypted)
   426  		assert.Contains(t, err.Error(), "encrypted data is required")
   427  	})
   428  }
   429  
   430  func TestEncryptWithKeyUsageValidation(t *testing.T) {
   431  	testData := []byte("test document with validation")
   432  	opts := encryption.DefaultEncryptOptions()
   433  
   434  	t.Run("Valid Certificate", func(t *testing.T) {
   435  		rsaKeys, err := algo.GenerateRSAKeyPair(algo.KeySize2048)
   436  		assert.NoError(t, err)
   437  
   438  		testCert := createTestCertificate(t, rsaKeys)
   439  
   440  		encrypted, err := EncryptWithKeyUsageValidation(testData, testCert, opts)
   441  		assert.NoError(t, err)
   442  		assert.NotNil(t, encrypted)
   443  	})
   444  
   445  	t.Run("Expired Certificate", func(t *testing.T) {
   446  		rsaKeys, err := algo.GenerateRSAKeyPair(algo.KeySize2048)
   447  		assert.NoError(t, err)
   448  
   449  		expiredCert := createExpiredCertificate(t, rsaKeys)
   450  
   451  		encrypted, err := EncryptWithKeyUsageValidation(testData, expiredCert, opts)
   452  		assert.Error(t, err)
   453  		assert.Nil(t, encrypted)
   454  		assert.Contains(t, err.Error(), "certificate has expired")
   455  	})
   456  
   457  	t.Run("Certificate Without Encryption Key Usage", func(t *testing.T) {
   458  		rsaKeys, err := algo.GenerateRSAKeyPair(algo.KeySize2048)
   459  		assert.NoError(t, err)
   460  
   461  		nonEncryptCert := createNonEncryptionCertificate(t, rsaKeys)
   462  
   463  		encrypted, err := EncryptWithKeyUsageValidation(testData, nonEncryptCert, opts)
   464  		assert.Error(t, err)
   465  		assert.Nil(t, encrypted)
   466  		assert.Contains(t, err.Error(), "key usage does not allow encryption")
   467  	})
   468  
   469  	t.Run("Nil Certificate", func(t *testing.T) {
   470  		encrypted, err := EncryptWithKeyUsageValidation(testData, nil, opts)
   471  		assert.Error(t, err)
   472  		assert.Nil(t, encrypted)
   473  		assert.Contains(t, err.Error(), "certificate is required")
   474  	})
   475  
   476  	t.Run("Not Yet Valid Certificate", func(t *testing.T) {
   477  		rsaKeys, err := algo.GenerateRSAKeyPair(algo.KeySize2048)
   478  		assert.NoError(t, err)
   479  
   480  		template := x509.Certificate{
   481  			SerialNumber:          big.NewInt(1),
   482  			Subject:               pkix.Name{CommonName: "Future Certificate"},
   483  			NotBefore:             time.Now().Add(24 * time.Hour), // Future
   484  			NotAfter:              time.Now().Add(48 * time.Hour),
   485  			KeyUsage:              x509.KeyUsageKeyEncipherment,
   486  			BasicConstraintsValid: true,
   487  		}
   488  
   489  		certDER, err := x509.CreateCertificate(rand.Reader, &template, &template,
   490  			rsaKeys.PublicKey, rsaKeys.PrivateKey)
   491  		assert.NoError(t, err)
   492  
   493  		parsedCert, err := x509.ParseCertificate(certDER)
   494  		assert.NoError(t, err)
   495  
   496  		futureCert := &cert.Certificate{
   497  			Certificate: parsedCert,
   498  		}
   499  
   500  		encrypted, err := EncryptWithKeyUsageValidation(testData, futureCert, opts)
   501  		assert.Error(t, err)
   502  		assert.Nil(t, encrypted)
   503  		assert.Contains(t, err.Error(), "certificate is not yet valid")
   504  	})
   505  }
   506  
   507  func TestDecryptWithCertificateValidation(t *testing.T) {
   508  	testData := []byte("test document with validation")
   509  	opts := encryption.DefaultEncryptOptions()
   510  	decryptOpts := encryption.DefaultDecryptOptions()
   511  
   512  	t.Run("Valid Certificate and KeyPair", func(t *testing.T) {
   513  		rsaKeys, err := algo.GenerateRSAKeyPair(algo.KeySize2048)
   514  		assert.NoError(t, err)
   515  
   516  		testCert := createTestCertificate(t, rsaKeys)
   517  
   518  		encrypted, err := EncryptDocument(testData, testCert, opts)
   519  		assert.NoError(t, err)
   520  
   521  		decrypted, err := DecryptWithCertificateValidation(encrypted, rsaKeys, testCert, decryptOpts)
   522  		assert.NoError(t, err)
   523  		assert.Equal(t, testData, decrypted)
   524  	})
   525  
   526  	t.Run("Nil Certificate", func(t *testing.T) {
   527  		rsaKeys, err := algo.GenerateRSAKeyPair(algo.KeySize2048)
   528  		assert.NoError(t, err)
   529  
   530  		testCert := createTestCertificate(t, rsaKeys)
   531  		encrypted, err := EncryptDocument(testData, testCert, opts)
   532  		assert.NoError(t, err)
   533  
   534  		decrypted, err := DecryptWithCertificateValidation(encrypted, rsaKeys, nil, decryptOpts)
   535  		assert.Error(t, err)
   536  		assert.Nil(t, decrypted)
   537  		assert.Contains(t, err.Error(), "certificate is required")
   538  	})
   539  }
   540  
   541  func TestValidateCertificateForEncryption(t *testing.T) {
   542  	t.Run("Valid Certificate", func(t *testing.T) {
   543  		rsaKeys, err := algo.GenerateRSAKeyPair(algo.KeySize2048)
   544  		assert.NoError(t, err)
   545  
   546  		testCert := createTestCertificate(t, rsaKeys)
   547  		err = validateCertificateForEncryption(testCert)
   548  		assert.NoError(t, err)
   549  	})
   550  
   551  	t.Run("Certificate Without Key Usage", func(t *testing.T) {
   552  		rsaKeys, err := algo.GenerateRSAKeyPair(algo.KeySize2048)
   553  		assert.NoError(t, err)
   554  
   555  		template := x509.Certificate{
   556  			SerialNumber:          big.NewInt(1),
   557  			Subject:               pkix.Name{CommonName: "No Key Usage"},
   558  			NotBefore:             time.Now().Add(-time.Hour),
   559  			NotAfter:              time.Now().Add(365 * 24 * time.Hour),
   560  			BasicConstraintsValid: true,
   561  			// KeyUsage not set (zero value)
   562  		}
   563  
   564  		certDER, err := x509.CreateCertificate(rand.Reader, &template, &template,
   565  			rsaKeys.PublicKey, rsaKeys.PrivateKey)
   566  		assert.NoError(t, err)
   567  
   568  		parsedCert, err := x509.ParseCertificate(certDER)
   569  		assert.NoError(t, err)
   570  
   571  		cert := &cert.Certificate{
   572  			Certificate: parsedCert,
   573  		}
   574  
   575  		// Should pass because KeyUsage is 0 (not set)
   576  		err = validateCertificateForEncryption(cert)
   577  		assert.NoError(t, err)
   578  	})
   579  
   580  	t.Run("Certificate With Wrong Key Usage", func(t *testing.T) {
   581  		rsaKeys, err := algo.GenerateRSAKeyPair(algo.KeySize2048)
   582  		assert.NoError(t, err)
   583  
   584  		nonEncryptCert := createNonEncryptionCertificate(t, rsaKeys)
   585  		err = validateCertificateForEncryption(nonEncryptCert)
   586  		assert.Error(t, err)
   587  		assert.Contains(t, err.Error(), "key usage does not allow encryption")
   588  	})
   589  
   590  	t.Run("Nil Certificate", func(t *testing.T) {
   591  		err := validateCertificateForEncryption(nil)
   592  		assert.Error(t, err)
   593  		assert.Contains(t, err.Error(), "invalid certificate")
   594  	})
   595  
   596  	t.Run("Certificate With Nil X509", func(t *testing.T) {
   597  		cert := &cert.Certificate{
   598  			Certificate: nil,
   599  		}
   600  		err := validateCertificateForEncryption(cert)
   601  		assert.Error(t, err)
   602  		assert.Contains(t, err.Error(), "invalid certificate")
   603  	})
   604  }
   605  
   606  func TestValidateCertificateForDecryption(t *testing.T) {
   607  	t.Run("Valid Certificate", func(t *testing.T) {
   608  		rsaKeys, err := algo.GenerateRSAKeyPair(algo.KeySize2048)
   609  		assert.NoError(t, err)
   610  
   611  		testCert := createTestCertificate(t, rsaKeys)
   612  		err = validateCertificateForDecryption(testCert)
   613  		assert.NoError(t, err)
   614  	})
   615  
   616  	t.Run("Nil Certificate", func(t *testing.T) {
   617  		err := validateCertificateForDecryption(nil)
   618  		assert.Error(t, err)
   619  		assert.Contains(t, err.Error(), "invalid certificate")
   620  	})
   621  }