desmain.c

C51下把DES汇编改为C语言的程序.改进版程序.

/*--------------------------------------------------------------------------------
DES.C: DES Algorithm Program 
--------------------------------------------------------------------------------*/
#include <string.h>
#define BYTE unsigned char
const BYTE code SBoxes[]={//BoxNr.: 2,1  4,3  6,5  8,7
  0xF7,0xE5,0x34,0xB2,
  0x02,0x5B,0x92,0xE8,
  0x9C,0x88,0x01,0x5C,
  0xAF,0xFD,0xEF,0x05,
  0x64,0x06,0x9E,0x6F,
  0x5B,0x31,0x45,0x93,
  0x3A,0xDD,0x7B,0xAA,
  0x9C,0xAA,0x86,0xF0,
  0x1B,0x79,0x52,0x14,
  0xE7,0x92,0xF8,0x2D,
  0x46,0x13,0xCC,0xC9,
  0x39,0xC4,0x23,0x56,
  0xCD,0x9F,0x6D,0xD1,
  0xB4,0xEC,0x3E,0x7E,
  0xA0,0x24,0xA7,0x36,
  0x4A,0x17,0xD0,0xA9,
  0x82,0xB0,0x83,0x4D,
  0x78,0x66,0x74,0xD2,
  0xE5,0x4B,0xBA,0x93,
  0x13,0x88,0x09,0x6F,
  0xDF,0x6C,0x45,0xF0,
  0x26,0xDF,0x1B,0x3C,
  0x09,0x32,0xE0,0x05,
  0xC5,0x45,0xBC,0xCA,
  0x78,0xC7,0xF8,0x27,
  0xD1,0x09,0xAD,0x8B,
  0xB3,0xAE,0x2F,0x7E,
  0x6E,0x73,0x5A,0xB1,
  0x21,0x5A,0x16,0x8B,
  0x8D,0xB0,0xC1,0x47,
  0x5E,0xF1,0xD9,0xE8,
  0xF0,0x2E,0x67,0x14,
  0xC0,0xBB,0x57,0x8B,
  0xBF,0xC8,0x2D,0x46,
  0x35,0x24,0x6A,0x37,
  0xDA,0x92,0xD6,0xF9,
  0xF7,0x6C,0xE2,0x52,
  0xC2,0x56,0x98,0x28,
  0x69,0x83,0x0C,0x04,
  0x05,0x3D,0x65,0xC7,
  0x2E,0xD0,0x24,0xBD,
  0x51,0x0B,0x43,0x7B,
  0x83,0x4A,0xBF,0x6A,
  0xEC,0xA7,0x80,0x90,
  0x1B,0x06,0x9B,0xE8,
  0x28,0xB1,0xF4,0x15,
  0xDC,0x7F,0xC1,0x91,
  0x76,0x44,0x1A,0x6C,
  0xBF,0x1E,0xFD,0xF0,
  0x13,0xF5,0xC1,0x8D,
  0x06,0xE1,0x80,0xAC,
  0x6D,0x2F,0x7F,0x3A,
  0x44,0xF2,0x3E,0xC9,
  0xF9,0x89,0xA7,0x52,
  0x9A,0x5D,0xD9,0x7F,
  0xA0,0xEA,0x02,0xA4,
  0xE2,0xA9,0x43,0x1E,
  0x84,0x60,0x3E,0xE1,
  0x5D,0x37,0x75,0xD3,
  0x37,0xDC,0xE9,0x0F,
  0x78,0xC5,0xA8,0x25,
  0x4E,0x1E,0x5B,0xBE,
  0xA1,0x98,0x16,0x46,
  0x9B,0x73,0xBC,0xD3};
BYTE DES(char mode, char data *text, char xdata *key)
{
  BYTE BitMap[8];  
  BYTE CalcArea[16];
  BYTE *ptr0,*ptr1,*ptr2;
  BYTE R3,R4,R6,A,B,tmp;
//mode:B7&B6(00 ECB 01 CBC), B5(0 encrypt 1 decrypt),B4(0  crypt 1 MAC generation/verification)

//Check DES mode
  if(mode&0x80)return 3;//Error: wrong mode
  mode^=0x20;
//DES_:
  for(R3=8,ptr1=key; R3!=0; R3--,ptr1++)
  {
    for(R4=7,ptr0=BitMap,A=*ptr1; R4!=0; R4--,ptr0++)
    {
	  (*ptr0)<<=1;
	  if(A&0x80)(*ptr0)++;
      A<<=1;
    }
  }
  A=BitMap[4];BitMap[4]=BitMap[6];BitMap[6]=A;
  //  memcpy(BitMap,"\x0f\x33\x55\x00\x55\x33\x0f\x00",8);
//SetKeyNxt:
  for(R3=7,ptr1=BitMap,ptr0=CalcArea; R3!=0; R3--,ptr1++)
  {
    A=*ptr1;
	for(R4=R3;R4!=0;R4--,ptr0++)
	{
	  tmp=(*ptr0);
	  (*ptr0)=(tmp>>2)+(tmp<<7);
      if(A&0x01)
        (*ptr0)+=0x40;
      A>>=1;
	}
	ptr0=CalcArea;
    for(R4=8-R3;R4!=0;R4--,ptr0++)
	{
  	  tmp=(*ptr0);
	  (*ptr0)=(tmp>>2)+(tmp<<7);
      if(A&0x01)
        (*ptr0)+=0x40;
      A>>=1;
    }
  }
/***************Function DES ***************/
//DesAction://InitPerm:
  for(R6=8,ptr1=text;R6!=0;R6--,ptr1++)
  {
    A=*ptr1;//permute byte into bitmap area
    if(R6==1)break;
    for(R4=8,ptr0=BitMap;R4!=0;R4--,ptr0++)
    {
      (*ptr0)<<=1;
  	  if(A&0x80)(*ptr0)++;
      A<<=1;
    }
  }
//InitEnd:  ;permute last byte
  A=(A>>6)+(A<<2);
  for(R4=8,ptr0=BitMap;R4!=0;R4--,ptr0++)
  {
    if(A&0x80)(*ptr0)|=0x80;else (*ptr0)&=~0x80;
	 A<<=1;
  }
//load permuted input in calculation area
  for(R4=4,ptr1=CalcArea+15,ptr0=BitMap+1;R4!=0;R4--,ptr1--,ptr0+=2)
    *ptr1=*ptr0;
  for(R4=4,ptr0=BitMap;R4!=0;R4--,ptr1--,ptr0+=2)
    *ptr1=*ptr0;  

//16 rounds DES operation //OneRound:
  for(R3=16,ptr2=CalcArea+8;R3!=0;R3--)
  {
    B=(R3-1)%7;
    if(mode&0x30)   //Decode~, BuildMac//EncShift2
    {
	  for( R6=( B&& (R3!=16) )?2:1; R6!=0; R6--)
	  {
        ptr1=CalcArea+6;
  	    A=(*ptr1);
        tmp=CalcArea[0];
  	    (*ptr1)=(tmp>>2)+(tmp<<6);
        ptr1--;
        for(R4=5; R4!=0; R4--, ptr1--)
   	    {
	      tmp=(*ptr1);
		  (*ptr1)=A;
		  A=tmp;
	    }
        (*ptr1)=A;
	  }
	}//Decode~, BuildMac
//RoundKey: 
/*Permutation 36  5 27 61 18 54  9 47    = D6, C6
              44 13 35  6 26 62 17 55    = D5, C5
              52 21 43 14 34  7 25 63    = D4, C4
              60 29 51 22 42 15 33  4    = D3, C3
               3 37 59 30 50 23 41 12    = D2, C2
              11 45  2 38 58 31 49 20    = D1, C1
              19 53 10 46  1 39 57 28    = D0, C0
*/
    A=CalcArea[0]; 
    if(A&0x80)BitMap[7]|=0x01;else BitMap[7]&=~0x01;
    if(A&0x40)BitMap[7]|=0x04;else BitMap[7]&=~0x04;      
    if(A&0x20){
  	  BitMap[1]|=0x10;BitMap[2]|=0x20;BitMap[7]|=0x02;
	}else{
      BitMap[1]&=~0x10;BitMap[2]&=~0x20;BitMap[7]&=~0x02;      
    }
    if(A&0x10){
	  BitMap[0]|=0x20;BitMap[1]|=0x02;BitMap[2]|=0x10;BitMap[6]|=0x01;
	}else{
      BitMap[0]&=~0x20;BitMap[1]&=~0x02;BitMap[2]&=~0x10;BitMap[6]&=~0x01;
	}
    if(A&0x08){
	  BitMap[0]|=0x10;BitMap[2]|=0x08;
	}else{
      BitMap[0]&=~0x10;BitMap[2]&=~0x08;      
    }
    if(A&0x04){
	  BitMap[1]|=0x01;BitMap[6]|=0x20;BitMap[7]|=0x80;
	}else{
      BitMap[1]&=~0x01;BitMap[6]&=~0x20;BitMap[7]&=~0x80;
    }  
    if(A&0x02){
	  BitMap[0]|=0x04;BitMap[6]|=0x10;
	}else{
      BitMap[0]&=~0x04;BitMap[6]&=~0x10;      
	}
    if(A&0x01)BitMap[6]|=0x08;else BitMap[6]&=~0x08;      
//    memcpy(BitMap,"\x9c\x2d\xce\x80\x87\x99\x72\xe5",8);      
    A=CalcArea[1];
	if(A&0x80){
	  BitMap[2]|=0x40;BitMap[3]|=0x02;BitMap[5]|=0x01;  
	}else{
      BitMap[2]&=~0x40;BitMap[3]&=~0x02;BitMap[5]&=~0x01;
	}
    if(A&0x40)BitMap[4]|=0x04;else BitMap[4]&=~0x04;      
	if(A&0x20){
	   BitMap[3]|=0x04;BitMap[5]|=0x02;      
	}else{
	   BitMap[3]&=~0x04;BitMap[5]&=~0x02;      
	}
    if(A&0x10){	  
      BitMap[3]|=0x01;BitMap[5]|=0x08;      
	}else{
	  BitMap[3]&=~0x01; BitMap[5]&=~0x08;      
	}
    if(A&0x04)BitMap[5]|=0x40;else BitMap[5]&=~0x40;
    if(A&0x02){
	   BitMap[3]|=0x80;BitMap[4]|=0x20;      
	}else{
	   BitMap[3]&=~0x80;BitMap[4]&=~0x20;      
	}
	if(A&0x01)BitMap[4]|=0x10;else BitMap[4]&=~0x10;

//    memcpy(BitMap,"\x9c\x2d\x8e\xdd\xae\xae\x72\xe5",8);      
    A=CalcArea[2];
    if(A&0x80)BitMap[0]|=0x02;else BitMap[0]&=~0x02;
    if(A&0x40)BitMap[5]|=0x80;else BitMap[5]&=~0x80;        
    if(A&0x20)BitMap[0]|=0x80;else BitMap[0]&=~0x80;        
    if(A&0x10)BitMap[4]|=0x40;else BitMap[4]&=~0x40;        
    if(A&0x08)BitMap[1]|=0x80;else BitMap[1]&=~0x80;        
    if(A&0x04)BitMap[6]|=0x04;else BitMap[6]&=~0x04;       
    if(A&0x02)BitMap[1]|=0x04;else BitMap[1]&=~0x04;       
    if(A&0x01)BitMap[4]|=0x08;else BitMap[4]&=~0x08;

//    memcpy(BitMap,"\x1c\x2d\x8e\xdd\xe6\x2e\x76\xe5",8);    
    A=CalcArea[3];
    if(A&0x40)BitMap[6]|=0x80;else BitMap[6]&=~0x80;
    if(A&0x10)BitMap[7]|=0x08;else BitMap[7]&=~0x08;
    if(A&0x08)BitMap[0]|=0x01;else BitMap[0]&=~0x01;
    if(A&0x02)BitMap[2]|=0x02;else BitMap[2]&=~0x02;
    if(A&0x01)BitMap[6]|=0x02;else BitMap[6]&=~0x02;
   
//    memcpy(BitMap,"\x1c\x2d\x8c\xdd\xe6\x2e\x76\xe5",8);
    A=CalcArea[4];
    if(A&0x80)BitMap[2]|=0x04;else BitMap[2]&=~0x04;
    if(A&0x40)BitMap[7]|=0x10;else BitMap[7]&=~0x10;
    if(A&0x20)BitMap[2]|=0x80;else BitMap[2]&=~0x80;
    if(A&0x08)BitMap[2]|=0x01;else BitMap[2]&=~0x01;
    if(A&0x04)BitMap[7]|=0x20;else BitMap[7]&=~0x20;
    if(A&0x02)BitMap[0]|=0x08;else BitMap[0]&=~0x08;
    if(A&0x01)BitMap[7]|=0x40;else BitMap[7]&=~0x40;
//    memcpy(BitMap,"\x14\x2d\x09\xdd\xe6\x2e\x76\xa5",8);
    A=CalcArea[5];
    if(A&0x80)BitMap[3]|=0x10;else BitMap[3]&=~0x10;
    if(A&0x40)BitMap[5]|=0x10;else BitMap[5]&=~0x10;
    if(A&0x20)BitMap[3]|=0x20;else BitMap[3]&=~0x20;
    if(A&0x10)BitMap[6]|=0x40;else BitMap[6]&=~0x40;
    if(A&0x08)BitMap[3]|=0x40;else BitMap[3]&=~0x40;
    if(A&0x04)BitMap[4]|=0x02;else BitMap[4]&=~0x02;
    if(A&0x02)BitMap[1]|=0x20;else BitMap[1]&=~0x20;
    if(A&0x01)BitMap[5]|=0x04;else BitMap[5]&=~0x04;
//    memcpy(BitMap,"\x14\x0d\x09\xed\xe6\x2e\x76\xa5",8);
    A=CalcArea[6];
    if(A&0x80)BitMap[1]|=0x08;else BitMap[1]&=~0x08;
    if(A&0x40)BitMap[4]|=0x80;else BitMap[4]&=~0x80;
    if(A&0x20)BitMap[1]|=0x40;else BitMap[1]&=~0x40;
    if(A&0x10)BitMap[5]|=0x20;else BitMap[5]&=~0x20;
    if(A&0x08)BitMap[0]|=0x40;else BitMap[0]&=~0x40;
    if(A&0x02)BitMap[3]|=0x08;else BitMap[3]&=~0x08;
    if(A&0x01)BitMap[4]|=0x01;else BitMap[4]&=~0x01;
//    memcpy(BitMap,"\x14\x0d\x09\xe5\x66\x2e\x76\xa5",8);
	if(!(mode&0x30))   //!(Decode~, BuildMac)//DecShift2
	{
      B--;
	  for( R6=( B && (R3!=0) )?2:1; R6!=0; R6--)
      {
	    ptr1=CalcArea;
        A=(*ptr1);
		ptr1++;
        for(R4=6;R4!=0;R4--,ptr1++)
  	    { 
	      tmp=A;
          A=(*ptr1);
          (*ptr1)=tmp;
	    }
        CalcArea[0]=(A<<2)+(A>>6);
	  }
	}
//InitExpand://ExpXorSBox:
	for(R4=4,ptr0=BitMap,A=(*ptr2),ptr2+=3;R4!=0;R4--,ptr2--)
	{
      A=(A&0xf0)+((*ptr2)&0x0f);
	  A^=(*ptr0);
	  A=(A>>4)+(A<<4);
	  A&=0xfc;
	  (*ptr0)=SBoxes[4-R4+A];
      ptr0++;

   	  A=(*ptr2);
      A^=(*ptr0); 
      A&=0xfc;
	  (*ptr0)=SBoxes[4-R4+A];
	  ptr0++;
      A=(*ptr2);
	}

	if(!(R3&0x01))ptr2+=8;//Odd Round?
    A>>=1;
	if(BitMap[1]&0x40)A|=0x80;else A&=~0x80;
    A>>=1;
	if(BitMap[4]&0x08)A|=0x80;else A&=~0x80;    
    A>>=1;
	if(BitMap[5]&0x10)A|=0x80;else A&=~0x80;    
    A>>=1;
	if(BitMap[7]&0x10)A|=0x80;else A&=~0x80;    
    A>>=1;
	if(BitMap[2]&0x08)A|=0x80;else A&=~0x80;    
    A>>=1;
	if(BitMap[6]&0x08)A|=0x80;else A&=~0x80;    
    A>>=1;
	if(BitMap[4]&0x01)A|=0x80;else A&=~0x80;    
    A>>=1;
	if(BitMap[0]&0x01)A|=0x80;else A&=~0x80;    
    (*ptr2)^=A;

    A>>=1;
	if(BitMap[3]&0x40)A|=0x80;else A&=~0x80;
    A>>=1;
	if(BitMap[5]&0x40)A|=0x80;else A&=~0x80;    
    A>>=1;
	if(BitMap[6]&0x02)A|=0x80;else A&=~0x80;    
    A>>=1;
	if(BitMap[1]&0x10)A|=0x80;else A&=~0x80;    
    A>>=1;
	if(BitMap[4]&0x02)A|=0x80;else A&=~0x80;    
    A>>=1;
	if(BitMap[7]&0x40)A|=0x80;else A&=~0x80;    
    A>>=1;
	if(BitMap[2]&0x02)A|=0x80;else A&=~0x80;    
    A>>=1;
	if(BitMap[0]&0x02)A|=0x80;else A&=~0x80;    
	ptr2--;
    (*ptr2)^=A;
    
    A>>=1;
	if(BitMap[1]&0x80)A|=0x80;else A&=~0x80;
    A>>=1;
	if(BitMap[5]&0x80)A|=0x80;else A&=~0x80;    
    A>>=1;
	if(BitMap[3]&0x20)A|=0x80;else A&=~0x80;    
    A>>=1;
	if(BitMap[7]&0x80)A|=0x80;else A&=~0x80;    
    A>>=1;
	if(BitMap[6]&0x04)A|=0x80;else A&=~0x80;    
    A>>=1;
	if(BitMap[0]&0x04)A|=0x80;else A&=~0x80;    
    A>>=1;
	if(BitMap[2]&0x01)A|=0x80;else A&=~0x80;    
    A>>=1;
	if(BitMap[4]&0x04)A|=0x80;else A&=~0x80;    
	ptr2--;
    (*ptr2)^=A;

    A>>=1;
	if(BitMap[3]&0x10)A|=0x80;else A&=~0x80;
    A>>=1;
	if(BitMap[7]&0x20)A|=0x80;else A&=~0x80;    
    A>>=1;
	if(BitMap[1]&0x20)A|=0x80;else A&=~0x80;    
    A>>=1;
	if(BitMap[5]&0x20)A|=0x80;else A&=~0x80;    
    A>>=1;
	if(BitMap[2]&0x04)A|=0x80;else A&=~0x80;    
    A>>=1;
	if(BitMap[0]&0x08)A|=0x80;else A&=~0x80;    
    A>>=1;
	if(BitMap[6]&0x01)A|=0x80;else A&=~0x80;    
    A>>=1;
	if(BitMap[3]&0x80)A|=0x80;else A&=~0x80;    
	ptr2--;
    (*ptr2)^=A;
  }
// Normalize output of 16 rounds
//PreOutput:
  BitMap[7]=(*ptr2);
  ptr2++;
  BitMap[5]=(*ptr2);
  ptr2++;
  BitMap[3]=(*ptr2);
  ptr2++;
  BitMap[1]=(*ptr2);
  ptr2++;
  BitMap[6]=(*ptr2);
  ptr2++;
  BitMap[4]=(*ptr2);
  ptr2++;
  BitMap[2]=(*ptr2);
  ptr2++;
  BitMap[0]=(*ptr2);
    
//InvItPerm:
  for(R3=8,ptr0=BitMap;R3!=0;R3--,ptr0++)
  {
    A=(*ptr0);
    A=(A<<1)+(A>>7);
    for(R4=8;R4!=0;R4--)
    {
      (*ptr2)<<=1;
      if(A&0x01)(*ptr2)|=0x01;else (*ptr2)&=~0x01;
      A>>=1; 
      ptr2--;
    }
    ptr2+=8;
  }
  tmp=(*ptr2);
  (*ptr2)=(tmp>>2)+(tmp<<6);
//Result of DES operation available
  for(R3=8;R3!=0;R3--)
    text[R3-1]=CalcArea[R3+7];
  return 0; //Normal Termination  => Carry == 0 !
}
void main(void)
{
  char xdata key[8] = {0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef};
  char data sour[8] = {0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef};
  char data dest[8] = {0xA2,0xD9,0x39,0x16,0x5D,0x26,0xA4,0xCA};

  memcpy(dest,sour,8);
  DES(0, dest, key);
  DES(0x20,dest,key);
  while (1);
}