|
380
|
1 #include <tomcrypt_test.h> |
|
|
2 |
|
|
3 #ifdef MKAT |
|
|
4 |
|
|
5 int katja_test(void) |
|
|
6 { |
|
|
7 unsigned char in[1024], out[1024], tmp[1024]; |
|
|
8 katja_key key, privKey, pubKey; |
|
|
9 int hash_idx, prng_idx, stat, stat2, size; |
|
|
10 unsigned long kat_msgsize, len, len2, cnt; |
|
|
11 static unsigned char lparam[] = { 0x01, 0x02, 0x03, 0x04 }; |
|
|
12 |
|
|
13 hash_idx = find_hash("sha1"); |
|
|
14 prng_idx = find_prng("yarrow"); |
|
|
15 if (hash_idx == -1 || prng_idx == -1) { |
|
|
16 fprintf(stderr, "katja_test requires SHA1 and yarrow"); |
|
|
17 return 1; |
|
|
18 } |
|
|
19 |
|
|
20 for (size = 1024; size <= 2048; size += 256) { |
|
|
21 |
|
|
22 /* make 10 random key */ |
|
|
23 for (cnt = 0; cnt < 10; cnt++) { |
|
|
24 DO(katja_make_key(&yarrow_prng, prng_idx, size/8, &key)); |
|
|
25 if (mp_count_bits(key.N) < size - 7) { |
|
|
26 fprintf(stderr, "katja_%d key modulus has %d bits\n", size, mp_count_bits(key.N)); |
|
|
27 |
|
|
28 len = mp_unsigned_bin_size(key.N); |
|
|
29 mp_to_unsigned_bin(key.N, tmp); |
|
|
30 fprintf(stderr, "N == \n"); |
|
|
31 for (cnt = 0; cnt < len; ) { |
|
|
32 fprintf(stderr, "%02x ", tmp[cnt]); |
|
|
33 if (!(++cnt & 15)) fprintf(stderr, "\n"); |
|
|
34 } |
|
|
35 |
|
|
36 len = mp_unsigned_bin_size(key.p); |
|
|
37 mp_to_unsigned_bin(key.p, tmp); |
|
|
38 fprintf(stderr, "p == \n"); |
|
|
39 for (cnt = 0; cnt < len; ) { |
|
|
40 fprintf(stderr, "%02x ", tmp[cnt]); |
|
|
41 if (!(++cnt & 15)) fprintf(stderr, "\n"); |
|
|
42 } |
|
|
43 |
|
|
44 len = mp_unsigned_bin_size(key.q); |
|
|
45 mp_to_unsigned_bin(key.q, tmp); |
|
|
46 fprintf(stderr, "\nq == \n"); |
|
|
47 for (cnt = 0; cnt < len; ) { |
|
|
48 fprintf(stderr, "%02x ", tmp[cnt]); |
|
|
49 if (!(++cnt & 15)) fprintf(stderr, "\n"); |
|
|
50 } |
|
|
51 fprintf(stderr, "\n"); |
|
|
52 |
|
|
53 |
|
|
54 return 1; |
|
|
55 } |
|
|
56 if (cnt != 9) { |
|
|
57 katja_free(&key); |
|
|
58 } |
|
|
59 } |
|
|
60 /* encrypt the key (without lparam) */ |
|
|
61 for (cnt = 0; cnt < 4; cnt++) { |
|
|
62 for (kat_msgsize = 1; kat_msgsize <= 42; kat_msgsize++) { |
|
|
63 /* make a random key/msg */ |
|
|
64 yarrow_read(in, kat_msgsize, &yarrow_prng); |
|
|
65 |
|
|
66 len = sizeof(out); |
|
|
67 len2 = kat_msgsize; |
|
|
68 |
|
|
69 DO(katja_encrypt_key(in, kat_msgsize, out, &len, NULL, 0, &yarrow_prng, prng_idx, hash_idx, &key)); |
|
|
70 /* change a byte */ |
|
|
71 out[8] ^= 1; |
|
|
72 DO(katja_decrypt_key(out, len, tmp, &len2, NULL, 0, hash_idx, &stat2, &key)); |
|
|
73 /* change a byte back */ |
|
|
74 out[8] ^= 1; |
|
|
75 if (len2 != kat_msgsize) { |
|
|
76 fprintf(stderr, "\nkatja_decrypt_key mismatch len %lu (first decrypt)", len2); |
|
|
77 return 1; |
|
|
78 } |
|
|
79 |
|
|
80 len2 = kat_msgsize; |
|
|
81 DO(katja_decrypt_key(out, len, tmp, &len2, NULL, 0, hash_idx, &stat, &key)); |
|
|
82 if (!(stat == 1 && stat2 == 0)) { |
|
|
83 fprintf(stderr, "katja_decrypt_key failed"); |
|
|
84 return 1; |
|
|
85 } |
|
|
86 if (len2 != kat_msgsize || memcmp(tmp, in, kat_msgsize)) { |
|
|
87 unsigned long x; |
|
|
88 fprintf(stderr, "\nkatja_decrypt_key mismatch, len %lu (second decrypt)\n", len2); |
|
|
89 fprintf(stderr, "Original contents: \n"); |
|
|
90 for (x = 0; x < kat_msgsize; ) { |
|
|
91 fprintf(stderr, "%02x ", in[x]); |
|
|
92 if (!(++x % 16)) { |
|
|
93 fprintf(stderr, "\n"); |
|
|
94 } |
|
|
95 } |
|
|
96 fprintf(stderr, "\n"); |
|
|
97 fprintf(stderr, "Output contents: \n"); |
|
|
98 for (x = 0; x < kat_msgsize; ) { |
|
|
99 fprintf(stderr, "%02x ", out[x]); |
|
|
100 if (!(++x % 16)) { |
|
|
101 fprintf(stderr, "\n"); |
|
|
102 } |
|
|
103 } |
|
|
104 fprintf(stderr, "\n"); |
|
|
105 return 1; |
|
|
106 } |
|
|
107 } |
|
|
108 } |
|
|
109 |
|
|
110 /* encrypt the key (with lparam) */ |
|
|
111 for (kat_msgsize = 1; kat_msgsize <= 42; kat_msgsize++) { |
|
|
112 len = sizeof(out); |
|
|
113 len2 = kat_msgsize; |
|
|
114 DO(katja_encrypt_key(in, kat_msgsize, out, &len, lparam, sizeof(lparam), &yarrow_prng, prng_idx, hash_idx, &key)); |
|
|
115 /* change a byte */ |
|
|
116 out[8] ^= 1; |
|
|
117 DO(katja_decrypt_key(out, len, tmp, &len2, lparam, sizeof(lparam), hash_idx, &stat2, &key)); |
|
|
118 if (len2 != kat_msgsize) { |
|
|
119 fprintf(stderr, "\nkatja_decrypt_key mismatch len %lu (first decrypt)", len2); |
|
|
120 return 1; |
|
|
121 } |
|
|
122 /* change a byte back */ |
|
|
123 out[8] ^= 1; |
|
|
124 |
|
|
125 len2 = kat_msgsize; |
|
|
126 DO(katja_decrypt_key(out, len, tmp, &len2, lparam, sizeof(lparam), hash_idx, &stat, &key)); |
|
|
127 if (!(stat == 1 && stat2 == 0)) { |
|
|
128 fprintf(stderr, "katja_decrypt_key failed"); |
|
|
129 return 1; |
|
|
130 } |
|
|
131 if (len2 != kat_msgsize || memcmp(tmp, in, kat_msgsize)) { |
|
|
132 fprintf(stderr, "katja_decrypt_key mismatch len %lu", len2); |
|
|
133 return 1; |
|
|
134 } |
|
|
135 } |
|
|
136 |
|
|
137 #if 0 |
|
|
138 |
|
|
139 /* sign a message (unsalted, lower cholestorol and Atkins approved) now */ |
|
|
140 len = sizeof(out); |
|
|
141 DO(katja_sign_hash(in, 20, out, &len, &yarrow_prng, prng_idx, hash_idx, 0, &key)); |
|
|
142 |
|
|
143 /* export key and import as both private and public */ |
|
|
144 len2 = sizeof(tmp); |
|
|
145 DO(katja_export(tmp, &len2, PK_PRIVATE, &key)); |
|
|
146 DO(katja_import(tmp, len2, &privKey)); |
|
|
147 len2 = sizeof(tmp); |
|
|
148 DO(katja_export(tmp, &len2, PK_PUBLIC, &key)); |
|
|
149 DO(katja_import(tmp, len2, &pubKey)); |
|
|
150 |
|
|
151 /* verify with original */ |
|
|
152 DO(katja_verify_hash(out, len, in, 20, hash_idx, 0, &stat, &key)); |
|
|
153 /* change a byte */ |
|
|
154 in[0] ^= 1; |
|
|
155 DO(katja_verify_hash(out, len, in, 20, hash_idx, 0, &stat2, &key)); |
|
|
156 |
|
|
157 if (!(stat == 1 && stat2 == 0)) { |
|
|
158 fprintf(stderr, "katja_verify_hash (unsalted, origKey) failed, %d, %d", stat, stat2); |
|
|
159 katja_free(&key); |
|
|
160 katja_free(&pubKey); |
|
|
161 katja_free(&privKey); |
|
|
162 return 1; |
|
|
163 } |
|
|
164 |
|
|
165 /* verify with privKey */ |
|
|
166 /* change a byte */ |
|
|
167 in[0] ^= 1; |
|
|
168 DO(katja_verify_hash(out, len, in, 20, hash_idx, 0, &stat, &privKey)); |
|
|
169 /* change a byte */ |
|
|
170 in[0] ^= 1; |
|
|
171 DO(katja_verify_hash(out, len, in, 20, hash_idx, 0, &stat2, &privKey)); |
|
|
172 |
|
|
173 if (!(stat == 1 && stat2 == 0)) { |
|
|
174 fprintf(stderr, "katja_verify_hash (unsalted, privKey) failed, %d, %d", stat, stat2); |
|
|
175 katja_free(&key); |
|
|
176 katja_free(&pubKey); |
|
|
177 katja_free(&privKey); |
|
|
178 return 1; |
|
|
179 } |
|
|
180 |
|
|
181 /* verify with pubKey */ |
|
|
182 /* change a byte */ |
|
|
183 in[0] ^= 1; |
|
|
184 DO(katja_verify_hash(out, len, in, 20, hash_idx, 0, &stat, &pubKey)); |
|
|
185 /* change a byte */ |
|
|
186 in[0] ^= 1; |
|
|
187 DO(katja_verify_hash(out, len, in, 20, hash_idx, 0, &stat2, &pubKey)); |
|
|
188 |
|
|
189 if (!(stat == 1 && stat2 == 0)) { |
|
|
190 fprintf(stderr, "katja_verify_hash (unsalted, pubkey) failed, %d, %d", stat, stat2); |
|
|
191 katja_free(&key); |
|
|
192 katja_free(&pubKey); |
|
|
193 katja_free(&privKey); |
|
|
194 return 1; |
|
|
195 } |
|
|
196 |
|
|
197 /* sign a message (salted) now (use privKey to make, pubKey to verify) */ |
|
|
198 len = sizeof(out); |
|
|
199 DO(katja_sign_hash(in, 20, out, &len, &yarrow_prng, prng_idx, hash_idx, 8, &privKey)); |
|
|
200 DO(katja_verify_hash(out, len, in, 20, hash_idx, 8, &stat, &pubKey)); |
|
|
201 /* change a byte */ |
|
|
202 in[0] ^= 1; |
|
|
203 DO(katja_verify_hash(out, len, in, 20, hash_idx, 8, &stat2, &pubKey)); |
|
|
204 |
|
|
205 if (!(stat == 1 && stat2 == 0)) { |
|
|
206 fprintf(stderr, "katja_verify_hash (salted) failed, %d, %d", stat, stat2); |
|
|
207 katja_free(&key); |
|
|
208 katja_free(&pubKey); |
|
|
209 katja_free(&privKey); |
|
|
210 return 1; |
|
|
211 } |
|
|
212 #endif |
|
|
213 |
|
|
214 katja_free(&key); |
|
|
215 katja_free(&pubKey); |
|
|
216 katja_free(&privKey); |
|
|
217 } |
|
|
218 |
|
|
219 /* free the key and return */ |
|
|
220 return 0; |
|
|
221 } |
|
|
222 |
|
|
223 #else |
|
|
224 |
|
|
225 int katja_test(void) |
|
|
226 { |
|
|
227 fprintf(stderr, "NOP"); |
|
|
228 return 0; |
|
|
229 } |
|
|
230 |
|
|
231 #endif |
