Improve Error Handling to Prevent Exit, Crashes and Memory Leaks

scripts/copy_from_upstream/src/kem/family/kem_scheme.c

@@ -11,7 +11,7 @@
 {% endif %}
 OQS_KEM *OQS_KEM_{{ family }}_{{ scheme['scheme'] }}_new(void) {
 
-	OQS_KEM *kem = malloc(sizeof(OQS_KEM));
+	OQS_KEM *kem = OQS_MEM_malloc(sizeof(OQS_KEM));
 	if (kem == NULL) {
 		return NULL;
 	}
@@ -42,7 +42,7 @@ OQS_KEM *OQS_KEM_{{ family }}_{{ scheme['scheme'] }}_new(void) {
 /** Alias */
 OQS_KEM *OQS_KEM_{{ family }}_{{ scheme['alias_scheme'] }}_new(void) {
 
-	OQS_KEM *kem = malloc(sizeof(OQS_KEM));
+	OQS_KEM *kem = OQS_MEM_malloc(sizeof(OQS_KEM));
 	if (kem == NULL) {
 		return NULL;
 	}

scripts/copy_from_upstream/src/sig/family/sig_scheme.c

@@ -11,7 +11,7 @@
 {% endif %}
 OQS_SIG *OQS_SIG_{{ family }}_{{ scheme['scheme'] }}_new(void) {
 
-	OQS_SIG *sig = malloc(sizeof(OQS_SIG));
+	OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
 	if (sig == NULL) {
 		return NULL;
 	}
@@ -41,7 +41,7 @@ OQS_SIG *OQS_SIG_{{ family }}_{{ scheme['scheme'] }}_new(void) {
 /** Alias */
 OQS_SIG *OQS_SIG_{{ family }}_{{ scheme['alias_scheme'] }}_new(void) {
 
-	OQS_SIG *sig = malloc(sizeof(OQS_SIG));
+	OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
 	if (sig == NULL) {
 		return NULL;
 	}

scripts/copy_from_upstream/tests/kat_sig.c/combine_message_signature.fragment

@@ -3,7 +3,7 @@
 {%- if scheme['signed_msg_order'] == 'sig_then_msg' %}
 		// signed_msg = signature || msg
 		*signed_msg_len = signature_len + msg_len;
-		*signed_msg = malloc(*signed_msg_len);
+		*signed_msg = OQS_MEM_malloc(*signed_msg_len);
 		if (*signed_msg == NULL) {
 			return OQS_ERROR;
 		}
@@ -13,7 +13,7 @@
 {%- elif scheme['signed_msg_order'] == 'msg_then_sig' %}
 		// signed_msg = msg || signature
 		*signed_msg_len = msg_len + signature_len;
-		*signed_msg = malloc(*signed_msg_len);
+		*signed_msg = OQS_MEM_malloc(*signed_msg_len);
 		if (*signed_msg == NULL) {
 			return OQS_ERROR;
 		}
@@ -24,7 +24,7 @@
 		// signed_msg = sig_len (2 bytes, big endian) || nonce (40 bytes) || msg || 0x29 || sig
 		const uint16_t signature_len_uint16 = (uint16_t)signature_len;
 		*signed_msg_len = 2 + signature_len_uint16 + msg_len;
-		*signed_msg = malloc(*signed_msg_len);
+		*signed_msg = OQS_MEM_malloc(*signed_msg_len);
 		if (*signed_msg == NULL) {
 			return OQS_ERROR;
 		}
@@ -44,7 +44,7 @@
 		// signed_msg = sig_len (2 bytes, big endian) || nonce (40 bytes) || msg || 0x2A || sig
 		const uint16_t signature_len_uint16 = (uint16_t)signature_len;
 		*signed_msg_len = 2 + signature_len + msg_len;
-		*signed_msg = malloc(*signed_msg_len);
+		*signed_msg = OQS_MEM_malloc(*signed_msg_len);
 		if (*signed_msg == NULL) {
 			return OQS_ERROR;
 		}

src/common/aes/aes.c

@@ -12,73 +12,109 @@
 static struct OQS_AES_callbacks *callbacks = &aes_default_callbacks;
 
 OQS_API void OQS_AES_set_callbacks(struct OQS_AES_callbacks *new_callbacks) {
-	callbacks = new_callbacks;
+	if (new_callbacks != NULL) {
+		callbacks = new_callbacks;
+	}
 }
 
 void OQS_AES128_ECB_load_schedule(const uint8_t *key, void **schedule) {
-	callbacks->AES128_ECB_load_schedule(key, schedule);
+	if (key != NULL && schedule != NULL) {
+		callbacks->AES128_ECB_load_schedule(key, schedule);
+	}
 }
 
 void OQS_AES128_CTR_inc_init(const uint8_t *key, void **_schedule) {
-	callbacks->AES128_CTR_inc_init(key, _schedule);
+	if (key != NULL && _schedule != NULL) {
+		callbacks->AES128_CTR_inc_init(key, _schedule);
+	}
 }
 
 void OQS_AES128_CTR_inc_iv(const uint8_t *iv, size_t iv_len, void *_schedule) {
-	callbacks->AES128_CTR_inc_iv(iv, iv_len, _schedule);
+	if (iv != NULL && _schedule != NULL) {
+		callbacks->AES128_CTR_inc_iv(iv, iv_len, _schedule);
+	}
 }
 
 void OQS_AES128_CTR_inc_ivu64(uint64_t iv, void *_schedule) {
-	callbacks->AES128_CTR_inc_ivu64(iv, _schedule);
+	if (_schedule != NULL) {
+		callbacks->AES128_CTR_inc_ivu64(iv, _schedule);
+	}
 }
 
 void OQS_AES128_free_schedule(void *schedule) {
-	callbacks->AES128_free_schedule(schedule);
+	if (schedule != NULL) {
+		callbacks->AES128_free_schedule(schedule);
+	}
 }
 
 void OQS_AES256_ECB_load_schedule(const uint8_t *key, void **schedule) {
-	callbacks->AES256_ECB_load_schedule(key, schedule);
+	if (key != NULL && schedule != NULL) {
+		callbacks->AES256_ECB_load_schedule(key, schedule);
+	}
 }
 
 void OQS_AES256_CTR_inc_init(const uint8_t *key, void **schedule) {
-	callbacks->AES256_CTR_inc_init(key, schedule);
+	if (key != NULL && schedule != NULL) {
+		callbacks->AES256_CTR_inc_init(key, schedule);
+	}
 }
 
 void OQS_AES256_CTR_inc_iv(const uint8_t *iv, size_t iv_len, void *schedule) {
-	callbacks->AES256_CTR_inc_iv(iv, iv_len, schedule);
+	if (iv != NULL && schedule != NULL) {
+		callbacks->AES256_CTR_inc_iv(iv, iv_len, schedule);
+	}
 }
 
 void OQS_AES256_CTR_inc_ivu64(uint64_t iv, void *schedule) {
-	callbacks->AES256_CTR_inc_ivu64(iv, schedule);
+	if (schedule != NULL) {
+		callbacks->AES256_CTR_inc_ivu64(iv, schedule);
+	}
 }
 
 void OQS_AES256_free_schedule(void *schedule) {
-	callbacks->AES256_free_schedule(schedule);
+	if (schedule != NULL) {
+		callbacks->AES256_free_schedule(schedule);
+	}
 }
 
 void OQS_AES128_ECB_enc(const uint8_t *plaintext, const size_t plaintext_len, const uint8_t *key, uint8_t *ciphertext) {
-	callbacks->AES128_ECB_enc(plaintext, plaintext_len, key, ciphertext);
+	if (plaintext != NULL && key != NULL && ciphertext != NULL) {
+		callbacks->AES128_ECB_enc(plaintext, plaintext_len, key, ciphertext);
+	}
 }
 
 void OQS_AES128_ECB_enc_sch(const uint8_t *plaintext, const size_t plaintext_len, const void *schedule, uint8_t *ciphertext) {
-	callbacks->AES128_ECB_enc_sch(plaintext, plaintext_len, schedule, ciphertext);
+	if (plaintext != NULL && schedule != NULL && ciphertext != NULL) {
+		callbacks->AES128_ECB_enc_sch(plaintext, plaintext_len, schedule, ciphertext);
+	}
 }
 
 void OQS_AES128_CTR_inc_stream_iv(const uint8_t *iv, const size_t iv_len, const void *schedule, uint8_t *out, size_t out_len) {
-	callbacks->AES128_CTR_inc_stream_iv(iv, iv_len, schedule, out, out_len);
+	if (iv != NULL && schedule != NULL && out != NULL) {
+		callbacks->AES128_CTR_inc_stream_iv(iv, iv_len, schedule, out, out_len);
+	}
 }
 
 void OQS_AES256_ECB_enc(const uint8_t *plaintext, const size_t plaintext_len, const uint8_t *key, uint8_t *ciphertext) {
-	callbacks->AES256_ECB_enc(plaintext, plaintext_len, key, ciphertext);
+	if (plaintext != NULL && key != NULL && ciphertext != NULL) {
+		callbacks->AES256_ECB_enc(plaintext, plaintext_len, key, ciphertext);
+	}
 }
 
 void OQS_AES256_ECB_enc_sch(const uint8_t *plaintext, const size_t plaintext_len, const void *schedule, uint8_t *ciphertext) {
-	callbacks->AES256_ECB_enc_sch(plaintext, plaintext_len, schedule, ciphertext);
+	if (plaintext != NULL && schedule != NULL && ciphertext != NULL) {
+		callbacks->AES256_ECB_enc_sch(plaintext, plaintext_len, schedule, ciphertext);
+	}
 }
 
 void OQS_AES256_CTR_inc_stream_iv(const uint8_t *iv, const size_t iv_len, const void *schedule, uint8_t *out, size_t out_len) {
-	callbacks->AES256_CTR_inc_stream_iv(iv, iv_len, schedule, out, out_len);
+	if (iv != NULL && schedule != NULL && out != NULL) {
+		callbacks->AES256_CTR_inc_stream_iv(iv, iv_len, schedule, out, out_len);
+	}
 }
 
 void OQS_AES256_CTR_inc_stream_blks(void *schedule, uint8_t *out, size_t out_blks) {
-	callbacks->AES256_CTR_inc_stream_blks(schedule, out, out_blks);
+	if (schedule != NULL && out != NULL) {
+		callbacks->AES256_CTR_inc_stream_blks(schedule, out, out_blks);
+	}
 }

src/common/aes/aes128_armv8.c

@@ -14,14 +14,17 @@ typedef struct {
 } aes128ctx;
 
 void oqs_aes128_load_iv_armv8(const uint8_t *iv, size_t iv_len, void *_schedule) {
+	if (_schedule == NULL) {
+		return;
+	}
 	aes128ctx *ctx = _schedule;
 	if (iv_len == 12) {
 		memcpy(ctx->iv, iv, 12);
 		memset(&ctx->iv[12], 0, 4);
 	} else if (iv_len == 16) {
 		memcpy(ctx->iv, iv, 16);
 	} else {
-		exit(EXIT_FAILURE);
+		return; /* TODO: better error handling */
 	}
 }
 
@@ -63,12 +66,18 @@ static inline void aes128_armv8_encrypt(const unsigned char *rkeys, const unsign
 }
 
 void oqs_aes128_enc_sch_block_armv8(const uint8_t *plaintext, const void *_schedule, uint8_t *ciphertext) {
+	if (_schedule == NULL || plaintext == NULL || ciphertext == NULL) {
+		return;
+	}
 	const unsigned char *schedule = (const unsigned char *) _schedule;
 	aes128_armv8_encrypt(schedule, plaintext, ciphertext);
 }
 
 void oqs_aes128_ecb_enc_sch_armv8(const uint8_t *plaintext, const size_t plaintext_len, const void *schedule, uint8_t *ciphertext) {
 	assert(plaintext_len % 16 == 0);
+	if (schedule == NULL || plaintext == NULL || ciphertext == NULL) {
+		return;
+	}
 	const aes128ctx *ctx = (const aes128ctx *) schedule;
 
 	for (size_t block = 0; block < plaintext_len / 16; block++) {
@@ -91,6 +100,9 @@ static uint32_t UINT32_TO_BE(const uint32_t x) {
 
 
 void oqs_aes128_ctr_enc_sch_upd_blks_armv8(void *schedule, uint8_t *out, size_t out_blks) {
+	if (schedule == NULL || out == NULL) {
+		return;
+	}
 	aes128ctx *ctx = (aes128ctx *) schedule;
 	uint8_t *block = ctx->iv;
 	uint32_t ctr;
@@ -108,6 +120,9 @@ void oqs_aes128_ctr_enc_sch_upd_blks_armv8(void *schedule, uint8_t *out, size_t
 }
 
 void oqs_aes128_ctr_enc_sch_armv8(const uint8_t *iv, const size_t iv_len, const void *schedule, uint8_t *out, size_t out_len) {
+	if (iv == NULL || schedule == NULL || out == NULL) {
+		return;
+	}
 	uint8_t block[16];
 	uint32_t ctr;
 	uint32_t ctr_be;
@@ -118,7 +133,7 @@ void oqs_aes128_ctr_enc_sch_armv8(const uint8_t *iv, const size_t iv_len, const
 		memcpy(&ctr_be, &iv[12], 4);
 		ctr = BE_TO_UINT32(ctr_be);
 	} else {
-		exit(EXIT_FAILURE);
+		return; /* TODO: better error handling */
 	}
 	while (out_len >= 16) {
 		ctr_be = UINT32_TO_BE(ctr);

src/common/aes/aes128_ni.c

@@ -49,14 +49,21 @@ static inline void aes128ni_setkey_encrypt(const unsigned char *key, __m128i rke
 }
 
 void oqs_aes128_load_schedule_ni(const uint8_t *key, void **_schedule) {
-	*_schedule = malloc(sizeof(aes128ctx));
-	OQS_EXIT_IF_NULLPTR(*_schedule, "AES");
-	assert(*_schedule != NULL);
+	if (_schedule == NULL) {
+		return;
+	}
+	*_schedule = OQS_MEM_malloc(sizeof(aes128ctx));
+	if (*_schedule == NULL) {
+		return;
+	}
 	__m128i *schedule = ((aes128ctx *) *_schedule)->sk_exp;
 	aes128ni_setkey_encrypt(key, schedule);
 }
 
 void oqs_aes128_load_iv_ni(const uint8_t *iv, size_t iv_len, void *_schedule) {
+	if (_schedule == NULL) {
+		return;
+	}
 	aes128ctx *ctx = _schedule;
 	__m128i idx = _mm_set_epi8(8, 9, 10, 11, 12, 13, 14, 15, 7, 6, 5, 4, 3, 2, 1, 0);
 	if (iv_len == 12) {
@@ -65,11 +72,14 @@ void oqs_aes128_load_iv_ni(const uint8_t *iv, size_t iv_len, void *_schedule) {
 	} else if (iv_len == 16) {
 		ctx->iv = _mm_shuffle_epi8(_mm_loadu_si128((const __m128i *)iv), idx);
 	} else {
-		exit(EXIT_FAILURE);
+		return; /* TODO: better error handling */
 	}
 }
 
 void oqs_aes128_load_iv_u64_ni(uint64_t iv, void *_schedule) {
+	if (_schedule == NULL) {
+		return;
+	}
 	aes128ctx *ctx = _schedule;
 	ctx->iv = _mm_loadl_epi64((__m128i *)&iv);
 }
@@ -133,18 +143,27 @@ static inline void aes128ni_encrypt_x4(const __m128i rkeys[11], __m128i n0,
 }
 
 void oqs_aes128_enc_sch_block_ni(const uint8_t *plaintext, const void *_schedule, uint8_t *ciphertext) {
+	if (_schedule == NULL) {
+		return;
+	}
 	const __m128i *schedule = ((const aes128ctx *) _schedule)->sk_exp;
 	aes128ni_encrypt(schedule, _mm_loadu_si128((const __m128i *)plaintext), ciphertext);
 }
 
 void oqs_aes128_ecb_enc_sch_ni(const uint8_t *plaintext, const size_t plaintext_len, const void *schedule, uint8_t *ciphertext) {
+	if (schedule == NULL) {
+		return;
+	}
 	assert(plaintext_len % 16 == 0);
 	for (size_t block = 0; block < plaintext_len / 16; block++) {
 		oqs_aes128_enc_sch_block_ni(plaintext + (16 * block), schedule, ciphertext + (16 * block));
 	}
 }
 
 void oqs_aes128_ctr_enc_sch_upd_blks_ni(void *schedule, uint8_t *out, size_t out_blks) {
+	if (schedule == NULL) {
+		return;
+	}
 	aes128ctx *ctx = (aes128ctx *) schedule;
 	const __m128i mask = _mm_set_epi8(8, 9, 10, 11, 12, 13, 14, 15, 7, 6, 5, 4, 3, 2, 1, 0);
 
@@ -168,6 +187,9 @@ void oqs_aes128_ctr_enc_sch_upd_blks_ni(void *schedule, uint8_t *out, size_t out
 }
 
 void oqs_aes128_ctr_enc_sch_ni(const uint8_t *iv, const size_t iv_len, const void *schedule, uint8_t *out, size_t out_len) {
+	if (schedule == NULL) {
+		return;
+	}
 	__m128i block;
 	__m128i mask = _mm_set_epi8(8, 9, 10, 11, 12, 13, 14, 15, 7, 6, 5, 4, 3, 2, 1, 0);
 	if (iv_len == 12) {
@@ -176,7 +198,7 @@ void oqs_aes128_ctr_enc_sch_ni(const uint8_t *iv, const size_t iv_len, const voi
 	} else if (iv_len == 16) {
 		block = _mm_loadu_si128((const __m128i *)iv);
 	} else {
-		exit(EXIT_FAILURE);
+		return; /* TODO: better error handling */
 	}
 
 	while (out_len >= 64) {