TEA加密算法的C/C++实现

血刀老祖

TEA(Tiny Encryption Algorithm) 是一种简单高效的加密算法，以加密解密速度快，实现简单著称。算法真的很简单，TEA算法每一次可以操作64-bit(8-byte)，采用128-bit(16-byte)作为key，算法采用迭代的形式，推荐的迭代轮数是64轮，最少32轮。目前我只知道QQ一直用的是16轮TEA。没什么好说的，先给出C语言的源代码(默认是32轮)：
微型加密算法（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 更有效率。
$ x5 f3 r! _; J7 \# E5 t$ ]5 n$ C& r在 1998 年，Markku-Juhani Saarinen 给出了一个可有效攻击 Block TEA 算法的代码，但之后很快 David J. Wheeler 和 Roger M. Needham 就给出了 Block TEA 算法的修订版，这个算法被称为 XXTEA。XXTEA 使用跟 Block TEA 相似的结构，但在处理块中每个字时利用了相邻字。它利用一个更复杂的 MX 函数代替了 XTEA 轮循函数，MX 使用 2 个输入量。

天云上人

1. 
   9 w- L- f6 j1 L9 _
2. void encrypt(unsigned long *v, unsigned long *k) {
   
3.      unsigned long y=v[0], z=v[1], sum=0, i;         /* set up */
   
4.      unsigned long delta=0x9e3779b9;                 /* a key schedule constant */
   / t/ k" p. c# f9 G. j9 {
5.      unsigned long a=k[0], b=k[1], c=k[2], d=k[3];   /* cache key */
   5 y- Q2 M' t# f& }& h0 A+ b
6.      for (i=0; i < 32; i++) {                        /* basic cycle start */
   
7.          sum += delta;
   ' g5 J  ^/ v8 [- e
8.          y += ((z<<4) + a) ^ (z + sum) ^ ((z>>5) + b);
   
9.          z += ((y<<4) + c) ^ (y + sum) ^ ((y>>5) + d);/* end cycle */
   
10.      }
    
11.      v[0]=y;
    + T' V# S- _2 z" N& s
12.      v[1]=z;
    4 Q% Q% a0 O2 ^% {) }  q$ r
13. }
    
14.   
    5 V$ l7 ~, |% n/ [- h0 g5 p# Y
15. void decrypt(unsigned long *v, unsigned long *k) {
    
16.      unsigned long y=v[0], z=v[1], sum=0xC6EF3720, i; /* set up */
    . D' T" R6 l, F  T" D; k# O
17.      unsigned long delta=0x9e3779b9;                  /* a key schedule constant */
    
18.      unsigned long a=k[0], b=k[1], c=k[2], d=k[3];    /* cache key */
    0 m- S3 ~3 \8 ]9 \# _- g
19.      for(i=0; i<32; i++) {                            /* basic cycle start */
    
20.          z -= ((y<<4) + c) ^ (y + sum) ^ ((y>>5) + d);
    
21.          y -= ((z<<4) + a) ^ (z + sum) ^ ((z>>5) + b);
    
22.          sum -= delta;                                /* end cycle */
    9 n' F/ T* X% g, o
23.      }
    
24.      v[0]=y;
    
25.      v[1]=z;
    ! {) t8 u1 v' Y1 j. d) @2 y3 d
26. }
    % I4 w9 G& V: Y: `" G8 u2 a

复制代码

C语言写的用起来当然不方便，没关系，用C++封装以下就OK了：

天云上人

#ifndef UTIL_H
#define UTIL_H

#include <string>
( C. d! w) `1 C4 s5 B5 e4 J#include <cmath>
#include <cstdlib>

2 n6 t# |# J7 \5 ~  C. ~typedef unsigned char byte;
typedef unsigned long ulong;

inline double logbase(double base, double x) {
    return log(x)/log(base);
}
. B6 T/ `( c, t1 {2 t; w7 F
2 ?; G' n% H. P9 C5 Z  g8 p+ J, c/*
" I' \2 r- \' ]*convert int to hex char.
*example:10 -> 'A',15 -> 'F'
*/
char intToHexChar(int x);
& L: t% v( R3 W# u
/*
*convert hex char to int.
8 k0 @- U' O1 [6 _*example:'A' -> 10,'F' -> 15
- m& u: n1 [7 i*/
int hexCharToInt(char hex);

. |5 |  |# S4 ]$ Y$ S! R8 a" dusing std::string;
/*
- J" V% S3 y$ g9 @7 w*convert a byte array to hex string.
*hex string format example:"AF B0 80 7D"
*/
string bytesToHexString(const byte *in, size_t size);

/*
*convert a hex string to a byte array.
* t) w: Q% c! F( |*hex string format example:"AF B0 80 7D"
*/
size_t hexStringToBytes(const string &str, byte *out);

#endif/*UTIL_H*/

天云上人

#include "util.h"
#include <vector>
" a# G7 I4 ^. Z# E
8 y# ^4 U. S6 yusing namespace std;

" U% \- J3 ~8 e; ]$ j, Y# nchar intToHexChar(int x) {
" d7 A5 }: ]9 u% Q: v    static const char HEX[16] = {
        '0', '1', '2', '3',
        '4', '5', '6', '7',
. O0 u, G) {- f        '8', '9', 'A', 'B',
( G. D1 n% O; t, O: y  p        'C', 'D', 'E', 'F'
    };
    return HEX[x];
# H6 O5 S# ]2 e! A# z}

int hexCharToInt(char hex) {
: U2 s: ?( i, d2 {9 `    hex = toupper(hex);
    if (isdigit(hex))
        return (hex - '0');
    if (isalpha(hex))
2 h1 I" z& a, p% l! m* J& l        return (hex - 'A' + 10);
    return 0;
}

string bytesToHexString(const byte *in, size_t size) {
3 p$ h) N3 N  n9 M- |* k    string str;
    for (size_t i = 0; i < size; ++i) {
  B8 i5 c* ?, U  B' t* e8 C+ P        int t = in[i];
& n4 P7 M: A% S& U# o$ y4 [        int a = t / 16;
        int b = t % 16;
        str.append(1, intToHexChar(a));
! q# ~9 L  t- E3 K2 V: N& F5 n        str.append(1, intToHexChar(b));
5 x8 a7 y  `1 a- R( v6 ?& q        if (i != size - 1)
            str.append(1, ' ');
% n" F  P$ p# Y3 ^    }
4 d: z* b5 ?$ I- e. N    return str;
}

" D& S9 ^& D: e- @size_t hexStringToBytes(const string &str, byte *out) {
" |$ w" r  p) ^
  F  i; g: I& c    vector<string> vec;
. ^' S% U. D8 U+ I# h$ ]# L& p! U    string::size_type currPos = 0, prevPos = 0;
$ M* T: r# q; z. `4 e& n4 t4 A" l% r    while ((currPos = str.find(' ', prevPos)) != string::npos) {
7 }& M* Y# C, r; c6 H        string b(str.substr(prevPos, currPos - prevPos));
- I/ |3 E4 J- g0 r# C        vec.push_back(b);
  q2 s) E  H; i/ l, O' B        prevPos = currPos + 1;
    }
; S$ i2 N0 _5 m    if (prevPos < str.size()) {
- o7 I4 q+ R4 T- p* d+ {        string b(str.substr(prevPos));
$ O. U. z0 \( s4 V. K. s6 `        vec.push_back(b);
    }
    typedef vector<string>::size_type sz_type;
) }1 l1 J  ], V# w( z. \. o% F    sz_type size = vec.size();
4 v2 ^" F% d  u5 q    for (sz_type i = 0; i < size; ++i) {
        int a = hexCharToInt(vec[i][0]);
        int b = hexCharToInt(vec[i][1]);
        out[i] = a * 16 + b;
! g: h4 a" D* E2 @7 r    }
    return size;
}

天云上人

#ifndef TEA_H
#define TEA_H
7 k, v/ j- r! v! b/ B* [. ~
0 O& s+ d$ P) j0 X/*
*for htonl,htonl
. r8 y. G* a1 c4 S4 _*do remember link "ws2_32.lib"
*/
% v1 V! G' |  D& D$ g: H#include <winsock2.h>
#include "util.h"

class TEA {
1 r2 X/ W/ G% \public:
    TEA(const byte *key, int round = 32, bool isNetByte = false);
    TEA(const TEA &rhs);
& ~* r! {! ?- H- w    TEA& operator=(const TEA &rhs);
    void encrypt(const byte *in, byte *out);
    void decrypt(const byte *in, byte *out);
private:
    void encrypt(const ulong *in, ulong *out);
1 V( l0 |0 O3 a# g    void decrypt(const ulong *in, ulong *out);
2 x4 _" n* y" z6 q4 Y7 d4 l    ulong ntoh(ulong netlong) { return _isNetByte ? ntohl(netlong) : netlong; }
    ulong hton(ulong hostlong) { return _isNetByte ? htonl(hostlong) : hostlong; }
* v* D0 E; @2 Zprivate:
    int _round; //iteration round to encrypt or decrypt
1 f& l) H6 O1 t# ~0 q7 k7 i    bool _isNetByte; //whether input bytes come from network
4 d0 z8 W7 j4 p# C: ~+ l3 X    byte _key[16]; //encrypt or decrypt key
};

& a( _  e6 Z; i  V, z3 U#endif/*TEA_H*/

天云上人

1 #include "tea.h"
2 #include <cstring> //for memcpy,memset
  Z3 w8 I4 `  P1 e! w# E% p 3  
4 using namespace std;
5  
1 P: Q5 ]7 d& \ 6 TEA::TEA(const byte *key, int round /*= 32*/, bool isNetByte /*= false*/)
) m, G" H' c6 Y# ] 7 :_round(round)
8 ,_isNetByte(isNetByte) {
9     if (key != 0)
! W8 O% F* q! ~% `3 d$ z10         memcpy(_key, key, 16);
11     else
  v8 |7 C9 S, _, m2 `3 I6 c0 w4 j12         memset(_key, 0, 16);
13 }
14  
' h6 B6 X* x$ [1 s% }15 TEA::TEA(const TEA &rhs)
  F# J% _0 j! Y" x16 :_round(rhs._round)
17 ,_isNetByte(rhs._isNetByte) {
18     memcpy(_key, rhs._key, 16);
19 }
0 _6 @7 z; |8 |4 X20  
21 TEA& TEA::operator=(const TEA &rhs) {
( q' ^; j. ~! C+ s2 ?% X  y22     if (&rhs != this) {
23         _round = rhs._round;
24         _isNetByte = rhs._isNetByte;
25         memcpy(_key, rhs._key, 16);
26     }
' T2 X4 ?& p+ Y  |  G- S27     return *this;
28 }
2 @# ~, R' L: t8 M2 K29  
30 void TEA::encrypt(const byte *in, byte *out) {
5 f3 U- K0 A* _3 B31     encrypt((const ulong*)in, (ulong*)out);
) z1 t" T1 P* R' R3 i4 M/ Y32 }
33  
34 void TEA::decrypt(const byte *in, byte *out) {
/ M3 J3 ?) R/ z+ D1 i35     decrypt((const ulong*)in, (ulong*)out);
36 }
  s9 p/ F2 K+ y. X) Z+ e0 H37  
- j' d" q# Q$ l4 e: U! ]2 k38 void TEA::encrypt(const ulong *in, ulong *out) {
39  
40     ulong *k = (ulong*)_key;
41     register ulong y = ntoh(in[0]);
# U. W+ z, l2 w- h42     register ulong z = ntoh(in[1]);
' Z& |( `5 y: a43     register ulong a = ntoh(k[0]);
44     register ulong b = ntoh(k[1]);
: |9 I9 Z  p7 j7 Q45     register ulong c = ntoh(k[2]);
6 p0 H6 n% B3 u) u46     register ulong d = ntoh(k[3]);
47     register ulong delta = 0x9E3779B9; /* (sqrt(5)-1)/2*2^32 */
48     register int round = _round;
2 I; ]1 R$ d4 ]) ]4 J2 f+ g0 h8 f49     register ulong sum = 0;
50  
51     while (round--) {    /* basic cycle start */
0 \5 V$ ?( z! K. p1 V52         sum += delta;
53         y += ((z << 4) + a) ^ (z + sum) ^ ((z >> 5) + b);
1 l% t* w( a9 O8 Z, V54         z += ((y << 4) + c) ^ (y + sum) ^ ((y >> 5) + d);
55     }    /* end cycle */
+ ~6 c/ M( V/ u" V7 s56     out[0] = ntoh(y);
57     out[1] = ntoh(z);
/ b) Q  e' f6 D58 }
- e/ W% a# H. ?3 ]# q$ e59  
" ?; m) p2 R$ K- \60 void TEA::decrypt(const ulong *in, ulong *out) {
+ a* ]" |  r( E8 s3 K6 {61  
/ |* c4 }' e& i62     ulong *k = (ulong*)_key;
63     register ulong y = ntoh(in[0]);
, `# Q, a1 n* h- u0 Y64     register ulong z = ntoh(in[1]);
% Y9 q  u) q/ e5 e% v( x65     register ulong a = ntoh(k[0]);
66     register ulong b = ntoh(k[1]);
67     register ulong c = ntoh(k[2]);
68     register ulong d = ntoh(k[3]);
69     register ulong delta = 0x9E3779B9; /* (sqrt(5)-1)/2*2^32 */
70     register int round = _round;
71     register ulong sum = 0;
7 ~1 e: H1 P! M) p- d4 l. z" Z" ?72  
73     if (round == 32)
, Q' i) l  P. _7 c/ X9 y74         sum = 0xC6EF3720; /* delta << 5*/
% K, U5 d# C) d+ i9 R75     else if (round == 16)
% E0 y( \4 }7 y. e3 U76         sum = 0xE3779B90; /* delta << 4*/
77     else
' [; Y! D2 n7 Q3 Z  C78         sum = delta << static_cast<int>(logbase(2, round));
79  
80     while (round--) {    /* basic cycle start */
81         z -= ((y << 4) + c) ^ (y + sum) ^ ((y >> 5) + d);
82         y -= ((z << 4) + a) ^ (z + sum) ^ ((z >> 5) + b);
' J% M% m! t: T* r/ C83         sum -= delta;
$ V1 E+ y9 ^( q84     }    /* end cycle */
/ W8 L0 S' s) h/ L1 t7 c  d85     out[0] = ntoh(y);
( r; G4 A) d& N86     out[1] = ntoh(z);
4 [* N; M" |. h" _/ a87 }

( j4 K9 W) p4 K5 O1 \* p% ~需要说明的是TEA的构造函数：
TEA(const byte *key, int round = 32, bool isNetByte = false);
; Y3 s+ q; a: _7 f1.key - 加密或解密用的128-bit(16byte)密钥。
2.round - 加密或解密的轮数，常用的有64，32，16。
# G! [! k2 v4 e! b, c* j3.isNetByte - 用来标记待处理的字节是不是来自网络，为true时在加密/解密前先要转换成本地字节，执行加密/解密，然后再转换回网络字节。偷偷告诉你，QQ就是这样做的！

最后当然少不了测试代码：

天云上人

1 #include "tea.h"
2 #include "util.h"
" [  o: d. Z( u, o6 n 3 #include <iostream>
4  
5 using namespace std;
6  
( Y( h6 z- y& z& U3 Y5 r, [ 7 int main() {
# j* M1 w  X( ~3 \ 8  
9     const string plainStr("AD DE E2 DB B3 E2 DB B3");
7 v4 Q( ]6 _- _' Z6 f# v; |10     const string keyStr("3A DA 75 21 DB E2 DB B3 11 B4 49 01 A5 C6 EA D4");
6 `. C" ?" N+ N) d# K9 G11     const int SIZE_IN = 8, SIZE_OUT = 8, SIZE_KEY = 16;
0 w3 `/ [; e2 U12     byte plain[SIZE_IN], crypt[SIZE_OUT], key[SIZE_KEY];
0 [# I4 _: }3 p- `13  
14     size_t size_in = hexStringToBytes(plainStr, plain);
) t* B1 Q! l  u15     size_t size_key = hexStringToBytes(keyStr, key);
16  
/ j8 d9 Q$ z  X5 g9 H# y1 `/ `& ?17     if (size_in != SIZE_IN || size_key != SIZE_KEY)
" y: C8 t8 u$ K2 i2 m18         return -1;
& S& \7 F# _' w: |- j8 n- L' J! w19  
, @; H6 T6 E$ x- j+ M, G7 F20     cout << "Plain: " << bytesToHexString(plain, size_in) << endl;
/ P2 z4 ^( B& u/ Q3 \21     cout << "Key  : " << bytesToHexString(key, size_key) << endl;
. y0 o' o3 Y" Y$ s* A5 L8 [" g22  
: S* t$ R# o8 T3 s, B23     TEA tea(key, 16, true);
9 [7 O. a+ N" @0 J* S24     tea.encrypt(plain, crypt);
- t8 a; q$ T! S8 |2 F6 W25     cout << "Crypt: " << bytesToHexString(crypt, SIZE_OUT) << endl;
26  
27     tea.decrypt(crypt, plain);
28     cout << "Plain: " << bytesToHexString(plain, SIZE_IN) << endl;
( b; p% k* W8 }: @29     return 0;
. @% D0 x: B" d8 m5 M30 }

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/sailing0123/archive/2008/04/28/2339231.aspx
运行结果：
Plain: AD DE E2 DB B3 E2 DB B3
8 @& L% }6 A% Q& `/ e8 M! Y( ]Key  : 3A DA 75 21 DB E2 DB B3 11 B4 49 01 A5 C6 EA D4
% w7 l% E7 ]5 F* V9 MCrypt: 3B 3B 4D 8C 24 3A FD F2
Plain: AD DE E2 DB B3 E2 DB B3