c4f2d992 |
1 | /* -*-c-*- |
2 | * |
03f996bd |
3 | * $Id: blowfish.c,v 1.2 1997/08/04 10:24:20 mdw Exp $ |
c4f2d992 |
4 | * |
5 | * Blowfish encryption routines |
6 | * |
7 | * (c) 1997 Mark Wooding |
8 | */ |
9 | |
10 | /*----- Licencing notice --------------------------------------------------* |
11 | * |
12 | * This file is part of `become' |
13 | * |
14 | * `Become' is free software; you can redistribute it and/or modify |
15 | * it under the terms of the GNU General Public License as published by |
16 | * the Free Software Foundation; either version 2 of the License, or |
17 | * (at your option) any later version. |
18 | * |
19 | * `Become' is distributed in the hope that it will be useful, |
20 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
21 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
22 | * GNU General Public License for more details. |
23 | * |
24 | * You should have received a copy of the GNU General Public License |
25 | * along with `become'; if not, write to the Free Software |
26 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. |
27 | */ |
28 | |
29 | /*----- Revision history --------------------------------------------------* |
30 | * |
31 | * $Log: blowfish.c,v $ |
03f996bd |
32 | * Revision 1.2 1997/08/04 10:24:20 mdw |
33 | * Sources placed under CVS control. |
34 | * |
35 | * Revision 1.1 1997/07/21 13:47:53 mdw |
c4f2d992 |
36 | * Initial revision |
37 | * |
38 | */ |
39 | |
40 | /*----- Header files ------------------------------------------------------*/ |
41 | |
42 | /* --- ANSI headers --- */ |
43 | |
44 | #include <stdio.h> |
45 | |
46 | /* --- Local headers --- */ |
47 | |
48 | #include "config.h" |
49 | #include "blowfish.h" |
50 | #include "utils.h" |
51 | |
52 | /*----- Define the initial S-box values -----------------------------------*/ |
53 | |
54 | #include "blowfish-sbox.h" |
55 | |
56 | /*----- Useful macros -----------------------------------------------------*/ |
57 | |
58 | /* --- The Blowfish round function --- * |
59 | * |
60 | * This is why I like this cipher. The round function is microscopic. And |
61 | * very fast. |
62 | */ |
63 | |
64 | #define ROUND(L, R, K) \ |
65 | ((L) ^= k->p[K], \ |
66 | (R) ^= ((((k->s0[((L) >> 24) & 0xFF]) + \ |
67 | k->s1[((L) >> 16) & 0xFF]) ^ \ |
68 | k->s2[((L) >> 8) & 0xFF]) + \ |
69 | k->s3[((L) >> 0) & 0xFF])) |
70 | |
71 | /*----- Main code ---------------------------------------------------------*/ |
72 | |
73 | /* --- @blowfish_encrypt@ --- * |
74 | * |
75 | * Arguments: @const blowfish_key *k@ = pointer to key block |
76 | * @const void *from@ = block to encrypt from |
77 | * @void *to@ = block to encrypt to |
78 | * |
79 | * Returns: --- |
80 | * |
81 | * Use: Encrypts a block using the Blowfish algorithm. |
82 | */ |
83 | |
84 | void blowfish_encrypt(const blowfish_key *k, const void *from, void *to) |
85 | { |
86 | uint_32 l, r; |
87 | const unsigned char *f = from; |
88 | unsigned char *t = to; |
89 | |
90 | /* --- Extract left and right block halves --- */ |
91 | |
92 | l = load32(f + 0); |
93 | r = load32(f + 4); |
94 | |
95 | /* --- Now run the round function on these values --- */ |
96 | |
97 | ROUND(l, r, 0); |
98 | ROUND(r, l, 1); |
99 | ROUND(l, r, 2); |
100 | ROUND(r, l, 3); |
101 | ROUND(l, r, 4); |
102 | ROUND(r, l, 5); |
103 | ROUND(l, r, 6); |
104 | ROUND(r, l, 7); |
105 | ROUND(l, r, 8); |
106 | ROUND(r, l, 9); |
107 | ROUND(l, r, 10); |
108 | ROUND(r, l, 11); |
109 | ROUND(l, r, 12); |
110 | ROUND(r, l, 13); |
111 | ROUND(l, r, 14); |
112 | ROUND(r, l, 15); |
113 | |
114 | /* --- Final transformation --- */ |
115 | |
116 | l ^= k->p[16]; |
117 | r ^= k->p[17]; |
118 | |
119 | /* --- Store the encrypted value --- */ |
120 | |
121 | store32(t + 0, r); |
122 | store32(t + 4, l); |
123 | } |
124 | |
125 | /* --- @blowfish_decrypt@ --- * |
126 | * |
127 | * Arguments: @const blowfish_key *k@ = pointer to key block |
128 | * @const void *from@ = block to decrypt from |
129 | * @void *to@ = block to decrypt to |
130 | * |
131 | * Returns: --- |
132 | * |
133 | * Use: Decrypts a block using the Blowfish algorithm. |
134 | */ |
135 | |
136 | void blowfish_decrypt(const blowfish_key *k, const void *from, void *to) |
137 | { |
138 | uint_32 l, r; |
139 | const unsigned char *f = from; |
140 | unsigned char *t = to; |
141 | |
142 | /* --- Extract left and right block halves --- */ |
143 | |
144 | l = load32(f + 0); |
145 | r = load32(f + 4); |
146 | |
147 | /* --- Now run the round function on these values --- */ |
148 | |
149 | ROUND(l, r, 17); |
150 | ROUND(r, l, 16); |
151 | ROUND(l, r, 15); |
152 | ROUND(r, l, 14); |
153 | ROUND(l, r, 13); |
154 | ROUND(r, l, 12); |
155 | ROUND(l, r, 11); |
156 | ROUND(r, l, 10); |
157 | ROUND(l, r, 9); |
158 | ROUND(r, l, 8); |
159 | ROUND(l, r, 7); |
160 | ROUND(r, l, 6); |
161 | ROUND(l, r, 5); |
162 | ROUND(r, l, 4); |
163 | ROUND(l, r, 3); |
164 | ROUND(r, l, 2); |
165 | |
166 | /* --- Final transformation --- */ |
167 | |
168 | l ^= k->p[1]; |
169 | r ^= k->p[0]; |
170 | |
171 | /* --- Store the decrypted value --- */ |
172 | |
173 | store32(t + 0, r); |
174 | store32(t + 4, l); |
175 | } |
176 | |
177 | /* --- @blowfish__qcrypt@ --- * |
178 | * |
179 | * Arguments: @const blowfish_key *k@ = pointer to a key block |
180 | * @uint_32 *p@ = pointer to block to mangle |
181 | * |
182 | * Returns: --- |
183 | * |
184 | * Use: Mangles a block using the Blowfish algorithm. |
185 | */ |
186 | |
187 | static void blowfish__qcrypt(blowfish_key *k, uint_32 *p) |
188 | { |
189 | uint_32 l = p[0], r = p[1]; |
190 | |
191 | /* --- Run the round function --- */ |
192 | |
193 | ROUND(l, r, 0); |
194 | ROUND(r, l, 1); |
195 | ROUND(l, r, 2); |
196 | ROUND(r, l, 3); |
197 | ROUND(l, r, 4); |
198 | ROUND(r, l, 5); |
199 | ROUND(l, r, 6); |
200 | ROUND(r, l, 7); |
201 | ROUND(l, r, 8); |
202 | ROUND(r, l, 9); |
203 | ROUND(l, r, 10); |
204 | ROUND(r, l, 11); |
205 | ROUND(l, r, 12); |
206 | ROUND(r, l, 13); |
207 | ROUND(l, r, 14); |
208 | ROUND(r, l, 15); |
209 | |
210 | /* --- Output transformation --- */ |
211 | |
212 | l ^= k->p[16]; |
213 | r ^= k->p[17]; |
214 | |
215 | /* --- Store the new values --- */ |
216 | |
217 | p[0] = r; |
218 | p[1] = l; |
219 | } |
220 | |
221 | /* --- @blowfish__buildKey@ --- * |
222 | * |
223 | * Arguments: @blowfish_key *k@ = pointer to a key block to set up |
224 | * |
225 | * Returns: --- |
226 | * |
227 | * Use: Sets up the P-array and S-boxes once a key has been mixed |
228 | * into the P-array. Use a local copy of the Blowfish |
229 | * encryption routine, to avoid penalising the main code too |
230 | * much with having to veneer onto a general args-in-words |
231 | * function, and to avoid me messing about with transforming |
232 | * values backwards and forwards between char arrays and |
233 | * integers. |
234 | */ |
235 | |
236 | static void blowfish__buildKey(blowfish_key *k) |
237 | { |
238 | uint_32 b[2] = { 0, 0 }; |
239 | int i; |
240 | |
241 | /* --- First, run through the P-array --- */ |
242 | |
243 | for (i = 0; i < 18; i += 2) { |
244 | blowfish__qcrypt(k, b); |
245 | k->p[i] = b[0]; |
246 | k->p[i + 1] = b[1]; |
247 | } |
248 | |
249 | /* --- Now do the S-boxes --- */ |
250 | |
251 | for (i = 0; i < 256; i += 2) { |
252 | blowfish__qcrypt(k, b); |
253 | k->s0[i] = b[0]; |
254 | k->s0[i + 1] = b[1]; |
255 | } |
256 | |
257 | for (i = 0; i < 256; i += 2) { |
258 | blowfish__qcrypt(k, b); |
259 | k->s1[i] = b[0]; |
260 | k->s1[i + 1] = b[1]; |
261 | } |
262 | |
263 | for (i = 0; i < 256; i += 2) { |
264 | blowfish__qcrypt(k, b); |
265 | k->s2[i] = b[0]; |
266 | k->s2[i + 1] = b[1]; |
267 | } |
268 | |
269 | for (i = 0; i < 256; i += 2) { |
270 | blowfish__qcrypt(k, b); |
271 | k->s3[i] = b[0]; |
272 | k->s3[i + 1] = b[1]; |
273 | } |
274 | } |
275 | |
276 | /* --- @blowfish_setKey@ --- * |
277 | * |
278 | * Arguments: @blowfish_key *kb@ = pointer to key block to fill |
279 | * @void *k@ = pointer to key data |
280 | * @size_t sz@ = length of data in bytes |
281 | * |
282 | * Returns: --- |
283 | * |
284 | * Use: Expands a key which isn't represented as a number of whole |
285 | * words. This is a nonstandard extension, although it can be |
286 | * used to support 40-bit keys, which some governments might |
287 | * find more palatable than 160-bit (or 448-bit!) keys. |
288 | */ |
289 | |
290 | void blowfish_setKey(blowfish_key *kb, const void *k, size_t sz) |
291 | { |
292 | int i, j, l; |
293 | const unsigned char *p = k; |
294 | uint_32 a; |
295 | |
296 | memcpy(kb, &blowfish__init, sizeof(blowfish__init)); |
297 | |
298 | j = 0; |
299 | for (i = 0; i < 18; i++) { |
300 | a = 0; |
301 | for (l = 0; l < 4; l++) { |
302 | a = (a << 8) | p[j]; |
303 | j++; |
304 | if (j >= sz) |
305 | j = 0; |
306 | } |
307 | kb->p[i] ^= a; |
308 | } |
309 | |
310 | blowfish__buildKey(kb); |
311 | } |
312 | |
313 | /*----- Test rig ----------------------------------------------------------*/ |
314 | |
315 | #ifdef TEST_RIG |
316 | |
317 | int main(void) |
318 | { |
319 | /* --- Stage one: ECB tests --- */ |
320 | |
321 | { |
322 | static struct { |
323 | uint_32 k[2]; |
324 | uint_32 p[2]; |
325 | uint_32 c[2]; |
326 | } table[] = { |
327 | { { 0x00000000u, 0x00000000u }, |
328 | { 0x00000000u, 0x00000000u }, |
329 | { 0x4EF99745u, 0x6198DD78u } }, |
330 | |
331 | { { 0xFFFFFFFFu, 0xFFFFFFFFu }, |
332 | { 0xFFFFFFFFu, 0xFFFFFFFFu }, |
333 | { 0x51866FD5u, 0xB85ECB8Au } }, |
334 | |
335 | { { 0x30000000u, 0x00000000u }, |
336 | { 0x10000000u, 0x00000001u }, |
337 | { 0x7D856F9Au, 0x613063F2u } }, |
338 | |
339 | { { 0x11111111u, 0x11111111u }, |
340 | { 0x11111111u, 0x11111111u }, |
341 | { 0x2466DD87u, 0x8B963C9Du } }, |
342 | |
343 | { { 0x01234567u, 0x89ABCDEFu }, |
344 | { 0x11111111u, 0x11111111u }, |
345 | { 0x61F9C380u, 0x2281B096u } }, |
346 | |
347 | { { 0x11111111u, 0x11111111u }, |
348 | { 0x01234567u, 0x89ABCDEFu }, |
349 | { 0x7D0CC630u, 0xAFDA1EC7u } }, |
350 | |
351 | { { 0x00000000u, 0x00000000u }, |
352 | { 0x00000000u, 0x00000000u }, |
353 | { 0x4EF99745u, 0x6198DD78u } }, |
354 | |
355 | { { 0xFEDCBA98u, 0x76543210u }, |
356 | { 0x01234567u, 0x89ABCDEFu }, |
357 | { 0x0ACEAB0Fu, 0xC6A0A28Du } }, |
358 | |
359 | { { 0x7CA11045u, 0x4A1A6E57u }, |
360 | { 0x01A1D6D0u, 0x39776742u }, |
361 | { 0x59C68245u, 0xEB05282Bu } }, |
362 | |
363 | { { 0x0131D961u, 0x9DC1376Eu }, |
364 | { 0x5CD54CA8u, 0x3DEF57DAu }, |
365 | { 0xB1B8CC0Bu, 0x250F09A0u } }, |
366 | |
367 | { { 0x07A1133Eu, 0x4A0B2686u }, |
368 | { 0x0248D438u, 0x06F67172u }, |
369 | { 0x1730E577u, 0x8BEA1DA4u } }, |
370 | |
371 | { { 0x3849674Cu, 0x2602319Eu }, |
372 | { 0x51454B58u, 0x2DDF440Au }, |
373 | { 0xA25E7856u, 0xCF2651EBu } }, |
374 | |
375 | { { 0x04B915BAu, 0x43FEB5B6u }, |
376 | { 0x42FD4430u, 0x59577FA2u }, |
377 | { 0x353882B1u, 0x09CE8F1Au } }, |
378 | |
379 | { { 0x0113B970u, 0xFD34F2CEu }, |
380 | { 0x059B5E08u, 0x51CF143Au }, |
381 | { 0x48F4D088u, 0x4C379918u } }, |
382 | |
383 | { { 0x0170F175u, 0x468FB5E6u }, |
384 | { 0x0756D8E0u, 0x774761D2u }, |
385 | { 0x432193B7u, 0x8951FC98u } }, |
386 | |
387 | { { 0x43297FADu, 0x38E373FEu }, |
388 | { 0x762514B8u, 0x29BF486Au }, |
389 | { 0x13F04154u, 0xD69D1AE5u } }, |
390 | |
391 | { { 0x07A71370u, 0x45DA2A16u }, |
392 | { 0x3BDD1190u, 0x49372802u }, |
393 | { 0x2EEDDA93u, 0xFFD39C79u } }, |
394 | |
395 | { { 0x04689104u, 0xC2FD3B2Fu }, |
396 | { 0x26955F68u, 0x35AF609Au }, |
397 | { 0xD887E039u, 0x3C2DA6E3u } }, |
398 | |
399 | { { 0x37D06BB5u, 0x16CB7546u }, |
400 | { 0x164D5E40u, 0x4F275232u }, |
401 | { 0x5F99D04Fu, 0x5B163969u } }, |
402 | |
403 | { { 0x1F08260Du, 0x1AC2465Eu }, |
404 | { 0x6B056E18u, 0x759F5CCAu }, |
405 | { 0x4A057A3Bu, 0x24D3977Bu } }, |
406 | |
407 | { { 0x58402364u, 0x1ABA6176u }, |
408 | { 0x004BD6EFu, 0x09176062u }, |
409 | { 0x452031C1u, 0xE4FADA8Eu } }, |
410 | |
411 | { { 0x02581616u, 0x4629B007u }, |
412 | { 0x480D3900u, 0x6EE762F2u }, |
413 | { 0x7555AE39u, 0xF59B87BDu } }, |
414 | |
415 | { { 0x49793EBCu, 0x79B3258Fu }, |
416 | { 0x437540C8u, 0x698F3CFAu }, |
417 | { 0x53C55F9Cu, 0xB49FC019u } }, |
418 | |
419 | { { 0x4FB05E15u, 0x15AB73A7u }, |
420 | { 0x072D43A0u, 0x77075292u }, |
421 | { 0x7A8E7BFAu, 0x937E89A3u } }, |
422 | |
423 | { { 0x49E95D6Du, 0x4CA229BFu }, |
424 | { 0x02FE5577u, 0x8117F12Au }, |
425 | { 0xCF9C5D7Au, 0x4986ADB5u } }, |
426 | |
427 | { { 0x018310DCu, 0x409B26D6u }, |
428 | { 0x1D9D5C50u, 0x18F728C2u }, |
429 | { 0xD1ABB290u, 0x658BC778u } }, |
430 | |
431 | { { 0x1C587F1Cu, 0x13924FEFu }, |
432 | { 0x30553228u, 0x6D6F295Au }, |
433 | { 0x55CB3774u, 0xD13EF201u } }, |
434 | |
435 | { { 0x01010101u, 0x01010101u }, |
436 | { 0x01234567u, 0x89ABCDEFu }, |
437 | { 0xFA34EC48u, 0x47B268B2u } }, |
438 | |
439 | { { 0x1F1F1F1Fu, 0x0E0E0E0Eu }, |
440 | { 0x01234567u, 0x89ABCDEFu }, |
441 | { 0xA7907951u, 0x08EA3CAEu } }, |
442 | |
443 | { { 0xE0FEE0FEu, 0xF1FEF1FEu }, |
444 | { 0x01234567u, 0x89ABCDEFu }, |
445 | { 0xC39E072Du, 0x9FAC631Du } }, |
446 | |
447 | { { 0x00000000u, 0x00000000u }, |
448 | { 0xFFFFFFFFu, 0xFFFFFFFFu }, |
449 | { 0x014933E0u, 0xCDAFF6E4u } }, |
450 | |
451 | { { 0xFFFFFFFFu, 0xFFFFFFFFu }, |
452 | { 0x00000000u, 0x00000000u }, |
453 | { 0xF21E9A77u, 0xB71C49BCu } }, |
454 | |
455 | { { 0x01234567u, 0x89ABCDEFu }, |
456 | { 0x00000000u, 0x00000000u }, |
457 | { 0x24594688u, 0x5754369Au } }, |
458 | |
459 | { { 0xFEDCBA98u, 0x76543210u }, |
460 | { 0xFFFFFFFFu, 0xFFFFFFFFu }, |
461 | { 0x6B5C5A9Cu, 0x5D9E0A5Au } } |
462 | }; |
463 | |
464 | int f = 1; |
465 | int i; |
466 | |
467 | printf("*** stage one: "); |
468 | fflush(stdout); |
469 | |
470 | for (i = 0; i < sizeof(table) / sizeof(table[0]); i++) { |
471 | char kb[8], p[8], c[8]; |
472 | blowfish_key k; |
473 | |
474 | store32(kb + 0, table[i].k[0]); |
475 | store32(kb + 4, table[i].k[1]); |
476 | blowfish_setKey(&k, kb, 8); |
477 | |
478 | store32(p + 0, table[i].p[0]); |
479 | store32(p + 4, table[i].p[1]); |
480 | blowfish_encrypt(&k, p, c); |
481 | |
482 | if (load32(c + 0) != table[i].c[0] || |
483 | load32(c + 4) != table[i].c[1]) { |
484 | printf("\n" |
485 | "!!! bad encryption\n" |
486 | " key = %08lx-%08lx\n" |
487 | " plaintext = %08lx-%08lx\n" |
488 | " expected ciphertext = %08lx-%08lx\n" |
489 | " calculated ciphertext = %08lx-%08lx\n", |
490 | (unsigned long)table[i].k[0], |
491 | (unsigned long)table[i].k[1], |
492 | (unsigned long)table[i].p[0], |
493 | (unsigned long)table[i].p[1], |
494 | (unsigned long)table[i].c[0], |
495 | (unsigned long)table[i].c[1], |
496 | (unsigned long)load32(c + 0), |
497 | (unsigned long)load32(c + 4)); |
498 | f = 0; |
499 | } |
500 | |
501 | blowfish_decrypt(&k, c, p); |
502 | if (load32(p + 0) != table[i].p[0] || |
503 | load32(p + 4) != table[i].p[1]) { |
504 | printf("\n" |
505 | "!!! bad decryption\n" |
506 | " key = %08lx-%08lx\n" |
507 | " ciphertext = %08lx-%08lx\n" |
508 | " expected plaintext = %08lx-%08lx\n" |
509 | " calculated plaintext = %08lx-%08lx\n", |
510 | (unsigned long)table[i].k[0], |
511 | (unsigned long)table[i].k[1], |
512 | (unsigned long)table[i].c[0], |
513 | (unsigned long)table[i].c[1], |
514 | (unsigned long)table[i].p[0], |
515 | (unsigned long)table[i].p[1], |
516 | (unsigned long)load32(p + 0), |
517 | (unsigned long)load32(p + 4)); |
518 | f = 0; |
519 | } |
520 | |
521 | putchar('.'); |
522 | fflush(stdout); |
523 | } |
524 | putchar('\n'); |
525 | if (f) |
526 | printf("*** stage one ok\n"); |
527 | } |
528 | |
529 | /* --- Stage 2: key scheduling --- */ |
530 | |
531 | { |
532 | static struct { |
533 | uint_32 c[2]; |
534 | } table[] = { |
535 | {{ 0xF9AD597Cu, 0x49DB005Eu }}, |
536 | {{ 0xE91D21C1u, 0xD961A6D6u }}, |
537 | {{ 0xE9C2B70Au, 0x1BC65CF3u }}, |
538 | {{ 0xBE1E6394u, 0x08640F05u }}, |
539 | {{ 0xB39E4448u, 0x1BDB1E6Eu }}, |
540 | {{ 0x9457AA83u, 0xB1928C0Du }}, |
541 | {{ 0x8BB77032u, 0xF960629Du }}, |
542 | {{ 0xE87A244Eu, 0x2CC85E82u }}, |
543 | {{ 0x15750E7Au, 0x4F4EC577u }}, |
544 | {{ 0x122BA70Bu, 0x3AB64AE0u }}, |
545 | {{ 0x3A833C9Au, 0xFFC537F6u }}, |
546 | {{ 0x9409DA87u, 0xA90F6BF2u }}, |
547 | {{ 0x884F8062u, 0x5060B8B4u }}, |
548 | {{ 0x1F85031Cu, 0x19E11968u }}, |
549 | {{ 0x79D9373Au, 0x714CA34Fu }}, |
550 | {{ 0x93142887u, 0xEE3BE15Cu }}, |
551 | {{ 0x03429E83u, 0x8CE2D14Bu }}, |
552 | {{ 0xA4299E27u, 0x469FF67Bu }}, |
553 | {{ 0xAFD5AED1u, 0xC1BC96A8u }}, |
554 | {{ 0x10851C0Eu, 0x3858DA9Fu }}, |
555 | {{ 0xE6F51ED7u, 0x9B9DB21Fu }}, |
556 | {{ 0x64A6E14Au, 0xFD36B46Fu }}, |
557 | {{ 0x80C7D7D4u, 0x5A5479ADu }}, |
558 | {{ 0x05044B62u, 0xFA52D080u }}, |
559 | }; |
560 | |
561 | unsigned char kk[] = { |
562 | 0xF0, 0xE1, 0xD2, 0xC3, 0xB4, 0xA5, 0x96, 0x87, |
563 | 0x78, 0x69, 0x5A, 0x4B, 0x3C, 0x2D, 0x1E, 0x0F, |
564 | 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77 |
565 | }; |
566 | |
567 | int i; |
568 | int f = 1; |
569 | |
570 | printf("*** stage two: "); |
571 | fflush(stdout); |
572 | |
573 | for (i = 0; i < sizeof(kk); i++) { |
574 | blowfish_key k; |
575 | unsigned char p[8] = { 0xFE, 0xDC, 0xBA, 0x98, |
576 | 0x76, 0x54, 0x32, 0x10 }; |
577 | |
578 | blowfish_setKey(&k, kk, i + 1); |
579 | blowfish_encrypt(&k, p, p); |
580 | |
581 | if (load32(p + 0) != table[i].c[0] || |
582 | load32(p + 4) != table[i].c[1]) { |
583 | printf("!!! bad encryption\n" |
584 | " key length = %i\n" |
585 | " expected = %08lx-%08lx\n" |
586 | " calculated = %08lx-%08lx\n", |
587 | i + 1, |
588 | (unsigned long)table[i].c[0], |
589 | (unsigned long)table[i].c[1], |
590 | (unsigned long)load32(p + 0), |
591 | (unsigned long)load32(p + 4)); |
592 | f = 0; |
593 | } |
594 | |
595 | putchar('.'); |
596 | fflush(stdout); |
597 | } |
598 | |
599 | putchar('\n'); |
600 | |
601 | if (f) |
602 | printf("*** stage two ok\n"); |
603 | } |
604 | |
605 | return (0); |
606 | |
607 | } |
608 | |
609 | #endif |
610 | |
611 | /*----- That's all, folks -------------------------------------------------*/ |