typedefstruct {

short gen;/* irreducible polynomial used in this field */

short exp;/* exponent used to generate this s function */

} sfn desc;

sfn desc sfn[] = {

{/*101110111*/375,31},{/*101111011*/379,31},

{/*110000111*/391,31},{/*110001011*/395,31},

{/*110001101*/397,31},{/*110011111*/415,31},

{/*110100011*/419,31},{/*110101001*/425,31},

{/*110110001*/433,31},{/*110111101*/445,31},

{/*111000011*/451,31},{/*111001111*/463,31},

{/*111010111*/471,31},{/*111011101*/477,31},

{/*111100111*/487,31},{/*111110011*/499,31},

{00,00}};

typedef struct {

Long loki subkeys[ROUNDS]; } loki ctx;

static Long f();/* declare LOKI function f */

static short s();/* declare LOKI S-box fn s */

#define ROL12(b) b = ((b << 12) (b >> 20)); #define ROL13(b) b = ((b << 13) (b >> 19));

#ifdef LITTLE ENDIAN

#define bswap(cb) {\

register char c;\

c =cb[0];cb[0]=cb[3];cb[3]=c;\

c =cb[1];cb[1]=cb[2];cb[2]=c;\

c =cb[4];cb[4]=cb[7];cb[7]=c;\

c =cb[5];cb[5]=cb[6];cb[6]=c;\

setlokikey(loki ctx *c, char *key)

registeri;

register Long KL, KR;

#ifdef LITTLE ENDIAN

bswap(key);/* swap bytes round if little-endian */

KL = ((Long *)key)[0]; KR = ((Long *)key)[1];

for (i=0; i<ROUNDS; i+=4) {/* Generate the 16 subkeys */

c->loki subkeys[i] = KL;

ROL12 (KL);

c->loki subkeys[i+1] = KL;

ROL13 (KL);

c->loki subkeys[i+2] = KR;

ROL12 (KR);

c->loki subkeys[i+3] = KR;

ROL13 (KR);

#ifdef LITTLE ENDIAN

bswap(key);/* swap bytes back if little-endian */

L = ((Long *)b)[0];

R = ((Long *)b)[1];

for (i=0; i<ROUNDS; i+=2) {/* Encrypt with the 16 subkeys

L A= f (R,c->loki subkeys[i]);

R a= f (l,c->loki subkeys[i+1]);

((Long *)b)[0]= R;/* Y = swap(LR) */

((Long *)b)[1] = L;

#ifdef LITTLE ENDIAN

bswap(b);/* swap bytes round if little-endian */

#endif }

deloki(loki ctx *c, char *b)

registeri;

register Long L, R;/* left & right data halves */

#ifdef LITTLE ENDIAN

bswap(b);/* swap bytes round if little-endian */

L = ((Long *)b)[0];/* LR = X XOR K */

R = ((Long *)b)[1];

for (i=ROUNDS; i>0; i-=2) {/* subkeys in reverse

order */

L A= f(R, c->loki subkeys[i-1]); R A= f(L, c->loki subkeys[i-2]);

((Long *)b)[0] = R;/* Y = LR XOR K */

((Long *)b)[1] = L;

#define MASK120x0fff/* 12 bit mask for expansion E

static Long

f(r, k)

register Long r;/* Data value R(i-1) */

Longk;/* Key K(i) */

Long a, b, c;/* 32 bit S-box output, & P output */

enloki (loki ctx *c, char *b)

registeri;

register Long L, R;/* left & right data halves */

#ifdef LITTLE ENDIAN

bswap(b);/* swap bytes round if little-endian */

a = r л k;/* A = R(i-1) XOR K(i) */

/* want to use slow speed/small size version */

b = ((Long)s((a& MASK12))) /* B = S(E(R(i-1))AK(i))

((Long)s(((a >> 8) & MASK12)) << 8) ((Long)s(((a >> 16) & MASK12)) << 16) ((Long)s((((a >> 24) (a << 8)) & MASK12)) << 24);

perm32(&c, &b, P);/* C = P(S( E(R(i-1)) XOR K(i))) */

return(c);/* f returns the result C */

static short s(i)

register Long i;/* return S-box value for input i */

register short r, c, v, t;

short exp8();/* exponentiation routine for GF(2A8) */

r = ((i>>8) & 0xc) (i & 0x3);/* row value-top 2 &

bottom 2 */

c = (i>>2) & 0xff;/* column

value-middle 8 bits */

t = (c + ((r * 17) л 0xff)) & 0xff;/* base value for Sfn */

v = exp8(t, sfn[r].exp, sfn[r].gen);/* Sfn[r] = t A exp

mod gen */

return(v);

#defineMSB 0x80000000L/* MSB of 32-bit word */

perm32(out, in , perm)

Long *out;/* Output 32-bit blockto be permuted */

Long *in;/* Input 32-bit blockafter permutation */

char perm[32];/* Permutation array*/

Long mask = MSB;/* mask used to set bit in

output */

register int i, o, b;/* input bit no, output bit no, value */

register char *p = perm;/* ptr to permutation array */

*out = 0;/* clear output block */

for (o=0; o<32; o++) {/* For each output bit

position o */

i =(int)*p++;/* get input bit permuted to

output o */

b = (*in >> i) & 01;/* value of input bit i */

if (b)/* If the input bit i is set */

*out = mask;/* OR in mask to

output i */

mask >>= 1;/* Shift mask to next

bit */

#define SIZE 256/* 256 elements in GF(2A8) */

short mult8(a, b, gen)

short a, b;/* operands for multiply */

short gen;/* irreducible polynomial generating Galois Field */