github.com/jasoet/gopki@v1.15.0/internal/crypto/ed25519_simple_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 TestSimpleEd25519PKCS7(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 Simple 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, Simple Ed25519 PKCS#7 World!")
    44  
    45  	t.Run("Simple Format Creation and Verification", func(t *testing.T) {
    46  		// Create simple PKCS#7 signature
    47  		pkcs7Data, err := SimpleEd25519PKCS7(testData, privateKey, cert)
    48  		if err != nil {
    49  			t.Fatalf("Failed to create simple PKCS#7 signature: %v", err)
    50  		}
    51  
    52  		if len(pkcs7Data) == 0 {
    53  			t.Fatal("PKCS#7 signature data is empty")
    54  		}
    55  
    56  		t.Logf("Simple PKCS#7 signature created: %d bytes", len(pkcs7Data))
    57  
    58  		// Verify the signature
    59  		info, err := VerifySimpleEd25519PKCS7(testData, pkcs7Data)
    60  		if err != nil {
    61  			t.Fatalf("Failed to verify simple signature: %v", err)
    62  		}
    63  
    64  		if !info.Verified {
    65  			t.Fatal("Signature verification failed")
    66  		}
    67  
    68  		if info.Certificate.SerialNumber.Cmp(cert.SerialNumber) != 0 {
    69  			t.Error("Certificate serial number mismatch")
    70  		}
    71  
    72  		t.Logf("Simple PKCS#7 signature verified successfully")
    73  	})
    74  
    75  	t.Run("Format Detection", func(t *testing.T) {
    76  		// Create simple PKCS#7 signature
    77  		pkcs7Data, err := SimpleEd25519PKCS7(testData, privateKey, cert)
    78  		if err != nil {
    79  			t.Fatalf("Failed to create simple PKCS#7 signature: %v", err)
    80  		}
    81  
    82  		// Test format detection
    83  		if !IsSimpleEd25519PKCS7(pkcs7Data) {
    84  			t.Fatal("Failed to detect simple Ed25519 PKCS#7 format")
    85  		}
    86  
    87  		// Test with non-simple data
    88  		nonSimpleData := []byte("not a simple Ed25519 PKCS#7 signature")
    89  		if IsSimpleEd25519PKCS7(nonSimpleData) {
    90  			t.Fatal("Incorrectly detected simple format in non-simple data")
    91  		}
    92  
    93  		t.Logf("Format detection working correctly")
    94  	})
    95  
    96  	t.Run("Tampered Data Detection", func(t *testing.T) {
    97  		// Create simple PKCS#7 signature
    98  		pkcs7Data, err := SimpleEd25519PKCS7(testData, privateKey, cert)
    99  		if err != nil {
   100  			t.Fatalf("Failed to create simple PKCS#7 signature: %v", err)
   101  		}
   102  
   103  		// Tamper with the data
   104  		tamperedData := append([]byte(nil), testData...)
   105  		tamperedData[0] ^= 0x01
   106  
   107  		// Try to verify with tampered data
   108  		_, err = VerifySimpleEd25519PKCS7(tamperedData, pkcs7Data)
   109  		if err == nil {
   110  			t.Fatal("Should have failed with tampered data")
   111  		}
   112  
   113  		t.Logf("Correctly detected tampered data: %v", err)
   114  	})
   115  
   116  	t.Run("Large Data", func(t *testing.T) {
   117  		// Test with larger data
   118  		largeData := make([]byte, 10240) // 10KB
   119  		for i := range largeData {
   120  			largeData[i] = byte(i % 256)
   121  		}
   122  
   123  		pkcs7Data, err := SimpleEd25519PKCS7(largeData, privateKey, cert)
   124  		if err != nil {
   125  			t.Fatalf("Failed to create PKCS#7 signature for large data: %v", err)
   126  		}
   127  
   128  		info, err := VerifySimpleEd25519PKCS7(largeData, pkcs7Data)
   129  		if err != nil {
   130  			t.Fatalf("Failed to verify large data signature: %v", err)
   131  		}
   132  
   133  		if !info.Verified {
   134  			t.Fatal("Large data signature verification failed")
   135  		}
   136  
   137  		t.Logf("Large data PKCS#7 signature verified successfully")
   138  	})
   139  }
   140  
   141  func TestSimpleEd25519PKCS7ErrorHandling(t *testing.T) {
   142  	t.Run("Invalid Private Key Size", func(t *testing.T) {
   143  		invalidKey := make([]byte, 10) // Wrong size
   144  		cert := &x509.Certificate{SerialNumber: big.NewInt(1)}
   145  		data := []byte("test")
   146  
   147  		_, err := SimpleEd25519PKCS7(data, invalidKey, cert)
   148  		if err == nil {
   149  			t.Fatal("Should fail for invalid private key size")
   150  		}
   151  
   152  		t.Logf("Correctly rejected invalid key size: %v", err)
   153  	})
   154  
   155  	t.Run("Nil Certificate", func(t *testing.T) {
   156  		_, privateKey, err := ed25519.GenerateKey(rand.Reader)
   157  		if err != nil {
   158  			t.Fatalf("Failed to generate key pair: %v", err)
   159  		}
   160  
   161  		data := []byte("test")
   162  
   163  		_, err = SimpleEd25519PKCS7(data, privateKey, nil)
   164  		if err == nil {
   165  			t.Fatal("Should fail for nil certificate")
   166  		}
   167  
   168  		t.Logf("Correctly rejected nil certificate: %v", err)
   169  	})
   170  
   171  	t.Run("Invalid PKCS#7 Data", func(t *testing.T) {
   172  		invalidData := []byte("Invalid PKCS#7 data")
   173  		testData := []byte("test")
   174  
   175  		_, err := VerifySimpleEd25519PKCS7(testData, invalidData)
   176  		if err == nil {
   177  			t.Fatal("Should fail for invalid PKCS#7 data")
   178  		}
   179  
   180  		t.Logf("Correctly rejected invalid PKCS#7 data: %v", err)
   181  	})
   182  }
   183  
   184  // Benchmark the simple Ed25519 PKCS#7 operations
   185  func BenchmarkSimpleEd25519PKCS7Creation(b *testing.B) {
   186  	// Setup
   187  	publicKey, privateKey, err := ed25519.GenerateKey(rand.Reader)
   188  	if err != nil {
   189  		b.Fatalf("Failed to generate key pair: %v", err)
   190  	}
   191  
   192  	template := &x509.Certificate{
   193  		SerialNumber: big.NewInt(1),
   194  		Subject: pkix.Name{
   195  			CommonName: "Benchmark Test",
   196  		},
   197  		NotBefore:             time.Now(),
   198  		NotAfter:              time.Now().Add(365 * 24 * time.Hour),
   199  		KeyUsage:              x509.KeyUsageDigitalSignature,
   200  		BasicConstraintsValid: true,
   201  	}
   202  
   203  	certDER, err := x509.CreateCertificate(rand.Reader, template, template, publicKey, privateKey)
   204  	if err != nil {
   205  		b.Fatalf("Failed to create certificate: %v", err)
   206  	}
   207  
   208  	cert, err := x509.ParseCertificate(certDER)
   209  	if err != nil {
   210  		b.Fatalf("Failed to parse certificate: %v", err)
   211  	}
   212  
   213  	testData := []byte("Benchmark test data")
   214  
   215  	b.ResetTimer()
   216  	for i := 0; i < b.N; i++ {
   217  		_, err := SimpleEd25519PKCS7(testData, privateKey, cert)
   218  		if err != nil {
   219  			b.Fatalf("Signature creation failed: %v", err)
   220  		}
   221  	}
   222  }
   223  
   224  func BenchmarkSimpleEd25519PKCS7Verification(b *testing.B) {
   225  	// Setup
   226  	publicKey, privateKey, err := ed25519.GenerateKey(rand.Reader)
   227  	if err != nil {
   228  		b.Fatalf("Failed to generate key pair: %v", err)
   229  	}
   230  
   231  	template := &x509.Certificate{
   232  		SerialNumber: big.NewInt(1),
   233  		Subject: pkix.Name{
   234  			CommonName: "Benchmark Test",
   235  		},
   236  		NotBefore:             time.Now(),
   237  		NotAfter:              time.Now().Add(365 * 24 * time.Hour),
   238  		KeyUsage:              x509.KeyUsageDigitalSignature,
   239  		BasicConstraintsValid: true,
   240  	}
   241  
   242  	certDER, err := x509.CreateCertificate(rand.Reader, template, template, publicKey, privateKey)
   243  	if err != nil {
   244  		b.Fatalf("Failed to create certificate: %v", err)
   245  	}
   246  
   247  	cert, err := x509.ParseCertificate(certDER)
   248  	if err != nil {
   249  		b.Fatalf("Failed to parse certificate: %v", err)
   250  	}
   251  
   252  	testData := []byte("Benchmark test data")
   253  	pkcs7Data, err := SimpleEd25519PKCS7(testData, privateKey, cert)
   254  	if err != nil {
   255  		b.Fatalf("Failed to create signature: %v", err)
   256  	}
   257  
   258  	b.ResetTimer()
   259  	for i := 0; i < b.N; i++ {
   260  		_, err := VerifySimpleEd25519PKCS7(testData, pkcs7Data)
   261  		if err != nil {
   262  			b.Fatalf("Signature verification failed: %v", err)
   263  		}
   264  	}
   265  }