rc4.cpp

这是一个关于密码学RC4算法（原创代码）

//  两者都作为字符用的话是没有区别的，但当整数用时有区别：   
//  char   整数范围为-128到127，而unsigned   char   整数范围为0到255

  #include   <stdio.h>   
  #include   <string>    
  #define   buf_size   1024 
  #define LEN sizeof(struct slink)
  int count;
  typedef   struct   rc4_key   
  {               
        unsigned   char   state[256];                 
        int  x;                   
        int  y;   
  }   rc4_key;   
    
 typedef struct slink
{ 
	  unsigned char cha;
    struct slink *next;
 } slink;

  static   void   swap_byte(unsigned   char   *a,   unsigned   char   *b);   
// #define   swap_byte(x,y)   t=*(x); *(x)=*(y); *(y)=t   
    
  void   prepare_key(unsigned   char   *key_data_ptr,   int   key_data_len,   rc4_key   *key)   
  {     
//    unsigned   char   swapByte;   
      int   index1;   
      int   index2;   
      unsigned   char*  state;   
      short    counter;   
    
      state   =   &key->state[0];   
      for(counter   =   0;   counter   <   256;   counter++)   
      state[counter]   =   counter;   
      key->x   =   0;   
      key->y   =   0;   
      index1   =   0;   // index1 控制重复填充 K
      index2   =   0;   // j
      for(counter   =   0;   counter   <   256;   counter++)   
      {   
          index2   =   (key_data_ptr[index1]   +   state[counter]   +   index2)   %   256;   
          swap_byte(&state[counter],   &state[index2]);   
          index1   =   (index1   +   1)   %   key_data_len;   
      }   
  }   
    
  void   rc4(struct  slink   *buffer_ptr,   int   buffer_len,   rc4_key   *key)   
  {   
      int   x; 
      int   y; 
      unsigned   char*  state;   
      unsigned   char   xorIndex;   
      short   counter;   
	  struct  slink   *p1,*p2;
      p1=p2=(struct slink * )malloc(LEN);
	  p1=buffer_ptr;
      x   =   key->x;   //  i
      y   =   key->y;   //  j
      state   =   &key->state[0];   
      for(counter   =   0;   counter   <   buffer_len;   counter++)   
      {   
          x   =   (x+1)   %   256;   
          y   =   (state[x]+y)   %   256;   
          swap_byte(&state[x],&state[y]);   
          xorIndex=(state[x]+state[y])%256;   
          p1->cha   ^=   state[xorIndex];//^异或运算
		  p1=p1->next;
      }   
      key->x   =   x;   
      key->y   =   y;   
  }   

  void   rc41(unsigned char   *buffer,   rc4_key   *key)   
  {   
      int   x; 
      int   y; 
      unsigned   char*  state;   
      unsigned   char   xorIndex;   
  
      x   =   key->x;   //  i
      y   =   key->y;   //  j 
		state   =   &key->state[0]; 
          x   =   (x+1)   %   256;   
          y   =   (state[x]+y)   %   256;   
          swap_byte(&state[x],&state[y]);   
          xorIndex=(state[x]+state[y])%256;   
          *buffer   ^=   state[xorIndex];//^异或运算  
      key->x   =   x;   
      key->y   =   y;   
  }   
    
  static   void   swap_byte(unsigned   char   *a,   unsigned   char   *b)   
          {   
                  unsigned   char   swapByte;     
                    
                  swapByte   =   *a;     
                  *a   =   *b;               
                  *b   =   swapByte;   
          } 


  struct slink *input(void)//输入明文并且返回头指针，没有加密时候转化的数字
{   
  struct  slink *head;
  struct  slink *p1,*p2;
    unsigned char  c,ch;

	p1=p2=(struct slink * )malloc(LEN);
	head=NULL;
	printf("Input the content : \n\n");
while((ch=getchar())!='\n')
   {
	c=ch;
	p1->cha=c;
	count=count+1;
	if(count==1)
		head=p1;
	else p2->next=p1;
	p2=p1;
    p1=(struct slink * )malloc(LEN);
	}
    p2->next=NULL; 
	return(head);
}

  int   main(int   argc,    char*   argv[])   //加密二进制文件和文本文件
  {   
          char   seed[256]; 
		  unsigned   char keydata[256],ch;
	      char   data[512];   
//      unsigned char   buf[buf_size];   
      char   digit[2];   
      int   hex,   rd,i;   
      int   n;   
	  struct  slink *head,*p1;
      rc4_key   key; 
	  	char c;  
		FILE *fpr,*fpw; 

	  strcpy(seed,argv[1]);   

      n   =   strlen(seed);  
	for(i=0;i<n;i++)
	{
		keydata[i]=(unsigned char)seed[i];
	}

      prepare_key(keydata,n,&key); 


  if(argc<4){printf("参数太少\n");return 0;} 
  if((fpr=fopen(argv[2],"rb"))==NULL)
  {
	  printf("文件%s不能打开\n",argv[2]);
	  return 0;
  } 
 if((fpw=fopen(argv[3],"wb"))==NULL)
 {
	 printf("文件%s不能打开\n",argv[3]);
	 return 0;
 }


 while(!feof(fpr))
 {
	c=fgetc(fpr); 
	ch=(unsigned char)c;
	rc41(&ch,&key);
	c=(signed char)ch;
	fputc(c,fpw);
 } 
 fclose(fpr);
 fclose(fpw); 
      

//      strcpy(data,argv[1]);   
//      n   =   strlen(data);   

/*      if   (n&1)   
      {   
          strcat(data,"0");   
          n++;   
      }         //把n恒变为偶数 
      n/=2; 
//	  printf("%s\n",data);
//	  printf("%d",n);

//      strcpy(digit,"AA");  
//
      for   (i=0;i<n;i++)   
      {   
          digit[0]   =   data[i*2];   
          digit[1]   =   data[i*2+1];   
          sscanf(digit,"%x",&hex);
		  printf("%d\n",hex);
          seed[i]   =  hex;   
		  printf("%c\n",seed[i]);
      }  */


         
   

 //     rd = fread(buf,1,buf_size,stdin);   

/*      while   (rd>0)   
      {   
          rc4(buf,rd,&key);   
          fwrite(buf,1,rd,stdout);   
          rd   =   fread(buf,1,buf_size,stdin);   
      }*/   

	  return 1;
  }