github.com/jasoet/gopki@v1.15.0/encryption/asymmetric/helpers_test.go (about) 1 package asymmetric 2 3 import ( 4 "bytes" 5 "crypto/rand" 6 "crypto/sha256" 7 "fmt" 8 "io" 9 "testing" 10 11 "golang.org/x/crypto/hkdf" 12 ) 13 14 func TestDeriveAESKey(t *testing.T) { 15 testCases := []struct { 16 name string 17 secretLength int 18 }{ 19 {"32ByteSecret", 32}, 20 {"64ByteSecret", 64}, 21 {"128ByteSecret", 128}, 22 {"MinSecret", 1}, 23 {"EmptySecret", 0}, 24 } 25 26 for _, tc := range testCases { 27 t.Run(tc.name, func(t *testing.T) { 28 secret := make([]byte, tc.secretLength) 29 if tc.secretLength > 0 { 30 _, err := rand.Read(secret) 31 if err != nil { 32 t.Fatalf("Failed to generate test secret: %v", err) 33 } 34 } 35 36 derivedKey := deriveAESKey(secret) 37 38 // Check that derived key is always 32 bytes (AES-256) 39 if len(derivedKey) != 32 { 40 t.Errorf("Expected derived key length 32, got %d", len(derivedKey)) 41 } 42 43 // Check that the same input produces the same output (deterministic) 44 derivedKey2 := deriveAESKey(secret) 45 if !bytes.Equal(derivedKey, derivedKey2) { 46 t.Error("Key derivation is not deterministic") 47 } 48 49 // Check that different inputs produce different outputs 50 if tc.secretLength > 0 { 51 differentSecret := make([]byte, tc.secretLength) 52 differentSecret[0] = secret[0] ^ 0xFF // Make it different 53 copy(differentSecret[1:], secret[1:]) 54 55 differentKey := deriveAESKey(differentSecret) 56 if bytes.Equal(derivedKey, differentKey) { 57 t.Error("Different secrets produced the same derived key") 58 } 59 } 60 }) 61 } 62 } 63 64 func TestDeriveAESKeyConsistencyWithHKDF(t *testing.T) { 65 // Test that our key derivation matches direct HKDF usage 66 secret := make([]byte, 32) 67 _, err := rand.Read(secret) 68 if err != nil { 69 t.Fatalf("Failed to generate test secret: %v", err) 70 } 71 72 // Derive key using our function 73 ourKey := deriveAESKey(secret) 74 75 // Derive key using HKDF directly (should match our implementation) 76 hkdfReader := hkdf.New(sha256.New, secret, nil, []byte("GoPKI-AES-Key")) 77 expectedKey := make([]byte, 32) 78 _, err = io.ReadFull(hkdfReader, expectedKey) 79 if err != nil { 80 t.Fatalf("Failed to derive key with HKDF: %v", err) 81 } 82 83 if !bytes.Equal(ourKey, expectedKey) { 84 t.Error("Our key derivation doesn't match HKDF implementation") 85 } 86 } 87 88 func TestEncryptAESGCM(t *testing.T) { 89 // Only test AES-256 as the implementation only supports 32-byte keys 90 testKeys := [][]byte{ 91 make([]byte, 32), // AES-256 92 } 93 94 // Fill keys with test data 95 for _, key := range testKeys { 96 _, err := rand.Read(key) 97 if err != nil { 98 t.Fatalf("Failed to generate test key: %v", err) 99 } 100 } 101 102 testData := [][]byte{ 103 []byte(""), 104 []byte("short"), 105 []byte("medium length test data"), 106 make([]byte, 1024), // 1KB 107 make([]byte, 10240), // 10KB 108 } 109 110 // Fill large test data 111 for i := range testData[len(testData)-1] { 112 testData[len(testData)-1][i] = byte(i % 256) 113 } 114 for i := range testData[len(testData)-2] { 115 testData[len(testData)-2][i] = byte(i % 256) 116 } 117 118 for _, key := range testKeys { 119 for dataIdx, data := range testData { 120 t.Run(fmt.Sprintf("Key%dBytes_Data%d", len(key), dataIdx), func(t *testing.T) { 121 ciphertext, iv, tag, err := encryptAESGCM(data, key) 122 if err != nil { 123 t.Fatalf("Failed to encrypt: %v", err) 124 } 125 126 // Check IV length (should be 12 bytes for GCM) 127 if len(iv) != 12 { 128 t.Errorf("Expected IV length 12, got %d", len(iv)) 129 } 130 131 // Check tag length (should be 16 bytes for GCM) 132 if len(tag) != 16 { 133 t.Errorf("Expected tag length 16, got %d", len(tag)) 134 } 135 136 // Check ciphertext length matches plaintext length 137 if len(ciphertext) != len(data) { 138 t.Errorf("Ciphertext length %d doesn't match plaintext length %d", len(ciphertext), len(data)) 139 } 140 141 // For non-empty data, ciphertext should be different from plaintext 142 if len(data) > 0 && bytes.Equal(ciphertext, data) { 143 t.Error("Ciphertext should be different from plaintext") 144 } 145 }) 146 } 147 } 148 } 149 150 func TestEncryptAESGCMUniqueness(t *testing.T) { 151 key := make([]byte, 32) 152 _, err := rand.Read(key) 153 if err != nil { 154 t.Fatalf("Failed to generate test key: %v", err) 155 } 156 157 data := []byte("test data for uniqueness") 158 159 // Encrypt the same data multiple times 160 numTests := 10 161 results := make(map[string]bool) 162 163 for i := 0; i < numTests; i++ { 164 ciphertext, iv, tag, err := encryptAESGCM(data, key) 165 if err != nil { 166 t.Fatalf("Failed to encrypt iteration %d: %v", i, err) 167 } 168 169 // Create unique identifier for this encryption 170 identifier := string(iv) + string(tag) + string(ciphertext) 171 172 if results[identifier] { 173 t.Error("Encryption produced identical results - IVs should be unique") 174 } 175 results[identifier] = true 176 177 // Each IV should be unique 178 ivStr := string(iv) 179 if len(ivStr) != 12 { 180 t.Errorf("IV length should be 12, got %d", len(ivStr)) 181 } 182 } 183 184 if len(results) != numTests { 185 t.Errorf("Expected %d unique encryptions, got %d", numTests, len(results)) 186 } 187 } 188 189 func TestEncryptAESGCMInvalidKey(t *testing.T) { 190 // Test invalid keys - implementation only accepts 32-byte keys 191 invalidKeys := [][]byte{ 192 make([]byte, 15), // Too short 193 make([]byte, 16), // AES-128 not supported 194 make([]byte, 24), // AES-192 not supported 195 make([]byte, 31), // Too short 196 make([]byte, 33), // Too long 197 nil, // Nil key 198 {}, // Empty key 199 } 200 201 data := []byte("test data") 202 203 for i, key := range invalidKeys { 204 t.Run(fmt.Sprintf("InvalidKey%d", i), func(t *testing.T) { 205 _, _, _, err := encryptAESGCM(data, key) 206 if err == nil { 207 t.Errorf("Expected error for invalid key of length %d", len(key)) 208 } 209 }) 210 } 211 } 212 213 func TestDecryptAESGCM(t *testing.T) { 214 // Only test AES-256 as the implementation only supports 32-byte keys 215 testKeys := [][]byte{ 216 make([]byte, 32), // AES-256 217 } 218 219 // Fill keys with test data 220 for _, key := range testKeys { 221 _, err := rand.Read(key) 222 if err != nil { 223 t.Fatalf("Failed to generate test key: %v", err) 224 } 225 } 226 227 testData := [][]byte{ 228 []byte(""), 229 []byte("short"), 230 []byte("medium length test data for decryption"), 231 make([]byte, 1024), 232 } 233 234 // Fill large test data 235 for i := range testData[len(testData)-1] { 236 testData[len(testData)-1][i] = byte(i % 256) 237 } 238 239 for _, key := range testKeys { 240 for dataIdx, originalData := range testData { 241 t.Run(fmt.Sprintf("Key%dBytes_Data%d", len(key), dataIdx), func(t *testing.T) { 242 // Encrypt first 243 ciphertext, iv, tag, err := encryptAESGCM(originalData, key) 244 if err != nil { 245 t.Fatalf("Failed to encrypt: %v", err) 246 } 247 248 // Decrypt 249 decrypted, err := decryptAESGCM(ciphertext, key, iv, tag) 250 if err != nil { 251 t.Fatalf("Failed to decrypt: %v", err) 252 } 253 254 // Verify decrypted data matches original 255 if !bytes.Equal(decrypted, originalData) { 256 t.Errorf("Decrypted data doesn't match original. Expected: %v, Got: %v", originalData, decrypted) 257 } 258 }) 259 } 260 } 261 } 262 263 func TestDecryptAESGCMErrorCases(t *testing.T) { 264 key := make([]byte, 32) 265 _, err := rand.Read(key) 266 if err != nil { 267 t.Fatalf("Failed to generate test key: %v", err) 268 } 269 270 data := []byte("test data for error cases") 271 ciphertext, iv, tag, err := encryptAESGCM(data, key) 272 if err != nil { 273 t.Fatalf("Failed to encrypt test data: %v", err) 274 } 275 276 t.Run("InvalidKey", func(t *testing.T) { 277 invalidKey := make([]byte, 15) // Invalid length 278 _, err := decryptAESGCM(ciphertext, invalidKey, iv, tag) 279 if err == nil { 280 t.Error("Expected error for invalid key") 281 } 282 }) 283 284 t.Run("WrongKey", func(t *testing.T) { 285 wrongKey := make([]byte, 32) 286 _, err := rand.Read(wrongKey) 287 if err != nil { 288 t.Fatalf("Failed to generate wrong key: %v", err) 289 } 290 291 _, err = decryptAESGCM(ciphertext, wrongKey, iv, tag) 292 if err == nil { 293 t.Error("Expected error for wrong key") 294 } 295 }) 296 297 t.Run("CorruptedCiphertext", func(t *testing.T) { 298 corruptedCiphertext := make([]byte, len(ciphertext)) 299 copy(corruptedCiphertext, ciphertext) 300 if len(corruptedCiphertext) > 0 { 301 corruptedCiphertext[0] ^= 0xFF 302 } 303 304 _, err := decryptAESGCM(corruptedCiphertext, key, iv, tag) 305 if err == nil { 306 t.Error("Expected error for corrupted ciphertext") 307 } 308 }) 309 310 t.Run("CorruptedIV", func(t *testing.T) { 311 corruptedIV := make([]byte, len(iv)) 312 copy(corruptedIV, iv) 313 corruptedIV[0] ^= 0xFF 314 315 _, err := decryptAESGCM(ciphertext, key, corruptedIV, tag) 316 if err == nil { 317 t.Error("Expected error for corrupted IV") 318 } 319 }) 320 321 t.Run("CorruptedTag", func(t *testing.T) { 322 corruptedTag := make([]byte, len(tag)) 323 copy(corruptedTag, tag) 324 corruptedTag[0] ^= 0xFF 325 326 _, err := decryptAESGCM(ciphertext, key, iv, corruptedTag) 327 if err == nil { 328 t.Error("Expected error for corrupted tag") 329 } 330 }) 331 332 t.Run("InvalidIVLength", func(t *testing.T) { 333 defer func() { 334 if r := recover(); r != nil { 335 // Expected panic for invalid IV length 336 t.Logf("Caught expected panic for invalid IV length: %v", r) 337 } 338 }() 339 340 invalidIV := make([]byte, 11) // Wrong length 341 _, err := decryptAESGCM(ciphertext, key, invalidIV, tag) 342 if err == nil { 343 t.Error("Expected error for invalid IV length") 344 } 345 }) 346 347 t.Run("InvalidTagLength", func(t *testing.T) { 348 invalidTag := make([]byte, 15) // Wrong length 349 _, err := decryptAESGCM(ciphertext, key, iv, invalidTag) 350 if err == nil { 351 t.Error("Expected error for invalid tag length") 352 } 353 }) 354 355 t.Run("NilInputs", func(t *testing.T) { 356 // Test nil ciphertext 357 _, err := decryptAESGCM(nil, key, iv, tag) 358 if err == nil { 359 t.Error("Expected error for nil ciphertext") 360 } 361 362 // Test nil key 363 _, err = decryptAESGCM(ciphertext, nil, iv, tag) 364 if err == nil { 365 t.Error("Expected error for nil key") 366 } 367 368 // Test nil IV (this will panic) 369 func() { 370 defer func() { 371 if r := recover(); r != nil { 372 t.Logf("Caught expected panic for nil IV: %v", r) 373 } 374 }() 375 _, err = decryptAESGCM(ciphertext, key, nil, tag) 376 if err == nil { 377 t.Error("Expected error for nil IV") 378 } 379 }() 380 381 // Test nil tag 382 _, err = decryptAESGCM(ciphertext, key, iv, nil) 383 if err == nil { 384 t.Error("Expected error for nil tag") 385 } 386 }) 387 } 388 389 func TestAESGCMRoundTrip(t *testing.T) { 390 // Test complete round-trip encryption/decryption 391 // Only test AES-256 as implementation only supports 32-byte keys 392 testCases := []struct { 393 keySize int 394 dataSize int 395 }{ 396 {32, 0}, 397 {32, 1}, 398 {32, 100}, 399 {32, 1000}, 400 {32, 10000}, 401 } 402 403 for _, tc := range testCases { 404 t.Run(fmt.Sprintf("Key%d_Data%d", tc.keySize, tc.dataSize), func(t *testing.T) { 405 key := make([]byte, tc.keySize) 406 _, err := rand.Read(key) 407 if err != nil { 408 t.Fatalf("Failed to generate key: %v", err) 409 } 410 411 originalData := make([]byte, tc.dataSize) 412 for i := range originalData { 413 originalData[i] = byte(i % 256) 414 } 415 416 // Encrypt 417 ciphertext, iv, tag, err := encryptAESGCM(originalData, key) 418 if err != nil { 419 t.Fatalf("Failed to encrypt: %v", err) 420 } 421 422 // Decrypt 423 decrypted, err := decryptAESGCM(ciphertext, key, iv, tag) 424 if err != nil { 425 t.Fatalf("Failed to decrypt: %v", err) 426 } 427 428 // Verify 429 if !bytes.Equal(decrypted, originalData) { 430 t.Error("Round-trip failed: decrypted data doesn't match original") 431 } 432 }) 433 } 434 } 435 436 func BenchmarkDeriveAESKey(b *testing.B) { 437 secret := make([]byte, 32) 438 _, err := rand.Read(secret) 439 if err != nil { 440 b.Fatalf("Failed to generate test secret: %v", err) 441 } 442 443 b.ResetTimer() 444 for i := 0; i < b.N; i++ { 445 _ = deriveAESKey(secret) 446 } 447 } 448 449 func BenchmarkEncryptAESGCM(b *testing.B) { 450 key := make([]byte, 32) 451 _, err := rand.Read(key) 452 if err != nil { 453 b.Fatalf("Failed to generate key: %v", err) 454 } 455 456 data := make([]byte, 1024) 457 _, err = rand.Read(data) 458 if err != nil { 459 b.Fatalf("Failed to generate data: %v", err) 460 } 461 462 b.ResetTimer() 463 for i := 0; i < b.N; i++ { 464 _, _, _, err := encryptAESGCM(data, key) 465 if err != nil { 466 b.Fatalf("Encryption failed: %v", err) 467 } 468 } 469 } 470 471 func BenchmarkDecryptAESGCM(b *testing.B) { 472 key := make([]byte, 32) 473 _, err := rand.Read(key) 474 if err != nil { 475 b.Fatalf("Failed to generate key: %v", err) 476 } 477 478 data := make([]byte, 1024) 479 _, err = rand.Read(data) 480 if err != nil { 481 b.Fatalf("Failed to generate data: %v", err) 482 } 483 484 ciphertext, iv, tag, err := encryptAESGCM(data, key) 485 if err != nil { 486 b.Fatalf("Failed to encrypt test data: %v", err) 487 } 488 489 b.ResetTimer() 490 for i := 0; i < b.N; i++ { 491 _, err := decryptAESGCM(ciphertext, key, iv, tag) 492 if err != nil { 493 b.Fatalf("Decryption failed: %v", err) 494 } 495 } 496 }