Fix CMake scalar/field macros and standardize RNG usage in tests.

Author: mrtcnk

CMakeLists.txt

@@ -11,7 +11,7 @@ if (HAVE___INT128)
     set(MPT_ARCH_DEFS SECP256K1_WIDEMUL_INT128 USE_FIELD_5X52 HAVE___INT128)
 else ()
     message(STATUS "Build: No 128-bit support detected. Using generic 32-bit arithmetic.")
-    set(MPT_ARCH_DEFS USE_SCALAR_8X32 USE_FIELD_10X26)
+    set(MPT_ARCH_DEFS SECP256K1_WIDEMUL_INT64 USE_FIELD_10X26)
 endif ()
 
 # --- Find Dependencies ---

tests/test_bulletproof_agg.c

@@ -2,9 +2,7 @@
 #include <string.h>
 #include <stdlib.h>
 #include <time.h>
-#include <openssl/rand.h>
 #include <secp256k1.h>
-
 #include "secp256k1_mpt.h"
 #include "test_utils.h"
 
@@ -24,18 +22,6 @@ static inline double elapsed_ms(struct timespec a, struct timespec b) {
            (b.tv_nsec - a.tv_nsec) / 1e6;
 }
 
-static void random_scalar(
-        const secp256k1_context* ctx,
-        unsigned char out[32]
-) {
-    do {
-        if (RAND_bytes(out, 32) != 1) {
-            fprintf(stderr, "RAND_bytes failed\n");
-            exit(1);
-        }
-    } while (!secp256k1_ec_seckey_verify(ctx, out));
-}
-
 /* ---- Main ---- */
 int main(void) {
     printf("[TEST] Aggregated Bulletproof test (m = %d)\n", M);

tests/test_commitments.c

@@ -2,21 +2,9 @@
 #include <string.h>
 #include <stdlib.h>
 #include "secp256k1_mpt.h"
-#include <openssl/rand.h>
 #include "test_utils.h"
 
-/* --- Helper: Safe Random Scalar Generation --- */
-/* Ensures the random bytes form a valid curve scalar (0 < scalar < order) */
-static void random_scalar(const secp256k1_context* ctx, unsigned char* out) {
-    int ret;
-    do {
-        ret = RAND_bytes(out, 32);
-        EXPECT(ret == 1); // Crash if RNG fails
-    } while (!secp256k1_ec_seckey_verify(ctx, out)); // Retry if scalar is invalid (>= curve order)
-}
-
 /* --- Tests --- */
-
 void test_pedersen_commitment_basic() {
     secp256k1_context* ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);
 

tests/test_elgamal.c

@@ -1,8 +1,7 @@
 #include <stdio.h>
-#include <stdlib.h> // Required for abort()
+#include <stdlib.h>
 #include <string.h>
 #include <secp256k1.h>
-#include <openssl/rand.h>
 #include "secp256k1_mpt.h"
 #include "test_utils.h"
 

tests/test_elgamal_verify.c

@@ -1,18 +1,22 @@
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
-#include <stdlib.h> // Required for abort()
 #include <secp256k1.h>
 #include "secp256k1_mpt.h"
-#include <openssl/rand.h>
 #include "test_utils.h"
 
-void test_elgamal_verify_encryption() {
+int main(void) {
     // 1. Setup Context
     secp256k1_context* ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);
     EXPECT(ctx != NULL);
 
+    // Standardized Context Randomization
+    unsigned char seed[32];
+    random_bytes(seed);
+    EXPECT(secp256k1_context_randomize(ctx, seed) == 1);
+
     unsigned char priv_q[32], r[32], r_bad[32];
-    secp256k1_pubkey pub_q, c1, c2, temp_pubkey;
+    secp256k1_pubkey pub_q, c1, c2;
     uint64_t amount = 12345;
     uint64_t amount_bad = 54321;
 
@@ -21,50 +25,33 @@ void test_elgamal_verify_encryption() {
     // 2. Generate Identity and Randomness
     EXPECT(secp256k1_elgamal_generate_keypair(ctx, priv_q, &pub_q) == 1);
 
-    // Use generate_keypair to get a valid random scalar for 'r' (safer than raw RAND_bytes)
-    EXPECT(secp256k1_elgamal_generate_keypair(ctx, r, &temp_pubkey) == 1);
+    // REFACTOR: Use standard helper instead of generating a full keypair
+    random_scalar(ctx, r);
 
     memcpy(r_bad, r, 32);
     r_bad[31] ^= 0xFF; // Flip bits to create a bad randomness factor
 
     // 3. Perform Encryption
-    // Note: Signature is (ctx, &c1, &c2, &pubkey, amount, r)
     EXPECT(secp256k1_elgamal_encrypt(ctx, &c1, &c2, &pub_q, amount, r) == 1);
     printf("DEBUG: Encryption successful.\n");
 
     // 4. Test Case 1: Valid Verification (The Happy Path)
     int res1 = secp256k1_elgamal_verify_encryption(ctx, &c1, &c2, &pub_q, amount, r);
-    if (res1 == 1) {
-        printf("SUCCESS: Valid encryption correctly verified.\n");
-    } else {
-        printf("FAILURE: Valid encryption failed verification.\n");
-    }
     EXPECT(res1 == 1);
+    printf("SUCCESS: Valid encryption correctly verified.\n");
 
     // 5. Test Case 2: Invalid Amount
     int res2 = secp256k1_elgamal_verify_encryption(ctx, &c1, &c2, &pub_q, amount_bad, r);
-    if (res2 == 0) {
-        printf("SUCCESS: Incorrect amount correctly rejected.\n");
-    } else {
-        printf("FAILURE: Incorrect amount was wrongly accepted!\n");
-    }
     EXPECT(res2 == 0);
+    printf("SUCCESS: Incorrect amount correctly rejected.\n");
 
     // 6. Test Case 3: Invalid Randomness (r)
     int res3 = secp256k1_elgamal_verify_encryption(ctx, &c1, &c2, &pub_q, amount, r_bad);
-    if (res3 == 0) {
-        printf("SUCCESS: Incorrect randomness correctly rejected.\n");
-    } else {
-        printf("FAILURE: Incorrect randomness was wrongly accepted!\n");
-    }
     EXPECT(res3 == 0);
+    printf("SUCCESS: Incorrect randomness correctly rejected.\n");
 
     // 7. Cleanup
     secp256k1_context_destroy(ctx);
     printf("DEBUG: All ElGamal Verification tests passed!\n");
-}
-
-int main() {
-    test_elgamal_verify_encryption();
     return 0;
 }

tests/test_equality_proof.c

@@ -1,16 +1,10 @@
 #include <stdio.h>
-#include <stdlib.h> // Required for abort()
+#include <stdlib.h>
 #include <string.h>
 #include <secp256k1.h>
-#include <openssl/rand.h>
 #include "secp256k1_mpt.h"
 #include "test_utils.h"
 
-// Helper: Generates 32 random bytes (e.g., for randomness or tx_context_id)
-// Now returns void and uses EXPECT internally to enforce success.
-static void get_random_bytes(unsigned char* buffer32) {
-    EXPECT(RAND_bytes(buffer32, 32) == 1);
-}
 
 // Forward declarations for all test functions
 static void test_equality_proof_valid(const secp256k1_context* ctx);
@@ -25,7 +19,7 @@ int main() {
     EXPECT(ctx != NULL);
 
     unsigned char seed[32];
-    get_random_bytes(seed);
+    random_bytes(seed);
     EXPECT(secp256k1_context_randomize(ctx, seed) == 1);
 
     // Run tests for this module
@@ -55,15 +49,15 @@ static void test_equality_proof_valid(const secp256k1_context* ctx) {
 
     // 1. Setup: Generate keys, randomness, and encrypt
     EXPECT(secp256k1_elgamal_generate_keypair(ctx, privkey, &pubkey) == 1);
-    get_random_bytes(randomness_r);
+    random_bytes(randomness_r);
 
     // Ensure randomness is a valid scalar (needed for proof gen)
     while (secp256k1_ec_seckey_verify(ctx, randomness_r) != 1) {
-        get_random_bytes(randomness_r);
+        random_bytes(randomness_r);
     }
 
     EXPECT(secp256k1_elgamal_encrypt(ctx, &c1, &c2, &pubkey, amount, randomness_r) == 1);
-    get_random_bytes(tx_context_id);
+    random_bytes(tx_context_id);
 
     // 2. Generate the proof
     int prove_result = secp256k1_equality_plaintext_prove(
@@ -93,14 +87,14 @@ static void test_equality_proof_invalid_amount(const secp256k1_context* ctx) {
 
     // 1. Setup: Generate keys, randomness, encrypt correct amount
     EXPECT(secp256k1_elgamal_generate_keypair(ctx, privkey, &pubkey) == 1);
-    get_random_bytes(randomness_r);
+    random_bytes(randomness_r);
 
     while (secp256k1_ec_seckey_verify(ctx, randomness_r) != 1) {
-        get_random_bytes(randomness_r);
+        random_bytes(randomness_r);
     }
 
     EXPECT(secp256k1_elgamal_encrypt(ctx, &c1, &c2, &pubkey, correct_amount, randomness_r) == 1);
-    get_random_bytes(tx_context_id);
+    random_bytes(tx_context_id);
 
     // 2. Generate the proof for the correct amount
     EXPECT(secp256k1_equality_plaintext_prove(
@@ -128,14 +122,14 @@ static void test_equality_proof_invalid_tampered(const secp256k1_context* ctx) {
 
     // 1. Setup and generate a valid proof
     EXPECT(secp256k1_elgamal_generate_keypair(ctx, privkey, &pubkey) == 1);
-    get_random_bytes(randomness_r);
+    random_bytes(randomness_r);
 
     while (secp256k1_ec_seckey_verify(ctx, randomness_r) != 1) {
-        get_random_bytes(randomness_r);
+        random_bytes(randomness_r);
     }
 
     EXPECT(secp256k1_elgamal_encrypt(ctx, &c1, &c2, &pubkey, amount, randomness_r) == 1);
-    get_random_bytes(tx_context_id);
+    random_bytes(tx_context_id);
     EXPECT(secp256k1_equality_plaintext_prove(
             ctx, proof, &c1, &c2, &pubkey, amount, randomness_r, tx_context_id) == 1);
 
@@ -163,14 +157,14 @@ static void test_equality_proof_zero_amount(const secp256k1_context* ctx) {
 
     // 1. Setup: Generate keys, randomness, and encrypt
     EXPECT(secp256k1_elgamal_generate_keypair(ctx, privkey, &pubkey) == 1);
-    get_random_bytes(randomness_r);
+    random_bytes(randomness_r);
 
     while (secp256k1_ec_seckey_verify(ctx, randomness_r) != 1) {
-        get_random_bytes(randomness_r);
+        random_bytes(randomness_r);
     }
 
     EXPECT(secp256k1_elgamal_encrypt(ctx, &c1, &c2, &pubkey, amount, randomness_r) == 1);
-    get_random_bytes(tx_context_id);
+    random_bytes(tx_context_id);
 
     // 2. Generate the proof for amount 0
     int prove_result = secp256k1_equality_plaintext_prove(

tests/test_ipa.c

@@ -1,9 +1,7 @@
 #include <stdio.h>
-#include <stdlib.h> // Required for abort()
+#include <stdlib.h>
 #include <string.h>
 #include <secp256k1.h>
-#include <openssl/rand.h>
-#include <openssl/sha.h>
 #include "secp256k1_mpt.h"
 #include "test_utils.h"
 
@@ -77,14 +75,6 @@ extern int secp256k1_bulletproof_ipa_dot(
         size_t n
 );
 
-/* ---- Test Utils ---- */
-
-static void random_scalar(const secp256k1_context* ctx, unsigned char s[32]) {
-    do {
-        EXPECT(RAND_bytes(s, 32) == 1);
-    } while (!secp256k1_ec_seckey_verify(ctx, s));
-}
-
 static int add_term(
         const secp256k1_context* ctx,
         secp256k1_pubkey* acc,

tests/test_link_proof.c

@@ -1,18 +1,10 @@
 #include <stdio.h>
 #include <string.h>
-#include <stdlib.h> // Required for abort()
+#include <stdlib.h>
 #include "secp256k1_mpt.h"
 #include <secp256k1.h>
-#include <openssl/rand.h>
 #include "test_utils.h"
 
-/* --- Helper: Safe Random Scalar Generation --- */
-static void random_scalar(const secp256k1_context* ctx, unsigned char* out) {
-    do {
-        EXPECT(RAND_bytes(out, 32) == 1);
-    } while (!secp256k1_ec_seckey_verify(ctx, out));
-}
-
 void test_link_proof() {
     secp256k1_context* ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);
     EXPECT(ctx != NULL);

tests/test_pok_sk.c

@@ -1,18 +1,10 @@
 #include <stdio.h>
 #include <string.h>
-#include <stdlib.h> // Required for abort()
+#include <stdlib.h>
 #include "secp256k1_mpt.h"
 #include <secp256k1.h>
-#include <openssl/rand.h>
 #include "test_utils.h"
 
-/* --- Helper: Safe Random Scalar Generation --- */
-static void random_scalar(const secp256k1_context* ctx, unsigned char* out) {
-    do {
-        EXPECT(RAND_bytes(out, 32) == 1);
-    } while (!secp256k1_ec_seckey_verify(ctx, out));
-}
-
 void test_pok_sk() {
     secp256k1_context* ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);
     EXPECT(ctx != NULL);