a8cb5138832760d239aff3158526489cd79e0f4e
3 * $Id: blowfish.c,v 1.4 1997/12/08 15:29:50 mdw Exp $
5 * Blowfish encryption routines
7 * (c) 1997 Mark Wooding
10 /*----- Licencing notice --------------------------------------------------*
12 * This file is part of `become'
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.
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.
24 * You should have received a copy of the GNU General Public License
25 * along with `become'; if not, write to the Free Software Foundation,
26 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
29 /*----- Revision history --------------------------------------------------*
31 * $Log: blowfish.c,v $
32 * Revision 1.4 1997/12/08 15:29:50 mdw
33 * Formatting fixes. Very boring.
35 * Revision 1.3 1997/08/07 09:42:58 mdw
36 * Fix address of the FSF.
38 * Revision 1.2 1997/08/04 10:24:20 mdw
39 * Sources placed under CVS control.
41 * Revision 1.1 1997/07/21 13:47:53 mdw
46 /*----- Header files ------------------------------------------------------*/
48 /* --- ANSI headers --- */
52 /* --- Local headers --- */
58 /*----- Define the initial S-box values -----------------------------------*/
60 #include "blowfish-sbox.h"
62 /*----- Useful macros -----------------------------------------------------*/
64 /* --- The Blowfish round function --- *
66 * This is why I like this cipher. The round function is microscopic. And
70 #define ROUND(L, R, K) \
72 (R) ^= ((((k->s0[((L) >> 24) & 0xFF]) + \
73 k->s1[((L) >> 16) & 0xFF]) ^ \
74 k->s2[((L) >> 8) & 0xFF]) + \
75 k->s3[((L) >> 0) & 0xFF]))
77 /*----- Main code ---------------------------------------------------------*/
79 /* --- @blowfish_encrypt@ --- *
81 * Arguments: @const blowfish_key *k@ = pointer to key block
82 * @const void *from@ = block to encrypt from
83 * @void *to@ = block to encrypt to
87 * Use: Encrypts a block using the Blowfish algorithm.
90 void blowfish_encrypt(const blowfish_key
*k
, const void *from
, void *to
)
93 const unsigned char *f
= from
;
94 unsigned char *t
= to
;
96 /* --- Extract left and right block halves --- */
101 /* --- Now run the round function on these values --- */
120 /* --- Final transformation --- */
125 /* --- Store the encrypted value --- */
131 /* --- @blowfish_decrypt@ --- *
133 * Arguments: @const blowfish_key *k@ = pointer to key block
134 * @const void *from@ = block to decrypt from
135 * @void *to@ = block to decrypt to
139 * Use: Decrypts a block using the Blowfish algorithm.
142 void blowfish_decrypt(const blowfish_key
*k
, const void *from
, void *to
)
145 const unsigned char *f
= from
;
146 unsigned char *t
= to
;
148 /* --- Extract left and right block halves --- */
153 /* --- Now run the round function on these values --- */
172 /* --- Final transformation --- */
177 /* --- Store the decrypted value --- */
183 /* --- @blowfish__qcrypt@ --- *
185 * Arguments: @const blowfish_key *k@ = pointer to a key block
186 * @uint_32 *p@ = pointer to block to mangle
190 * Use: Mangles a block using the Blowfish algorithm.
193 static void blowfish__qcrypt(blowfish_key
*k
, uint_32
*p
)
195 uint_32 l
= p
[0], r
= p
[1];
197 /* --- Run the round function --- */
216 /* --- Output transformation --- */
221 /* --- Store the new values --- */
227 /* --- @blowfish__buildKey@ --- *
229 * Arguments: @blowfish_key *k@ = pointer to a key block to set up
233 * Use: Sets up the P-array and S-boxes once a key has been mixed
234 * into the P-array. Use a local copy of the Blowfish
235 * encryption routine, to avoid penalising the main code too
236 * much with having to veneer onto a general args-in-words
237 * function, and to avoid me messing about with transforming
238 * values backwards and forwards between char arrays and
242 static void blowfish__buildKey(blowfish_key
*k
)
244 uint_32 b
[2] = { 0, 0 };
247 /* --- First, run through the P-array --- */
249 for (i
= 0; i
< 18; i
+= 2) {
250 blowfish__qcrypt(k
, b
);
255 /* --- Now do the S-boxes --- */
257 for (i
= 0; i
< 256; i
+= 2) {
258 blowfish__qcrypt(k
, b
);
263 for (i
= 0; i
< 256; i
+= 2) {
264 blowfish__qcrypt(k
, b
);
269 for (i
= 0; i
< 256; i
+= 2) {
270 blowfish__qcrypt(k
, b
);
275 for (i
= 0; i
< 256; i
+= 2) {
276 blowfish__qcrypt(k
, b
);
282 /* --- @blowfish_setKey@ --- *
284 * Arguments: @blowfish_key *kb@ = pointer to key block to fill
285 * @void *k@ = pointer to key data
286 * @size_t sz@ = length of data in bytes
290 * Use: Expands a key which isn't represented as a number of whole
291 * words. This is a nonstandard extension, although it can be
292 * used to support 40-bit keys, which some governments might
293 * find more palatable than 160-bit (or 448-bit!) keys.
296 void blowfish_setKey(blowfish_key
*kb
, const void *k
, size_t sz
)
299 const unsigned char *p
= k
;
302 memcpy(kb
, &blowfish__init
, sizeof(blowfish__init
));
305 for (i
= 0; i
< 18; i
++) {
307 for (l
= 0; l
< 4; l
++) {
316 blowfish__buildKey(kb
);
319 /*----- Test rig ----------------------------------------------------------*/
325 /* --- Stage one: ECB tests --- */
333 { { 0x00000000u
, 0x00000000u
},
334 { 0x00000000u
, 0x00000000u
},
335 { 0x4EF99745u
, 0x6198DD78u
} },
337 { { 0xFFFFFFFFu
, 0xFFFFFFFFu
},
338 { 0xFFFFFFFFu
, 0xFFFFFFFFu
},
339 { 0x51866FD5u
, 0xB85ECB8Au
} },
341 { { 0x30000000u
, 0x00000000u
},
342 { 0x10000000u
, 0x00000001u
},
343 { 0x7D856F9Au
, 0x613063F2u
} },
345 { { 0x11111111u
, 0x11111111u
},
346 { 0x11111111u
, 0x11111111u
},
347 { 0x2466DD87u
, 0x8B963C9Du
} },
349 { { 0x01234567u
, 0x89ABCDEFu
},
350 { 0x11111111u
, 0x11111111u
},
351 { 0x61F9C380u
, 0x2281B096u
} },
353 { { 0x11111111u
, 0x11111111u
},
354 { 0x01234567u
, 0x89ABCDEFu
},
355 { 0x7D0CC630u
, 0xAFDA1EC7u
} },
357 { { 0x00000000u
, 0x00000000u
},
358 { 0x00000000u
, 0x00000000u
},
359 { 0x4EF99745u
, 0x6198DD78u
} },
361 { { 0xFEDCBA98u
, 0x76543210u
},
362 { 0x01234567u
, 0x89ABCDEFu
},
363 { 0x0ACEAB0Fu
, 0xC6A0A28Du
} },
365 { { 0x7CA11045u
, 0x4A1A6E57u
},
366 { 0x01A1D6D0u
, 0x39776742u
},
367 { 0x59C68245u
, 0xEB05282Bu
} },
369 { { 0x0131D961u
, 0x9DC1376Eu
},
370 { 0x5CD54CA8u
, 0x3DEF57DAu
},
371 { 0xB1B8CC0Bu
, 0x250F09A0u
} },
373 { { 0x07A1133Eu
, 0x4A0B2686u
},
374 { 0x0248D438u
, 0x06F67172u
},
375 { 0x1730E577u
, 0x8BEA1DA4u
} },
377 { { 0x3849674Cu
, 0x2602319Eu
},
378 { 0x51454B58u
, 0x2DDF440Au
},
379 { 0xA25E7856u
, 0xCF2651EBu
} },
381 { { 0x04B915BAu
, 0x43FEB5B6u
},
382 { 0x42FD4430u
, 0x59577FA2u
},
383 { 0x353882B1u
, 0x09CE8F1Au
} },
385 { { 0x0113B970u
, 0xFD34F2CEu
},
386 { 0x059B5E08u
, 0x51CF143Au
},
387 { 0x48F4D088u
, 0x4C379918u
} },
389 { { 0x0170F175u
, 0x468FB5E6u
},
390 { 0x0756D8E0u
, 0x774761D2u
},
391 { 0x432193B7u
, 0x8951FC98u
} },
393 { { 0x43297FADu
, 0x38E373FEu
},
394 { 0x762514B8u
, 0x29BF486Au
},
395 { 0x13F04154u
, 0xD69D1AE5u
} },
397 { { 0x07A71370u
, 0x45DA2A16u
},
398 { 0x3BDD1190u
, 0x49372802u
},
399 { 0x2EEDDA93u
, 0xFFD39C79u
} },
401 { { 0x04689104u
, 0xC2FD3B2Fu
},
402 { 0x26955F68u
, 0x35AF609Au
},
403 { 0xD887E039u
, 0x3C2DA6E3u
} },
405 { { 0x37D06BB5u
, 0x16CB7546u
},
406 { 0x164D5E40u
, 0x4F275232u
},
407 { 0x5F99D04Fu
, 0x5B163969u
} },
409 { { 0x1F08260Du
, 0x1AC2465Eu
},
410 { 0x6B056E18u
, 0x759F5CCAu
},
411 { 0x4A057A3Bu
, 0x24D3977Bu
} },
413 { { 0x58402364u
, 0x1ABA6176u
},
414 { 0x004BD6EFu
, 0x09176062u
},
415 { 0x452031C1u
, 0xE4FADA8Eu
} },
417 { { 0x02581616u
, 0x4629B007u
},
418 { 0x480D3900u
, 0x6EE762F2u
},
419 { 0x7555AE39u
, 0xF59B87BDu
} },
421 { { 0x49793EBCu
, 0x79B3258Fu
},
422 { 0x437540C8u
, 0x698F3CFAu
},
423 { 0x53C55F9Cu
, 0xB49FC019u
} },
425 { { 0x4FB05E15u
, 0x15AB73A7u
},
426 { 0x072D43A0u
, 0x77075292u
},
427 { 0x7A8E7BFAu
, 0x937E89A3u
} },
429 { { 0x49E95D6Du
, 0x4CA229BFu
},
430 { 0x02FE5577u
, 0x8117F12Au
},
431 { 0xCF9C5D7Au
, 0x4986ADB5u
} },
433 { { 0x018310DCu
, 0x409B26D6u
},
434 { 0x1D9D5C50u
, 0x18F728C2u
},
435 { 0xD1ABB290u
, 0x658BC778u
} },
437 { { 0x1C587F1Cu
, 0x13924FEFu
},
438 { 0x30553228u
, 0x6D6F295Au
},
439 { 0x55CB3774u
, 0xD13EF201u
} },
441 { { 0x01010101u
, 0x01010101u
},
442 { 0x01234567u
, 0x89ABCDEFu
},
443 { 0xFA34EC48u
, 0x47B268B2u
} },
445 { { 0x1F1F1F1Fu
, 0x0E0E0E0Eu
},
446 { 0x01234567u
, 0x89ABCDEFu
},
447 { 0xA7907951u
, 0x08EA3CAEu
} },
449 { { 0xE0FEE0FEu
, 0xF1FEF1FEu
},
450 { 0x01234567u
, 0x89ABCDEFu
},
451 { 0xC39E072Du
, 0x9FAC631Du
} },
453 { { 0x00000000u
, 0x00000000u
},
454 { 0xFFFFFFFFu
, 0xFFFFFFFFu
},
455 { 0x014933E0u
, 0xCDAFF6E4u
} },
457 { { 0xFFFFFFFFu
, 0xFFFFFFFFu
},
458 { 0x00000000u
, 0x00000000u
},
459 { 0xF21E9A77u
, 0xB71C49BCu
} },
461 { { 0x01234567u
, 0x89ABCDEFu
},
462 { 0x00000000u
, 0x00000000u
},
463 { 0x24594688u
, 0x5754369Au
} },
465 { { 0xFEDCBA98u
, 0x76543210u
},
466 { 0xFFFFFFFFu
, 0xFFFFFFFFu
},
467 { 0x6B5C5A9Cu
, 0x5D9E0A5Au
} }
473 printf("*** stage one: ");
476 for (i
= 0; i
< sizeof(table
) / sizeof(table
[0]); i
++) {
477 char kb
[8], p
[8], c
[8];
480 store32(kb
+ 0, table
[i
].k
[0]);
481 store32(kb
+ 4, table
[i
].k
[1]);
482 blowfish_setKey(&k
, kb
, 8);
484 store32(p
+ 0, table
[i
].p
[0]);
485 store32(p
+ 4, table
[i
].p
[1]);
486 blowfish_encrypt(&k
, p
, c
);
488 if (load32(c
+ 0) != table
[i
].c
[0] ||
489 load32(c
+ 4) != table
[i
].c
[1]) {
491 "!!! bad encryption\n"
492 " key = %08lx-%08lx\n"
493 " plaintext = %08lx-%08lx\n"
494 " expected ciphertext = %08lx-%08lx\n"
495 " calculated ciphertext = %08lx-%08lx\n",
496 (unsigned long)table
[i
].k
[0],
497 (unsigned long)table
[i
].k
[1],
498 (unsigned long)table
[i
].p
[0],
499 (unsigned long)table
[i
].p
[1],
500 (unsigned long)table
[i
].c
[0],
501 (unsigned long)table
[i
].c
[1],
502 (unsigned long)load32(c
+ 0),
503 (unsigned long)load32(c
+ 4));
507 blowfish_decrypt(&k
, c
, p
);
508 if (load32(p
+ 0) != table
[i
].p
[0] ||
509 load32(p
+ 4) != table
[i
].p
[1]) {
511 "!!! bad decryption\n"
512 " key = %08lx-%08lx\n"
513 " ciphertext = %08lx-%08lx\n"
514 " expected plaintext = %08lx-%08lx\n"
515 " calculated plaintext = %08lx-%08lx\n",
516 (unsigned long)table
[i
].k
[0],
517 (unsigned long)table
[i
].k
[1],
518 (unsigned long)table
[i
].c
[0],
519 (unsigned long)table
[i
].c
[1],
520 (unsigned long)table
[i
].p
[0],
521 (unsigned long)table
[i
].p
[1],
522 (unsigned long)load32(p
+ 0),
523 (unsigned long)load32(p
+ 4));
532 printf("*** stage one ok\n");
535 /* --- Stage 2: key scheduling --- */
541 {{ 0xF9AD597Cu
, 0x49DB005Eu
}},
542 {{ 0xE91D21C1u
, 0xD961A6D6u
}},
543 {{ 0xE9C2B70Au
, 0x1BC65CF3u
}},
544 {{ 0xBE1E6394u
, 0x08640F05u
}},
545 {{ 0xB39E4448u
, 0x1BDB1E6Eu
}},
546 {{ 0x9457AA83u
, 0xB1928C0Du
}},
547 {{ 0x8BB77032u
, 0xF960629Du
}},
548 {{ 0xE87A244Eu
, 0x2CC85E82u
}},
549 {{ 0x15750E7Au
, 0x4F4EC577u
}},
550 {{ 0x122BA70Bu
, 0x3AB64AE0u
}},
551 {{ 0x3A833C9Au
, 0xFFC537F6u
}},
552 {{ 0x9409DA87u
, 0xA90F6BF2u
}},
553 {{ 0x884F8062u
, 0x5060B8B4u
}},
554 {{ 0x1F85031Cu
, 0x19E11968u
}},
555 {{ 0x79D9373Au
, 0x714CA34Fu
}},
556 {{ 0x93142887u
, 0xEE3BE15Cu
}},
557 {{ 0x03429E83u
, 0x8CE2D14Bu
}},
558 {{ 0xA4299E27u
, 0x469FF67Bu
}},
559 {{ 0xAFD5AED1u
, 0xC1BC96A8u
}},
560 {{ 0x10851C0Eu
, 0x3858DA9Fu
}},
561 {{ 0xE6F51ED7u
, 0x9B9DB21Fu
}},
562 {{ 0x64A6E14Au
, 0xFD36B46Fu
}},
563 {{ 0x80C7D7D4u
, 0x5A5479ADu
}},
564 {{ 0x05044B62u
, 0xFA52D080u
}},
567 unsigned char kk
[] = {
568 0xF0, 0xE1, 0xD2, 0xC3, 0xB4, 0xA5, 0x96, 0x87,
569 0x78, 0x69, 0x5A, 0x4B, 0x3C, 0x2D, 0x1E, 0x0F,
570 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77
576 printf("*** stage two: ");
579 for (i
= 0; i
< sizeof(kk
); i
++) {
581 unsigned char p
[8] = { 0xFE, 0xDC, 0xBA, 0x98,
582 0x76, 0x54, 0x32, 0x10 };
584 blowfish_setKey(&k
, kk
, i
+ 1);
585 blowfish_encrypt(&k
, p
, p
);
587 if (load32(p
+ 0) != table
[i
].c
[0] ||
588 load32(p
+ 4) != table
[i
].c
[1]) {
589 printf("!!! bad encryption\n"
591 " expected = %08lx-%08lx\n"
592 " calculated = %08lx-%08lx\n",
594 (unsigned long)table
[i
].c
[0],
595 (unsigned long)table
[i
].c
[1],
596 (unsigned long)load32(p
+ 0),
597 (unsigned long)load32(p
+ 4));
608 printf("*** stage two ok\n");
617 /*----- That's all, folks -------------------------------------------------*/