65 #define inline __inline
66 #else /* !__GNUC__ */
67 #define inline
68 #endif /* !__GNUC__ */
69
70 /* Function for Feistel Networks */
71
72 #define F(s, x) ((((s)[ (((x)>>24)&0xFF)] \
73 + (s)[0x100 + (((x)>>16)&0xFF)]) \
74 ^ (s)[0x200 + (((x)>> 8)&0xFF)]) \
75 + (s)[0x300 + ( (x) &0xFF)])
76
77 #define BLFRND(s,p,i,j,n) (i ^= F(s,j) ^ (p)[n])
78
79 void
80 Blowfish_encipher(c, xl, xr)
81 blf_ctx *c;
82 uint32_t *xl;
83 uint32_t *xr;
84 {
85 /* CRYPT DELETE START */
86 uint32_t Xl;
87 uint32_t Xr;
88 uint32_t *s = c->S[0];
89 uint32_t *p = c->P;
90
91 Xl = *xl;
92 Xr = *xr;
93
94 Xl ^= p[0];
95 BLFRND(s, p, Xr, Xl, 1); BLFRND(s, p, Xl, Xr, 2);
96 BLFRND(s, p, Xr, Xl, 3); BLFRND(s, p, Xl, Xr, 4);
97 BLFRND(s, p, Xr, Xl, 5); BLFRND(s, p, Xl, Xr, 6);
98 BLFRND(s, p, Xr, Xl, 7); BLFRND(s, p, Xl, Xr, 8);
99 BLFRND(s, p, Xr, Xl, 9); BLFRND(s, p, Xl, Xr, 10);
100 BLFRND(s, p, Xr, Xl, 11); BLFRND(s, p, Xl, Xr, 12);
101 BLFRND(s, p, Xr, Xl, 13); BLFRND(s, p, Xl, Xr, 14);
102 BLFRND(s, p, Xr, Xl, 15); BLFRND(s, p, Xl, Xr, 16);
103
104 *xl = Xr ^ p[17];
105 *xr = Xl;
106 /* CRYPT DELETE END */
107 }
108
109 void
110 Blowfish_decipher(c, xl, xr)
111 blf_ctx *c;
112 uint32_t *xl;
113 uint32_t *xr;
114 {
115 /* CRYPT DELETE START */
116 uint32_t Xl;
117 uint32_t Xr;
118 uint32_t *s = c->S[0];
119 uint32_t *p = c->P;
120
121 Xl = *xl;
122 Xr = *xr;
123
124 Xl ^= p[17];
125 BLFRND(s, p, Xr, Xl, 16); BLFRND(s, p, Xl, Xr, 15);
126 BLFRND(s, p, Xr, Xl, 14); BLFRND(s, p, Xl, Xr, 13);
127 BLFRND(s, p, Xr, Xl, 12); BLFRND(s, p, Xl, Xr, 11);
128 BLFRND(s, p, Xr, Xl, 10); BLFRND(s, p, Xl, Xr, 9);
129 BLFRND(s, p, Xr, Xl, 8); BLFRND(s, p, Xl, Xr, 7);
130 BLFRND(s, p, Xr, Xl, 6); BLFRND(s, p, Xl, Xr, 5);
131 BLFRND(s, p, Xr, Xl, 4); BLFRND(s, p, Xl, Xr, 3);
132 BLFRND(s, p, Xr, Xl, 2); BLFRND(s, p, Xl, Xr, 1);
133
134 *xl = Xr ^ p[0];
135 *xr = Xl;
136 /* CRYPT DELETE END */
137 }
138
139 void
140 Blowfish_initstate(c)
141 blf_ctx *c;
142 {
143 /* CRYPT DELETE START */
144
145 /* P-box and S-box tables initialized with digits of Pi */
146
147 const blf_ctx initstate =
148
149 { {
150 {
151 0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7,
152 0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99,
153 0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16,
154 0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e,
155 0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee,
156 0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013,
157 0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef,
158 0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e,
159 0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60,
160 0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440,
161 0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce,
162 0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a,
163 0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e,
164 0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677,
400 0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614,
401 0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a,
402 0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6,
403 0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b,
404 0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0,
405 0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060,
406 0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e,
407 0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9,
408 0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f,
409 0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6}
410 },
411 {
412 0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344,
413 0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89,
414 0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
415 0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917,
416 0x9216d5d9, 0x8979fb1b
417 } };
418
419 *c = initstate;
420
421 /* CRYPT DELETE END */
422 }
423
424 uint32_t
425 Blowfish_stream2word(const uint8_t *data, uint16_t databytes, uint16_t *current)
426 {
427 uint8_t i;
428 uint16_t j;
429 uint32_t temp;
430
431 temp = 0x00000000;
432 /* CRYPT DELETE START */
433 j = *current;
434
435 for (i = 0; i < 4; i++, j++) {
436 if (j >= databytes)
437 j = 0;
438 temp = (temp << 8) | data[j];
439 }
440
441 *current = j;
442 /* CRYPT DELETE END */
443 return temp;
444 }
445
446 void
447 Blowfish_expand0state(blf_ctx *c, const uint8_t *key, uint16_t keybytes)
448 {
449 /* CRYPT DELETE START */
450 uint16_t i;
451 uint16_t j;
452 uint16_t k;
453 uint32_t temp;
454 uint32_t datal;
455 uint32_t datar;
456
457 j = 0;
458 for (i = 0; i < BLF_N + 2; i++) {
459 /* Extract 4 int8 to 1 int32 from keystream */
460 temp = Blowfish_stream2word(key, keybytes, &j);
461 c->P[i] = c->P[i] ^ temp;
462 }
463
464 j = 0;
465 datal = 0x00000000;
466 datar = 0x00000000;
467 for (i = 0; i < BLF_N + 2; i += 2) {
468 Blowfish_encipher(c, &datal, &datar);
469
470 c->P[i] = datal;
471 c->P[i + 1] = datar;
472 }
473
474 for (i = 0; i < 4; i++) {
475 for (k = 0; k < 256; k += 2) {
476 Blowfish_encipher(c, &datal, &datar);
477
478 c->S[i][k] = datal;
479 c->S[i][k + 1] = datar;
480 }
481 }
482 /* CRYPT DELETE END */
483 }
484
485
486 void
487 Blowfish_expandstate(blf_ctx *c, const uint8_t *data, uint16_t databytes,
488 const uint8_t *key, uint16_t keybytes)
489 {
490 /* CRYPT DELETE START */
491 uint16_t i;
492 uint16_t j;
493 uint16_t k;
494 uint32_t temp;
495 uint32_t datal;
496 uint32_t datar;
497
498 j = 0;
499 for (i = 0; i < BLF_N + 2; i++) {
500 /* Extract 4 int8 to 1 int32 from keystream */
501 temp = Blowfish_stream2word(key, keybytes, &j);
502 c->P[i] = c->P[i] ^ temp;
503 }
504
505 j = 0;
506 datal = 0x00000000;
507 datar = 0x00000000;
508 for (i = 0; i < BLF_N + 2; i += 2) {
509 datal ^= Blowfish_stream2word(data, databytes, &j);
510 datar ^= Blowfish_stream2word(data, databytes, &j);
511 Blowfish_encipher(c, &datal, &datar);
512
513 c->P[i] = datal;
514 c->P[i + 1] = datar;
515 }
516
517 for (i = 0; i < 4; i++) {
518 for (k = 0; k < 256; k += 2) {
519 datal ^= Blowfish_stream2word(data, databytes, &j);
520 datar ^= Blowfish_stream2word(data, databytes, &j);
521 Blowfish_encipher(c, &datal, &datar);
522
523 c->S[i][k] = datal;
524 c->S[i][k + 1] = datar;
525 }
526 }
527
528 /* CRYPT DELETE END */
529 }
530
531 void
532 blf_key(blf_ctx *c, const uint8_t *k, uint16_t len)
533 {
534 /* CRYPT DELETE START */
535 /* Initialize S-boxes and subkeys with Pi */
536 Blowfish_initstate(c);
537
538 /* Transform S-boxes and subkeys with key */
539 Blowfish_expand0state(c, k, len);
540 /* CRYPT DELETE END */
541 }
542
543 void
544 blf_enc(blf_ctx *c, uint32_t *data, uint16_t blocks)
545 {
546 /* CRYPT DELETE START */
547 uint32_t *d;
548 uint16_t i;
549
550 d = data;
551 for (i = 0; i < blocks; i++) {
552 Blowfish_encipher(c, d, d + 1);
553 d += 2;
554 }
555 /* CRYPT DELETE END */
556 }
557
558 void
559 blf_dec(blf_ctx *c, uint32_t *data, uint16_t blocks)
560 {
561 /* CRYPT DELETE START */
562 uint32_t *d;
563 uint16_t i;
564
565 d = data;
566 for (i = 0; i < blocks; i++) {
567 Blowfish_decipher(c, d, d + 1);
568 d += 2;
569 }
570 /* CRYPT DELETE END */
571 }
572
573 void
574 blf_ecb_encrypt(blf_ctx *c, uint8_t *data, uint32_t len)
575 {
576 /* CRYPT DELETE START */
577 uint32_t l, r;
578 uint32_t i;
579
580 for (i = 0; i < len; i += 8) {
581 l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
582 r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
583 Blowfish_encipher(c, &l, &r);
584 data[0] = l >> 24 & 0xff;
585 data[1] = l >> 16 & 0xff;
586 data[2] = l >> 8 & 0xff;
587 data[3] = l & 0xff;
588 data[4] = r >> 24 & 0xff;
589 data[5] = r >> 16 & 0xff;
590 data[6] = r >> 8 & 0xff;
591 data[7] = r & 0xff;
592 data += 8;
593 }
594 /* CRYPT DELETE END */
595 }
596
597 void
598 blf_ecb_decrypt(blf_ctx *c, uint8_t *data, uint32_t len)
599 {
600 /* CRYPT DELETE START */
601 uint32_t l, r;
602 uint32_t i;
603
604 for (i = 0; i < len; i += 8) {
605 l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
606 r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
607 Blowfish_decipher(c, &l, &r);
608 data[0] = l >> 24 & 0xff;
609 data[1] = l >> 16 & 0xff;
610 data[2] = l >> 8 & 0xff;
611 data[3] = l & 0xff;
612 data[4] = r >> 24 & 0xff;
613 data[5] = r >> 16 & 0xff;
614 data[6] = r >> 8 & 0xff;
615 data[7] = r & 0xff;
616 data += 8;
617 }
618 /* CRYPT DELETE END */
619 }
620
621 void
622 blf_cbc_encrypt(blf_ctx *c, uint8_t *iv, uint8_t *data, uint32_t len)
623 {
624 /* CRYPT DELETE START */
625 uint32_t l, r;
626 uint32_t i, j;
627
628 for (i = 0; i < len; i += 8) {
629 for (j = 0; j < 8; j++)
630 data[j] ^= iv[j];
631 l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
632 r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
633 Blowfish_encipher(c, &l, &r);
634 data[0] = l >> 24 & 0xff;
635 data[1] = l >> 16 & 0xff;
636 data[2] = l >> 8 & 0xff;
637 data[3] = l & 0xff;
638 data[4] = r >> 24 & 0xff;
639 data[5] = r >> 16 & 0xff;
640 data[6] = r >> 8 & 0xff;
641 data[7] = r & 0xff;
642 iv = data;
643 data += 8;
644 }
645 /* CRYPT DELETE END */
646 }
647
648 void
649 blf_cbc_decrypt(blf_ctx *c, uint8_t *iva, uint8_t *data, uint32_t len)
650 {
651 /* CRYPT DELETE START */
652 uint32_t l, r;
653 uint8_t *iv;
654 uint32_t i, j;
655
656 iv = data + len - 16;
657 data = data + len - 8;
658 for (i = len - 8; i >= 8; i -= 8) {
659 l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
660 r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
661 Blowfish_decipher(c, &l, &r);
662 data[0] = l >> 24 & 0xff;
663 data[1] = l >> 16 & 0xff;
664 data[2] = l >> 8 & 0xff;
665 data[3] = l & 0xff;
666 data[4] = r >> 24 & 0xff;
667 data[5] = r >> 16 & 0xff;
668 data[6] = r >> 8 & 0xff;
669 data[7] = r & 0xff;
670 for (j = 0; j < 8; j++)
671 data[j] ^= iv[j];
672 iv -= 8;
673 data -= 8;
674 }
675 l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
676 r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
677 Blowfish_decipher(c, &l, &r);
678 data[0] = l >> 24 & 0xff;
679 data[1] = l >> 16 & 0xff;
680 data[2] = l >> 8 & 0xff;
681 data[3] = l & 0xff;
682 data[4] = r >> 24 & 0xff;
683 data[5] = r >> 16 & 0xff;
684 data[6] = r >> 8 & 0xff;
685 data[7] = r & 0xff;
686 for (j = 0; j < 8; j++)
687 data[j] ^= iva[j];
688 /* CRYPT DELETE END */
689 }
690
691 /* CRYPT DELETE START */
692 #if 0
693 void
694 report(uint32_t data[], uint16_t len)
695 {
696 uint16_t i;
697 for (i = 0; i < len; i += 2)
698 printf("Block %0hd: %08lx %08lx.\n",
699 i / 2, data[i], data[i + 1]);
700 }
701 void
702 main(void)
703 {
704
705 blf_ctx c;
706 char key[] = "AAAAA";
707 char key2[] = "abcdefghijklmnopqrstuvwxyz";
708
709 uint32_t data[10];
710 uint32_t data2[] =
711 {0x424c4f57l, 0x46495348l};
715 /* First test */
716 for (i = 0; i < 10; i++)
717 data[i] = i;
718
719 blf_key(&c, (uint8_t *) key, 5);
720 blf_enc(&c, data, 5);
721 blf_dec(&c, data, 1);
722 blf_dec(&c, data + 2, 4);
723 printf("Should read as 0 - 9.\n");
724 report(data, 10);
725
726 /* Second test */
727 blf_key(&c, (uint8_t *) key2, strlen(key2));
728 blf_enc(&c, data2, 1);
729 printf("\nShould read as: 0x324ed0fe 0xf413a203.\n");
730 report(data2, 2);
731 blf_dec(&c, data2, 1);
732 report(data2, 2);
733 }
734 #endif
735 /* CRYPT DELETE END */
|
65 #define inline __inline
66 #else /* !__GNUC__ */
67 #define inline
68 #endif /* !__GNUC__ */
69
70 /* Function for Feistel Networks */
71
72 #define F(s, x) ((((s)[ (((x)>>24)&0xFF)] \
73 + (s)[0x100 + (((x)>>16)&0xFF)]) \
74 ^ (s)[0x200 + (((x)>> 8)&0xFF)]) \
75 + (s)[0x300 + ( (x) &0xFF)])
76
77 #define BLFRND(s,p,i,j,n) (i ^= F(s,j) ^ (p)[n])
78
79 void
80 Blowfish_encipher(c, xl, xr)
81 blf_ctx *c;
82 uint32_t *xl;
83 uint32_t *xr;
84 {
85 uint32_t Xl;
86 uint32_t Xr;
87 uint32_t *s = c->S[0];
88 uint32_t *p = c->P;
89
90 Xl = *xl;
91 Xr = *xr;
92
93 Xl ^= p[0];
94 BLFRND(s, p, Xr, Xl, 1); BLFRND(s, p, Xl, Xr, 2);
95 BLFRND(s, p, Xr, Xl, 3); BLFRND(s, p, Xl, Xr, 4);
96 BLFRND(s, p, Xr, Xl, 5); BLFRND(s, p, Xl, Xr, 6);
97 BLFRND(s, p, Xr, Xl, 7); BLFRND(s, p, Xl, Xr, 8);
98 BLFRND(s, p, Xr, Xl, 9); BLFRND(s, p, Xl, Xr, 10);
99 BLFRND(s, p, Xr, Xl, 11); BLFRND(s, p, Xl, Xr, 12);
100 BLFRND(s, p, Xr, Xl, 13); BLFRND(s, p, Xl, Xr, 14);
101 BLFRND(s, p, Xr, Xl, 15); BLFRND(s, p, Xl, Xr, 16);
102
103 *xl = Xr ^ p[17];
104 *xr = Xl;
105 }
106
107 void
108 Blowfish_decipher(c, xl, xr)
109 blf_ctx *c;
110 uint32_t *xl;
111 uint32_t *xr;
112 {
113 uint32_t Xl;
114 uint32_t Xr;
115 uint32_t *s = c->S[0];
116 uint32_t *p = c->P;
117
118 Xl = *xl;
119 Xr = *xr;
120
121 Xl ^= p[17];
122 BLFRND(s, p, Xr, Xl, 16); BLFRND(s, p, Xl, Xr, 15);
123 BLFRND(s, p, Xr, Xl, 14); BLFRND(s, p, Xl, Xr, 13);
124 BLFRND(s, p, Xr, Xl, 12); BLFRND(s, p, Xl, Xr, 11);
125 BLFRND(s, p, Xr, Xl, 10); BLFRND(s, p, Xl, Xr, 9);
126 BLFRND(s, p, Xr, Xl, 8); BLFRND(s, p, Xl, Xr, 7);
127 BLFRND(s, p, Xr, Xl, 6); BLFRND(s, p, Xl, Xr, 5);
128 BLFRND(s, p, Xr, Xl, 4); BLFRND(s, p, Xl, Xr, 3);
129 BLFRND(s, p, Xr, Xl, 2); BLFRND(s, p, Xl, Xr, 1);
130
131 *xl = Xr ^ p[0];
132 *xr = Xl;
133 }
134
135 void
136 Blowfish_initstate(c)
137 blf_ctx *c;
138 {
139 /* P-box and S-box tables initialized with digits of Pi */
140
141 const blf_ctx initstate =
142
143 { {
144 {
145 0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7,
146 0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99,
147 0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16,
148 0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e,
149 0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee,
150 0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013,
151 0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef,
152 0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e,
153 0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60,
154 0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440,
155 0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce,
156 0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a,
157 0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e,
158 0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677,
394 0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614,
395 0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a,
396 0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6,
397 0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b,
398 0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0,
399 0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060,
400 0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e,
401 0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9,
402 0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f,
403 0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6}
404 },
405 {
406 0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344,
407 0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89,
408 0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
409 0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917,
410 0x9216d5d9, 0x8979fb1b
411 } };
412
413 *c = initstate;
414 }
415
416 uint32_t
417 Blowfish_stream2word(const uint8_t *data, uint16_t databytes, uint16_t *current)
418 {
419 uint8_t i;
420 uint16_t j;
421 uint32_t temp;
422
423 temp = 0x00000000;
424 j = *current;
425
426 for (i = 0; i < 4; i++, j++) {
427 if (j >= databytes)
428 j = 0;
429 temp = (temp << 8) | data[j];
430 }
431
432 *current = j;
433 return temp;
434 }
435
436 void
437 Blowfish_expand0state(blf_ctx *c, const uint8_t *key, uint16_t keybytes)
438 {
439 uint16_t i;
440 uint16_t j;
441 uint16_t k;
442 uint32_t temp;
443 uint32_t datal;
444 uint32_t datar;
445
446 j = 0;
447 for (i = 0; i < BLF_N + 2; i++) {
448 /* Extract 4 int8 to 1 int32 from keystream */
449 temp = Blowfish_stream2word(key, keybytes, &j);
450 c->P[i] = c->P[i] ^ temp;
451 }
452
453 j = 0;
454 datal = 0x00000000;
455 datar = 0x00000000;
456 for (i = 0; i < BLF_N + 2; i += 2) {
457 Blowfish_encipher(c, &datal, &datar);
458
459 c->P[i] = datal;
460 c->P[i + 1] = datar;
461 }
462
463 for (i = 0; i < 4; i++) {
464 for (k = 0; k < 256; k += 2) {
465 Blowfish_encipher(c, &datal, &datar);
466
467 c->S[i][k] = datal;
468 c->S[i][k + 1] = datar;
469 }
470 }
471 }
472
473
474 void
475 Blowfish_expandstate(blf_ctx *c, const uint8_t *data, uint16_t databytes,
476 const uint8_t *key, uint16_t keybytes)
477 {
478 uint16_t i;
479 uint16_t j;
480 uint16_t k;
481 uint32_t temp;
482 uint32_t datal;
483 uint32_t datar;
484
485 j = 0;
486 for (i = 0; i < BLF_N + 2; i++) {
487 /* Extract 4 int8 to 1 int32 from keystream */
488 temp = Blowfish_stream2word(key, keybytes, &j);
489 c->P[i] = c->P[i] ^ temp;
490 }
491
492 j = 0;
493 datal = 0x00000000;
494 datar = 0x00000000;
495 for (i = 0; i < BLF_N + 2; i += 2) {
496 datal ^= Blowfish_stream2word(data, databytes, &j);
497 datar ^= Blowfish_stream2word(data, databytes, &j);
498 Blowfish_encipher(c, &datal, &datar);
499
500 c->P[i] = datal;
501 c->P[i + 1] = datar;
502 }
503
504 for (i = 0; i < 4; i++) {
505 for (k = 0; k < 256; k += 2) {
506 datal ^= Blowfish_stream2word(data, databytes, &j);
507 datar ^= Blowfish_stream2word(data, databytes, &j);
508 Blowfish_encipher(c, &datal, &datar);
509
510 c->S[i][k] = datal;
511 c->S[i][k + 1] = datar;
512 }
513 }
514 }
515
516 void
517 blf_key(blf_ctx *c, const uint8_t *k, uint16_t len)
518 {
519 /* Initialize S-boxes and subkeys with Pi */
520 Blowfish_initstate(c);
521
522 /* Transform S-boxes and subkeys with key */
523 Blowfish_expand0state(c, k, len);
524 }
525
526 void
527 blf_enc(blf_ctx *c, uint32_t *data, uint16_t blocks)
528 {
529 uint32_t *d;
530 uint16_t i;
531
532 d = data;
533 for (i = 0; i < blocks; i++) {
534 Blowfish_encipher(c, d, d + 1);
535 d += 2;
536 }
537 }
538
539 void
540 blf_dec(blf_ctx *c, uint32_t *data, uint16_t blocks)
541 {
542 uint32_t *d;
543 uint16_t i;
544
545 d = data;
546 for (i = 0; i < blocks; i++) {
547 Blowfish_decipher(c, d, d + 1);
548 d += 2;
549 }
550 }
551
552 void
553 blf_ecb_encrypt(blf_ctx *c, uint8_t *data, uint32_t len)
554 {
555 uint32_t l, r;
556 uint32_t i;
557
558 for (i = 0; i < len; i += 8) {
559 l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
560 r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
561 Blowfish_encipher(c, &l, &r);
562 data[0] = l >> 24 & 0xff;
563 data[1] = l >> 16 & 0xff;
564 data[2] = l >> 8 & 0xff;
565 data[3] = l & 0xff;
566 data[4] = r >> 24 & 0xff;
567 data[5] = r >> 16 & 0xff;
568 data[6] = r >> 8 & 0xff;
569 data[7] = r & 0xff;
570 data += 8;
571 }
572 }
573
574 void
575 blf_ecb_decrypt(blf_ctx *c, uint8_t *data, uint32_t len)
576 {
577 uint32_t l, r;
578 uint32_t i;
579
580 for (i = 0; i < len; i += 8) {
581 l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
582 r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
583 Blowfish_decipher(c, &l, &r);
584 data[0] = l >> 24 & 0xff;
585 data[1] = l >> 16 & 0xff;
586 data[2] = l >> 8 & 0xff;
587 data[3] = l & 0xff;
588 data[4] = r >> 24 & 0xff;
589 data[5] = r >> 16 & 0xff;
590 data[6] = r >> 8 & 0xff;
591 data[7] = r & 0xff;
592 data += 8;
593 }
594 }
595
596 void
597 blf_cbc_encrypt(blf_ctx *c, uint8_t *iv, uint8_t *data, uint32_t len)
598 {
599 uint32_t l, r;
600 uint32_t i, j;
601
602 for (i = 0; i < len; i += 8) {
603 for (j = 0; j < 8; j++)
604 data[j] ^= iv[j];
605 l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
606 r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
607 Blowfish_encipher(c, &l, &r);
608 data[0] = l >> 24 & 0xff;
609 data[1] = l >> 16 & 0xff;
610 data[2] = l >> 8 & 0xff;
611 data[3] = l & 0xff;
612 data[4] = r >> 24 & 0xff;
613 data[5] = r >> 16 & 0xff;
614 data[6] = r >> 8 & 0xff;
615 data[7] = r & 0xff;
616 iv = data;
617 data += 8;
618 }
619 }
620
621 void
622 blf_cbc_decrypt(blf_ctx *c, uint8_t *iva, uint8_t *data, uint32_t len)
623 {
624 uint32_t l, r;
625 uint8_t *iv;
626 uint32_t i, j;
627
628 iv = data + len - 16;
629 data = data + len - 8;
630 for (i = len - 8; i >= 8; i -= 8) {
631 l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
632 r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
633 Blowfish_decipher(c, &l, &r);
634 data[0] = l >> 24 & 0xff;
635 data[1] = l >> 16 & 0xff;
636 data[2] = l >> 8 & 0xff;
637 data[3] = l & 0xff;
638 data[4] = r >> 24 & 0xff;
639 data[5] = r >> 16 & 0xff;
640 data[6] = r >> 8 & 0xff;
641 data[7] = r & 0xff;
642 for (j = 0; j < 8; j++)
643 data[j] ^= iv[j];
644 iv -= 8;
645 data -= 8;
646 }
647 l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
648 r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
649 Blowfish_decipher(c, &l, &r);
650 data[0] = l >> 24 & 0xff;
651 data[1] = l >> 16 & 0xff;
652 data[2] = l >> 8 & 0xff;
653 data[3] = l & 0xff;
654 data[4] = r >> 24 & 0xff;
655 data[5] = r >> 16 & 0xff;
656 data[6] = r >> 8 & 0xff;
657 data[7] = r & 0xff;
658 for (j = 0; j < 8; j++)
659 data[j] ^= iva[j];
660 }
661
662 #if 0
663 void
664 report(uint32_t data[], uint16_t len)
665 {
666 uint16_t i;
667 for (i = 0; i < len; i += 2)
668 printf("Block %0hd: %08lx %08lx.\n",
669 i / 2, data[i], data[i + 1]);
670 }
671 void
672 main(void)
673 {
674
675 blf_ctx c;
676 char key[] = "AAAAA";
677 char key2[] = "abcdefghijklmnopqrstuvwxyz";
678
679 uint32_t data[10];
680 uint32_t data2[] =
681 {0x424c4f57l, 0x46495348l};
685 /* First test */
686 for (i = 0; i < 10; i++)
687 data[i] = i;
688
689 blf_key(&c, (uint8_t *) key, 5);
690 blf_enc(&c, data, 5);
691 blf_dec(&c, data, 1);
692 blf_dec(&c, data + 2, 4);
693 printf("Should read as 0 - 9.\n");
694 report(data, 10);
695
696 /* Second test */
697 blf_key(&c, (uint8_t *) key2, strlen(key2));
698 blf_enc(&c, data2, 1);
699 printf("\nShould read as: 0x324ed0fe 0xf413a203.\n");
700 report(data2, 2);
701 blf_dec(&c, data2, 1);
702 report(data2, 2);
703 }
704 #endif
|