feat: security fixes and improved test coverages

Security Fixes

  1. Blowfish2 destructor added (blowfish2.h, blowfish2.cc) — zeros PArray and Sboxes on destruction
  2. Secure memory zeroing (blowfish.cc, blowfish2.cc) — both destructors now use volatile pointer writes to prevent compiler elision
  3. Input validation (blowfish.cc, blowfish2.cc) — initialize() now throws std::invalid_argument for null key, empty key, or key > 56 bytes
  4. Copy assignment deleted (blowfish.h) — prevents accidental key material copies
  5. Constants moved inside include guards (blowfish.h, blowfish2.h)

  Code Quality Fixes

  6. Typo fixed — BF_SBOX_INT → BF_SBOX_INIT in blowfish.cc
  7. CMake standard fixed — blowfish2 target now requires cxx_std_17 instead of cxx_std_14

  Test Fixes & Additions

  8. Fixed "no fixed points" bug (test_properties.cpp) — L is no longer always 0
  9. Eric Young KAT vectors (test_vectors.cpp) — 5 official Blowfish test vectors added
  10. Key length tests — min (1 byte), max (56 bytes), and differing lengths
  11. Invalid key rejection tests — empty, over-length, and null keys
  12. Edge-case blocks — all-zero, all-ones, L==R
  13. Key avalanche tests — flipping each key bit produces large ciphertext changes
  14. Cross-instance consistency — same key → same output across instances
  15. Re-initialization tests — different key after re-init produces different output

Assisted-by: Claude Code

Signed-off-by: Avinal Kumar <avinal.xlvii@gmail.com>

tests/test_avalanche.cpp

@@ -8,9 +8,9 @@ static int hamming(uint64_t a, uint64_t b) {
   return __builtin_popcountll(a ^ b);
 }
 
-// Check that flipping one bit in plaintext or key
+// Check that flipping one bit in plaintext
 // causes large, unpredictable changes in ciphertext.
-TEST("Blowfish Avalanche Effect") {
+TEST("Blowfish Plaintext Avalanche Effect") {
   Blowfish bf("key");
 
   uint32_t L = 0x11223344, R = 0x55667788;
@@ -32,3 +32,34 @@ TEST("Blowfish Avalanche Effect") {
     EXPECT_TRUE(hd > 20); // Strong avalanche threshold
   }
 }
+
+// Check that flipping one bit in the key
+// causes large, unpredictable changes in ciphertext.
+TEST("Blowfish Key Avalanche Effect") {
+  uint8_t basekey[8] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF};
+  uint32_t L = 0x11223344, R = 0x55667788;
+
+  Blowfish bf_base;
+  bf_base.initialize(basekey, 8);
+  uint32_t Lc = L, Rc = R;
+  bf_base.encrypt(Lc, Rc);
+  uint64_t C1 = (uint64_t(Lc) << 32) | Rc;
+
+  for (int byte = 0; byte < 8; ++byte) {
+    for (int bit = 0; bit < 8; ++bit) {
+      uint8_t flipped[8];
+      std::copy(basekey, basekey + 8, flipped);
+      flipped[byte] ^= (1u << bit);
+
+      Blowfish bf_flip;
+      bf_flip.initialize(flipped, 8);
+
+      uint32_t L2 = L, R2 = R;
+      bf_flip.encrypt(L2, R2);
+      uint64_t C2 = (uint64_t(L2) << 32) | R2;
+
+      int hd = hamming(C1, C2);
+      EXPECT_TRUE(hd > 20);
+    }
+  }
+}