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>
Merge pull request #8 from avinal/avinal/robust-tests
2026-07-04 04:10:09 +05:30 · 2026-04-15 18:21:01 +05:30 · 2025-12-07 15:13:55 +05:30 · 2025-12-06 18:23:08 +05:30
16 changed files with 812 additions and 202 deletions
@@ -29,7 +29,7 @@ target_include_directories(blowfish PUBLIC ${BF_INCLUDE_DIR})

 # ===== blowfish2 library =====
 add_library(blowfish2)
-target_compile_features(blowfish2 PUBLIC cxx_std_14)
+target_compile_features(blowfish2 PUBLIC cxx_std_17)

 target_sources(blowfish2
    PRIVATE
@@ -43,12 +43,30 @@ target_include_directories(blowfish2 PUBLIC ${BF_INCLUDE_DIR})

 # ===== Tests =====
 include(CTest)
-if(BUILD_TESTING)
-    add_executable(bf_test tests/Main.cpp)
-    target_link_libraries(bf_test PRIVATE blowfish)
-    add_test(NAME bf_test COMMAND bf_test)
+if (BUILD_TESTING)

-    add_executable(bf2_test tests/Main2.cpp)
+    # ---- Blowfish Test ----
+    add_executable(bf_test
+        tests/Main.cpp
+        tests/test_framework.h
+        tests/test_vectors.cpp
+        tests/test_roundtrip.cpp
+        tests/test_avalanche.cpp
+        tests/test_properties.cpp
+    )
+    target_link_libraries(bf_test PRIVATE blowfish)
+    add_test(NAME BlowfishTests COMMAND bf_test)
+
+    # ---- Blowfish2 Test ----
+    add_executable(bf2_test
+        tests/Main2.cpp
+        tests/test_framework.h
+        tests/bf2_test_vectors.cpp
+        tests/bf2_test_roundtrip.cpp
+        tests/bf2_test_avalanche.cpp
+        tests/bf2_test_properties.cpp
+    )
    target_link_libraries(bf2_test PRIVATE blowfish2)
-    add_test(NAME bf2_test COMMAND bf2_test)
+    add_test(NAME Blowfish2Tests COMMAND bf2_test)
+
 endif()
@@ -5,19 +5,20 @@
 // SPDX-FileCopyrightText: 1997 Paul Kocher

 #pragma once
-#include <array>
-#include <cstdint>
-#include <string>
-
-#define MAXKEYBYTES 56 // 448 bits max
-static constexpr uint32_t N = 16;

 #if !defined(BLOWFISH_BLOWFISH_H_)
 #define BLOWFISH_BLOWFISH_H_

+#include <array>
+#include <cstdint>
+#include <string>
+
+static constexpr uint32_t BF_NUM_ROUNDS = 16;
+static constexpr uint32_t BF_MAX_KEYBYTES = 56;
+
 class Blowfish {
 private:
-  std::array<uint32_t, N + 2> PArray{};
+  std::array<uint32_t, BF_NUM_ROUNDS + 2> PArray{};
  std::array<std::array<uint32_t, 256>, 4> Sboxes{};
  uint32_t F(uint32_t x) const noexcept;

@@ -25,6 +26,7 @@ public:
  Blowfish() = default;
  explicit Blowfish(std::string const &key);
  Blowfish(Blowfish const &) = delete;
+  Blowfish &operator=(const Blowfish &) = delete;

  void initialize(const uint8_t *key, size_t keylen);
  void initialize(const std::string &key);
@@ -5,19 +5,20 @@
 // SPDX-FileCopyrightText: 2005 Alexander Pukall

 #pragma once
-#include <array>
-#include <cstdint>
-#include <string>
-
-#define MAXKEYBYTES 56 // 448 bits max

 #if !defined(BLOWFISH_BLOWFISH2_H_)
 #define BLOWFISH_BLOWFISH2_H_

+#include <array>
+#include <cstdint>
+#include <string>
+
+static constexpr uint64_t BF2_NUM_ROUNDS = 64;
+static constexpr uint64_t BF2_MAX_KEYBYTES = 56;
+
 class Blowfish2 {
 private:
-  static constexpr uint64_t N = 64;
-  std::array<uint64_t, N + 2> PArray{};
+  std::array<uint64_t, BF2_NUM_ROUNDS + 2> PArray{};
  std::array<std::array<uint64_t, 256>, 8> Sboxes{};
  uint64_t F(uint64_t x) const noexcept;

@@ -33,6 +34,7 @@ public:

  void encrypt(uint64_t &xl, uint64_t &xr) noexcept;
  void decrypt(uint64_t &xl, uint64_t &xr) noexcept;
+  ~Blowfish2();
 };

 #endif // BLOWFISH_BLOWFISH2_H_
@@ -5,14 +5,15 @@
 // SPDX-FileCopyrightText: 1997 Paul Kocher

 #include <blowfish/blowfish.h>
+#include <stdexcept>

-static const std::array<uint32_t, 16 + 2> P = {
+static const std::array<uint32_t, 16 + 2> BF_PARRAY_INIT = {
    0x243F6A88L, 0x85A308D3L, 0x13198A2EL, 0x03707344L, 0xA4093822L,
    0x299F31D0L, 0x082EFA98L, 0xEC4E6C89L, 0x452821E6L, 0x38D01377L,
    0xBE5466CFL, 0x34E90C6CL, 0xC0AC29B7L, 0xC97C50DDL, 0x3F84D5B5L,
    0xB5470917L, 0x9216D5D9L, 0x8979FB1BL};

-static const std::array<std::array<uint32_t, 256>, 4> S = {
+static const std::array<std::array<uint32_t, 256>, 4> BF_SBOX_INIT = {
    {{0xD1310BA6L, 0x98DFB5ACL, 0x2FFD72DBL, 0xD01ADFB7L, 0xB8E1AFEDL,
      0x6A267E96L, 0xBA7C9045L, 0xF12C7F99L, 0x24A19947L, 0xB3916CF7L,
      0x0801F2E2L, 0x858EFC16L, 0x636920D8L, 0x71574E69L, 0xA458FEA3L,
@@ -226,23 +227,27 @@ static const std::array<std::array<uint32_t, 256>, 4> S = {
      0x3AC372E6L}}};

 void Blowfish::initialize(const uint8_t *key, size_t keylen) {
+  if (key == nullptr || keylen == 0 || keylen > BF_MAX_KEYBYTES)
+    throw std::invalid_argument(
+        "Blowfish key must be non-null and between 1 and 56 bytes");
+
  uint32_t data = 0;
  uint32_t datal = 0;
  uint32_t datar = 0;

-  Sboxes = S;
+  Sboxes = BF_SBOX_INIT;

  size_t j = 0;
-  for (uint32_t i = 0; i < N + 2; ++i) {
+  for (uint32_t i = 0; i < BF_NUM_ROUNDS + 2; ++i) {
    data = 0;
    for (uint32_t k = 0; k < 4; ++k) {
      data = (data << 8) | key[j];
      j = (j + 1) % keylen;
    }
-    PArray[i] = P[i] ^ data;
+    PArray[i] = BF_PARRAY_INIT[i] ^ data;
  }

-  for (uint32_t i = 0; i < N + 2; i += 2) {
+  for (uint32_t i = 0; i < BF_NUM_ROUNDS + 2; i += 2) {
    encrypt(datal, datar);
    PArray[i] = datal;
    PArray[i + 1] = datar;
@@ -282,15 +287,15 @@ void Blowfish::encrypt(uint32_t &xl, uint32_t &xr) noexcept {
  uint32_t Xl = xl;
  uint32_t Xr = xr;

-  for (uint32_t i = 0; i < N; ++i) {
+  for (uint32_t i = 0; i < BF_NUM_ROUNDS; ++i) {
    Xl ^= PArray[i];
    Xr = F(Xl) ^ Xr;
    std::swap(Xl, Xr);
  }

  std::swap(Xl, Xr);
-  Xr ^= PArray[N];
-  Xl ^= PArray[N + 1];
+  Xr ^= PArray[BF_NUM_ROUNDS];
+  Xl ^= PArray[BF_NUM_ROUNDS + 1];
  xl = Xl;
  xr = Xr;
 }
@@ -299,7 +304,7 @@ void Blowfish::decrypt(uint32_t &xl, uint32_t &xr) noexcept {
  uint32_t Xl = xl;
  uint32_t Xr = xr;

-  for (int i = N + 1; i >= 2; --i) {
+  for (int i = BF_NUM_ROUNDS + 1; i >= 2; --i) {
    Xl ^= PArray[i];
    Xr ^= F(Xl);
    std::swap(Xl, Xr);
@@ -312,8 +317,12 @@ void Blowfish::decrypt(uint32_t &xl, uint32_t &xr) noexcept {
  xr = Xr;
 }
 Blowfish::~Blowfish() {
-  std::fill(PArray.begin(), PArray.end(), 0);
+  volatile uint32_t *p = PArray.data();
+  for (size_t i = 0; i < PArray.size(); ++i)
+    p[i] = 0;
  for (auto &row : Sboxes) {
-    std::fill(row.begin(), row.end(), 0);
+    volatile uint32_t *s = row.data();
+    for (size_t i = 0; i < row.size(); ++i)
+      s[i] = 0;
  }
 }
@@ -5,8 +5,9 @@
 // SPDX-FileCopyrightText: 2005 Alexander Pukall

 #include <blowfish/blowfish2.h>
+#include <stdexcept>

-static const std::array<uint64_t, 64 + 2> P = {
+static const std::array<uint64_t, 64 + 2> BF2_PARRAY_INIT = {
    0x243F6A8885A308D3, 0x13198A2E03707344, 0xA4093822299F31D0,
    0x082EFA98EC4E6C89, 0x452821E638D01377, 0xBE5466CF34E90C6C,
    0xC0AC29B7C97C50DD, 0x3F84D5B5B5470917, 0x9216D5D98979FB1B,
@@ -30,7 +31,7 @@ static const std::array<uint64_t, 64 + 2> P = {
    0x1BFEDF72429B023D, 0x37D0D724D00A1248, 0xDB0FEAD349F1C09B,
    0x075372C980991B7B, 0x25D479D8F6E8DEF7, 0xE3FE501AB6794C3B};

-static const std::array<std::array<uint64_t, 256>, 8> S = {
+static const std::array<std::array<uint64_t, 256>, 8> BF2_SBOX_INIT = {
    {{0x976CE0BD04C006BA, 0xC1A94FB6409F60C4, 0x5E5C9EC2196A2463,
      0x68FB6FAF3E6C53B5, 0x1339B2EB3B52EC6F, 0x6DFC511F9B30952C,
      0xCC814544AF5EBD09, 0xBEE3D004DE334AFD, 0x660F2807192E4BB3,
@@ -732,24 +733,28 @@ void Blowfish2::initialize(const std::string &key) {
 }

 void Blowfish2::initialize(const uint8_t *key, size_t keylen) {
+  if (key == nullptr || keylen == 0 || keylen > BF2_MAX_KEYBYTES)
+    throw std::invalid_argument(
+        "Blowfish2 key must be non-null and between 1 and 56 bytes");
+
  uint64_t data = 0;
  uint64_t datal = 0;
  uint64_t datar = 0;

-  Sboxes = S; // assumes static const S exists
+  Sboxes = BF2_SBOX_INIT;

  size_t j = 0;

-  for (uint64_t i = 0; i < N + 2; ++i) {
+  for (uint64_t i = 0; i < BF2_NUM_ROUNDS + 2; ++i) {
    data = 0;
    for (uint64_t k = 0; k < 8; ++k) {
      data = (data << 8) | key[j];
      j = (j + 1) % keylen;
    }
-    PArray[i] = P[i] ^ data;
+    PArray[i] = BF2_PARRAY_INIT[i] ^ data;
  }

-  for (uint64_t i = 0; i < N + 2; i += 2) {
+  for (uint64_t i = 0; i < BF2_NUM_ROUNDS + 2; i += 2) {
    encrypt(datal, datar);
    PArray[i] = datal;
    PArray[i + 1] = datar;
@@ -798,15 +803,15 @@ void Blowfish2::encrypt(uint64_t &xl, uint64_t &xr) noexcept {
  uint64_t Xl = xl;
  uint64_t Xr = xr;

-  for (uint64_t i = 0; i < N; ++i) {
+  for (uint64_t i = 0; i < BF2_NUM_ROUNDS; ++i) {
    Xl ^= PArray[i];
    Xr = F(Xl) ^ Xr;
    std::swap(Xl, Xr);
  }

  std::swap(Xl, Xr);
-  Xr ^= PArray[N];
-  Xl ^= PArray[N + 1];
+  Xr ^= PArray[BF2_NUM_ROUNDS];
+  Xl ^= PArray[BF2_NUM_ROUNDS + 1];
  xl = Xl;
  xr = Xr;
 }
@@ -815,7 +820,7 @@ void Blowfish2::decrypt(uint64_t &xl, uint64_t &xr) noexcept {
  uint64_t Xl = xl;
  uint64_t Xr = xr;

-  for (uint64_t i = N + 1; i > 1; --i) {
+  for (uint64_t i = BF2_NUM_ROUNDS + 1; i > 1; --i) {
    Xl ^= PArray[i];
    Xr = F(Xl) ^ Xr;
    std::swap(Xl, Xr);
@@ -827,3 +832,14 @@ void Blowfish2::decrypt(uint64_t &xl, uint64_t &xr) noexcept {
  xl = Xl;
  xr = Xr;
 }
+
+Blowfish2::~Blowfish2() {
+  volatile uint64_t *p = PArray.data();
+  for (size_t i = 0; i < PArray.size(); ++i)
+    p[i] = 0;
+  for (auto &row : Sboxes) {
+    volatile uint64_t *s = row.data();
+    for (size_t i = 0; i < row.size(); ++i)
+      s[i] = 0;
+  }
+}
@@ -1,58 +1,6 @@
-#include <iostream>
+// SPDX-FileCopyrightText: 2025 Avinal Kumar avinal.xlvii@gmail.com
+// SPDX-License-Identifier: MIT

-#include <blowfish/blowfish.h>
+#include "test_framework.h"

-std::string from_uint(uint32_t sh) {
-  std::string re("");
-  for (int i = 0; i < 4; i++) {
-    re += (unsigned char)(sh >> i * 8);
-  }
-  return re;
-}
-
-int main(int argc, char const *argv[]) {
-  std::string key("test@pass47");
-  std::string message("My name is Avinal and I am cute");
-  std::string cipher("");
-  int len = message.length();
-  int j = sizeof(uint32_t);
-  int rem =
-      ((len > j * 2) ? (((len / j * 2) + 1) * j * 2 - len) : (j * 2 - len));
-  message.append(rem, '\0');
-  len = message.length();
-  Blowfish blowfish(key);
-  std::cout << "My message is: " << message << std::endl;
-  uint32_t lm, rm;
-  for (size_t i = 0; i < len; i += 8) {
-    lm = 0;
-    rm = 0;
-    lm = *reinterpret_cast<unsigned int *>(
-        const_cast<char *>(message.substr(i, j).c_str()));
-    rm = *reinterpret_cast<unsigned int *>(
-        const_cast<char *>(message.substr(i + 4, j).c_str()));
-    blowfish.encrypt(lm, rm);
-    cipher += from_uint(lm) + from_uint(rm);
-  }
-  std::cout << cipher << std::endl;
-  std::string decipher("");
-  len = cipher.length();
-  std::cout << "length: " << len << std::endl;
-  for (size_t i = 0; i < len; i += 8) {
-    lm = 0;
-    rm = 0;
-    lm = *reinterpret_cast<unsigned int *>(
-        const_cast<char *>(cipher.substr(i, 4).c_str()));
-    rm = *reinterpret_cast<unsigned int *>(
-        const_cast<char *>(cipher.substr(i + 4, 4).c_str()));
-    blowfish.decrypt(lm, rm);
-    decipher += from_uint(lm) + from_uint(rm);
-  }
-
-  std::cout << decipher << std::endl;
-  if (message == decipher) {
-    std::cout << "Test successful!" << std::endl;
-    return 0;
-  } else {
-    return 1;
-  }
-}
+int main() { return tests_summary(); }
@@ -1,105 +1,6 @@
-#include <cstdint>
-#include <iostream>
+// SPDX-FileCopyrightText: 2025 Avinal Kumar avinal.xlvii@gmail.com
+// SPDX-License-Identifier: MIT

-#include <blowfish/blowfish2.h>
-#include <ostream>
+#include "test_framework.h"

-std::string from_uint(uint64_t sh) {
-  std::string re("");
-  for (int i = 0; i < 8; i++) {
-    re += (unsigned char)(sh >> i * 8);
-  }
-  return re;
-}
-
-uint64_t to_uint(std::string &s, size_t index, size_t size) {
-  return *reinterpret_cast<uint64_t *>(
-      const_cast<char *>(s.substr(index, size).c_str()));
-}
-
-int main(int argc, char const *argv[]) {
-  std::string key("test@pass47");
-  std::string message("My name is Avinal and I am cute and smart");
-  std::string cipher("");
-  int len = message.length();
-  int J = sizeof(uint64_t);
-  int rem =
-      ((len > J * 2) ? (((len / J * 2) + 1) * J * 2 - len) : (J * 2 - len));
-  message.append(rem, '\0');
-  len = message.length();
-
-  Blowfish2 blowfish(key);
-
-  std::cout << "My message is: " << message << J << std::endl;
-  uint64_t L = 0, R = 0;
-  for (size_t i = 0; i < len; i += 16) {
-    L = to_uint(message, i, J);
-    R = to_uint(message, i + J, J);
-    blowfish.encrypt(L, R);
-    cipher += from_uint(L) + from_uint(R);
-  }
-  std::cout << "Cipher: " << cipher << std::endl;
-
-  std::string decipher("");
-  len = cipher.length();
-  std::cout << "length: " << len << std::endl;
-  for (size_t i = 0; i < len; i += 16) {
-    L = to_uint(cipher, i, J);
-    R = to_uint(cipher, i + J, J);
-    blowfish.decrypt(L, R);
-    decipher += from_uint(L) + from_uint(R);
-  }
-  if (message == decipher) {
-    std::cout << "Test OK." << std::endl;
-  } else {
-    std::cout << "Test failed." << std::endl;
-  }
-  // C Blowfish 2 tests
-
-  L = 0x0000000000000001, R = 0x0000000000000002;
-
-  blowfish.initialize("TESTKEY");
-  blowfish.encrypt(L, R);
-  if (L == 0x7B2B9DE71D1B1C62 && R == 0x91C230351177BEE8)
-    std::cout << "Test encryption OK." << std::endl;
-  else
-    std::cout << "Test encryption failed." << std::endl;
-
-  blowfish.decrypt(L, R);
-  if (L == 1 && R == 2)
-    std::cout << "Test decryption OK." << std::endl;
-  else
-    std::cout << "Test decryption failed." << std::endl;
-
-  L = 0x0102030405060708;
-  R = 0x0910111213141516;
-
-  blowfish.initialize("A");
-  blowfish.encrypt(L, R);
-  if (L == 0xCA38165603F9915C && R == 0x61F0776A0F55E807)
-    std::cout << "Test encryption OK." << std::endl;
-  else
-    std::cout << "Test encryption failed." << std::endl;
-
-  blowfish.decrypt(L, R);
-  if (L == 0x0102030405060708 && R == 0x0910111213141516)
-    std::cout << "Test decryption OK." << std::endl;
-  else
-    std::cout << "Test decryption failed." << std::endl;
-
-  L = 0x0102030405060708;
-  R = 0x0910111213141516;
-
-  blowfish.initialize("B");
-  blowfish.encrypt(L, R);
-  if (L == 0xD07690A78B109983 && R == 0x8DDF85826F2366C2)
-    std::cout << "Test encryption OK." << std::endl;
-  else
-    std::cout << "Test encryption failed." << std::endl;
-
-  blowfish.decrypt(L, R);
-  if (L == 0x0102030405060708 && R == 0x0910111213141516)
-    std::cout << "Test decryption OK." << std::endl;
-  else
-    std::cout << "Test decryption failed." << std::endl;
-}
+int main() { return tests_summary(); }
@@ -0,0 +1,64 @@
+// SPDX-FileCopyrightText: 2025 Avinal Kumar avinal.xlvii@gmail.com
+// SPDX-License-Identifier: MIT
+
+#include "test_framework.h"
+#include <blowfish/blowfish2.h>
+
+static int hamming128(uint64_t a1, uint64_t b1, uint64_t a2, uint64_t b2) {
+  return __builtin_popcountll(a1 ^ a2) + __builtin_popcountll(b1 ^ b2);
+}
+
+// Check that flipping one bit in plaintext
+// causes large, unpredictable changes in ciphertext.
+TEST("Blowfish2 Plaintext Avalanche Effect") {
+  Blowfish2 bf("key-for-avalanche");
+
+  uint64_t L = 0x1122334455667788ULL;
+  uint64_t R = 0x99AABBCCDDEEFF00ULL;
+
+  uint64_t L0 = L, R0 = R;
+  bf.encrypt(L0, R0);
+
+  for (int bit = 0; bit < 64; ++bit) {
+    uint64_t Lf = L ^ (1ULL << bit);
+    uint64_t Rf = R;
+
+    uint64_t L1 = Lf, R1 = Rf;
+    bf.encrypt(L1, R1);
+
+    int hd = hamming128(L0, R0, L1, R1);
+
+    // Expect large hamming distance: ideally >40 for Blowfish2
+    EXPECT_TRUE(hd > 40);
+  }
+}
+
+// Check that flipping one bit in the key
+// causes large, unpredictable changes in ciphertext.
+TEST("Blowfish2 Key Avalanche Effect") {
+  uint8_t basekey[8] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF};
+  uint64_t L = 0x1122334455667788ULL;
+  uint64_t R = 0x99AABBCCDDEEFF00ULL;
+
+  Blowfish2 bf_base;
+  bf_base.initialize(basekey, 8);
+  uint64_t L0 = L, R0 = R;
+  bf_base.encrypt(L0, R0);
+
+  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);
+
+      Blowfish2 bf_flip;
+      bf_flip.initialize(flipped, 8);
+
+      uint64_t L1 = L, R1 = R;
+      bf_flip.encrypt(L1, R1);
+
+      int hd = hamming128(L0, R0, L1, R1);
+      EXPECT_TRUE(hd > 40);
+    }
+  }
+}
@@ -0,0 +1,172 @@
+// SPDX-FileCopyrightText: 2025 Avinal Kumar avinal.xlvii@gmail.com
+// SPDX-License-Identifier: MIT
+
+#include "test_framework.h"
+#include <blowfish/blowfish2.h>
+#include <stdexcept>
+
+TEST("Blowfish2 varying key lengths") {
+  uint64_t L = 0xDEADBEEFCAFEBABEULL, R = 0x0123456789ABCDEFULL;
+
+  // 1-byte key (minimum)
+  {
+    Blowfish2 bf;
+    bf.initialize(reinterpret_cast<const uint8_t *>("A"), 1);
+    uint64_t l = L, r = R;
+    bf.encrypt(l, r);
+    EXPECT_TRUE(l != L || r != R);
+    bf.decrypt(l, r);
+    EXPECT_EQ(l, L);
+    EXPECT_EQ(r, R);
+  }
+
+  // 56-byte key (maximum)
+  {
+    const uint8_t maxkey[56] = {
+        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A,
+        0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14,
+        0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E,
+        0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
+        0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32,
+        0x33, 0x34, 0x35, 0x36, 0x37, 0x38};
+    Blowfish2 bf;
+    bf.initialize(maxkey, 56);
+    uint64_t l = L, r = R;
+    bf.encrypt(l, r);
+    EXPECT_TRUE(l != L || r != R);
+    bf.decrypt(l, r);
+    EXPECT_EQ(l, L);
+    EXPECT_EQ(r, R);
+  }
+
+  // Different key lengths produce different ciphertext
+  {
+    Blowfish2 bf4, bf8;
+    bf4.initialize(reinterpret_cast<const uint8_t *>("ABCD"), 4);
+    bf8.initialize(reinterpret_cast<const uint8_t *>("ABCDEFGH"), 8);
+    uint64_t l4 = L, r4 = R, l8 = L, r8 = R;
+    bf4.encrypt(l4, r4);
+    bf8.encrypt(l8, r8);
+    EXPECT_TRUE(l4 != l8 || r4 != r8);
+  }
+}
+
+TEST("Blowfish2 rejects invalid keys") {
+  bool caught = false;
+
+  // Empty key
+  try {
+    Blowfish2 bf("");
+    (void)bf;
+  } catch (const std::invalid_argument &) {
+    caught = true;
+  }
+  EXPECT_TRUE(caught);
+
+  // Over-length key (57 bytes)
+  caught = false;
+  try {
+    Blowfish2 bf;
+    uint8_t bigkey[57] = {};
+    bf.initialize(bigkey, 57);
+  } catch (const std::invalid_argument &) {
+    caught = true;
+  }
+  EXPECT_TRUE(caught);
+
+  // Null pointer
+  caught = false;
+  try {
+    Blowfish2 bf;
+    bf.initialize(nullptr, 8);
+  } catch (const std::invalid_argument &) {
+    caught = true;
+  }
+  EXPECT_TRUE(caught);
+}
+
+TEST("Blowfish2 edge-case blocks") {
+  Blowfish2 bf("edge-test-2");
+
+  // All-zero block
+  {
+    uint64_t L = 0, R = 0;
+    uint64_t L2 = L, R2 = R;
+    bf.encrypt(L2, R2);
+    EXPECT_TRUE(L2 != 0 || R2 != 0);
+    bf.decrypt(L2, R2);
+    EXPECT_EQ(L2, L);
+    EXPECT_EQ(R2, R);
+  }
+
+  // All-ones block
+  {
+    uint64_t L = 0xFFFFFFFFFFFFFFFFULL, R = 0xFFFFFFFFFFFFFFFFULL;
+    uint64_t L2 = L, R2 = R;
+    bf.encrypt(L2, R2);
+    EXPECT_TRUE(L2 != L || R2 != R);
+    bf.decrypt(L2, R2);
+    EXPECT_EQ(L2, L);
+    EXPECT_EQ(R2, R);
+  }
+}
+
+TEST("Blowfish2 cross-instance consistency") {
+  Blowfish2 bf1("same-key-2");
+  Blowfish2 bf2("same-key-2");
+
+  uint64_t L = 0xAAAAAAAAAAAAAAAAULL, R = 0x5555555555555555ULL;
+  uint64_t L1 = L, R1 = R, L2 = L, R2 = R;
+  bf1.encrypt(L1, R1);
+  bf2.encrypt(L2, R2);
+  EXPECT_EQ(L1, L2);
+  EXPECT_EQ(R1, R2);
+}
+
+TEST("Blowfish2 re-initialization") {
+  Blowfish2 bf("key-one");
+
+  uint64_t L = 0x1111111111111111ULL, R = 0x2222222222222222ULL;
+  uint64_t L1 = L, R1 = R;
+  bf.encrypt(L1, R1);
+
+  bf.initialize("key-two");
+  uint64_t L2 = L, R2 = R;
+  bf.encrypt(L2, R2);
+
+  EXPECT_TRUE(L1 != L2 || R1 != R2);
+
+  bf.decrypt(L2, R2);
+  EXPECT_EQ(L2, L);
+  EXPECT_EQ(R2, R);
+}
+
+TEST("Blowfish2 no fixed points") {
+  Blowfish2 bf("fixed-point-check");
+
+  for (uint64_t i = 1; i < 50; ++i) {
+    uint64_t L = i * 0x123456789ABCDEFULL;
+    uint64_t R = i * 0xFEDCBA987654321ULL;
+
+    uint64_t L2 = L, R2 = R;
+    bf.encrypt(L2, R2);
+
+    EXPECT_TRUE(!(L == L2 && R == R2));
+  }
+}
+
+TEST("Blowfish2 no short cycles") {
+  Blowfish2 bf("cycle-check");
+
+  for (uint64_t seed = 1; seed <= 5; ++seed) {
+    uint64_t L0 = seed;
+    uint64_t R0 = seed * 12345;
+
+    uint64_t L = L0, R = R0;
+
+    for (int iter = 0; iter < 12; ++iter) {
+      bf.encrypt(L, R);
+      EXPECT_TRUE(!(L == L0 && R == R0));
+    }
+  }
+}
@@ -0,0 +1,26 @@
+// SPDX-FileCopyrightText: 2025 Avinal Kumar avinal.xlvii@gmail.com
+// SPDX-License-Identifier: MIT
+
+#include "test_framework.h"
+#include <blowfish/blowfish2.h>
+#include <random>
+
+// Ensure encrypt -> decrypt returns original plaintext
+// for fixed and randomized test blocks.
+TEST("Blowfish2 encrypt/decrypt roundtrip") {
+  Blowfish2 bf("test-key-2");
+
+  std::mt19937_64 rng(987654321ULL);
+
+  for (int i = 0; i < 400; ++i) {
+    uint64_t L = rng();
+    uint64_t R = rng();
+
+    uint64_t L2 = L, R2 = R;
+    bf.encrypt(L2, R2);
+    bf.decrypt(L2, R2);
+
+    EXPECT_EQ(L, L2);
+    EXPECT_EQ(R, R2);
+  }
+}
@@ -0,0 +1,25 @@
+// SPDX-FileCopyrightText: 2025 Avinal Kumar avinal.xlvii@gmail.com
+// SPDX-License-Identifier: MIT
+
+#include "test_framework.h"
+#include <blowfish/blowfish2.h>
+
+// Known Answer Tests (KAT): Validate Blowfish output against fixed reference
+// vectors to ensure algorithmic correctness.
+TEST("Blowfish2 Known Answer Vector")
+{
+    Blowfish2 bf("abcdefghijklmnopqrstuvwxyz");
+
+    uint64_t L = 0x424C4F5742463231ULL; // "BLOWBF21" (just a stable block)
+    uint64_t R = 0x4649534832463231ULL; // "FISH2F21"
+
+    uint64_t Lc = L, Rc = R;
+    bf.encrypt(Lc, Rc);
+
+    EXPECT_EQ(Lc, 0xF69E30BC3A4E8B0AULL);
+    EXPECT_EQ(Rc, 0x31E5F507F5412293ULL);
+
+    bf.decrypt(Lc, Rc);
+    EXPECT_EQ(Lc, L);
+    EXPECT_EQ(Rc, R);
+}
@@ -0,0 +1,65 @@
+// SPDX-FileCopyrightText: 2025 Avinal Kumar avinal.xlvii@gmail.com
+// SPDX-License-Identifier: MIT
+
+#include "test_framework.h"
+#include <blowfish/blowfish.h>
+
+static int hamming(uint64_t a, uint64_t b) {
+  return __builtin_popcountll(a ^ b);
+}
+
+// Check that flipping one bit in plaintext
+// causes large, unpredictable changes in ciphertext.
+TEST("Blowfish Plaintext Avalanche Effect") {
+  Blowfish bf("key");
+
+  uint32_t L = 0x11223344, R = 0x55667788;
+  uint32_t Lc = L, Rc = R;
+
+  bf.encrypt(Lc, Rc);
+  uint64_t C1 = (uint64_t(Lc) << 32) | Rc;
+
+  for (int bit = 0; bit < 32; ++bit) {
+    uint32_t Lflip = L ^ (1u << bit);
+    uint32_t Rflip = R;
+
+    uint32_t L2 = Lflip, R2 = Rflip;
+    bf.encrypt(L2, R2);
+
+    uint64_t C2 = (uint64_t(L2) << 32) | R2;
+
+    int hd = hamming(C1, C2);
+    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);
+    }
+  }
+}
@@ -0,0 +1,87 @@
+// SPDX-FileCopyrightText: 2025 Avinal Kumar avinal.xlvii@gmail.com
+// SPDX-License-Identifier: MIT
+
+#pragma once
+#include <functional>
+#include <iostream>
+#include <string>
+#include <vector>
+
+inline int g_failures = 0;
+
+struct TestCase {
+  std::string name;
+  std::function<void()> fn;
+};
+
+inline std::vector<TestCase> &test_registry() {
+  static std::vector<TestCase> r;
+  return r;
+}
+
+/* helper to build unique identifiers from __LINE__ */
+#define TEST_CONCAT_INNER(a, b) a##b
+#define TEST_CONCAT(a, b) TEST_CONCAT_INNER(a, b)
+
+/*
+   Usage:
+     TEST("Some name with spaces") { ... }
+*/
+#define TEST(name)                                                             \
+  static void TEST_CONCAT(test_func_, __LINE__)();                             \
+  static bool TEST_CONCAT(test_reg_, __LINE__) = []() {                        \
+    test_registry().push_back({name, TEST_CONCAT(test_func_, __LINE__)});      \
+    return true;                                                               \
+  }();                                                                         \
+  static void TEST_CONCAT(test_func_, __LINE__)()
+
+#define EXPECT_EQ(a, b)                                                        \
+  do {                                                                         \
+    if ((a) != (b)) {                                                          \
+      std::cout << "[FAILED] " << __FILE__ << ":" << __LINE__ << ": expected " \
+                << #a << " == " << #b << " but got " << (a) << "\n";           \
+      ++g_failures;                                                            \
+    }                                                                          \
+  } while (0)
+
+#define EXPECT_NE(a, b)                                                        \
+  do {                                                                         \
+    if ((a) == (b)) {                                                          \
+      std::cout << "[FAILED] " << __FILE__ << ":" << __LINE__ << ": expected " \
+                << #a << " != " << #b << "\n";                                 \
+      ++g_failures;                                                            \
+    }                                                                          \
+  } while (0)
+
+#define EXPECT_TRUE(a)                                                         \
+  do {                                                                         \
+    if (!(a)) {                                                                \
+      std::cout << "[FAILED] " << __FILE__ << ":" << __LINE__                  \
+                << ": expected true: " << #a << "\n";                          \
+      ++g_failures;                                                            \
+    }                                                                          \
+  } while (0)
+
+inline int tests_summary() {
+  std::cout << "Running " << test_registry().size() << " tests...\n";
+  for (auto &t : test_registry()) {
+    std::cout << "[ RUN     ] " << t.name << "\n";
+    try {
+      t.fn();
+    } catch (const std::exception &e) {
+      std::cout << "[  ERROR  ] exception: " << e.what() << "\n";
+      ++g_failures;
+    } catch (...) {
+      std::cout << "[  ERROR  ] unknown exception\n";
+      ++g_failures;
+    }
+    std::cout << "[   DONE  ] " << t.name << "\n";
+  }
+
+  if (g_failures == 0)
+    std::cout << "\nAll tests passed \\^_^/\n";
+  else
+    std::cout << "\n" << g_failures << " tests failed /^.^\\\n";
+
+  return g_failures;
+}
@@ -0,0 +1,187 @@
+// SPDX-FileCopyrightText: 2025 Avinal Kumar avinal.xlvii@gmail.com
+// SPDX-License-Identifier: MIT
+
+#include "test_framework.h"
+#include <blowfish/blowfish.h>
+#include <stdexcept>
+
+// Test edge-case blocks, key lengths, symmetry,
+// and consistency across instances.
+
+TEST("Blowfish varying key lengths") {
+  uint32_t L = 0xDEADBEEF, R = 0xCAFEBABE;
+
+  // 1-byte key (minimum)
+  {
+    Blowfish bf;
+    bf.initialize(reinterpret_cast<const uint8_t *>("A"), 1);
+    uint32_t l = L, r = R;
+    bf.encrypt(l, r);
+    EXPECT_TRUE(l != L || r != R);
+    bf.decrypt(l, r);
+    EXPECT_EQ(l, L);
+    EXPECT_EQ(r, R);
+  }
+
+  // 56-byte key (maximum)
+  {
+    const uint8_t maxkey[56] = {
+        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A,
+        0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14,
+        0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E,
+        0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
+        0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32,
+        0x33, 0x34, 0x35, 0x36, 0x37, 0x38};
+    Blowfish bf;
+    bf.initialize(maxkey, 56);
+    uint32_t l = L, r = R;
+    bf.encrypt(l, r);
+    EXPECT_TRUE(l != L || r != R);
+    bf.decrypt(l, r);
+    EXPECT_EQ(l, L);
+    EXPECT_EQ(r, R);
+  }
+
+  // Different key lengths produce different ciphertext
+  {
+    Blowfish bf4, bf8;
+    bf4.initialize(reinterpret_cast<const uint8_t *>("ABCD"), 4);
+    bf8.initialize(reinterpret_cast<const uint8_t *>("ABCDEFGH"), 8);
+    uint32_t l4 = L, r4 = R, l8 = L, r8 = R;
+    bf4.encrypt(l4, r4);
+    bf8.encrypt(l8, r8);
+    EXPECT_TRUE(l4 != l8 || r4 != r8);
+  }
+}
+
+TEST("Blowfish rejects invalid keys") {
+  bool caught = false;
+
+  // Empty key
+  try {
+    Blowfish bf("");
+    (void)bf;
+  } catch (const std::invalid_argument &) {
+    caught = true;
+  }
+  EXPECT_TRUE(caught);
+
+  // Over-length key (57 bytes)
+  caught = false;
+  try {
+    Blowfish bf;
+    uint8_t bigkey[57] = {};
+    bf.initialize(bigkey, 57);
+  } catch (const std::invalid_argument &) {
+    caught = true;
+  }
+  EXPECT_TRUE(caught);
+
+  // Null pointer
+  caught = false;
+  try {
+    Blowfish bf;
+    bf.initialize(nullptr, 8);
+  } catch (const std::invalid_argument &) {
+    caught = true;
+  }
+  EXPECT_TRUE(caught);
+}
+
+TEST("Blowfish edge-case blocks") {
+  Blowfish bf("edge-test");
+
+  // All-zero block
+  {
+    uint32_t L = 0, R = 0;
+    uint32_t L2 = L, R2 = R;
+    bf.encrypt(L2, R2);
+    EXPECT_TRUE(L2 != 0 || R2 != 0);
+    bf.decrypt(L2, R2);
+    EXPECT_EQ(L2, L);
+    EXPECT_EQ(R2, R);
+  }
+
+  // All-ones block
+  {
+    uint32_t L = 0xFFFFFFFF, R = 0xFFFFFFFF;
+    uint32_t L2 = L, R2 = R;
+    bf.encrypt(L2, R2);
+    EXPECT_TRUE(L2 != L || R2 != R);
+    bf.decrypt(L2, R2);
+    EXPECT_EQ(L2, L);
+    EXPECT_EQ(R2, R);
+  }
+
+  // L == R
+  {
+    uint32_t L = 0x12345678, R = 0x12345678;
+    uint32_t L2 = L, R2 = R;
+    bf.encrypt(L2, R2);
+    bf.decrypt(L2, R2);
+    EXPECT_EQ(L2, L);
+    EXPECT_EQ(R2, R);
+  }
+}
+
+TEST("Blowfish cross-instance consistency") {
+  Blowfish bf1("same-key");
+  Blowfish bf2("same-key");
+
+  uint32_t L = 0xAAAAAAAA, R = 0x55555555;
+  uint32_t L1 = L, R1 = R, L2 = L, R2 = R;
+  bf1.encrypt(L1, R1);
+  bf2.encrypt(L2, R2);
+  EXPECT_EQ(L1, L2);
+  EXPECT_EQ(R1, R2);
+}
+
+TEST("Blowfish re-initialization") {
+  Blowfish bf("key-one");
+
+  uint32_t L = 0x11111111, R = 0x22222222;
+  uint32_t L1 = L, R1 = R;
+  bf.encrypt(L1, R1);
+
+  bf.initialize("key-two");
+  uint32_t L2 = L, R2 = R;
+  bf.encrypt(L2, R2);
+
+  // Different keys must produce different ciphertext
+  EXPECT_TRUE(L1 != L2 || R1 != R2);
+
+  // Roundtrip still works after re-init
+  bf.decrypt(L2, R2);
+  EXPECT_EQ(L2, L);
+  EXPECT_EQ(R2, R);
+}
+
+TEST("Blowfish no fixed points") {
+  Blowfish bf("key1");
+
+  for (uint32_t i = 1; i < 20; ++i) {
+    uint32_t L = i * 0x12345678u;
+    uint32_t R = i * 0x9ABCDEF0u;
+
+    uint32_t L2 = L, R2 = R;
+    bf.encrypt(L2, R2);
+
+    EXPECT_TRUE(!(L2 == L && R2 == R));
+  }
+}
+
+TEST("Blowfish no short encryption cycles") {
+  Blowfish bf("another-key");
+
+  for (uint32_t seed = 1; seed < 10; ++seed) {
+    uint32_t L = seed * 0x11111111u;
+    uint32_t R = seed * 0xAAAAAAAAu;
+
+    uint32_t a = L, b = R;
+
+    for (int i = 0; i < 10; ++i) {
+      bf.encrypt(a, b);
+      EXPECT_TRUE(!(a == L && b == R));
+    }
+  }
+}
@@ -0,0 +1,27 @@
+// SPDX-FileCopyrightText: 2025 Avinal Kumar avinal.xlvii@gmail.com
+// SPDX-License-Identifier: MIT
+
+#include "test_framework.h"
+#include <blowfish/blowfish.h>
+#include <random>
+
+// Ensure encrypt -> decrypt returns original plaintext
+// for fixed and randomized test blocks.
+TEST("Blowfish encrypt/decrypt roundtrip") {
+  Blowfish bf("test-key");
+
+  std::mt19937_64 rng(12345);
+
+  for (int i = 0; i < 500; ++i) {
+    uint64_t block = rng();
+    uint32_t L = block >> 32;
+    uint32_t R = block & 0xFFFFFFFFu;
+
+    uint32_t L2 = L, R2 = R;
+    bf.encrypt(L2, R2);
+    bf.decrypt(L2, R2);
+
+    EXPECT_EQ(L, L2);
+    EXPECT_EQ(R, R2);
+  }
+}
@@ -0,0 +1,61 @@
+// SPDX-FileCopyrightText: 2025 Avinal Kumar avinal.xlvii@gmail.com
+// SPDX-License-Identifier: MIT
+
+#include "test_framework.h"
+#include <blowfish/blowfish.h>
+
+// Known Answer Tests (KAT): Validate Blowfish output against fixed reference
+// vectors to ensure algorithmic correctness.
+TEST("Blowfish Known Test Vectors") {
+  Blowfish bf("abcdefghijklmnopqrstuvwxyz");
+
+  uint32_t L = 0x424C4F57; // "BLOW"
+  uint32_t R = 0x46495348; // "FISH"
+
+  bf.encrypt(L, R);
+  EXPECT_EQ(L, 0x324ED0FE);
+  EXPECT_EQ(R, 0xF413A203);
+
+  bf.decrypt(L, R);
+  EXPECT_EQ(L, 0x424C4F57);
+  EXPECT_EQ(R, 0x46495348);
+}
+
+// Eric Young test vectors — official Blowfish KAT from Schneier's reference.
+// Each entry: { key (hex bytes), plaintext_L, plaintext_R, cipher_L, cipher_R }
+TEST("Blowfish Eric Young Test Vectors") {
+  struct TestVector {
+    const uint8_t key[8];
+    size_t keylen;
+    uint32_t plain_l, plain_r;
+    uint32_t cipher_l, cipher_r;
+  };
+
+  // Subset of the published Eric Young / SSLeay test vectors
+  static const TestVector vectors[] = {
+      {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+       8, 0x00000000, 0x00000000, 0x4EF99745, 0x6198DD78},
+      {{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
+       8, 0xFFFFFFFF, 0xFFFFFFFF, 0x51866FD5, 0xB85ECB8A},
+      {{0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+       8, 0x10000000, 0x00000001, 0x7D856F9A, 0x613063F2},
+      {{0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
+       8, 0x11111111, 0x11111111, 0x61F9C380, 0x2281B096},
+      {{0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10},
+       8, 0x01234567, 0x89ABCDEF, 0x0ACEAB0F, 0xC6A0A28D},
+  };
+
+  for (const auto &v : vectors) {
+    Blowfish bf;
+    bf.initialize(v.key, v.keylen);
+
+    uint32_t L = v.plain_l, R = v.plain_r;
+    bf.encrypt(L, R);
+    EXPECT_EQ(L, v.cipher_l);
+    EXPECT_EQ(R, v.cipher_r);
+
+    bf.decrypt(L, R);
+    EXPECT_EQ(L, v.plain_l);
+    EXPECT_EQ(R, v.plain_r);
+  }
+}