cipherfun.cpp

一个用3DES加密文件的小测试程序！

/**This programe is created by Chenfeng and Lihua in 7.13.2000*/
#include <stdafx.h>

#include "stdlib.h"
#include "stdio.h"
#include "des_cipher.h"
#include "string.h"

void deskey(unsigned char *key,short mode) 
{
        register int i,j,l,m,n;
        unsigned char pclm[56],pcr[56];
        unsigned long  kn[32];/**/

        for( j=0;j< 56;j++) {
                l= pc1[j];
                m= l&  07;
                pclm[j]=(key[l>>3]&bytebit[m])?1:0;
                    }

        for(i=0;i<16;i++){
                if(mode==DE1)m=(15- i)<<1;
                else  m=  i<<1;
                n=m+1;
                kn[m]=kn[n]=0L;
                for( j=0; j<28; j++){
                      l= j+ totrot[i];/**totrot is used for left cycle**/
                      if( l<28) pcr[j]= pclm[l];
                        else pcr[j]=pclm[l-28];
                              }
                for( j=28; j<56; j++) {
                    l=j+totrot[i];
                  if( l<56) pcr[j]=pclm[l];
                  else pcr[j]=pclm[l-28];
                          }
                for(j=0;j<24;j++){
                      if (pcr[pc2[j]] ) kn[m]|= bigbyte[j];
                      if( pcr[pc2[j+24]]) kn[n]|= bigbyte[j];
                              }
                    }
      cookey(kn);/**kn store the primary child keys:kn[0]=1 2 3 4 byte,kn[1]=5 6 7 8byte and so on**/
          return;
}
  
static void cookey(register unsigned long *raw1)
{
      register unsigned long *cook,*raw0;
      unsigned long dough[32];
      register  int  i;

      cook=dough;
      for( i=0; i<16; i++, raw1++){
                raw0=raw1++;
                *cook =(*raw0 & 0x00fc0000L)<<6;
                *cook |=(*raw0 & 0x00000fc0L) << 10;
                *cook |=(*raw1 & 0x00fc0000L) >>10;
                *cook++    |=(*raw1& 0x00000fc0L) >>6;
                *cook  =(*raw0 & 0x0003f000L) <<12;
                *cook |=(*raw0 & 0x0000003fL) <<16;
                *cook |=(*raw1 & 0x0003f000L) >>4;
                *cook++    |=(*raw1&0x0000003fL);
                    }
        usekey(dough);/**knl store the changed keys knl[0]=1 3 5 7byte,knl[1]=2 4 6 8byte and so on**/
          return;
}

void cpkey(register unsigned  long *into)
{
        register unsigned long *from,*endp;
        from=KnL; endp=&KnL[32];
        while(from<endp)*into++=*from++;
          return;
}

void usekey(register unsigned long *from)
{
        register unsigned long *to,*endp;
          to=KnL;endp=&KnL[32];
        while(to<  endp)*to++=*from++;
          return;
}


static void scrunch(register unsigned char *outof,
					register unsigned long *into)
{
        *into   =(*outof++&0xffL)<<24;
        *into   |=(*outof++&0xffL)<<16;
        *into   |=(*outof++&0xffL)<<8;
        *into++   |=(*outof++&0xffL);
        *into   =(*outof++&0xffL)<<24;
        *into |=(*outof++ &0xffL)<<16;
        *into |=(*outof++ &0xffL)<<8;
        *into |=(*outof &0xffL);
         return;
}

static void unscrun(register unsigned long *outof,
					register unsigned char *into)
{
      *into++=(*outof>>24)&0xffL;
      *into++=(*outof>>16)&0xffL;
      *into++=(*outof>>8)&0xffL;
      *into++=*outof++  &0xffL;
      *into++=(*outof>>24)&0xffL;
      *into++=(*outof>>16)&0xffL;
      *into++=(*outof>>8)&0xffL;
      *into  = *outof    &0xffL;
      return;
}

/**the main DES algrothim**/
static void desfunc(register unsigned long *block,
					register unsigned long *keys)   
{
      register unsigned long fval,work,right,leftt;
      register int round;
      
	  /*IP transform*/
	  leftt=block[0];
      right=block[1];
      work=((leftt>>4)^right)&0x0f0f0f0fL;
      right^=work;
      leftt^=(work<<4);
      work=((leftt>>16)^right)&0x0000ffffL;
      right^=work;
      leftt^=(work<<16);
      work=((right>>2)^leftt)&0x33333333L;
      leftt^=work;
      right^=(work<<2);
      work=((right>>8)^leftt)&0x00ff00ffL;
      leftt^=work;
      right^=(work << 8);
      right=((right<< 1)|((right>>31)&1L)) & 0xffffffffL;
      work=(leftt^right)& 0xaaaaaaaaL;
      leftt^=work;/*here the leftt is the true result of the transform*/
      right^=work;
      leftt=((leftt<< 1)|((leftt>>31) & 1L))& 0xffffffffL;/*the changed leftt is used for E-expand*/

      for( round=0; round<8; round++){ 
              work=(right<< 28)|(right>>4);
              work^=*keys++;
              fval= SP7 [work & 0x3fL];
              fval |= SP5[(work>>8)& 0x3fL];
              fval |= SP3[(work>>16)& 0x3fL];
              fval |= SP1[(work>>24)& 0x3fL];
              work=right^*keys++;
              fval |= SP8[ work         & 0x3fL];
              fval |= SP6[(work>>8)& 0x3fL];
              fval |= SP4[(work>>16)& 0x3fL];
              fval |= SP2[(work>>24)& 0x3fL];
              leftt^=fval; 
              work=(leftt << 28)|(leftt >>4);
                work^=*keys++;
                fval = SP7[  work        & 0x3fL];
                fval |= SP5[(work>>8)& 0x3fL];
                fval |= SP3[(work>>16)& 0x3fL];
                fval |= SP1[(work>>24)& 0x3fL];
                work =leftt^*keys++;
                fval |= SP8[  work        & 0x3fL];
                fval |= SP6[(work>>8)& 0x3fL];
                fval |= SP4[(work>>16)& 0x3fL];
                fval |= SP2[(work>>24)& 0x3fL];
                right^= fval;
                    }

        /*IP-1 transform*/
        right=(right<< 31)|(right>>1);
        work=(leftt^right)& 0xaaaaaaaaL;
        leftt^=work;
        right^=work;
        leftt=(leftt<<31)|(leftt>>1);
        work=((leftt>>8)^right)&0x00ff00ffL;
        right^=work;
        leftt^=(work<<8);
        work=((leftt>>2)^ right) & 0x33333333L;
        right^=work;
        leftt^=(work<<2);
        work=((right >>16)^leftt)& 0x0000ffffL;
        leftt^=work;
        right^=(work<<16);
        work=((right>>4)^leftt) & 0x0f0f0f0fL;
        leftt^=work;
        right^=(work<<4);
        *block++= right;
        *block= leftt;
          return ;
}
/*Validation sets;
 *
 *Single-length key,single-length plaintext
 *key   :0123 4567 89ab cdef
 *plain :0123 4567 89ab cde7
*Cipher:c957 4425 6a5e d31d
*  
***********************************************/

/**get the key and put them into the structure des_ctx**/
void des_key(des_ctx *dc,unsigned char * key,short mode){
        
	if(mode==EN0){
	    deskey(key,EN0);
        cpkey(dc->ek);
	}
	else{
		 deskey(key,DE1);
         cpkey(dc->dk);
	}
}

/*Encrypt several blocks in ECB mode.Caller is responsible for
    Short blocks.*/
void des_enc(des_ctx *dc,unsigned char *data,int block_num){
        unsigned long work[2];
        unsigned char *cp;
	    register int   i;
     
		cp=data;
		for(i=0;i<block_num;i++){
			scrunch(cp,work);
			desfunc(work,dc->ek);
			unscrun(work,cp);
			cp+=8;
		}
           
}

void des_dec(des_ctx *dc,unsigned char *data,int block_num){
         unsigned long work[2];
         unsigned char*cp;
         int i;
		 
		 cp=data;
		 for(i=0;i<block_num;i++){     
			scrunch(cp,work);
			desfunc(work,dc->dk);
			unscrun(work,cp);
			cp+=8;
		 }
}


void des_cipher(register unsigned char *data,int block_num,
				register unsigned char *key,short mode)
{
	des_ctx dc;
    register unsigned char *cp;

    cp=data;
	if(mode==EN0){
		des_key(&dc,key,mode);
		des_enc(&dc,cp,block_num);
	}
	else {
		des_key(&dc,key,mode);
		des_dec(&dc,cp,block_num);
	}
}