My favorites | Sign in
Project Home Downloads Wiki Issues Source
READ-ONLY: This project has been archived. For more information see this post.
Search
for
xxtea  
微型可逆加密算法
Featured, Phase-Requirements, Phase-Design
Updated Mar 11, 2009 by lovexY...@gmail.com

Introduction

微型加密算法(TEA)及其相关变种(XTEA,Block TEA,XXTEA) 都是分组加密算法,它们很容易被描述,实现也很简单(典型的几行代码)。 TEA 算法最初是由剑桥计算机实验室的 David Wheeler 和 Roger Needham 在 1994 年设计的。该算法使用 128 位的密钥为 64 位的信息块进行加密,它需要进行 64 轮迭代,尽管作者认为 32 轮已经足够了。该算法使用了一个神秘常数δ作为倍数,它来源于黄金比率,以保证每一轮加密都不相同。但δ的精确值似乎并不重要,这里 TEA 把它定义为 δ=「(√5 - 1)231」(也就是程序中的 0×9E3779B9)。之后 TEA 算法被发现存在缺陷,作为回应,设计者提出了一个 TEA 的升级版本——XTEA(有时也被称为“tean”)。XTEA 跟 TEA 使用了相同的简单运算,但它采用了截然不同的顺序,为了阻止密钥表攻击,四个子密钥(在加密过程中,原 128 位的密钥被拆分为 4 个 32 位的子密钥)采用了一种不太正规的方式进行混合,但速度更慢了。 在跟描述 XTEA 算法的同一份报告中,还介绍了另外一种被称为 Block TEA 算法的变种,它可以对 32 位大小任意倍数的变量块进行操作。该算法将 XTEA 轮循函数依次应用于块中的每个字,并且将它附加于它的邻字。该操作重复多少轮依赖于块的大小,但至少需要 6 轮。该方法的优势在于它无需操作模式(CBC,OFB,CFB 等),密钥可直接用于信息。对于长的信息它可能比 XTEA 更有效率。 在 1998 年,Markku-Juhani Saarinen 给出了一个可有效攻击 Block TEA 算法的代码,但之后很快 David J. Wheeler 和 Roger M. Needham 就给出了 Block TEA 算法的修订版,这个算法被称为 XXTEA。XXTEA 使用跟 Block TEA 相似的结构,但在处理块中每个字时利用了相邻字。它利用一个更复杂的 MX 函数代替了 XTEA 轮循函数,MX 使用 2 个输入量。

XXTEA算法在加密、解密时需要提供给算法一个自己设计的密码本,此密码本必须严密保护,不可对外泄露,可以是任意字符,甚至可以是中文。

Details

/* xxtea.java  
*  
* Author:       Ma Bingyao < andot@ujn.edu.cn >  
* Copyright:    CoolCode.CN  
* Version:      1.0  
* LastModified: 2006-05-11  
* This library is free.  You can redistribute it and/or modify it.  
* http://www.coolcode.cn/?p=169  
*/  
public   class xxtea {  
    /**  
     * Encrypt data with key.  
     *  
     * @param data  
     * @param key  
     * @return  
     */  
    public   static byte [] encrypt ( byte [] data , byte [] key ) {  
        if   ( data . length == 0 ) {  
            return   data ;  
        }  
        return   toByteArray ( encrypt ( toIntArray ( data , true ) , toIntArray ( key , false )) , false ) ;  
    }  
   
    /**  
     * Decrypt data with key.  
     *  
     * @param data  
     * @param key  
     * @return  
     */  
    public   static byte [] decrypt ( byte [] data , byte [] key ) {  
        if   ( data . length == 0 ) {  
            return   data ;  
        }  
        return   toByteArray ( decrypt ( toIntArray ( data , false ) , toIntArray ( key , false )) , true ) ;  
    }  
   
    /**  
     * Encrypt data with key.  
     *  
     * @param v  
     * @param k  
     * @return  
     */  
    public   static int [] encrypt ( int [] v , int [] k ) {  
        int   n = v . length - 1 ;  
        if   ( n < 1 ) {  
            return   v ;  
        }  
        if   ( k . length < 4 ) {  
            int []   key = new int [ 4 ] ;  
            System . arraycopy ( k , 0 , key , 0 , k . length ) ;  
            k = key ;  
        }  
        int   z = v [ n ] , y = v [ 0 ] , delta = 0x9E3779B9 , sum = 0 , e ;  
        int   p , q = 6 + 52 / ( n + 1 ) ;  
        while   ( q -- > 0 ) {  
            sum = sum + delta ;  
            e = sum >>> 2 & 3 ;  
            for   ( p = 0 ; p < n ; p ++ ) {  
                y = v [ p + 1 ] ;  
                z = v [ p ] += ( z >>> 5 ^ y << 2 ) + ( y >>> 3 ^ z << 4 ) ^ ( sum ^ y ) + ( k [ p & 3 ^ e ] ^ z ) ;  
            }  
            y = v [ 0 ] ;  
            z = v [ n ] += ( z >>> 5 ^ y << 2 ) + ( y >>> 3 ^ z << 4 ) ^ ( sum ^ y ) + ( k [ p & 3 ^ e ] ^ z ) ;  
        }  
        return   v ;  
    }  
   
    /**  
     * Decrypt data with key.  
     *  
     * @param v  
     * @param k  
     * @return  
     */  
    public   static int [] decrypt ( int [] v , int [] k ) {  
        int   n = v . length - 1 ;  
        if   ( n < 1 ) {  
            return   v ;  
        }  
        if   ( k . length < 4 ) {  
            int []   key = new int [ 4 ] ;  
            System . arraycopy ( k , 0 , key , 0 , k . length ) ;  
            k = key ;  
        }  
        int   z = v [ n ] , y = v [ 0 ] , delta = 0x9E3779B9 , sum , e ;  
        int   p , q = 6 + 52 / ( n + 1 ) ;  
        sum = q * delta ;  
        while   ( sum != 0 ) {  
            e = sum >>> 2 & 3 ;  
            for   ( p = n ; p > 0 ; p -- ) {  
                z = v [ p - 1 ] ;  
                y = v [ p ] -= ( z >>> 5 ^ y << 2 ) + ( y >>> 3 ^ z << 4 ) ^ ( sum ^ y ) + ( k [ p & 3 ^ e ] ^ z ) ;  
            }  
            z = v [ n ] ;  
            y = v [ 0 ] -= ( z >>> 5 ^ y << 2 ) + ( y >>> 3 ^ z << 4 ) ^ ( sum ^ y ) + ( k [ p & 3 ^ e ] ^ z ) ;  
            sum = sum - delta ;  
        }  
        return   v ;  
    }  
   
    /**  
     * Convert byte array to int array.  
     *  
     * @param data  
     * @param includeLength  
     * @return  
     */  
    private   static int [] toIntArray ( byte [] data , boolean includeLength ) {  
        int   n = ((( data . length & 3 ) == 0 ) ? ( data . length >>> 2 )  
                : (( data . length >>> 2 ) + 1 )) ;  
        int []   result ;  
        if   ( includeLength ) {  
            result = new   int [ n + 1 ] ;  
            result [ n ] = data . length ;  
        }   else {  
            result = new   int [ n ] ;  
        }  
        n = data . length ;  
        for   ( int i = 0 ; i < n ; i ++ ) {  
            result [ i >>> 2 ] |= ( 0x000000ff & data [ i ]) << (( i & 3 ) << 3 ) ;  
        }  
        return   result ;  
    }  
   
    /**  
     * Convert int array to byte array.  
     *  
     * @param data  
     * @param includeLength  
     * @return  
     */  
    private   static byte [] toByteArray ( int [] data , boolean includeLength ) {  
        int   n ;  
        if   ( includeLength ) {  
            n = data [ data . length - 1 ] ;  
        }   else {  
            n = data . length << 2 ;  
        }  
   
        byte []   result = new byte [ n ] ;  
        for   ( int i = 0 ; i < n ; i ++ ) {  
            result [ i ] = ( byte )   ( data [ i >>> 2 ] >>> (( i & 3 ) << 3 )) ;  
        }  
        return   result ;  
    }  
}
Powered by Google Project Hosting