Java xxtea加密算法

最近在修改我的俄罗斯方块的同时,又添加了一个显示并记录最好成绩的功能,需要将信息加密/解密,存入文件/读取文件,在我下铺(牛人啊!)的指点下,采用了TEA加密算法.
     
         这个算法简单,而且效率高,每次可以操作8个字节的数据,加密解密的KEY为16字节,即包含4个int数据的int型数组,加密轮数应为8的倍数,一般比较常用的轮数为64,32,16,推荐用64轮.
     
        源代码里 delta的值是算法标准给的,delta = (sqrt(5) - 1)/2 * 2^32,(sqrt(5) - 1)/2是黄金分割点的值.
sum是根据delta算出来的,sum = delta * times //times为加密轮数 

 源代码如下:
/** */ /**
 * Tea算法
 * 每次操作可以处理8个字节数据
 * KEY为16字节,应为包含4个int型数的int[],一个int为4个字节
 * 加密解密轮数应为8的倍数,推荐加密轮数为64轮
 * 
*/

public   class  Tea  {
    
private final static int[] KEY = new int[]{//加密解密所用的KEY
        0x789f56450xf68bd5a4,
        
0x81963ffa0x458fac58
    }
;
    
//加密
    public byte[] encrypt(byte[] content, int offset, int[] key, int times){//times为加密轮数
        int[] tempInt = byteToInt(content, offset);
        
int y = tempInt[0], z = tempInt[1], sum = 0, i;
        
int delta=0x9e3779b9//这是算法标准给的值
        int a = key[0], b = key[1], c = key[2], d = key[3]; 

        
for (i = 0; i < times; i++{   
            
            sum 
+= delta;
            y 
+= ((z<<4+ a) ^ (z + sum) ^ ((z>>5+ b);
            z 
+= ((y<<4+ c) ^ (y + sum) ^ ((y>>5+ d);
        }

        tempInt[
0]=y;
        tempInt[
1]=z; 
        
return intToByte(tempInt, 0);
    }

    
//解密
    public byte[] decrypt(byte[] encryptContent, int offset, int[] key, int times){
        
int[] tempInt = byteToInt(encryptContent, offset);
        
int y = tempInt[0], z = tempInt[1], sum = 0, i;
        
int delta=0x9e3779b9//这是算法标准给的值
        int a = key[0], b = key[1], c = key[2], d = key[3];
        
if (times == 32)
            sum 
= 0xC6EF3720/**//* delta << 5*/
        
else if (times == 16)
            sum 
= 0xE3779B90/**//* delta << 4*/
        
else
            sum 
= delta * times;

        
for(i = 0; i < times; i++
            z 
-= ((y<<4+ c) ^ (y + sum) ^ ((y>>5+ d);
            y 
-= ((z<<4+ a) ^ (z + sum) ^ ((z>>5+ b);
            sum 
-= delta; 
        }

        tempInt[
0= y;
        tempInt[
1= z;

        
return intToByte(tempInt, 0);
    }

    
//byte[]型数据转成int[]型数据
    private int[] byteToInt(byte[] content, int offset){

        
int[] result = new int[content.length >> 2];//除以2的n次方 == 右移n位 即 content.length / 4 == content.length >> 2
        for(int i = 0, j = offset; j < content.length; i++, j += 4){
            result[i] 
= transform(content[j + 3]) | transform(content[j + 2]) << 8 |
            transform(content[j 
+ 1]) << 16 | (int)content[j] << 24;
        }

        
return result;
        
    }

    
//int[]型数据转成byte[]型数据
    private byte[] intToByte(int[] content, int offset){
        
byte[] result = new byte[content.length << 2];//乘以2的n次方 == 左移n位 即 content.length * 4 == content.length << 2
        for(int i = 0, j = offset; j < result.length; i++, j += 4){
            result[j 
+ 3= (byte)(content[i] & 0xff);
            result[j 
+ 2= (byte)((content[i] >> 8& 0xff);
            result[j 
+ 1= (byte)((content[i] >> 16& 0xff);
            result[j] 
= (byte)((content[i] >> 24& 0xff);
        }

        
return result;
    }

    
//若某字节为负数则需将其转成无符号正数
    private static int transform(byte temp){
        
int tempInt = (int)temp;
        
if(tempInt < 0){
            tempInt 
+= 256;
        }

        
return tempInt;
    }

    
}

测试代码如下:
        
public   static   void  main(String[] args) {
        
        
int[] KEY = new int[]{//加密解密所用的KEY
                0x789f56450xf68bd5a4,
                
0x81963ffa0x458fac58
            }
;
        Tea tea 
= new Tea();
        
        
byte[] info = new byte[]{
                
                
1,2,3,4,5,6,7,8
        }
;
        System.out.print(
"原数据:");
        
for(byte i : info)
            System.out.print(i 
+ " ");
        System.out.println();
        
        
byte[] secretInfo = tea.encrypt(info, 0, KEY, 32);
        System.out.print(
"加密后的数据:");
        
for(byte i : secretInfo)
            System.out.print(i 
+ " ");
        System.out.println();
        
        
byte[] decryptInfo = tea.decrypt(secretInfo, 0, KEY, 32);
        System.out.print(
"解密后的数据:");
        
for(byte i : decryptInfo)
            System.out.print(i 
+ " ");
        
    }

输出结果如下:

原数据:1 2 3 4 5 6 7 8
加密后的数据:92 124 -3 -125 -115 82 21 28
解密后的数据:1 2 3 4 5 6 7 8 

        这只是一次加密解密操作,如果你想一次处理大于8个字节的数据,需要再封装一下.

封装后的代码如下:
// 通过TEA算法加密信息
     private   byte [] encryptByTea(String info) {
        
byte[] temp = info.getBytes();
        
int n = 8 - temp.length % 8;//若temp的位数不足8的倍数,需要填充的位数
        byte[] encryptStr = new byte[temp.length + n];
        encryptStr[
0= (byte)n;
        System.arraycopy(temp, 
0, encryptStr, n, temp.length);
        
byte[] result = new byte[encryptStr.length];
        
for(int offset = 0; offset < result.length; offset += 8){
            
byte[] tempEncrpt = tea.encrypt(encryptStr, offset, KEY, 32);
            System.arraycopy(tempEncrpt, 
0, result, offset, 8);
        }

        
return result;
    }

    
// 通过TEA算法解密信息
     private  String decryptByTea( byte [] secretInfo) {
        
byte[] decryptStr = null;
        
byte[] tempDecrypt = new byte[secretInfo.length];
        
for(int offset = 0; offset < secretInfo.length; offset += 8){
            decryptStr 
= tea.decrypt(secretInfo, offset, KEY, 32);
            System.arraycopy(decryptStr, 
0, tempDecrypt, offset, 8);
        }

        
        
int n = tempDecrypt[0];
        
return new String(tempDecrypt, n, decryptStr.length - n);
        
    }

测试代码如下:
public   static   void  main(String[] args) {
        String info 
= "www.blogjava.net/orangehf";
        System.out.println(
"原数据:" + info);
        
for(byte i : info.getBytes())
            System.out.print(i 
+ " ");
        
        SaveFileIO io 
= new SaveFileIO();
        
        
byte[] encryptInfo = io.encryptByTea(info);
        System.out.println();
        System.out.println(
"加密后的数据:");
        
for(byte i : encryptInfo)
            System.out.print(i 
+ " ");
        System.out.println();
        
        String decryptInfo 
= io.decryptByTea(encryptInfo);
        System.out.print(
"解密后的数据:");
        System.out.println(decryptInfo);
        
for(byte i : decryptInfo.getBytes())
            System.out.print(i 
+ " ");
        System.out.println();
        
    }


输出结果如下:
原数据:www.blogjava.net/orangehf
119 119 119 46 98 108 111 103 106 97 118 97 46 110 101 116 47 111 114 97 110 103 101 104 102
加密后的数据:
-123 7 -64 -33 -29 32 107 -17 89 78 -78 -11 -125 -12 -59 -2 49 -112 -122 -91 -102 118 114 -11 -24 39 113 -14 66 37 -2 114
解密后的数据:www.blogjava.net/orangehf
119 119 119 46 98 108 111 103 106 97 118 97 46 110 101 116 47 111 114 97 110 103 101 104 102

C++ xxtea加密算法地址:

http://www.cppblog.com/ant/archive/2007/08/31/31326.html

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值