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 }