cas.c

CAS的实现代码

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
 
void main()
{   void rands(unsigned char ,unsigned char);
    void create_ECM(unsigned char ,unsigned char);
	int des(unsigned char *source,unsigned char * dest,unsigned char * inkey, int flg);
    int i,j,k,flag;
    char source[9]="tjdxdxxy",key[8]="abababab",dest[9],source1[9];
    
	/*printf("please input source:\n");
	scanf("%s",source);

    printf("please input key[8]:\n");
	scanf("%s",key);

    printf("please input jiami 1 or jiemi 0:\n");
	scanf("%d",flag);*/
    
	


    des(source,dest,key,1);
	dest[8]='\0';

	printf("The encryption result:\n");
	printf("%s",dest);
    printf("\n");

    des(dest,source1,key,0);
	source1[8]='\0';

    printf("The decryption result:\n");
	printf("%s",source1);
    printf("\n");


	getchar();
    
    
    
    
    
  /*
	static long counter;
	FILE *fp,*fp1;
	unsigned char ch[188],ch1,CW[8];
	unsigned char ECM_KEY[8],EMM_KEY[8],SDK[4];
	rands(CW,ECM_KEY);
	create_ECM(CW,ECM_KEY);
	for(i=0;i<1000;i++)
	{ counter++;
	  if((fp=fopen("mpeg20.ts","rb"))==NULL)
	  {  printf("%d  can not open this file\n",i);
	     exit(0);
	  }
	  fseek(fp,188*i,0);	
	  fread(ch,188,1,fp);
	  
	  if(counter>100) 
	  {   counter=0;
		  rands(CW,ECM_KEY);
		  create_ECM(CW,ECM_KEY);

	         //此时需要更改ECM，此处缺少此函数  
	  }
	 
      if(ch[0]==0x47)             //ts流的开始
	  {  ch1=ch[1]&&0x1f;
	     if(!((((ch1<<8)-0x30)+(ch[2]-0x30))==0x0)) //判断是否是PID=0
		 {   
			 if(!((((ch1<<8)-0x30)+(ch[2]-0x30))==0x0))
			 {
				 if(!((((ch1<<8)-0x30)+(ch[2]-0x30))==0x0))
				 {  
					 for(j=4;j<188;j++)
					 {  ch[j]=(unsigned char)((int)ch[j]^(int)CW[j]); //按位异或，对payload进行加扰
					 }
				 }
			 }
		  
		 
		 }

	  } //end if(ch[0]==47h)

        fp1= fopen("out.ts","a");
	  fwrite(ch,188,1,fp1);
          fclose(fp1);
	  
	
		  
	  for(j=0;j<188;j++)
		  {  printf("%x  ",ch[j]); 
	         if(!(j%40))  printf("\n");
		  }
	  fclose(fp);
       
	}//end for(i=0;i<2;i++)
	*/
}


void rands(unsigned char *CW,unsigned char *ECM_KEY) //随机产生CW以及ECM_KEY
{  int i;
   

   /* Seed the random-number generator with current time so that
    * the numbers will be different every time we run.
    */
   srand( (unsigned)time( NULL ) );

   /* write to the CW and ECM_KEY */
   for( i = 0;   i < 8;i++ )
   
  
   {  CW[i]=rand();
      ECM_KEY[i]=rand();
	  printf("%2x  %2x\n",CW[i],ECM_KEY[i]);
   }
   
}
void create_ECM(unsigned char*CW ,unsigned char*ECM_KEY)//加密CW，并形成文件输出到硬盘
{  FILE *fp;
   unsigned char temp[8];
   des(CW,temp,ECM_KEY,1);
   if((fp=fopen("CW_out.ts","a"))==NULL) printf("open CW_out.ts error");
   fwrite(temp,1,8,fp);
   fclose(fp);
   
}


/* ================================================================ 
des() 
Description: DES algorithm,do encript or descript. 
================================================================ */ 
int des(unsigned char *source,unsigned char * dest,unsigned char * inkey, int flg) 
{                        //flg=1,加密；=0，解密
unsigned char bufout[64], 
kwork[56], worka[48], kn[48], buffer[64], key[64], 
nbrofshift, temp1, temp2; 
int valindex; 
register i, j, k, iter; 

/* INITIALIZE THE TABLES */ 
/* Table - s1 */ 
static unsigned char s1[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 }; 

/* Table - s2 */ 
static unsigned char s2[4][16] = { 
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 }; 

/* Table - s3 */ 
static unsigned char s3[4][16] = { 
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 }; 

/* Table - s4 */ 
static unsigned char s4[4][16] = { 
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 }; 

/* Table - s5 */ 
static unsigned char s5[4][16] = { 
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 }; 

/* Table - s6 */ 
static unsigned char s6[4][16] = { 
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 }; 

/* Table - s7 */ 
static unsigned char s7[4][16] = { 
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 }; 

/* Table - s8 */ 
static unsigned char s8[4][16] = { 
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 }; 


/* Table - Shift */ 
static unsigned char shift[16] = { 
1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1 }; 


/* Table - Binary */ 
static unsigned char binary[64] = { 
0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 
0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 
1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 
1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1 }; 

/* MAIN PROCESS */ 
/* Convert from 64-bit key into 64-byte key */ 
for (i = 0; i < 8; i++) 
	{key[8*i] = ((j = *(inkey + i)) / 128) % 2; 
         key[8*i+1] = (j / 64) % 2; 
         key[8*i+2] = (j / 32) % 2; 
         key[8*i+3] = (j / 16) % 2; 
         key[8*i+4] = (j / 8) % 2; 
         key[8*i+5] = (j / 4) % 2; 
         key[8*i+6] = (j / 2) % 2; 
         key[8*i+7] = j % 2; 
        } 

/* Convert from 64-bit data into 64-byte data */ 
for (i = 0; i < 8; i++) 
	{ buffer[8*i] = ((j = *(source + i)) / 128) % 2; 
         buffer[8*i+1] = (j / 64) % 2; 
         buffer[8*i+2] = (j / 32) % 2; 
         buffer[8*i+3] = (j / 16) % 2; 
         buffer[8*i+4] = (j / 8) % 2; 
         buffer[8*i+5] = (j / 4) % 2; 
         buffer[8*i+6] = (j / 2) % 2; 
         buffer[8*i+7] = j % 2; 
} 

/* Initial Permutation of Data */ 
bufout[ 0] = buffer[57]; 
bufout[ 1] = buffer[49]; 
bufout[ 2] = buffer[41]; 
bufout[ 3] = buffer[33]; 
bufout[ 4] = buffer[25]; 
bufout[ 5] = buffer[17]; 
bufout[ 6] = buffer[ 9]; 
bufout[ 7] = buffer[ 1]; 
bufout[ 8] = buffer[59]; 
bufout[ 9] = buffer[51]; 
bufout[10] = buffer[43]; 
bufout[11] = buffer[35]; 
bufout[12] = buffer[27]; 
bufout[13] = buffer[19]; 
bufout[14] = buffer[11]; 
bufout[15] = buffer[ 3]; 
bufout[16] = buffer[61]; 
bufout[17] = buffer[53]; 
bufout[18] = buffer[45]; 
bufout[19] = buffer[37]; 
bufout[20] = buffer[29]; 
bufout[21] = buffer[21]; 
bufout[22] = buffer[13]; 
bufout[23] = buffer[ 5]; 
bufout[24] = buffer[63]; 
bufout[25] = buffer[55]; 
bufout[26] = buffer[47]; 
bufout[27] = buffer[39]; 
bufout[28] = buffer[31]; 
bufout[29] = buffer[23]; 
bufout[30] = buffer[15]; 
bufout[31] = buffer[ 7]; 
bufout[32] = buffer[56]; 
bufout[33] = buffer[48]; 
bufout[34] = buffer[40]; 
bufout[35] = buffer[32]; 
bufout[36] = buffer[24]; 
bufout[37] = buffer[16]; 
bufout[38] = buffer[ 8]; 
bufout[39] = buffer[ 0]; 
bufout[40] = buffer[58]; 
bufout[41] = buffer[50]; 
bufout[42] = buffer[42]; 
bufout[43] = buffer[34]; 
bufout[44] = buffer[26]; 
bufout[45] = buffer[18]; 
bufout[46] = buffer[10]; 
bufout[47] = buffer[ 2]; 
bufout[48] = buffer[60]; 
bufout[49] = buffer[52]; 
bufout[50] = buffer[44]; 
bufout[51] = buffer[36]; 
bufout[52] = buffer[28]; 
bufout[53] = buffer[20]; 
bufout[54] = buffer[12]; 
bufout[55] = buffer[ 4]; 
bufout[56] = buffer[62]; 
bufout[57] = buffer[54]; 
bufout[58] = buffer[46]; 
bufout[59] = buffer[38]; 
bufout[60] = buffer[30]; 
bufout[61] = buffer[22]; 
bufout[62] = buffer[14]; 
bufout[63] = buffer[ 6]; 

/* Initial Permutation of Key */ 
kwork[ 0] = key[56]; 
kwork[ 1] = key[48]; 
kwork[ 2] = key[40]; 
kwork[ 3] = key[32]; 
kwork[ 4] = key[24]; 
kwork[ 5] = key[16]; 
kwork[ 6] = key[ 8]; 
kwork[ 7] = key[ 0]; 
kwork[ 8] = key[57]; 
kwork[ 9] = key[49]; 
kwork[10] = key[41]; 
kwork[11] = key[33]; 
kwork[12] = key[25]; 
kwork[13] = key[17]; 
kwork[14] = key[ 9]; 
kwork[15] = key[ 1]; 
kwork[16] = key[58]; 
kwork[17] = key[50]; 
kwork[18] = key[42]; 
kwork[19] = key[34]; 
kwork[20] = key[26]; 
kwork[21] = key[18]; 
kwork[22] = key[10]; 
kwork[23] = key[ 2]; 
kwork[24] = key[59]; 
kwork[25] = key[51]; 
kwork[26] = key[43]; 
kwork[27] = key[35]; 
kwork[28] = key[62]; 
kwork[29] = key[54]; 
kwork[30] = key[46];