Экспорт и импорт криптографии за рубежом 2 страница

leftt ^ = (work << 16);

work = ((right >> 2) leftt) & Ox33333333L;

leftt ^= work;

right ^= (work << 2);

work = ((right >> 8) leftt) & OxOOtfOOffL;

leftt ^= work;

right ^= (work << 8);

right = ((right << 1) | ((right >> 31) & 1L)) & OxffffffffL;

work = (leftt ^ right) & OxaaaaaaaaL;

leftt ^= work;

right ^=work;

leftt = ((leftt << 1) | ((leftt >> 31) & 1L)) & OxffffffffL;

for(round = 0; round <8; round++) {

work = (right << 28) | (right >> 4);

work ^=*keys++;

fval = SP7[ work & Ox3fL];

fval |= SP5[(work >> 8) & Ox3fL];

fval |= SP3[(work >> 16) & Ox3fL];

fval | =SP1[(work >> 24) & Ox3fl-:l;

work = right ^ *keys++;

fval | = SP81* work & Ox3fL];

fval |= SP6[(work >> 8) & Ox3fL];

fval |= SP4[(work >> 16) & Ox3fL];

fval | = SP2[(work >> 24) & Ox3fL];

leftt ^= fval;

work = (leftt << 28) | (leftt >> 4);

work = *keys++;

fval = SP7[ work & Ox3fL];

fval |= SP5[(work >> 8) & Ox3fL];

tval |= SP3[(work >> 16) & Ox3fL];

fval |= SP1[(work >> 24) & Ox3fL];

work = leftt ^*keys++;

fval |= SPEC work & Ox3fL];

fval |= SP6[(work >> 8) & Ox3fL];

fval |= SP4[(work >> 16) & Ox3fL];

fval |= SP2[(work >> 24) & Ox3fL];

right ^= fval;

}

right = (right << 31) | (right >> 1);

work = (letft ^right) & OxaaaaaaaaL;

leftt ^=work;

right ^= work;

leftt = (leftt << 31) | (leftt >> 1);

work = ((leftt >> 8) right) & OxOOffOOffL;

right ^=work;

leftt ^= (work << 8);

work = ((leftt >>2) right) & Ox33333333L;

right ^=work;

leftt ^= (work << 2);

work = ((right >> 16) leftt) & OxOOOOffffL;

leftt ^=work;

right ^=(work << 16);

work = ((right >> 4) leftt) & OxOfOfOfOfL;

leftt ^=work;

right ^=(work << 4);

*block++ = right;

*block = leftt;

return;

}

/* Наборы для проверки:

* Ключ одинарной длины, открытый текст одинарной длины

* Ключ 0123 4567 89ab cdef

* открытый текст 0123 4567 89ab cde7

* шифротекст c957 4425 6a5e d31d

****************************************************************************************/

void des_key(des_ctx *dc, unsigned char *key){

deskey(key, EN0);

cpkey (dc -> ek);

deskey(key, DE1);

cpkey (dc ->dk);

}

/* Шифрование нескольких блоков в режиме ECB. За короткие блоки отвечает вызывающая функция. */

void des_enc(des_ctx *dc, unsigned char *data, int blocks){

unsigned long work[2];

int i;

unsigned char *cp;

cp = data;

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

scrunch(cp, work);

desfunc(work, dc ->ek);

unscrun(work, cp);

cp+=8;

}

}

void des_dec(des_ctx *dc, unsigned char *data, int blocks){

unsigned long work[2];

int i;

unsigned char *cp;

cp = data;

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

scrunch(cp, work);

desfunc(work, dc ->dk);

unscrun(work, cp);

cp+=8

}

}

void main (void) {

des_ctx dc;

int i;

unsigned long data[10];

char *cp,key[8] = {OxO1,Ox23,Ox45,Ox67,Ox89,Oxab,Oxcd,Oxef};

char x[8] = {OxO1,Ox23,Ox45,Ox67,Ox89,Oxab,Oxcd,Oxe7};

cp = x;

des_key(&dc, key);

des_enc(&dc, cp, 1);

printf(" Enc(0..7, 0..7)=");

for(i=0;i<8;i++) printf("%02x ((unsigned int) cp[i])&OxOOff);

printf("\n");

des_dec(&dc, cp, 1);

printf("Dec(above,0..7) = ");

for(i=0;i<8;i++) printf("%02x ((unsigned int) cp[i])&OxOOff);

printf("\n");

cp = (char *) data;

for(i=0; i <10; i++)data[i]=i;

des_enc(&dc,cp,5); /* Шифрование 5 блоков. */

for(i=0;i<10;i+=2) printf("Блок *Old = %081x %081x.\n",i/2, data[i], data[i+l])

des_dec(&dc, cp, 1)

des_dec(&dc, cp+8, 4);

for(i=0;i<10;i+=2) printf("Блок *Old = %081x %081x.\n",i/2, data[i], data[i+l])

}

LOKI91

#include <stdio.h>

#deflne LOKIBLK 8 /* Количество байтов в блоке LOKI */

#deflne ROUNDS 16 /* Количество этапов LOKI */

typedef unsigned long Long; /* определение типов для выровненных блоков LOKI */

extern Long lokikey[2]; /* 64-битовый ключ, используемый в процедурах LOKI */

extern char *loki_lib_ver; /* Строка с номером версии copyright *

#ifdef _STDC_ /* объявление прототипов библиотечных функций *

extern void enloki(char *b);

extern void deloki(char *b);

extern void setloklkeytchar key[LOKiBLK]);

#else /* если объявляются только внешние функции */

extern void enloki(), deloki(), setlokikey();

#endif _STDC_

char P[32] = {

31, 23, 15, 7, 30, 22, 14, 6,

29, 21, 13, 5, 28, 20, 12, 4,

27, 19, 11, 3, 26, 18, 10, 2,

25, 17, 9, 1, 24, 16, 8, 0

};

typedef struct {

short gen; /* неприводимый многочлен, используемый в этом поле */

short exp; /* показатель степени, используемый для генерации этой функции s */

} sfn_desc;

sfn_desc sfn[] = {

{ /* lO111O111 */ 375, 31}, { /* 101111O11 */ 379, 31},

{ /* 11OOOO111 */ 391, 31}, { /* 11OOO1O11 */ 395, 31},

{ /* 11OOO11O1 */ 397, 31}, { /* llOO11111 */ 415, 31},

{ /* llO1DOO11 */ 419, 31}, { /* llO1O1OO1 */ 425, 31},

{ /*11O11OOO1 */ 433, 31}, { /* llO1111O1 */ 445, 31},

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

{ /* 111O1O111 */ 471, 31}, { /*111011101 */ 477, 31},

{ /* 1111OO111 */ 487, 31}, { /* 11111OO11 */ 499, 31},

{ 00, 00) };

typedef struct {

Long loki_subkeys[ROUNDS];

} loki_ctx;

static Long f(); /* объявление функции LOKI f */

static short s(); /* объявление функции LOKI s */

#deflne ROL12(b) b = ((b << 12) | (b >> 20));

#deflne ROL13(b) b = ((b << 13) | (b >> 19));

#ifdef LITTLE_ENDIAN

#define bswap(cb) { \

register char c; \

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

c = cbLi]; cb[l] = 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; \

}

#endif

void

setlokikey(lokl_ctx *c, char *key)

{

register i;

register Long KL, KR;

#ifdef Lml-E*NDiAN

bswapfke.)'); /* swap bytes round if little-endlan */

rfend i f

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

KR = ((Long *)ke*l:l;

for (|=0; K*ROUNDS; l+=4) i /* Generate the 16 subkeys */

c->lokl_sl<bke*s[l] = KL;

ROLi2 (KL);

c->lokl_subke*s[*l+l] = KL;

ROLi3 (KL);

c->lokl_subke*sl*l+2] = KR;

ROLi2 (KR);

c->lokl_sljbke*s[*l+3] = KR;

ROLi3 (KR);

#lfdef LiTTLE-ENDiAN

bswap(ke*); /* swap b*tes back if little-endlan */

f*/e nd i f

v o i d

enlokl (lokl_ct.x *c, char *b)

register };

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

#lfdet LiTTLE-ENDiAN

bswaptb); /* swap bytes round if little-endlan */

#end i f

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

R = (fLong *)b)l*l];

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

L "= f (R, c)loklsllbkeysl'l]);

R *= f (L, c->lokl_subke*sl*l+l]);

(tLong *)b)l*0] = R; /* Y = smaptLR) */

(fLong *)b)!_l-1 * L;

rflfdef LiTTLEENDiAN

bslb*ap(b); /* swap b*tes round if little-endlan */

#e nd i f

v o i d

delokl(lokl_ctx *c, char *b)

register };

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

rflfdef LiTTLE-ENDiAN

bsmapCb); it gmap bytes round if llttleendlan */

#end i f

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

R = ((Long *) b) !_ i ]

for (*ROUNDS; l>0; 1-=2) i /* Subkeys in reverse order */

L "= ffR, c->lokl_subkeys[ll]);

R "= ftL, c->lokl_subkeys[l-2]);

((Long *)b)l*0] = R; /* Y = LR XOR k */

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

*define MASKi2 OxOfff /* 12 bit mask for expansion E */

static Long

ftr, k)

register Long r; /* Data value Rtl-l) */

Long k; /*Key Kfl) */

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

a - r k; /* A = Rt i - i) XOR Kt i) */

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

b * ((Long) s ((a & MASKi2))) i /* B = S (E (Rt i i)) *Kt i)) */

((Long)s(((a >> 8) & MASKi2)) << 8) 1

((Long)s(((a >> 16) & MASKi2)) << 16) 1

((Long)s((((a >> 24) 1 (a << 8)) & MASKi2)) << 24);

perm32t&c, &b, P); /* C = Pest EtRtl-l)) XOR Km)) */

returnee); /* f returns the result C */

static short stl)

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

register short r, c, v, t;

short expel); /* exponentiation routine for GF*8) */

r = ((l>>8) & axe) i (i & Ox3); /* row value top 2 & bottom 2 */

c = (l>>2) & Oxff; /* column value-middle 8 bits */

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

v = expBtt, sfnlr*exp, sfnl*r].gen); /* Sfn[r] = t ^ exp mod gen */

r et u r n (v);

*define MSB OxBOOOOOOOL /* MSB of 32-bit mord */

perm321out, in perm)

Long *out; /* Output 32-bit block to be permuted */

Long *ln; /* input 32blt block after permutation */

char permf'*j; /* Permutation array */

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

register int *, 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; 002; 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 j= mask; /* OR in mask to output i */

mask)*= }; /* Shift mask to next bit */

*define SjZE 256 /* 256 elements in GF*S) */

short multSfa, b, gen)

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

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

short product = 0; /* result of multiplication */

wh i i e (b! = 0) j / * wh i i e mu i t i p i i e r i s n on ze ro * /

if (b & 01)

product *= a; /* add multiplicand if LSB of b set

a <<= }; /* shift multiplicand one place */

if (a >= SjZE)

a *= gen; /* and modulo reduce if needed */

b)>= }; /* shift multiplier one place */

re t u r n (p r od u c t);

short expSfbase, exponent, gen)

short base; /* base of exponentiation */

short exponent; /* exponent */

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

short accum = base; /* supenncreaslng sequence of base */

short result = }; /* result of exponentiation */

if (base " 0) /* if zero base specified then */

returnfO); /* the result is "0" if base = 0 */

№hlle (exponent j* 0)! /* repeat while exponent nonzero */

if ((exponent & OxOOOi) == OxCOOi) /* multiply if exp i *

result = multSfresult, accum, gen);

exponent >>= }; /* shift exponent to next digit */

accum = nlult8(accum, accum, gen); /* & square */

ret u rn (res u i t);

void loki_key(loki_ctx *c, unsigned char *key)(

s et i o k i key (c, key);

void loki_enc(loki_ctx *c, unsigned char *data, int blocks)!

unsigned char *cp;

int i;

cp = d a t a;

fo r (i =0; i < b i oc ks; i ++) (

en i o k i (c, cp);

c p+=8;

void lokl_dec(lokl_ctx *c, unsigned char *data, int blocks)!

unsigned char *cp;

int i;

c p = d a t a;

for (i *O; i <bl ocks; i++)!

de i 0 k i (c, c p);

c p+*8;

vo i d nla i n (v o i d)!

loki_ctx lc;

unsigned long data[10];

unsigned char *cp;

u n s i g n ed c h a r key [ ] =! 0, i, 2, 3, 4, 5, 6, 7!;

int i;

for(|=0;l<10;i++) data[i]=};

i 0 k i _key (& i c, key);

c p = (c h a r *) d a t a;

i o k i _en c (& i c, c p, 5);

for(i=0;i<10;i+=2) printFC'Block XOld = %081x %081x\n",

i /2, data [ i j, data). i +l ]);

i 0 k i _d ec (& i c, cp, i);

i oki-dec (&l c, cp+8, 4);

for(i**0;i<10;i+=2) printfCBlock XOld = *081x XO81x\n",

i /2, data [ i ], data [ i+l ] j;

mEA

typedef unsigned char boolean; /* values are TRUE or FALSE */

typedet unsigned char byte; /* values are 0255 */

typedef byte *byteptr; /* pointer to byte */

typedef char *stnng;/* pointer to ASCtf character string */

typedef unsigned short wordlg; /* values are 0-65535 */

typedef unsigned long mord32; /* values are 04294967295 */

#lfndef TRUE

#deflne FALSE 0

*define TRUE (iFALSE)

#endlf /* if TRUE not already defined */

#lfndef min /* if min macro not already defined */

*define n<ln(a,b) ((a)<(b)? (a): (b))

#deflne nlax(a,b) ((aWb)? (a): (b))

#endlf /* if min macro not already defined */

*define iDEAKEYSiZE 16

*define jDEABLOCKSiZE 8

*define iDEAROUNDS 8

*define iDEAKEYLEN (6*jDEAROUNDS+4)

typedef struct!

wordle ek[iDEAKEYLEN:!,dk[tDEAKEYLEN];

}ldea__ctx;

/* End includes for iDEA-C */

#lfdef iDEA32 /* Use >16blt temporaries */

*define lo№16(x) ((x) & OxFFFF)

typedef unsigned int uintl6;/* at LEAST 16 bits, maybe more */

#e i s e

*define lo№16(x) (x) /* this is only ever applied to ninth's */

typedef wordle uintl6;

#e n d i f

#ifdef SMALL_CACHE

static uintl6

muKregister (jintl6 a, register uintl6 b)

register kord32 p;

p = (word32)a * b;

if (p) f

b = i ow i 6 (p);

a = p> > i 6;

r et u r n (b a) + (b < a);

! else if (a)!

return l-b;

) e i s e (

return i a;

i /* mul */

#endif /* SMALL-CACHE */

static uintl6

nlu i 2 n v (u int i 6 x)

uintl6 to, tl;

uintl6 q, y;

if (x <= i)

return x; /* 0 and i are self inverse */

tl = OxlOOOiL / x; /* Since x >= 2, this fits into 16 bits */

y = OxlOOOiL? x;

if (y == i)

return lomi6Mtl);

to = };

do!

q = x / y;

x = x X y;

to +* q * tl;

if (x == i)

return to;

q = y / x!

y = y X x;

tl += q * to;

) while (y i= i);

return lowl6M-tl);

) /* muklnv */

static void

ldeaExpandKeyfbyte canst *userkey, mordl6 *Ek)

i nl. i, j;

for (j=0; jO; j++) {

EKi-jj = (userkey[0]<<8) + userkey[l];

userkey += 2;

for (i=0; j < iDEAKEYLEN; j++) {

l++;

EK[l+7] = EK[l & 7] << 9 * EK!_l+l & 7] >> 7;

EK += i & 8;

i &= 7;

) /* ldeaExpandkey */

static void

idealnvertKeytwordl6 canst *EK, mordle DK[iDEAKEYLEN_i)

int i;

uintle tl, t2, t3;

wordle temp[iDEAKEYLEN];

mordle *p = temp + iDEAKEYLEN;

t i = mul: nv (*EK++);

t2 * *EK++;

t3 = *EK++;

* p = mu i S nv (* EK++);

* p = t3;

* p = t 2;

*p=tl;

for(|=0;l<iDEAROUNDS};l++)!

t|=*EK++;

*p=*EK++;

*p=tl;

t|=mullnv*EK++);

t2=*EK++;

t3= *EK++;

*p=mjijnv(*EK++);

p=t2;

p=t3;

*p=tl;

t|=*EK++;

*p=*EK++;

*p=tl;

t|=mullnv*EK++);

t2= *EK++;

t3= *EK++;

*p=mj*nv(*EK++);

*p=t3;

p=t2;

*p=tl;

/* Copy and destroy temp copy */

rrtemcpytDK, temp, slzeoftternp));

for (i =0; i <? DEAKEYLEN; i ++) temp* i ]=0;

) /*ldea?nvertKey*/

#lfdef SMALL_CACHE

**define MUL(x,y) (x* mul(lowl6(x),y))

№?lse/*!SMALLCACHE*/

#lfdef AVO?D_jUMPS

№jeflneMUL(x,y) (x=lowl6(x i), tl6=lowl6((y) i), \

t32=(word32)x*tl6+x+tl6+l,x=lowl6(t32), \

tl6=t32>>16,x=(xtl6)+(x<tl6))

#*se/*!AVO:D_jUMPS (default) */

;*deflneMUL(x,y)\

((tl6=(y))?\

(x=lowl6*))? \

t32=(word32)x*tl6, \

x= lowl6(t32),\

tl6=t32*16, \

x=(xtl6)+(x<tl6) \

(x=l tl6) \

(x*lx))

**endlf

**endlf

static void

ideaClphertbyte *lnbuf, byte *outbl<f, wordl6 *key)

register uintl6 xl, x2.x3, x4.s2, s3;

№]rdl6*ln,*out;

#lfndef SMALL_CACHE

register uintl6 tl6; /* Temporaries needed by MUL macro */

register mord32 t32;

#**f

intr=iDEAROUNDS;

ln=(wordl6*)lnbuf;

j(l**ln++; x2=*ln++;

x3**ln++; x4=*m;

**lfndefH?GHF:RST

xl*(xl>>8)) (xl*S);

x2*tx2*8) i (x2<<8);

x3*(x3>>8) j (x3*8);

x4*(x4>>8) j (x4*8);

#m*f

do j

MUL(xl,*key++);

x2+=*key++;

x3+=*key++;

MUL(x4, *key++);

s3*x3;

x3**xl;

MUL(x3, *key++);

s2=x2;

x2*=x4;

x2+*x3;

MULfx2, *key++);

x3+*x2;

xl*=x2; x4*-x3;

x2=s3; x3*=s2;

i while (r);

MU*xl, *key++);

x3+=*key++;

x2+**key++;

MUL(x4,*key);

out=(wordl6*)outbuf;

4*lfdefH:GHF?RST

*out++*xl;

*out++=x3;

*out++*x2;

*out-x4;

№*lse/*!H?GHF?RST*/

*out++*(xl>>8) j (xl<<8);

*out++*(x3>>8) j (x3<<8);

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

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

**endlf

) /* ideaClpher*/

void ideakey*deactx *c, unsigned char *key)f

ldeaExpandKey(key,c>ek);

i d ea i n v e r t Key (c - >e k, c >d k);

voldldeaenc(ldea_etx*c, unsigned char *data, int blocks)!

intl;

unsigned char *d * data;

for (l*O; i <bl ocks; l++) j

ldeaClpher(d,d,c)ek);

d+*8;

voldldeadec(ldea_ctx*c, unsigned char *data, int blocks)!

intl;

unsigned char *d * data;

forM*0;l<blocks;i++){

ldeaClpher(d,d,c>dk);

d+*8;

**include <stdio.h>

#lfndef BLOCKS

?*lfndef KBYTES

*Mefine KBYTES 1024

**endlT

**define BLOCKS (64*KBYTES)

#m*T

int

rmintvold)

i /*Test driver for jDEA cipher */

intl, j, k;

ldeactxc;

by* userkey[16];

mordle EK[?DEAKEYLEN_f, DK[?DEAKEYLEN];

byteXX[8], YY*l, ZZ[8];

word32 longblock[10]; /* 5 blocks */

iong};

char*lbp;

/* Make a sample user key for testing... */

for(l*0;l<16;l++)

userkey*jj*l+l;

ldeakey(&c,userkey);

/* Make a sample plaintext pattern for testing... */

for**O; US; k++j

XX[k]=k;

ldeaenc(&c,XX,l);/*encrypt*/

lbp = (unsigned char *) long*lock;

for(l*0;l<10;l++) long_block[l] = };

ldeaenc(&c,lbp,5);

for(|=0;l<10;l+=2) printf("Block XOld = MSjx?OSlx.\n",

i / 2, i ong_bl ock[ i ], i ong-bl oc k [ i +l ]);

ldeadec(&c,lbp,3);

ldea_dec (&c, i bp+24, 2);

for(l*0;l<10;l+*2)printfC'BlockM)ld=M)Slx%081x.\n",

i /2, i ong_bl ock[ i ], i ong_bl ocki: l+l ]);

return 0; /* normal exit */

)/*nlaln*/

cost

typedef unsigned long u4;

typedef unsigned char byte;

typedef struct {

u4k[8];

/* Constant s b0xes setuplngostlmt().*/

char k87[256],k65[256],k43[256],k21[256];

tgost*tx;

/*Note: encrypt ard decrypt expect full blocks padding blocks is

caller's responsibility. An bulk encryption is done in

eCBnlode by these calls. Other modes may be added easily

enough. */

voldgostenc(gost_ctx*, u4*, int);

voldgostdec(gost_ctx*, u4*, int);

voldgost_key(gostctx*, u4*);

voldgostlnlt(gostctx*);

void gost_destroy(gost_ctx *);

#lfdef -alpha /* Any other 64blt machines? */

typedef unsigned int word32;

#*se

typedef unsigned long mord32;

#endl f

kb0xlnlt(gostctx*c)

intl;

bytek8[16]*il4, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6,

12, 5, 9, 0, 7)!

bytek7[16]*tl5, i, 8, 14, 6, 11, 3, 4 9, 7, 2,

13, 12, 0, 5, 10);

bytek6[16] =flO, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12,

7, 11, 4, 2, 8);

bytek5[16]=f 7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8,

5, 11, 12, 4, 15);

bytek4[16j=! 2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3,

15, 13, 0, 14, 9);

bytek3[16]=!12, i, 10, 15, 9, 2, 6, 8, 0, 13, 3,

4, 14, 7, 5, 11 t!

by* k2[16]= f4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9,

7, 5, 10, 6, 1 t;

by* kl[16]= fl3, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3,

14, 5, 0, 12, 7 };

for(|=0; i (256; l++) {

c>k87[l?= №[1 >>4]<<4 j k7[l&15];

c>k65[l!= k6[l >>4]<<4 j k5[l&15];

c>k43[l]= k4[l >>4]<<4) k3[l &15];

c*k2*lj= k2[l *>4]<<4) kl[l &15];

static word32

f(gostctx*c,word32x)

x=c>k87[x*24&255]<<24jc>k65[x>*16&255]<<16j

(->k43[x>>8&255]<< 8jc>k21[x&255];

/* Rotate left 11 bits */

return x*ll) x>>(3211);

void gostcrypt(gost_ctx *c, word32 *d)!

register mord32 nl, n2; /* As named in the GOST */

n|=d[0];

n2=d[l];

/* instead of swapping halves, swap names each round */

n2 "= f**l+c >k[0]); nl*=f(c,n2+o>k[l]);

n2 "= f(c,nl+c>k[2]); nl*=f(c,n2+c>k[3]);

n2*=f(c,nl+o>k[4]); nl"=f(c,n2+c>k[5]);

n2*=f(c,nl+c>k[6j); nl"=f(c,n2+c>k[7]);

n2*=f(c,nl+Ok[0]); n|=l(c,n2+c>k[l]);

n2"=f(c,nl+c>k[2]);nl*=f(c,n2+c>k[3]);

n2"=f(c,nl+c>k[4])! nl*=f(c,n2+c>k[5]);

n2*=f(c,nl+c>k[6]); nl"=f(c,n2+c>k[7]);

n2*=f(o,nl+c>k[0]);nl"=f(c,n2+c>k[l]);

n2*=f(c,nl+c>k[2]);nl*=f(c,n2+c>k[3]);

n2*=f(c,nl+Ok[4]);nl"=f(c,n2+o>k[5]);

n2"=f(c,nl+c>k[6]);nl*=f(c,n2+Ok[7]);

n2*=f(c,nl+c)k[7]); nl*=f(c,n2+c>k[6]);

n2"*f(c,nl+c>k[5]); nl*=f(c,n2+c>k[4]);

"2"=f(C,"l+Ok[3]);nl*=f(c,n2+c>k[2]);

"2*=f(C,nl+c>k[l]);nl*=f(c,n2+c>k[0]);

d[0]=n2;d[l]=nl;

vol d

gostdecrypt(gost_ctx *c, u4 *d)(

register mord32 nl, n2; /* As named in the GOST */.

n|=d[0];n2=d[l];

n2*=f(c,nl+c>k[0]);nl*=f(c,n2+c>k[l]);

n2*=f(c,nl+c>k[2]);nl*=f(c,n2+c>k[3]);

n2*=f(c,nl+c>k[4]);nl"=f(c,n2+c>k[5]);

n2"=f(c,nl+c>k[6]);nl"=f(c,n2+c>k[7]);

n2"=f(c,nl+c>k[7]);nl"=f(c,n2+c>k[6]);

n2"=f(c,nl+c>k[5]);nl"=f(c,n2+c>k[4]);

n2*=f(c,nl+c>k[3]);nl*=f(c,n2+c>k[2]);

n2*=f(c,nl+c>k[l]);nl"=f(c,n2+c>k[0]);

n2*=f(c,nl+c>k[7]);nl*=f(c,n2+c>k[6]);

n2*=f(o,nl+c)k[5]);nl"=f(c,n2+c>k[4]);

n2*=f(c,nl+c>k[3]);nl*=f(c,n2+o>k[2]);

n2"=f(c,nl+c>k[l]);nl*=f(c,n2+c)k[0]);

n2*=f(c,nl+c>k[7]);nl*=f(c,n2+c>k[6]);

n2"=f(c,nl+c>k[5]);nl*=f(c,n2+c>k[4]);

n2*=f(c,nl+o>k[3]);nl"=f(c,n2+c>k[2]);

n2*=f(c,nl+c>k[l]);nl*=f(o,n2+o>k[0]);

d[0]=n2;d[l]=nl;

void gost_eno(gost_ctx *c, u4 *d, int blocks)!

intl;

for (i =0; i (bl ocks; l++) {

gostcryp**d);

d+=2;

void gost_deo(gost_ctx *c, u4 *d, int blocks)j

intl;

fort i =0; i <bl ocks; i ++) f

go s tdec rypt (c, d);

d+=2;

voldgostkey(gost_ctx*c, u4 *k)!

intl;

for(|=0;l<8;l++) c>k[l]=k[l];

void gostinit(gost_ctx *c){

kb0x i n i t (c);

void gostdestroy(gost_ctx *c){

int i;

for(i=0;i<8;i++) c>k[i]=0;

v 0 i d ma i n (v o i d) {

gostctx gc;

u4 k[8],data[10];

int i;

/* initialize GOST context. */

go s ti n i t (&g c);

/* Prepare key--a simple key should be OK, with this many rounds! */

for (|=0; i <8; i ++) k[ i ] = i;

go s tkey (&gc, k);

/* Try some test vectors. */

data[0] = 0; data[l] = 0;

g 0 s t c ry pt (&gc, d a t a);

printf("Enc of zero vector: %081x %081x\n",data[0],data[l]);

gos tc rypt (&g c, d a t a);

printf("Enc of above: %081x %081x\n",data[0],data[l]);

data[0] = Oxffffffff; data[l] = Oxffffffff;

g OS t c rypt (&g c, d a ta);

printf("Enc of ones vector: %081x %081x\n",data[0],data[l]);

go s tc rypt (&gc, d a t a);

printf("Enc of above: %081x %081x\n",data[0],data[l]);

/* Does gost_dec() propeny reverse gost_enc()? Do

we deal OK with single-block lengths passed in gost_dec()?

Do we deal OK with different lengths passed in? */

/* lnit data */

for(i=0;i<10;i++) data[i]=};

/* Encrypt data as 5 blocks. */

go s t_e nc (&gc, d a t a, 5);

/* Display encrypted data. */

for(i=0;i<10;i+=2) printf("Block %02d = %081x %081x\n",

i /2, data [ i ], data [ i +l ]);

/* Decrypt in different sized chunks. */

go s td ec (&g c, d a t a, i);

gostdec (&gc, da ta+2, 4);

printf(" \n ");

/* Display decrypted data. */

fOr(i=0;i<10;i+=2) printf("Block %02d = %081x %081x\n",

i /2, data [i ], data [ i +l ]);

gost_dest roy (&gc);

BLOWFiSH

**include <math.h>

*include <stdio.h>

*include <stdlib.h>

**include <time.h>

#ifdef little_endian /* Eg: intel */

#i n c i ud e < a i i a c. h >

#en d i f

#include <ctype.h>

#ifdef iittle_endian /* Eg: intel */

#include <dir.h>

#include <bios.h>

#en d i f

#ifdef bigendian

#include <Types.h>

#en d i f

typedef struct {

unsigned long S[4][256],P[18];

i blf_ctx;

#define MAXKEYBYTES 56 /* 448 bits */

// #define littleendian i /* Eg: intel */

#define bigendian i /* Eg: Motorola */

void Blowfish_encipher(blfctx *.unsigned long *xl, unsigned long *xr);

void Blowfishdecipher(blfctx *.unsigned long *xl, unsigned long *xr);

*define N 16

#define noErr 0

#define DATAERROR - {

#define KEYBYTES 8

FiLE* SubkeyFile;

unsigned long F(blfctx *bc, unsigned long x)

unsigned short a;