28 * modes: cbc, ecb, ...
29 * need Hashes, asymetrics, signatures, ...
33 #include "serial-tools.h"
47 /*****************************************************************************
48 * additional validation-functions *
49 *****************************************************************************/
51 void shavs_rnd(sha256_hash_t seed){
52 uint8_t md[4][SHA256_HASH_BITS/8], buffer[3*SHA256_HASH_BITS/8];
56 for(j=0; j< 100; ++j){
57 memcpy(md[0], seed, SHA256_HASH_BITS/8);
58 memcpy(md[1], seed, SHA256_HASH_BITS/8);
59 memcpy(md[2], seed, SHA256_HASH_BITS/8);
60 for(i=3; i<1003; ++i){
61 memcpy(buffer+0*(SHA256_HASH_BITS/8), md[(i-3)%4], SHA256_HASH_BITS/8);
62 memcpy(buffer+1*(SHA256_HASH_BITS/8), md[(i-2)%4], SHA256_HASH_BITS/8);
63 memcpy(buffer+2*(SHA256_HASH_BITS/8), md[(i-1)%4], SHA256_HASH_BITS/8);
64 sha256(((void*)md[i%4]), buffer, 3*SHA256_HASH_BITS);
69 uart_putstr("\r\nMD = ");
70 uart_hexdump(md[i%4], SHA256_HASH_BITS/8);
72 memcpy(seed, (md[i%4]), SHA256_HASH_BITS/8);
76 /*****************************************************************************
78 *****************************************************************************/
79 void testrun_sha256(void){
80 uint8_t block[SHA256_BLOCK_BITS/8];
82 uart_putstr("\r\nsha256(\"\", 0)= ");
83 sha256((void*)block, (void*)"\x00", 0);
84 uart_hexdump(block, SHA256_HASH_BITS/8);
87 uart_putstr("\r\nsha256(0x80, 8)= ");
88 sha256((void*)block, (void*)"\x80", 8);
89 uart_hexdump(block, SHA256_HASH_BITS/8);
91 uart_putstr("\r\nsha256(0x02, 8)= ");
92 sha256((void*)block, (void*)"\x02", 8);
93 uart_hexdump(block, SHA256_HASH_BITS/8);
96 uart_putstr("\r\nsha256(\"abc\", 24)= ");
97 sha256((void*)block, (void*)"abc", 24);
98 uart_hexdump(block, SHA256_HASH_BITS/8);
100 uart_putstr("\r\nsha256(\"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq\", 24)= ");
101 sha256((void*)block, (void*) "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 448);
102 uart_hexdump(block, SHA256_HASH_BITS/8);
104 uart_putstr("\r\nsha256(1,000,000 x 'a')= ");
109 memset(block,'a',SHA256_BLOCK_BITS/8);
110 for(i=0; i<(1000000/(SHA256_BLOCK_BITS/8)); ++i){ /* 15625 times*/
111 sha256_nextBlock(&s, block);
113 sha256_lastBlock(&s, block, 0);
114 sha256_ctx2hash((void*)block, &s);
116 uart_hexdump(block, SHA256_HASH_BITS/8);
119 void testrun_xtea(void){
120 uint8_t block[8], block2[8];
123 memcpy (block, "abcdefgh", 8);
125 memset (block2, 0, 8);
126 uart_putstr("\r\nxtea_enc(\"abcdefgh\", 0)= ");
127 xtea_enc((void*)block2, (void*)block, (void*)key);
128 uart_hexdump(block2, 8);
129 uart_putstr("\r\nxtea_dec(form above)= ");
130 xtea_dec((void*)block, (void*)block2, (void*)key);
131 uart_hexdump(block, 8);
133 memcpy (key, "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f", 16);
134 uart_putstr("\r\nxtea_enc(\"abcdefgh\", 000102030405060708090a0b0c0d0e0f)= ");
135 xtea_enc((void*)block, (void*)block, (void*)key);
136 uart_hexdump(block, 8);
137 uart_putstr("\r\nxtea_dec(form above)= ");
138 xtea_dec((void*)block, (void*)block, (void*)key);
139 uart_hexdump(block, 8);
142 void testrun_arcfour(void){
145 /* using wikipedia test-vectors:
146 * RC4( "Key", "Plaintext" ) == "bbf316e8 d940af0a d3"
147 * RC4( "Wiki", "pedia" ) == "1021bf0420"
148 * RC4( "Secret", "Attack at dawn" ) == "45a01f64 5fc35b38 3552544b 9bf5"
150 uart_putstr("\r\narcfour(\"Plaintext\", \"Key\")=");
151 arcfour_init(&s, "Key", 3);
154 *b++ ^= arcfour_gen(&s);
155 uart_hexdump(b-9, 9);
157 uart_putstr("\r\narcfour(\"pedia\", \"Wiki\")=");
158 arcfour_init(&s, "Wiki", 4);
161 *b++ ^= arcfour_gen(&s);
162 uart_hexdump(b-5, 5);
164 uart_putstr("\r\narcfour(\"Attack at dawn\", \"Secret\")=");
165 arcfour_init(&s, "Secret", 6);
168 *b++ ^= arcfour_gen(&s);
169 uart_hexdump(b-14, 14);
171 uart_putstr("\r\narcfour(00.00.00.00.00.00.00.00, 01.23.45.67.89.AB.CD.EF)=");
172 arcfour_init(&s, "\x01\x23\x45\x67\x89\xAB\xCD\xEF", 8);
177 a[i++] ^= arcfour_gen(&s);
181 void testrun_prng(void){
183 uart_putstr("\r\naddEntropy(32, 0x00000000)");
184 addEntropy(32,"\x00\x00\x00\x00");
186 getRandomBlock((void*)block);
188 uart_hexdump(block, 32);
192 void testrun_cast5(void){
195 uart_putstr("\r\nCAST5:\r\nkey: 01 23 45 67 34 56 78 23 45 67 89 34 56 78 9A");
196 cast5_init(&s, "\x01\x23\x45\x67\x12\x34\x56\x78\x23\x45\x67\x89\x34\x56\x78\x9A", 128);
197 uint8_t block[] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF};
198 uart_putstr("\r\nplaintext: ");
199 uart_hexdump(block, 8);
200 cast5_enc(&s, block);
201 uart_putstr("\r\nciphertext: ");
202 uart_hexdump(block, 8);
204 uart_putstr("\r\nK"); uart_putc('0'+(i+1)/10); uart_putc('0'+(i+1)%10); uart_putstr(": ");
205 uart_hexdump(&(s.mask[i]),4);
209 /*****************************************************************************
211 *****************************************************************************/
218 uint8_t block[SHA256_BLOCK_BITS/8];
225 uart_putstr("\r\n\r\nCrypto-VS\r\nloaded and running\r\n");
228 if (!getnextwordn(str,20)) {DEBUG_S("DBG: W1\r\n"); goto error;}
229 if (strcmp(str, "REQ")) {DEBUG_S("DBG: 1b\r\n"); goto error;}
230 if (!getnextwordn(str,20)) {DEBUG_S("DBG: W2\r\n"); goto error;}
231 if (strcmp(str, "SHA256")) {
232 if (strcmp(str, "test")){DEBUG_S("DBG: 1d\r\n"); goto error;};
233 /* use some fixed test-vectors and all Algos */
234 uart_putstr("\r\n intergrated selftests:\r\n");
246 if (!getnextwordn(str,20)) {DEBUG_S("DBG: W4\r\n"); goto error;}
247 if (strcmp(str, "Len=")) {
248 /* 1d9370cdccba99b23670e2e0d6514001006f50d3c7a453201d2776f03c5e58fd */
249 /* f41ece26 13e45739 15696b5a dcd51ca3
250 28be3bf5 66a9ca99 c9ceb027 9c1cb0a7
252 if(strcmp(str, "rnd")){DEBUG_S("DBG: 2b\r\n"); goto error;}
253 sha256_hash_t seed = {0x1d, 0x93, 0x70, 0xcd, 0xcc, 0xba, 0x99, 0xb2, 0x36, 0x70,
254 0xe2, 0xe0, 0xd6, 0x51, 0x40, 0x01, 0x00, 0x6f, 0x50, 0xd3,
255 0xc7, 0xa4, 0x53, 0x20, 0x1d, 0x27, 0x76, 0xf0, 0x3c, 0x5e,
257 { 0xf4, 0x1e, 0xce, 0x26, 0x13, 0xe4, 0x57, 0x39, 0x15, 0x69, 0x6b, 0x5a, 0xdc, 0xd5, 0x1c, 0xa3,
258 0x28, 0xbe, 0x3b, 0xf5, 0x66, 0xa9, 0xca, 0x99, 0xc9, 0xce, 0xb0, 0x27, 0x9c, 0x1c, 0xb0, 0xa7 };
264 if (!getnextwordn(str,20)) {DEBUG_S("DBG: W5\r\n"); goto error;}
268 while (str[i]){ /* we should check for error here */
270 length += str[i++] - '0';
273 // DEBUG_S("\r\nDBG: Length="); DEBUG_B(length&0xff); DEBUG_S("\r\n");
277 if (!getnextwordn(str,20)) {DEBUG_S("DBG: W6\r\n"); goto error;}
279 if (strcmp(str, "Msg=")) {DEBUG_S("DBG: 4b\r\n"); goto error;}
282 memset(block, 0, SHA256_BLOCK_BITS/8);
284 while (length>=SHA256_BLOCK_BITS){
285 readhex2buffer(block, SHA256_BLOCK_BITS/8);
287 sha256_nextBlock(&s, block);
289 length -= SHA256_BLOCK_BITS;
292 readhex2buffer(block, (length/8) + ((length&0x7)?1:0) + ((length)?0:1));
294 sha256_lastBlock(&s, block, length);
296 sha256_ctx2hash((void*)block, &s);
297 uart_putstr("\n\rMD= ");
298 uart_hexdump(block, SHA256_HASH_BITS/8);
299 uart_putstr("\n\r\n\r");
303 uart_putstr("ERROR\r\n");