コード例 #1
0
ファイル: des.c プロジェクト: theflyfish/stb-network-upgrade
/*解密单个分组*/
int DES_DecryptBlock(ElemType cipherBlock[8], ElemType subKeys[16][48],ElemType plainBlock[8]){
 ElemType cipherBits[64];
 ElemType copyRight[48];
 int cnt;
  
 Char8ToBit64(cipherBlock,cipherBits); 
 /*初始置换(IP置换)*/
 DES_IP_Transform(cipherBits);
 
 /*16轮迭代*/
 for(cnt = 15; cnt >= 0; cnt--){
  memcpy(copyRight,cipherBits+32,32);
  /*将右半部分进行扩展置换,从32位扩展到48位*/
  DES_E_Transform(copyRight);
  /*将右半部分与子密钥进行异或操作*/
  DES_XOR(copyRight,subKeys[cnt],48);  
  /*异或结果进入S盒,输出32位结果*/
  DES_SBOX(copyRight);
  /*P置换*/
  DES_P_Transform(copyRight);  
  /*将明文左半部分与右半部分进行异或*/
  DES_XOR(cipherBits,copyRight,32);
  if(cnt != 0){
/*最终完成左右部的交换*/
DES_Swap(cipherBits,cipherBits+32);
  }
 }
 /*逆初始置换(IP^1置换)*/
 DES_IP_1_Transform(cipherBits);
 Bit64ToChar8(cipherBits,plainBlock);
 return 0;
}
コード例 #2
0
// 解密单个分组
unsigned char DES_DecryptBlock(unsigned char cipherBlock[8], unsigned char subKeys[16][48],unsigned char plainBlock[8])
{
    unsigned char cipherBits[64];
    unsigned char copyRight[48];
    short cnt;
    Char8ToBit64(cipherBlock,cipherBits);       
    //初始置换(IP置换)
    DES_IP_Transform(cipherBits);
    // 16轮迭代 
    for(cnt = 15; cnt >= 0; cnt--)
	{       
        memcpy(copyRight,cipherBits+32,32);
        //将右半部分进行扩展置换,从32位扩展到48位 
        DES_E_Transform(copyRight);
        // 将右半部分与子密钥进行异或操作 
        DES_XOR(copyRight,subKeys[cnt],48);       
        //异或结果进入S盒,输出32位结果 
        DES_SBOX(copyRight);
        // P置换 
        DES_P_Transform(copyRight);       
        //将明文左半部分与右半部分进行异或 
        DES_XOR(cipherBits,copyRight,32);
        if(cnt != 0)
		{
            // 最终完成左右部的交换
            DES_Swap(cipherBits,cipherBits+32);
        }
    }
    // 逆初始置换(IP^1置换)
    DES_IP_1_Transform(cipherBits);
    Bit64ToChar8(cipherBits,plainBlock);
    return 0;
}
コード例 #3
0
ファイル: des.cpp プロジェクト: yzmin/Des
//加密单个分组  
int DES_EncryptBlock(ElemType plainBlock[8], ElemType subKeys[16][48], ElemType cipherBlock[8]){  
	ElemType plainBits[64];  
	ElemType copyRight[48];  
	int cnt;  

	Char8ToBit64(plainBlock,plainBits);       
	//初始置换(IP置换)  
	DES_IP_Transform(plainBits);  

	//16轮迭代  
	for(cnt = 0; cnt < 16; cnt++){         
		memcpy(copyRight,plainBits+32,32);  
		//将右半部分进行扩展置换,从32位扩展到48位  
		DES_E_Transform(copyRight);  
		//将右半部分与子密钥进行异或操作  
		DES_XOR(copyRight,subKeys[cnt],48);   
		//异或结果进入S盒,输出32位结果  
		DES_SBOX(copyRight);  
		//P置换  
		DES_P_Transform(copyRight);  
		//将明文左半部分与右半部分进行异或  
		DES_XOR(plainBits,copyRight,32);  
		if(cnt != 15){  
			//最终完成左右部的交换  
			DES_Swap(plainBits,plainBits+32);  
		}  
	}  
	//逆初始置换(IP^1置换)  
	DES_IP_1_Transform(plainBits);  
	Bit64ToChar8(plainBits,cipherBlock);  
	return 0;  
}  
コード例 #4
0
unsigned char DES_EncryptBlock(unsigned char plainBlock[8], unsigned char subKeys[16][48], unsigned char cipherBlock[8])
{
    unsigned char plainBits[64];
    unsigned char copyRight[48];
    unsigned char cnt;
    Char8ToBit64(plainBlock,plainBits);       
    //初始置换(IP置换) 
    DES_IP_Transform(plainBits);
    // 16轮迭代 
    for(cnt = 0; cnt < 16; cnt++)
	{       
        memcpy(copyRight,plainBits+32,32);
        DES_E_Transform(copyRight);			// 将右半部分进行扩展置换,从32位扩展到48位
        DES_XOR(copyRight,subKeys[cnt],48);	// 将右半部分与子密钥进行异或操作 
        DES_SBOX(copyRight);				// 异或结果进入S盒,输出32位结果 
        DES_P_Transform(copyRight);			// P置换
        DES_XOR(plainBits,copyRight,32);	//将明文左半部分与右半部分进行异或 
        if(cnt != 15)
		{
            DES_Swap(plainBits,plainBits+32);//最终完成左右部的交换 
        }
    }
    DES_IP_1_Transform(plainBits);			//逆初始置换(IP^1置换)
    Bit64ToChar8(plainBits,cipherBlock);
    return 0;
}
コード例 #5
0
ファイル: des.cpp プロジェクト: yzmin/Des
//解密文件 
int DES_Decrypt(char *cipherFile, char *keyStr,char *plainFile)
{  
	FILE *plain, *cipher;  
	int count,times = 0;  
	long fileLen;  
	ElemType plainBlock[8],cipherBlock[8],keyBlock[8];  
	ElemType bKey[64];  
	ElemType subKeys[16][48];  
	if((cipher = fopen(cipherFile,"rb")) == NULL){  
		return CIPHER_FILE_OPEN_ERROR;  
	}  
	if((plain = fopen(plainFile,"wb")) == NULL){  
		return PLAIN_FILE_OPEN_ERROR;  
	}  

	//设置密钥  
	memcpy(keyBlock,keyStr,8);  
	//将密钥转换为二进制流  
	Char8ToBit64(keyBlock,bKey);  
	//生成子密钥  
	DES_MakeSubKeys(bKey,subKeys);  

	//取文件长度   
	fseek(cipher,0,SEEK_END);   //将文件指针置尾  
	fileLen = ftell(cipher);    //取文件指针当前位置  
	rewind(cipher);             //将文件指针重指向文件头  
	while(1){  
		//密文的字节数一定是8的整数倍  
		fread(cipherBlock,sizeof(char),8,cipher);  
		DES_DecryptBlock(cipherBlock,subKeys,plainBlock);                         
		times += 8;  
		if(times < fileLen){  
			fwrite(plainBlock,sizeof(char),8,plain);  
		}  
		else{  
			break;  
		}  
	}  
	//判断末尾是否被填充  
	if(plainBlock[7] < 8){  
		for(count = 8 - plainBlock[7]; count < 7; count++){  
			if(plainBlock[count] != '\0'){  
				break;  
			}  
		}  
	}     
	if(count == 7){//有填充  
		fwrite(plainBlock,sizeof(char),8 - plainBlock[7],plain);  
	}  
	else{//无填充  
		fwrite(plainBlock,sizeof(char),8,plain);  
	}  

	fclose(plain);  
	fclose(cipher);  
	return OK;  
}  
コード例 #6
0
ファイル: des.cpp プロジェクト: yzmin/Des
//str —> file 加密
int DES_Encrypt_str_to_file(char *source, char *keyStr,char *cipherFile)
{
	int cipher;
	int count = strlen(source);
	printf("count = %d\n",count);
	int times = 0;
	ElemType plainBlock[8],cipherBlock[8],keyBlock[8];
	ElemType bKey[64];  
	ElemType subKeys[16][48]; 

	if((cipher = open(cipherFile,O_CREAT | O_RDWR,0660)) < 0)
	{
		return CIPHER_FILE_OPEN_ERROR; 
	}

	//设置密钥
	memcpy(keyBlock,keyStr,8);  
	//将密钥转换为二进制流
	Char8ToBit64(keyBlock,bKey);  
	//生成子密钥
	DES_MakeSubKeys(bKey,subKeys);

	//加密8个字节
	while(1)
	{
		memcpy(plainBlock,source+times,8); 
		printf("%s\n",plainBlock);
		count -= 8;
		printf("count = %d\n",count);

		DES_EncryptBlock(plainBlock,subKeys,cipherBlock);
		write(cipher,cipherBlock,sizeof(cipherBlock));
		printf("cipherBlock = %s\n",cipherBlock);
		times += 8;
		if(count < 8)
			break;
	}

	if(count){ 
		printf("if times = %d\n",times);
		printf("if count = %d\n",count);
		//填充 
		memset(plainBlock,'\0',8);
		memcpy(plainBlock,source + times ,count);
		printf("if = %s\n",plainBlock);

		//最后一个字符保存包括最后一个字符在内的所填充的字符数量  
		plainBlock[7] = 8 - count;
		DES_EncryptBlock(plainBlock,subKeys,cipherBlock);
		write(cipher,cipherBlock,sizeof(cipherBlock));
		printf("if cipherBlock = %s\n",cipherBlock);
	}  

	close(cipher);
	return OK;

}
コード例 #7
0
ファイル: des.cpp プロジェクト: yzmin/Des
//解析文件成字符串
//file -> str
int DES_Decrypt_file_to_str(char *cipherFile, char *keyStr,char *result)
{ 
	int cipher; 
	int count,times = 0;  
	long fileLen;  
	ElemType plainBlock[8],cipherBlock[8],keyBlock[8];  
	ElemType bKey[64];  
	ElemType subKeys[16][48];  
	if((cipher = open(cipherFile,O_RDONLY)) < 0){  
		return CIPHER_FILE_OPEN_ERROR;  
	}  
	printf("cipher = %d\n",cipher);
	//设置密钥  
	memcpy(keyBlock,keyStr,8);  
	//将密钥转换为二进制流  
	Char8ToBit64(keyBlock,bKey);  
	//生成子密钥  
	DES_MakeSubKeys(bKey,subKeys);  

	//取文件长度   
	fileLen = lseek(cipher,0,SEEK_END);   //将文件指针置尾  取文件指针当前位置 
	lseek(cipher,0,SEEK_SET);             //将文件指针重指向文件头

	while(1){  
		//密文的字节数一定是8的整数倍  
		read(cipher,cipherBlock,sizeof(cipherBlock));  
		DES_DecryptBlock(cipherBlock,subKeys,plainBlock);                         

		if(times < fileLen){  
			memcpy(result + times,plainBlock,8); 
			times += 8; 
			//printf("result = %s\n",result);			  
		}  
		else{  
			break;  
		}  
	}  

	//判断末尾是否被填充  
	if(plainBlock[7] < 8){  
		for(count = 8 - plainBlock[7]; count < 7; count++){  
			if(plainBlock[count] != '\0'){  
				break;  
			}  
		}  
	}     
	if(count == 7){//有填充  
		memcpy(result + times,plainBlock,8 - plainBlock[7]);  
	}  
	else{//无填充  
		memcpy(result + times,plainBlock,8);  
	}  

	close(cipher);  
	return OK;
}
コード例 #8
0
//加密文件
unsigned char DES_Encrypt(unsigned char *keyStr,unsigned char *plainFile,unsigned char *cipherFile)
{
    unsigned char keyBlock[8],bKey[64],subKeys[16][48];

    memcpy(keyBlock,keyStr,8);							 //设置密钥
    Char8ToBit64(keyBlock,bKey);						 //将密钥转换为二进制流
    DES_MakeSubKeys(bKey,subKeys);						 //生成子密钥

	DES_EncryptBlock(plainFile,subKeys,cipherFile);  	
	return 1;
}
コード例 #9
0
ファイル: qdes.cpp プロジェクト: mildrock/dummy
/*
 *功能说明:DES算法解密函数
 *入口参数:key:密钥,长度为8字节
 *s_text:待解密的密文,长度为8字节;
 *d_text:解密得到的明文,长度为8字节。
 */
int _QDES(char *key, char *s_text, char *d_text)
{
	char plainBlock[8];
	char cipherBlock[8];
	char keyBlock[8];

	char bKey[64];
	char subKeys[16][48];
	memcpy(keyBlock, key, 8); //设置密钥
	Char8ToBit64(keyBlock, bKey); //将密钥转换为二进制流
	DES_MakeSubKeys(bKey, subKeys); //生成子密钥
	memcpy(cipherBlock, s_text, 8);

	char cipherBits[64];
	char copyRight[48];
	int cnt;
	Char8ToBit64(cipherBlock, cipherBits);
	DES_IP_Transform(cipherBits); //初始置换(IP置换)
	for (cnt = 15; cnt >= 0; cnt--) //16轮迭代
	{
		memset(copyRight, 0, 48);
		memcpy(copyRight, cipherBits + 32, 32);
		DES_E_Transform(copyRight); //将右半部分进行扩展置换,从32位扩展到48位
		DES_XOR(copyRight, subKeys[cnt], 48); //将右半部分与子密钥进行异或操作
		DES_SBOX(copyRight); //异或结果进入S盒,输出32位结果
		DES_P_Transform(copyRight); //P置换
		DES_XOR(cipherBits, copyRight, 32); //将明文左半部分与右半部分进行异或
		if (cnt != 0)
		{
			DES_Swap(cipherBits, cipherBits + 32); //最终完成左右部的交换
		}
	}
	DES_IP_1_Transform(cipherBits); //逆初始置换(IP^1置换)
	Bit64ToChar8(cipherBits, plainBlock);
	memcpy(d_text, plainBlock, 8);
	return 0;
}
コード例 #10
0
ファイル: des.c プロジェクト: theflyfish/stb-network-upgrade
/**************************对文件进行加密*****************************/
int DES_Encrypt(char *plainFile, char *keyStr,char *cipherFile)
{
 FILE *plain,*cipher;
 int count,num=0;
 ElemType plainBlock[8],cipherBlock[8],keyBlock[8];
 ElemType bKey[64];
 ElemType subKeys[16][48];
 if((plain = fopen(plainFile,"rb")) == NULL){
  return PLAIN_FILE_OPEN_ERROR;
 }
 if((cipher = fopen(cipherFile,"wb")) == NULL){
  return CIPHER_FILE_OPEN_ERROR;
 }
 /*设置密钥*/
 memcpy(keyBlock,keyStr,8);
 /*将密钥转换为二进制流*/
 Char8ToBit64(keyBlock,bKey);
 /*生成子密钥*/
 DES_MakeSubKeys(bKey,subKeys);
 
 while(!feof(plain))
 {
  /*每次读8个字节,并返回成功读取的字节数*/
  if((count = fread(plainBlock,sizeof(char),8,plain)) == 8)
  {
	num+=count;
	DES_EncryptBlock(plainBlock,subKeys,cipherBlock);
	fwrite(cipherBlock,sizeof(char),8,cipher);  
  }
 }

 if(count)
 {
   num+=count;
  /*填充*/
  memset(plainBlock + count,'\0',7 - count);
  /*最后一个字符保存包括最后一个字符在内的所填充的字符数量*/
  plainBlock[7] = 8 - count;
  DES_EncryptBlock(plainBlock,subKeys,cipherBlock);
  fwrite(cipherBlock,sizeof(char),8,cipher);
 }
 fclose(plain);
 fclose(cipher);
 printf("Plain File Length is %d\n",num);
 return OK;
}
コード例 #11
0
ファイル: des_encrypt.cpp プロジェクト: seraph1188/darcoin
 //加密文件   
 int DES_Encrypt(const char *pSrcData,int &nLen,const char *keyStr,char *pDesData){

     int count;   
     ElemType plainBlock[8],cipherBlock[8],keyBlock[8];   
     ElemType bKey[64];   
     ElemType subKeys[16][48];   

     //设置密钥   
     memcpy(keyBlock,keyStr,8);   
     //将密钥转换为二进制流   
     Char8ToBit64(keyBlock,bKey);   
     //生成子密钥   
     DES_MakeSubKeys(bKey,subKeys);   
        
	 int  nRead = 0;
	 while(nRead < nLen)
	 {
		 if(nLen - nRead>=8)
		 {
			 count = 8;
			 memcpy(plainBlock,pSrcData+nRead,count);
			//每次读8个字节,并返回成功读取的字节数   
			 DES_EncryptBlock(plainBlock,subKeys,cipherBlock);   
			 memcpy(pDesData+nRead,cipherBlock,8); 

		 }else
		 {
			 count = nLen - nRead;
			 memcpy(plainBlock,pSrcData+nRead,count);
		          //填充   
			 memset(plainBlock + count,'\0',7 - count);   
             //最后一个字符保存包括最后一个字符在内的所填充的字符数量   
             plainBlock[7] = 8 - count;   
             DES_EncryptBlock(plainBlock,subKeys,cipherBlock);   
			 memcpy(pDesData+nRead,cipherBlock,8); 
		 }
		 nRead += count;
     }
	 nLen = (nLen+7)&0xfffffff8;
     return OK;   
 }   
コード例 #12
0
ファイル: des.cpp プロジェクト: yzmin/Des
//加密文件  
int DES_Encrypt(char *plainFile, char *keyStr,char *cipherFile)
{  
	FILE *plain,*cipher;  
	int count;  
	ElemType plainBlock[8],cipherBlock[8],keyBlock[8];  
	ElemType bKey[64];  
	ElemType subKeys[16][48];  
	if((plain = fopen(plainFile,"rb")) == NULL){  
		return PLAIN_FILE_OPEN_ERROR;  
	}     
	if((cipher = fopen(cipherFile,"wb")) == NULL){  
		return CIPHER_FILE_OPEN_ERROR;  
	}  
	//设置密钥  
	memcpy(keyBlock,keyStr,8);  
	//将密钥转换为二进制流  
	Char8ToBit64(keyBlock,bKey);  
	//生成子密钥  
	DES_MakeSubKeys(bKey,subKeys);  

	while(!feof(plain)){  
		//每次读8个字节,并返回成功读取的字节数  
		if((count = fread(plainBlock,sizeof(char),8,plain)) == 8){  
			DES_EncryptBlock(plainBlock,subKeys,cipherBlock);  
			fwrite(cipherBlock,sizeof(char),8,cipher);    
		}  
	}  
	if(count){  
		//填充  
		memset(plainBlock + count,'\0',7 - count);  
		//最后一个字符保存包括最后一个字符在内的所填充的字符数量  
		plainBlock[7] = 8 - count;  
		DES_EncryptBlock(plainBlock,subKeys,cipherBlock);  
		fwrite(cipherBlock,sizeof(char),8,cipher);  
	}  
	fclose(plain);  
	fclose(cipher);  
	return OK;  
}  
コード例 #13
0
ファイル: des_encrypt.cpp プロジェクト: seraph1188/darcoin
 //解密文件   
 int DES_Decrypt(const char *pSrcData, int &nLen, const char *keyStr,char *pDesData){
 
     int count,times = 0;    
     ElemType plainBlock[8],cipherBlock[8],keyBlock[8];   
     ElemType bKey[64];   
     ElemType subKeys[16][48];   
  
    
     //设置密钥   
     memcpy(keyBlock,keyStr,8);   
     //将密钥转换为二进制流   
     Char8ToBit64(keyBlock,bKey);   
     //生成子密钥   
     DES_MakeSubKeys(bKey,subKeys);   
    
     while(times<nLen){   
         //密文的字节数一定是8的整数倍   
         memcpy(cipherBlock,pSrcData+times,8);
         DES_DecryptBlock(cipherBlock,subKeys,plainBlock);
         memcpy(pDesData+times,plainBlock,8);
         times += 8;   
     }   
     //判断末尾是否被填充   
     if(plainBlock[7] < 8){   
         for(count = 8 - plainBlock[7]; count < 7; count++){   
             if(plainBlock[count] != '\0'){   
                 break;   
             }   
         }   
     }      
     if(count == 7){//有填充   
         times = times -  plainBlock[7];
     }   
     nLen = times;
     return OK;   
 }   
コード例 #14
0
ファイル: des.c プロジェクト: theflyfish/stb-network-upgrade
/*解密文件 author by yx */
int DES_Decrypt(unsigned char *cipherbuf,unsigned char *keyStr,unsigned char *plainbuf, unsigned long  Num_len)
{
 
 long fileLen;
 ElemType plainBlock[8],cipherBlock[8],keyBlock[8];
 ElemType bKey[64];
 ElemType subKeys[16][48];
 int count,times = 0;
 unsigned char *TempBufIn=NULL;
 unsigned char *TempBufOut=NULL;

 if(cipherbuf == NULL||keyStr==NULL||plainbuf==NULL||Num_len==0) 
 	return -1;
  TempBufIn=cipherbuf;
  TempBufOut=plainbuf;
 /*设置密钥*/
 memcpy(keyBlock,keyStr,8);
 /*将密钥转换为二进制流*/
 Char8ToBit64(keyBlock,bKey);
 /*生成子密钥*/
 DES_MakeSubKeys(bKey,subKeys);
  
 while(1)
 {
  /*密文的字节数一定是8的整数倍*/
  memset(cipherBlock,0,8);
  memset(plainBlock,0,8);
  //读取缓冲区数据
  memcpy(cipherBlock,TempBufIn,8);
  TempBufIn+=8;
  DES_DecryptBlock(cipherBlock,subKeys,plainBlock);  
  times += 8;
  if(times < Num_len)
  {
  //将解密后的数据写回缓冲区;
   memset(TempBufOut,0,8);
   memcpy(TempBufOut,plainBlock,8);
   TempBufOut+=8;
  }
  else
  	{
     break;
  }
 }
 /*判断末尾是否被填充*/
 if(plainBlock[7] < 8)
 {
  	for(count = 8 - plainBlock[7]; count < 7; count++)
  	{
		if(plainBlock[count] != '\0')
		{
 			break;
		}
   }
 }
 if(count == 7)
 	{/*有填充*/
 	
	   memset(TempBufOut,0,8);
       memcpy(TempBufOut,plainBlock,8 - plainBlock[7]);
 	}
 else
 	{/*无填充*/
	   memset(TempBufOut,0,8);
       memcpy(TempBufOut,plainBlock,8);
	} 
 return OK;
}  
コード例 #15
0
ファイル: des.cpp プロジェクト: yzmin/Des
//加密字符串
int DES_Encrypt_str(char *source,char *keyStr,char *result)
{
	int count = 178;
	printf("count = %d\n",count);
	int times = 0;
	ElemType plainBlock[8],cipherBlock[8],keyBlock[8];
	ElemType bKey[64];  
	ElemType subKeys[16][48]; 

	//设置密钥
	memcpy(keyBlock,keyStr,8);  
	//将密钥转换为二进制流
	Char8ToBit64(keyBlock,bKey);  
	//生成子密钥
	DES_MakeSubKeys(bKey,subKeys);

	//加密8个字节
	while(1)
	{
		memcpy(plainBlock,source+times,8); 
		printf("%s\n",plainBlock);
		count -= 8;
		printf("count = %d\n",count);

		DES_EncryptBlock(plainBlock,subKeys,cipherBlock);
		for(int i = 0; i < 8;++i)
			printf("%x ",cipherBlock[i]);
		printf("\n");
		memcpy(result+times,cipherBlock,8);
		printf("result = %s\n",result);
		times += 8;
		if(count < 8)
			break;
	}

	if(count){ 
		printf("if times = %d\n",times);
		printf("if count = %d\n",count);
		//填充 
		memset(plainBlock,'\0',8);
		memcpy(plainBlock,source + times ,count);
		printf("plainBlock = ");
		for(int i = 0; i < 8;++i)
			printf("%x ",plainBlock[i]);
		printf("\n");

		//最后一个字符保存包括最后一个字符在内的所填充的字符数量  
		plainBlock[7] = 8 - count;
		DES_EncryptBlock(plainBlock,subKeys,cipherBlock);
		for(int i = 0; i < 8;++i)
			printf("%x ",cipherBlock[i]);
		printf("\n");
		memcpy(result+times,cipherBlock,8); 
		printf("if result = %s\n",result);
	}  

	for(int i = 0;i < 184;++i)
		printf("%x ",result[i]);
	printf("\n");

	return 0;
}
コード例 #16
0
ファイル: des.cpp プロジェクト: yzmin/Des
//字符串解密
int DES_Decrypt_str(char *source,char *keyStr,char *reslut)
{
	int count = 0,times = 0;  
	long fileLen = 178;
	printf("fileLen = %ld\n",fileLen);
	ElemType plainBlock[8],cipherBlock[8],keyBlock[8];  
	ElemType bKey[64];  
	ElemType subKeys[16][48]; 

	//设置密钥  
	memcpy(keyBlock,keyStr,8);  
	//将密钥转换为二进制流  
	Char8ToBit64(keyBlock,bKey);  
	//生成子密钥  
	DES_MakeSubKeys(bKey,subKeys);

	//加载解密数据
	while(times < fileLen){ 
		memset(cipherBlock,'\0',8);  
		memcpy(plainBlock,source+times,8);
		for(int i = 0;i<8;++i)
			printf("times = %d  cipherBlock[%d] = %x\n",times,i,plainBlock[i]);

		DES_DecryptBlock(plainBlock,subKeys,cipherBlock);		

		printf("times = %d cipherBlock = ",times);
		for(int i = 0; i < 8;++i)
			printf("%x ",cipherBlock[i]);
		printf("\n");

		memcpy(reslut+times,cipherBlock,8); 
		printf("reslut = %s\n",reslut);
		times += 8;
	}  

	printf("times = %d cipherBlock = ",times);
	for(int i = 0; i < 8;++i)
		printf("%x ",cipherBlock[i]);
	printf("\n");

	//判断末尾是否被填充  
	if(cipherBlock[7] < 8){  
		printf("for cipherBlock = %s\n",cipherBlock);
		printf("for count = %d\n",8 - cipherBlock[7]);
		for(count = 8 - cipherBlock[7]; count < 7; count++){  // 4 5 6 7
			if(cipherBlock[count] != '\0'){  
				break;  
			}  
		}  
	}  

	if(count == 7){//有填充  
		memcpy(reslut+times,cipherBlock,8 - cipherBlock[7]);  
		printf("if cipherBlock = %s\n",reslut+times);
	}  
	else{//无填充  
		memcpy(reslut+times,cipherBlock,8);   
		printf("else cipherBlock = %s\n",reslut+times);
	}
	printf("cipherBlock = %s\n",reslut);
	for(int i = 0; i < 184;++i)
		printf("%x ",reslut[i]);
	printf("\n");
	return 0;
}