/*#define DEBUG
/**************** WARNING ************************************************
*
* CURRENT EXPORT LAWS CONTROL THE EXPORT OF THE DES
* ALGORITHM OUTSIDE OF THE UNITED STATES.
* If you are outside of the United States, then you do not have
* the legal right to export/download/view this program.
*
************************************************************************/
/*
* Behavioral model for the DEStiny chip
*
* DEStiny is an implementation of the crypt() algorithm of DES encryption
* It is being created as a project for CS755 by Zhenyu Liu and David Ljung
*
* Code written by David Ljung, 3/25/94
*
* Tables were taken from simple_crypt.c by Michael Glad (glad@daimi.aau.dk)
* (Copyright 1992 under GNU Public License)
*
* I used integer tables for bits instead of a more packed representation
* for the sake of clarity, and to be more analogous to a VLSI representation
*
*/
/* Includes
*/
#include
#include
#include /* for crypt(), for final comparison */
/* Tables
*/
/* Expansion table (32 to 48) */
int E_p[48]=
{ 32, 1, 2, 3, 4, 5, 4, 5, 6, 7, 8, 9,
8, 9,10,11,12,13,12,13,14,15,16,17,
16,17,18,19,20,21,20,21,22,23,24,25,
24,25,26,27,28,29,28,29,30,31,32, 1 };
/* Permutation Choice 1 for subkey generation (64/56 to 56) */
int PC1_p[56]=
{ 57,49,41,33,25,17, 9, 1,58,50,42,34,26,18,
10, 2,59,51,43,35,27,19,11, 3,60,52,44,36,
63,55,47,39,31,23,15, 7,62,54,46,38,30,22,
14, 6,61,53,45,37,29,21,13, 5,28,20,12, 4 };
/* Permutation Choice 2 for subkey generation (56 to 48) */
int PC2_p[56]=
{ 14,17,11,24, 1, 5, 3,28,15, 6,21,10,
23,19,12, 4,26, 8,16, 7,27,20,13, 2,
41,52,31,37,47,55,30,40,51,45,33,48,
44,49,39,56,34,53,46,42,50,36,29,32 };
/* Number of rotations for the iteration of key scheduling */
/* The concept of a table here doesn't fit our behavioral model */
/* This will be logic in our final design */
int keyrots[16]= {1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1};
/* Selection blocks
* There are 8 sblocks, each of which is referenced by a 2 bit value
* which picks the row, and a 4 bit value which picks the column
* This number is then the 4 bit output for that select block
*/
int sblocks[8][4][16]=
{ { { 14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7 },
{ 0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8 },
{ 4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0 },
{ 15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13 }
},
{ { 15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10 },
{ 3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5 },
{ 0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15 },
{ 13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9 }
},
{ { 10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8 },
{ 13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1 },
{ 13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7 },
{ 1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12 }
},
{ { 7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15 },
{ 13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9 },
{ 10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4 },
{ 3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14 }
},
{ { 2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9 },
{ 14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6 },
{ 4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14 },
{ 11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3 }
},
{ { 12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11 },
{ 10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8 },
{ 9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6 },
{ 4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13 }
},
{ { 4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1 },
{ 13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6 },
{ 1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2 },
{ 6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12 }
},
{ { 13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7 },
{ 1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2 },
{ 7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8 },
{ 2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11 }
}
};
/* Permutation P for after sblocks */
int P_p[32] =
{ 16, 7,20,21,29,12,28,17, 1,15,23,26, 5,18,31,10,
2, 8,24,14,32,27, 3, 9,19,13,30, 6,22,11, 4,25 };
/* Inverse permutation of IP for end
* Temporary - the true behavior will be implemented in a shift out register
* (Look at the pattern obvious in an 8x8 layout)
*/
int IPinv_p[64] =
{ 40, 8, 48, 16, 56, 24, 64, 32,
39, 7, 47, 15, 55, 23, 63, 31,
38, 6, 46, 14, 54, 22, 62, 30,
37, 5, 45, 13, 53, 21, 61, 29,
36, 4, 44, 12, 52, 20, 60, 28,
35, 3, 43, 11, 51, 19, 59, 27,
34, 2, 42, 10, 50, 18, 58, 26,
33, 1, 41, 9, 49, 17, 57, 25 };
/* Code
*/
/* header
* Print out a header for print_bits
* For debugging/testing
*/
header(amt)
int amt;
{
int i;
if(amt/10>0) {
for(i=1;i<=amt;i++)
if(i/10>0 && i/10*10==i) printf("%d",i/10);
else printf(" ");
printf("\n");
}
for(i=1;i<=amt;i++) fprintf(stdout,"%d",i-i/10*10);
fprintf(stdout,"\n");
}
/* print_bits
* Prints out the bits of a string in binary format
*/
print_bits(s,amt)
int *s,amt;
{
int i;
for(i=0;i=0;amt--)
out[amt]=in[by[amt]-1];
}
/* do_sblocks
* Convert the 48 bit value into 32 bits with the selection blocks
*/
do_sblocks(in,out)
int *in,*out;
{
int i,j,val;
for(i=0;i<8;i++) {
val=sblocks[i] [ in[i*6]<<1 | in[i*6+5] ]
[ in[i*6+1]<<3 | in[i*6+2]<<2 |in[i*6+3]<<1 |in[i*6+4] ];
out[i*4]=val>>3&1;
out[i*4+1]=val>>2&1;
out[i*4+2]=val>>1&1;
out[i*4+3]=val&1;
}
/*
printf("Before SB: "); pr_bits(in,48);
printf("After SB: "); pr_bits(out,32);
*/
}
/* load_salt
* load the salt mask with the salt bits
*
* We either need to figure out a good VLSI implementation of ascii_to_bin
* or else just take the salt as the converted 12 bits and not 2 chars
* hmm.. we also need bin_to_ascii - for output
*/
#define ascii_to_bin(c) (c>='a'?(c-59):c>='A'?(c-53):c-'.')
#define bin_to_ascii(c) (c>=38?(c-38+'a'):c>=12?(c-12+'A'):c+'.')
load_salt(saltmask,salt)
int *saltmask;
char *salt;
{
int tot,i;
tot=ascii_to_bin(salt[0]) | (ascii_to_bin(salt[1])<<6);
for(i=0;i<12;i++)
saltmask[i]=tot>>i&1;
#ifdef DEBUG
printf("Salt mask: "); print_bits(saltmask,12);
#endif
}
/* salt
* the salting function
* switch bits according to salt
*/
do_salt(bits,saltmask)
int *bits,*saltmask;
{
int i,t;
for(i=0;i<12;i++)
if(saltmask[i]) {
t=bits[i];
bits[i]=bits[24+i];
bits[24+i]=t;
}
}
/* load the intermediate key with the password bits permuted by PC1
*
* bit 1 is MSB of first char
*/
load_key(ikey,password)
int *ikey;
char *password;
{
int i,j;
int tmp[64];
for(i=0;i<8;i++)
for(j=0;j<8;j++)
tmp[i*8+j]=(password[i]>>(6-j)) &1;
permute(PC1_p,56,tmp,ikey);
/*
#ifdef DEBUG
*/
printf("Password bits: "); pr_bits(tmp,64);
if(0) for(i=0;i<=56;i+=8) print_bits(tmp+i,7);
printf("Loaded (after PC 1): "); pr_bits(ikey,56);
/*
#endif
*/
}
/* generate a subkey for iteration: iter
* the subkey is kept in the same memory space, so
* subsequent calls will be destructive to the last subkey.
* This also means that subkey() counts on the memory space being unchanged.
* This call will change the intermediate key (by a rotate)
*
* (It would be more efficient to generate the 16 subkeys at
* once and save them, but this should be close to the behavior
* of the chip, which will generate in parallel to the function)
*/
int *subkey(ikey,iter)
int *ikey,iter;
{
static int sub[48];
int rots,i,tmp0l,tmp1l,tmp0r,tmp1r;
rots=keyrots[iter]; /* number of rotates - 1 or 2 */
tmp0l=ikey[0];
tmp1l=ikey[1];
tmp0r=ikey[28];
tmp1r=ikey[29];
for(i=0;i<28-rots;i++) {
ikey[i]=ikey[i+rots];
ikey[28+i]=ikey[28+i+rots];
}
if(rots==2) {
ikey[26]=tmp0l;
ikey[27]=tmp1l;
ikey[54]=tmp0r;
ikey[55]=tmp1r;
} else {
ikey[27]=tmp0l;
ikey[55]=tmp0r;
}
/* printf("Key[%2.2d]: ",iter+1); pr_bits(ikey,56); */
permute(PC2_p,48,ikey, sub);
/* printf("subKey[%2.2d]: ",iter+1); pr_bits(sub,48); */
return sub;
}
/* xor
* src1 <- src1 xor src2
*/
xor(src1,src2,num)
int *src1,*src2,num;
{
int i;
for(i=0;i \n\
password is a string up to 8 characters\n\
salt is two characters\n\
",name);
exit(-1);
}
/* main
*
* This is all just behavioral model interface
*/
main(argc,argv)
int argc;
char **argv;
{
char password[9];
char salt[3];
char *answer;
if(argc!=3) usage(argv[0]);
if(argv[2][0]=='\0' || argv[2][1]=='\0') usage(argv[0]);
strcpy(password,"\0\0\0\0\0\0\0\0\0");
strncpy(password,argv[1],8);
salt[0]=argv[2][0]; salt[1]=argv[2][1]; salt[2]='\0';
fprintf(stdout,"Encrypting [%s] with salt [%s]\n",password,salt);
answer=mycrypt(password,salt);
fprintf(stdout,"Comparison:\n"
"UNIX crypt() Behavioral Model\n"
"[%s] [%s]\n",
crypt(password,salt),answer);
fprintf(stdout,"\nDone.\n");
exit(0);
}
Back to the DEStiny page
Back to DaveSource.com