305 lines
6.2 KiB
C
305 lines
6.2 KiB
C
|
/* zodiac - advanced dns spoofer
|
||
|
|
*
|
||
|
|
* blowfish encryption routines, reference implementation
|
||
|
|
*
|
||
|
|
* by: (unknown, possible bruce schneier)
|
||
|
|
* additions by random
|
||
|
|
* slightly modified by scut
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include <string.h>
|
||
|
|
#include "cipher-sha1.h"
|
||
|
|
#include "cipher-blowfish.h"
|
||
|
|
#include "cipher-blowfish-tab.h"
|
||
|
|
#include "common.h"
|
||
|
|
|
||
|
|
#define BOXES 3
|
||
|
|
|
||
|
|
/* #define S(x,i) (bf_S[i][x.w.byte##i]) */
|
||
|
|
#define S0(x) (bf_S[0][x.w.byte0])
|
||
|
|
#define S1(x) (bf_S[1][x.w.byte1])
|
||
|
|
#define S2(x) (bf_S[2][x.w.byte2])
|
||
|
|
#define S3(x) (bf_S[3][x.w.byte3])
|
||
|
|
#define bf_F(x) (((S0(x) + S1(x)) ^ S2(x)) + S3(x))
|
||
|
|
#define ROUND(a,b,n) (a.word ^= bf_F(b) ^ bf_P[n])
|
||
|
|
|
||
|
|
struct box_t {
|
||
|
|
UWORD_32bits *P;
|
||
|
|
UWORD_32bits **S;
|
||
|
|
char key[81];
|
||
|
|
char keybytes;
|
||
|
|
} box[BOXES];
|
||
|
|
|
||
|
|
static void blowfish_encipher (UWORD_32bits *xl, UWORD_32bits *xr);
|
||
|
|
static void blowfish_decipher (UWORD_32bits *xl, UWORD_32bits *xr);
|
||
|
|
static void blowfish_init (UBYTE_08bits *key, short keybytes, int bxtouse);
|
||
|
|
|
||
|
|
|
||
|
|
UWORD_32bits *bf_P;
|
||
|
|
UWORD_32bits **bf_S;
|
||
|
|
|
||
|
|
|
||
|
|
static void
|
||
|
|
blowfish_encipher (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;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
static void
|
||
|
|
blowfish_decipher (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;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
static void
|
||
|
|
blowfish_init (UBYTE_08bits *key, short keybytes, int bxtouse)
|
||
|
|
{
|
||
|
|
int i, j, bx;
|
||
|
|
UWORD_32bits data;
|
||
|
|
UWORD_32bits datal;
|
||
|
|
UWORD_32bits datar;
|
||
|
|
union aword temp;
|
||
|
|
|
||
|
|
for (i = 0 ; i < BOXES ; i++)
|
||
|
|
if (box[i].P != NULL) {
|
||
|
|
if ((box[i].keybytes == keybytes) &&
|
||
|
|
(strncmp ((char *) (box[i].key), (char *) key, keybytes) == 0))
|
||
|
|
{
|
||
|
|
bf_P = box[i].P;
|
||
|
|
bf_S = box[i].S;
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
bx = (-1);
|
||
|
|
|
||
|
|
for (i = 0 ; i < BOXES ; i++) {
|
||
|
|
if (box[i].P == NULL) {
|
||
|
|
bx = i;
|
||
|
|
i = BOXES + 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (bx < 0) {
|
||
|
|
bx = bxtouse;
|
||
|
|
free (box[bx].P);
|
||
|
|
|
||
|
|
for (i = 0 ; i < 4 ; i++)
|
||
|
|
free (box[bx].S[i]);
|
||
|
|
|
||
|
|
free (box[bx].S);
|
||
|
|
}
|
||
|
|
|
||
|
|
box[bx].P = (UWORD_32bits *) malloc ((bf_N + 2) * sizeof (UWORD_32bits));
|
||
|
|
box[bx].S = (UWORD_32bits **) malloc (4 * sizeof (UWORD_32bits *));
|
||
|
|
|
||
|
|
for (i = 0 ; i < 4 ; i++)
|
||
|
|
box[bx].S[i] = (UWORD_32bits *) malloc (256 * sizeof (UWORD_32bits));
|
||
|
|
|
||
|
|
bf_P = box[bx].P;
|
||
|
|
bf_S = box[bx].S;
|
||
|
|
box[bx].keybytes = keybytes;
|
||
|
|
strncpy (box[bx].key, key, keybytes);
|
||
|
|
|
||
|
|
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];
|
||
|
|
|
||
|
|
for (i = 0, j = 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;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
unsigned char *
|
||
|
|
bf_encipher (char *keyphrase, unsigned char *data, size_t data_len, size_t *result_len)
|
||
|
|
{
|
||
|
|
UWORD_32bits left, right; /* blowfish halfs */
|
||
|
|
unsigned long int dp_i; /* data pointer relative */
|
||
|
|
unsigned char key[20]; /* hash used as bf key */
|
||
|
|
unsigned char *data_enc,
|
||
|
|
*dp;
|
||
|
|
unsigned char *sp,
|
||
|
|
*source;
|
||
|
|
long int do_count;
|
||
|
|
|
||
|
|
/* build a strong hash out of a weak keyphrase
|
||
|
|
*/
|
||
|
|
SHA1Hash (keyphrase, key);
|
||
|
|
blowfish_init (key, sizeof (key), 0);
|
||
|
|
|
||
|
|
sp = source = xcalloc (1, data_len + (8 - (data_len % 8)) + 1);
|
||
|
|
memcpy (source, data, data_len);
|
||
|
|
dp = data_enc = xcalloc (1, data_len + 9);
|
||
|
|
|
||
|
|
do_count = data_len / 8;
|
||
|
|
if ((data_len % 8) != 0)
|
||
|
|
do_count += 1;
|
||
|
|
|
||
|
|
*result_len = do_count * 8;
|
||
|
|
|
||
|
|
for (dp_i = 0 ; dp_i < do_count ; ++dp_i) {
|
||
|
|
left = ((*sp++) << 24);
|
||
|
|
left |= ((*sp++) << 16);
|
||
|
|
left |= ((*sp++) << 8);
|
||
|
|
left |= (*sp++);
|
||
|
|
right = ((*sp++) << 24);
|
||
|
|
right |= ((*sp++) << 16);
|
||
|
|
right |= ((*sp++) << 8);
|
||
|
|
right |= (*sp++);
|
||
|
|
|
||
|
|
blowfish_encipher (&left, &right);
|
||
|
|
*dp++ = (right & 0xff000000) >> 24;
|
||
|
|
*dp++ = (right & 0x00ff0000) >> 16;
|
||
|
|
*dp++ = (right & 0x0000ff00) >> 8;
|
||
|
|
*dp++ = (right & 0x000000ff);
|
||
|
|
*dp++ = (left & 0xff000000) >> 24;
|
||
|
|
*dp++ = (left & 0x00ff0000) >> 16;
|
||
|
|
*dp++ = (left & 0x0000ff00) >> 8;
|
||
|
|
*dp++ = (left & 0x000000ff);
|
||
|
|
}
|
||
|
|
|
||
|
|
free (source);
|
||
|
|
|
||
|
|
return (data_enc);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
unsigned char *
|
||
|
|
bf_decipher (char *keyphrase, unsigned char *data, size_t data_len)
|
||
|
|
{
|
||
|
|
UWORD_32bits left, right; /* blowfish halfs */
|
||
|
|
unsigned long int dp_i; /* data pointer relative */
|
||
|
|
unsigned char key[20]; /* hash used as bf key */
|
||
|
|
unsigned char *data_dec,
|
||
|
|
*dp;
|
||
|
|
unsigned char *sp;
|
||
|
|
long int do_count;
|
||
|
|
|
||
|
|
/* sanity checking
|
||
|
|
*/
|
||
|
|
if ((data_len % 8) != 0)
|
||
|
|
return (NULL);
|
||
|
|
|
||
|
|
/* build a strong hash out of a weak keyphrase
|
||
|
|
*/
|
||
|
|
SHA1Hash (keyphrase, key);
|
||
|
|
blowfish_init (key, sizeof (key), 0);
|
||
|
|
|
||
|
|
sp = data;
|
||
|
|
dp = data_dec = xcalloc (1, data_len);
|
||
|
|
|
||
|
|
do_count = data_len / 8;
|
||
|
|
|
||
|
|
for (dp_i = 0 ; dp_i < do_count ; ++dp_i) {
|
||
|
|
right = ((*sp++) << 24);
|
||
|
|
right |= ((*sp++) << 16);
|
||
|
|
right |= ((*sp++) << 8);
|
||
|
|
right |= (*sp++);
|
||
|
|
left = ((*sp++) << 24);
|
||
|
|
left |= ((*sp++) << 16);
|
||
|
|
left |= ((*sp++) << 8);
|
||
|
|
left |= (*sp++);
|
||
|
|
|
||
|
|
blowfish_decipher (&left, &right);
|
||
|
|
|
||
|
|
*dp++ = (left & 0xff000000) >> 24;
|
||
|
|
*dp++ = (left & 0x00ff0000) >> 16;
|
||
|
|
*dp++ = (left & 0x0000ff00) >> 8;
|
||
|
|
*dp++ = (left & 0x000000ff);
|
||
|
|
*dp++ = (right & 0xff000000) >> 24;
|
||
|
|
*dp++ = (right & 0x00ff0000) >> 16;
|
||
|
|
*dp++ = (right & 0x0000ff00) >> 8;
|
||
|
|
*dp++ = (right & 0x000000ff);
|
||
|
|
}
|
||
|
|
|
||
|
|
return (data_dec);
|
||
|
|
}
|
||
|
|
|
||
|
|
|