github.com/jasoet/gopki@v1.15.0/internal/crypto/ed25519_pkcs7_test.go (about)

     1  package crypto
     2  
     3  import (
     4  	"crypto/ed25519"
     5  	"crypto/rand"
     6  	"crypto/x509"
     7  	"crypto/x509/pkix"
     8  	"math/big"
     9  	"testing"
    10  	"time"
    11  )
    12  
    13  func TestCreateEd25519PKCS7Signature(t *testing.T) {
    14  	// Generate test key pair
    15  	publicKey, privateKey, err := ed25519.GenerateKey(rand.Reader)
    16  	if err != nil {
    17  		t.Fatalf("Failed to generate Ed25519 key pair: %v", err)
    18  	}
    19  
    20  	// Create test certificate
    21  	template := &x509.Certificate{
    22  		SerialNumber: big.NewInt(1),
    23  		Subject: pkix.Name{
    24  			CommonName: "Ed25519 Test Certificate",
    25  		},
    26  		NotBefore:             time.Now(),
    27  		NotAfter:              time.Now().Add(365 * 24 * time.Hour),
    28  		KeyUsage:              x509.KeyUsageDigitalSignature,
    29  		ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageCodeSigning},
    30  		BasicConstraintsValid: true,
    31  	}
    32  
    33  	certDER, err := x509.CreateCertificate(rand.Reader, template, template, publicKey, privateKey)
    34  	if err != nil {
    35  		t.Fatalf("Failed to create certificate: %v", err)
    36  	}
    37  
    38  	cert, err := x509.ParseCertificate(certDER)
    39  	if err != nil {
    40  		t.Fatalf("Failed to parse certificate: %v", err)
    41  	}
    42  
    43  	testData := []byte("Hello, Ed25519 PKCS#7 World!")
    44  
    45  	t.Run("Attached Signature", func(t *testing.T) {
    46  		pkcs7Data, err := CreateEd25519PKCS7Signature(testData, privateKey, cert, false)
    47  		if err != nil {
    48  			t.Fatalf("Failed to create attached PKCS#7 signature: %v", err)
    49  		}
    50  
    51  		if len(pkcs7Data) == 0 {
    52  			t.Fatal("PKCS#7 signature data is empty")
    53  		}
    54  
    55  		t.Logf("Attached PKCS#7 signature created: %d bytes", len(pkcs7Data))
    56  
    57  		// Verify the signature
    58  		info, err := VerifyEd25519PKCS7Signature(testData, pkcs7Data)
    59  		if err != nil {
    60  			t.Fatalf("Failed to verify attached signature: %v", err)
    61  		}
    62  
    63  		if !info.Verified {
    64  			t.Fatal("Signature verification failed")
    65  		}
    66  
    67  		if info.Certificate.SerialNumber.Cmp(cert.SerialNumber) != 0 {
    68  			t.Error("Certificate serial number mismatch")
    69  		}
    70  
    71  		t.Logf("Attached PKCS#7 signature verified successfully")
    72  	})
    73  
    74  	t.Run("Detached Signature", func(t *testing.T) {
    75  		pkcs7Data, err := CreateEd25519PKCS7Signature(testData, privateKey, cert, true)
    76  		if err != nil {
    77  			t.Fatalf("Failed to create detached PKCS#7 signature: %v", err)
    78  		}
    79  
    80  		if len(pkcs7Data) == 0 {
    81  			t.Fatal("PKCS#7 signature data is empty")
    82  		}
    83  
    84  		t.Logf("Detached PKCS#7 signature created: %d bytes", len(pkcs7Data))
    85  
    86  		// Verify the signature
    87  		info, err := VerifyEd25519PKCS7Signature(testData, pkcs7Data)
    88  		if err != nil {
    89  			t.Fatalf("Failed to verify detached signature: %v", err)
    90  		}
    91  
    92  		if !info.Verified {
    93  			t.Fatal("Signature verification failed")
    94  		}
    95  
    96  		t.Logf("Detached PKCS#7 signature verified successfully")
    97  	})
    98  
    99  	t.Run("Large Data", func(t *testing.T) {
   100  		// Test with larger data
   101  		largeData := make([]byte, 10240) // 10KB
   102  		for i := range largeData {
   103  			largeData[i] = byte(i % 256)
   104  		}
   105  
   106  		pkcs7Data, err := CreateEd25519PKCS7Signature(largeData, privateKey, cert, true)
   107  		if err != nil {
   108  			t.Fatalf("Failed to create PKCS#7 signature for large data: %v", err)
   109  		}
   110  
   111  		info, err := VerifyEd25519PKCS7Signature(largeData, pkcs7Data)
   112  		if err != nil {
   113  			t.Fatalf("Failed to verify large data signature: %v", err)
   114  		}
   115  
   116  		if !info.Verified {
   117  			t.Fatal("Large data signature verification failed")
   118  		}
   119  
   120  		t.Logf("Large data PKCS#7 signature verified successfully")
   121  	})
   122  }
   123  
   124  func TestVerifyEd25519PKCS7Signature(t *testing.T) {
   125  	// Generate test key pair
   126  	publicKey, privateKey, err := ed25519.GenerateKey(rand.Reader)
   127  	if err != nil {
   128  		t.Fatalf("Failed to generate Ed25519 key pair: %v", err)
   129  	}
   130  
   131  	// Create test certificate
   132  	template := &x509.Certificate{
   133  		SerialNumber: big.NewInt(2),
   134  		Subject: pkix.Name{
   135  			CommonName: "Ed25519 Verify Test",
   136  		},
   137  		NotBefore:             time.Now(),
   138  		NotAfter:              time.Now().Add(365 * 24 * time.Hour),
   139  		KeyUsage:              x509.KeyUsageDigitalSignature,
   140  		BasicConstraintsValid: true,
   141  	}
   142  
   143  	certDER, err := x509.CreateCertificate(rand.Reader, template, template, publicKey, privateKey)
   144  	if err != nil {
   145  		t.Fatalf("Failed to create certificate: %v", err)
   146  	}
   147  
   148  	cert, err := x509.ParseCertificate(certDER)
   149  	if err != nil {
   150  		t.Fatalf("Failed to parse certificate: %v", err)
   151  	}
   152  
   153  	testData := []byte("Verification test data")
   154  
   155  	t.Run("Valid Signature", func(t *testing.T) {
   156  		// Create signature
   157  		pkcs7Data, err := CreateEd25519PKCS7Signature(testData, privateKey, cert, true)
   158  		if err != nil {
   159  			t.Fatalf("Failed to create signature: %v", err)
   160  		}
   161  
   162  		// Verify signature
   163  		info, err := VerifyEd25519PKCS7Signature(testData, pkcs7Data)
   164  		if err != nil {
   165  			t.Fatalf("Verification failed: %v", err)
   166  		}
   167  
   168  		if !info.Verified {
   169  			t.Fatal("Signature should be valid")
   170  		}
   171  
   172  		if info.Certificate == nil {
   173  			t.Fatal("Certificate should be present")
   174  		}
   175  
   176  		if len(info.Signature) != ed25519.SignatureSize {
   177  			t.Errorf("Expected signature size %d, got %d", ed25519.SignatureSize, len(info.Signature))
   178  		}
   179  
   180  		t.Logf("Valid signature verified successfully")
   181  	})
   182  
   183  	t.Run("Tampered Data", func(t *testing.T) {
   184  		// Create signature
   185  		pkcs7Data, err := CreateEd25519PKCS7Signature(testData, privateKey, cert, true)
   186  		if err != nil {
   187  			t.Fatalf("Failed to create signature: %v", err)
   188  		}
   189  
   190  		// Tamper with the data
   191  		tamperedData := append([]byte(nil), testData...)
   192  		tamperedData[0] ^= 0x01
   193  
   194  		// Verify should fail
   195  		_, err = VerifyEd25519PKCS7Signature(tamperedData, pkcs7Data)
   196  		if err == nil {
   197  			t.Fatal("Should have failed with tampered data")
   198  		}
   199  
   200  		t.Logf("Correctly detected tampered data: %v", err)
   201  	})
   202  }
   203  
   204  func TestIsEd25519PKCS7(t *testing.T) {
   205  	// Generate test key pair
   206  	publicKey, privateKey, err := ed25519.GenerateKey(rand.Reader)
   207  	if err != nil {
   208  		t.Fatalf("Failed to generate Ed25519 key pair: %v", err)
   209  	}
   210  
   211  	// Create test certificate
   212  	template := &x509.Certificate{
   213  		SerialNumber: big.NewInt(3),
   214  		Subject: pkix.Name{
   215  			CommonName: "Ed25519 Detection Test",
   216  		},
   217  		NotBefore:             time.Now(),
   218  		NotAfter:              time.Now().Add(365 * 24 * time.Hour),
   219  		KeyUsage:              x509.KeyUsageDigitalSignature,
   220  		BasicConstraintsValid: true,
   221  	}
   222  
   223  	certDER, err := x509.CreateCertificate(rand.Reader, template, template, publicKey, privateKey)
   224  	if err != nil {
   225  		t.Fatalf("Failed to create certificate: %v", err)
   226  	}
   227  
   228  	cert, err := x509.ParseCertificate(certDER)
   229  	if err != nil {
   230  		t.Fatalf("Failed to parse certificate: %v", err)
   231  	}
   232  
   233  	testData := []byte("Detection test data")
   234  
   235  	t.Run("Ed25519 PKCS#7", func(t *testing.T) {
   236  		pkcs7Data, err := CreateEd25519PKCS7Signature(testData, privateKey, cert, true)
   237  		if err != nil {
   238  			t.Fatalf("Failed to create signature: %v", err)
   239  		}
   240  
   241  		isEd25519, err := IsEd25519PKCS7(pkcs7Data)
   242  		if err != nil {
   243  			t.Fatalf("Detection failed: %v", err)
   244  		}
   245  
   246  		if !isEd25519 {
   247  			t.Fatal("Should detect Ed25519 PKCS#7 format")
   248  		}
   249  
   250  		t.Logf("Ed25519 PKCS#7 detected correctly")
   251  	})
   252  
   253  	t.Run("Non-PKCS#7 Data", func(t *testing.T) {
   254  		nonPKCS7Data := []byte("This is not PKCS#7 data")
   255  
   256  		isEd25519, err := IsEd25519PKCS7(nonPKCS7Data)
   257  		if err == nil {
   258  			t.Fatal("Should fail for non-PKCS#7 data")
   259  		}
   260  
   261  		if isEd25519 {
   262  			t.Fatal("Should not detect Ed25519 in non-PKCS#7 data")
   263  		}
   264  
   265  		t.Logf("Correctly rejected non-PKCS#7 data")
   266  	})
   267  }
   268  
   269  func TestValidateEd25519PKCS7Structure(t *testing.T) {
   270  	// Generate test key pair
   271  	publicKey, privateKey, err := ed25519.GenerateKey(rand.Reader)
   272  	if err != nil {
   273  		t.Fatalf("Failed to generate Ed25519 key pair: %v", err)
   274  	}
   275  
   276  	// Create test certificate
   277  	template := &x509.Certificate{
   278  		SerialNumber: big.NewInt(4),
   279  		Subject: pkix.Name{
   280  			CommonName: "Ed25519 Validation Test",
   281  		},
   282  		NotBefore:             time.Now(),
   283  		NotAfter:              time.Now().Add(365 * 24 * time.Hour),
   284  		KeyUsage:              x509.KeyUsageDigitalSignature,
   285  		BasicConstraintsValid: true,
   286  	}
   287  
   288  	certDER, err := x509.CreateCertificate(rand.Reader, template, template, publicKey, 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  	testData := []byte("Structure validation test")
   299  
   300  	t.Run("Valid Structure", func(t *testing.T) {
   301  		pkcs7Data, err := CreateEd25519PKCS7Signature(testData, privateKey, cert, true)
   302  		if err != nil {
   303  			t.Fatalf("Failed to create signature: %v", err)
   304  		}
   305  
   306  		err = ValidateEd25519PKCS7Structure(pkcs7Data)
   307  		if err != nil {
   308  			t.Fatalf("Structure validation failed: %v", err)
   309  		}
   310  
   311  		t.Logf("Structure validation passed")
   312  	})
   313  
   314  	t.Run("Invalid Data", func(t *testing.T) {
   315  		invalidData := []byte("Invalid PKCS#7 structure")
   316  
   317  		err := ValidateEd25519PKCS7Structure(invalidData)
   318  		if err == nil {
   319  			t.Fatal("Should fail for invalid structure")
   320  		}
   321  
   322  		t.Logf("Correctly rejected invalid structure: %v", err)
   323  	})
   324  }
   325  
   326  func TestEd25519PKCS7ErrorHandling(t *testing.T) {
   327  	t.Run("Invalid Private Key Size", func(t *testing.T) {
   328  		invalidKey := make([]byte, 10) // Wrong size
   329  		cert := &x509.Certificate{SerialNumber: big.NewInt(1)}
   330  		data := []byte("test")
   331  
   332  		_, err := CreateEd25519PKCS7Signature(data, invalidKey, cert, true)
   333  		if err == nil {
   334  			t.Fatal("Should fail for invalid private key size")
   335  		}
   336  
   337  		t.Logf("Correctly rejected invalid key size: %v", err)
   338  	})
   339  
   340  	t.Run("Nil Certificate", func(t *testing.T) {
   341  		_, privateKey, err := ed25519.GenerateKey(rand.Reader)
   342  		if err != nil {
   343  			t.Fatalf("Failed to generate key pair: %v", err)
   344  		}
   345  
   346  		data := []byte("test")
   347  
   348  		_, err = CreateEd25519PKCS7Signature(data, privateKey, nil, true)
   349  		if err == nil {
   350  			t.Fatal("Should fail for nil certificate")
   351  		}
   352  
   353  		t.Logf("Correctly rejected nil certificate: %v", err)
   354  	})
   355  
   356  	t.Run("Invalid PKCS#7 Data", func(t *testing.T) {
   357  		invalidData := []byte("Invalid PKCS#7 data")
   358  		testData := []byte("test")
   359  
   360  		_, err := VerifyEd25519PKCS7Signature(testData, invalidData)
   361  		if err == nil {
   362  			t.Fatal("Should fail for invalid PKCS#7 data")
   363  		}
   364  
   365  		t.Logf("Correctly rejected invalid PKCS#7 data: %v", err)
   366  	})
   367  }
   368  
   369  // Benchmark the Ed25519 PKCS#7 operations
   370  func BenchmarkEd25519PKCS7Creation(b *testing.B) {
   371  	// Setup
   372  	publicKey, privateKey, err := ed25519.GenerateKey(rand.Reader)
   373  	if err != nil {
   374  		b.Fatalf("Failed to generate key pair: %v", err)
   375  	}
   376  
   377  	template := &x509.Certificate{
   378  		SerialNumber: big.NewInt(1),
   379  		Subject: pkix.Name{
   380  			CommonName: "Benchmark Test",
   381  		},
   382  		NotBefore:             time.Now(),
   383  		NotAfter:              time.Now().Add(365 * 24 * time.Hour),
   384  		KeyUsage:              x509.KeyUsageDigitalSignature,
   385  		BasicConstraintsValid: true,
   386  	}
   387  
   388  	certDER, err := x509.CreateCertificate(rand.Reader, template, template, publicKey, privateKey)
   389  	if err != nil {
   390  		b.Fatalf("Failed to create certificate: %v", err)
   391  	}
   392  
   393  	cert, err := x509.ParseCertificate(certDER)
   394  	if err != nil {
   395  		b.Fatalf("Failed to parse certificate: %v", err)
   396  	}
   397  
   398  	testData := []byte("Benchmark test data")
   399  
   400  	b.ResetTimer()
   401  	for i := 0; i < b.N; i++ {
   402  		_, err := CreateEd25519PKCS7Signature(testData, privateKey, cert, true)
   403  		if err != nil {
   404  			b.Fatalf("Signature creation failed: %v", err)
   405  		}
   406  	}
   407  }
   408  
   409  func BenchmarkEd25519PKCS7Verification(b *testing.B) {
   410  	// Setup
   411  	publicKey, privateKey, err := ed25519.GenerateKey(rand.Reader)
   412  	if err != nil {
   413  		b.Fatalf("Failed to generate key pair: %v", err)
   414  	}
   415  
   416  	template := &x509.Certificate{
   417  		SerialNumber: big.NewInt(1),
   418  		Subject: pkix.Name{
   419  			CommonName: "Benchmark Test",
   420  		},
   421  		NotBefore:             time.Now(),
   422  		NotAfter:              time.Now().Add(365 * 24 * time.Hour),
   423  		KeyUsage:              x509.KeyUsageDigitalSignature,
   424  		BasicConstraintsValid: true,
   425  	}
   426  
   427  	certDER, err := x509.CreateCertificate(rand.Reader, template, template, publicKey, privateKey)
   428  	if err != nil {
   429  		b.Fatalf("Failed to create certificate: %v", err)
   430  	}
   431  
   432  	cert, err := x509.ParseCertificate(certDER)
   433  	if err != nil {
   434  		b.Fatalf("Failed to parse certificate: %v", err)
   435  	}
   436  
   437  	testData := []byte("Benchmark test data")
   438  	pkcs7Data, err := CreateEd25519PKCS7Signature(testData, privateKey, cert, true)
   439  	if err != nil {
   440  		b.Fatalf("Failed to create signature: %v", err)
   441  	}
   442  
   443  	b.ResetTimer()
   444  	for i := 0; i < b.N; i++ {
   445  		_, err := VerifyEd25519PKCS7Signature(testData, pkcs7Data)
   446  		if err != nil {
   447  			b.Fatalf("Signature verification failed: %v", err)
   448  		}
   449  	}
   450  }