Reorganize to use get/set paradigm

CMakeLists.txt

@@ -137,6 +137,7 @@ endif()
 set(PUBLIC_HEADERS ${PROJECT_SOURCE_DIR}/src/oqs.h
                    ${PROJECT_SOURCE_DIR}/src/common/common.h
                    ${PROJECT_SOURCE_DIR}/src/common/rand/rand.h
+                   ${PROJECT_SOURCE_DIR}/src/common/rand/rand_nist_internal.h
                    ${PROJECT_SOURCE_DIR}/src/common/aes/aes.h
                    ${PROJECT_SOURCE_DIR}/src/common/sha2/sha2.h
                    ${PROJECT_SOURCE_DIR}/src/common/sha3/sha3.h

src/CMakeLists.txt

@@ -54,8 +54,6 @@ add_library(oqs kem/kem.c
                 ${SIG_OBJS}
                 ${COMMON_OBJS})
 set(COMMON_OBJS ${COMMON_OBJS} PARENT_SCOPE)
-set(_ALL_OBJS ${KEM_OBJS} ${SIG_OBJS} ${COMMON_OBJS} $<TARGET_OBJECTS:oqs>)
-set(ALL_OBJS ${_ALL_OBJS} PARENT_SCOPE)
 if(DEFINED SANITIZER_LD_FLAGS)
     target_link_libraries(oqs PUBLIC ${SANITIZER_LD_FLAGS})
 endif()

src/common/rand/rand.h

@@ -70,16 +70,6 @@ OQS_API void OQS_randombytes(uint8_t *random_array, size_t bytes_to_read);
  */
 OQS_API void OQS_randombytes_nist_kat_init_256bit(const uint8_t *entropy_input, const uint8_t *personalization_string);
 
-/**
- * Writes the current state of the NIST DRBG into the provided memory.
- */
-OQS_API void OQS_randombytes_nist_kat_get_state(void *out);
-
-/**
- * Overwrites the current state of the NIST DRBG from the provided memory.
- */
-OQS_API void OQS_randombytes_nist_kat_set_state(const void *in);
-
 #if defined(__cplusplus)
 } // extern "C"
 #endif

src/common/rand/rand_nist.c

@@ -19,6 +19,7 @@ You are solely responsible for determining the appropriateness of using and dist
 
 #include <oqs/common.h>
 #include <oqs/rand.h>
+#include <oqs/rand_nist_internal.h>
 
 #ifdef OQS_USE_OPENSSL
 #include <openssl/conf.h>
@@ -127,22 +128,22 @@ void OQS_randombytes_nist_kat(unsigned char *x, size_t xlen) {
 	DRBG_ctx.reseed_counter++;
 }
 
-OQS_API void OQS_randombytes_nist_kat_get_state(void *out) {
-    AES256_CTR_DRBG_struct *out_state = (AES256_CTR_DRBG_struct *)out;
-    if (out_state != NULL) {
-        memcpy(out_state->Key, DRBG_ctx.Key, sizeof(DRBG_ctx.Key));
-        memcpy(out_state->V, DRBG_ctx.V, sizeof(DRBG_ctx.V));
-        out_state->reseed_counter = DRBG_ctx.reseed_counter;
-    }
+void OQS_randombytes_nist_kat_get_state(void *out) {
+	AES256_CTR_DRBG_struct *out_state = (AES256_CTR_DRBG_struct *)out;
+	if (out_state != NULL) {
+		memcpy(out_state->Key, DRBG_ctx.Key, sizeof(DRBG_ctx.Key));
+		memcpy(out_state->V, DRBG_ctx.V, sizeof(DRBG_ctx.V));
+		out_state->reseed_counter = DRBG_ctx.reseed_counter;
+	}
 }
 
-OQS_API void OQS_randombytes_nist_kat_set_state(const void *in) {
-    AES256_CTR_DRBG_struct *in_state = (AES256_CTR_DRBG_struct *)in;
-    if (in_state != NULL) {
-        memcpy(DRBG_ctx.Key, in_state->Key, sizeof(DRBG_ctx.Key));
-        memcpy(DRBG_ctx.V, in_state->V, sizeof(DRBG_ctx.V));
-        DRBG_ctx.reseed_counter = in_state->reseed_counter;
-    }
+void OQS_randombytes_nist_kat_set_state(const void *in) {
+	AES256_CTR_DRBG_struct *in_state = (AES256_CTR_DRBG_struct *)in;
+	if (in_state != NULL) {
+		memcpy(DRBG_ctx.Key, in_state->Key, sizeof(DRBG_ctx.Key));
+		memcpy(DRBG_ctx.V, in_state->V, sizeof(DRBG_ctx.V));
+		DRBG_ctx.reseed_counter = in_state->reseed_counter;
+	}
 }
 
 static void AES256_CTR_DRBG_Update(unsigned char *provided_data, unsigned char *Key, unsigned char *V) {

src/common/rand/rand_nist_internal.h

@@ -0,0 +1,29 @@
+/**
+ * \file rand_nist_internal.h
+ * \brief Functions for manipulating the state of the NIST DRBG; not part of the OQS public API
+ *
+ * Contains definitions for functions for manipulating the NIST DRBG state, intended to be used
+ * by the kat_kem and kat_sig test programs.
+ *
+ * <b>Note this is not part of the OQS public API: implementations within liboqs can use these
+ * functions, but external consumers of liboqs should not use these functions.</b>
+ *
+ * \author Spencer Wilson
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef OQS_RAND_NIST_INTERNAL_H
+#define OQS_RAND_NIST_INTERNAL_H
+
+/**
+ * Writes the current state of the NIST DRBG into the provided memory.
+ */
+void OQS_randombytes_nist_kat_get_state(void *out);
+
+/**
+ * Overwrites the current state of the NIST DRBG from the provided memory.
+ */
+void OQS_randombytes_nist_kat_set_state(const void *in);
+
+#endif

tests/CMakeLists.txt

@@ -70,9 +70,8 @@ endif()
 add_executable(example_kem example_kem.c)
 target_link_libraries(example_kem PRIVATE ${API_TEST_DEPS})
 
-# KAT KEM needs to call the internal SHA3 functions directly, hence the extra dependencies
-add_executable(kat_kem kat_kem.c test_helpers.c ${ALL_OBJS})
-target_link_libraries(kat_kem PRIVATE ${API_TEST_DEPS} ${INTERNAL_TEST_DEPS})
+add_executable(kat_kem kat_kem.c test_helpers.c)
+target_link_libraries(kat_kem PRIVATE ${API_TEST_DEPS})
 
 add_executable(test_kem test_kem.c)
 target_link_libraries(test_kem PRIVATE ${API_TEST_DEPS})

tests/kat_sig.c

@@ -242,13 +242,13 @@ OQS_STATUS sig_kat(const char *method_name, bool all) {
 	size_t signature_len = 0;
 	size_t signed_msg_len = 0;
 	OQS_STATUS rc, ret = OQS_ERROR;
-    OQS_KAT_PRNG *prng = NULL;
-    int max_count;
+	OQS_KAT_PRNG *prng = NULL;
+	int max_count;
 
-    prng = OQS_KAT_PRNG_new(method_name);
-    if (prng == NULL) {
-        goto err;
-    }
+	prng = OQS_KAT_PRNG_new(method_name);
+	if (prng == NULL) {
+		goto err;
+	}
 
 	sig = OQS_SIG_new(method_name);
 	if (sig == NULL) {
@@ -346,7 +346,7 @@ OQS_STATUS sig_kat(const char *method_name, bool all) {
 	OQS_MEM_insecure_free(signature);
 	OQS_MEM_insecure_free(msg);
 	OQS_SIG_free(sig);
-    OQS_KAT_PRNG_free(prng);
+	OQS_KAT_PRNG_free(prng);
 	return ret;
 }
 

tests/test_helpers.c

@@ -1,9 +1,13 @@
+// SPDX-License-Identifier: MIT
+#include <stddef.h>
+#include <stdio.h>
 #include <string.h>
 
-#include "test_helpers.h"
 #include <oqs/oqs.h>
+#include <oqs/rand_nist_internal.h> // Internal NIST DRBG API
+#include <oqs/sha3.h>               // Internal SHA3 API
 
-#define HQC_PRNG_DOMAIN 1
+#include "test_helpers.h"
 
 /* HQC PRNG implementation */
 
@@ -12,15 +16,15 @@ static OQS_SHA3_shake256_inc_ctx hqc_prng_state = { NULL };
 
 // Allocate the state.
 static void hqc_prng_new(void) {
-    OQS_SHA3_shake256_inc_init(&hqc_prng_state);
+	OQS_SHA3_shake256_inc_init(&hqc_prng_state);
 }
 
 // entropy_input must have length 48.
 // If personalization_string is non-null, its length must also be 48.
 static void hqc_prng_seed(const uint8_t *entropy_input, const uint8_t *personalization_string) {
-	uint8_t domain = HQC_PRNG_DOMAIN;
-    // reset state
-    OQS_SHA3_shake256_inc_ctx_reset(&hqc_prng_state);
+	uint8_t domain = 1;
+	// reset state
+	OQS_SHA3_shake256_inc_ctx_reset(&hqc_prng_state);
 	OQS_SHA3_shake256_inc_absorb(&hqc_prng_state, entropy_input, 48);
 	if (personalization_string != NULL) {
 		OQS_SHA3_shake256_inc_absorb(&hqc_prng_state, personalization_string, 48);
@@ -35,26 +39,25 @@ static void hqc_prng_randombytes(uint8_t *random_array, size_t bytes_to_read) {
 }
 
 static void hqc_prng_get_state(void *out) {
-    OQS_SHA3_shake256_inc_ctx_clone((OQS_SHA3_shake256_inc_ctx *)out, &hqc_prng_state);
+	OQS_SHA3_shake256_inc_ctx_clone((OQS_SHA3_shake256_inc_ctx *)out, &hqc_prng_state);
 }
 
 static void hqc_prng_set_state(const void *in) {
-    OQS_SHA3_shake256_inc_ctx_clone(&hqc_prng_state, (OQS_SHA3_shake256_inc_ctx *)in);
+	OQS_SHA3_shake256_inc_ctx_clone(&hqc_prng_state, (const OQS_SHA3_shake256_inc_ctx *)in);
 }
 
-static void hqc_prng_free(void *saved_state) {
-    OQS_SHA3_shake256_inc_ctx *hqc_saved_state = (OQS_SHA3_shake256_inc_ctx *)saved_state;
-    if (hqc_saved_state != NULL) {
-        OQS_SHA3_shake256_inc_ctx_release(hqc_saved_state);
-    }
-    if (hqc_prng_state.ctx != NULL) {
-        OQS_SHA3_shake256_inc_ctx_release(&hqc_prng_state);
-        hqc_prng_state.ctx = NULL;
-    }
+static void hqc_prng_free(OQS_KAT_PRNG_state *saved_state) {
+	if (saved_state != NULL) {
+		OQS_SHA3_shake256_inc_ctx_release(&saved_state->hqc_state);
+	}
+	if (hqc_prng_state.ctx != NULL) {
+		OQS_SHA3_shake256_inc_ctx_release(&hqc_prng_state);
+		hqc_prng_state.ctx = NULL;
+	}
 }
 
 /* Additional NIST DRBG implementation */
-static void nist_drbg_free(void *saved_state) {}
+static void nist_drbg_free(OQS_KAT_PRNG_state *saved_state) {}
 
 /* Helpers for identifying algorithms */
 static int is_mceliece(const char *method_name) {
@@ -79,67 +82,66 @@ static int is_hqc(const char *method_name) {
 /* OQS_KAT_PRNG interface implementation */
 
 OQS_KAT_PRNG *OQS_KAT_PRNG_new(const char *method_name) {
-    OQS_KAT_PRNG *prng = malloc(sizeof(OQS_KAT_PRNG));
-    if (prng != NULL) {
-        prng->max_kats = is_mceliece(method_name) ? 10 : 100;
-        if (is_hqc(method_name)) {
-            // set randombytes function
-            OQS_randombytes_custom_algorithm(&hqc_prng_randombytes);
-            // reset the PRNG
-            hqc_prng_new();
-            // initialize saved state
-            OQS_SHA3_shake256_inc_init(&prng->saved_state.hqc_state);
-            // TODO set callbacks
-            prng->seed = &hqc_prng_seed;
-            prng->get_state = &hqc_prng_get_state;
-            prng->set_state = &hqc_prng_set_state;
-            prng->free = &hqc_prng_free;
-        } else {
-            // set randombytes function
-            if (OQS_randombytes_switch_algorithm(OQS_RAND_alg_nist_kat) == OQS_SUCCESS) {
-                // TODO set callbacks
-                prng->seed = &OQS_randombytes_nist_kat_init_256bit;
-                prng->get_state = &OQS_randombytes_nist_kat_get_state;
-                prng->set_state = &OQS_randombytes_nist_kat_set_state;
-                prng->free = &nist_drbg_free;
-            } else {
-                OQS_MEM_insecure_free(prng);
-                prng = NULL;
-            }
-        }
-    }
-    return prng;
+	OQS_KAT_PRNG *prng = malloc(sizeof(OQS_KAT_PRNG));
+	if (prng != NULL) {
+		prng->max_kats = is_mceliece(method_name) ? 10 : 100;
+		if (is_hqc(method_name)) {
+			// set randombytes function
+			OQS_randombytes_custom_algorithm(&hqc_prng_randombytes);
+			// reset the PRNG
+			hqc_prng_new();
+			// initialize saved state
+			OQS_SHA3_shake256_inc_init(&prng->saved_state.hqc_state);
+			// TODO set callbacks
+			prng->seed = &hqc_prng_seed;
+			prng->get_state = &hqc_prng_get_state;
+			prng->set_state = &hqc_prng_set_state;
+			prng->free = &hqc_prng_free;
+		} else {
+			// set randombytes function
+			if (OQS_randombytes_switch_algorithm(OQS_RAND_alg_nist_kat) == OQS_SUCCESS) {
+				// TODO set callbacks
+				prng->seed = &OQS_randombytes_nist_kat_init_256bit;
+				prng->get_state = &OQS_randombytes_nist_kat_get_state;
+				prng->set_state = &OQS_randombytes_nist_kat_set_state;
+				prng->free = &nist_drbg_free;
+			} else {
+				OQS_MEM_insecure_free(prng);
+				prng = NULL;
+			}
+		}
+	}
+	return prng;
 }
 
 // entropy_input must have length 48.
 // If personalization_string is non-null, its length must also be 48.
 void OQS_KAT_PRNG_seed(OQS_KAT_PRNG *prng, const uint8_t *entropy_input, const uint8_t *personalization_string) {
-    if (prng != NULL) {
-        prng->seed(entropy_input, personalization_string);
-    }
+	if (prng != NULL) {
+		prng->seed(entropy_input, personalization_string);
+	}
 }
 
 void OQS_KAT_PRNG_save_state(OQS_KAT_PRNG *prng) {
-    if (prng != NULL) {
-        prng->get_state(&prng->saved_state);
-    }
+	if (prng != NULL) {
+		prng->get_state(&prng->saved_state);
+	}
 }
 
 void OQS_KAT_PRNG_restore_state(OQS_KAT_PRNG *prng) {
-    if (prng != NULL) {
-        prng->set_state(&prng->saved_state);
-    }
+	if (prng != NULL) {
+		prng->set_state(&prng->saved_state);
+	}
 }
 
 void OQS_KAT_PRNG_free(OQS_KAT_PRNG *prng) {
-    if (prng != NULL) {
-        // saved_state needs to be handled dynamically
-        prng->free(&prng->saved_state);
-    }
-    OQS_MEM_insecure_free(prng);
+	if (prng != NULL) {
+		// saved_state needs to be handled dynamically
+		prng->free(&prng->saved_state);
+	}
+	OQS_MEM_insecure_free(prng);
 }
 
-
 /* Displays hexadecimal strings */
 void OQS_print_hex_string(const char *label, const uint8_t *str, size_t len) {
 	printf("%-20s (%4zu bytes):  ", label, len);
@@ -160,4 +162,3 @@ void OQS_fprintBstr(FILE *fp, const char *S, const uint8_t *A, size_t L) {
 	}
 	fprintf(fp, "\n");
 }
-

tests/test_helpers.h

@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: MIT
 #ifndef OQS_TEST_HELPERS_H
 #define OQS_TEST_HELPERS_H
 
@@ -8,23 +9,23 @@
 #include <oqs/sha3.h>
 
 typedef union {
-    OQS_SHA3_shake256_inc_ctx hqc_state;
-    // struct definition copied from rand_nist.c
-    struct {
-        unsigned char Key[32];
-        unsigned char V[16];
-        int reseed_counter;
-    } nist_state;
+	OQS_SHA3_shake256_inc_ctx hqc_state;
+	// struct definition copied from rand_nist.c
+	struct {
+		unsigned char Key[32];
+		unsigned char V[16];
+		int reseed_counter;
+	} nist_state;
 } OQS_KAT_PRNG_state;
 
 typedef struct {
-    int max_kats;
-    OQS_KAT_PRNG_state saved_state;
-    // The caller should use the OQS_KAT_PRNG_* functions instead of these callbacks.
+	int max_kats;
+	OQS_KAT_PRNG_state saved_state;
+	// The caller should use the OQS_KAT_PRNG_* functions instead of these callbacks.
 	void (*seed)(const uint8_t *, const uint8_t *);
 	void (*get_state)(void *);
 	void (*set_state)(const void *);
-	void (*free)(void *);
+	void (*free)(OQS_KAT_PRNG_state *);
 } OQS_KAT_PRNG;
 
 OQS_KAT_PRNG *OQS_KAT_PRNG_new(const char *method_name);