datadecrypt.c

该例程实现了一个简单的16轮分组加密算法

/*
 * main.c
 *
 * Project:	Datadecrypt
 * Author:	root <[e-mail]>
 * Date:	Thu Jul 29 11:17:45 CST 2004
 */
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#define DATASIZE 64

void fk();
void decrypt(unsigned char *into,unsigned char *outof);
unsigned long Sbox(unsigned long key);
unsigned long zkbuf[16];
unsigned S0[256],S1[256],S2[256],S3[256];
unsigned long zkbuf[16];
unsigned long kbuf[16];
int i,j,k;
int main(int argc, char *argv[])
{

  //unsigned long zkbuf[16];
  unsigned long *kbufpt;
  //unsigned long *zkbufpt;
  unsigned char *newmingwenpt;
  unsigned char *miwenpt;
  unsigned char newmingwenbuf[DATASIZE];
  unsigned char miwenbuf[DATASIZE];

  FILE *pfile,*fp;
  int i;
  //int j;
  int bytes_read=DATASIZE;
  //int bytes_write;
  bzero(newmingwenbuf,DATASIZE);
  bzero(miwenbuf,DATASIZE);
  newmingwenpt=newmingwenbuf;
  miwenpt=miwenbuf;
  for(i=0;i<16;i++)
  {
     kbuf[i]=0x00000000L;
  }
  kbufpt=kbuf;
  if((pfile=fopen("/tmp/miwen","r+"))==NULL)
    {
      printf("Can't find the file !");
      return(0);
    }
   if((fp=fopen("/tmp/newmingwen","w+"))==NULL)
    {
      printf("Can't find the file !");
      return(0);
    }

  while(bytes_read==DATASIZE)
    {
       bzero(newmingwenbuf,DATASIZE);
       bzero(miwenbuf,DATASIZE);
       /*for(i=0;i<DATASIZE;i++)
       {
        mingwenbuf[i]=0;
       }
      for(i=0;i<DATASIZE;i++)
       {
        miwenbuf[i]=0;
       } */
     if((bytes_read=fread(miwenpt,1,DATASIZE,pfile))<1)
     break;
     printf("bytes_read is %d\n",bytes_read);
     decrypt(miwenpt,newmingwenpt);
     fwrite(newmingwenpt,1,DATASIZE,fp);
    }
   fclose(pfile);
   fclose(fp);
   return EXIT_SUCCESS;
}

/**********************************************************
         S-BOX :k--->zk
***********************************************************/
unsigned long Sbox(unsigned long key)
{
   int A,B,C,D;
   unsigned long Zk;
     Zk=0;
     A=(int)((key&0x000000ff));
     B=(int)((key&0x0000ff00)>>8);
     C=(int)((key&0x00ff0000)>>16);
     D=(int)((key&0xff000000)>>24);
     Zk=((unsigned long)(S0[A]))|Zk;
     Zk=(((unsigned long)(S1[B]))<<8)|Zk;
     Zk=(((unsigned long)(S2[C]))<<16)|Zk;
     Zk=(((unsigned long)(S3[D]))<<24)|Zk;
     return(Zk);
}


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

         FK:generation of child key
 **********************************************************/


void fk(unsigned long key)
{
    //unsigned long kbuf[16];

    unsigned long S0[256],S1[256],S2[256],S3[256];

    int i;
    int b;
    int c;
    int d;
    int a;
    bzero(zkbuf,64);
     a=(kbuf[0])& 0x000000ff;
     b=(int)(((kbuf[0])&0x0000ff00)>>8);
     c=(int)(((kbuf[0])&0x00ff0000)>>16);
     d=(int)(((kbuf[0])&0xff000000)>>24);
    srand((unsigned)time(NULL));

    for(i=0;i<256;i++)
     {
       S0[i]=rand()%256;
     }
     for(i=0;i<256;i++)
     {
       S1[i]=rand()%256;
     }
     for(i=0;i<256;i++)
     {
       S2[i]=rand()%256;
     }
     for(i=0;i<256;i++)
     {
       S3[i]=rand()%256;
     }
        zkbuf[0]= ((unsigned long)S0[a])|zkbuf[0];
        zkbuf[0]=(((unsigned long)(S1[b]))<<8)|zkbuf[0];
        zkbuf[0]=(((unsigned long)(S2[c]))<<16)|zkbuf[0];
        zkbuf[0]=(((unsigned long)(S3[d]))<<24)|zkbuf[0];
     for(i=1;i<16;i++)
     {
       zkbuf[i]=(Sbox((zkbuf[i-1]^kbuf[i])));
     }
}

/*****************************************************
              decrypt function  realization
******************************************************/
void decrypt(unsigned char *into,unsigned char *outof)
{
   unsigned long zkbuf[16];
   unsigned char mingmibuf[DATASIZE];
   unsigned char tempbuf[DATASIZE];
   for(i=0;i<DATASIZE;i++)
       {
        mingmibuf[i]=0;
       }
   for(i=0;i<DATASIZE;i++)
       {
        tempbuf[i]=0;
       }

   for(j=0;j<16;j++)
   {
     mingmibuf[0]=(into[0])^zkbuf[15-j];
     tempbuf[60]=mingmibuf[0];
     mingmibuf[1]=(into[1])^(zkbuf[15-j]>>8);
     tempbuf[61]=mingmibuf[1];
     mingmibuf[2]=(into[2])^(zkbuf[15-j]>>16);
     tempbuf[62]=mingmibuf[2];
     mingmibuf[3]=(into[3])^(zkbuf[15-j]>>24);
     tempbuf[63]=mingmibuf[3];
     for(i=1;i<16;i++)
     {
     mingmibuf[4*i]=(into[4*i])^mingmibuf[4*i-4];
     tempbuf[4*i-4]=mingmibuf[4*i];
     mingmibuf[4*i+1]=(into[4*i+1])^mingmibuf[4*i-3];
     tempbuf[4*i-3]=mingmibuf[4*i+1];
     mingmibuf[4*i+2]=(into[4*i+2])^mingmibuf[4*i-2];
     tempbuf[4*i-2]=mingmibuf[4*i+2];
     mingmibuf[4*i+3]=(into[4*i+3])^mingmibuf[4*i-1];
     tempbuf[4*i-1]=mingmibuf[4*i+3];
     }
     for(i=0;i<DATASIZE;i++)
      {
        into[i]=tempbuf[i];
      }
  }

     for(i=0;i<DATASIZE;i++)
      {
       outof[i]=tempbuf[i];
      }
     for(i=0;i<DATASIZE;i++)
       {
        mingmibuf[i]=0;
       }
}