/*
   blowfish.c -- handles:
     encryption and decryption of passwords

   The first half of this is very lightly edited from public domain
   sourcecode.  For simplicity, this entire module will remain public
   domain.
*/

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "blowfish.h"
#include "bf_tab.h"             /* P-box P-array, S-box  */

#define S(x,i) (bf_S[i][x.w.byte##i])
#define bf_F(x) (((S(x,0) + S(x,1)) ^ S(x,2)) + S(x,3))
#define ROUND(a,b,n) (a.word ^= bf_F(b) ^ bf_P[n])

static UWORD_32bits bf_P[bf_N+2];
static UWORD_32bits bf_S[4][256];

void blowfish_encipher(xl,xr)
UWORD_32bits *xl; UWORD_32bits *xr;
{
  union aword  Xl;
  union aword  Xr;

  Xl.word = *xl;
  Xr.word = *xr;

  Xl.word ^= bf_P[0];
  ROUND (Xr, Xl, 1);  ROUND (Xl, Xr, 2);
  ROUND (Xr, Xl, 3);  ROUND (Xl, Xr, 4);
  ROUND (Xr, Xl, 5);  ROUND (Xl, Xr, 6);
  ROUND (Xr, Xl, 7);  ROUND (Xl, Xr, 8);
  ROUND (Xr, Xl, 9);  ROUND (Xl, Xr, 10);
  ROUND (Xr, Xl, 11); ROUND (Xl, Xr, 12);
  ROUND (Xr, Xl, 13); ROUND (Xl, Xr, 14);
  ROUND (Xr, Xl, 15); ROUND (Xl, Xr, 16);
  Xr.word ^= bf_P[17];

  *xr = Xl.word;
  *xl = Xr.word;
}

void blowfish_decipher(xl,xr)
UWORD_32bits *xl; UWORD_32bits *xr;
{
   union aword  Xl;
   union aword  Xr;

   Xl.word = *xl;
   Xr.word = *xr;

   Xl.word ^= bf_P[17];
   ROUND (Xr, Xl, 16);  ROUND (Xl, Xr, 15);
   ROUND (Xr, Xl, 14);  ROUND (Xl, Xr, 13);
   ROUND (Xr, Xl, 12);  ROUND (Xl, Xr, 11);
   ROUND (Xr, Xl, 10);  ROUND (Xl, Xr, 9);
   ROUND (Xr, Xl, 8);   ROUND (Xl, Xr, 7);
   ROUND (Xr, Xl, 6);   ROUND (Xl, Xr, 5);
   ROUND (Xr, Xl, 4);   ROUND (Xl, Xr, 3);
   ROUND (Xr, Xl, 2);   ROUND (Xl, Xr, 1);
   Xr.word ^= bf_P[0];

   *xl = Xr.word;
   *xr = Xl.word;
}

void blowfish_init(key,keybytes)
UBYTE_08bits *key; short keybytes;
{
  int i,j;
  UWORD_32bits  data;
  UWORD_32bits  datal;
  UWORD_32bits  datar;
  union aword temp;

  /* robey: reset blowfish boxes to initial state */
  /* (i guess normally it just keeps scrambling them, but here it's */
  /* important to get the same encrypted result each time) */
  for (i=0; i<bf_N+2; i++) bf_P[i]=initbf_P[i];
  for (i=0; i<4; i++) for (j=0; j<256; j++) bf_S[i][j]=initbf_S[i][j];

  j = 0;
  for (i = 0; i < bf_N + 2; ++i) {
    temp.word = 0;
    temp.w.byte0 = key[j];
    temp.w.byte1 = key[(j+1)%keybytes];
    temp.w.byte2 = key[(j+2)%keybytes];
    temp.w.byte3 = key[(j+3)%keybytes];
    data = temp.word;
    bf_P[i] = bf_P[i] ^ data;
    j = (j + 4) % keybytes;
  }

  datal = 0x00000000;
  datar = 0x00000000;

  for (i = 0; i < bf_N + 2; i += 2) {
    blowfish_encipher(&datal, &datar);

    bf_P[i] = datal;
    bf_P[i + 1] = datar;
  }

  for (i = 0; i < 4; ++i) {
    for (j = 0; j < 256; j += 2) {

      blowfish_encipher(&datal, &datar);

      bf_S[i][j] = datal;
      bf_S[i][j + 1] = datar;
    }
  }
}


/* stuff below this line was written by robey for eggdrop use */

/* of course, if you change either of these, then your userfile will */
/* no longer be able to be shared. :)  */
#define SALT1  0xdeadd061
#define SALT2  0x23f6b095

/* convert 64-bit encrypted password to text for userfile */
char *base64="./0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";

void encrypt_pass(text,new)
char *text; char *new;
{
  UWORD_32bits left,right; int n; char *p;
  blowfish_init(text,strlen(text));
  left=SALT1; right=SALT2;
  blowfish_encipher(&left,&right);
  p=new; *p++='+';     /* + means encrypted pass */
  n=32; while (n>0) {
    *p++ = base64[right&0x3f];
    right=(right>>6); n-=6;
  }
  n=32; while (n>0) {
    *p++ = base64[left&0x3f];
    left=(left>>6); n-=6;
  }
  *p=0;
}