} /* ideaExpandKey */

static void

ideaInvertKey(word16 const *EK, word16 DK[IDEAKEYLEN])

uint16 t1, t2, t3;

word16 temp[IDEAKEYLEN];

word16 *p = temp + IDEAKEYLEN;

t1 = mulInv(*EK++);

t2 = -*EK++;

t3 = -*EK++;

*--p = mulInv(*EK++);

*-- p = t3; *-- p = t2; *-- p = t1;

for (i = 0; i < IDEAROUNDS-1;{

t1 = *EK++; *-p = *EK++;

*-- p = t1;

t1 = mulInv(*EK++);

t2 = -*EK++;

t3 = -*EK++;

*--p = mulInv(*EK++);

*-- p = t2; *-- p = t3; *-- p = t1;

t1 = *EK++; *-p = *EK++;

*-- p = t1;

t1 = mulInv(*EK++);

t2 = -*EK++;

t3 = -*EK++;

*--p = mulInv(*EK++);

*-- p = t3; *-- p = t2; *-- p = t1;

/* Copy and destroy temp copy */

memcpy(DK, temp, sizeof(temp));

for(i=0;i<IDEAKEYLEN;i++)temp[i]=0; } /* ideaInvertKey */

#ifdef SMALL CACHE

#define MUL(x,y) (x = mul(low16(x),y)) #else /* !SMALL CACHE */

#ifdef AVOID JUMPS

#define MUL(x,y) (x = low16(x-1), t16 = low16((y)-1), \

t32 = (word32)x*t16 + x + t16 + 1, x = low16(t32), \ t16 = t32>>16, x = (x-t16) + (x<t16) )

#else /* !AVOID JUMPS (default) */ #define MUL(x,y) \

((t16 = (y)) ? \

(x=low16(x)) ? \

t32 = (word32)x*t16, \ x = low16(t32), \ t16 = t32>>16, \

x = (x-t16) + (x<t16) \

(x = 1-t16) \ (x = 1-x))

#endif #endif

static void

ideaCipher(byte *inbuf, byte *outbuf, word16 *key)

register uint16 x1, x2, x3, x4, s2, s3; word16 *in, *out;

#ifndef SMALL CACHE

register uint16 t16; /* Temporaries needed by MUL macro */ register word32 t32;

int r = IDEAROUNDS;

in = (word16 *)inbuf; x1 = *in++; x2 = *in++; x3 = *in++; x4 = *in;

#ifndef HIGHFIRST

x1 = (x1 >>8) (x1<<8); x2 = (x2 >>8) (x2<<8); x3 = (x3 >>8) (x3<<8); x4 = (x4 >>8) (x4<<8);

MUL(x1,*key++); x2 += *key++; x3 += *key++; MUL(x4, *key++);

s3 = x3; x3 A= x1; MUL(x3, *key++); s2 = x2;

x2 A= x4;

x2 += x3; MUL(x2, *key++); x3 += x2;

x1 A= x2; x4 A= x3;

x2 A= s3; x3 A= s2; } while (--r); MUL(x1, *key++); x3 += *key++; x2 += *key++;

MUL(x4, *key);

out = (word16 *)outbuf;

#ifdef HIGHFIRST

*out++ = x1; *out++ = x3; *out++ = x2; *out = x4;

#else /* !HIGHFIRST */

*out++ = (x1 >>8) (x1<<8); *out++ = (x3 >>8) (x3<<8); *out++ = (x2 >>8) (x2<<8);

*out = (x4 >>8) (x4<<8);

} /* ideaCipher */

void idea key(idea ctx *c, unsigned char *key){ ideaExpandKey(key,c->ek); ideaInvertKey(c->ek,c->dk);

void idea enc(idea ctx *c, unsigned char *data, int blocks){ int i;

unsigned char *d = data;

for(i=0;i<blocks;i++){

ideaCipher(d,d,c->ek); d+=8;

void idea dec(idea ctx *c, unsigned char *data, int blocks){ int i;

unsigned char *d = data;

for(i=0;i<blocks;i++){

ideaCipher(d,d,c->dk); d+=8;

#include <stdio.h>

#ifndef BLOCKS #ifndef KBYTES #define KBYTES 1024 #endif

#define BLOCKS (64*KBYTES) #endif

main(void)

{/* Test driver for IDEA cipher */

int i, j, k; idea ctx c; byte userkey[16];

word16 EK[IDEAKEYLEN], DK[IDEAKEYLEN]; byte XX[8], YY[8], ZZ[8];

word32 long block[10]; /* 5 blocks */ long l; char *lbp;

/* Make a sample user key for testing... */ for(i=0; i<16;

userkey[i] =

idea key(&c,userkey);

/* Make a sample plaintext pattern for testing... */ for (k=0; k<8; k++)

XX[k] = k;

idea enc(&c,XX,1); /* encrypt */ lbp = (unsigned char *) long block;