X-Git-Url: https://git.cryptolib.org/?p=avr-crypto-lib.git;a=blobdiff_plain;f=test_src%2Fmain-rsaes_pkcs1v15-test.c;h=ad2ecae206a472e48335ba78f6a4343107980506;hp=efea72c122c0596e4915e822c4dbf9200b3ba1ca;hb=4b5da1dc27a791b5c448274a3db09cd035b33493;hpb=cc6b183296a5852449e3324737e2a2dece788786

diff --git a/test_src/main-rsaes_pkcs1v15-test.c b/test_src/main-rsaes_pkcs1v15-test.c
index efea72c..ad2ecae 100644
--- a/test_src/main-rsaes_pkcs1v15-test.c
+++ b/test_src/main-rsaes_pkcs1v15-test.c
@@ -1,7 +1,7 @@
 /* main-dsa-test.c */
 /*
     This file is part of the ARM-Crypto-Lib.
-    Copyright (C) 2010 Daniel Otte (daniel.otte@rub.de)
+    Copyright (C) 2006-2015 Daniel Otte (bg@nerilex.org)
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -32,9 +32,9 @@
 
 #include "performance_test.h"
 
-#define DEBUG 0
+#define DEBUG 1
 
-const char* algo_name = "RSAES-PKCS1V15";
+const char *algo_name = "RSAES-PKCS1V15";
 
 #define BIGINT_CEIL(x) ((((x) + sizeof(bigint_word_t) - 1) / sizeof(bigint_word_t)) *  sizeof(bigint_word_t))
 #define BIGINT_OFF(x) ((sizeof(bigint_word_t) - (x) % sizeof(bigint_word_t)) % sizeof(bigint_word_t))
@@ -174,7 +174,7 @@ uint8_t convert_nibble(uint8_t c){
 
 const char *block_ignore_string=" \t\r\n,;";
 #define BUFFER_LIMIT 120
-uint16_t read_os(void* dst, uint16_t length, const char* ignore_string){
+uint16_t read_os(void *dst, uint16_t length, const char *ignore_string){
 	uint16_t counter = 0;
 	uint16_t c;
 	uint8_t v, tmp = 0, idx = 0;
@@ -207,7 +207,7 @@ uint16_t read_os(void* dst, uint16_t length, const char* ignore_string){
 	return counter;
 }
 
-uint16_t own_atou(const char* str){
+uint16_t own_atou(const char *str){
 	uint16_t r=0;
 	while(*str && *str >= '0' && *str <= '9'){
 		r *= 10;
@@ -216,7 +216,7 @@ uint16_t own_atou(const char* str){
 	return r;
 }
 
-uint8_t read_bigint(bigint_t* a, char* prompt){
+uint8_t read_bigint(bigint_t *a, char *prompt){
 	uint16_t read_length, actual_length;
 	uint8_t off;
 	uint8_t *buffer;
@@ -240,13 +240,113 @@ uint8_t read_bigint(bigint_t* a, char* prompt){
 		return 1;
 	}
 	a->wordv = (bigint_word_t*)buffer;
-	a->length_B = (read_length + sizeof(bigint_word_t) - 1) / sizeof(bigint_word_t);
+	a->length_W = (read_length + sizeof(bigint_word_t) - 1) / sizeof(bigint_word_t);
 	a->info = 0;
 	bigint_changeendianess(a);
 	bigint_adjust(a);
 	return 0;
 }
 
+uint8_t pre_alloc_key_crt(void){
+	priv_key.n = 5;
+	priv_key.components = malloc(5 * sizeof(bigint_t));
+	if(!priv_key.components){
+		cli_putstr_P(PSTR("\r\nERROR: OOM!"));
+		return 2;
+	}
+	return 0;
+}
+
+void free_key(void){
+	uint8_t c;
+	free(pub_key.modulus.wordv);
+	free(pub_key.exponent.wordv);
+	for(c = 0; c < priv_key.n; ++c){
+		free(priv_key.components[c].wordv);
+	}
+	free(priv_key.components);
+	keys_allocated = 0;
+}
+
+uint8_t read_key_crt(void){
+	uint8_t r;
+	cli_putstr_P(PSTR("\r\n== reading key (crt) =="));
+	r = pre_alloc_key_crt();
+	if(r) return r;
+	r = read_bigint(&pub_key.modulus,"\r\n = module =");
+	if(r) return r;
+	memcpy(&priv_key.modulus, &pub_key.modulus, sizeof(bigint_t));
+	r = read_bigint(&pub_key.exponent,"\r\n = public exponent =");
+	if(r) return r;
+	r = read_bigint(&(priv_key.components[0]),"\r\n = p (first prime) =");
+	if(r) return r;
+	r = read_bigint(&(priv_key.components[1]),"\r\n = q (second prime) =");
+	if(r) return r;
+	r = read_bigint(&(priv_key.components[2]),"\r\n = dp (p's exponent) =");
+	if(r) return r;
+	r = read_bigint(&(priv_key.components[3]),"\r\n = dq (q's exponent) =");
+	if(r) return r;
+	r = read_bigint(&(priv_key.components[4]),"\r\n = qInv (q' coefficient) =");
+	return r;
+}
+
+uint8_t read_key_conv(void){
+	uint8_t r;
+	priv_key.components = malloc(sizeof(bigint_t));
+	if(!priv_key.components){
+		cli_putstr_P(PSTR("\r\nERROR: OOM!"));
+		return 2;
+	}
+	cli_putstr_P(PSTR("\r\n== reading key (conv) =="));
+	r = read_bigint(&pub_key.modulus,"\r\n = module =");
+	if(r) return r;
+	memcpy(&priv_key.modulus, &pub_key.modulus, sizeof(bigint_t));
+	priv_key.n = 1;
+	r = read_bigint(&pub_key.exponent,"\r\n = public exponent =");
+	if(r) return r;
+	r = read_bigint(priv_key.components,"\r\n = private exponent =");
+	return r;
+}
+
+uint8_t load_bigint_from_os(bigint_t *a, PGM_VOID_P os, uint16_t length_B){
+	a->length_W = BIGINT_CEIL(length_B) / sizeof(bigint_word_t);
+	a->wordv = malloc(BIGINT_CEIL(length_B));
+	if(!a->wordv){
+		cli_putstr_P(PSTR("\r\nOOM!\r\n"));
+		return 1;
+	}
+	memset(a->wordv, 0, sizeof(bigint_word_t));
+	memcpy_P((uint8_t*)a->wordv + BIGINT_OFF(length_B), os, length_B);
+	a->info = 0;
+	bigint_changeendianess(a);
+	bigint_adjust(a);
+	return 0;
+}
+
+void load_fix_rsa(void){
+	if(keys_allocated){
+		free_key();
+	}
+	keys_allocated = 1;
+
+	if(pre_alloc_key_crt()){
+		cli_putstr_P(PSTR("\r\nOOM!\r\n"));
+		return;
+	}
+
+	load_bigint_from_os(&pub_key.modulus, MODULUS, sizeof(MODULUS));
+	memcpy(&priv_key.modulus, &pub_key.modulus, sizeof(bigint_t));
+	load_bigint_from_os(&pub_key.exponent, PUB_EXPONENT, sizeof(PUB_EXPONENT));
+	priv_key.n = 5;
+	load_bigint_from_os(&(priv_key.components[0]), P, sizeof(P));
+	load_bigint_from_os(&(priv_key.components[1]), Q, sizeof(Q));
+	load_bigint_from_os(&(priv_key.components[2]), DP, sizeof(DP));
+	load_bigint_from_os(&(priv_key.components[3]), DQ, sizeof(DQ));
+	load_bigint_from_os(&(priv_key.components[4]), QINV, sizeof(QINV));
+}
+
+/*
+
 uint8_t pre_alloc_key_crt(void){
 	uint8_t c;
 	pub_key.modulus = malloc(sizeof(bigint_t));
@@ -374,8 +474,8 @@ void load_priv_conventional(void){
 		cli_putstr_P(PSTR("\r\nERROR: OOM!"));
 		return;
 	}
-	epriv->length_B = (sizeof(PRIV_EXPONENT) + sizeof(bigint_word_t) - 1) / sizeof(bigint_word_t);
-	epriv->wordv =  malloc(epriv->length_B * sizeof(bigint_word_t));
+	epriv->length_W = (sizeof(PRIV_EXPONENT) + sizeof(bigint_word_t) - 1) / sizeof(bigint_word_t);
+	epriv->wordv =  malloc(epriv->length_W * sizeof(bigint_word_t));
 	if(!epriv->wordv){
 		cli_putstr_P(PSTR("\r\nERROR: OOM!"));
 		return;
@@ -408,8 +508,8 @@ void load_priv_crt_mono(void){
 	for(i=0; i<5; ++i){
 		v[i] = malloc(sizeof(bigint_t));
 		v[i]->info = 0;
-		v[i]->length_B = (sv[i] + sizeof(bigint_word_t) - 1) / sizeof(bigint_word_t);
-		v[i]->wordv = calloc(v[i]->length_B , sizeof(bigint_word_t));
+		v[i]->length_W = (sv[i] + sizeof(bigint_word_t) - 1) / sizeof(bigint_word_t);
+		v[i]->wordv = calloc(v[i]->length_W , sizeof(bigint_word_t));
 		if(!v[i]->wordv){
 			cli_putstr_P(PSTR("\r\nERROR: OOM!"));
 			return;
@@ -421,8 +521,8 @@ void load_priv_crt_mono(void){
 	}
 }
 
-uint8_t load_bigint_from_os(bigint_t* a, PGM_VOID_P os, uint16_t length_B){
-	a->length_B = BIGINT_CEIL(length_B) / sizeof(bigint_word_t);
+uint8_t load_bigint_from_os(bigint_t *a, PGM_VOID_P os, uint16_t length_B){
+	a->length_W = BIGINT_CEIL(length_B) / sizeof(bigint_word_t);
 	a->wordv = malloc(BIGINT_CEIL(length_B));
 	if(!a->wordv){
 		cli_putstr_P(PSTR("\r\nOOM!\r\n"));
@@ -459,6 +559,7 @@ void load_fix_rsa(void){
 //	load_priv_conventional();
 //	load_priv_crt_mono();
 }
+*/
 
 void quick_test(void){
 	uint8_t *ciphertext, *plaintext, rc;
@@ -467,8 +568,8 @@ void quick_test(void){
 	if(!keys_allocated){
 		load_fix_rsa();
 	}
-	ciphertext = malloc(clen = pub_key.modulus->length_B * sizeof(bigint_word_t));
-	plaintext = malloc(pub_key.modulus->length_B * sizeof(bigint_word_t));
+	ciphertext = malloc(clen = bigint_length_B(&pub_key.modulus));
+	plaintext = malloc(clen);
 	memcpy_P(plaintext, MSG, sizeof(MSG));
 	memcpy_P(seed, SEED, sizeof(SEED));
 	cli_putstr_P(PSTR("\r\nplaintext:"));
@@ -487,11 +588,13 @@ void quick_test(void){
 
 	cli_putstr_P(PSTR("\r\n\r\nciphertext:"));
 	cli_hexdump_block(ciphertext, clen, 4, 16);
-	if(clen!=sizeof(ENCRYPTED)){
+	if(clen != sizeof(ENCRYPTED)){
 			cli_putstr_P(PSTR("\r\n>>FAIL (no size match)<<"));
+			return;
 	}else{
 		if(memcmp_P(ciphertext, ENCRYPTED, clen)){
 			cli_putstr_P(PSTR("\r\n>>FAIL (no content match)<<"));
+			return;
 		}else{
 			cli_putstr_P(PSTR("\r\n>>OK<<"));
 		}
@@ -525,7 +628,7 @@ void run_seed_test(void){
 	cli_putstr_P(PSTR("\r\n  length: "));
 	cli_getsn(read_int_str, 16);
 	msg_len = own_atou(read_int_str);
-	seed_len = rsa_pkcs1v15_compute_padlength_B(pub_key.modulus, msg_len);
+	seed_len = rsa_pkcs1v15_compute_padlength_B(&pub_key.modulus, msg_len);
 	seed = malloc(seed_len);
 #if DEBUG
 	cli_putstr_P(PSTR("\r\nDBG: @seed: 0x"));
@@ -553,7 +656,7 @@ void run_seed_test(void){
 		cli_putstr_P(PSTR("\r\nERROR: OOM!"));
 		return;
 	}
-	ciph = malloc(bigint_length_B(pub_key.modulus));
+	ciph = malloc(bigint_length_B(&pub_key.modulus));
 #if DEBUG
 	cli_putstr_P(PSTR("\r\nDBG: @ciph: 0x"));
 	cli_hexdump_rev(&ciph, 2);
@@ -562,7 +665,7 @@ void run_seed_test(void){
 		cli_putstr_P(PSTR("\r\nERROR: OOM!"));
 		return;
 	}
-	msg_ = malloc(bigint_length_B(pub_key.modulus) + sizeof(bigint_word_t));
+	msg_ = malloc(bigint_length_B(&pub_key.modulus) /* + sizeof(bigint_word_t) */ );
 #if DEBUG
 	cli_putstr_P(PSTR("\r\nDBG: @msg_: 0x"));
 	cli_hexdump_rev(&msg_, 2);
@@ -587,14 +690,14 @@ void run_seed_test(void){
 */
 #if DEBUG
 	cli_putstr_P(PSTR("\r\n  first prime:"));
-	bigint_print_hex(priv_key.components[0]);
+	bigint_print_hex(&priv_key.components[0]);
 #endif
 	rsa_encrypt_pkcs1v15(ciph, &ciph_len, msg, msg_len, &pub_key, seed);
 	cli_putstr_P(PSTR("\r\n  ciphertext:"));
 	cli_hexdump_block(ciph, ciph_len, 4, 16);
 #if DEBUG
 	cli_putstr_P(PSTR("\r\n  first prime:"));
-	bigint_print_hex(priv_key.components[0]);
+	bigint_print_hex(&priv_key.components[0]);
 #endif
 	cli_putstr_P(PSTR("\r\n  decrypting ... "));
 
@@ -671,7 +774,7 @@ void test_dump(void){
 	cli_putstr_P(PSTR("\r\ndumping 0x"));
 	cli_hexdump_rev(&len, 2);
 	cli_putstr_P(PSTR(" byte:"));
-	cli_hexdump_block(pub_key.modulus->wordv, len, 4, 8);
+	cli_hexdump_block(pub_key.modulus.wordv, len, 4, 8);
 }
 
 /*****************************************************************************