github.com/jasoet/gopki@v1.15.0/encryption/symmetric/symmetric_test.go (about) 1 package symmetric 2 3 import ( 4 "bytes" 5 "crypto/rand" 6 "fmt" 7 "testing" 8 "time" 9 10 "github.com/jasoet/gopki/encryption" 11 "github.com/stretchr/testify/assert" 12 ) 13 14 func TestEncryptAESGCM(t *testing.T) { 15 testData := []byte("test data for AES-GCM encryption") 16 opts := encryption.DefaultEncryptOptions() 17 18 t.Run("AES-128", func(t *testing.T) { 19 key, err := GenerateAESKey(16) 20 assert.NoError(t, err) 21 22 encrypted, err := EncryptAESGCM(testData, key, opts) 23 assert.NoError(t, err) 24 assert.NotNil(t, encrypted) 25 assert.Equal(t, encryption.AlgorithmAESGCM, encrypted.Algorithm) 26 assert.NotEmpty(t, encrypted.Data) 27 assert.NotEmpty(t, encrypted.IV) 28 assert.NotEmpty(t, encrypted.Tag) 29 assert.Equal(t, 12, len(encrypted.IV)) // GCM nonce size 30 assert.Equal(t, 16, len(encrypted.Tag)) // GCM tag size 31 }) 32 33 t.Run("AES-192", func(t *testing.T) { 34 key, err := GenerateAESKey(24) 35 assert.NoError(t, err) 36 37 encrypted, err := EncryptAESGCM(testData, key, opts) 38 assert.NoError(t, err) 39 assert.NotNil(t, encrypted) 40 assert.Equal(t, encryption.AlgorithmAESGCM, encrypted.Algorithm) 41 }) 42 43 t.Run("AES-256", func(t *testing.T) { 44 key, err := GenerateAESKey(32) 45 assert.NoError(t, err) 46 47 encrypted, err := EncryptAESGCM(testData, key, opts) 48 assert.NoError(t, err) 49 assert.NotNil(t, encrypted) 50 assert.Equal(t, encryption.AlgorithmAESGCM, encrypted.Algorithm) 51 }) 52 53 t.Run("Invalid Key Size", func(t *testing.T) { 54 invalidKey := make([]byte, 15) // Invalid size 55 56 encrypted, err := EncryptAESGCM(testData, invalidKey, opts) 57 assert.Error(t, err) 58 assert.Nil(t, encrypted) 59 assert.Contains(t, err.Error(), "invalid AES key size") 60 }) 61 62 t.Run("Empty Data", func(t *testing.T) { 63 key, err := GenerateAESKey(32) 64 assert.NoError(t, err) 65 66 encrypted, err := EncryptAESGCM([]byte{}, key, opts) 67 assert.NoError(t, err) 68 assert.NotNil(t, encrypted) 69 assert.Empty(t, encrypted.Data) 70 }) 71 72 t.Run("Large Data", func(t *testing.T) { 73 largeData := make([]byte, 1024*1024) // 1MB 74 _, err := rand.Read(largeData) 75 assert.NoError(t, err) 76 77 key, err := GenerateAESKey(32) 78 assert.NoError(t, err) 79 80 encrypted, err := EncryptAESGCM(largeData, key, opts) 81 assert.NoError(t, err) 82 assert.NotNil(t, encrypted) 83 assert.Len(t, encrypted.Data, len(largeData)) 84 }) 85 86 t.Run("With Metadata", func(t *testing.T) { 87 key, err := GenerateAESKey(32) 88 assert.NoError(t, err) 89 90 opts := encryption.DefaultEncryptOptions() 91 opts.Metadata = map[string]interface{}{ 92 "purpose": "testing", 93 "algorithm": "AES-GCM", 94 } 95 96 encrypted, err := EncryptAESGCM(testData, key, opts) 97 assert.NoError(t, err) 98 assert.NotNil(t, encrypted.Metadata) 99 assert.Equal(t, "testing", encrypted.Metadata["purpose"]) 100 assert.Equal(t, "AES-GCM", encrypted.Metadata["algorithm"]) 101 }) 102 103 t.Run("Unique Nonces", func(t *testing.T) { 104 key, err := GenerateAESKey(32) 105 assert.NoError(t, err) 106 107 encrypted1, err := EncryptAESGCM(testData, key, opts) 108 assert.NoError(t, err) 109 110 encrypted2, err := EncryptAESGCM(testData, key, opts) 111 assert.NoError(t, err) 112 113 // Same plaintext should produce different ciphertexts due to unique nonces 114 assert.NotEqual(t, encrypted1.IV, encrypted2.IV) 115 assert.NotEqual(t, encrypted1.Data, encrypted2.Data) 116 assert.NotEqual(t, encrypted1.Tag, encrypted2.Tag) 117 }) 118 119 t.Run("Invalid Encrypt Options", func(t *testing.T) { 120 key, err := GenerateAESKey(32) 121 assert.NoError(t, err) 122 123 invalidOpts := encryption.EncryptOptions{ 124 Algorithm: "INVALID_ALG", // Invalid algorithm 125 Format: encryption.FormatCMS, 126 } 127 128 encrypted, err := EncryptAESGCM(testData, key, invalidOpts) 129 assert.Error(t, err) 130 assert.Nil(t, encrypted) 131 assert.Contains(t, err.Error(), "unsupported encryption algorithm") 132 }) 133 134 t.Run("Zero Length Key", func(t *testing.T) { 135 zeroKey := []byte{} // Zero-length key 136 137 encrypted, err := EncryptAESGCM(testData, zeroKey, opts) 138 assert.Error(t, err) 139 assert.Nil(t, encrypted) 140 assert.Contains(t, err.Error(), "invalid AES key size") 141 }) 142 } 143 144 func TestDecryptAESGCM(t *testing.T) { 145 testData := []byte("test data for AES-GCM decryption") 146 opts := encryption.DefaultEncryptOptions() 147 decryptOpts := encryption.DefaultDecryptOptions() 148 149 t.Run("AES-128 Round Trip", func(t *testing.T) { 150 key, err := GenerateAESKey(16) 151 assert.NoError(t, err) 152 153 encrypted, err := EncryptAESGCM(testData, key, opts) 154 assert.NoError(t, err) 155 156 decrypted, err := DecryptAESGCM(encrypted, key, decryptOpts) 157 assert.NoError(t, err) 158 assert.Equal(t, testData, decrypted) 159 }) 160 161 t.Run("AES-192 Round Trip", func(t *testing.T) { 162 key, err := GenerateAESKey(24) 163 assert.NoError(t, err) 164 165 encrypted, err := EncryptAESGCM(testData, key, opts) 166 assert.NoError(t, err) 167 168 decrypted, err := DecryptAESGCM(encrypted, key, decryptOpts) 169 assert.NoError(t, err) 170 assert.Equal(t, testData, decrypted) 171 }) 172 173 t.Run("AES-256 Round Trip", func(t *testing.T) { 174 key, err := GenerateAESKey(32) 175 assert.NoError(t, err) 176 177 encrypted, err := EncryptAESGCM(testData, key, opts) 178 assert.NoError(t, err) 179 180 decrypted, err := DecryptAESGCM(encrypted, key, decryptOpts) 181 assert.NoError(t, err) 182 assert.Equal(t, testData, decrypted) 183 }) 184 185 t.Run("Wrong Algorithm", func(t *testing.T) { 186 key, err := GenerateAESKey(32) 187 assert.NoError(t, err) 188 189 encrypted := &encryption.EncryptedData{ 190 Algorithm: encryption.AlgorithmRSAOAEP, 191 Data: []byte("test"), 192 IV: make([]byte, 12), 193 Tag: make([]byte, 16), 194 } 195 196 decrypted, err := DecryptAESGCM(encrypted, key, decryptOpts) 197 assert.Error(t, err) 198 assert.Nil(t, decrypted) 199 assert.Contains(t, err.Error(), "expected AES-GCM algorithm") 200 }) 201 202 t.Run("Wrong Key", func(t *testing.T) { 203 key1, err := GenerateAESKey(32) 204 assert.NoError(t, err) 205 key2, err := GenerateAESKey(32) 206 assert.NoError(t, err) 207 208 encrypted, err := EncryptAESGCM(testData, key1, opts) 209 assert.NoError(t, err) 210 211 decrypted, err := DecryptAESGCM(encrypted, key2, decryptOpts) 212 assert.Error(t, err) 213 assert.Nil(t, decrypted) 214 assert.Contains(t, err.Error(), "authentication error") 215 }) 216 217 t.Run("Invalid Key Size", func(t *testing.T) { 218 key, err := GenerateAESKey(32) 219 assert.NoError(t, err) 220 221 encrypted, err := EncryptAESGCM(testData, key, opts) 222 assert.NoError(t, err) 223 224 invalidKey := make([]byte, 15) 225 decrypted, err := DecryptAESGCM(encrypted, invalidKey, decryptOpts) 226 assert.Error(t, err) 227 assert.Nil(t, decrypted) 228 assert.Contains(t, err.Error(), "invalid AES key size") 229 }) 230 231 t.Run("Tampered Ciphertext", func(t *testing.T) { 232 key, err := GenerateAESKey(32) 233 assert.NoError(t, err) 234 235 encrypted, err := EncryptAESGCM(testData, key, opts) 236 assert.NoError(t, err) 237 238 // Tamper with ciphertext 239 encrypted.Data[0] ^= 0x01 240 241 decrypted, err := DecryptAESGCM(encrypted, key, decryptOpts) 242 assert.Error(t, err) 243 assert.Nil(t, decrypted) 244 assert.Contains(t, err.Error(), "authentication error") 245 }) 246 247 t.Run("Tampered Tag", func(t *testing.T) { 248 key, err := GenerateAESKey(32) 249 assert.NoError(t, err) 250 251 encrypted, err := EncryptAESGCM(testData, key, opts) 252 assert.NoError(t, err) 253 254 // Tamper with authentication tag 255 encrypted.Tag[0] ^= 0x01 256 257 decrypted, err := DecryptAESGCM(encrypted, key, decryptOpts) 258 assert.Error(t, err) 259 assert.Nil(t, decrypted) 260 assert.Contains(t, err.Error(), "authentication error") 261 }) 262 263 t.Run("Tampered IV", func(t *testing.T) { 264 key, err := GenerateAESKey(32) 265 assert.NoError(t, err) 266 267 encrypted, err := EncryptAESGCM(testData, key, opts) 268 assert.NoError(t, err) 269 270 // Tamper with IV/nonce 271 encrypted.IV[0] ^= 0x01 272 273 decrypted, err := DecryptAESGCM(encrypted, key, decryptOpts) 274 assert.Error(t, err) 275 assert.Nil(t, decrypted) 276 assert.Contains(t, err.Error(), "authentication error") 277 }) 278 279 t.Run("Large Data Round Trip", func(t *testing.T) { 280 largeData := make([]byte, 5*1024*1024) // 5MB 281 _, err := rand.Read(largeData) 282 assert.NoError(t, err) 283 284 key, err := GenerateAESKey(32) 285 assert.NoError(t, err) 286 287 encrypted, err := EncryptAESGCM(largeData, key, opts) 288 assert.NoError(t, err) 289 290 decrypted, err := DecryptAESGCM(encrypted, key, decryptOpts) 291 assert.NoError(t, err) 292 assert.True(t, bytes.Equal(largeData, decrypted)) 293 }) 294 295 t.Run("Empty Data Round Trip", func(t *testing.T) { 296 key, err := GenerateAESKey(32) 297 assert.NoError(t, err) 298 299 encrypted, err := EncryptAESGCM([]byte{}, key, opts) 300 assert.NoError(t, err) 301 302 decrypted, err := DecryptAESGCM(encrypted, key, decryptOpts) 303 assert.NoError(t, err) 304 assert.Empty(t, decrypted) 305 }) 306 307 t.Run("Invalid Decrypt Options", func(t *testing.T) { 308 key, err := GenerateAESKey(32) 309 assert.NoError(t, err) 310 311 encrypted, err := EncryptAESGCM(testData, key, opts) 312 assert.NoError(t, err) 313 314 invalidDecryptOpts := encryption.DecryptOptions{ 315 MaxAge: -1 * time.Hour, // Invalid negative max age 316 } 317 318 decrypted, err := DecryptAESGCM(encrypted, key, invalidDecryptOpts) 319 assert.Error(t, err) 320 assert.Nil(t, decrypted) 321 assert.Contains(t, err.Error(), "invalid encryption parameters") 322 }) 323 } 324 325 func TestGenerateAESKey(t *testing.T) { 326 t.Run("AES-128", func(t *testing.T) { 327 key, err := GenerateAESKey(16) 328 assert.NoError(t, err) 329 assert.Len(t, key, 16) 330 }) 331 332 t.Run("AES-192", func(t *testing.T) { 333 key, err := GenerateAESKey(24) 334 assert.NoError(t, err) 335 assert.Len(t, key, 24) 336 }) 337 338 t.Run("AES-256", func(t *testing.T) { 339 key, err := GenerateAESKey(32) 340 assert.NoError(t, err) 341 assert.Len(t, key, 32) 342 }) 343 344 t.Run("Invalid Key Sizes", func(t *testing.T) { 345 invalidSizes := []int{8, 12, 15, 17, 20, 25, 31, 33, 64} 346 for _, size := range invalidSizes { 347 key, err := GenerateAESKey(size) 348 assert.Error(t, err) 349 assert.Nil(t, key) 350 assert.Contains(t, err.Error(), "invalid AES key size") 351 } 352 }) 353 354 t.Run("Key Uniqueness", func(t *testing.T) { 355 key1, err := GenerateAESKey(32) 356 assert.NoError(t, err) 357 358 key2, err := GenerateAESKey(32) 359 assert.NoError(t, err) 360 361 // Keys should be different 362 assert.NotEqual(t, key1, key2) 363 }) 364 365 t.Run("Key Randomness", func(t *testing.T) { 366 key, err := GenerateAESKey(32) 367 assert.NoError(t, err) 368 369 // Key should not be all zeros 370 allZeros := make([]byte, 32) 371 assert.NotEqual(t, allZeros, key) 372 373 // Key should not be all 0xFF 374 allFF := make([]byte, 32) 375 for i := range allFF { 376 allFF[i] = 0xFF 377 } 378 assert.NotEqual(t, allFF, key) 379 }) 380 } 381 382 func TestDeriveKeyFromPassword(t *testing.T) { 383 password := "test-password-123" 384 salt := []byte("test-salt-16-bytes-long") 385 iterations := 100000 386 387 t.Run("AES-128", func(t *testing.T) { 388 key, err := DeriveKeyFromPassword(password, salt, 16, iterations) 389 assert.NoError(t, err) 390 assert.Len(t, key, 16) 391 }) 392 393 t.Run("AES-192", func(t *testing.T) { 394 key, err := DeriveKeyFromPassword(password, salt, 24, iterations) 395 assert.NoError(t, err) 396 assert.Len(t, key, 24) 397 }) 398 399 t.Run("AES-256", func(t *testing.T) { 400 key, err := DeriveKeyFromPassword(password, salt, 32, iterations) 401 assert.NoError(t, err) 402 assert.Len(t, key, 32) 403 }) 404 405 t.Run("Deterministic", func(t *testing.T) { 406 key1, err := DeriveKeyFromPassword(password, salt, 32, iterations) 407 assert.NoError(t, err) 408 409 key2, err := DeriveKeyFromPassword(password, salt, 32, iterations) 410 assert.NoError(t, err) 411 412 // Same inputs should produce same key 413 assert.Equal(t, key1, key2) 414 }) 415 416 t.Run("Different Passwords", func(t *testing.T) { 417 key1, err := DeriveKeyFromPassword("password1", salt, 32, iterations) 418 assert.NoError(t, err) 419 420 key2, err := DeriveKeyFromPassword("password2", salt, 32, iterations) 421 assert.NoError(t, err) 422 423 // Different passwords should produce different keys 424 assert.NotEqual(t, key1, key2) 425 }) 426 427 t.Run("Different Salts", func(t *testing.T) { 428 salt1 := []byte("salt1-16-bytes-long") 429 salt2 := []byte("salt2-16-bytes-long") 430 431 key1, err := DeriveKeyFromPassword(password, salt1, 32, iterations) 432 assert.NoError(t, err) 433 434 key2, err := DeriveKeyFromPassword(password, salt2, 32, iterations) 435 assert.NoError(t, err) 436 437 // Different salts should produce different keys 438 assert.NotEqual(t, key1, key2) 439 }) 440 441 t.Run("Different Iterations", func(t *testing.T) { 442 key1, err := DeriveKeyFromPassword(password, salt, 32, 10000) 443 assert.NoError(t, err) 444 445 key2, err := DeriveKeyFromPassword(password, salt, 32, 20000) 446 assert.NoError(t, err) 447 448 // Different iteration counts should produce different keys 449 assert.NotEqual(t, key1, key2) 450 }) 451 452 t.Run("Invalid Key Size", func(t *testing.T) { 453 key, err := DeriveKeyFromPassword(password, salt, 15, iterations) 454 assert.Error(t, err) 455 assert.Nil(t, key) 456 assert.Contains(t, err.Error(), "invalid AES key size") 457 }) 458 459 t.Run("Salt Too Short", func(t *testing.T) { 460 shortSalt := []byte("short") 461 key, err := DeriveKeyFromPassword(password, shortSalt, 32, iterations) 462 assert.Error(t, err) 463 assert.Nil(t, key) 464 assert.Contains(t, err.Error(), "salt too short") 465 }) 466 467 t.Run("Iterations Too Low", func(t *testing.T) { 468 key, err := DeriveKeyFromPassword(password, salt, 32, 500) 469 assert.Error(t, err) 470 assert.Nil(t, key) 471 assert.Contains(t, err.Error(), "iteration count too low") 472 }) 473 474 t.Run("Round Trip Encryption", func(t *testing.T) { 475 testData := []byte("test data for password-derived encryption") 476 477 key, err := DeriveKeyFromPassword(password, salt, 32, iterations) 478 assert.NoError(t, err) 479 480 encrypted, err := EncryptAESGCM(testData, key, encryption.DefaultEncryptOptions()) 481 assert.NoError(t, err) 482 483 // Derive the same key again 484 derivedKey, err := DeriveKeyFromPassword(password, salt, 32, iterations) 485 assert.NoError(t, err) 486 487 decrypted, err := DecryptAESGCM(encrypted, derivedKey, encryption.DefaultDecryptOptions()) 488 assert.NoError(t, err) 489 assert.Equal(t, testData, decrypted) 490 }) 491 } 492 493 func TestDeriveKeyFromSharedSecret(t *testing.T) { 494 sharedSecret := make([]byte, 32) 495 _, err := rand.Read(sharedSecret) 496 assert.NoError(t, err) 497 498 info := []byte("test-context-info") 499 500 t.Run("AES-128", func(t *testing.T) { 501 key, err := DeriveKeyFromSharedSecret(sharedSecret, info, 16) 502 assert.NoError(t, err) 503 assert.Len(t, key, 16) 504 }) 505 506 t.Run("AES-192", func(t *testing.T) { 507 key, err := DeriveKeyFromSharedSecret(sharedSecret, info, 24) 508 assert.NoError(t, err) 509 assert.Len(t, key, 24) 510 }) 511 512 t.Run("AES-256", func(t *testing.T) { 513 key, err := DeriveKeyFromSharedSecret(sharedSecret, info, 32) 514 assert.NoError(t, err) 515 assert.Len(t, key, 32) 516 }) 517 518 t.Run("Deterministic", func(t *testing.T) { 519 key1, err := DeriveKeyFromSharedSecret(sharedSecret, info, 32) 520 assert.NoError(t, err) 521 522 key2, err := DeriveKeyFromSharedSecret(sharedSecret, info, 32) 523 assert.NoError(t, err) 524 525 // Same inputs should produce same key 526 assert.Equal(t, key1, key2) 527 }) 528 529 t.Run("Different Shared Secrets", func(t *testing.T) { 530 sharedSecret1 := make([]byte, 32) 531 sharedSecret2 := make([]byte, 32) 532 _, err := rand.Read(sharedSecret1) 533 assert.NoError(t, err) 534 _, err = rand.Read(sharedSecret2) 535 assert.NoError(t, err) 536 537 key1, err := DeriveKeyFromSharedSecret(sharedSecret1, info, 32) 538 assert.NoError(t, err) 539 540 key2, err := DeriveKeyFromSharedSecret(sharedSecret2, info, 32) 541 assert.NoError(t, err) 542 543 // Different shared secrets should produce different keys 544 assert.NotEqual(t, key1, key2) 545 }) 546 547 t.Run("Different Info", func(t *testing.T) { 548 info1 := []byte("context1") 549 info2 := []byte("context2") 550 551 key1, err := DeriveKeyFromSharedSecret(sharedSecret, info1, 32) 552 assert.NoError(t, err) 553 554 key2, err := DeriveKeyFromSharedSecret(sharedSecret, info2, 32) 555 assert.NoError(t, err) 556 557 // Different info should produce different keys 558 assert.NotEqual(t, key1, key2) 559 }) 560 561 t.Run("No Info", func(t *testing.T) { 562 key, err := DeriveKeyFromSharedSecret(sharedSecret, nil, 32) 563 assert.NoError(t, err) 564 assert.Len(t, key, 32) 565 }) 566 567 t.Run("Invalid Key Size", func(t *testing.T) { 568 key, err := DeriveKeyFromSharedSecret(sharedSecret, info, 15) 569 assert.Error(t, err) 570 assert.Nil(t, key) 571 assert.Contains(t, err.Error(), "invalid AES key size") 572 }) 573 574 t.Run("Empty Shared Secret", func(t *testing.T) { 575 key, err := DeriveKeyFromSharedSecret([]byte{}, info, 32) 576 assert.Error(t, err) 577 assert.Nil(t, key) 578 assert.Contains(t, err.Error(), "shared secret cannot be empty") 579 }) 580 581 t.Run("Round Trip Encryption", func(t *testing.T) { 582 testData := []byte("test data for shared secret encryption") 583 584 key, err := DeriveKeyFromSharedSecret(sharedSecret, info, 32) 585 assert.NoError(t, err) 586 587 encrypted, err := EncryptAESGCM(testData, key, encryption.DefaultEncryptOptions()) 588 assert.NoError(t, err) 589 590 // Derive the same key again 591 derivedKey, err := DeriveKeyFromSharedSecret(sharedSecret, info, 32) 592 assert.NoError(t, err) 593 594 decrypted, err := DecryptAESGCM(encrypted, derivedKey, encryption.DefaultDecryptOptions()) 595 assert.NoError(t, err) 596 assert.Equal(t, testData, decrypted) 597 }) 598 } 599 600 func TestGenerateSalt(t *testing.T) { 601 t.Run("Minimum Size", func(t *testing.T) { 602 salt, err := GenerateSalt(16) 603 assert.NoError(t, err) 604 assert.Len(t, salt, 16) 605 }) 606 607 t.Run("Large Salt", func(t *testing.T) { 608 salt, err := GenerateSalt(64) 609 assert.NoError(t, err) 610 assert.Len(t, salt, 64) 611 }) 612 613 t.Run("Salt Uniqueness", func(t *testing.T) { 614 salt1, err := GenerateSalt(16) 615 assert.NoError(t, err) 616 617 salt2, err := GenerateSalt(16) 618 assert.NoError(t, err) 619 620 // Salts should be different 621 assert.NotEqual(t, salt1, salt2) 622 }) 623 624 t.Run("Salt Randomness", func(t *testing.T) { 625 salt, err := GenerateSalt(16) 626 assert.NoError(t, err) 627 628 // Salt should not be all zeros 629 allZeros := make([]byte, 16) 630 assert.NotEqual(t, allZeros, salt) 631 }) 632 633 t.Run("Salt Too Small", func(t *testing.T) { 634 salt, err := GenerateSalt(8) 635 assert.Error(t, err) 636 assert.Nil(t, salt) 637 assert.Contains(t, err.Error(), "salt size too small") 638 }) 639 } 640 641 func TestQuickEncryptSymmetric(t *testing.T) { 642 testData := []byte("test data for quick symmetric encryption") 643 644 t.Run("Valid Encryption", func(t *testing.T) { 645 key, err := GenerateAESKey(32) 646 assert.NoError(t, err) 647 648 encrypted, err := QuickEncryptSymmetric(testData, key) 649 assert.NoError(t, err) 650 assert.NotNil(t, encrypted) 651 assert.Equal(t, encryption.AlgorithmAESGCM, encrypted.Algorithm) 652 assert.NotEmpty(t, encrypted.Data) 653 }) 654 655 t.Run("Invalid Key", func(t *testing.T) { 656 invalidKey := make([]byte, 15) 657 658 encrypted, err := QuickEncryptSymmetric(testData, invalidKey) 659 assert.Error(t, err) 660 assert.Nil(t, encrypted) 661 }) 662 } 663 664 func TestQuickDecryptSymmetric(t *testing.T) { 665 testData := []byte("test data for quick symmetric decryption") 666 667 t.Run("Round Trip", func(t *testing.T) { 668 key, err := GenerateAESKey(32) 669 assert.NoError(t, err) 670 671 encrypted, err := QuickEncryptSymmetric(testData, key) 672 assert.NoError(t, err) 673 674 decrypted, err := QuickDecryptSymmetric(encrypted, key) 675 assert.NoError(t, err) 676 assert.Equal(t, testData, decrypted) 677 }) 678 679 t.Run("Wrong Key", func(t *testing.T) { 680 key1, err := GenerateAESKey(32) 681 assert.NoError(t, err) 682 key2, err := GenerateAESKey(32) 683 assert.NoError(t, err) 684 685 encrypted, err := QuickEncryptSymmetric(testData, key1) 686 assert.NoError(t, err) 687 688 decrypted, err := QuickDecryptSymmetric(encrypted, key2) 689 assert.Error(t, err) 690 assert.Nil(t, decrypted) 691 }) 692 } 693 694 func TestSymmetricPerformance(t *testing.T) { 695 if testing.Short() { 696 t.Skip("Skipping performance test in short mode") 697 } 698 699 key, err := GenerateAESKey(32) 700 assert.NoError(t, err) 701 702 // Test with different data sizes 703 dataSizes := []int{ 704 1024, // 1KB 705 1024 * 1024, // 1MB 706 10 * 1024 * 1024, // 10MB 707 } 708 709 for _, size := range dataSizes { 710 t.Run(fmt.Sprintf("Size%dB", size), func(t *testing.T) { 711 data := make([]byte, size) 712 _, err := rand.Read(data) 713 assert.NoError(t, err) 714 715 // Measure encryption 716 encrypted, err := QuickEncryptSymmetric(data, key) 717 assert.NoError(t, err) 718 719 // Measure decryption 720 decrypted, err := QuickDecryptSymmetric(encrypted, key) 721 assert.NoError(t, err) 722 723 assert.True(t, bytes.Equal(data, decrypted)) 724 }) 725 } 726 }