Print this page
3882 remove xmod & friends


  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