");
+ }
+ cli_putstr("\r\n computing signature ... ");
+ dsa_sign_message(&dsa_sig, message, i*8, &sha1_desc, &dsa_ctx, random8);
+ dsa_print_signature(&dsa_sig);
+ cli_putstr("\r\n base64:\r\n--- SIGNATURE ---\r\n ");
+ dsa_print_signature_b64(&dsa_sig);
+ cli_putstr("\r\n verifying signature ... ");
+ t = dsa_verify_message(&dsa_sig, message, i*8, &sha1_desc, &dsa_ctx);
+ cli_putstr("\r\n verification: ");
+ if(t==DSA_SIGNATURE_OK){
+ cli_putstr("[PASS]");
+ }else{
+ cli_putstr("[FAIL]");
+ }
+ }
+}
+
+void reset_prng(void){
+ uint8_t buf[16];
+ memset(buf, 0, 16);
+ random_seed(buf);
+ cli_putstr("\r\nPRNG reset");
+}
+
+void testrun_performance_bigint(void){
+
+}
+/*****************************************************************************
+ * main *
+ *****************************************************************************/
+
+const char echo_test_str[] = "echo-test";
+const char reset_prng_str[] = "reset-prng";
+const char quick_test_str[] = "quick-test";
+const char performance_str[] = "performance";
+const char echo_str[] = "echo";
+
+cmdlist_entry_t cmdlist[] = {
+ { reset_prng_str, NULL, reset_prng },
+ { quick_test_str, NULL, quick_test },
+ { performance_str, NULL, testrun_performance_bigint },
+ { echo_str, (void*)1, (void_fpt)echo_ctrl },
+ { NULL, NULL, NULL }
+};
+
+int main (void){
+ sysclk_set_freq(SYS_FREQ);
+ sysclk_mosc_verify_enable();
+ uart_init(UART_0, 115200, 8, UART_PARATY_NONE, UART_STOPBITS_ONE);
+ gptm_set_timer_32periodic(TIMER0);
+
+ cli_rx = uart0_getc;
+ cli_tx = uart0_putc;
+
+ for(;;){
+ cli_putstr("\r\n\r\nARM-Crypto-Lib VS (");
+ cli_putstr(algo_name);
+ cli_putstr("; ");
+ cli_putstr(__DATE__);
+ cli_putc(' ');
+ cli_putstr(__TIME__);
+ cli_putstr(")\r\nloaded and running\r\n");
+ cmd_interface(cmdlist);
+ }
+}
diff --git a/test_src/main-entropium-test.c b/test_src/main-entropium-test.c
new file mode 100644
index 0000000..35e8fb1
--- /dev/null
+++ b/test_src/main-entropium-test.c
@@ -0,0 +1,106 @@
+/* main-entropium-test.c */
+/*
+ This file is part of the ARM-Crypto-Lib.
+ Copyright (C) 2006-2010 Daniel Otte (daniel.otte@rub.de)
+
+ 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
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see .
+*/
+/*
+ * entropium test-suit
+ *
+*/
+
+#include "main-test-common.h"
+
+#include "entropium.h"
+#include "nessie_bc_test.h"
+#include "performance_test.h"
+
+char* algo_name = "Entropium";
+
+/*****************************************************************************
+ * additional validation-functions *
+ *****************************************************************************/
+
+void testrun_entropium(void){
+ char c, str[16];
+ uint8_t data[32];
+ uint32_t i=0;
+ while('q'!=cli_getc()){
+ entropium_getRandomBlock(data);
+ cli_putstr("\r\n ");
+ ultoa(i, str, 10);
+ for(c=strlen(str); c<11; ++c){
+ cli_putc(' ');
+ }
+ cli_putstr(str);
+ ++i;
+ cli_putstr(" : ");
+ cli_hexdump(data, 32);
+ }
+ cli_putstr("\r\n\r\n");
+}
+
+
+void testrun_performance_entropium(void){
+ uint64_t t;
+ char str[16];
+ uint8_t data[32];
+
+ calibrateTimer();
+ print_overhead();
+
+ startTimer(1);
+ entropium_addEntropy(128, data);
+ t = stopTimer();
+ cli_putstr("\r\n\tadd entropy time: ");
+ ultoa((unsigned long)t, str, 10);
+ cli_putstr(str);
+
+
+ startTimer(1);
+ entropium_getRandomBlock(data);
+ t = stopTimer();
+ cli_putstr("\r\n\tget random time: ");
+ ultoa((unsigned long)t, str, 10);
+ cli_putstr(str);
+
+ cli_putstr("\r\n");
+}
+/*****************************************************************************
+ * main *
+ *****************************************************************************/
+
+const char nessie_str[] = "nessie";
+const char test_str[] = "test";
+const char performance_str[] = "performance";
+const char echo_str[] = "echo";
+
+cmdlist_entry_t cmdlist[] = {
+ { nessie_str, NULL, testrun_entropium},
+ { test_str, NULL, testrun_entropium},
+ { performance_str, NULL, testrun_performance_entropium},
+ { echo_str, (void*)1, (void_fpt)echo_ctrl},
+ { NULL, NULL, NULL}
+};
+
+
+int main (void){
+ main_setup();
+
+ for(;;){
+ welcome_msg(algo_name);
+ cmd_interface(cmdlist);
+ }
+}
diff --git a/test_src/main-hmac-md5-test.c b/test_src/main-hmac-md5-test.c
new file mode 100644
index 0000000..7b6cf8b
--- /dev/null
+++ b/test_src/main-hmac-md5-test.c
@@ -0,0 +1,183 @@
+/* main-hmac-md5-test.c */
+/*
+ This file is part of the ARM-Crypto-Lib.
+ Copyright (C) 2006-2010 Daniel Otte (daniel.otte@rub.de)
+
+ 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
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see .
+*/
+/*
+ * HMAC-MD5 test-suit
+ *
+*/
+#include "main-test-common.h"
+
+#include "md5.h"
+#include "hmac-md5.h"
+/*
+#include "base64_enc.h"
+#include "base64_dec.h"
+*/
+#include "nessie_mac_test.h"
+
+const char* algo_name = "HMAC-MD5";
+
+/*****************************************************************************
+ * additional validation-functions *
+ *****************************************************************************/
+void testrun_nessie_hmacmd5(void){
+ nessie_mac_ctx.macsize_b = HMAC_MD5_BITS;
+ nessie_mac_ctx.keysize_b = HMAC_MD5_BLOCK_BITS;
+ nessie_mac_ctx.blocksize_B = HMAC_MD5_BLOCK_BYTES;
+ nessie_mac_ctx.ctx_size_B = sizeof(hmac_md5_ctx_t);
+ nessie_mac_ctx.name = algo_name;
+ nessie_mac_ctx.mac_init = (nessie_mac_init_fpt)hmac_md5_init;
+ nessie_mac_ctx.mac_next = (nessie_mac_next_fpt)hmac_md5_nextBlock;
+ nessie_mac_ctx.mac_last = (nessie_mac_last_fpt)hmac_md5_lastBlock;
+ nessie_mac_ctx.mac_conv = (nessie_mac_conv_fpt)hmac_md5_final;
+
+ nessie_mac_run();
+}
+
+void testrun_test_hmacmd5(void){
+ uint8_t hmac[16];
+ uint8_t keys[][16] = {
+ { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+ 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b },
+ { 'J', 'e', 'f', 'e', },
+ { 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
+ 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA }
+ };
+ uint8_t buffer[50];
+ cli_putstr("\r\n hmac (1): ");
+ hmac_md5(hmac, keys[0], 128, "Hi There", 64);
+ cli_hexdump(hmac, 16);
+
+ cli_putstr("\r\n hmac (2): ");
+ hmac_md5(hmac, keys[1], 4*8, "what do ya want for nothing?", 28*8);
+ cli_hexdump(hmac, 16);
+
+ cli_putstr("\r\n hmac (3): ");
+ memset(buffer, 0xDD, 50);
+ hmac_md5(hmac, keys[2], 128, buffer, 50*8);
+ cli_hexdump(hmac, 16);
+
+}
+
+void hmacmd5_interactive(void){
+ char key[101];
+ char msg[101];
+ uint8_t hmac[HMAC_MD5_BYTES];
+ uint8_t key_len, msg_len;
+ cli_putstr("\r\nHMAC-MD5:\r\nkey: ");
+ cli_getsn(key, 100);
+ key_len = strlen(key);
+ cli_putstr("\r\nmsg: ");
+ cli_getsn(msg, 100);
+ msg_len = strlen(msg);
+ hmac_md5(hmac, key, key_len*8, msg, msg_len*8);
+ cli_putstr("\r\nhmac-md5: ");
+ cli_hexdump(hmac, HMAC_MD5_BYTES);
+}
+
+void strhexdump(char* dest, void* src, uint16_t length){
+ char table[] = { '0', '1', '2', '3',
+ '4', '5', '6', '7',
+ '8', '9', 'a', 'b',
+ 'c', 'd', 'e', 'f' };
+ while(length--){
+ *dest++ = table[(*((uint8_t*)src))>>4];
+ *dest++ = table[(*((uint8_t*)src))&0xf];
+ src = (uint8_t*)src +1;
+ }
+}
+
+/*
+void cram_md5_interactive(void){
+ char key[101];
+ char msg_b64[101];
+ char username[101];
+ uint8_t msg[100];
+ uint8_t hmac[HMAC_MD5_BYTES];
+ int key_len, msg_len;
+ int ul;
+ cli_putstr("\r\nCRAM-MD5:\r\nkey: ");
+ cli_getsn(key, 100);
+ key_len = strlen(key);
+ cli_putstr("\r\nusername: ");
+ cli_getsn(username, 60);
+ cli_putstr("\r\nchallange: ");
+ cli_getsn(msg_b64, 100);
+ if((msg_len = base64_binlength(msg_b64, 1))==-1){
+ cli_putstr("\r\nERROR in base64 encoding !\r\n");
+ return;
+ }
+ base64dec(msg, msg_b64, 1);
+ hmac_md5(hmac, key, key_len*8, msg, msg_len*8);
+ ul=strlen(username);
+ username[ul]=' ';
+ strhexdump(username+ul+1, hmac, 128/8);
+ base64enc(msg_b64, username, ul+1+128/8*2);
+ cli_putstr("\r\nresponse: ");
+ cli_hexdump(hmac, HMAC_MD5_BYTES);
+ cli_putstr("\r\nresponse (b64): ");
+ cli_putstr(msg_b64);
+}
+*/
+
+
+void md5_interactive(void){
+ char msg[101];
+ uint8_t hash[MD5_HASH_BYTES];
+ uint8_t msg_len;
+ cli_putstr("\r\nmsg: ");
+ cli_getsn(msg, 100);
+ msg_len = strlen(msg);
+ md5((void*)hash, msg, msg_len*8);
+ cli_putstr("\r\nmd5: ");
+ cli_hexdump(hash, MD5_HASH_BYTES);
+}
+
+
+/*****************************************************************************
+ * main *
+ *****************************************************************************/
+
+const char nessie_str[] = "nessie";
+const char test_str[] = "test";
+/* const char performance_str[] = "performance"; */
+const char echo_str[] = "echo";
+const char hmd5i_str[] = "hmac-md5";
+/* const char crammd5i_str[] = "cram-md5"; */
+const char md5i_str[] = "md5";
+
+
+const cmdlist_entry_t const cmdlist[] = {
+ { nessie_str, NULL, testrun_nessie_hmacmd5},
+ { test_str, NULL, testrun_test_hmacmd5},
+ { hmd5i_str, NULL, hmacmd5_interactive},
+/* { crammd5i_str, NULL, cram_md5_interactive}, */
+ { md5i_str, NULL, md5_interactive},
+/* { performance_str, NULL, testrun_performance_hmacmd5}, */
+ { echo_str, (void*)1, (void_fpt)echo_ctrl},
+ { NULL, NULL, NULL}
+};
+
+int main (void){
+ main_setup();
+
+ for(;;){
+ welcome_msg(algo_name);
+ cmd_interface(cmdlist);
+ }
+}
diff --git a/test_src/main-hmac-sha1-test.c b/test_src/main-hmac-sha1-test.c
new file mode 100644
index 0000000..450493d
--- /dev/null
+++ b/test_src/main-hmac-sha1-test.c
@@ -0,0 +1,76 @@
+/* main-hmac-sha1-test.c */
+/*
+ This file is part of the ARM-Crypto-Lib.
+ Copyright (C) 2006-2010 Daniel Otte (daniel.otte@rub.de)
+
+ 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
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see .
+*/
+/*
+ * HMAC-SHA1 test-suit
+ *
+*/
+
+#include "main-test-common.h"
+#include "sha1.h"
+#include "hmac-sha1.h"
+
+#include "nessie_mac_test.h"
+
+
+const char* algo_name = "HMAC-SHA1";
+
+/*****************************************************************************
+ * additional validation-functions *
+ *****************************************************************************/
+
+void testrun_nessie_hmacsha1(void){
+ nessie_mac_ctx.macsize_b = HMAC_SHA1_BITS;
+ nessie_mac_ctx.keysize_b = HMAC_SHA1_BLOCK_BITS;
+ nessie_mac_ctx.blocksize_B = HMAC_SHA1_BLOCK_BYTES;
+ nessie_mac_ctx.ctx_size_B = sizeof(hmac_sha1_ctx_t);
+ nessie_mac_ctx.name = algo_name;
+ nessie_mac_ctx.mac_init = (nessie_mac_init_fpt)hmac_sha1_init;
+ nessie_mac_ctx.mac_next = (nessie_mac_next_fpt)hmac_sha1_nextBlock;
+ nessie_mac_ctx.mac_last = (nessie_mac_last_fpt)hmac_sha1_lastBlock;
+ nessie_mac_ctx.mac_conv = (nessie_mac_conv_fpt)hmac_sha1_final;
+
+ nessie_mac_run();
+}
+
+
+/*****************************************************************************
+ * main *
+ *****************************************************************************/
+
+const char nessie_str[] = "nessie";
+const char test_str[] = "test";
+/* const char performance_str[] = "performance"; */
+const char echo_str[] = "echo";
+
+const cmdlist_entry_t const cmdlist[] = {
+ { nessie_str, NULL, testrun_nessie_hmacsha1},
+ { test_str, NULL, testrun_nessie_hmacsha1},
+/* { performance_str, NULL, testrun_performance_hmacsha1}, */
+ { echo_str, (void*)1, (void_fpt)echo_ctrl},
+ { NULL, NULL, NULL}
+};
+
+int main (void){
+ main_setup();
+
+ for(;;){
+ welcome_msg(algo_name);
+ cmd_interface(cmdlist);
+ }
+}
diff --git a/test_src/main-hmac-sha256-test.c b/test_src/main-hmac-sha256-test.c
new file mode 100644
index 0000000..6241043
--- /dev/null
+++ b/test_src/main-hmac-sha256-test.c
@@ -0,0 +1,95 @@
+/* main-hmac-sha256-test.c */
+/*
+ This file is part of the ARM-Crypto-Lib.
+ Copyright (C) 2006-2010 Daniel Otte (daniel.otte@rub.de)
+
+ 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
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see .
+*/
+/*
+ * HMAC-SHA256 test-suit
+ *
+*/
+
+#include "main-test-common.h"
+
+#include "sha256.h"
+#include "hmac-sha256.h"
+
+#include "nessie_mac_test.h"
+
+
+const char* algo_name = "HMAC-SHA256";
+
+/*****************************************************************************
+ * additional validation-functions *
+ *****************************************************************************/
+
+void testrun_hmacsha256(void){
+ uint8_t key[] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
+ 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF,
+ 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
+ 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
+ 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF,
+ 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
+ 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
+ 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF };
+ uint8_t msg[] = { 0x00 };
+ uint8_t mac[HMAC_SHA256_BYTES];
+ hmac_sha256(mac, key, 512, msg, 0);
+ cli_putstr("\r\n quick hmac = ");
+ cli_hexdump(mac, HMAC_SHA256_BYTES);
+ cli_putstr("\r\n");
+}
+
+void testrun_nessie_hmacsha256(void){
+ nessie_mac_ctx.macsize_b = HMAC_SHA256_BITS;
+ nessie_mac_ctx.keysize_b = HMAC_SHA256_BLOCK_BITS;
+ nessie_mac_ctx.blocksize_B = HMAC_SHA256_BLOCK_BYTES;
+ nessie_mac_ctx.ctx_size_B = sizeof(hmac_sha256_ctx_t);
+ nessie_mac_ctx.name = algo_name;
+ nessie_mac_ctx.mac_init = (nessie_mac_init_fpt)hmac_sha256_init;
+ nessie_mac_ctx.mac_next = (nessie_mac_next_fpt)hmac_sha256_nextBlock;
+ nessie_mac_ctx.mac_last = (nessie_mac_last_fpt)hmac_sha256_lastBlock;
+ nessie_mac_ctx.mac_conv = (nessie_mac_conv_fpt)hmac_sha256_final;
+
+ nessie_mac_run();
+}
+
+
+
+/*****************************************************************************
+ * main *
+ *****************************************************************************/
+
+const char nessie_str[] = "nessie";
+const char test_str[] = "test";
+/* const char performance_str[] = "performance"; */
+const char echo_str[] = "echo";
+
+const cmdlist_entry_t const cmdlist[] = {
+ { nessie_str, NULL, testrun_nessie_hmacsha256},
+ { test_str, NULL, testrun_hmacsha256},
+/* { performance_str, NULL, testrun_performance_hmacsha256}, */
+ { echo_str, (void*)1, (void_fpt)echo_ctrl},
+ { NULL, NULL, NULL}
+};
+
+int main (void){
+ main_setup();
+
+ for(;;){
+ welcome_msg(algo_name);
+ cmd_interface(cmdlist);
+ }
+}
diff --git a/test_src/main-rsaes_oaep-test.c b/test_src/main-rsaes_oaep-test.c
new file mode 100644
index 0000000..1107c3a
--- /dev/null
+++ b/test_src/main-rsaes_oaep-test.c
@@ -0,0 +1,794 @@
+/* main-dsa-test.c */
+/*
+ This file is part of the ARM-Crypto-Lib.
+ Copyright (C) 2010 Daniel Otte (daniel.otte@rub.de)
+
+ 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
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see .
+*/
+/*
+ * RSA test-suit
+ *
+*/
+#include "main-test-common.h"
+
+#include "noekeon.h"
+#include "noekeon_prng.h"
+#include "bigint.h"
+#include "bigint_io.h"
+#include "random_dummy.h"
+#include "rsa_basic.h"
+#include "rsaes_oaep.h"
+
+#include "performance_test.h"
+
+const char* algo_name = "RSAES-OAEP";
+
+#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))
+
+/*****************************************************************************
+ * additional validation-functions *
+ *****************************************************************************/
+#if 0
+/* ==================================
+ * Example 1: A 1024-bit RSA Key Pair
+ * ================================== */
+
+/* ------------------------------
+ * Components of the RSA Key Pair
+ * ------------------------------ */
+
+/* RSA modulus n: */
+const uint8_t modulus[] = {
+0xa8, 0xb3, 0xb2, 0x84, 0xaf, 0x8e, 0xb5, 0x0b, 0x38, 0x70, 0x34, 0xa8, 0x60, 0xf1, 0x46, 0xc4,
+0x91, 0x9f, 0x31, 0x87, 0x63, 0xcd, 0x6c, 0x55, 0x98, 0xc8, 0xae, 0x48, 0x11, 0xa1, 0xe0, 0xab,
+0xc4, 0xc7, 0xe0, 0xb0, 0x82, 0xd6, 0x93, 0xa5, 0xe7, 0xfc, 0xed, 0x67, 0x5c, 0xf4, 0x66, 0x85,
+0x12, 0x77, 0x2c, 0x0c, 0xbc, 0x64, 0xa7, 0x42, 0xc6, 0xc6, 0x30, 0xf5, 0x33, 0xc8, 0xcc, 0x72,
+0xf6, 0x2a, 0xe8, 0x33, 0xc4, 0x0b, 0xf2, 0x58, 0x42, 0xe9, 0x84, 0xbb, 0x78, 0xbd, 0xbf, 0x97,
+0xc0, 0x10, 0x7d, 0x55, 0xbd, 0xb6, 0x62, 0xf5, 0xc4, 0xe0, 0xfa, 0xb9, 0x84, 0x5c, 0xb5, 0x14,
+0x8e, 0xf7, 0x39, 0x2d, 0xd3, 0xaa, 0xff, 0x93, 0xae, 0x1e, 0x6b, 0x66, 0x7b, 0xb3, 0xd4, 0x24,
+0x76, 0x16, 0xd4, 0xf5, 0xba, 0x10, 0xd4, 0xcf, 0xd2, 0x26, 0xde, 0x88, 0xd3, 0x9f, 0x16, 0xfb
+};
+
+/* RSA public exponent e: */
+const uint8_t public_exponent[] = {
+0x00, 0x01, 0x00, 0x01
+};
+
+/* RSA private exponent d: */
+const uint8_t private_exponent[] = {
+0x53, 0x33, 0x9c, 0xfd, 0xb7, 0x9f, 0xc8, 0x46, 0x6a, 0x65, 0x5c, 0x73, 0x16, 0xac, 0xa8, 0x5c,
+0x55, 0xfd, 0x8f, 0x6d, 0xd8, 0x98, 0xfd, 0xaf, 0x11, 0x95, 0x17, 0xef, 0x4f, 0x52, 0xe8, 0xfd,
+0x8e, 0x25, 0x8d, 0xf9, 0x3f, 0xee, 0x18, 0x0f, 0xa0, 0xe4, 0xab, 0x29, 0x69, 0x3c, 0xd8, 0x3b,
+0x15, 0x2a, 0x55, 0x3d, 0x4a, 0xc4, 0xd1, 0x81, 0x2b, 0x8b, 0x9f, 0xa5, 0xaf, 0x0e, 0x7f, 0x55,
+0xfe, 0x73, 0x04, 0xdf, 0x41, 0x57, 0x09, 0x26, 0xf3, 0x31, 0x1f, 0x15, 0xc4, 0xd6, 0x5a, 0x73,
+0x2c, 0x48, 0x31, 0x16, 0xee, 0x3d, 0x3d, 0x2d, 0x0a, 0xf3, 0x54, 0x9a, 0xd9, 0xbf, 0x7c, 0xbf,
+0xb7, 0x8a, 0xd8, 0x84, 0xf8, 0x4d, 0x5b, 0xeb, 0x04, 0x72, 0x4d, 0xc7, 0x36, 0x9b, 0x31, 0xde,
+0xf3, 0x7d, 0x0c, 0xf5, 0x39, 0xe9, 0xcf, 0xcd, 0xd3, 0xde, 0x65, 0x37, 0x29, 0xea, 0xd5, 0xd1
+};
+
+/* Prime p: */
+const uint8_t p[] = {
+0xd3, 0x27, 0x37, 0xe7, 0x26, 0x7f, 0xfe, 0x13, 0x41, 0xb2, 0xd5, 0xc0, 0xd1, 0x50, 0xa8, 0x1b,
+0x58, 0x6f, 0xb3, 0x13, 0x2b, 0xed, 0x2f, 0x8d, 0x52, 0x62, 0x86, 0x4a, 0x9c, 0xb9, 0xf3, 0x0a,
+0xf3, 0x8b, 0xe4, 0x48, 0x59, 0x8d, 0x41, 0x3a, 0x17, 0x2e, 0xfb, 0x80, 0x2c, 0x21, 0xac, 0xf1,
+0xc1, 0x1c, 0x52, 0x0c, 0x2f, 0x26, 0xa4, 0x71, 0xdc, 0xad, 0x21, 0x2e, 0xac, 0x7c, 0xa3, 0x9d
+};
+
+/* Prime q: */
+const uint8_t q[] = {
+0xcc, 0x88, 0x53, 0xd1, 0xd5, 0x4d, 0xa6, 0x30, 0xfa, 0xc0, 0x04, 0xf4, 0x71, 0xf2, 0x81, 0xc7,
+0xb8, 0x98, 0x2d, 0x82, 0x24, 0xa4, 0x90, 0xed, 0xbe, 0xb3, 0x3d, 0x3e, 0x3d, 0x5c, 0xc9, 0x3c,
+0x47, 0x65, 0x70, 0x3d, 0x1d, 0xd7, 0x91, 0x64, 0x2f, 0x1f, 0x11, 0x6a, 0x0d, 0xd8, 0x52, 0xbe,
+0x24, 0x19, 0xb2, 0xaf, 0x72, 0xbf, 0xe9, 0xa0, 0x30, 0xe8, 0x60, 0xb0, 0x28, 0x8b, 0x5d, 0x77
+};
+
+/* p's CRT exponent dP: */
+const uint8_t dp[] = {
+0x0e, 0x12, 0xbf, 0x17, 0x18, 0xe9, 0xce, 0xf5, 0x59, 0x9b, 0xa1, 0xc3, 0x88, 0x2f, 0xe8, 0x04,
+0x6a, 0x90, 0x87, 0x4e, 0xef, 0xce, 0x8f, 0x2c, 0xcc, 0x20, 0xe4, 0xf2, 0x74, 0x1f, 0xb0, 0xa3,
+0x3a, 0x38, 0x48, 0xae, 0xc9, 0xc9, 0x30, 0x5f, 0xbe, 0xcb, 0xd2, 0xd7, 0x68, 0x19, 0x96, 0x7d,
+0x46, 0x71, 0xac, 0xc6, 0x43, 0x1e, 0x40, 0x37, 0x96, 0x8d, 0xb3, 0x78, 0x78, 0xe6, 0x95, 0xc1
+};
+
+/* q's CRT exponent dQ: */
+const uint8_t dq[] = {
+0x95, 0x29, 0x7b, 0x0f, 0x95, 0xa2, 0xfa, 0x67, 0xd0, 0x07, 0x07, 0xd6, 0x09, 0xdf, 0xd4, 0xfc,
+0x05, 0xc8, 0x9d, 0xaf, 0xc2, 0xef, 0x6d, 0x6e, 0xa5, 0x5b, 0xec, 0x77, 0x1e, 0xa3, 0x33, 0x73,
+0x4d, 0x92, 0x51, 0xe7, 0x90, 0x82, 0xec, 0xda, 0x86, 0x6e, 0xfe, 0xf1, 0x3c, 0x45, 0x9e, 0x1a,
+0x63, 0x13, 0x86, 0xb7, 0xe3, 0x54, 0xc8, 0x99, 0xf5, 0xf1, 0x12, 0xca, 0x85, 0xd7, 0x15, 0x83
+};
+
+/* CRT coefficient qInv: */
+const uint8_t qinv[] = {
+0x4f, 0x45, 0x6c, 0x50, 0x24, 0x93, 0xbd, 0xc0, 0xed, 0x2a, 0xb7, 0x56, 0xa3, 0xa6, 0xed, 0x4d,
+0x67, 0x35, 0x2a, 0x69, 0x7d, 0x42, 0x16, 0xe9, 0x32, 0x12, 0xb1, 0x27, 0xa6, 0x3d, 0x54, 0x11,
+0xce, 0x6f, 0xa9, 0x8d, 0x5d, 0xbe, 0xfd, 0x73, 0x26, 0x3e, 0x37, 0x28, 0x14, 0x27, 0x43, 0x81,
+0x81, 0x66, 0xed, 0x7d, 0xd6, 0x36, 0x87, 0xdd, 0x2a, 0x8c, 0xa1, 0xd2, 0xf4, 0xfb, 0xd8, 0xe1
+};
+
+/* ---------------------------------
+ * RSAES-OAEP Encryption Example 1.1
+ * --------------------------------- */
+
+/* Message to be, encrypted: */
+const uint8_t message[] = {
+0x66, 0x28, 0x19, 0x4e, 0x12, 0x07, 0x3d, 0xb0, 0x3b, 0xa9, 0x4c, 0xda, 0x9e, 0xf9, 0x53, 0x23,
+0x97, 0xd5, 0x0d, 0xba, 0x79, 0xb9, 0x87, 0x00, 0x4a, 0xfe, 0xfe, 0x34
+};
+
+/* Seed: */
+const uint8_t seed[] = {
+0x18, 0xb7, 0x76, 0xea, 0x21, 0x06, 0x9d, 0x69, 0x77, 0x6a, 0x33, 0xe9, 0x6b, 0xad, 0x48, 0xe1,
+0xdd, 0xa0, 0xa5, 0xef
+};
+
+/* Encryption: */
+const uint8_t encrypted[] = {
+0x35, 0x4f, 0xe6, 0x7b, 0x4a, 0x12, 0x6d, 0x5d, 0x35, 0xfe, 0x36, 0xc7, 0x77, 0x79, 0x1a, 0x3f,
+0x7b, 0xa1, 0x3d, 0xef, 0x48, 0x4e, 0x2d, 0x39, 0x08, 0xaf, 0xf7, 0x22, 0xfa, 0xd4, 0x68, 0xfb,
+0x21, 0x69, 0x6d, 0xe9, 0x5d, 0x0b, 0xe9, 0x11, 0xc2, 0xd3, 0x17, 0x4f, 0x8a, 0xfc, 0xc2, 0x01,
+0x03, 0x5f, 0x7b, 0x6d, 0x8e, 0x69, 0x40, 0x2d, 0xe5, 0x45, 0x16, 0x18, 0xc2, 0x1a, 0x53, 0x5f,
+0xa9, 0xd7, 0xbf, 0xc5, 0xb8, 0xdd, 0x9f, 0xc2, 0x43, 0xf8, 0xcf, 0x92, 0x7d, 0xb3, 0x13, 0x22,
+0xd6, 0xe8, 0x81, 0xea, 0xa9, 0x1a, 0x99, 0x61, 0x70, 0xe6, 0x57, 0xa0, 0x5a, 0x26, 0x64, 0x26,
+0xd9, 0x8c, 0x88, 0x00, 0x3f, 0x84, 0x77, 0xc1, 0x22, 0x70, 0x94, 0xa0, 0xd9, 0xfa, 0x1e, 0x8c,
+0x40, 0x24, 0x30, 0x9c, 0xe1, 0xec, 0xcc, 0xb5, 0x21, 0x00, 0x35, 0xd4, 0x7a, 0xc7, 0x2e, 0x8a
+};
+
+/* Message to be encrypted: */
+const uint8_t message2[] = {
+0x75, 0x0c, 0x40, 0x47, 0xf5, 0x47, 0xe8, 0xe4, 0x14, 0x11, 0x85, 0x65, 0x23, 0x29, 0x8a, 0xc9,
+0xba, 0xe2, 0x45, 0xef, 0xaf, 0x13, 0x97, 0xfb, 0xe5, 0x6f, 0x9d, 0xd5
+};
+
+/* Seed: */
+const uint8_t seed2[] = {
+0x0c, 0xc7, 0x42, 0xce, 0x4a, 0x9b, 0x7f, 0x32, 0xf9, 0x51, 0xbc, 0xb2, 0x51, 0xef, 0xd9, 0x25,
+0xfe, 0x4f, 0xe3, 0x5f
+};
+
+/* Encryption: */
+const uint8_t encrypted2[] = {
+0x64, 0x0d, 0xb1, 0xac, 0xc5, 0x8e, 0x05, 0x68, 0xfe, 0x54, 0x07, 0xe5, 0xf9, 0xb7, 0x01, 0xdf,
+0xf8, 0xc3, 0xc9, 0x1e, 0x71, 0x6c, 0x53, 0x6f, 0xc7, 0xfc, 0xec, 0x6c, 0xb5, 0xb7, 0x1c, 0x11,
+0x65, 0x98, 0x8d, 0x4a, 0x27, 0x9e, 0x15, 0x77, 0xd7, 0x30, 0xfc, 0x7a, 0x29, 0x93, 0x2e, 0x3f,
+0x00, 0xc8, 0x15, 0x15, 0x23, 0x6d, 0x8d, 0x8e, 0x31, 0x01, 0x7a, 0x7a, 0x09, 0xdf, 0x43, 0x52,
+0xd9, 0x04, 0xcd, 0xeb, 0x79, 0xaa, 0x58, 0x3a, 0xdc, 0xc3, 0x1e, 0xa6, 0x98, 0xa4, 0xc0, 0x52,
+0x83, 0xda, 0xba, 0x90, 0x89, 0xbe, 0x54, 0x91, 0xf6, 0x7c, 0x1a, 0x4e, 0xe4, 0x8d, 0xc7, 0x4b,
+0xbb, 0xe6, 0x64, 0x3a, 0xef, 0x84, 0x66, 0x79, 0xb4, 0xcb, 0x39, 0x5a, 0x35, 0x2d, 0x5e, 0xd1,
+0x15, 0x91, 0x2d, 0xf6, 0x96, 0xff, 0xe0, 0x70, 0x29, 0x32, 0x94, 0x6d, 0x71, 0x49, 0x2b, 0x44
+};
+
+/**********************************************************************************************/
+/* ---------------------------------
+ * RSAES-OAEP Encryption Example 2.1
+ * --------------------------------- */
+
+/* Message to be encrypted: */
+const uint8_t message3[] = {
+0x8f, 0xf0, 0x0c, 0xaa, 0x60, 0x5c, 0x70, 0x28, 0x30, 0x63, 0x4d, 0x9a, 0x6c, 0x3d, 0x42, 0xc6,
+0x52, 0xb5, 0x8c, 0xf1, 0xd9, 0x2f, 0xec, 0x57, 0x0b, 0xee, 0xe7
+};
+
+/* Seed: */
+const uint8_t seed3[] = {
+0x8c, 0x40, 0x7b, 0x5e, 0xc2, 0x89, 0x9e, 0x50, 0x99, 0xc5, 0x3e, 0x8c, 0xe7, 0x93, 0xbf, 0x94,
+0xe7, 0x1b, 0x17, 0x82
+};
+
+/* Encryption: */
+const uint8_t encrypted3[] = {
+0x01, 0x81, 0xaf, 0x89, 0x22, 0xb9, 0xfc, 0xb4, 0xd7, 0x9d, 0x92, 0xeb, 0xe1, 0x98, 0x15, 0x99,
+0x2f, 0xc0, 0xc1, 0x43, 0x9d, 0x8b, 0xcd, 0x49, 0x13, 0x98, 0xa0, 0xf4, 0xad, 0x3a, 0x32, 0x9a,
+0x5b, 0xd9, 0x38, 0x55, 0x60, 0xdb, 0x53, 0x26, 0x83, 0xc8, 0xb7, 0xda, 0x04, 0xe4, 0xb1, 0x2a,
+0xed, 0x6a, 0xac, 0xdf, 0x47, 0x1c, 0x34, 0xc9, 0xcd, 0xa8, 0x91, 0xad, 0xdc, 0xc2, 0xdf, 0x34,
+0x56, 0x65, 0x3a, 0xa6, 0x38, 0x2e, 0x9a, 0xe5, 0x9b, 0x54, 0x45, 0x52, 0x57, 0xeb, 0x09, 0x9d,
+0x56, 0x2b, 0xbe, 0x10, 0x45, 0x3f, 0x2b, 0x6d, 0x13, 0xc5, 0x9c, 0x02, 0xe1, 0x0f, 0x1f, 0x8a,
+0xbb, 0x5d, 0xa0, 0xd0, 0x57, 0x09, 0x32, 0xda, 0xcf, 0x2d, 0x09, 0x01, 0xdb, 0x72, 0x9d, 0x0f,
+0xef, 0xcc, 0x05, 0x4e, 0x70, 0x96, 0x8e, 0xa5, 0x40, 0xc8, 0x1b, 0x04, 0xbc, 0xae, 0xfe, 0x72,
+0x0e
+};
+#endif
+/**********************************************************************************************/
+
+/* ---------------------------------
+ * RSAES-OAEP Encryption Example 2.4
+ * --------------------------------- */
+
+/* Message to be encrypted: */
+const uint8_t message4[] = {
+0xa7, 0xeb, 0x2a, 0x50, 0x36, 0x93, 0x1d, 0x27, 0xd4, 0xe8, 0x91, 0x32, 0x6d, 0x99, 0x69, 0x2f,
+0xfa, 0xdd, 0xa9, 0xbf, 0x7e, 0xfd, 0x3e, 0x34, 0xe6, 0x22, 0xc4, 0xad, 0xc0, 0x85, 0xf7, 0x21,
+0xdf, 0xe8, 0x85, 0x07, 0x2c, 0x78, 0xa2, 0x03, 0xb1, 0x51, 0x73, 0x9b, 0xe5, 0x40, 0xfa, 0x8c,
+0x15, 0x3a, 0x10, 0xf0, 0x0a
+};
+
+/* Seed: */
+const uint8_t seed4[] = {
+0x9a, 0x7b, 0x3b, 0x0e, 0x70, 0x8b, 0xd9, 0x6f, 0x81, 0x90, 0xec, 0xab, 0x4f, 0xb9, 0xb2, 0xb3,
+0x80, 0x5a, 0x81, 0x56
+};
+
+/* Encryption: */
+const uint8_t encrypted4[] = {
+/* 0x00,*/ 0xa4, 0x57, 0x8c, 0xbc, 0x17, 0x63, 0x18, 0xa6, 0x38, 0xfb, 0xa7, 0xd0, 0x1d, 0xf1, 0x57,
+0x46, 0xaf, 0x44, 0xd4, 0xf6, 0xcd, 0x96, 0xd7, 0xe7, 0xc4, 0x95, 0xcb, 0xf4, 0x25, 0xb0, 0x9c,
+0x64, 0x9d, 0x32, 0xbf, 0x88, 0x6d, 0xa4, 0x8f, 0xba, 0xf9, 0x89, 0xa2, 0x11, 0x71, 0x87, 0xca,
+0xfb, 0x1f, 0xb5, 0x80, 0x31, 0x76, 0x90, 0xe3, 0xcc, 0xd4, 0x46, 0x92, 0x0b, 0x7a, 0xf8, 0x2b,
+0x31, 0xdb, 0x58, 0x04, 0xd8, 0x7d, 0x01, 0x51, 0x4a, 0xcb, 0xfa, 0x91, 0x56, 0xe7, 0x82, 0xf8,
+0x67, 0xf6, 0xbe, 0xd9, 0x44, 0x9e, 0x0e, 0x9a, 0x2c, 0x09, 0xbc, 0xec, 0xc6, 0xaa, 0x08, 0x76,
+0x36, 0x96, 0x5e, 0x34, 0xb3, 0xec, 0x76, 0x6f, 0x2f, 0xe2, 0xe4, 0x30, 0x18, 0xa2, 0xfd, 0xde,
+0xb1, 0x40, 0x61, 0x6a, 0x0e, 0x9d, 0x82, 0xe5, 0x33, 0x10, 0x24, 0xee, 0x06, 0x52, 0xfc, 0x76,
+0x41
+};
+
+/**********************************************************************************************/
+#if 1
+/* RSA modulus n: */
+const uint8_t modulus2[] = {
+0x01, 0x94, 0x7c, 0x7f, 0xce, 0x90, 0x42, 0x5f, 0x47, 0x27, 0x9e, 0x70, 0x85, 0x1f, 0x25, 0xd5,
+0xe6, 0x23, 0x16, 0xfe, 0x8a, 0x1d, 0xf1, 0x93, 0x71, 0xe3, 0xe6, 0x28, 0xe2, 0x60, 0x54, 0x3e,
+0x49, 0x01, 0xef, 0x60, 0x81, 0xf6, 0x8c, 0x0b, 0x81, 0x41, 0x19, 0x0d, 0x2a, 0xe8, 0xda, 0xba,
+0x7d, 0x12, 0x50, 0xec, 0x6d, 0xb6, 0x36, 0xe9, 0x44, 0xec, 0x37, 0x22, 0x87, 0x7c, 0x7c, 0x1d,
+0x0a, 0x67, 0xf1, 0x4b, 0x16, 0x94, 0xc5, 0xf0, 0x37, 0x94, 0x51, 0xa4, 0x3e, 0x49, 0xa3, 0x2d,
+0xde, 0x83, 0x67, 0x0b, 0x73, 0xda, 0x91, 0xa1, 0xc9, 0x9b, 0xc2, 0x3b, 0x43, 0x6a, 0x60, 0x05,
+0x5c, 0x61, 0x0f, 0x0b, 0xaf, 0x99, 0xc1, 0xa0, 0x79, 0x56, 0x5b, 0x95, 0xa3, 0xf1, 0x52, 0x66,
+0x32, 0xd1, 0xd4, 0xda, 0x60, 0xf2, 0x0e, 0xda, 0x25, 0xe6, 0x53, 0xc4, 0xf0, 0x02, 0x76, 0x6f,
+0x45
+};
+
+/* RSA public exponent e: */
+const uint8_t public_exponent2[] = {
+0x01, 0x00, 0x01
+};
+
+/* RSA private exponent d: */
+const uint8_t private_exponent2[] = {
+0x08, 0x23, 0xf2, 0x0f, 0xad, 0xb5, 0xda, 0x89, 0x08, 0x8a, 0x9d, 0x00, 0x89, 0x3e, 0x21, 0xfa,
+0x4a, 0x1b, 0x11, 0xfb, 0xc9, 0x3c, 0x64, 0xa3, 0xbe, 0x0b, 0xaa, 0xea, 0x97, 0xfb, 0x3b, 0x93,
+0xc3, 0xff, 0x71, 0x37, 0x04, 0xc1, 0x9c, 0x96, 0x3c, 0x1d, 0x10, 0x7a, 0xae, 0x99, 0x05, 0x47,
+0x39, 0xf7, 0x9e, 0x02, 0xe1, 0x86, 0xde, 0x86, 0xf8, 0x7a, 0x6d, 0xde, 0xfe, 0xa6, 0xd8, 0xcc,
+0xd1, 0xd3, 0xc8, 0x1a, 0x47, 0xbf, 0xa7, 0x25, 0x5b, 0xe2, 0x06, 0x01, 0xa4, 0xa4, 0xb2, 0xf0,
+0x8a, 0x16, 0x7b, 0x5e, 0x27, 0x9d, 0x71, 0x5b, 0x1b, 0x45, 0x5b, 0xdd, 0x7e, 0xab, 0x24, 0x59,
+0x41, 0xd9, 0x76, 0x8b, 0x9a, 0xce, 0xfb, 0x3c, 0xcd, 0xa5, 0x95, 0x2d, 0xa3, 0xce, 0xe7, 0x25,
+0x25, 0xb4, 0x50, 0x16, 0x63, 0xa8, 0xee, 0x15, 0xc9, 0xe9, 0x92, 0xd9, 0x24, 0x62, 0xfe, 0x39
+};
+
+/* Prime p: */
+const uint8_t p2[] = {
+0x01, 0x59, 0xdb, 0xde, 0x04, 0xa3, 0x3e, 0xf0, 0x6f, 0xb6, 0x08, 0xb8, 0x0b, 0x19, 0x0f, 0x4d,
+0x3e, 0x22, 0xbc, 0xc1, 0x3a, 0xc8, 0xe4, 0xa0, 0x81, 0x03, 0x3a, 0xbf, 0xa4, 0x16, 0xed, 0xb0,
+0xb3, 0x38, 0xaa, 0x08, 0xb5, 0x73, 0x09, 0xea, 0x5a, 0x52, 0x40, 0xe7, 0xdc, 0x6e, 0x54, 0x37,
+0x8c, 0x69, 0x41, 0x4c, 0x31, 0xd9, 0x7d, 0xdb, 0x1f, 0x40, 0x6d, 0xb3, 0x76, 0x9c, 0xc4, 0x1a,
+0x43
+};
+
+/* Prime q: */
+const uint8_t q2[] = {
+0x01, 0x2b, 0x65, 0x2f, 0x30, 0x40, 0x3b, 0x38, 0xb4, 0x09, 0x95, 0xfd, 0x6f, 0xf4, 0x1a, 0x1a,
+0xcc, 0x8a, 0xda, 0x70, 0x37, 0x32, 0x36, 0xb7, 0x20, 0x2d, 0x39, 0xb2, 0xee, 0x30, 0xcf, 0xb4,
+0x6d, 0xb0, 0x95, 0x11, 0xf6, 0xf3, 0x07, 0xcc, 0x61, 0xcc, 0x21, 0x60, 0x6c, 0x18, 0xa7, 0x5b,
+0x8a, 0x62, 0xf8, 0x22, 0xdf, 0x03, 0x1b, 0xa0, 0xdf, 0x0d, 0xaf, 0xd5, 0x50, 0x6f, 0x56, 0x8b,
+0xd7
+};
+
+/* p's CRT exponent dP: */
+const uint8_t dp2[] = {
+0x43, 0x6e, 0xf5, 0x08, 0xde, 0x73, 0x65, 0x19, 0xc2, 0xda, 0x4c, 0x58, 0x0d, 0x98, 0xc8, 0x2c,
+0xb7, 0x45, 0x2a, 0x3f, 0xb5, 0xef, 0xad, 0xc3, 0xb9, 0xc7, 0x78, 0x9a, 0x1b, 0xc6, 0x58, 0x4f,
+0x79, 0x5a, 0xdd, 0xbb, 0xd3, 0x24, 0x39, 0xc7, 0x46, 0x86, 0x55, 0x2e, 0xcb, 0x6c, 0x2c, 0x30,
+0x7a, 0x4d, 0x3a, 0xf7, 0xf5, 0x39, 0xee, 0xc1, 0x57, 0x24, 0x8c, 0x7b, 0x31, 0xf1, 0xa2, 0x55
+};
+
+/* q's CRT exponent dQ: */
+const uint8_t dq2[] = {
+0x01, 0x2b, 0x15, 0xa8, 0x9f, 0x3d, 0xfb, 0x2b, 0x39, 0x07, 0x3e, 0x73, 0xf0, 0x2b, 0xdd, 0x0c,
+0x1a, 0x7b, 0x37, 0x9d, 0xd4, 0x35, 0xf0, 0x5c, 0xdd, 0xe2, 0xef, 0xf9, 0xe4, 0x62, 0x94, 0x8b,
+0x7c, 0xec, 0x62, 0xee, 0x90, 0x50, 0xd5, 0xe0, 0x81, 0x6e, 0x07, 0x85, 0xa8, 0x56, 0xb4, 0x91,
+0x08, 0xdc, 0xb7, 0x5f, 0x36, 0x83, 0x87, 0x4d, 0x1c, 0xa6, 0x32, 0x9a, 0x19, 0x01, 0x30, 0x66,
+0xff
+};
+
+/* CRT coefficient qInv: */
+const uint8_t qinv2[] = {
+0x02, 0x70, 0xdb, 0x17, 0xd5, 0x91, 0x4b, 0x01, 0x8d, 0x76, 0x11, 0x8b, 0x24, 0x38, 0x9a, 0x73,
+0x50, 0xec, 0x83, 0x6b, 0x00, 0x63, 0xa2, 0x17, 0x21, 0x23, 0x6f, 0xd8, 0xed, 0xb6, 0xd8, 0x9b,
+0x51, 0xe7, 0xee, 0xb8, 0x7b, 0x61, 0x1b, 0x71, 0x32, 0xcb, 0x7e, 0xa7, 0x35, 0x6c, 0x23, 0x15,
+0x1c, 0x1e, 0x77, 0x51, 0x50, 0x7c, 0x78, 0x6d, 0x9e, 0xe1, 0x79, 0x41, 0x70, 0xa8, 0xc8, 0xe8
+};
+
+#endif
+/**********************************************************************************************/
+
+
+uint8_t keys_allocated = 0;
+rsa_publickey_t pub_key;
+rsa_privatekey_t priv_key;
+
+#if 0
+ #define MSG message
+ #define SEED seed
+ #define ENCRYPTED encrypted
+ #define MODULUS modulus
+ #define PUB_EXPONENT public_exponent
+ #define PRIV_EXPONENT private_exponent
+ #define P p
+ #define Q q
+ #define DP dp
+ #define DQ dq
+ #define QINV qinv
+#else
+ #define MSG message4
+ #define SEED seed4
+ #define ENCRYPTED encrypted4
+ #define MODULUS modulus2
+ #define PUB_EXPONENT public_exponent2
+ #define PRIV_EXPONENT private_exponent2
+ #define P p2
+ #define Q q2
+ #define DP dp2
+ #define DQ dq2
+ #define QINV qinv2
+#endif
+
+
+uint8_t convert_nibble(uint8_t c){
+ if(c>='0' && c<='9'){
+ return c - '0';
+ }
+ c |= 'A' ^ 'a';
+ if(c>='a' && c<='f'){
+ return c - 'a' + 10;
+ }
+ return 0xff;
+}
+
+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 counter = 0;
+ uint16_t c;
+ uint8_t v, tmp = 0, idx = 0;
+ if(!ignore_string){
+ ignore_string = block_ignore_string;
+ }
+ while(counter < length){
+ c = cli_getc();
+ if(c > 0xff){
+ return counter;
+ }
+ if(strchr(ignore_string, c)){
+ continue;
+ }
+ v = convert_nibble(c);
+ if(v > 0x0f){
+ return counter;
+ }
+ if(idx){
+ ((uint8_t*)dst)[counter++] = (tmp << 4) | v;
+ idx = 0;
+ if(counter % (BUFFER_LIMIT/2) == 0){
+ cli_putc('.');
+ }
+ }else{
+ tmp = v;
+ idx = 1;
+ }
+ }
+ return counter;
+}
+
+uint16_t own_atou(const char* str){
+ uint16_t r=0;
+ while(*str && *str >= '0' && *str <= '9'){
+ r *= 10;
+ r += *str++ - '0';
+ }
+ return r;
+}
+
+char* own_utoa(unsigned value, char* str, uint8_t radix){
+ char *p = str, *b = str;
+ char t;
+ div_t d;
+ if(radix>36){
+ return NULL;
+ }
+ if(value == 0){
+ *p++ = '0';
+ *p = '\0';
+ return str;
+ }
+ while(value){
+ d = div(value, radix);
+ value = d.quot;
+ if(d.rem < 10){
+ *p++ = '0' + d.rem;
+ }else{
+ *p++ = 'a' + d.rem - 10;
+ }
+ }
+ *p = '\0';
+ while(strwordv = (bigint_word_t*)buffer;
+ 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("\r\nERROR: OOM!");
+ return 2;
+ }
+ return 0;
+}
+
+void free_key(void){
+ uint8_t c;
+ free(pub_key.modulus.wordv);
+ free(pub_key.exponent.wordv);
+ pub_key.modulus.wordv = priv_key.modulus.wordv = NULL;
+ for(c = 0; c < priv_key.n; ++c){
+ free(priv_key.components[c].wordv);
+ }
+ free(priv_key.components);
+}
+
+uint8_t read_key_crt(void){
+ uint8_t r;
+ cli_putstr("\r\n== reading key (crt) ==");
+ r = pre_alloc_key_crt();
+ if(r) return r;
+ r = read_bigint(&pub_key.modulus, "\r\n = module =");
+ memcpy(&priv_key.modulus, &pub_key.modulus, sizeof(bigint_t));
+ if(r) return r;
+ 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;
+ cli_putstr("\r\n== reading key (crt) ==");
+ 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;
+ priv_key.components = malloc(sizeof(bigint_t));
+ if(!priv_key.components){
+ cli_putstr("\r\nERROR: OOM!");
+ return 2;
+ }
+ r = read_bigint(&pub_key.exponent, "\r\n = public exponent =");
+ if(r) return r;
+ r = read_bigint(&priv_key.components[0], "\r\n = private exponent =");
+ return r;
+}
+
+void load_priv_conventional(void){
+ priv_key.components = malloc(sizeof(bigint_t));
+ priv_key.components[0].length_W = (sizeof(PRIV_EXPONENT) +
+ sizeof(bigint_word_t) - 1) / sizeof(bigint_word_t);
+ priv_key.components[0].wordv = malloc(priv_key.components[0].length_W *
+ sizeof(bigint_word_t));
+ if(!priv_key.components[0].wordv){
+ cli_putstr("\r\nERROR: OOM!");
+ return;
+ }
+ memcpy(priv_key.components[0].wordv, PRIV_EXPONENT, sizeof(PRIV_EXPONENT));
+ priv_key.n = 1;
+ bigint_changeendianess(&priv_key.components[0]);
+ bigint_adjust(&priv_key.components[0]);
+}
+
+
+void load_priv_crt_mono(void){
+ bigint_t *v;
+ const uint8_t *bv[5] = {P,Q,DP,DQ,QINV};
+ uint16_t sv[5] = {sizeof(P), sizeof(Q), sizeof(DP), sizeof(DQ), sizeof(QINV)};
+ uint8_t i;
+ v = malloc(5 * sizeof(bigint_t));
+ if(!v){
+ cli_putstr("\r\nERROR: OOM!");
+ return;
+ }
+ priv_key.components = v;
+ priv_key.n = 5;
+ for(i=0; i<5; ++i){
+ v[i].info = 0;
+ 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("\r\nERROR: OOM!");
+ return;
+ }
+ memcpy(v[i].wordv, bv[i], sv[i]);
+ bigint_changeendianess(&v[i]);
+ bigint_adjust(&v[i]);
+ }
+}
+
+uint8_t load_bigint_from_os(bigint_t* a, const void* 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("\r\nOOM!\r\n");
+ return 1;
+ }
+ memset(a->wordv, 0, sizeof(bigint_word_t));
+ memcpy((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("\r\nOOM!\r\n");
+ return;
+ }
+
+ load_bigint_from_os(&pub_key.modulus, MODULUS, sizeof(MODULUS));
+ load_bigint_from_os(&pub_key.exponent, PUB_EXPONENT, sizeof(PUB_EXPONENT));
+ priv_key.n = 5;
+ memcpy(&priv_key.modulus, &pub_key.modulus, sizeof(bigint_t));
+ 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));
+
+// load_priv_conventional();
+// load_priv_crt_mono();
+}
+
+void quick_test(void){
+ uint8_t *ciphertext, *plaintext, rc;
+ uint8_t seed[sizeof(SEED)];
+ uint16_t clen, plen;
+ ciphertext = malloc(clen = pub_key.modulus.length_W * sizeof(bigint_word_t));
+ plaintext = malloc(pub_key.modulus.length_W * sizeof(bigint_word_t));
+ memcpy(plaintext, MSG, sizeof(MSG));
+ memcpy(seed, SEED, sizeof(SEED));
+ cli_putstr("\r\nplaintext:");
+ cli_hexdump_block(plaintext, sizeof(MSG), 4, 8);
+ cli_putstr("\r\nencrypting: ...");
+ rc = rsa_encrypt_oaep(ciphertext, &clen, plaintext, sizeof(MSG), &pub_key, NULL, NULL, seed);
+ if(rc){
+ cli_putstr("\r\nERROR: rsa_encrypt_oaep returned: ");
+ cli_hexdump_byte(rc);
+ return;
+
+ }
+
+ cli_putstr("\r\n\r\nciphertext:");
+ cli_hexdump_block(ciphertext, clen, 4, 8);
+ if(clen!=sizeof(ENCRYPTED)){
+ cli_putstr("\r\n>>FAIL (no size match)<<");
+ }else{
+ if(memcmp(ciphertext, ENCRYPTED, clen)){
+ cli_putstr("\r\n>>FAIL (no content match)<<");
+ }else{
+ cli_putstr("\r\n>>OK<<");
+ }
+ }
+
+ cli_putstr("\r\ndecrypting: ...");
+ rc = rsa_decrypt_oaep(plaintext, &plen, ciphertext, clen, &priv_key, NULL, NULL, NULL);
+ if(rc){
+ cli_putstr("\r\nERROR: rsa_decrypt_oaep returned: ");
+ cli_hexdump_byte(rc);
+ return;
+ }
+ cli_putstr("\r\n\r\nplaintext:");
+ cli_hexdump_block(plaintext, plen, 4, 8);
+
+ free(ciphertext);
+ free(plaintext);
+}
+
+void run_seed_test(void){
+ uint8_t *msg, *ciph, *msg_;
+ uint16_t msg_len, ciph_len, msg_len_;
+ uint8_t seed[20], seed_out[20];
+ char read_int_str[18];
+ cli_putstr("\r\n== test with given seed ==");
+ cli_putstr("\r\n = message =");
+ cli_putstr("\r\n length: ");
+ cli_getsn(read_int_str, 16);
+ msg_len = own_atou(read_int_str);
+ msg = malloc(msg_len);
+ if(!msg){
+ cli_putstr("\r\nERROR: OOM!");
+ return;
+ }
+ ciph = malloc(bigint_length_B(&pub_key.modulus));
+ if(!ciph){
+ cli_putstr("\r\nERROR: OOM!");
+ return;
+ }
+ msg_ = malloc(bigint_length_B(&pub_key.modulus));
+ if(!msg_){
+ cli_putstr("\r\nERROR: OOM!");
+ return;
+ }
+ cli_putstr("\r\n data: ");
+ read_os(msg, msg_len, NULL);
+ cli_putstr("\r\n seed (20 bytes): ");
+ read_os(seed, 20, NULL);
+
+ cli_putstr("\r\n encrypting ...");
+ rsa_encrypt_oaep(ciph, &ciph_len, msg, msg_len, &pub_key, NULL, NULL, seed);
+ cli_putstr("\r\n ciphertext:");
+ cli_hexdump_block(ciph, ciph_len, 4, 16);
+ cli_putstr("\r\n decrypting ... ");
+ rsa_decrypt_oaep(msg_, &msg_len_, ciph, ciph_len, &priv_key, NULL, NULL, seed_out);
+ cli_putstr("[done]");
+ if(msg_len != msg_len_){
+ char tstr[16];
+ cli_putstr("\r\nERROR: wrong decrypted message length (");
+
+ own_utoa(msg_len_, tstr, 10);
+ cli_putstr(tstr);
+ cli_putstr(" instead of ");
+ own_utoa(msg_len, tstr, 10);
+ cli_putstr(tstr);
+ cli_putc(')');
+ goto end;
+ }
+ if(memcmp(msg, msg_, msg_len)){
+ cli_putstr("\r\nERROR: wrong decrypted message:");
+ cli_hexdump_block(msg_, msg_len_, 4, 16);
+ cli_putstr("\r\nreference:");
+ cli_hexdump_block(msg, msg_len, 4, 16);
+ goto end;
+ }
+
+ if(memcmp(seed, seed_out, 20)){
+ cli_putstr("\r\nERROR: wrong decrypted seed:");
+ cli_hexdump_block(seed_out, 20, 4, 16);
+ cli_putstr("\r\nreference:");
+ cli_hexdump_block(seed, 20, 4, 16);
+ goto end;
+ }
+ cli_putstr("\r\n >>OK<<");
+end:
+ free(msg);
+ free(msg_);
+ free(ciph);
+}
+
+void reset_prng(void){
+ uint8_t buf[16];
+ memset(buf, 0, 16);
+ random_seed(buf);
+ cli_putstr("\r\nPRNG reset");
+}
+
+void rsa_init(void){
+ prng_get_byte = random8;
+}
+
+void load_key(void){
+ if(keys_allocated){
+ free_key();
+ }
+ keys_allocated = 1;
+ read_key_crt();
+}
+
+void test_dump(void){
+ char lstr[16];
+ int len;
+ cli_putstr("\r\nenter dump length: ");
+ cli_getsn(lstr, 15);
+ len = own_atou(lstr);
+ cli_putstr("\r\ndumping 0x");
+ cli_hexdump_rev(&len, 2);
+ cli_putstr(" byte:");
+ cli_hexdump_block(pub_key.modulus.wordv, len, 4, 8);
+}
+
+/*****************************************************************************
+ * main *
+ *****************************************************************************/
+
+const char echo_test_str[] = "echo-test";
+const char reset_prng_str[] = "reset-prng";
+const char load_key_str[] = "load-key";
+const char load_fix_key_str[] = "load-fix-key";
+const char quick_test_str[] = "quick-test";
+const char seed_test_str[] = "seed-test";
+const char dump_test_str[] = "dump-test";
+const char performance_str[] = "performance";
+const char echo_str[] = "echo";
+
+const cmdlist_entry_t cmdlist[] = {
+ { reset_prng_str, NULL, reset_prng },
+ { load_key_str, NULL, load_key },
+ { load_fix_key_str, NULL, load_fix_rsa },
+ { quick_test_str, NULL, quick_test },
+ { seed_test_str, NULL, run_seed_test },
+ { dump_test_str, NULL, test_dump },
+// { performance_str, NULL, testrun_performance_bigint },
+ { echo_str, (void*)1, (void_fpt)echo_ctrl },
+ { NULL, NULL, NULL }
+};
+
+void dump_sp(void){
+ uint8_t x;
+ uint8_t *xa = &x;
+ cli_putstr("\r\nstack pointer: ~");
+ cli_hexdump_rev(&xa, 4);
+}
+
+int main (void){
+ main_setup();
+
+ for(;;){
+ welcome_msg(algo_name);
+ rsa_init();
+ cmd_interface(cmdlist);
+ }
+}
diff --git a/test_src/main-rsaes_pkcs1v15-test.c b/test_src/main-rsaes_pkcs1v15-test.c
new file mode 100644
index 0000000..c0ccd6c
--- /dev/null
+++ b/test_src/main-rsaes_pkcs1v15-test.c
@@ -0,0 +1,714 @@
+/* main-dsa-test.c */
+/*
+ This file is part of the ARM-Crypto-Lib.
+ Copyright (C) 2010 Daniel Otte (daniel.otte@rub.de)
+
+ 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
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see .
+*/
+/*
+ * RSA test-suit
+ *
+*/
+#include "main-test-common.h"
+
+#include "noekeon.h"
+#include "noekeon_prng.h"
+#include "bigint.h"
+#include "bigint_io.h"
+#include "random_dummy.h"
+#include "rsa_basic.h"
+#include "rsaes_pkcs1v15.h"
+
+#include "performance_test.h"
+
+const char* algo_name = "RSAES-PKCS15";
+
+#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))
+
+/*****************************************************************************
+ * additional validation-functions *
+ *****************************************************************************/
+
+/* Modulus: */
+const uint8_t modulus[] = {
+0xa8, 0xb3, 0xb2, 0x84, 0xaf, 0x8e, 0xb5, 0x0b, 0x38, 0x70, 0x34, 0xa8, 0x60, 0xf1, 0x46, 0xc4,
+0x91, 0x9f, 0x31, 0x87, 0x63, 0xcd, 0x6c, 0x55, 0x98, 0xc8, 0xae, 0x48, 0x11, 0xa1, 0xe0, 0xab,
+0xc4, 0xc7, 0xe0, 0xb0, 0x82, 0xd6, 0x93, 0xa5, 0xe7, 0xfc, 0xed, 0x67, 0x5c, 0xf4, 0x66, 0x85,
+0x12, 0x77, 0x2c, 0x0c, 0xbc, 0x64, 0xa7, 0x42, 0xc6, 0xc6, 0x30, 0xf5, 0x33, 0xc8, 0xcc, 0x72,
+0xf6, 0x2a, 0xe8, 0x33, 0xc4, 0x0b, 0xf2, 0x58, 0x42, 0xe9, 0x84, 0xbb, 0x78, 0xbd, 0xbf, 0x97,
+0xc0, 0x10, 0x7d, 0x55, 0xbd, 0xb6, 0x62, 0xf5, 0xc4, 0xe0, 0xfa, 0xb9, 0x84, 0x5c, 0xb5, 0x14,
+0x8e, 0xf7, 0x39, 0x2d, 0xd3, 0xaa, 0xff, 0x93, 0xae, 0x1e, 0x6b, 0x66, 0x7b, 0xb3, 0xd4, 0x24,
+0x76, 0x16, 0xd4, 0xf5, 0xba, 0x10, 0xd4, 0xcf, 0xd2, 0x26, 0xde, 0x88, 0xd3, 0x9f, 0x16, 0xfb
+};
+
+/* Public exponent: */
+const uint8_t pub_exponent[] = { 0x01, 0x00, 0x01 };
+
+/* Exponent: */
+const uint8_t priv_exponent[] = {
+0x53, 0x33, 0x9c, 0xfd, 0xb7, 0x9f, 0xc8, 0x46, 0x6a, 0x65, 0x5c, 0x73, 0x16, 0xac, 0xa8, 0x5c,
+0x55, 0xfd, 0x8f, 0x6d, 0xd8, 0x98, 0xfd, 0xaf, 0x11, 0x95, 0x17, 0xef, 0x4f, 0x52, 0xe8, 0xfd,
+0x8e, 0x25, 0x8d, 0xf9, 0x3f, 0xee, 0x18, 0x0f, 0xa0, 0xe4, 0xab, 0x29, 0x69, 0x3c, 0xd8, 0x3b,
+0x15, 0x2a, 0x55, 0x3d, 0x4a, 0xc4, 0xd1, 0x81, 0x2b, 0x8b, 0x9f, 0xa5, 0xaf, 0x0e, 0x7f, 0x55,
+0xfe, 0x73, 0x04, 0xdf, 0x41, 0x57, 0x09, 0x26, 0xf3, 0x31, 0x1f, 0x15, 0xc4, 0xd6, 0x5a, 0x73,
+0x2c, 0x48, 0x31, 0x16, 0xee, 0x3d, 0x3d, 0x2d, 0x0a, 0xf3, 0x54, 0x9a, 0xd9, 0xbf, 0x7c, 0xbf,
+0xb7, 0x8a, 0xd8, 0x84, 0xf8, 0x4d, 0x5b, 0xeb, 0x04, 0x72, 0x4d, 0xc7, 0x36, 0x9b, 0x31, 0xde,
+0xf3, 0x7d, 0x0c, 0xf5, 0x39, 0xe9, 0xcf, 0xcd, 0xd3, 0xde, 0x65, 0x37, 0x29, 0xea, 0xd5, 0xd1
+};
+
+/* Prime 1: */
+const uint8_t p[] = {
+0xd3, 0x27, 0x37, 0xe7, 0x26, 0x7f, 0xfe, 0x13, 0x41, 0xb2, 0xd5, 0xc0, 0xd1, 0x50, 0xa8, 0x1b,
+0x58, 0x6f, 0xb3, 0x13, 0x2b, 0xed, 0x2f, 0x8d, 0x52, 0x62, 0x86, 0x4a, 0x9c, 0xb9, 0xf3, 0x0a,
+0xf3, 0x8b, 0xe4, 0x48, 0x59, 0x8d, 0x41, 0x3a, 0x17, 0x2e, 0xfb, 0x80, 0x2c, 0x21, 0xac, 0xf1,
+0xc1, 0x1c, 0x52, 0x0c, 0x2f, 0x26, 0xa4, 0x71, 0xdc, 0xad, 0x21, 0x2e, 0xac, 0x7c, 0xa3, 0x9d
+};
+
+/* Prime 2: */
+const uint8_t q[] = {
+0xcc, 0x88, 0x53, 0xd1, 0xd5, 0x4d, 0xa6, 0x30, 0xfa, 0xc0, 0x04, 0xf4, 0x71, 0xf2, 0x81, 0xc7,
+0xb8, 0x98, 0x2d, 0x82, 0x24, 0xa4, 0x90, 0xed, 0xbe, 0xb3, 0x3d, 0x3e, 0x3d, 0x5c, 0xc9, 0x3c,
+0x47, 0x65, 0x70, 0x3d, 0x1d, 0xd7, 0x91, 0x64, 0x2f, 0x1f, 0x11, 0x6a, 0x0d, 0xd8, 0x52, 0xbe,
+0x24, 0x19, 0xb2, 0xaf, 0x72, 0xbf, 0xe9, 0xa0, 0x30, 0xe8, 0x60, 0xb0, 0x28, 0x8b, 0x5d, 0x77
+};
+
+/* Prime exponent 1: */
+const uint8_t dp[] = {
+0x0e, 0x12, 0xbf, 0x17, 0x18, 0xe9, 0xce, 0xf5, 0x59, 0x9b, 0xa1, 0xc3, 0x88, 0x2f, 0xe8, 0x04,
+0x6a, 0x90, 0x87, 0x4e, 0xef, 0xce, 0x8f, 0x2c, 0xcc, 0x20, 0xe4, 0xf2, 0x74, 0x1f, 0xb0, 0xa3,
+0x3a, 0x38, 0x48, 0xae, 0xc9, 0xc9, 0x30, 0x5f, 0xbe, 0xcb, 0xd2, 0xd7, 0x68, 0x19, 0x96, 0x7d,
+0x46, 0x71, 0xac, 0xc6, 0x43, 0x1e, 0x40, 0x37, 0x96, 0x8d, 0xb3, 0x78, 0x78, 0xe6, 0x95, 0xc1
+};
+
+/* Prime exponent 2: */
+const uint8_t dq[] = {
+0x95, 0x29, 0x7b, 0x0f, 0x95, 0xa2, 0xfa, 0x67, 0xd0, 0x07, 0x07, 0xd6, 0x09, 0xdf, 0xd4, 0xfc,
+0x05, 0xc8, 0x9d, 0xaf, 0xc2, 0xef, 0x6d, 0x6e, 0xa5, 0x5b, 0xec, 0x77, 0x1e, 0xa3, 0x33, 0x73,
+0x4d, 0x92, 0x51, 0xe7, 0x90, 0x82, 0xec, 0xda, 0x86, 0x6e, 0xfe, 0xf1, 0x3c, 0x45, 0x9e, 0x1a,
+0x63, 0x13, 0x86, 0xb7, 0xe3, 0x54, 0xc8, 0x99, 0xf5, 0xf1, 0x12, 0xca, 0x85, 0xd7, 0x15, 0x83
+};
+
+/* Coefficient: */
+const uint8_t qinv[] = {
+0x4f, 0x45, 0x6c, 0x50, 0x24, 0x93, 0xbd, 0xc0, 0xed, 0x2a, 0xb7, 0x56, 0xa3, 0xa6, 0xed, 0x4d,
+0x67, 0x35, 0x2a, 0x69, 0x7d, 0x42, 0x16, 0xe9, 0x32, 0x12, 0xb1, 0x27, 0xa6, 0x3d, 0x54, 0x11,
+0xce, 0x6f, 0xa9, 0x8d, 0x5d, 0xbe, 0xfd, 0x73, 0x26, 0x3e, 0x37, 0x28, 0x14, 0x27, 0x43, 0x81,
+0x81, 0x66, 0xed, 0x7d, 0xd6, 0x36, 0x87, 0xdd, 0x2a, 0x8c, 0xa1, 0xd2, 0xf4, 0xfb, 0xd8, 0xe1
+};
+
+/*
+ * Example 2: A 1024-bit RSA key pair
+ * ---------------------------------------------------
+ */
+
+/* Modulus: */
+const uint8_t modulus2[] = {
+0x98, 0xb7, 0x05, 0x82, 0xca, 0x80, 0x8f, 0xd1, 0xd3, 0x50, 0x95, 0x62, 0xa0, 0xef, 0x30, 0x5a,
+0xf6, 0xd9, 0x87, 0x54, 0x43, 0xb3, 0x5b, 0xdf, 0x24, 0xd5, 0x36, 0x35, 0x3e, 0x3f, 0x12, 0x28,
+0xdc, 0xd1, 0x2a, 0x78, 0x56, 0x83, 0x56, 0xc6, 0xff, 0x32, 0x3a, 0xbf, 0x72, 0xac, 0x1c, 0xdb,
+0xfe, 0x71, 0x2f, 0xb4, 0x9f, 0xe5, 0x94, 0xa5, 0xa2, 0x17, 0x5d, 0x48, 0xb6, 0x73, 0x25, 0x38,
+0xd8, 0xdf, 0x37, 0xcb, 0x97, 0x0b, 0xe4, 0xa5, 0xb5, 0x62, 0xc3, 0xf2, 0x98, 0xdb, 0x9d, 0xdf,
+0x75, 0x60, 0x78, 0x77, 0x91, 0x8c, 0xce, 0xd1, 0xd0, 0xd1, 0xf3, 0x77, 0x33, 0x8c, 0x0d, 0x3d,
+0x32, 0x07, 0x79, 0x7e, 0x86, 0x2c, 0x65, 0xd1, 0x14, 0x39, 0xe5, 0x88, 0x17, 0x75, 0x27, 0xa7,
+0xde, 0xd9, 0x19, 0x71, 0xad, 0xcf, 0x91, 0xe2, 0xe8, 0x34, 0xe3, 0x7f, 0x05, 0xa7, 0x36, 0x55
+};
+
+/* Public exponent: */
+const uint8_t pub_exponent2[] = {0x01, 0x00, 0x01 };
+
+/* Exponent: */
+const uint8_t priv_exponent2[] = {
+0x06, 0x14, 0xa7, 0x86, 0x05, 0x2d, 0x28, 0x4c, 0xd9, 0x06, 0xa8, 0xe4, 0x13, 0xf7, 0x62, 0x2c,
+0x05, 0x0f, 0x35, 0x49, 0xc0, 0x26, 0x58, 0x9e, 0xa2, 0x77, 0x50, 0xe0, 0xbe, 0xd9, 0x41, 0x0e,
+0x5a, 0x78, 0x83, 0xa1, 0xe6, 0x03, 0xf5, 0xc5, 0x17, 0xad, 0x36, 0xd4, 0x9f, 0xaa, 0xc5, 0xbd,
+0x66, 0xbc, 0xb8, 0x03, 0x0f, 0xa8, 0xd3, 0x09, 0xe3, 0x51, 0xdd, 0xd7, 0x82, 0xd8, 0x43, 0xdf,
+0x97, 0x56, 0x80, 0xae, 0x73, 0xee, 0xa9, 0xaa, 0xb2, 0x89, 0xb7, 0x57, 0x20, 0x5d, 0xad, 0xb8,
+0xfd, 0xfb, 0x98, 0x9e, 0xc8, 0xdb, 0x8e, 0x70, 0x95, 0xf5, 0x1f, 0x24, 0x52, 0x9f, 0x56, 0x37,
+0xaa, 0x66, 0x93, 0x31, 0xe2, 0x56, 0x9f, 0x8b, 0x85, 0x4a, 0xbe, 0xce, 0xc9, 0x9a, 0xa2, 0x64,
+0xc3, 0xda, 0x7c, 0xc6, 0x86, 0x6f, 0x0c, 0x0e, 0x1f, 0xb8, 0x46, 0x98, 0x48, 0x58, 0x1c, 0x73
+};
+
+/* Prime 1: */
+const uint8_t p2[] = {
+0xcb, 0x61, 0xa8, 0x8c, 0x8c, 0x30, 0x5a, 0xd9, 0xa8, 0xfb, 0xec, 0x2b, 0xa4, 0xc8, 0x6c, 0xcc,
+0xc2, 0x02, 0x80, 0x24, 0xaa, 0x16, 0x90, 0xc2, 0x9b, 0xc8, 0x26, 0x4d, 0x2f, 0xeb, 0xe8, 0x7e,
+0x4f, 0x86, 0xe9, 0x12, 0xef, 0x0f, 0x5c, 0x18, 0x53, 0xd7, 0x1c, 0xbc, 0x9b, 0x14, 0xba, 0xed,
+0x3c, 0x37, 0xce, 0xf6, 0xc7, 0xa3, 0x59, 0x8b, 0x6f, 0xbe, 0x06, 0x48, 0x10, 0x90, 0x5b, 0x57
+};
+
+/* Prime 2: */
+const uint8_t q2[] = {
+0xc0, 0x39, 0x9f, 0x0b, 0x93, 0x80, 0xfa, 0xba, 0x38, 0xff, 0x80, 0xd2, 0xff, 0xf6, 0xed, 0xe7,
+0x9c, 0xfd, 0xab, 0xf6, 0x58, 0x97, 0x20, 0x77, 0xa5, 0xe2, 0xb2, 0x95, 0x69, 0x3e, 0xa5, 0x10,
+0x72, 0x26, 0x8b, 0x91, 0x74, 0x6e, 0xea, 0x9b, 0xe0, 0x4a, 0xd6, 0x61, 0x00, 0xeb, 0xed, 0x73,
+0x3d, 0xb4, 0xcd, 0x01, 0x47, 0xa1, 0x8d, 0x6d, 0xe8, 0xc0, 0xcd, 0x8f, 0xbf, 0x24, 0x9c, 0x33
+};
+
+/* Prime exponent 1: */
+const uint8_t dp2[] = {
+0x94, 0x4c, 0x3a, 0x65, 0x79, 0x57, 0x4c, 0xf7, 0x87, 0x33, 0x62, 0xab, 0x14, 0x35, 0x9c, 0xb7,
+0xd5, 0x03, 0x93, 0xc2, 0xa8, 0x4f, 0x59, 0xf0, 0xbd, 0x3c, 0xbd, 0x48, 0xed, 0x17, 0x7c, 0x68,
+0x95, 0xbe, 0x8e, 0xb6, 0xe2, 0x9f, 0xf5, 0x8c, 0x3b, 0x9e, 0x0f, 0xf3, 0x2a, 0xb5, 0x7b, 0xf3,
+0xbe, 0x44, 0x07, 0x62, 0x84, 0x81, 0x84, 0xaa, 0x9a, 0xa9, 0x19, 0xd5, 0x74, 0x56, 0x7e, 0x73
+};
+
+/* Prime exponent 2: */
+const uint8_t dq2[] = {
+0x45, 0xeb, 0xef, 0xd5, 0x87, 0x27, 0x30, 0x8c, 0xd2, 0xb4, 0xe6, 0x08, 0x5a, 0x81, 0x58, 0xd2,
+0x9a, 0x41, 0x8f, 0xee, 0xc1, 0x14, 0xe0, 0x03, 0x85, 0xbc, 0xeb, 0x96, 0xfb, 0xbc, 0x84, 0xd0,
+0x71, 0xa5, 0x61, 0xb9, 0x5c, 0x30, 0x08, 0x79, 0x00, 0xe2, 0x58, 0x0e, 0xdb, 0x05, 0xf6, 0xce,
+0xa7, 0x90, 0x7f, 0xcd, 0xca, 0x5f, 0x92, 0x91, 0x7b, 0x4b, 0xbe, 0xba, 0x5e, 0x1e, 0x14, 0x0f
+};
+
+/* Coefficient: */
+const uint8_t qinv2[] = {
+0xc5, 0x24, 0x68, 0xc8, 0xfd, 0x15, 0xe5, 0xda, 0x2f, 0x6c, 0x8e, 0xba, 0x4e, 0x97, 0xba, 0xeb,
+0xe9, 0x95, 0xb6, 0x7a, 0x1a, 0x7a, 0xd7, 0x19, 0xdd, 0x9f, 0xff, 0x36, 0x6b, 0x18, 0x4d, 0x5a,
+0xb4, 0x55, 0x07, 0x59, 0x09, 0x29, 0x20, 0x44, 0xec, 0xb3, 0x45, 0xcf, 0x2c, 0xdd, 0x26, 0x22,
+0x8e, 0x21, 0xf8, 0x51, 0x83, 0x25, 0x5f, 0x4a, 0x9e, 0x69, 0xf4, 0xc7, 0x15, 0x2e, 0xbb, 0x0f
+};
+
+
+/* PKCS#1 v1.5 encryption of 0x20, random messages with random s0xee,ds
+ * ---------------------------------------------------------------------------
+ */
+
+/* Message: */
+const uint8_t message_x[] = {
+0x66, 0x28, 0x19, 0x4e, 0x12, 0x07, 0x3d, 0xb0, 0x3b, 0xa9, 0x4c, 0xda, 0x9e, 0xf9, 0x53, 0x23,
+0x97, 0xd5, 0x0d, 0xba, 0x79, 0xb9, 0x87, 0x00, 0x4a, 0xfe, 0xfe, 0x34
+};
+
+/* Seed: */
+const uint8_t seed_x[] = {
+0x01, 0x73, 0x41, 0xae, 0x38, 0x75, 0xd5, 0xf8, 0x71, 0x01, 0xf8, 0xcc, 0x4f, 0xa9, 0xb9, 0xbc,
+0x15, 0x6b, 0xb0, 0x46, 0x28, 0xfc, 0xcd, 0xb2, 0xf4, 0xf1, 0x1e, 0x90, 0x5b, 0xd3, 0xa1, 0x55,
+0xd3, 0x76, 0xf5, 0x93, 0xbd, 0x73, 0x04, 0x21, 0x08, 0x74, 0xeb, 0xa0, 0x8a, 0x5e, 0x22, 0xbc,
+0xcc, 0xb4, 0xc9, 0xd3, 0x88, 0x2a, 0x93, 0xa5, 0x4d, 0xb0, 0x22, 0xf5, 0x03, 0xd1, 0x63, 0x38,
+0xb6, 0xb7, 0xce, 0x16, 0xdc, 0x7f, 0x4b, 0xbf, 0x9a, 0x96, 0xb5, 0x97, 0x72, 0xd6, 0x60, 0x6e,
+0x97, 0x47, 0xc7, 0x64, 0x9b, 0xf9, 0xe0, 0x83, 0xdb, 0x98, 0x18, 0x84, 0xa9, 0x54, 0xab, 0x3c,
+0x6f };
+
+/* Encryption: */
+const uint8_t encrypted_x[] = {
+0x50, 0xb4, 0xc1, 0x41, 0x36, 0xbd, 0x19, 0x8c, 0x2f, 0x3c, 0x3e, 0xd2, 0x43, 0xfc, 0xe0, 0x36,
+0xe1, 0x68, 0xd5, 0x65, 0x17, 0x98, 0x4a, 0x26, 0x3c, 0xd6, 0x64, 0x92, 0xb8, 0x08, 0x04, 0xf1,
+0x69, 0xd2, 0x10, 0xf2, 0xb9, 0xbd, 0xfb, 0x48, 0xb1, 0x2f, 0x9e, 0xa0, 0x50, 0x09, 0xc7, 0x7d,
+0xa2, 0x57, 0xcc, 0x60, 0x0c, 0xce, 0xfe, 0x3a, 0x62, 0x83, 0x78, 0x9d, 0x8e, 0xa0, 0xe6, 0x07,
+0xac, 0x58, 0xe2, 0x69, 0x0e, 0xc4, 0xeb, 0xc1, 0x01, 0x46, 0xe8, 0xcb, 0xaa, 0x5e, 0xd4, 0xd5,
+0xcc, 0xe6, 0xfe, 0x7b, 0x0f, 0xf9, 0xef, 0xc1, 0xea, 0xbb, 0x56, 0x4d, 0xbf, 0x49, 0x82, 0x85,
+0xf4, 0x49, 0xee, 0x61, 0xdd, 0x7b, 0x42, 0xee, 0x5b, 0x58, 0x92, 0xcb, 0x90, 0x60, 0x1f, 0x30,
+0xcd, 0xa0, 0x7b, 0xf2, 0x64, 0x89, 0x31, 0x0b, 0xcd, 0x23, 0xb5, 0x28, 0xce, 0xab, 0x3c, 0x31
+};
+
+/*
+ * PKCS#1 v1.5 Encryption Example 2.15
+ * ----------------------------------
+ */
+/* Message: */
+const uint8_t message_2_15[] = {
+0xa6, 0xd0, 0xe8, 0xc1, 0xea, 0x4a, 0xb4, 0xec, 0xc8, 0x95, 0x7d, 0x62, 0x28, 0x15, 0x79, 0x67,
+0x5a, 0x64, 0x8d, 0x62, 0xb7, 0xf2, 0x2b, 0x2b, 0x08, 0xd1, 0x31, 0x3f, 0x40, 0x6f, 0x13, 0x7e,
+0x99, 0x42, 0x67, 0x35, 0xcd, 0xb9, 0x37, 0x2f, 0xec, 0xa1, 0xee, 0x78, 0x46, 0x3f, 0xa5, 0xde,
+0x9c, 0xdd, 0x84, 0x75, 0x6c, 0x68, 0xbd, 0x1d, 0x92, 0xba, 0x96, 0x5f, 0x50, 0x64, 0x10, 0xb1
+};
+
+/* Seed: */
+const uint8_t seed_2_15[] = {
+0x1c, 0x25, 0xc9, 0xb8, 0x32, 0x16, 0x9a, 0x1f, 0xdb, 0x6c, 0x14, 0x8e, 0x47, 0xe6, 0x6c, 0x3c,
+0xc8, 0x21, 0x41, 0xe6, 0x11, 0xa6, 0xf3, 0x0c, 0xc9, 0x0c, 0x50, 0x49, 0xe8, 0xc5, 0x02, 0xb3,
+0x1c, 0xad, 0xc7, 0x62, 0x39, 0xb7, 0xbd, 0xaf, 0x93, 0xfa, 0x97, 0x34, 0x3e, 0x7e, 0xe5, 0x51,
+0xbc, 0x52, 0xfd, 0xb5, 0xec, 0x9e, 0x40, 0x0a, 0xf0, 0x5d, 0xbe, 0xac, 0xda
+};
+
+/* Encryption: */
+const uint8_t encrypted_2_15[] = {
+0xe8, 0xb2, 0xfc, 0x76, 0xdf, 0xb4, 0xa6, 0xcc, 0x43, 0x64, 0xde, 0x8f, 0x68, 0x3c, 0x3f,
+0xcd, 0x0a, 0x9e, 0xcf, 0xbd, 0x4a, 0x5a, 0x72, 0x24, 0xf4, 0x9a, 0xe9, 0xb4, 0xf3, 0xb5, 0xcd,
+0xc7, 0x1c, 0xbb, 0x8c, 0x66, 0xfd, 0x35, 0xf3, 0xd1, 0x8e, 0xca, 0x98, 0x96, 0x7b, 0xd4, 0x00,
+0x5d, 0xf7, 0x91, 0x52, 0x41, 0x6f, 0xd4, 0x7e, 0x56, 0x2c, 0x55, 0xed, 0xc6, 0xd6, 0x12, 0x12,
+0x28, 0x6e, 0xf9, 0x75, 0xbc, 0xc8, 0x02, 0x69, 0x25, 0x92, 0x65, 0x39, 0x00, 0x97, 0x3c, 0x72,
+0xe0, 0x1a, 0x69, 0x3b, 0x05, 0xfc, 0x2d, 0x58, 0x56, 0xea, 0xef, 0x7a, 0xc0, 0x8f, 0xf5, 0xec,
+0xd5, 0x31, 0xe2, 0xc2, 0xce, 0x92, 0x77, 0x45, 0xa1, 0x16, 0x5a, 0x51, 0xaa, 0x66, 0x98, 0xa1,
+0xff, 0xcb, 0x87, 0xf8, 0x1e, 0xf6, 0x51, 0x0b, 0xca, 0xf9, 0xcb, 0x76, 0x1e, 0x9e, 0x1f, 0x0f
+};
+
+uint8_t keys_allocated = 0;
+rsa_publickey_t pub_key;
+rsa_privatekey_t priv_key;
+
+#if 1
+ #define MSG message_2_15
+ #define SEED seed_2_15
+ #define ENCRYPTED encrypted_2_15
+ #define MODULUS modulus2
+ #define PUB_EXPONENT pub_exponent2
+ #define PRIV_EXPONENT priv_exponent2
+ #define P p2
+ #define Q q2
+ #define DP dp2
+ #define DQ dq2
+ #define QINV qinv2
+#endif
+
+
+uint8_t convert_nibble(uint8_t c){
+ if(c>='0' && c<='9'){
+ return c - '0';
+ }
+ c |= 'A' ^ 'a';
+ if(c>='a' && c<='f'){
+ return c - 'a' + 10;
+ }
+ return 0xff;
+}
+
+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 counter = 0;
+ uint16_t c;
+ uint8_t v, tmp = 0, idx = 0;
+ if(!ignore_string){
+ ignore_string = block_ignore_string;
+ }
+ while(counter < length){
+ c = cli_getc();
+ if(c > 0xff){
+ return counter;
+ }
+ if(strchr(ignore_string, c)){
+ continue;
+ }
+ v = convert_nibble(c);
+ if(v > 0x0f){
+ return counter;
+ }
+ if(idx){
+ ((uint8_t*)dst)[counter++] = (tmp << 4) | v;
+ idx = 0;
+ if(counter % (BUFFER_LIMIT/2) == 0){
+ cli_putc('.');
+ }
+ }else{
+ tmp = v;
+ idx = 1;
+ }
+ }
+ return counter;
+}
+
+uint16_t own_atou(const char* str){
+ uint16_t r=0;
+ while(*str && *str >= '0' && *str <= '9'){
+ r *= 10;
+ r += *str++ - '0';
+ }
+ return r;
+}
+
+uint8_t read_bigint(bigint_t* a, char* prompt){
+ uint16_t read_length, actual_length;
+ uint8_t off;
+ uint8_t *buffer;
+ char read_int_str[18];
+ cli_putstr(prompt);
+ cli_putstr("\r\n length: ");
+ cli_getsn(read_int_str, 16);
+ read_length = own_atou(read_int_str);
+ off = (sizeof(bigint_word_t) - (read_length % sizeof(bigint_word_t))) % sizeof(bigint_word_t);
+ buffer = malloc(((read_length + sizeof(bigint_word_t) - 1) / sizeof(bigint_word_t)) * sizeof(bigint_word_t));
+ if(!buffer){
+ cli_putstr("\r\nERROR: OOM!");
+ return 2;
+ }
+ cli_putstr("\r\n data: ");
+ memset(buffer, 0, sizeof(bigint_word_t));
+ actual_length = read_os(buffer + off, read_length, NULL);
+ if(actual_length != read_length){
+ cli_putstr("\r\nERROR: unexpected end of data!");
+ free(buffer);
+ return 1;
+ }
+ a->wordv = (bigint_word_t*)buffer;
+ 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("\r\nERROR: OOM!");
+ return 2;
+ }
+ return 0;
+}
+
+void free_key(void){
+ uint8_t c;
+ free(pub_key.modulus.wordv);
+ free(pub_key.exponent.wordv);
+ pub_key.modulus.wordv = priv_key.modulus.wordv = NULL;
+ for(c = 0; c < priv_key.n; ++c){
+ free(priv_key.components[c].wordv);
+ }
+ free(priv_key.components);
+}
+
+uint8_t read_key_crt(void){
+ uint8_t r;
+ cli_putstr("\r\n== reading key (crt) ==");
+ r = pre_alloc_key_crt();
+ if(r) return r;
+ r = read_bigint(&pub_key.modulus, "\r\n = module =");
+ memcpy(&priv_key.modulus, &pub_key.modulus, sizeof(bigint_t));
+ if(r) return r;
+ 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;
+ cli_putstr("\r\n== reading key (crt) ==");
+ 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;
+ priv_key.components = malloc(sizeof(bigint_t));
+ if(!priv_key.components){
+ cli_putstr("\r\nERROR: OOM!");
+ return 2;
+ }
+ r = read_bigint(&pub_key.exponent, "\r\n = public exponent =");
+ if(r) return r;
+ r = read_bigint(&priv_key.components[0], "\r\n = private exponent =");
+ return r;
+}
+
+void load_priv_conventional(void){
+ priv_key.components = malloc(sizeof(bigint_t));
+ priv_key.components[0].length_W = (sizeof(PRIV_EXPONENT) +
+ sizeof(bigint_word_t) - 1) / sizeof(bigint_word_t);
+ priv_key.components[0].wordv = malloc(priv_key.components[0].length_W *
+ sizeof(bigint_word_t));
+ if(!priv_key.components[0].wordv){
+ cli_putstr("\r\nERROR: OOM!");
+ return;
+ }
+ memcpy(priv_key.components[0].wordv, PRIV_EXPONENT, sizeof(PRIV_EXPONENT));
+ priv_key.n = 1;
+ bigint_changeendianess(&priv_key.components[0]);
+ bigint_adjust(&priv_key.components[0]);
+}
+
+
+void load_priv_crt_mono(void){
+ bigint_t *v;
+ const uint8_t *bv[5] = {P,Q,DP,DQ,QINV};
+ uint16_t sv[5] = {sizeof(P), sizeof(Q), sizeof(DP), sizeof(DQ), sizeof(QINV)};
+ uint8_t i;
+ v = malloc(5 * sizeof(bigint_t));
+ if(!v){
+ cli_putstr("\r\nERROR: OOM!");
+ return;
+ }
+ priv_key.components = v;
+ priv_key.n = 5;
+ for(i=0; i<5; ++i){
+ v[i].info = 0;
+ 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("\r\nERROR: OOM!");
+ return;
+ }
+ memcpy(v[i].wordv, bv[i], sv[i]);
+ bigint_changeendianess(&v[i]);
+ bigint_adjust(&v[i]);
+ }
+}
+
+uint8_t load_bigint_from_os(bigint_t* a, const void* 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("\r\nOOM!\r\n");
+ return 1;
+ }
+ memset(a->wordv, 0, sizeof(bigint_word_t));
+ memcpy((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("\r\nOOM!\r\n");
+ return;
+ }
+
+ load_bigint_from_os(&pub_key.modulus, MODULUS, sizeof(MODULUS));
+ load_bigint_from_os(&pub_key.exponent, PUB_EXPONENT, sizeof(PUB_EXPONENT));
+ priv_key.n = 5;
+ memcpy(&priv_key.modulus, &pub_key.modulus, sizeof(bigint_t));
+ 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));
+
+// load_priv_conventional();
+// load_priv_crt_mono();
+}
+
+void quick_test(void){
+ uint8_t *ciphertext, *plaintext, rc;
+ uint8_t seed[sizeof(SEED)], seed_out[sizeof(SEED)];
+ uint16_t clen, plen;
+ if(!keys_allocated){
+ load_fix_rsa();
+ }
+ ciphertext = malloc(clen = pub_key.modulus.length_W * sizeof(bigint_word_t));
+ plaintext = malloc(pub_key.modulus.length_W * sizeof(bigint_word_t));
+ memcpy(plaintext, MSG, sizeof(MSG));
+ memcpy(seed, SEED, sizeof(SEED));
+ cli_putstr("\r\nplaintext:");
+ cli_hexdump_block(plaintext, sizeof(MSG), 4, 16);
+ cli_putstr("\r\nseed:");
+ cli_hexdump_block(seed, sizeof(SEED), 4, 16);
+ cli_putstr("\r\nencrypting: ...");
+
+ rc = rsa_encrypt_pkcs1v15(ciphertext, &clen, plaintext, sizeof(MSG), &pub_key, seed);
+ if(rc){
+ cli_putstr("\r\nERROR: rsa_encrypt_pkcs1v15 returned: ");
+ cli_hexdump_byte(rc);
+ return;
+
+ }
+
+ cli_putstr("\r\n\r\nciphertext:");
+ cli_hexdump_block(ciphertext, clen, 4, 16);
+ if(clen!=sizeof(ENCRYPTED)){
+ cli_putstr("\r\n>>FAIL (no size match)<<");
+ }else{
+ if(memcmp(ciphertext, ENCRYPTED, clen)){
+ cli_putstr("\r\n>>FAIL (no content match)<<");
+ }else{
+ cli_putstr("\r\n>>OK<<");
+ }
+ }
+
+ cli_putstr("\r\ndecrypting: ...");
+ rc = rsa_decrypt_pkcs1v15(plaintext, &plen, ciphertext, clen, &priv_key, seed_out);
+ if(rc){
+ cli_putstr("\r\nERROR: rsa_decrypt_pkcs1v15 returned: ");
+ cli_hexdump_byte(rc);
+ return;
+ }
+ cli_putstr("\r\n\r\nplaintext:");
+ cli_hexdump_block(plaintext, plen, 4, 16);
+ cli_putstr("\r\n\r\nseed (out):");
+ cli_hexdump_block(seed_out, sizeof(SEED), 4, 16);
+
+ free(ciphertext);
+ free(plaintext);
+}
+
+void run_seed_test(void){
+ uint8_t *msg, *ciph, *msg_;
+ uint16_t msg_len, ciph_len, msg_len_;
+ uint16_t seed_len;
+ uint8_t *seed, *seed_out;
+ char read_int_str[18];
+ cli_putstr("\r\n== test with given seed ==");
+ cli_putstr("\r\n = message =");
+ cli_putstr("\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 = malloc(seed_len);
+ if(!seed){
+ cli_putstr("\r\nERROR: OOM!");
+ return;
+ }
+ seed_out = malloc(seed_len);
+ if(!seed_out){
+ cli_putstr("\r\nERROR: OOM!");
+ return;
+ }
+ msg = malloc(msg_len);
+ if(!msg){
+ cli_putstr("\r\nERROR: OOM!");
+ return;
+ }
+ ciph = malloc(bigint_length_B(&pub_key.modulus));
+ if(!ciph){
+ cli_putstr("\r\nERROR: OOM!");
+ return;
+ }
+ msg_ = malloc(bigint_length_B(&pub_key.modulus));
+ if(!msg_){
+ cli_putstr("\r\nERROR: OOM!");
+ return;
+ }
+ cli_putstr("\r\n data: ");
+ read_os(msg, msg_len, NULL);
+ cli_putstr("\r\n seed (0x");
+ cli_hexdump_rev(&seed_len, 2);
+ cli_putstr(" bytes): ");
+ read_os(seed, seed_len, NULL);
+
+ cli_putstr("\r\n encrypting ...");
+/*
+ cli_putstr("\r\n plaintext:");
+ cli_hexdump_block(msg, msg_len, 4, 16);
+ cli_putstr("\r\n seed:");
+ cli_hexdump_block(seed, seed_len, 4, 16);
+*/
+ rsa_encrypt_pkcs1v15(ciph, &ciph_len, msg, msg_len, &pub_key, seed);
+ cli_putstr("\r\n ciphertext:");
+ cli_hexdump_block(ciph, ciph_len, 4, 16);
+ cli_putstr("\r\n decrypting ... ");
+ rsa_decrypt_pkcs1v15(msg_, &msg_len_, ciph, ciph_len, &priv_key, seed_out);
+ cli_putstr("[done]");
+ if(msg_len != msg_len_){
+ char tstr[16];
+ cli_putstr("\r\nERROR: wrong decrypted message length (");
+ ultoa(msg_len_, tstr, 10);
+ cli_putstr(tstr);
+ cli_putstr(" instead of ");
+ ultoa(msg_len, tstr, 10);
+ cli_putstr(tstr);
+ cli_putc(')');
+ goto end;
+ }
+ if(memcmp(msg, msg_, msg_len)){
+ cli_putstr("\r\nERROR: wrong decrypted message:");
+ cli_hexdump_block(msg_, msg_len_, 4, 16);
+ cli_putstr("\r\nreference:");
+ cli_hexdump_block(msg, msg_len, 4, 16);
+ goto end;
+ }
+
+ if(memcmp(seed, seed_out, seed_len)){
+ cli_putstr("\r\nERROR: wrong decrypted seed:");
+ cli_hexdump_block(seed_out, seed_len, 4, 16);
+ cli_putstr("\r\nreference:");
+ cli_hexdump_block(seed, seed_len, 4, 16);
+ goto end;
+ }
+ cli_putstr("\r\n >>OK<<");
+end:
+ free(ciph);
+ free(msg_);
+ free(msg);
+ free(seed_out);
+ free(seed);
+}
+
+void reset_prng(void){
+ uint8_t buf[16];
+ memset(buf, 0, 16);
+ random_seed(buf);
+ cli_putstr("\r\nPRNG reset");
+}
+
+void rsa_init(void){
+ prng_get_byte = random8;
+}
+
+void load_key(void){
+ if(keys_allocated){
+ free_key();
+ }
+ keys_allocated = 1;
+ read_key_crt();
+}
+
+void test_dump(void){
+ char lstr[16];
+ int len;
+ cli_putstr("\r\nenter dump length: ");
+ cli_getsn(lstr, 15);
+ len = own_atou(lstr);
+ cli_putstr("\r\ndumping 0x");
+ cli_hexdump_rev(&len, 2);
+ cli_putstr(" byte:");
+ cli_hexdump_block(pub_key.modulus.wordv, len, 4, 8);
+}
+
+/*****************************************************************************
+ * main *
+ *****************************************************************************/
+
+const char echo_test_str[] = "echo-test";
+const char reset_prng_str[] = "reset-prng";
+const char load_key_str[] = "load-key";
+const char load_fix_key_str[] = "load-fix-key";
+const char quick_test_str[] = "quick-test";
+const char seed_test_str[] = "seed-test";
+const char dump_test_str[] = "dump-test";
+const char performance_str[] = "performance";
+const char echo_str[] = "echo";
+
+const cmdlist_entry_t cmdlist[] = {
+ { reset_prng_str, NULL, reset_prng },
+ { load_key_str, NULL, load_key },
+ { load_fix_key_str, NULL, load_fix_rsa },
+ { quick_test_str, NULL, quick_test },
+ { seed_test_str, NULL, run_seed_test },
+ { dump_test_str, NULL, test_dump },
+// { performance_str, NULL, testrun_performance_bigint },
+ { echo_str, (void*)1, (void_fpt)echo_ctrl },
+ { NULL, NULL, NULL }
+};
+
+void dump_sp(void){
+ uint8_t x;
+ uint8_t *xa = &x;
+ cli_putstr("\r\nstack pointer: ~");
+ cli_hexdump_rev(&xa, 4);
+}
+
+int main (void){
+ main_setup();
+
+ for(;;){
+ welcome_msg(algo_name);
+ rsa_init();
+ cmd_interface(cmdlist);
+ }
+}
diff --git a/test_src/main-sha2-test.c b/test_src/main-sha2-test.c
new file mode 100644
index 0000000..2c8cd7f
--- /dev/null
+++ b/test_src/main-sha2-test.c
@@ -0,0 +1,217 @@
+/* main-sha512-test.c */
+/*
+ This file is part of the ARM-Crypto-Lib.
+ Copyright (C) 2006-2011 Daniel Otte (daniel.otte@rub.de)
+
+ 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
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see .
+*/
+/*
+ * SHA-512 test-suit
+ *
+*/
+
+#include "main-test-common.h"
+#include "uart_lowlevel.h"
+
+#include "shavs.h"
+#include "nessie_hash_test.h"
+#include "performance_test.h"
+#include "hfal-nessie.h"
+#include "hfal-performance.h"
+#include "hfal-test.h"
+
+
+#include "sha224.h"
+#include "hfal_sha224.h"
+#include "sha256.h"
+#include "hfal_sha256.h"
+#include "sha384.h"
+#include "hfal_sha384.h"
+#include "sha512.h"
+#include "hfal_sha512.h"
+
+const char* algo_name = "SHA-2";
+
+const hfdesc_t* algolist[] = {
+ (hfdesc_t*)&sha224_desc,
+ (hfdesc_t*)&sha256_desc,
+ (hfdesc_t*)&sha384_desc,
+ (hfdesc_t*)&sha512_desc,
+ NULL
+};
+
+/*****************************************************************************
+ * additional validation-functions *
+ *****************************************************************************/
+
+void testrun_nessie_sha2(void){
+ hfal_nessie_multiple(algolist);
+}
+
+void testrun_performance_sha2(void){
+ hfal_performance_multiple(algolist);
+}
+
+void simple_test(void){
+ const char *msg = "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmn"
+ "hijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu";
+
+ uint8_t hash[64];
+ sha512_ctx_t ctx;
+ cli_putstr("\r\nDBG: init ..."); uart_flush(0);
+ sha512_init(&ctx);
+ cli_putstr("\r\nDBG: init done"); uart_flush(0);
+ sha512_lastBlock(&ctx, msg, 3*8);
+ cli_putstr("\r\nDBG: lastBlock done"); uart_flush(0);
+ sha512_ctx2hash(hash, &ctx);
+ cli_putstr("\r\n hash = ");
+ cli_hexdump(hash, 64);
+
+
+ cli_putstr("\r\nDBG: init ..."); uart_flush(0);
+ sha512_init(&ctx);
+ cli_putstr("\r\nDBG: init done"); uart_flush(0);
+ sha512_lastBlock(&ctx, msg, 896);
+ cli_putstr("\r\nDBG: lastBlock done"); uart_flush(0);
+ sha512_ctx2hash(hash, &ctx);
+ cli_putstr("\r\n hash = ");
+ cli_hexdump(hash, 64);
+
+ uint32_t c=0;
+ uint8_t buffer[128];
+ memset(buffer, 'a', 128);
+ cli_putstr("\r\nDBG: init ..."); uart_flush(0);
+ sha512_init(&ctx);
+ cli_putstr("\r\nDBG: init done"); uart_flush(0);
+ do{
+ sha512_nextBlock(&ctx, buffer);
+ c += 128;
+ }while(c+128<1000000L);
+ sha512_lastBlock(&ctx, buffer, (1000000-c)*8);
+ cli_putstr("\r\nDBG: lastBlock done"); uart_flush(0);
+ sha512_ctx2hash(hash, &ctx);
+ cli_putstr("\r\n hash = ");
+ cli_hexdump(hash, 64);
+
+
+}
+
+/*
+void test_monte(void){
+ uint8_t data1[] = {
+ 0xF4, 0x1E, 0xCE, 0x26, 0x13, 0xE4, 0x57, 0x39,
+ 0x15, 0x69, 0x6B, 0x5A, 0xDC, 0xD5, 0x1C, 0xA3,
+ 0x28, 0xBE, 0x3B, 0xF5, 0x66, 0xA9, 0xCA, 0x99,
+ 0xC9, 0xCE, 0xB0, 0x27, 0x9C, 0x1C, 0xB0, 0xA7,
+ 0xF4, 0x1E, 0xCE, 0x26, 0x13, 0xE4, 0x57, 0x39,
+ 0x15, 0x69, 0x6B, 0x5A, 0xDC, 0xD5, 0x1C, 0xA3,
+ 0x28, 0xBE, 0x3B, 0xF5, 0x66, 0xA9, 0xCA, 0x99,
+ 0xC9, 0xCE, 0xB0, 0x27, 0x9C, 0x1C, 0xB0, 0xA7,
+ 0xF4, 0x1E, 0xCE, 0x26, 0x13, 0xE4, 0x57, 0x39,
+ 0x15, 0x69, 0x6B, 0x5A, 0xDC, 0xD5, 0x1C, 0xA3,
+ 0x28, 0xBE, 0x3B, 0xF5, 0x66, 0xA9, 0xCA, 0x99,
+ 0xC9, 0xCE, 0xB0, 0x27, 0x9C, 0x1C, 0xB0, 0xA7 };
+
+ uint8_t data2[] = {
+ 0xF4, 0x1E, 0xCE, 0x26, 0x13, 0xE4, 0x57, 0x39,
+ 0x15, 0x69, 0x6B, 0x5A, 0xDC, 0xD5, 0x1C, 0xA3,
+ 0x28, 0xBE, 0x3B, 0xF5, 0x66, 0xA9, 0xCA, 0x99,
+ 0xC9, 0xCE, 0xB0, 0x27, 0x9C, 0x1C, 0xB0, 0xA7,
+ 0xF4, 0x1E, 0xCE, 0x26, 0x13, 0xE4, 0x57, 0x39,
+ 0x15, 0x69, 0x6B, 0x5A, 0xDC, 0xD5, 0x1C, 0xA3,
+ 0x28, 0xBE, 0x3B, 0xF5, 0x66, 0xA9, 0xCA, 0x99,
+ 0xC9, 0xCE, 0xB0, 0x27, 0x9C, 0x1C, 0xB0, 0xA7,
+ 0xFD, 0xDF, 0x1B, 0x37, 0xDD, 0x34, 0xB3, 0xB2,
+ 0x01, 0xD4, 0x3C, 0x57, 0xBC, 0xDE, 0x11, 0x58,
+ 0x38, 0xF0, 0xDF, 0x70, 0x1D, 0xA9, 0x3C, 0x3B,
+ 0xF2, 0xC9, 0xC8, 0x68, 0x96, 0xE7, 0xE6, 0xC7 };
+ uint8_t hash[SHA256_HASH_BYTES];
+ sha256((sha256_hash_t*)hash, data1, 3*32*8);
+ cli_putstr("\r\n hash(data1) = ");
+ cli_hexdump(hash, 32);
+ sha256((sha256_hash_t*)hash, data2, 3*32*8);
+ cli_putstr("\r\n hash(data2) = ");
+ cli_hexdump(hash, 32);
+}
+
+void test_monte2(void){
+ uint8_t data[] = {
+ 0x6c, 0xd4, 0xc0, 0xc5, 0xcb, 0x2c, 0xa2, 0xa0,
+ 0xf1, 0xd1, 0xae, 0xce, 0xba, 0xc0, 0x3b, 0x52,
+ 0xe6, 0x4e, 0xa0, 0x3d, 0x1a, 0x16, 0x54, 0x37,
+ 0x29, 0x36, 0x54, 0x5b, 0x92, 0xbb, 0xc5, 0x48,
+ 0x4a, 0x59, 0xdb, 0x74, 0xbb, 0x60, 0xf9, 0xc4,
+ 0x0c, 0xeb, 0x1a, 0x5a, 0xa3, 0x5a, 0x6f, 0xaf,
+ 0xe8, 0x03, 0x49, 0xe1, 0x4c, 0x25, 0x3a, 0x4e,
+ 0x8b, 0x1d, 0x77, 0x61, 0x2d, 0xdd, 0x81, 0xac,
+ 0xe9, 0x26, 0xae, 0x8b, 0x0a, 0xf6, 0xe5, 0x31,
+ 0x76, 0xdb, 0xff, 0xcc, 0x2a, 0x6b, 0x88, 0xc6,
+ 0xbd, 0x76, 0x5f, 0x93, 0x9d, 0x3d, 0x17, 0x8a,
+ 0x9b, 0xde, 0x9e, 0xf3, 0xaa, 0x13, 0x1c, 0x61,
+ 0xe3, 0x1c, 0x1e, 0x42, 0xcd, 0xfa, 0xf4, 0xb4,
+ 0xdc, 0xde, 0x57, 0x9a, 0x37, 0xe1, 0x50, 0xef,
+ 0xbe, 0xf5, 0x55, 0x5b, 0x4c, 0x1c, 0xb4, 0x04,
+ 0x39, 0xd8, 0x35, 0xa7, 0x24, 0xe2, 0xfa, 0xe7 };
+
+ uint8_t hash[SHA256_HASH_BYTES];
+ sha256((sha256_hash_t*)hash, data, 1024);
+ cli_putstr("\r\n hash(data) = ");
+ cli_hexdump(hash, 32);
+}
+*/
+/*****************************************************************************
+ * main *
+ *****************************************************************************/
+
+const char nessie_str[] = "nessie";
+const char test_str[] = "test";
+//const char monte_str[] = "monte";
+//const char monte2_str[] = "monte2";
+const char performance_str[] = "performance";
+const char echo_str[] = "echo";
+const char shavs_list_str[] = "shavs_list";
+const char shavs_set_str[] = "shavs_set";
+const char shavs_test1_str[] = "shavs_test1";
+const char shavs_test2_str[] = "shavs_test2";
+const char shavs_test3_str[] = "shavs_test3";
+const char dump_str[] = "dump";
+
+const cmdlist_entry_t cmdlist[] = {
+ { nessie_str, NULL, testrun_nessie_sha2 },
+ { test_str, NULL, simple_test },
+// { monte_str, NULL, test_monte },
+// { monte2_str, NULL, test_monte2 },
+ { performance_str, NULL, testrun_performance_sha2 },
+ { echo_str, (void*)1, (void_fpt)echo_ctrl },
+ { shavs_list_str, NULL, shavs_listalgos },
+ { shavs_set_str, (void*)1, (void_fpt)shavs_setalgo },
+ { shavs_test1_str, NULL, shavs_test1 },
+ { shavs_test2_str, NULL, shavs_test2 },
+ { shavs_test3_str, NULL, shavs_test3 },
+ { dump_str, (void*)1, (void_fpt)dump },
+ { NULL, NULL, NULL }
+};
+
+int main(void) {
+ main_setup();
+
+ shavs_algolist=(hfdesc_t**)algolist;
+ shavs_algo=(hfdesc_t*)&sha256_desc;
+
+ for(;;){
+ welcome_msg(algo_name);
+ cmd_interface(cmdlist);
+ }
+
+}
diff --git a/test_src/nessie_bc_test.c b/test_src/nessie_bc_test.c
new file mode 100644
index 0000000..e67dd1c
--- /dev/null
+++ b/test_src/nessie_bc_test.c
@@ -0,0 +1,214 @@
+/* nessie_bc_test.c */
+/*
+ This file is part of the ARM-Crypto-Lib.
+ Copyright (C) 2006-2010 Daniel Otte (daniel.otte@rub.de)
+
+ 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
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see .
+*/
+/**
+ *
+ * author: Daniel Otte
+ * email: daniel.otte@rub.de
+ * license: GPLv3
+ *
+ * a suit for running the nessie-tests for blockciphers
+ *
+ * */
+#include
+#include
+#include "nessie_bc_test.h"
+#include "nessie_common.h"
+
+volatile nessie_bc_ctx_t nessie_bc_ctx;
+
+void nessie_bc_init(void){
+ memset((void*)&nessie_bc_ctx, 0, sizeof(nessie_bc_ctx_t));
+}
+
+static
+void nessie_bc_free(void* ctx){
+ if(nessie_bc_ctx.cipher_free)
+ nessie_bc_ctx.cipher_free(ctx);
+}
+
+void nessie_bc_enc(uint8_t* key, uint8_t* pt){
+ uint8_t ctx[nessie_bc_ctx.ctx_size_B];
+ uint8_t buffer[nessie_bc_ctx.blocksize_B];
+ uint16_t i;
+
+ /* single test */
+ nessie_print_item("key", key, (nessie_bc_ctx.keysize_b+7)/8);
+ nessie_bc_ctx.cipher_genctx(key, nessie_bc_ctx.keysize_b, ctx);
+
+ memcpy(buffer, pt, nessie_bc_ctx.blocksize_B);
+ nessie_print_item("plain", buffer, nessie_bc_ctx.blocksize_B);
+ nessie_bc_ctx.cipher_enc(buffer, ctx);
+ nessie_print_item("cipher", buffer, nessie_bc_ctx.blocksize_B);
+ if(nessie_bc_ctx.cipher_dec){
+ nessie_bc_ctx.cipher_dec(buffer, ctx);
+ nessie_print_item("decrypted", buffer, nessie_bc_ctx.blocksize_B);
+ }
+ /* 100 times test */
+ memcpy(buffer, pt, nessie_bc_ctx.blocksize_B);
+ for(i=0; i<100; ++i){
+ nessie_bc_ctx.cipher_enc(buffer, ctx);
+ NESSIE_SEND_ALIVE_A(i);
+ }
+ nessie_print_item("Iterated 100 times", buffer, nessie_bc_ctx.blocksize_B);
+#ifndef NESSIE_NO1KTEST
+ /* 1000 times test, we use the 100 preceding steps to fasten things a bit */
+ for(; i<1000; ++i){
+ nessie_bc_ctx.cipher_enc(buffer, ctx);
+ NESSIE_SEND_ALIVE_A(i);
+ }
+ nessie_print_item("Iterated 1000 times", buffer, nessie_bc_ctx.blocksize_B);
+#endif
+ nessie_bc_free(ctx);
+}
+
+void nessie_bc_dec(uint8_t* key, uint8_t* ct){
+ uint8_t ctx[nessie_bc_ctx.ctx_size_B];
+ uint8_t buffer[nessie_bc_ctx.blocksize_B];
+
+ /* single test */
+ nessie_print_item("key", key, (nessie_bc_ctx.keysize_b+7)/8);
+ nessie_bc_ctx.cipher_genctx(key, nessie_bc_ctx.keysize_b, ctx);
+ memcpy(buffer, ct, nessie_bc_ctx.blocksize_B);
+ nessie_print_item("cipher", buffer, nessie_bc_ctx.blocksize_B);
+ nessie_bc_ctx.cipher_dec(buffer, ctx);
+ nessie_print_item("plain", buffer, nessie_bc_ctx.blocksize_B);
+ nessie_bc_ctx.cipher_enc(buffer, ctx);
+ nessie_print_item("encrypted", buffer, nessie_bc_ctx.blocksize_B);
+ nessie_bc_free(ctx);
+}
+
+void nessie_bc_run(void){
+ uint16_t i;
+ uint8_t set;
+ uint8_t key[(nessie_bc_ctx.keysize_b+7)/8];
+ uint8_t buffer[nessie_bc_ctx.blocksize_B];
+
+ nessie_print_header(nessie_bc_ctx.name, nessie_bc_ctx.keysize_b,
+ nessie_bc_ctx.blocksize_B*8, 0, 0, 0);
+ /* test set 1 */
+ set=1;
+ nessie_print_setheader(set);
+ for(i=0; i>(i%8);
+ memset(buffer, 0, nessie_bc_ctx.blocksize_B);
+ nessie_bc_enc(key, buffer);
+ }
+ /* test set 2 */
+ set=2;
+ nessie_print_setheader(set);
+ for(i=0; i>(i%8);
+ nessie_bc_enc(key, buffer);
+ }
+ /* test set 3 */
+ set=3;
+ nessie_print_setheader(set);
+ for(i=0; i<256; ++i){
+ nessie_print_set_vector(set, i);
+ memset(key, i, (nessie_bc_ctx.keysize_b+7)/8);
+ memset(buffer, i, nessie_bc_ctx.blocksize_B);
+ nessie_bc_enc(key, buffer);
+ }
+ /* test set 4 */
+ set=4;
+ nessie_print_setheader(set);
+ /* 4 - 0*/
+ nessie_print_set_vector(set, 0);
+ for(i=0; i<(nessie_bc_ctx.keysize_b+7)/8; ++i){
+ key[i]=i;
+ }
+ for(i=0; i>(i%8);
+ memset(buffer, 0, nessie_bc_ctx.blocksize_B);
+ nessie_bc_dec(key, buffer);
+ }
+ /* test set 6 */
+ set=6;
+ nessie_print_setheader(set);
+ for(i=0; i>(i%8);
+ nessie_bc_dec(key, buffer);
+ }
+ /* test set 7 */
+ set=7;
+ nessie_print_setheader(set);
+ for(i=0; i<256; ++i){
+ nessie_print_set_vector(set, i);
+ memset(key, i, (nessie_bc_ctx.keysize_b+7)/8);
+ memset(buffer, i, nessie_bc_ctx.blocksize_B);
+ nessie_bc_dec(key, buffer);
+ }
+ /* test set 8 */
+ set=8;
+ nessie_print_setheader(set);
+ /* 8 - 0*/
+ nessie_print_set_vector(set, 0);
+ for(i=0; i<(nessie_bc_ctx.keysize_b+7)/8; ++i){
+ key[i]=(uint8_t)i;
+ }
+ for(i=0; i.
+*/
+#ifndef NESSIE_BC_TEST_H_
+#define NESSIE_BC_TEST_H_
+
+#include
+
+typedef void (*nessie_bc_gen_fpt)(const uint8_t* key, uint16_t keysize_b, void* ctx);
+typedef void (*nessie_bc_free_fpt)(void* ctx);
+typedef void (*nessie_bc_enc_fpt)(void* buffer, const void* ctx);
+typedef void (*nessie_bc_dec_fpt)(void* buffer, const void* ctx);
+
+typedef struct nessie_bc_ctx_st{
+ uint16_t keysize_b;
+ uint16_t blocksize_B;
+ uint16_t ctx_size_B;
+ const char* name;
+ nessie_bc_gen_fpt cipher_genctx;
+ nessie_bc_free_fpt cipher_free;
+ nessie_bc_enc_fpt cipher_enc;
+ nessie_bc_dec_fpt cipher_dec;
+} nessie_bc_ctx_t;
+
+
+extern volatile nessie_bc_ctx_t nessie_bc_ctx;
+
+void nessie_bc_run(void);
+void nessie_bc_init(void);
+
+
+#endif /*NESSIE_BC_TEST_H_*/
diff --git a/test_src/nessie_mac_test.c b/test_src/nessie_mac_test.c
new file mode 100644
index 0000000..dcab69a
--- /dev/null
+++ b/test_src/nessie_mac_test.c
@@ -0,0 +1,302 @@
+/* nessie_mac_test.c */
+/*
+ This file is part of the ARM-Crypto-Lib.
+ Copyright (C) 2006-2010 Daniel Otte (daniel.otte@rub.de)
+
+ 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
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see .
+*/
+/**
+ *
+ * author: Daniel Otte
+ * email: daniel.otte@rub.de
+ * license: GPLv3
+ *
+ * a suit for running the nessie-tests for MACs
+ *
+ * */
+#include
+#include
+#include
+#include "nessie_mac_test.h"
+#include "nessie_common.h"
+#include "dbz_strings.h"
+
+nessie_mac_ctx_t nessie_mac_ctx;
+
+#define KEYSIZE_B ((nessie_mac_ctx.keysize_b+7)/8)
+#define MACSIZE_B ((nessie_mac_ctx.macsize_b+7)/8)
+#define BLOCKSIZE_B (nessie_mac_ctx.blocksize_B)
+
+#define PRINTKEY nessie_print_item("key", key, KEYSIZE_B)
+#define PRINTMAC nessie_print_item("MAC", mac, MACSIZE_B)
+
+
+static const uint8_t keyproto[] = {
+ 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
+ 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
+ 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
+
+static
+void ascii_mac(const void* data, const void* desc, uint8_t* key){
+ uint8_t ctx[nessie_mac_ctx.ctx_size_B];
+ uint8_t mac[MACSIZE_B];
+ uint16_t sl;
+ uint8_t buffer[BLOCKSIZE_B];
+
+ NESSIE_PUTSTR("\r\n message=");
+ NESSIE_PUTSTR(desc);
+ PRINTKEY;
+ nessie_mac_ctx.mac_init(ctx, key, nessie_mac_ctx.keysize_b);
+ sl = strlen(data);
+ while(sl>nessie_mac_ctx.blocksize_B){
+ memcpy(buffer, data, BLOCKSIZE_B);
+ nessie_mac_ctx.mac_next(ctx, buffer);
+ data = (uint8_t*)data + BLOCKSIZE_B;
+ sl -= BLOCKSIZE_B;
+ }
+ memcpy(buffer, data, sl);
+ nessie_mac_ctx.mac_last(ctx, buffer, sl*8);
+ nessie_mac_ctx.mac_conv(mac, ctx);
+ PRINTMAC;
+}
+
+// message=1 million times "a"
+
+static
+void amillion_mac(uint8_t* key){
+ uint8_t ctx[nessie_mac_ctx.ctx_size_B];
+ uint8_t mac[MACSIZE_B];
+ uint8_t block[nessie_mac_ctx.blocksize_B];
+ uint32_t n=1000000LL;
+ uint16_t i=0;
+
+ NESSIE_PUTSTR("\r\n message=");
+ NESSIE_PUTSTR("1 million times \"a\"");
+ PRINTKEY;
+
+ memset(block, 'a', nessie_mac_ctx.blocksize_B);
+ nessie_mac_ctx.mac_init(ctx, key, nessie_mac_ctx.keysize_b);
+ while(n>=nessie_mac_ctx.blocksize_B){
+ nessie_mac_ctx.mac_next(ctx, block);
+ n -= nessie_mac_ctx.blocksize_B;
+ NESSIE_SEND_ALIVE_A(i++);
+ }
+ nessie_mac_ctx.mac_last(ctx, block, n*8);
+ nessie_mac_ctx.mac_conv(mac, ctx);
+ PRINTMAC;
+}
+
+
+static
+void zero_mac(uint16_t n, uint8_t* key){
+ uint8_t ctx[nessie_mac_ctx.ctx_size_B];
+ uint8_t mac[MACSIZE_B];
+ uint8_t block[nessie_mac_ctx.blocksize_B];
+
+ NESSIE_PUTSTR("\r\n message=");
+ if(n>=10000)
+ NESSIE_PUTC('0'+n/10000);
+ if(n>=1000)
+ NESSIE_PUTC('0'+(n/1000)%10);
+ if(n>=100)
+ NESSIE_PUTC('0'+(n/100)%10);
+ if(n>=10)
+ NESSIE_PUTC('0'+(n/10)%10);
+ NESSIE_PUTC('0'+n%10);
+ NESSIE_PUTSTR(" zero bits");
+ PRINTKEY;
+
+ memset(block, 0, nessie_mac_ctx.blocksize_B);
+ nessie_mac_ctx.mac_init(ctx, key, nessie_mac_ctx.keysize_b);
+ while(n>nessie_mac_ctx.blocksize_B*8){
+ nessie_mac_ctx.mac_next(ctx, block);
+ n -= nessie_mac_ctx.blocksize_B*8;
+ }
+ nessie_mac_ctx.mac_last(ctx, block, n);
+ nessie_mac_ctx.mac_conv(mac, ctx);
+ PRINTMAC;
+}
+
+static
+void one_in512_mac(uint16_t pos, uint8_t* key){
+ uint8_t ctx[nessie_mac_ctx.ctx_size_B];
+ uint8_t mac[MACSIZE_B];
+ uint8_t block[nessie_mac_ctx.blocksize_B];
+ uint16_t n=512;
+ char* tab[8]={"80", "40", "20", "10",
+ "08", "04", "02", "01" };
+
+ pos&=511;
+ NESSIE_PUTSTR("\r\n message=");
+ NESSIE_PUTSTR("512-bit string: ");
+ if((pos/8) >=10){
+ NESSIE_PUTC('0'+(pos/8/10)%10);
+ } else {
+ NESSIE_PUTC(' ');
+ }
+ NESSIE_PUTC('0'+(pos/8)%10);
+ NESSIE_PUTSTR("*00,");
+ NESSIE_PUTSTR(tab[pos&7]);
+ NESSIE_PUTC(',');
+ if(63-(pos/8) >=10){
+ NESSIE_PUTC('0'+((63-pos/8)/10)%10);
+ } else {
+ NESSIE_PUTC(' ');
+ }
+ NESSIE_PUTC('0'+(63-pos/8)%10);
+ NESSIE_PUTSTR("*00");
+ PRINTKEY;
+
+ /* now the real stuff */
+ memset(block, 0, 512/8);
+ block[pos>>3] = 0x80>>(pos&0x7);
+ uint8_t* bp;
+ bp = block;
+ nessie_mac_ctx.mac_init(ctx, key, nessie_mac_ctx.keysize_b);
+ while(n>nessie_mac_ctx.blocksize_B*8){
+ nessie_mac_ctx.mac_next(ctx, bp);
+ n -= nessie_mac_ctx.blocksize_B*8;
+ bp += nessie_mac_ctx.blocksize_B;
+ }
+ nessie_mac_ctx.mac_last(ctx, bp, n);
+ nessie_mac_ctx.mac_conv(mac, ctx);
+ PRINTMAC;
+}
+
+static
+void tv4_mac(void){
+ uint8_t ctx[nessie_mac_ctx.ctx_size_B];
+ uint8_t mac[MACSIZE_B];
+ uint8_t block[MACSIZE_B];
+ uint8_t key[KEYSIZE_B];
+ uint16_t n=MACSIZE_B*8;
+ uint32_t i;
+ char str[6];
+
+ NESSIE_PUTSTR("\r\n message=");
+ utoa(MACSIZE_B*8, str, 10);
+ NESSIE_PUTSTR(str);
+ NESSIE_PUTSTR(" zero bits");
+ memset(block, 0, MACSIZE_B);
+ for(i=0; inessie_mac_ctx.blocksize_B*8){
+ nessie_mac_ctx.mac_next(ctx, block);
+ n -= nessie_mac_ctx.blocksize_B*8;
+ }
+ nessie_mac_ctx.mac_last(ctx, block, n);
+ nessie_mac_ctx.mac_conv(mac, ctx);
+ PRINTMAC;
+ for(i=1; i<100000L; ++i){ /* this assumes BLOCKSIZE >= HASHSIZE */
+ nessie_mac_ctx.mac_init(ctx, key, nessie_mac_ctx.keysize_b);
+ nessie_mac_ctx.mac_last(ctx, mac, nessie_mac_ctx.macsize_b);
+ nessie_mac_ctx.mac_conv(mac, ctx);
+ NESSIE_SEND_ALIVE_A(i);
+ }
+ nessie_print_item("iterated 100000 times", mac, MACSIZE_B);
+}
+
+void nessie_mac_run(void){
+ uint16_t i;
+ uint8_t set;
+ uint8_t key[KEYSIZE_B];
+
+ nessie_print_header(nessie_mac_ctx.name, nessie_mac_ctx.keysize_b, 0, 0,
+ nessie_mac_ctx.macsize_b, 0);
+ /* test set 1 */
+ const char* challange_dbz=
+ "\0"
+ "\"\" (empty string)\0"
+ "a\0"
+ "\"a\"\0"
+ "abc\0"
+ "\"abc\"\0"
+ "message digest\0"
+ "\"message digest\"\0"
+ "abcdefghijklmnopqrstuvwxyz\0"
+ "\"abcdefghijklmnopqrstuvwxyz\"\0"
+ "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq\0"
+ "\"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq\"\0"
+ "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+ "abcdefghijklmnopqrstuvwxyz"
+ "0123456789\0"
+ "\"A...Za...z0...9\"\0"
+ "1234567890123456789012345678901234567890"
+ "1234567890123456789012345678901234567890\0"
+ "8 times \"1234567890\"\0"
+ "Now is the time for all \0"
+ "\"Now is the time for all \"\0"
+ "Now is the time for it\0"
+ "\"Now is the time for it\"\0"
+ ;
+
+ set=1;
+ nessie_print_setheader(set);
+ for(i=0; i>3]=0x80>>(i&0x7);
+ ascii_mac("ABC", "\"ABC\"", key);
+ }
+ nessie_print_footer();
+}
diff --git a/test_src/nessie_mac_test.h b/test_src/nessie_mac_test.h
new file mode 100644
index 0000000..dd1119f
--- /dev/null
+++ b/test_src/nessie_mac_test.h
@@ -0,0 +1,47 @@
+/* nessie_mac_test.h */
+/*
+ This file is part of the ARM-Crypto-Lib.
+ Copyright (C) 2008 Daniel Otte (daniel.otte@rub.de)
+
+ 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
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see .
+*/
+#ifndef NESSIE_MAC_TEST_H_
+#define NESSIE_MAC_TEST_H_
+
+#include
+
+typedef void (*nessie_mac_init_fpt)(void* ctx, const void* key, uint16_t keysize_b);
+typedef void (*nessie_mac_next_fpt)(void* ctx, const void* buffer);
+typedef void (*nessie_mac_last_fpt)(void* ctx, const void* buffer, uint16_t size_b);
+typedef void (*nessie_mac_conv_fpt)(void* buffer, void* ctx);
+
+
+typedef struct nessie_mac_ctx_st{
+ uint16_t macsize_b;
+ uint16_t keysize_b;
+ uint16_t blocksize_B;
+ uint16_t ctx_size_B;
+ const char* name;
+ nessie_mac_init_fpt mac_init;
+ nessie_mac_next_fpt mac_next;
+ nessie_mac_last_fpt mac_last;
+ nessie_mac_conv_fpt mac_conv;
+} nessie_mac_ctx_t;
+
+
+extern nessie_mac_ctx_t nessie_mac_ctx;
+
+void nessie_mac_run(void);
+
+#endif /*NESSIE_MAC_TEST_H_*/
diff --git a/test_src/nessie_stream_test.c b/test_src/nessie_stream_test.c
new file mode 100644
index 0000000..7545a3b
--- /dev/null
+++ b/test_src/nessie_stream_test.c
@@ -0,0 +1,185 @@
+/* nessie_stream_test.c */
+/*
+ This file is part of the ARM-Crypto-Lib.
+ Copyright (C) 2008 Daniel Otte (daniel.otte@rub.de)
+
+ 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
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see .
+*/
+/**
+ *
+ * author: Daniel Otte
+ * email: daniel.otte@rub.de
+ * license: GPLv3
+ *
+ * a suit for running the nessie-tests for streamciphers
+ *
+ * */
+#include
+#include
+#include "nessie_stream_test.h"
+#include "nessie_common.h"
+#include "memxor.h"
+
+nessie_stream_ctx_t nessie_stream_ctx;
+
+
+#define BLOCKSIZE_B 64
+
+
+static
+void nessie_gen_block(void* ctx, uint8_t* block){
+ uint16_t i;
+ for(i=0; i>(i%8);
+ nessie_stream_enc(key);
+ }
+ /* test set 2 */
+ set=2;
+ nessie_print_setheader(set);
+ for(i=0; i<256; ++i){
+ nessie_print_set_vector(set, i);
+ memset(key, i, (nessie_stream_ctx.keysize_b+7)/8);
+ nessie_stream_enc(key);
+ }
+ /* test set 3 */
+ set=3;
+ nessie_print_setheader(set);
+ for(i=0; i<256; ++i){
+ uint8_t j;
+ nessie_print_set_vector(set, i);
+ for(j=0; j<(nessie_stream_ctx.keysize_b+7)/8; ++j){
+ key[j]=(i+j)&0xff;
+ }
+ nessie_stream_enc(key);
+ }
+ /* test set 4 */
+ set=4;
+ nessie_print_setheader(set);
+ for(i=0; i<4; ++i){
+ uint8_t j;
+ nessie_print_set_vector(set, i);
+ for(j=0; j<(nessie_stream_ctx.keysize_b+7)/8; ++j){
+ key[j]=(i*5+j*0x53)&0xff;
+ }
+ nessie_stream_enc_large(key);
+ }
+
+ nessie_print_footer();
+}
diff --git a/test_src/nessie_stream_test.h b/test_src/nessie_stream_test.h
new file mode 100644
index 0000000..00fa7b6
--- /dev/null
+++ b/test_src/nessie_stream_test.h
@@ -0,0 +1,42 @@
+/* nessie_stream_test.h */
+/*
+ This file is part of the ARM-Crypto-Lib.
+ Copyright (C) 2008 Daniel Otte (daniel.otte@rub.de)
+
+ 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
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see .
+*/
+#ifndef NESSIE_STREAM_TEST_H_
+#define NESSIE_STREAM_TEST_H_
+
+#include
+
+typedef void (*nessie_stream_genctx_fpt)(uint8_t* key, uint16_t keylength_b, void* ctx);
+typedef uint8_t (*nessie_stream_genenc_fpt)(void* ctx);
+
+typedef struct nessie_stream_ctx_st{
+ uint16_t keysize_b;
+ uint16_t ivsize_b;
+ uint16_t outsize_b;
+ uint16_t ctx_size_B;
+ char* name;
+ nessie_stream_genctx_fpt cipher_genctx;
+ nessie_stream_genenc_fpt cipher_enc;
+} nessie_stream_ctx_t;
+
+
+extern nessie_stream_ctx_t nessie_stream_ctx;
+
+void nessie_stream_run(void);
+
+#endif /*NESSIE_STREAM_TEST_H_*/