[become] / src / blowfish.c

/* -*-c-*-
 *
 * $Id: blowfish.c,v 1.3 1997/08/07 09:42:58 mdw Exp $
 *
 * Blowfish encryption routines
 *
 * (c) 1997 Mark Wooding
 */
 
/*----- Licencing notice --------------------------------------------------*
 *
 * This file is part of `become'
 *
 * `Become' is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * `Become' is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with `become'; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */
 
/*----- Revision history --------------------------------------------------*
 *
 * $Log: blowfish.c,v $
 * Revision 1.3  1997/08/07 09:42:58  mdw
 * Fix address of the FSF.
 *
 * Revision 1.2  1997/08/04 10:24:20  mdw
 * Sources placed under CVS control.
 *
 * Revision 1.1  1997/07/21  13:47:53  mdw
 * Initial revision
 *
 */

/*----- Header files ------------------------------------------------------*/

/* --- ANSI headers --- */

#include <stdio.h>

/* --- Local headers --- */

#include "config.h"
#include "blowfish.h"
#include "utils.h"

/*----- Define the initial S-box values -----------------------------------*/

#include "blowfish-sbox.h"

/*----- Useful macros -----------------------------------------------------*/

/* --- The Blowfish round function --- *
 *
 * This is why I like this cipher.  The round function is microscopic.  And
 * very fast.
 */

#define ROUND(L, R, K)							\
  ((L) ^= k->p[K],							\
   (R) ^= ((((k->s0[((L) >> 24) & 0xFF]) +				\
	      k->s1[((L) >> 16) & 0xFF]) ^				\
	      k->s2[((L) >>  8) & 0xFF]) +				\
	      k->s3[((L) >>  0) & 0xFF]))

/*----- Main code ---------------------------------------------------------*/

/* --- @blowfish_encrypt@ --- *
 *
 * Arguments:	@const blowfish_key *k@ = pointer to key block
 *		@const void *from@ = block to encrypt from
 *		@void *to@ = block to encrypt to
 *
 * Returns:	---
 *
 * Use:		Encrypts a block using the Blowfish algorithm.
 */

void blowfish_encrypt(const blowfish_key *k, const void *from, void *to)
{
  uint_32 l, r;
  const unsigned char *f = from;
  unsigned char *t = to;

  /* --- Extract left and right block halves --- */

  l = load32(f + 0);
  r = load32(f + 4);

  /* --- Now run the round function on these values --- */

  ROUND(l, r,  0);
  ROUND(r, l,  1);
  ROUND(l, r,  2);
  ROUND(r, l,  3);
  ROUND(l, r,  4);
  ROUND(r, l,  5);
  ROUND(l, r,  6);
  ROUND(r, l,  7);
  ROUND(l, r,  8);
  ROUND(r, l,  9);
  ROUND(l, r, 10);
  ROUND(r, l, 11);
  ROUND(l, r, 12);
  ROUND(r, l, 13);
  ROUND(l, r, 14);
  ROUND(r, l, 15);

  /* --- Final transformation --- */

  l ^= k->p[16];
  r ^= k->p[17];

  /* --- Store the encrypted value --- */

  store32(t + 0, r);
  store32(t + 4, l);  
}

/* --- @blowfish_decrypt@ --- *
 *
 * Arguments:	@const blowfish_key *k@ = pointer to key block
 *		@const void *from@ = block to decrypt from
 *		@void *to@ = block to decrypt to
 *
 * Returns:	---
 *
 * Use:		Decrypts a block using the Blowfish algorithm.
 */

void blowfish_decrypt(const blowfish_key *k, const void *from, void *to)
{
  uint_32 l, r;
  const unsigned char *f = from;
  unsigned char *t = to;

  /* --- Extract left and right block halves --- */

  l = load32(f + 0);
  r = load32(f + 4);

  /* --- Now run the round function on these values --- */

  ROUND(l, r, 17);
  ROUND(r, l, 16);
  ROUND(l, r, 15);
  ROUND(r, l, 14);
  ROUND(l, r, 13);
  ROUND(r, l, 12);
  ROUND(l, r, 11);
  ROUND(r, l, 10);
  ROUND(l, r,  9);
  ROUND(r, l,  8);
  ROUND(l, r,  7);
  ROUND(r, l,  6);
  ROUND(l, r,  5);
  ROUND(r, l,  4);
  ROUND(l, r,  3);
  ROUND(r, l,  2);

  /* --- Final transformation --- */

  l ^= k->p[1];
  r ^= k->p[0];

  /* --- Store the decrypted value --- */

  store32(t + 0, r);
  store32(t + 4, l);  
}

/* --- @blowfish__qcrypt@ --- *
 *
 * Arguments:	@const blowfish_key *k@ = pointer to a key block
 *		@uint_32 *p@ = pointer to block to mangle
 *
 * Returns:	---
 *
 * Use:		Mangles a block using the Blowfish algorithm.
 */

static void blowfish__qcrypt(blowfish_key *k, uint_32 *p)
{
  uint_32 l = p[0], r = p[1];

  /* --- Run the round function --- */

  ROUND(l, r,  0);
  ROUND(r, l,  1);
  ROUND(l, r,  2);
  ROUND(r, l,  3);
  ROUND(l, r,  4);
  ROUND(r, l,  5);
  ROUND(l, r,  6);
  ROUND(r, l,  7);
  ROUND(l, r,  8);
  ROUND(r, l,  9);
  ROUND(l, r, 10);
  ROUND(r, l, 11);
  ROUND(l, r, 12);
  ROUND(r, l, 13);
  ROUND(l, r, 14);
  ROUND(r, l, 15);

  /* --- Output transformation --- */

  l ^= k->p[16];
  r ^= k->p[17];

  /* --- Store the new values --- */

  p[0] = r;
  p[1] = l;
}

/* --- @blowfish__buildKey@ --- *
 *
 * Arguments:	@blowfish_key *k@ = pointer to a key block to set up
 *
 * Returns:	---
 *
 * Use:		Sets up the P-array and S-boxes once a key has been mixed
 *		into the P-array.  Use a local copy of the Blowfish
 *		encryption routine, to avoid penalising the main code too
 *		much with having to veneer onto a general args-in-words
 *		function, and to avoid me messing about with transforming
 *		values backwards and forwards between char arrays and
 *		integers.
 */

static void blowfish__buildKey(blowfish_key *k)
{
  uint_32 b[2] = { 0, 0 };
  int i;

  /* --- First, run through the P-array --- */

  for (i = 0; i < 18; i += 2) {
    blowfish__qcrypt(k, b);
    k->p[i] = b[0];
    k->p[i + 1] = b[1];
  }

  /* --- Now do the S-boxes --- */

  for (i = 0; i < 256; i += 2) {
    blowfish__qcrypt(k, b);
    k->s0[i] = b[0];
    k->s0[i + 1] = b[1];
  }

  for (i = 0; i < 256; i += 2) {
    blowfish__qcrypt(k, b);
    k->s1[i] = b[0];
    k->s1[i + 1] = b[1];
  }

  for (i = 0; i < 256; i += 2) {
    blowfish__qcrypt(k, b);
    k->s2[i] = b[0];
    k->s2[i + 1] = b[1];
  }

  for (i = 0; i < 256; i += 2) {
    blowfish__qcrypt(k, b);
    k->s3[i] = b[0];
    k->s3[i + 1] = b[1];
  }
}

/* --- @blowfish_setKey@ --- *
 *
 * Arguments:	@blowfish_key *kb@ = pointer to key block to fill
 *		@void *k@ = pointer to key data
 *		@size_t sz@ = length of data in bytes
 *
 * Returns:	---
 *
 * Use:		Expands a key which isn't represented as a number of whole
 *		words.  This is a nonstandard extension, although it can be
 *		used to support 40-bit keys, which some governments might
 *		find more palatable than 160-bit (or 448-bit!) keys.
 */

void blowfish_setKey(blowfish_key *kb, const void *k, size_t sz)
{
  int i, j, l;
  const unsigned char *p = k;
  uint_32 a;

  memcpy(kb, &blowfish__init, sizeof(blowfish__init));

  j = 0;
  for (i = 0; i < 18; i++) {
    a = 0;
    for (l = 0; l < 4; l++) {
      a = (a << 8) | p[j];
      j++;
      if (j >= sz)
	j = 0;
    }
    kb->p[i] ^= a;
  }

  blowfish__buildKey(kb);
}

/*----- Test rig ----------------------------------------------------------*/

#ifdef TEST_RIG

int main(void)
{
  /* --- Stage one: ECB tests --- */

  {
    static struct {
      uint_32 k[2];
      uint_32 p[2];
      uint_32 c[2];
    } table[] = {
      { { 0x00000000u, 0x00000000u },
        { 0x00000000u, 0x00000000u },
        { 0x4EF99745u, 0x6198DD78u } },

      { { 0xFFFFFFFFu, 0xFFFFFFFFu },
        { 0xFFFFFFFFu, 0xFFFFFFFFu },
        { 0x51866FD5u, 0xB85ECB8Au } },

      { { 0x30000000u, 0x00000000u },
        { 0x10000000u, 0x00000001u },
        { 0x7D856F9Au, 0x613063F2u } },

      { { 0x11111111u, 0x11111111u },
        { 0x11111111u, 0x11111111u },
        { 0x2466DD87u, 0x8B963C9Du } },

      { { 0x01234567u, 0x89ABCDEFu },
        { 0x11111111u, 0x11111111u },
        { 0x61F9C380u, 0x2281B096u } },

      { { 0x11111111u, 0x11111111u },
        { 0x01234567u, 0x89ABCDEFu },
        { 0x7D0CC630u, 0xAFDA1EC7u } },

      { { 0x00000000u, 0x00000000u },
        { 0x00000000u, 0x00000000u },
        { 0x4EF99745u, 0x6198DD78u } },

      { { 0xFEDCBA98u, 0x76543210u },
        { 0x01234567u, 0x89ABCDEFu },
        { 0x0ACEAB0Fu, 0xC6A0A28Du } },

      { { 0x7CA11045u, 0x4A1A6E57u },
        { 0x01A1D6D0u, 0x39776742u },
        { 0x59C68245u, 0xEB05282Bu } },

      { { 0x0131D961u, 0x9DC1376Eu },
        { 0x5CD54CA8u, 0x3DEF57DAu },
        { 0xB1B8CC0Bu, 0x250F09A0u } },

      { { 0x07A1133Eu, 0x4A0B2686u },
        { 0x0248D438u, 0x06F67172u },
        { 0x1730E577u, 0x8BEA1DA4u } },

      { { 0x3849674Cu, 0x2602319Eu },
        { 0x51454B58u, 0x2DDF440Au },
        { 0xA25E7856u, 0xCF2651EBu } },

      { { 0x04B915BAu, 0x43FEB5B6u },
        { 0x42FD4430u, 0x59577FA2u },
        { 0x353882B1u, 0x09CE8F1Au } },

      { { 0x0113B970u, 0xFD34F2CEu },
        { 0x059B5E08u, 0x51CF143Au },
        { 0x48F4D088u, 0x4C379918u } },

      { { 0x0170F175u, 0x468FB5E6u },
        { 0x0756D8E0u, 0x774761D2u },
        { 0x432193B7u, 0x8951FC98u } },

      { { 0x43297FADu, 0x38E373FEu },
        { 0x762514B8u, 0x29BF486Au },
        { 0x13F04154u, 0xD69D1AE5u } },

      { { 0x07A71370u, 0x45DA2A16u },
        { 0x3BDD1190u, 0x49372802u },
        { 0x2EEDDA93u, 0xFFD39C79u } },

      { { 0x04689104u, 0xC2FD3B2Fu },
        { 0x26955F68u, 0x35AF609Au },
        { 0xD887E039u, 0x3C2DA6E3u } },

      { { 0x37D06BB5u, 0x16CB7546u },
        { 0x164D5E40u, 0x4F275232u },
        { 0x5F99D04Fu, 0x5B163969u } },

      { { 0x1F08260Du, 0x1AC2465Eu },
        { 0x6B056E18u, 0x759F5CCAu },
        { 0x4A057A3Bu, 0x24D3977Bu } },

      { { 0x58402364u, 0x1ABA6176u },
        { 0x004BD6EFu, 0x09176062u },
        { 0x452031C1u, 0xE4FADA8Eu } },

      { { 0x02581616u, 0x4629B007u },
        { 0x480D3900u, 0x6EE762F2u },
        { 0x7555AE39u, 0xF59B87BDu } },

      { { 0x49793EBCu, 0x79B3258Fu },
        { 0x437540C8u, 0x698F3CFAu },
        { 0x53C55F9Cu, 0xB49FC019u } },

      { { 0x4FB05E15u, 0x15AB73A7u },
        { 0x072D43A0u, 0x77075292u },
        { 0x7A8E7BFAu, 0x937E89A3u } },

      { { 0x49E95D6Du, 0x4CA229BFu },
        { 0x02FE5577u, 0x8117F12Au },
        { 0xCF9C5D7Au, 0x4986ADB5u } },

      { { 0x018310DCu, 0x409B26D6u },
        { 0x1D9D5C50u, 0x18F728C2u },
        { 0xD1ABB290u, 0x658BC778u } },

      { { 0x1C587F1Cu, 0x13924FEFu },
        { 0x30553228u, 0x6D6F295Au },
        { 0x55CB3774u, 0xD13EF201u } },

      { { 0x01010101u, 0x01010101u },
        { 0x01234567u, 0x89ABCDEFu },
        { 0xFA34EC48u, 0x47B268B2u } },

      { { 0x1F1F1F1Fu, 0x0E0E0E0Eu },
        { 0x01234567u, 0x89ABCDEFu },
        { 0xA7907951u, 0x08EA3CAEu } },

      { { 0xE0FEE0FEu, 0xF1FEF1FEu },
        { 0x01234567u, 0x89ABCDEFu },
        { 0xC39E072Du, 0x9FAC631Du } },

      { { 0x00000000u, 0x00000000u },
        { 0xFFFFFFFFu, 0xFFFFFFFFu },
        { 0x014933E0u, 0xCDAFF6E4u } },

      { { 0xFFFFFFFFu, 0xFFFFFFFFu },
        { 0x00000000u, 0x00000000u },
        { 0xF21E9A77u, 0xB71C49BCu } },

      { { 0x01234567u, 0x89ABCDEFu },
        { 0x00000000u, 0x00000000u },
        { 0x24594688u, 0x5754369Au } },

      { { 0xFEDCBA98u, 0x76543210u },
        { 0xFFFFFFFFu, 0xFFFFFFFFu },
        { 0x6B5C5A9Cu, 0x5D9E0A5Au } }
    };

    int f = 1;
    int i;

    printf("*** stage one: ");
    fflush(stdout);

    for (i = 0; i < sizeof(table) / sizeof(table[0]); i++) {
      char kb[8], p[8], c[8];
      blowfish_key k;

      store32(kb + 0, table[i].k[0]);
      store32(kb + 4, table[i].k[1]);
      blowfish_setKey(&k, kb, 8);

      store32(p + 0, table[i].p[0]);
      store32(p + 4, table[i].p[1]);
      blowfish_encrypt(&k, p, c);

      if (load32(c + 0) != table[i].c[0] ||
	  load32(c + 4) != table[i].c[1]) {
	printf("\n"
	       "!!! bad encryption\n"
	       "                    key = %08lx-%08lx\n"
	       "              plaintext = %08lx-%08lx\n"
	       "    expected ciphertext = %08lx-%08lx\n"
	       "  calculated ciphertext = %08lx-%08lx\n",
	       (unsigned long)table[i].k[0],
	       (unsigned long)table[i].k[1],
	       (unsigned long)table[i].p[0],
	       (unsigned long)table[i].p[1],
	       (unsigned long)table[i].c[0],
	       (unsigned long)table[i].c[1],
	       (unsigned long)load32(c + 0),
	       (unsigned long)load32(c + 4));
	f = 0;
      }

      blowfish_decrypt(&k, c, p);
      if (load32(p + 0) != table[i].p[0] ||
	  load32(p + 4) != table[i].p[1]) {
	printf("\n"
	       "!!! bad decryption\n"
	       "                    key = %08lx-%08lx\n"
	       "             ciphertext = %08lx-%08lx\n"
	       "     expected plaintext = %08lx-%08lx\n"
	       "   calculated plaintext = %08lx-%08lx\n",
	       (unsigned long)table[i].k[0],
	       (unsigned long)table[i].k[1],
	       (unsigned long)table[i].c[0],
	       (unsigned long)table[i].c[1],
	       (unsigned long)table[i].p[0],
	       (unsigned long)table[i].p[1],
	       (unsigned long)load32(p + 0),
	       (unsigned long)load32(p + 4));
	f = 0;
      }

      putchar('.');
      fflush(stdout);
    }
    putchar('\n');
    if (f)
      printf("*** stage one ok\n");
  }

  /* --- Stage 2: key scheduling --- */

  {
    static struct {
      uint_32 c[2];
    } table[] = {
      {{ 0xF9AD597Cu, 0x49DB005Eu }},
      {{ 0xE91D21C1u, 0xD961A6D6u }},
      {{ 0xE9C2B70Au, 0x1BC65CF3u }},
      {{ 0xBE1E6394u, 0x08640F05u }},
      {{ 0xB39E4448u, 0x1BDB1E6Eu }},
      {{ 0x9457AA83u, 0xB1928C0Du }},
      {{ 0x8BB77032u, 0xF960629Du }},
      {{ 0xE87A244Eu, 0x2CC85E82u }},
      {{ 0x15750E7Au, 0x4F4EC577u }},
      {{ 0x122BA70Bu, 0x3AB64AE0u }},
      {{ 0x3A833C9Au, 0xFFC537F6u }},
      {{ 0x9409DA87u, 0xA90F6BF2u }},
      {{ 0x884F8062u, 0x5060B8B4u }},
      {{ 0x1F85031Cu, 0x19E11968u }},
      {{ 0x79D9373Au, 0x714CA34Fu }},
      {{ 0x93142887u, 0xEE3BE15Cu }},
      {{ 0x03429E83u, 0x8CE2D14Bu }},
      {{ 0xA4299E27u, 0x469FF67Bu }},
      {{ 0xAFD5AED1u, 0xC1BC96A8u }},
      {{ 0x10851C0Eu, 0x3858DA9Fu }},
      {{ 0xE6F51ED7u, 0x9B9DB21Fu }},
      {{ 0x64A6E14Au, 0xFD36B46Fu }},
      {{ 0x80C7D7D4u, 0x5A5479ADu }},
      {{ 0x05044B62u, 0xFA52D080u }},
    };

    unsigned char kk[] = {
      0xF0, 0xE1, 0xD2, 0xC3, 0xB4, 0xA5, 0x96, 0x87,
      0x78, 0x69, 0x5A, 0x4B, 0x3C, 0x2D, 0x1E, 0x0F,
      0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77
    };

    int i;
    int f = 1;

    printf("*** stage two: ");
    fflush(stdout);

    for (i = 0; i < sizeof(kk); i++) {
      blowfish_key k;
      unsigned char p[8] = { 0xFE, 0xDC, 0xBA, 0x98,
			     0x76, 0x54, 0x32, 0x10 };

      blowfish_setKey(&k, kk, i + 1);
      blowfish_encrypt(&k, p, p);

      if (load32(p + 0) != table[i].c[0] ||
	  load32(p + 4) != table[i].c[1]) {
	printf("!!! bad encryption\n"
	       "  key length = %i\n"
	       "    expected = %08lx-%08lx\n"
	       "  calculated = %08lx-%08lx\n",
	       i + 1,
	       (unsigned long)table[i].c[0],
	       (unsigned long)table[i].c[1],
	       (unsigned long)load32(p + 0),
	       (unsigned long)load32(p + 4));
	f = 0;
      }

      putchar('.');
      fflush(stdout);
    }

    putchar('\n');

    if (f)
      printf("*** stage two ok\n");
  }

  return (0);

}      

#endif

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