redoc2.c
00b40ca7ef33ac20be11dfd430e6cbf1d8bc0050e8b875cf5e3988b2aa905cd5#include <stdio.h>
#include <string.h>
#define byte unsigned int
byte permtable[256][10];
byte esubtable[16][256];
byte dsubtable[16][256];
byte encltable[256][3][5];
byte key_x[10] = {114, 77, 62, 14, 91, 113, 233, 170, 56, 152};
byte key_y[10] = {255, 222, 26, 155, 213, 248, 12, 109, 78, 95};
byte keystable[256][10];
byte masktable[10][10];
byte dataval[10] = {65, 66, 67, 68, 69, 70, 71, 72, 73, 74};
int randy (lo, hi, stval)
int lo, hi;
byte *stval;
{
int fcnt, fscnt, fnum;
short int fg;
byte *cuval, *tsval;
fnum = hi - lo + 1;
cuval = stval;
fcnt = 0;
while (fcnt < fnum)
{ *cuval = rand() % fnum;
while (*cuval >= fnum) *cuval -= fnum;
*cuval += lo;
if (fcnt > 0)
{ fg = 1;
tsval = stval;
for (fscnt = 0; fscnt < fcnt; ++fscnt)
{ if (*tsval == *cuval) fg = 0;
++tsval;
}
if (fg == 1)
{ ++fcnt;
++cuval;
}
}
if (fcnt == 0)
{ ++fcnt;
++cuval;
}
}
return (fnum);
}
int create_permutations (num, stval, pen, cdimp)
int num;
byte *stval;
int pen;
byte *cdimp;
{
int fi, fcnt, ccnt;
byte *cdvalue;
fcnt = pen - 1;
--num;
ccnt = 0;
cdvalue = cdimp;
srand (*cdvalue);
for (fi = 0; fi <= num; ++fi)
{ stval += randy (0,fcnt,stval);
++ccnt;
if (ccnt == 6)
{ ccnt = 0;
++cdvalue;
srand (*cdvalue);
}
}
return (0);
}
int create_substitutions (num, stval, sun, cdimp)
int num;
byte *stval;
int sun;
byte *cdimp;
{
int fi, fcnt;
byte *cdvalue;
fcnt = sun - 1;
--num;
cdvalue = cdimp;
srand (*cdvalue);
for (fi = 0; fi <= num; ++fi)
{ stval += randy (0, fcnt, stval);
++cdvalue;
srand (*cdvalue);
}
return (0);
}
int create_inverse_table (stval1, stval2, sun)
byte *stval1, *stval2;
int sun;
{
int fi, fcnt;
byte *temp_value;
fcnt = sun - 1;
for (fi = 0; fi <= fcnt; ++fi)
{ temp_value = stval2 + *stval1;
*temp_value = fi;
++stval1;
}
return (sun);
}
int create_inverse_substitutions (num, val1, val2, sun)
int num;
byte *val1, *val2;
int sun;
{
int fi, fcnt;
--num;
for (fi = 0; fi <= num; ++fi)
{ create_inverse_table (val1, val2, sun);
val1 += sun;
val2 += sun;
}
return (0);
}
int create_enclave_table (stval)
byte *stval;
{
int fi, fii;
byte *cuval, *temp1, *temp2;
short int fg;
fg = 1;
while (fg == 1)
{ cuval = stval;
for (fi = 0; fi <= 2; ++fi)
cuval += randy (0, 4, cuval);
fg = 0;
cuval = stval;
for (fi = 0; fi <= 4; ++fi)
{ temp1 = cuval + 5;
temp2 = cuval + 10;
if ((*cuval == *temp1) || (*cuval == *temp2) || (*temp1 == *temp2))
fg = 1;
++cuval;
}
}
return (15);
}
int create_enclaves (num, val1, cdimp)
int num;
byte *val1;
byte *cdimp;
{
int fi, ccnt;
byte *cdvalue;
--num;
ccnt = 0;
cdvalue = cdimp;
srand (*cdvalue);
for (fi = 0; fi <= num; ++ fi)
{ create_enclave_table (val1);
val1 += 15;
++ccnt;
if (ccnt == 6)
{ ccnt = 0;
++cdvalue;
srand (*cdvalue);
}
}
return (0);
}
int check_enclave_columns (clmn1, clmn2)
byte *clmn1, *clmn2;
{
int fi, fg;
fg = 1;
for (fi = 0; fi <= 4; ++fi)
{ if (*clmn1 != *clmn2) fg = 0;
++clmn1;
++clmn2;
}
return (fg);
}
int save_function_tables (peb, sub, isb, enb, pen, sun, fl)
byte *peb, *sub, *isb, *enb;
int pen, sun;
FILE *fl;
{
int fi, fii, fiii, fcnt;
fcnt = 256 * pen;
while (fcnt > 0)
{ fputc (*peb, fl);
++peb;
--fcnt;
}
fcnt = 16 * sun;
while (fcnt > 0)
{ fputc (*sub, fl);
++sub;
--fcnt;
}
fcnt = 16 * sun;
while (fcnt > 0)
{ fputc (*isb, fl);
++isb;
--fcnt;
}
fcnt = 256 * 15;
while (fcnt > 0)
{ fputc (*enb, fl);
++enb;
--fcnt;
}
return (0);
}
int permutate (permval, dataval)
byte *permval, *dataval;
{
byte *temp1, *temp2;
byte work_space[20];
int fi;
temp1 = dataval;
for (fi = 0; fi <= 9; ++fi)
{ temp2 = *permval + &work_space[0];
*temp2 = *dataval;
++dataval;
++permval;
}
dataval = temp1;
temp2 = &work_space[0];
for (fi = 0; fi <= 9; ++fi)
{ *dataval = *temp2;
++temp2;
++dataval;
}
return (0);
}
int inverse_permutate (permval, dataval)
byte *permval, *dataval;
{
byte *temp1, *temp2;
int fi;
byte work_space[20];
temp1 = dataval;
for (fi = 0; fi <= 9; ++fi)
{ temp2 = temp1 + *permval;
work_space[fi] = *temp2;
++permval;
}
dataval = temp1;
temp2 = &work_space[0];
for (fi = 0; fi <= 9; ++fi)
{ *dataval = *temp2;
++temp2;
++dataval;
}
return (0);
}
int substitute (skip, subval, dataval)
int skip;
byte *subval, *dataval;
{
int fi;
byte *temp;
for (fi = 0; fi <= 9; ++fi)
{ if (fi != skip)
{ temp = subval + *dataval;
*dataval = *temp;
}
++dataval;
}
return (skip);
}
int add_clave (encval, dataval)
byte *encval, *dataval;
{
int fi, fii;
byte *temp1, *temp2, *temp3;
for (fi = 0; fi <= 4; ++fi)
{ temp2 = encval + 5;
temp3 = encval + 10;
temp1 = dataval + *encval;
temp2 = dataval + *temp2;
temp3 = dataval + *temp3;
*temp1 = (*temp1 + *temp2 + *temp3) % 256;
while (*temp1 > 255) *temp1 -= 256;
++encval;
}
return (0);
}
int subtract_clave (encval, dataval)
byte *encval, *dataval;
{
int fi, fii;
byte *temp1, *temp2, *temp3;
encval += 4;
for (fi = 0; fi <= 4; ++fi)
{ temp2 = encval + 5;
temp3 = encval + 10;
temp1 = dataval + *encval;
temp2 = dataval + *temp2;
temp3 = dataval + *temp3;
*temp1 = (*temp1 - *temp2 - *temp3) + 512;
while (*temp1 > 255) *temp1 += 256;
--encval;
}
return (0);
}
int right_add_merge (dataval)
byte *dataval;
{
int fi;
byte *left, *right;
left = dataval;
right = dataval + 5;
for (fi = 0; fi <=4; ++fi)
{ *right = *right ^ *left;
while (*right > 255) *right -= 256;
++right;
++left;
}
return (0);
}
int right_sub_merge (dataval)
byte *dataval;
{
int fi;
byte *left, *right;
left = dataval;
right = dataval + 5;
for (fi = 0; fi <= 4; ++fi)
{ *right = *right ^ *left;
while (*right < 0) *right += 256;
++right;
++left;
}
return (0);
}
int left_add_merge (dataval)
byte *dataval;
{
int fi;
byte *left, *right;
left = dataval;
right = dataval + 5;
for (fi = 0; fi <= 4; ++fi)
{ *left = *right ^ *left;
while (*left > 255) *left -= 256;
++right;
++left;
}
return (0);
}
int left_sub_merge (dataval)
byte *dataval;
{
int fi;
byte *left, *right;
left = dataval;
right = dataval + 5;
for (fi = 0; fi <= 4; ++fi)
{ *left = *left ^ *right;
while (*left < 0) *left += 256;
++right;
++left;
}
return (0);
}
int right_enclave (fenc, senc, dval)
byte *fenc, *senc, *dval;
{
byte *pval;
pval = dval + 5;
add_clave (fenc, pval);
add_clave (senc, pval);
right_add_merge (dval);
return (0);
}
int inverse_right_enclave (fenc, senc, dval)
byte *fenc, *senc, *dval;
{
byte *pval;
pval = dval + 5;
right_sub_merge (dval);
subtract_clave (senc, pval);
subtract_clave (fenc, pval);
return (0);
}
int left_enclave (fenc, senc, dval)
byte *fenc, *senc, *dval;
{
add_clave (fenc, dval);
add_clave (senc, dval);
left_add_merge (dval);
return (0);
}
int inverse_left_enclave (fenc, senc, dval)
byte *fenc, *senc, *dval;
{
left_sub_merge (dval);
subtract_clave (senc, dval);
subtract_clave (fenc, dval);
return (0);
}
int key_xor (skip, kval, dval)
int skip;
byte *kval, *dval;
{
int fi;
for (fi = 0; fi <= 9; ++fi)
{ if (fi != skip) *dval ^= *kval;
++kval;
++dval;
}
return (0);
}
int key_add (skip, kval, dval)
int skip;
byte *kval, *dval;
{
int fi;
for (fi = 0; fi <= 9; ++fi)
{ if (fi != skip) *dval += *kval;
while (*dval > 255) *dval -= 256;
++kval;
++dval;
}
return (0);
}
int key_sub (skip, kval, dval)
int skip;
byte *kval, *dval;
{
int fi;
for (fi = 0; fi <= 9; ++fi)
{ if (fi != skip) *dval -= *kval;
while (*dval < 0) *dval += 256;
++kval;
++dval;
}
return (0);
}
int create_key_table (kx, kyval, tableval, peb, sub, enb, pen, sun, enn)
byte *kx, *kyval, *tableval, *peb, *sub, *enb;
int pen, sun, enn;
{
int fi, fii;
unsigned long int a, b, c, d, m, n, z;
byte *tempval, *fp1, *fp2, *adval, *ev1, *ev2, *ev3, *ev4;
byte *kxval, keyxxx[10];
tempval = tableval;
kxval = &keyxxx[0];
for (fii = 0; fii <= 9; ++fii)
{ *tableval = *kyval;
keyxxx[fii] = *kx;
++kx;
++kyval;
++tableval;
}
for (fi = 0; fi <= 255; ++fi)
{ tableval = tempval;
a = *kxval ^ *tableval;
while (a > 255) a -= 256;
++kxval;
++tableval;
b = *kxval ^ *tableval;
while (b > 255) b -= 256;
++kxval;
++tableval;
c = *kxval ^ *tableval;
while (c > 255) c -= 256;
++kxval;
++tableval;
d = *kxval ^ *tableval;
while (d > 255) d -= 256;
++kxval;
++tableval;
m = *kxval ^ *tableval ^ *(kxval+1) ^ *(tableval+1);
while (m > 255) m -= 256;
kxval += 2;
tableval += 2;
n = *kxval ^ *tableval ^ *(kxval+1) ^ *(tableval+1);
while (n > 255) n -= 256;
kxval += 2;
tableval += 2;
z = *kxval ^ *tableval ^ *(kxval+1) + *(tableval+1);
while (z > 255) z -= 256;
kxval += 2;
tableval += 2;
n *= pen;
adval = peb + n;
permutate (adval, tempval);
while (m > 15) m -= 16;
m *= sun;
adval = sub + m;
substitute (10, adval, tempval);
a *= enn;
ev1 = enb + a;
b *= enn;
ev2 = enb + b;
c *= enn;
ev3 = enb + c;
d *= enn;
ev4 = enb + d;
left_enclave (ev1, ev2, tempval);
right_enclave (ev3, ev4, tempval);
z *= pen;
adval = peb + z;
kxval -= 10;
permutate (adval, kxval);
if (fi < 255)
{ tableval = tempval;
tempval += 10;
for (fii = 0; fii <= 9; ++fii)
{ *tempval = *tableval;
++tableval;
++tempval;
}
tempval -= 10;
}
}
return (0);
}
int create_mask_table (ktval, mtval)
byte *ktval, *mtval;
{
int fi, fii;
byte *temp, *ktemp;
temp = mtval;
for (fi = 0; fi <= 99; ++fi)
{ *mtval = 0;
++mtval;
}
mtval = temp;
for (fi = 0; fi <= 25; ++fi)
{ for (fii = 0; fii <= 99; ++fii)
{ *mtval ^= *ktval;
while (*mtval > 255) *mtval -= 256;
++mtval;
++ktval;
}
mtval = temp;
}
return (0);
}
int d_redoc_ii (keyval, maskval, dataval, peb, isb, enb,
pen, isn, enn)
byte *keyval, *maskval, *dataval, *peb, *isb, *enb;
int pen, isn, enn;
{
int a, b, c, d, w, z, fi, pi;
int round, table, skip1, skip2;
byte *datapoint, *maskpoint, *temp;
byte *taddress, *a_address, *b_address, *c_address, *d_address;
maskpoint = maskval + 89;
datapoint = dataval + 9;
round = 9;
skip1 = 9;
skip2 = 0;
table = 0;
temp = dataval;
for (fi = 0; fi <= 9; ++fi)
{ table ^= *temp;
++temp;
}
table ^= *maskpoint;
while (table > 255) table -= 256;
table *= pen;
taddress = peb + table;
inverse_permutate (taddress, dataval);
datapoint = dataval;
maskpoint -= 10;
table = *datapoint ^ *maskpoint;
table *= 10;
taddress = keyval + table;
key_xor (skip2, taddress, dataval);
w = round - 1;
while (w < 0) w += 5;
while (w > 4) w -= 5;
z = w + 1;
while (z > 4) z -= 5;
maskpoint -= 10;
temp = dataval + z;
d = *temp ^ *maskpoint;
while (d > 255) d -= 256;
d *= enn;
d_address = enb + d;
maskpoint -= 10;
temp = dataval + w;
c = *temp ^ *maskpoint;
while (c > 255) c -= 256;
c *= enn;
c_address = enb + c;
inverse_right_enclave (c_address, d_address, dataval);
maskpoint -= 10;
temp = dataval + 5 + z;
b = *temp ^ *maskpoint;
while (b > 255) b -= 256;
b *= enn;
b_address = enb + b;
maskpoint -= 10;
temp = dataval + 5 + w;
a = *temp ^ *maskpoint;
while (a > 255) a -= 256;
a *= enn;
a_address = enb + a;
inverse_left_enclave (a_address, b_address, dataval);
datapoint = dataval + 9;
maskpoint -= 10;
table = *datapoint ^ *maskpoint;
table *= 10;
taddress = keyval + table;
key_xor (skip1, taddress, dataval);
datapoint = dataval;
maskpoint -= 10;
table = *datapoint ^ *maskpoint;
while (table > 15) table -= 16;
table *= isn;
taddress = isb + table;
substitute (skip2, taddress, dataval);
datapoint = dataval + 9;
maskpoint -= 10;
table = *datapoint ^ *maskpoint;
while (table > 15) table -= 16;
table *= isn;
taddress = isb + table;
substitute (skip1, taddress, dataval);
--datapoint;
maskpoint += 79;
for (round = 8; round >= 0; --round)
{ skip1 = round;
skip2 = round + 1;
table = 0;
temp = dataval;
for (fi = 0; fi <= 9; ++fi)
{ table ^= *temp;
++temp;
}
table ^= *maskpoint;
while (table > 255) table -= 256;
table *= pen;
taddress = peb + table;
inverse_permutate (taddress, dataval);
datapoint = dataval + skip2;
maskpoint -= 10;
table = *datapoint ^ *maskpoint;
table *= 10;
taddress = keyval + table;
key_xor (skip2, taddress, dataval);
w = round - 1;
while (w < 0) w += 5;
while (w > 4) w -= 5;
z = w + 1;
while (z > 4) z -= 5;
maskpoint -= 10;
temp = dataval + z;
d = *temp ^ *maskpoint;
while (d > 255) d -= 256;
d *= enn;
d_address = enb + d;
maskpoint -= 10;
temp = dataval + w;
c = *temp ^ *maskpoint;
while (c > 255) c -= 256;
c *= enn;
c_address = enb + c;
inverse_right_enclave (c_address, d_address, dataval);
maskpoint -= 10;
temp = dataval + 5 + z;
b = *temp ^ *maskpoint;
while (b > 255) b -= 256;
b *= enn;
b_address = enb + b;
maskpoint -= 10;
temp = dataval + 5 + w;
a = *temp ^ *maskpoint;
while (a > 255) a -= 256;
a *= enn;
a_address = enb + a;
inverse_left_enclave (a_address, b_address, dataval);
datapoint = dataval + skip1;
maskpoint -= 10;
table = *datapoint ^ *maskpoint;
table *= 10;
taddress = keyval + table;
key_xor (skip1, taddress, dataval);
datapoint = dataval + skip2;
maskpoint -= 10;
table = *datapoint ^ *maskpoint;
while (table > 15) table -= 16;
table *= isn;
taddress = isb + table;
substitute (skip2, taddress, dataval);
datapoint = dataval + skip1;
maskpoint -= 10;
table = *datapoint ^ *maskpoint;
while (table > 15) table -= 16;
table *= isn;
taddress = isb + table;
substitute (skip1, taddress, dataval);
--datapoint;
maskpoint += 79;
}
return (0);
}
int e_redoc_ii (keyval, maskval, dataval, peb, sub, enb,
pen, sun, enn, ken)
byte *keyval, *maskval, *dataval, *peb, *sub, *enb;
int pen, sun, enn, ken;
{
int a, b, c, d, w, z, fi, pi;
int round, table, skip1, skip2;
byte *datapoint, *maskpoint, *temp, *taddress;
byte *a_address, *b_address, *c_address, *d_address;
maskpoint = maskval;
datapoint = dataval;
for (round = 0; round <= 8; ++round)
{ skip1 = round;
skip2 = round + 1;
table = *datapoint ^ *maskpoint;
while (table > 15) table -= 16;
table *= sun;
taddress = table + sub;
substitute (skip1, taddress, dataval);
++datapoint;
maskpoint += 10;
table = *datapoint ^ *maskpoint;
while (table > 15) table -= 16;
table *= sun;
taddress = sub + table;
substitute (skip2, taddress, dataval);
--datapoint;
maskpoint += 10;
table = *datapoint ^ *maskpoint;
table *= ken;
taddress = keyval + table;
key_xor (skip1, taddress, dataval);
w = round - 1;
while (w < 0) w += 5;
while (w > 4) w -= 5;
z = w + 1;
while (z > 4) z -= 5;
maskpoint += 10;
temp = dataval + 5 + w;
a = *temp ^ *maskpoint;
while (a > 255) a -= 256;
a *= enn;
a_address = enb + a;
maskpoint += 10;
temp = dataval + 5 + z;
b = *temp ^ *maskpoint;
while (b > 255) b -= 256;
b *= enn;
b_address = enb + b;
left_enclave (a_address, b_address, dataval);
maskpoint += 10;
temp = dataval + w;
c = *temp ^ *maskpoint;
while (c > 255) c -= 256;
c *= enn;
c_address = enb + c;
maskpoint += 10;
temp = dataval + z;
d = *temp ^ *maskpoint;
while (d > 255) d -= 256;
d *= enn;
d_address = enb + d;
right_enclave (c_address, d_address, dataval);
++datapoint;
maskpoint += 10;
table = *datapoint ^ *maskpoint;
table *= 10;
taddress = keyval + table;
key_xor (skip2, taddress, dataval);
maskpoint += 10;
table = 0;
temp = dataval;
for (fi = 0; fi <= 9; ++fi)
{ table ^= *temp;
++temp;
}
/* while (table > 255) table -= 256; */
table ^= *maskpoint;
table *= pen;
taddress = peb + table;
permutate (taddress, dataval);
maskpoint -= 79;
}
round = 9;
skip1 = 9;
skip2 = 0;
table = *datapoint ^ *maskpoint;
while (table > 15) table -= 16;
table *= sun;
taddress = table + sub;
substitute (skip1, taddress, dataval);
datapoint = dataval;
maskpoint += 10;
table = *datapoint ^ *maskpoint;
while (table > 15) table -= 16;
table *= sun;
taddress = sub + table;
substitute (skip2, taddress, dataval);
datapoint = dataval + 9;
maskpoint += 10;
table = *datapoint ^ *maskpoint;
table *= ken;
taddress = keyval + table;
key_xor (skip1, taddress, dataval);
w = round - 1;
while (w < 0) w += 5;
while (w > 4) w -= 5;
z = w + 1;
while (z > 4) z -= 5;
maskpoint += 10;
temp = dataval + 5 + w;
a = *temp ^ *maskpoint;
while (a > 255) a -= 256;
a *= enn;
a_address = enb + a;
maskpoint += 10;
temp = dataval + 5 + z;
b = *temp ^ *maskpoint;
while (b > 255) b -= 256;
b *= enn;
b_address = enb + b;
left_enclave (a_address, b_address, dataval);
maskpoint += 10;
temp = dataval + w;
c = *temp ^ *maskpoint;
while (c > 255) c -= 256;
c *= enn;
c_address = enb + c;
maskpoint += 10;
temp = dataval + z;
d = *temp ^ *maskpoint;
while (d > 255) d -= 256;
d *= enn;
d_address = enb + d;
right_enclave (c_address, d_address, dataval);
datapoint = dataval;
maskpoint += 10;
table = *datapoint ^ *maskpoint;
table *= 10;
taddress = keyval + table;
key_xor (skip2, taddress, dataval);
maskpoint += 10;
table = 0;
temp = dataval;
for (fi = 0; fi <= 9; ++fi)
{ table ^= *temp;
++temp;
}
while (table > 255) table -= 256;
table ^= *maskpoint;
table *= pen;
taddress = peb + table;
permutate (taddress, dataval);
return (0);
}
int pe_redoc_ii (keyval, maskval, dataval, peb, sub, enb,
pen, sun, enn, ken)
byte *keyval, *maskval, *dataval, *peb, *sub, *enb;
int pen, sun, enn, ken;
{
int a, b, c, d, w, z, fi, pi;
int round, table, skip1, skip2;
byte *datapoint, *maskpoint, *temp, *taddress;
byte *a_address, *b_address, *c_address, *d_address;
FILE *fl;
fl = fopen ("ENCRYPT.TXT","wt");
maskpoint = maskval;
datapoint = dataval;
for (round = 0; round <= 8; ++round)
{ skip1 = round;
skip2 = round + 1;
fprintf (fl,"round = %2d skip1 = %2d skip2 = %2d \n\r\n\r", round, skip1, skip2);
table = *datapoint ^ *maskpoint;
fprintf (fl, "esubtable = (DATA xor MASK) mod 16 = (%3d xor %3d) mod 16 \n\r = %3d mod 16 = ", *datapoint, *maskpoint, table);
while (table > 15) table -= 16;
fprintf (fl, "%3d \n\r\n\r", table);
table *= sun;
taddress = table + sub;
fprintf (fl,"DATA BEFORE SUBSTITUTION 1: ");
for (pi = 0; pi <= 9; ++pi) fprintf (fl,"%4d",*(dataval+pi));
fprintf (fl,"\n\r");
substitute (skip1, taddress, dataval);
fprintf (fl,"DATA AFTER SUBSTITUTION 1: ");
for (pi = 0; pi <= 9; ++pi) fprintf (fl,"%4d",*(dataval+pi));
fprintf (fl,"\n\r\n\r");
++datapoint;
maskpoint += 10;
table = *datapoint ^ *maskpoint;
fprintf (fl, "esubtable = (DATA xor MASK) mod 16 = (%3d xor %3d) mod 16 \n\r = %3d mod 16 = ", *datapoint, *maskpoint, table);
while (table > 15) table -= 16;
fprintf (fl, "%3d \n\r\n\r", table);
table *= sun;
taddress = sub + table;
fprintf (fl,"DATA BEFORE SUBSTITUTION 2: ");
for (pi = 0; pi <= 9; ++pi) fprintf (fl,"%4d",*(dataval+pi));
fprintf (fl,"\n\r");
substitute (skip2, taddress, dataval);
fprintf (fl,"DATA AFTER SUBSTITUTION 2: ");
for (pi = 0; pi <= 9; ++pi) fprintf (fl,"%4d",*(dataval+pi));
fprintf (fl,"\n\r\n\r");
--datapoint;
maskpoint += 10;
table = *datapoint ^ *maskpoint;
fprintf (fl, " keytable = DATA xor MASK = %3d xor %3d = %3d \n\r\n\r", *datapoint, *maskpoint, table);
table *= ken;
taddress = keyval + table;
fprintf (fl,"DATA BEFORE KEY ADDITION 1: ");
for (pi = 0; pi <= 9; ++pi) fprintf (fl,"%4d",*(dataval+pi));
fprintf (fl,"\n\r");
key_xor (skip1, taddress, dataval);
fprintf (fl,"DATA AFTER KEY ADDITION 1: ");
for (pi = 0; pi <= 9; ++pi) fprintf (fl,"%4d",*(dataval+pi));
fprintf (fl,"\n\r\n\r");
w = round - 1;
while (w < 0) w += 5;
while (w > 4) w -= 5;
z = w + 1;
while (z > 4) z -= 5;
maskpoint += 10;
temp = dataval + 5 + w;
a = *temp ^ *maskpoint;
fprintf (fl,"w = %3d : a = DATA xor MASK = %3d xor %3d = %3d \n\r",w , *temp, *maskpoint, a);
while (a > 255) a -= 256;
a *= enn;
a_address = enb + a;
maskpoint += 10;
temp = dataval + 5 + z;
b = *temp ^ *maskpoint;
fprintf (fl,"z = %3d : b = DATA xor MASK = %3d xor %3d = %3d \n\r", z, *temp, *maskpoint, b);
while (b > 255) b -= 256;
b *= enn;
b_address = enb + b;
fprintf (fl,"DATA BEFORE LEFT ENCLAVE : ");
for (pi = 0; pi <= 9; ++pi) fprintf (fl,"%4d",*(dataval+pi));
fprintf (fl,"\n\r");
left_enclave (a_address, b_address, dataval);
fprintf (fl,"DATA AFTER LEFT ENCLAVE : ");
for (pi = 0; pi <= 9; ++pi) fprintf (fl,"%4d",*(dataval+pi));
fprintf (fl,"\n\r\n\r");
maskpoint += 10;
temp = dataval + w;
c = *temp ^ *maskpoint;
fprintf (fl,"w = %3d : c = DATA xor MASK = %3d xor %3d = %3d \n\r",w , *temp, *maskpoint, c);
while (c > 255) c -= 256;
c *= enn;
c_address = enb + c;
maskpoint += 10;
temp = dataval + z;
d = *temp ^ *maskpoint;
fprintf (fl,"z = %3d : d = DATA xor MASK = %3d xor %3d = %3d \n\r", z, *temp, *maskpoint, d);
while (d > 255) d -= 256;
d *= enn;
d_address = enb + d;
fprintf (fl,"DATA BEFORE RIGHT ENCLAVE : ");
for (pi = 0; pi <= 9; ++pi) fprintf (fl,"%4d",*(dataval+pi));
fprintf (fl,"\n\r");
right_enclave (c_address, d_address, dataval);
fprintf (fl,"DATA AFTER RIGHT ENCLAVE : ");
for (pi = 0; pi <= 9; ++pi) fprintf (fl,"%4d",*(dataval+pi));
fprintf (fl,"\n\r\n\r");
++datapoint;
maskpoint += 10;
table = *datapoint ^ *maskpoint;
fprintf (fl, " keytable = DATA xor MASK = %3d xor %3d = %3d \n\r\n\r", *datapoint, *maskpoint, table);
table *= 10;
taddress = keyval + table;
fprintf (fl,"DATA BEFORE KEY ADDITION 2: ");
for (pi = 0; pi <= 9; ++pi) fprintf (fl,"%4d",*(dataval+pi));
fprintf (fl,"\n\r");
key_xor (skip2, taddress, dataval);
fprintf (fl,"DATA AFTER KEY ADDITION 2: ");
for (pi = 0; pi <= 9; ++pi) fprintf (fl,"%4d",*(dataval+pi));
fprintf (fl,"\n\r\n\r");
maskpoint += 10;
table = 0;
temp = dataval;
fprintf (fl,"permtable = ");
for (fi = 0; fi <= 9; ++fi)
{ table ^= *temp;
if (fi < 9) fprintf (fl,"%3d ^", *temp);
else fprintf (fl,"%3d = ",*temp);
++temp;
}
/* while (table > 255) table -= 256; */
fprintf (fl,"%3d\n\r = %3d xor %3d = ", table, table, *maskpoint);
table ^= *maskpoint;
fprintf (fl,"%3d\n\r\n\r",table);
table *= pen;
taddress = peb + table;
fprintf (fl,"DATA BEFORE PERMUTATION : ");
for (pi = 0; pi <= 9; ++pi) fprintf (fl,"%4d",*(dataval+pi));
fprintf (fl,"\n\r");
permutate (taddress, dataval);
fprintf (fl,"DATA AFTER PERMUTATION : ");
for (pi = 0; pi <= 9; ++pi) fprintf (fl,"%4d",*(dataval+pi));
fprintf (fl,"\n\r\n\r");
fprintf (fl,"\f");
maskpoint -= 79;
}
round = 9;
skip1 = 9;
skip2 = 0;
fprintf (fl,"round = %2d skip1 = %2d skip2 = %2d \n\r\n\r", round, skip1, skip2);
table = *datapoint ^ *maskpoint;
fprintf (fl, "esubtable = (DATA xor MASK) mod 16 = (%3d xor %3d) mod 16 /n/r = %3d mod 16 = ", *datapoint, *maskpoint, table);
while (table > 15) table -= 16;
fprintf (fl, "%3d \n\r\n\r");
table *= sun;
taddress = table + sub;
fprintf (fl,"DATA BEFORE SUBSTITUTION 1: ");
for (pi = 0; pi <= 9; ++pi) fprintf (fl,"%4d",*(dataval+pi));
fprintf (fl,"\n\r");
substitute (skip1, taddress, dataval);
fprintf (fl,"DATA AFTER SUBSTITUTION 1: ");
for (pi = 0; pi <= 9; ++pi) fprintf (fl,"%4d",*(dataval+pi));
fprintf (fl,"\n\r\n\r");
datapoint = dataval;
maskpoint += 10;
table = *datapoint ^ *maskpoint;
fprintf (fl, "esubtable = (DATA xor MASK) mod 16 = (%3d xor %3d) mod 16 /n/r = %3d mod 16 = ", *datapoint, *maskpoint, table);
while (table > 15) table -= 16;
fprintf (fl, "%3d \n\r\n\r");
table *= sun;
taddress = sub + table;
fprintf (fl,"DATA BEFORE SUBSTITUTION 2: ");
for (pi = 0; pi <= 9; ++pi) fprintf (fl,"%4d",*(dataval+pi));
fprintf (fl,"\n\r");
substitute (skip2, taddress, dataval);
fprintf (fl,"DATA AFTER SUBSTITUTION 2: ");
for (pi = 0; pi <= 9; ++pi) fprintf (fl,"%4d",*(dataval+pi));
fprintf (fl,"\n\r\n\r");
datapoint = dataval + 9;
maskpoint += 10;
table = *datapoint ^ *maskpoint;
fprintf (fl, " keytable = DATA xor MASK = %3d xor %3d = %3d", *datapoint, *maskpoint, table);
table *= ken;
taddress = keyval + table;
fprintf (fl,"DATA BEFORE KEY ADDITION 1: ");
for (pi = 0; pi <= 9; ++pi) fprintf (fl,"%4d",*(dataval+pi));
fprintf (fl,"\n\r");
key_xor (skip1, taddress, dataval);
fprintf (fl,"DATA AFTER KEY ADDITION 1: ");
for (pi = 0; pi <= 9; ++pi) fprintf (fl,"%4d",*(dataval+pi));
fprintf (fl,"\n\r\n\r");
w = round - 1;
while (w < 0) w += 5;
while (w > 4) w -= 5;
z = w + 1;
while (z > 4) z -= 5;
maskpoint += 10;
temp = dataval + 5 + w;
a = *temp ^ *maskpoint;
fprintf (fl,"w = %3d : a = DATA xor MASK = %3d xor %3d = %3d \n\r",w , *temp, *maskpoint, a);
while (a > 255) a -= 256;
a *= enn;
a_address = enb + a;
maskpoint += 10;
temp = dataval + 5 + z;
b = *temp ^ *maskpoint;
fprintf (fl,"z = %3d : b = DATA xor MASK = %3d xor %3d = %3d \n\r", z, *temp, *maskpoint, b);
while (b > 255) b -= 256;
b *= enn;
b_address = enb + b;
fprintf (fl,"DATA BEFORE LEFT ENCLAVE : ");
for (pi = 0; pi <= 9; ++pi) fprintf (fl,"%4d",*(dataval+pi));
fprintf (fl,"\n\r");
left_enclave (a_address, b_address, dataval);
fprintf (fl,"DATA AFTER LEFT ENCLAVE : ");
for (pi = 0; pi <= 9; ++pi) fprintf (fl,"%4d",*(dataval+pi));
fprintf (fl,"\n\r\n\r");
maskpoint += 10;
temp = dataval + w;
c = *temp ^ *maskpoint;
fprintf (fl,"w = %3d : c = DATA xor MASK = %3d xor %3d = %3d \n\r",w , *temp, *maskpoint, c);
while (c > 255) c -= 256;
c *= enn;
c_address = enb + c;
maskpoint += 10;
temp = dataval + z;
d = *temp ^ *maskpoint;
fprintf (fl,"z = %3d : d = DATA xor MASK = %3d xor %3d = %3d \n\r", z, *temp, *maskpoint, d);
while (d > 255) d -= 256;
d *= enn;
d_address = enb + d;
fprintf (fl,"DATA BEFORE RIGHT ENCLAVE : ");
for (pi = 0; pi <= 9; ++pi) fprintf (fl,"%4d",*(dataval+pi));
fprintf (fl,"\n\r");
right_enclave (c_address, d_address, dataval);
fprintf (fl,"DATA AFTER RIGHT ENCLAVE : ");
for (pi = 0; pi <= 9; ++pi) fprintf (fl,"%4d",*(dataval+pi));
fprintf (fl,"\n\r\n\r");
datapoint = dataval;
maskpoint += 10;
table = *datapoint ^ *maskpoint;
fprintf (fl, " keytable = DATA xor MASK = %3d xor %3d = %3d", *datapoint, *maskpoint, table);
table *= 10;
taddress = keyval + table;
fprintf (fl,"DATA BEFORE KEY ADDITION 2: ");
for (pi = 0; pi <= 9; ++pi) fprintf (fl,"%4d",*(dataval+pi));
fprintf (fl,"\n\r");
key_xor (skip2, taddress, dataval);
fprintf (fl,"DATA AFTER KEY ADDITION 2: ");
for (pi = 0; pi <= 9; ++pi) fprintf (fl,"%4d",*(dataval+pi));
fprintf (fl,"\n\r\n\r");
maskpoint += 10;
table = 0;
temp = dataval;
fprintf (fl,"permtable = ((");
for (fi = 0; fi <= 9; ++fi)
{ table ^= *temp;
if (fi < 9) fprintf (fl,"%3d +", *temp);
else fprintf (fl,"%3d) mod 256) xor ",*temp);
++temp;
}
while (table > 255) table -= 256;
table ^= *maskpoint;
fprintf (fl,"%3d = %3d \n\r", *maskpoint, table);
table *= pen;
taddress = peb + table;
fprintf (fl,"DATA BEFORE PERMUTATION : ");
for (pi = 0; pi <= 9; ++pi) fprintf (fl,"%4d",*(dataval+pi));
fprintf (fl,"\n\r");
permutate (taddress, dataval);
fprintf (fl,"DATA AFTER PERMUTATION : ");
for (pi = 0; pi <= 9; ++pi) fprintf (fl,"%4d",*(dataval+pi));
fprintf (fl,"\n\r\n\r");
fprintf (fl,"\f");
fclose (fl);
return (0);
}
int print_permutations ()
{
int pcnt1, pcnt2;
for (pcnt1 = 0; pcnt1 <= 255; ++pcnt1)
{ fprintf (stdprn, "PERMUTATION TABLE %3d = ", pcnt1);
for (pcnt2 = 0; pcnt2 <= 9; ++pcnt2) fprintf (stdprn,"%3d",permtable[pcnt1][pcnt2]);
fprintf (stdprn, "\n\r");
}
fprintf (stdprn, "\f");
return (0);
}
int print_substitutions ()
{
int pcnt1, pcnt2;
for (pcnt1 = 0; pcnt1 <= 15; ++pcnt1)
{ fprintf (stdprn,"SUBSTITUTION TABLE %2d \n\r\n\r",pcnt1);
for (pcnt2 = 0; pcnt2 <= 255; ++pcnt2) fprintf (stdprn," %3d=>%3d ",pcnt2,esubtable[pcnt1][pcnt2]);
fprintf (stdprn,"\f");
}
return (0);
}
int print_inverse_substitutions ()
{
int pcnt1, pcnt2;
for (pcnt1 = 0; pcnt1 <= 15; ++pcnt1)
{ fprintf (stdprn,"INVERSE SUBSTITUTION TABLE %2d \n\r\n\r",pcnt1);
for (pcnt2 = 0; pcnt2 <= 255; ++pcnt2) fprintf (stdprn," %3d=>%3d ",pcnt2,dsubtable[pcnt1][pcnt2]);
fprintf (stdprn,"\f");
}
return (0);
}
int print_enclaves ()
{
int p1, p2, p3, l1;
for (p1 = 0; p1 <= 255; p1+=4)
{ for (l1 = 0; l1 <= 3; ++l1) fprintf (stdprn, " Enclave Table %3d ", p1+l1);
fprintf (stdprn,"\n\r\n\r");
for (p2 = 0; p2 <= 4; ++p2)
{ for (l1 = 0; l1 <= 3; ++l1)
{ fprintf (stdprn," ");
for (p3 = 0; p3 <= 2; ++p3) fprintf (stdprn, "%4d",encltable[p1+l1][p3][p2]);
fprintf (stdprn," ");
}
fprintf (stdprn, "\n\r");
}
fprintf (stdprn,"\n\r\n\r\n\r\n\r");
}
fprintf (stdprn, "\f");
return (0);
}
int print_key_table ()
{
int fi, fii;
for (fi = 0; fi <=255; ++fi)
{ fprintf (stdprn, "KEY NUMBER %3d = ", fi);
for (fii = 0; fii <= 9; ++fii) fprintf (stdprn, "%5d", keystable[fi][fii]);
fprintf (stdprn, "\n\r");
}
fprintf (stdprn, "\f");
return (0);
}
int print_mask_table ()
{
int fi, fii;
for (fi = 0; fi <= 9; ++fi)
{ fprintf (stdprn, "MASK NUMBER %3d = ", fi);
for (fii = 0; fii <= 9; ++fii) fprintf (stdprn, "%5d", masktable[fi][fii]);
fprintf (stdprn, "\n\r");
}
fprintf (stdprn, "\f");
return (0);
}
int pd_redoc_ii (keyval, maskval, dataval, peb, isb, enb,
pen, isn, enn)
byte *keyval, *maskval, *dataval, *peb, *isb, *enb;
int pen, isn, enn;
{
int a, b, c, d, w, z, fi, pi;
int round, table, skip1, skip2;
byte *datapoint, *maskpoint, *temp;
byte *taddress, *a_address, *b_address, *c_address, *d_address;
FILE *fl;
fl = fopen ("DECRYPT.TXT","wt");
maskpoint = maskval + 89;
datapoint = dataval + 9;
round = 9;
skip1 = 9;
skip2 = 0;
fprintf (fl, "round = %d skip1 = %d skip2 = %d \n\r\n\r", round, skip1, skip2);
table = 0;
temp = dataval;
fprintf (fl,"permtable = ");
for (fi = 0; fi <= 9; ++fi)
{ table ^= *temp;
if (fi < 9) fprintf (fl,"%3d ^ ",*temp);
else fprintf (fl,"%3d = %3d\n\r",*temp,table);
++temp;
}
fprintf (fl,"%3d xor %3d = ",table, *maskpoint);
table ^= *maskpoint;
fprintf (fl,"%3d\n\r\n\r",table);
while (table > 255) table -= 256;
table *= pen;
taddress = peb + table;
fprintf (fl, "DATA BEFORE PERMUTATION : ");
for (pi = 0; pi <= 9; ++pi) fprintf (fl,"%4d",*(dataval+pi));
fprintf (fl, "\n\r");
inverse_permutate (taddress, dataval);
fprintf (fl, "DATA AFTER PERMUTATION : ");
for (pi = 0; pi <= 9; ++pi) fprintf (fl,"%4d",*(dataval+pi));
fprintf (fl, "\n\r\n\r");
datapoint = dataval;
maskpoint -= 10;
table = *datapoint ^ *maskpoint;
fprintf (fl," keytable = DATA xor MASK = %3d xor %3d = %3d", *datapoint, *maskpoint, table);
table *= 10;
taddress = keyval + table;
fprintf (fl, "DATA BEFORE KEY XOR : ");
for (pi = 0; pi <= 9; ++pi) fprintf (fl,"%4d",*(dataval+pi));
fprintf (fl, "\n\r");
key_xor (skip2, taddress, dataval);
fprintf (fl, "DATA AFTER KEY XOR : ");
for (pi = 0; pi <= 9; ++pi) fprintf (fl,"%4d",*(dataval+pi));
fprintf (fl, "\n\r\n\r");
w = round - 1;
while (w < 0) w += 5;
while (w > 4) w -= 5;
z = w + 1;
while (z > 4) z -= 5;
maskpoint -= 10;
temp = dataval + z;
d = *temp ^ *maskpoint;
fprintf (fl,"z = %3d : d = DATA xor MASK = %3d xor %3d = %3d\n\r",z, *temp, *maskpoint, d);
while (d > 255) d -= 256;
d *= enn;
d_address = enb + d;
maskpoint -= 10;
temp = dataval + w;
c = *temp ^ *maskpoint;
fprintf (fl,"w = %3d : c = DATA xor MASK = %3d xor %3d = %3d\n\r", w, *temp, *maskpoint, c);
while (c > 255) c -= 256;
c *= enn;
c_address = enb + c;
fprintf (fl, "DATA BEFORE RIGHT ENCLAVE : ");
for (pi = 0; pi <= 9; ++pi) fprintf (fl,"%4d",*(dataval+pi));
fprintf (fl, "\n\r");
inverse_right_enclave (c_address, d_address, dataval);
fprintf (fl, "DATA AFTER RIGHT ENCLAVE : ");
for (pi = 0; pi <= 9; ++pi) fprintf (fl,"%4d",*(dataval+pi));
fprintf (fl, "\n\r\n\r");
maskpoint -= 10;
temp = dataval + 5 + z;
b = *temp ^ *maskpoint;
fprintf (fl,"z = %3d : b = DATA xor MASK = %3d xor %3d = %3d\n\r", z, *temp, *maskpoint, b);
while (b > 255) b -= 256;
b *= enn;
b_address = enb + b;
maskpoint -= 10;
temp = dataval + 5 + w;
a = *temp ^ *maskpoint;
fprintf (fl,"w = %3d : a = DATA xor MASK = %3d xor %3d = %3d\n\r", w, *temp, *maskpoint, a);
while (a > 255) a -= 256;
a *= enn;
a_address = enb + a;
fprintf (fl, "DATA BEFORE LEFT ENCLAVE : ");
for (pi = 0; pi <= 9; ++pi) fprintf (fl,"%4d",*(dataval+pi));
fprintf (fl, "\n\r");
inverse_left_enclave (a_address, b_address, dataval);
fprintf (fl, "DATA AFTER LEFT ENCLAVE : ");
for (pi = 0; pi <= 9; ++pi) fprintf (fl,"%4d",*(dataval+pi));
fprintf (fl, "\n\r\n\r");
datapoint = dataval + 9;
maskpoint -= 10;
table = *datapoint ^ *maskpoint;
fprintf (fl," keytable = DATA xor MASK = %3d xor %3d = %3d", *datapoint, *maskpoint, table);
table *= 10;
taddress = keyval + table;
fprintf (fl, "DATA BEFORE KEY XOR : ");
for (pi = 0; pi <= 9; ++pi) fprintf (fl,"%4d",*(dataval+pi));
fprintf (fl, "\n\r");
key_xor (skip1, taddress, dataval);
fprintf (fl, "DATA AFTER KEY XOR : ");
for (pi = 0; pi <= 9; ++pi) fprintf (fl,"%4d",*(dataval+pi));
fprintf (fl, "\n\r\n\r");
datapoint = dataval;
maskpoint -= 10;
table = *datapoint ^ *maskpoint;
while (table > 15) table -= 16;
table *= isn;
taddress = isb + table;
substitute (skip2, taddress, dataval);
datapoint = dataval + 9;
maskpoint -= 10;
table = *datapoint ^ *maskpoint;
while (table > 15) table -= 16;
table *= isn;
taddress = isb + table;
substitute (skip1, taddress, dataval);
--datapoint;
maskpoint += 79;
for (round = 8; round >= 0; --round)
{ skip1 = round;
skip2 = round + 1;
table = 0;
temp = dataval;
for (fi = 0; fi <= 9; ++fi)
{ table ^= *temp;
++temp;
}
table ^= *maskpoint;
while (table > 255) table -= 256;
table *= pen;
taddress = peb + table;
inverse_permutate (taddress, dataval);
datapoint = dataval + skip2;
maskpoint -= 10;
table = *datapoint ^ *maskpoint;
table *= 10;
taddress = keyval + table;
key_xor (skip2, taddress, dataval);
w = round - 1;
while (w < 0) w += 5;
while (w > 4) w -= 5;
z = w + 1;
while (z > 4) z -= 5;
maskpoint -= 10;
temp = dataval + z;
d = *temp ^ *maskpoint;
while (d > 255) d -= 256;
d *= enn;
d_address = enb + d;
maskpoint -= 10;
temp = dataval + w;
c = *temp ^ *maskpoint;
while (c > 255) c -= 256;
c *= enn;
c_address = enb + c;
inverse_right_enclave (c_address, d_address, dataval);
maskpoint -= 10;
temp = dataval + 5 + z;
b = *temp ^ *maskpoint;
while (b > 255) b -= 256;
b *= enn;
b_address = enb + b;
maskpoint -= 10;
temp = dataval + 5 + w;
a = *temp ^ *maskpoint;
while (a > 255) a -= 256;
a *= enn;
a_address = enb + a;
inverse_left_enclave (a_address, b_address, dataval);
datapoint = dataval + skip1;
maskpoint -= 10;
table = *datapoint ^ *maskpoint;
table *= 10;
taddress = keyval + table;
key_xor (skip1, taddress, dataval);
datapoint = dataval + skip2;
maskpoint -= 10;
table = *datapoint ^ *maskpoint;
while (table > 15) table -= 16;
table *= isn;
taddress = isb + table;
substitute (skip2, taddress, dataval);
datapoint = dataval + skip1;
maskpoint -= 10;
table = *datapoint ^ *maskpoint;
while (table > 15) table -= 16;
table *= isn;
taddress = isb + table;
substitute (skip1, taddress, dataval);
--datapoint;
maskpoint += 79;
}
fclose (fl);
return (0);
}
int create_function_tables (peb, sub, isb, enb, pen, sun, cimp)
byte *peb, *sub, *isb, *enb;
int pen, sun;
byte *cimp;
{
create_permutations (256, peb, pen, cimp);
create_substitutions (16, sub, sun, cimp);
create_inverse_substitutions (16, sub, isb, sun);
create_enclaves (256, enb, cimp);
return (0);
}
int main ()
{
int i, ii;
create_function_tables (&permtable, &esubtable, &dsubtable, &encltable,
10, 256, 32);
create_key_table (&key_x, &key_y, &keystable, &permtable, &esubtable,
&encltable, 10, 256, 15);
create_mask_table (&keystable, &masktable);
e_redoc_ii (&keystable, &masktable, &dataval, &permtable, &esubtable,
&encltable, 10, 256, 15, 10);
d_redoc_ii (&keystable, &masktable, &dataval, &permtable, &dsubtable,
&encltable, 10, 256, 15);
return (0);
}
© 2022 Packet Storm. All rights reserved.
%7Cutmcsr%3D(direct)%7Cutmcmd%3D(none)){kind=small}
Follow us on Twitter
Follow us on Facebook
Subscribe to an RSS Feed