github.com/jasoet/gopki@v1.15.0/pkcs12/helpers_test.go (about)

     1  package pkcs12
     2  
     3  import (
     4  	"crypto/ecdsa"
     5  	"crypto/ed25519"
     6  	"crypto/rand"
     7  	"crypto/rsa"
     8  	"crypto/x509"
     9  	"crypto/x509/pkix"
    10  	"math/big"
    11  	"testing"
    12  	"time"
    13  
    14  	"github.com/jasoet/gopki/keypair"
    15  	"github.com/jasoet/gopki/keypair/algo"
    16  )
    17  
    18  // TestValidateKeyPairMatch tests the validateKeyPairMatch function with various key types and scenarios
    19  func TestValidateKeyPairMatch(t *testing.T) {
    20  	// Generate RSA key pair
    21  	rsaManager, err := keypair.Generate[algo.KeySize, *algo.RSAKeyPair, *rsa.PrivateKey, *rsa.PublicKey](algo.KeySize2048)
    22  	if err != nil {
    23  		t.Fatalf("Failed to generate RSA key pair: %v", err)
    24  	}
    25  	rsaKeyPair := rsaManager.KeyPair()
    26  
    27  	// Generate ECDSA key pair
    28  	ecdsaManager, err := keypair.Generate[algo.ECDSACurve, *algo.ECDSAKeyPair, *ecdsa.PrivateKey, *ecdsa.PublicKey](algo.P256)
    29  	if err != nil {
    30  		t.Fatalf("Failed to generate ECDSA key pair: %v", err)
    31  	}
    32  	ecdsaKeyPair := ecdsaManager.KeyPair()
    33  
    34  	// Generate Ed25519 key pair
    35  	ed25519Manager, err := keypair.Generate[algo.Ed25519Config, *algo.Ed25519KeyPair, ed25519.PrivateKey, ed25519.PublicKey]("")
    36  	if err != nil {
    37  		t.Fatalf("Failed to generate Ed25519 key pair: %v", err)
    38  	}
    39  	ed25519KeyPair := ed25519Manager.KeyPair()
    40  
    41  	// Generate a different RSA key pair for mismatch testing
    42  	differentRSAManager, err := keypair.Generate[algo.KeySize, *algo.RSAKeyPair, *rsa.PrivateKey, *rsa.PublicKey](algo.KeySize2048)
    43  	if err != nil {
    44  		t.Fatalf("Failed to generate different RSA key pair: %v", err)
    45  	}
    46  	differentRSAKeyPair := differentRSAManager.KeyPair()
    47  
    48  	t.Run("ValidRSAKeyPairMatch", func(t *testing.T) {
    49  		err := validateKeyPairMatch(rsaKeyPair.PrivateKey, rsaKeyPair.PublicKey)
    50  		if err != nil {
    51  			t.Errorf("Expected RSA key pair to match, got error: %v", err)
    52  		}
    53  	})
    54  
    55  	t.Run("ValidECDSAKeyPairMatch", func(t *testing.T) {
    56  		err := validateKeyPairMatch(ecdsaKeyPair.PrivateKey, ecdsaKeyPair.PublicKey)
    57  		if err != nil {
    58  			t.Errorf("Expected ECDSA key pair to match, got error: %v", err)
    59  		}
    60  	})
    61  
    62  	t.Run("ValidEd25519KeyPairMatch", func(t *testing.T) {
    63  		err := validateKeyPairMatch(ed25519KeyPair.PrivateKey, ed25519KeyPair.PublicKey)
    64  		if err != nil {
    65  			t.Errorf("Expected Ed25519 key pair to match, got error: %v", err)
    66  		}
    67  	})
    68  
    69  	t.Run("RSAKeyPairMismatch", func(t *testing.T) {
    70  		err := validateKeyPairMatch(rsaKeyPair.PrivateKey, differentRSAKeyPair.PublicKey)
    71  		if err == nil {
    72  			t.Error("Expected RSA key pair mismatch to produce an error")
    73  		}
    74  	})
    75  
    76  	t.Run("RSAPrivateKeyWithECDSAPublicKey", func(t *testing.T) {
    77  		err := validateKeyPairMatch(rsaKeyPair.PrivateKey, ecdsaKeyPair.PublicKey)
    78  		if err == nil {
    79  			t.Error("Expected RSA private key with ECDSA public key to produce an error")
    80  		}
    81  		if err != nil && err.Error() != "private key is RSA but public key is not" {
    82  			t.Errorf("Expected specific error message, got: %v", err)
    83  		}
    84  	})
    85  
    86  	t.Run("ECDSAPrivateKeyWithRSAPublicKey", func(t *testing.T) {
    87  		err := validateKeyPairMatch(ecdsaKeyPair.PrivateKey, rsaKeyPair.PublicKey)
    88  		if err == nil {
    89  			t.Error("Expected ECDSA private key with RSA public key to produce an error")
    90  		}
    91  		if err != nil && err.Error() != "private key is ECDSA but public key is not" {
    92  			t.Errorf("Expected specific error message, got: %v", err)
    93  		}
    94  	})
    95  
    96  	t.Run("Ed25519PrivateKeyWithRSAPublicKey", func(t *testing.T) {
    97  		err := validateKeyPairMatch(ed25519KeyPair.PrivateKey, rsaKeyPair.PublicKey)
    98  		if err == nil {
    99  			t.Error("Expected Ed25519 private key with RSA public key to produce an error")
   100  		}
   101  		if err != nil && err.Error() != "private key is Ed25519 but public key is not" {
   102  			t.Errorf("Expected specific error message, got: %v", err)
   103  		}
   104  	})
   105  
   106  	t.Run("UnsupportedPrivateKeyType", func(t *testing.T) {
   107  		// Create an unsupported private key type (using a string as a mock)
   108  		unsupportedKey := "not a real key"
   109  		err := validateKeyPairMatch(unsupportedKey, rsaKeyPair.PublicKey)
   110  		if err == nil {
   111  			t.Error("Expected unsupported private key type to produce an error")
   112  		}
   113  		if err != nil && !contains(err.Error(), "unsupported private key type") {
   114  			t.Errorf("Expected unsupported key type error, got: %v", err)
   115  		}
   116  	})
   117  
   118  	t.Run("ECDSAKeyPairMismatch", func(t *testing.T) {
   119  		// Generate another ECDSA key pair for mismatch testing
   120  		differentECDSAManager, err := keypair.Generate[algo.ECDSACurve, *algo.ECDSAKeyPair, *ecdsa.PrivateKey, *ecdsa.PublicKey](algo.P256)
   121  		if err != nil {
   122  			t.Fatalf("Failed to generate different ECDSA key pair: %v", err)
   123  		}
   124  		differentECDSAKeyPair := differentECDSAManager.KeyPair()
   125  
   126  		err = validateKeyPairMatch(ecdsaKeyPair.PrivateKey, differentECDSAKeyPair.PublicKey)
   127  		if err == nil {
   128  			t.Error("Expected ECDSA key pair mismatch to produce an error")
   129  		}
   130  		if err != nil && err.Error() != "ECDSA private key does not match public key" {
   131  			t.Errorf("Expected specific ECDSA mismatch error, got: %v", err)
   132  		}
   133  	})
   134  
   135  	t.Run("Ed25519KeyPairMismatch", func(t *testing.T) {
   136  		// Generate another Ed25519 key pair for mismatch testing
   137  		differentEd25519Manager, err := keypair.Generate[algo.Ed25519Config, *algo.Ed25519KeyPair, ed25519.PrivateKey, ed25519.PublicKey]("")
   138  		if err != nil {
   139  			t.Fatalf("Failed to generate different Ed25519 key pair: %v", err)
   140  		}
   141  		differentEd25519KeyPair := differentEd25519Manager.KeyPair()
   142  
   143  		err = validateKeyPairMatch(ed25519KeyPair.PrivateKey, differentEd25519KeyPair.PublicKey)
   144  		if err == nil {
   145  			t.Error("Expected Ed25519 key pair mismatch to produce an error")
   146  		}
   147  		if err != nil && err.Error() != "Ed25519 private key does not match public key" {
   148  			t.Errorf("Expected specific Ed25519 mismatch error, got: %v", err)
   149  		}
   150  	})
   151  }
   152  
   153  // TestGetExtKeyUsageStrings tests the getExtKeyUsageStrings function comprehensively
   154  func TestGetExtKeyUsageStrings(t *testing.T) {
   155  	testCases := []struct {
   156  		name     string
   157  		usages   []x509.ExtKeyUsage
   158  		expected []string
   159  	}{
   160  		{
   161  			name:     "EmptyUsages",
   162  			usages:   []x509.ExtKeyUsage{},
   163  			expected: []string{},
   164  		},
   165  		{
   166  			name:     "ServerAuth",
   167  			usages:   []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
   168  			expected: []string{"Server Authentication"},
   169  		},
   170  		{
   171  			name:     "ClientAuth",
   172  			usages:   []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth},
   173  			expected: []string{"Client Authentication"},
   174  		},
   175  		{
   176  			name:     "CodeSigning",
   177  			usages:   []x509.ExtKeyUsage{x509.ExtKeyUsageCodeSigning},
   178  			expected: []string{"Code Signing"},
   179  		},
   180  		{
   181  			name:     "EmailProtection",
   182  			usages:   []x509.ExtKeyUsage{x509.ExtKeyUsageEmailProtection},
   183  			expected: []string{"Email Protection"},
   184  		},
   185  		{
   186  			name:     "TimeStamping",
   187  			usages:   []x509.ExtKeyUsage{x509.ExtKeyUsageTimeStamping},
   188  			expected: []string{"Time Stamping"},
   189  		},
   190  		{
   191  			name:     "OCSPSigning",
   192  			usages:   []x509.ExtKeyUsage{x509.ExtKeyUsageOCSPSigning},
   193  			expected: []string{"OCSP Signing"},
   194  		},
   195  		{
   196  			name: "MultipleUsages",
   197  			usages: []x509.ExtKeyUsage{
   198  				x509.ExtKeyUsageServerAuth,
   199  				x509.ExtKeyUsageClientAuth,
   200  				x509.ExtKeyUsageCodeSigning,
   201  			},
   202  			expected: []string{
   203  				"Server Authentication",
   204  				"Client Authentication",
   205  				"Code Signing",
   206  			},
   207  		},
   208  		{
   209  			name: "AllStandardUsages",
   210  			usages: []x509.ExtKeyUsage{
   211  				x509.ExtKeyUsageServerAuth,
   212  				x509.ExtKeyUsageClientAuth,
   213  				x509.ExtKeyUsageCodeSigning,
   214  				x509.ExtKeyUsageEmailProtection,
   215  				x509.ExtKeyUsageTimeStamping,
   216  				x509.ExtKeyUsageOCSPSigning,
   217  			},
   218  			expected: []string{
   219  				"Server Authentication",
   220  				"Client Authentication",
   221  				"Code Signing",
   222  				"Email Protection",
   223  				"Time Stamping",
   224  				"OCSP Signing",
   225  			},
   226  		},
   227  		{
   228  			name:     "UnknownUsage",
   229  			usages:   []x509.ExtKeyUsage{x509.ExtKeyUsage(999)}, // Unknown usage value
   230  			expected: []string{"Unknown (999)"},
   231  		},
   232  		{
   233  			name: "MixedKnownAndUnknownUsages",
   234  			usages: []x509.ExtKeyUsage{
   235  				x509.ExtKeyUsageServerAuth,
   236  				x509.ExtKeyUsage(888), // Unknown
   237  				x509.ExtKeyUsageClientAuth,
   238  				x509.ExtKeyUsage(777), // Unknown
   239  			},
   240  			expected: []string{
   241  				"Server Authentication",
   242  				"Unknown (888)",
   243  				"Client Authentication",
   244  				"Unknown (777)",
   245  			},
   246  		},
   247  	}
   248  
   249  	for _, tc := range testCases {
   250  		t.Run(tc.name, func(t *testing.T) {
   251  			result := getExtKeyUsageStrings(tc.usages)
   252  
   253  			if len(result) != len(tc.expected) {
   254  				t.Errorf("Expected %d usage strings, got %d", len(tc.expected), len(result))
   255  				return
   256  			}
   257  
   258  			for i, expected := range tc.expected {
   259  				if i >= len(result) || result[i] != expected {
   260  					t.Errorf("Expected usage string at index %d to be '%s', got '%s'", i, expected, result[i])
   261  				}
   262  			}
   263  		})
   264  	}
   265  }
   266  
   267  // TestGetCertificateInfoExtKeyUsage tests GetCertificateInfo with focus on extended key usage
   268  func TestGetCertificateInfoExtKeyUsage(t *testing.T) {
   269  	// Create a certificate with various extended key usages
   270  	rsaManager, err := keypair.Generate[algo.KeySize, *algo.RSAKeyPair, *rsa.PrivateKey, *rsa.PublicKey](algo.KeySize2048)
   271  	if err != nil {
   272  		t.Fatalf("Failed to generate RSA key pair: %v", err)
   273  	}
   274  	rsaKeyPair := rsaManager.KeyPair()
   275  
   276  	template := &x509.Certificate{
   277  		Subject: pkix.Name{
   278  			CommonName:   "Test Cert with ExtKeyUsage",
   279  			Organization: []string{"Test Org"},
   280  		},
   281  		NotBefore:    time.Now(),
   282  		NotAfter:     time.Now().Add(365 * 24 * time.Hour),
   283  		KeyUsage:     x509.KeyUsageDigitalSignature | x509.KeyUsageKeyEncipherment,
   284  		ExtKeyUsage:  []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth, x509.ExtKeyUsageClientAuth, x509.ExtKeyUsageCodeSigning},
   285  		SerialNumber: big.NewInt(12345),
   286  	}
   287  
   288  	certDER, err := x509.CreateCertificate(rand.Reader, template, template, rsaKeyPair.PublicKey, rsaKeyPair.PrivateKey)
   289  	if err != nil {
   290  		t.Fatalf("Failed to create certificate: %v", err)
   291  	}
   292  
   293  	cert, err := x509.ParseCertificate(certDER)
   294  	if err != nil {
   295  		t.Fatalf("Failed to parse certificate: %v", err)
   296  	}
   297  
   298  	// Test GetCertificateInfo
   299  	info := GetCertificateInfo(cert)
   300  	if info == nil {
   301  		t.Error("Expected certificate info to be non-nil")
   302  		return
   303  	}
   304  
   305  	// Check extended key usage strings
   306  	extKeyUsage, ok := info["ext_key_usage"].([]string)
   307  	if !ok {
   308  		t.Error("Expected ext_key_usage to be []string")
   309  		return
   310  	}
   311  
   312  	expectedExtKeyUsages := []string{
   313  		"Server Authentication",
   314  		"Client Authentication",
   315  		"Code Signing",
   316  	}
   317  
   318  	if len(extKeyUsage) != len(expectedExtKeyUsages) {
   319  		t.Errorf("Expected %d extended key usages, got %d", len(expectedExtKeyUsages), len(extKeyUsage))
   320  	}
   321  
   322  	for i, expected := range expectedExtKeyUsages {
   323  		if i < len(extKeyUsage) && extKeyUsage[i] != expected {
   324  			t.Errorf("Expected extended key usage %d to be '%s', got '%s'", i, expected, extKeyUsage[i])
   325  		}
   326  	}
   327  
   328  	t.Run("NilCertificate", func(t *testing.T) {
   329  		info := GetCertificateInfo(nil)
   330  		if info != nil {
   331  			t.Error("Expected nil certificate to return nil info")
   332  		}
   333  	})
   334  }
   335  
   336  // Helper function to check if a string contains a substring
   337  func contains(s, substr string) bool {
   338  	return len(s) >= len(substr) && (s == substr ||
   339  		(len(s) > len(substr) &&
   340  			(s[:len(substr)] == substr ||
   341  				s[len(s)-len(substr):] == substr ||
   342  				findInString(s, substr))))
   343  }
   344  
   345  func findInString(s, substr string) bool {
   346  	for i := 0; i <= len(s)-len(substr); i++ {
   347  		if s[i:i+len(substr)] == substr {
   348  			return true
   349  		}
   350  	}
   351  	return false
   352  }