程序博客网 > js模块化开发的好处

KeeLoq算法深入剖析

来源：互联网 发布：js模块化开发的好处 编辑：程序博客网 时间：2024/04/29 05:07

KeeLoq算法深入剖析

 

请支持原创，尊重原创，转载请注明出处：http://blog.csdn.net/kangweijian（来自kangweijian的csdn博客）

 

 

1       KeeLoq算法介绍

1.1  KeeLoq运算规则

        KeeLoq算法的核心思想就是用8byte密钥加密4byte明文，从而得到4byte密文或者用8byte密钥解密4byte密文，还原出原4byte明文。KeeLoq算法演算过程需要定义一个数据寄存器，用于存放4byte明文y31~0或者4byte密文y31~0，和一个密钥寄存器，用于存放8byte密钥k63~0。

        KeeLoq数据加密过程模型图如图1所示，首先定义一个非线性表，这个非线性表有5bits输入码，1bit输出码。它在数据寄存器中间隔均匀地取5bits: y31、y26、y20、y9、y1，通过NLF（Nonlinear Logic Function）运算产生一个输出码。输出码再与数据寄存器中的y16与y0以及密钥寄存器中的k0进行异或运算后生成1bit加密数据码。每生成1bit加密数据码，密钥寄存器和数据寄存器分别进行移位，密钥寄存器作循环移位，加密数据码作为数据寄存器移位的输入，重复上述步骤528次后，得到4byte的输出密文。

NLF(x4,x3,x2,x1,x0)=x4x3x2^x4x3x1^x4x2x0^x4x1x0^x4x2^x4x0^x3x2^x3x0^x2x1^x1x0^x1^x0


图1  KeeLoq加密模型图

        KeeLoq数据解密模型图如图2所示，其过程的运算方法与数据加密过程的运算方法基本一致，只是其中运算数据数据位发生变化。非线性表的5bits输入码改成从数据寄存器中间隔均匀地取固定5bits:y30、y25、y19、y8、y0。产生1bit输出码后输出码再与数据寄存器中的y31与y15以及密钥寄存器中的k15进行异或运算后生成1bit解密数据码。每输出1bit解密数据码后，密钥寄存器和数据寄存器分别进行移位，密钥寄存器作循环移位，解密数据码作为数据寄存器移位的输入，重复上述步骤528次后，还原出4byte的明文。


图2  KeeLoq解密模型图

1.2   KeeLoq实现机制

        采用KeeLoq方法实现数据编码和解码，其通信过程需严格按照下述过程进行。首先，要求编码端和解码端都需要有非易失性存储空间以存储8byte密钥(用于编解码，可编程且不被发送不可泄露)、3byte序列号(用于区分不同的编码端)、2byte同步计数值(用于产生编码滚动效果，每完成一次数据传送后，其值自加1后更新)、1byte识别码（序列号的低1byte）和4byte种子码（安全模式下用来生成密钥）。

        当用户有按键操作时，KeeLoq编码端将1byte功能键、1byte识别码、2byte同步计数值组合成4byte明文，按照图1的NLF运算规则加密成4byte密文，再加上4byte固定码（3byte序列号、1byte功能键），组合成一组8byte的编码数据发送。由于每次发送过程，同步计数值自加1，使得每次发送的4byte密文都是惟一的、不规则的、且不重复，故称之为滚动码，可以有效的防止密码捕捉和密码拷贝。由于8byte的编码组合达到2^64=1.84*10^19，因而可以有效的防止密码扫描。

        解码端接收到8byte密文数据后，首先匹配编码端和解码段的3byte序列号一致后，按照图2的KeeLoq解码运算规则还原出4byte明文。再校验明文中的识别码以及功能键正确后，最后判断同步计数值是否合理增加。确认成功后根据功能键定义，控制相应执行机构动作。

2     KeeLoq算法不足与改进

2.1 KeeLoq算法的安全性与不足

        KeeLoq算法的NLF运算规则，使得一个很小的输入变化量，也会造成很大的输出变化量，产生的编码滚动效果。密码分析者就无法通过输入微小的变化来观察分析输出的变化，从而破解出密钥，使得KeeLoq算法具有安全性高特点。

        虽然KeeLoq算法发布于20世纪80年代，但直到2007年，Bogdanov才首次对KeeLoq算法进行攻击，他使用猜测-决定和滑动技术来完成攻击，攻击的时间复杂度为252，空间复杂度为16GB。在2008年，Courtois等人提出了4种滑动-代数攻击方法，其主要思想是利用KeeLoq算法连续64圈圈函数形成的置换和圈结构与随机置换圈结构的差异，先攻击密钥的前16bits，再攻击剩余的48bits。折合计算复杂性至少约为O(2^43)次加密。2010年，游建雄等人提出3 种不同采用面向字节的差分故障攻击方法，其中攻击效率最好的方法，恢复1 bit 密钥信息平均只需要0. 707617 个错误，恢复8byte的密钥只需要46个错误。

        虽然KeeLoq算法发布后至今已经取得很多有效的攻击，大大降低了计算时间复杂度，但是也增加了计算空间复杂度，并且需要一定数量的已知前提。导致在实际密码破解过程中难度系数高，故其安全性足以保证，在实际应用当中有着广泛应用。

2.2   KeeLoq算法的改进

         KeeLoq加密算法是4byte的分组密码，密钥长度较短，仅为8byte。算法发布至今已有相关文献报导取得有效攻击，针对这一现状及上述算法不足之处，为了进一步提高 KeeLoq算法安全性，本文分别对编解码过程及密钥管理进行改进。

2.2.1       编解码过程的改进

        首先，编解码过程借鉴了三重数据加密算法（3DES，Triple Data Encryption Algorithm），提出三重KeeLoq算法。即采用三个不同密钥分别对明文、第一次获得密文及第二次获得密文进行KeeLoq加密后，生成最终密文。解密过程则是，先用第三个密钥对最终密文解密得到第二次密文，用第二个密钥对第二次密文解密得到第一次密文，最后用第一个密钥对第一次密文解密得到原始明文。该过程是KeeLoq算法的一种更安全的变形，通过增加KeeLoq的密钥长度来提高针对KeeLoq攻击的时间复杂度和计算复杂度，以进一步提高其安全性。

2.2.2       KeeLoq密钥管理机制的改进

        以Microchip的KeeLoq密钥管理机制为例。Microchip定义了一套学习模式来管理密钥。学习模式目的是为了编码端与解码端进行配对。在学习过程中，首先按下学习按键之后，解码端解码密文后，校验功能键和识别码正确后，就将该编码端的同步计数值和序列号存到自身的非易失性存储空间，这样就表示学习成功。学习成功之后，编码端才能与解码端正常通信。

        Microchip总共提出了三种学习模式(密钥管理机制)。第一种：简易学习模式。简易学习模式无法修改密钥，一旦密钥泄露，后果无法挽回。

        第二种：标准学习模式。标准学习模式在学习过程中可同时按下全部或多个功能按钮，则该模式将原始密钥和编码端的序列号通过某种算法生成新的密钥，解码端接收到密文后，通过原始密钥解密不正确之后，就会尝试用原始密钥+序列号生成新的密钥来解密密文，一旦解密成功，解码端就会在自身的非易失性存储空间内将密钥更改掉。很明显，标准学习模式的安全性就比简易学习模式高了许多，原始密钥和序列号同时泄漏的难度明显比单单仅原始密钥泄漏的难度高了多。

        第三种：安全学习模式。安全学习模式比标准学习模式多了一个种子码，学习过程与标准模式差不多，差别仅在于标准模式生成新密钥的方式是：原始密钥+序列号。而安全学习模式是：原始密钥+种子码+序列号通过某种算法生成新的密钥。

        三种学习模式，其安全性一层比一层高。简易学习模式的安全性完全依赖于密钥不丢失，标准学习模式的安全性依赖于密钥和序列号不同时丢失，安全学习模式的安全性依赖于密钥、种子码和序列号不同时丢失。当然了生成新密钥的算法也不能丢失。

        说到这里，我们再说说密钥管理机制的改进，其实有很多种。比如我们可以有一个手动输入的种子码让其放于固定码中发送出去，这样就如我们QQ或者Google帐号被盗窃后，直接手动修改密码那般惬意。或者如果无法做到手动修改，我们可以做一个随机生成器，随机生成一个种子码，这样完全不必担心种子码在哪个环节会泄漏，因为我们自己都不知道种子码会是多少。总的来说，密钥管理机制的改进取决于KeeLoq算法的应用环境中，视具体情况而定。当然Microchip已经做的非常好了。但是凡事没有尽善尽美，哪怕我们可以做出一点点的进步。

       附KeeLoq算法源码

源码一：KeeLoq.c (32位处理器)

[cpp] view plaincopy
  1. #include<iostream>  
  2. #include<stdio.h>  
  3. using namespace std;  
  4. unsigned long long int SERX=0xefcdab2143658709;  
  5. unsigned long long int key=0xefcdab2143658709;  
  6. unsigned int HOPE;  
  7. unsigned int c=0;  
  8. int NLF[2][2][2][2][2];  
  9. int  getBit(unsigned long long int source,int n) {  
  10.     unsigned long long int temp0=((long long int) 1<<n);  
  11.     unsigned long long int temp1=source&temp0;  
  12.     if ( temp1 != 0) {  
  13.         return 1;  
  14.     }  
  15.     return 0;  
  16. }  
  17. void RrcHOPE(){  
  18.     if(c!=0){  
  19.         HOPE=(HOPE>>1)|0x80000000;  
  20.     }else{  
  21.         HOPE=(HOPE>>1)&0x7fffffff;   
  22.     }  
  23. }   
  24. void RlcHOPE(){  
  25.     if(c!=0){  
  26.         HOPE=(HOPE<<1)|1;  
  27.     }else{  
  28.         HOPE=(HOPE<<1)&0xFFFFFFFE;   
  29.     }  
  30. }   
  31.    
  32. void CRYPT() {  
  33.     //key=SERX;  
  34.     for (int i = 0; i < 528; i++) {  
  35.         int nlf=NLF[getBit(HOPE, 31)][getBit(HOPE, 26)][getBit(HOPE, 20)][getBit(HOPE, 9)][getBit(HOPE, 1)];  
  36.         int y16=getBit(HOPE, 16);  
  37.         int y0=getBit(HOPE, 0);  
  38.         int k=getBit(key, i%64);  
  39.         int result=nlf^y16^y0^k;  
  40.         if (result!=0) {  
  41.             c=1;  
  42.         }else {  
  43.             c=0;  
  44.         }  
  45.           
  46.         RrcHOPE();  
  47.     }  
  48. }  
  49.   
  50. void DECRYPT() {  
  51.     key=SERX;  
  52.     for (int i = 528; i >0; i--) {  
  53.         int nlf=NLF[getBit(HOPE, 30)][getBit(HOPE, 25)][getBit(HOPE, 19)][getBit(HOPE, 8)][getBit(HOPE, 0)];  
  54.         int y15=getBit(HOPE, 15);  
  55.         int y31=getBit(HOPE, 31);  
  56.         int k=getBit(key, (i-1)%64);  
  57.         int result=nlf^y15^y31^k;  
  58.         if (result!=0) {  
  59.             c=1;  
  60.         }else {  
  61.             c=0;  
  62.         }  
  63.         //printf("step %d : %x  %x %x %x %x %x\n",i,HOPE,nlf,y15,y31,k,result);   
  64.         RlcHOPE();  
  65.     }  
  66. }  
  67.   
  68. int main(){  
  69.     NLF[0][0][0][0][0]=0;  
  70.     NLF[0][0][0][0][1]=1;  
  71.     NLF[0][0][0][1][0]=1;  
  72.     NLF[0][0][0][1][1]=1;  
  73.     NLF[0][0][1][0][0]=0;  
  74.     NLF[0][0][1][0][1]=1;  
  75.     NLF[0][0][1][1][0]=0;  
  76.     NLF[0][0][1][1][1]=0;  
  77.       
  78.     NLF[0][1][0][0][0]=0;  
  79.     NLF[0][1][0][0][1]=0;  
  80.     NLF[0][1][0][1][0]=1;   
  81.     NLF[0][1][0][1][1]=0;  
  82.     NLF[0][1][1][0][0]=1;  
  83.     NLF[0][1][1][0][1]=1;  
  84.     NLF[0][1][1][1][0]=1;  
  85.     NLF[0][1][1][1][1]=0;  
  86.           
  87.     NLF[1][0][0][0][0]=0;  
  88.     NLF[1][0][0][0][1]=0;  
  89.     NLF[1][0][0][1][0]=1;   
  90.     NLF[1][0][0][1][1]=1;  
  91.     NLF[1][0][1][0][0]=1;  
  92.     NLF[1][0][1][0][1]=0;  
  93.     NLF[1][0][1][1][0]=1;  
  94.     NLF[1][0][1][1][1]=0;  
  95.           
  96.     NLF[1][1][0][0][0]=0;  
  97.     NLF[1][1][0][0][1]=1;  
  98.     NLF[1][1][0][1][0]=0;  
  99.     NLF[1][1][0][1][1]=1;  
  100.     NLF[1][1][1][0][0]=1;  
  101.     NLF[1][1][1][0][1]=1;  
  102.     NLF[1][1][1][1][0]=0;  
  103.     NLF[1][1][1][1][1]=0;  
  104.       
  105.     while(1){  
  106.         scanf("%x",&HOPE);  
  107.         CRYPT();  
  108.         printf("%x\n",HOPE);  
  109.         DECRYPT();  
  110.         printf("%x\n",HOPE);  
  111.       
  112.     }  
  113.     return 0;  
  114. }               

源码二：KeeLoq.h+KeeLoq.c(8位微机)

[cpp] view plaincopy
  1. unsigned char SERX[]={0XEF,0XCD,0XAB,0X21,0X43,0X65,0X87,0X09};    
  2. unsigned char key[]={0X09,0X87,0X65,0X43,0X21,0XAB,0XCD,0XEF};   
  3. unsigned char NLF[2][2][2][2][2];   
  4.   
  5. unsigned char getBit(unsigned char source[],int n);  
  6. unsigned char * RRC(unsigned char source[],char c,char n);  
  7. unsigned char * RLC(unsigned char source[],char c,char n);  
  8. unsigned char * CRYPT(unsigned char *source);  
  9. unsigned char *  DECRYPT(unsigned char *source);  
  10. void init();  

[cpp] view plaincopy
  1. #include<stdio.h>   
  2. #include"KeeLoq.h"  
  3.    
  4. /*****************************  
  5.  *  
  6.  * @param source 
  7.  * @param n 
  8.  * @return source的第n个位数  
  9.  *  
  10. ******************************/  
  11. unsigned char getBit(unsigned char source[],int n)  
  12. {  
  13.     unsigned char temp0=(unsigned char)1<<(n%8);   
  14.     unsigned char temp1=source[n/8]&temp0;   
  15.     if(temp1!=0)  
  16.     {  
  17.         return 1;  
  18.     }  
  19.     return 0;  
  20. }  
  21.   
  22. /*********************** 
  23.  * 
  24.  * @param source[] 
  25.  * @param c 进位标志位  
  26.  * @param n 数组长度  
  27.  * @return source数组带进位右移  
  28.  * 
  29. ***********************/  
  30. unsigned char * RRC(unsigned char source[],char c,char n)  
  31. {  
  32.     int i=0;  
  33.     unsigned char temp;   
  34.     for(i=n-1;i>=0;i--)  
  35.     {  
  36.         temp=source[i];    
  37.         if(c!=0){  
  38.             source[i]=(source[i]>>1)|0x80;  
  39.         }else{  
  40.             source[i]=(source[i]>>1)&0x7f;   
  41.         }  
  42.           
  43.         if(temp&0x01!=0){  
  44.             c=1;  
  45.         }else{  
  46.             c=0;  
  47.         }   
  48.     }    
  49.     return source;  
  50. }   
  51.   
  52. /********************************* 
  53.  * 
  54.  * @param source[] 
  55.  * @param c 进位标志位  
  56.  * @param n 数组长度  
  57.  * @return source数组带进位左移  
  58.  * 
  59. *********************************/  
  60. unsigned char * RLC(unsigned char source[],char c,char n)  
  61. {  
  62.     int i=0;  
  63.     unsigned char temp;  
  64.     for(i=0;i<n;i++)  
  65.     {   
  66.         temp=source[i];  
  67.         if(c!=0){  
  68.             source[i]=(source[i]<<1)|0x01;  
  69.         }else{  
  70.             source[i]=(source[i]<<1)&0xfe;   
  71.         }  
  72.           
  73.         if((temp&0x80)!=0){  
  74.             c=1;  
  75.         }else{  
  76.             c=0;  
  77.         }  
  78.     }   
  79.     return source;  
  80. }   
  81.   
  82. /************************************* 
  83.  * 
  84.  * @param source 
  85.  * @return source明文经过KeeLoq加密后的密文  
  86.  * 
  87. *************************************/  
  88. unsigned char * CRYPT(unsigned char *source)  
  89. {  
  90.     int i=0;  
  91.     unsigned char c=0;  
  92.     unsigned char nlf,y16,y0,k,result;   
  93.     init();   
  94.     for (i = 0; i < 528; i++)   
  95.     {    
  96.         nlf=NLF[getBit(source, 31)][getBit(source, 26)][getBit(source, 20)][getBit(source, 9)][getBit(source, 1)];   
  97.         y16=getBit(source, 16);  
  98.         y0=getBit(source, 0);  
  99.         k=getBit(key, i%64);  
  100.         result=nlf^y16^y0^k;  
  101.         if (result!=0) {  
  102.             c=1;  
  103.         }else {  
  104.             c=0;  
  105.         }  
  106.         source=RRC(source,c,4);   
  107.     }  
  108.     return source;  
  109. }  
  110.   
  111. /************************************* 
  112.  * 
  113.  * @param source 
  114.  * @return source密文经过KeeLoq解密后的明文  
  115.  * 
  116. *************************************/  
  117. unsigned char *  DECRYPT(unsigned char *source)  
  118. {  
  119.     int i=0;  
  120.     unsigned char c=0;  
  121.     unsigned char nlf,y15,y31,k,result;  
  122.     init();   
  123.     for (i = 528; i >0; i--)   
  124.     {   
  125.         nlf=NLF[getBit(source, 30)][getBit(source, 25)][getBit(source, 19)][getBit(source, 8)][getBit(source, 0)];  
  126.         y15=getBit(source, 15);  
  127.         y31=getBit(source, 31);  
  128.         k=getBit(key, (i-1)%64);  
  129.         result=nlf^y15^y31^k;  
  130.         if (result!=0) {  
  131.             c=1;  
  132.         }else {  
  133.             c=0;  
  134.         }   
  135.         source=RLC(source,c,4);    
  136.     }  
  137.     return source;  
  138. }  
  139.   
  140. /************************************* 
  141.  * 
  142.  *  初始化非线性逻辑函数的值  
  143.  * 
  144. *************************************/  
  145. void init()  
  146. {  
  147.     NLF[0][0][0][0][0]=0;  
  148.     NLF[0][0][0][0][1]=1;  
  149.     NLF[0][0][0][1][0]=1;  
  150.     NLF[0][0][0][1][1]=1;  
  151.     NLF[0][0][1][0][0]=0;  
  152.     NLF[0][0][1][0][1]=1;  
  153.     NLF[0][0][1][1][0]=0;  
  154.     NLF[0][0][1][1][1]=0;  
  155.       
  156.     NLF[0][1][0][0][0]=0;  
  157.     NLF[0][1][0][0][1]=0;  
  158.     NLF[0][1][0][1][0]=1;   
  159.     NLF[0][1][0][1][1]=0;  
  160.     NLF[0][1][1][0][0]=1;  
  161.     NLF[0][1][1][0][1]=1;  
  162.     NLF[0][1][1][1][0]=1;  
  163.     NLF[0][1][1][1][1]=0;  
  164.           
  165.     NLF[1][0][0][0][0]=0;  
  166.     NLF[1][0][0][0][1]=0;  
  167.     NLF[1][0][0][1][0]=1;   
  168.     NLF[1][0][0][1][1]=1;  
  169.     NLF[1][0][1][0][0]=1;  
  170.     NLF[1][0][1][0][1]=0;  
  171.     NLF[1][0][1][1][0]=1;  
  172.     NLF[1][0][1][1][1]=0;  
  173.           
  174.     NLF[1][1][0][0][0]=0;  
  175.     NLF[1][1][0][0][1]=1;  
  176.     NLF[1][1][0][1][0]=0;  
  177.     NLF[1][1][0][1][1]=1;  
  178.     NLF[1][1][1][0][0]=1;  
  179.     NLF[1][1][1][0][1]=1;  
  180.     NLF[1][1][1][1][0]=0;  
  181.     NLF[1][1][1][1][1]=0;   
  182. }               
  183.   
  184. int main()  
  185. {  
  186.     unsigned char source[4];  
  187.     unsigned char *p;   
  188.     scanf("%c %c %c %c",&source[3],&source[2],&source[1],&source[0]);   
  189.       
  190.     p=source;  
  191.       
  192.     printf("%x %x %x %x\n",p[3],p[2],p[1],p[0]);    
  193.       
  194.     p=CRYPT(p);  
  195.       
  196.     printf("%x %x %x %x\n",p[3],p[2],p[1],p[0]);    
  197.       
  198.     p=DECRYPT(p);  
  199.       
  200.     printf("%x %x %x %x",p[3],p[2],p[1],p[0]);  
  201.       
  202.     return 0;  
  203. }  

源码三：KeeLoqCrypt.java

[java] view plaincopy
  1. import java.util.Scanner;  
  2.   
  3.   
  4. public class KeeLoqCrypt {  
  5.   
  6.     /** 
  7.      * @param args 
  8.      */  
  9.     private static long SERX=0xefcdab2143658709L;  
  10.     private static long key=0Xefcdab2143658709L;     
  11.     private static int NLF[][][][][]=new int[2][2][2][2][2];  
  12.       
  13.     /********* 
  14.      * 构造函数 
  15.      */  
  16.     KeeLoqCrypt(){  
  17.         NLF[0][0][0][0][0]=0;  
  18.         NLF[0][0][0][0][1]=1;  
  19.         NLF[0][0][0][1][0]=1;  
  20.         NLF[0][0][0][1][1]=1;  
  21.         NLF[0][0][1][0][0]=0;  
  22.         NLF[0][0][1][0][1]=1;  
  23.         NLF[0][0][1][1][0]=0;  
  24.         NLF[0][0][1][1][1]=0;  
  25.           
  26.         NLF[0][1][0][0][0]=0;  
  27.         NLF[0][1][0][0][1]=0;  
  28.         NLF[0][1][0][1][0]=1;   
  29.         NLF[0][1][0][1][1]=0;  
  30.         NLF[0][1][1][0][0]=1;  
  31.         NLF[0][1][1][0][1]=1;  
  32.         NLF[0][1][1][1][0]=1;  
  33.         NLF[0][1][1][1][1]=0;  
  34.               
  35.         NLF[1][0][0][0][0]=0;  
  36.         NLF[1][0][0][0][1]=0;  
  37.         NLF[1][0][0][1][0]=1;   
  38.         NLF[1][0][0][1][1]=1;  
  39.         NLF[1][0][1][0][0]=1;  
  40.         NLF[1][0][1][0][1]=0;  
  41.         NLF[1][0][1][1][0]=1;  
  42.         NLF[1][0][1][1][1]=0;  
  43.               
  44.         NLF[1][1][0][0][0]=0;  
  45.         NLF[1][1][0][0][1]=1;  
  46.         NLF[1][1][0][1][0]=0;  
  47.         NLF[1][1][0][1][1]=1;  
  48.         NLF[1][1][1][0][0]=1;  
  49.         NLF[1][1][1][0][1]=1;  
  50.         NLF[1][1][1][1][0]=0;  
  51.         NLF[1][1][1][1][1]=0;   
  52.     }  
  53.       
  54.     /***************** 
  55.      *  
  56.      * @param source 
  57.      * @param n 
  58.      * @return source的第n个位数 
  59.      */  
  60.     private static int  getBit(long source,int n) {  
  61.         long temp0=((long) 1<<n);  
  62.         long temp1=source&temp0;  
  63.         if ( temp1 != 0) {  
  64.             return 1;  
  65.         }  
  66.         return 0;  
  67.     }  
  68.       
  69.     /**************** 
  70.      *  
  71.      * @param soucre 
  72.      * @param c 
  73.      * @return 带进位右移 
  74.      */  
  75.     private static int RRC(int soucre,int c){  
  76.         if(c!=0){  
  77.             soucre=(soucre>>1)|0x80000000;  
  78.         }else{  
  79.             soucre=(soucre>>1)&0x7fffffff;   
  80.         }  
  81.         return soucre;  
  82.     }   
  83.       
  84.     /******************** 
  85.      *  
  86.      * @param source 
  87.      * @param c 
  88.      * @return 带进位左移 
  89.      */  
  90.     private static int RLC(int source, int c){  
  91.         if(c!=0){  
  92.             source=(source<<1)|1;  
  93.         }else{  
  94.             source=(source<<1)&0xFFFFFFFE;   
  95.         }  
  96.         return source;  
  97.     }   
  98.        
  99.     /******************** 
  100.      *  
  101.      * @param source 
  102.      * @param key 
  103.      * @return source经过key密钥进行KeeLoq加密后的数据 
  104.      */  
  105.     private static int CRYPT(int source , long key) {  
  106.         long mKey=key;  
  107.         int c;  
  108.         for (int i = 0; i < 528; i++) {  
  109.             int nlf=NLF[getBit(source, 31)][getBit(source, 26)][getBit(source, 20)][getBit(source, 9)][getBit(source, 1)];  
  110.             int y16=getBit(source, 16);  
  111.             int y0=getBit(source, 0);  
  112.             int k=getBit(mKey, i%64);  
  113.             int result=nlf^y16^y0^k;  
  114.             if (result!=0) {  
  115.                 c=1;  
  116.             }else {  
  117.                 c=0;  
  118.             }  
  119.             source=RRC(source,c);  
  120.         }  
  121.         return source;  
  122.     }  
  123.    
  124.     /********************************* 
  125.      *  
  126.      * @param source 
  127.      * @param key 
  128.      * @return source经过key密钥进行KeeLoq解密后的数据 
  129.      */  
  130.     private static int DECRYPT(int source , long key) {  
  131.         long mkey=key;  
  132.         int c;  
  133.         for (int i = 528; i >0; i--) {  
  134.             int nlf=NLF[getBit(source, 30)][getBit(source, 25)][getBit(source, 19)][getBit(source, 8)][getBit(source, 0)];  
  135.             int y15=getBit(source, 15);  
  136.             int y31=getBit(source, 31);  
  137.             int k=getBit(mkey, (i-1)%64);  
  138.             int result=nlf^y15^y31^k;  
  139.             if (result!=0) {  
  140.                 c=1;  
  141.             }else {  
  142.                 c=0;  
  143.             }  
  144.             source=RLC(source,c);  
  145.         }  
  146.         return source;  
  147.     }  
  148.   
  149.       
  150.     public static void main(String[] args) {  
  151.         // TODO Auto-generated method stub  
  152.         NLF[0][0][0][0][0]=0;  
  153.         NLF[0][0][0][0][1]=1;  
  154.         NLF[0][0][0][1][0]=1;  
  155.         NLF[0][0][0][1][1]=1;  
  156.         NLF[0][0][1][0][0]=0;  
  157.         NLF[0][0][1][0][1]=1;  
  158.         NLF[0][0][1][1][0]=0;  
  159.         NLF[0][0][1][1][1]=0;  
  160.           
  161.         NLF[0][1][0][0][0]=0;  
  162.         NLF[0][1][0][0][1]=0;  
  163.         NLF[0][1][0][1][0]=1;   
  164.         NLF[0][1][0][1][1]=0;  
  165.         NLF[0][1][1][0][0]=1;  
  166.         NLF[0][1][1][0][1]=1;  
  167.         NLF[0][1][1][1][0]=1;  
  168.         NLF[0][1][1][1][1]=0;  
  169.               
  170.         NLF[1][0][0][0][0]=0;  
  171.         NLF[1][0][0][0][1]=0;  
  172.         NLF[1][0][0][1][0]=1;   
  173.         NLF[1][0][0][1][1]=1;  
  174.         NLF[1][0][1][0][0]=1;  
  175.         NLF[1][0][1][0][1]=0;  
  176.         NLF[1][0][1][1][0]=1;  
  177.         NLF[1][0][1][1][1]=0;  
  178.               
  179.         NLF[1][1][0][0][0]=0;  
  180.         NLF[1][1][0][0][1]=1;  
  181.         NLF[1][1][0][1][0]=0;  
  182.         NLF[1][1][0][1][1]=1;  
  183.         NLF[1][1][1][0][0]=1;  
  184.         NLF[1][1][1][0][1]=1;  
  185.         NLF[1][1][1][1][0]=0;  
  186.         NLF[1][1][1][1][1]=0;   
  187.           
  188.         Scanner mScanner=new Scanner(System.in);   
  189.         int HOPE=mScanner.nextInt(16);   
  190.         System.out.printf("%x\n",CRYPT(HOPE,key));   
  191.         System.out.printf("%x\n",DECRYPT(CRYPT(HOPE,key),key));  
  192.         System.out.printf("%x\n",getBit(HOPE,1));   
  193.     }  
  194.   
  195. }  


 

 

请支持原创，尊重原创，转载请注明出处：http://blog.csdn.net/kangweijian（来自kangweijian的csdn博客）

0 0
js模块化开发的好处 js模块化开发的好处
原创粉丝点击
热门IT博客
dota2大神知乎dota2大神知乎
淘宝优惠券图片怎么做淘宝优惠券图片怎么做
淘宝助理老版本
安卓让软件防止卸载
广州市最新的json文件
道教里的仙人 知乎
淘宝企业店如何避税
sas软件有用吗
华讯网络和华讯网存
手机淘宝登录首页
淘宝直播怎么弄
去日本带mac好吗
网络互动平台骗局
农村淘宝宣传视频下载
算法概论 pdf
ecs windows 开启ftp
淘宝上哪家笛子好
广电总局禁止网络电视
微商版微信是什么软件
淘宝怎么可以买到弩
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 澳洲灵缇犬 灵缇犬好养吗 如何训练灵缇犬 灵缇犬价钱 灵缇犬驱虫 灵缇犬吃什么 灵缇犬皮肤病 灵缇犬和格力犬 灵缇犬和格力犬的区别 灵罗戒第二部 灵罗戒txt免费下载 灵罗戒xiazai 灵罗戒txt全集下载 羽林灵作品 痴心缭乱 羽林灵 意外 羽林灵 我们是邻居 羽林灵 灵翼龙卵插件 猎能者猎能学院 猎能者 能者多劳 猎能者2鲲鹏传说 能者上平者让庸者下 能者居之 能者多劳是不是坑 猎能者全文免费阅读 猎能者1猎能学院 能者多劳是什么意思啊 一句话反驳能者多劳 无能者无所求 能者为师的意思 能者多劳下一句是什么 猎能者2猎能学院全文阅 猎能者1猎能学院免费阅读 人之所不学而能者 制灵虫自 舞灵美娜子的自频道 灵舟全文阅读 灵芝椅 灵芝煲瘦肉 什么灵芝

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里