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） 都是分组加密算法，它们很容易被描述，实现也很简单（典型的几行代码）。
- U( R/ J9 o1 q2 N% B9 O1 [TEA 算法最初是由剑桥计算机实验室的 David Wheeler 和 Roger Needham 在 1994 年设计的。该算法使用 128 位的密钥为 64 位的信息块进行加密，它需要进行 64 轮迭代，尽管作者认为 32 轮已经足够了。该算法使用了一个神秘常数δ作为倍数，它来源于黄金比率，以保证每一轮加密都不相同。但δ的精确值似乎并不重要，这里 TEA 把它定义为 δ=「(√5 - 1)231」（也就是程序中的 0×9E3779B9）。
% K: U8 J. j% @' v/ Z之后 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 个输入量。

天云上人

1. 
   
2. void encrypt(unsigned long *v, unsigned long *k) {
   
3.      unsigned long y=v[0], z=v[1], sum=0, i;         /* set up */
   4 K+ e. @% D# X+ n$ ~
4.      unsigned long delta=0x9e3779b9;                 /* a key schedule constant */
   9 M4 g) C) h8 a# ~
5.      unsigned long a=k[0], b=k[1], c=k[2], d=k[3];   /* cache key */
   
6.      for (i=0; i < 32; i++) {                        /* basic cycle start */
   
7.          sum += delta;
   
8.          y += ((z<<4) + a) ^ (z + sum) ^ ((z>>5) + b);
   3 j( J  _# c4 x
9.          z += ((y<<4) + c) ^ (y + sum) ^ ((y>>5) + d);/* end cycle */
   6 M6 P2 [/ T6 C) j
10.      }
    ( O; b. Y: }+ L, n* T- }# M
11.      v[0]=y;
    
12.      v[1]=z;
    
13. }
    
14.   
    
15. void decrypt(unsigned long *v, unsigned long *k) {
    ) b) t2 \9 j) x& h: r, n
16.      unsigned long y=v[0], z=v[1], sum=0xC6EF3720, i; /* set up */
    
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 */
    
19.      for(i=0; i<32; i++) {                            /* basic cycle start */
    
20.          z -= ((y<<4) + c) ^ (y + sum) ^ ((y>>5) + d);
    ; W: O! ^: j/ b0 _( ?$ n* i6 c8 `
21.          y -= ((z<<4) + a) ^ (z + sum) ^ ((z>>5) + b);
    
22.          sum -= delta;                                /* end cycle */
    
23.      }
    
24.      v[0]=y;
    
25.      v[1]=z;
    
26. }
    ; x# G2 T2 E. A' d4 s

复制代码

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

天云上人

#ifndef UTIL_H
( L$ e  F' u" Z) ], o5 {#define UTIL_H

. d9 a  z4 f7 D5 B#include <string>
#include <cmath>
/ ]2 [1 f3 p! N#include <cstdlib>
1 I4 O5 i4 ~2 A1 d2 r+ W
typedef unsigned char byte;
typedef unsigned long ulong;
- v6 h  K; b. S+ Q4 @1 c
inline double logbase(double base, double x) {
/ x  \( @6 D8 ~7 v) U: e    return log(x)/log(base);
( K. ^4 n/ Q" c% k$ o}
0 ]' H: m, T0 Y" `
/*
*convert int to hex char.
+ }: p6 D! b  V! y7 \5 i*example:10 -> 'A',15 -> 'F'
6 L$ p& n1 l, M0 n: }; L*/
char intToHexChar(int x);
- c4 L. f' x( W! k$ M# L7 X! i. W
( T: J8 G: k: }2 X9 X0 h/*
" f/ b6 C; ~2 B6 J: s*convert hex char to int.
*example:'A' -> 10,'F' -> 15
*/
& @2 O. Z! y" x7 J% qint hexCharToInt(char hex);
6 V, J* |) t5 ^: d& x( L8 n- g  i, E
: ^5 \7 ]' q' S' q" Y5 |using std::string;
' }% s- m, O0 D$ ^8 X; c' l0 V/*
*convert a byte array to hex string.
*hex string format example:"AF B0 80 7D"
*/
string bytesToHexString(const byte *in, size_t size);
" C6 ]) n: n; n/ ?0 A
  W  I0 _% J/ l9 D9 F/*
4 x6 U- p5 p7 ]& v*convert a hex string to a byte array.
8 m9 F) {% L( W: m* p) E*hex string format example:"AF B0 80 7D"
- n6 ^8 f: K4 p/ T3 s+ w*/
size_t hexStringToBytes(const string &str, byte *out);

#endif/*UTIL_H*/

天云上人

#include "util.h"
#include <vector>
6 A: |0 h; r) M0 d: f- G& G
6 f+ D! _3 n: f7 j+ l, L/ Xusing namespace std;

  o& h2 {% H6 s/ ?char intToHexChar(int x) {
    static const char HEX[16] = {
        '0', '1', '2', '3',
        '4', '5', '6', '7',
        '8', '9', 'A', 'B',
- T- [( i0 W0 Z* A7 r& N        'C', 'D', 'E', 'F'
+ v6 U0 X. V# K* S  c' n/ K1 u    };
! |+ P* q  v% N    return HEX[x];
}
" \" E7 L* k8 h6 j/ \( G+ s$ f' c
( t# n: N: R) D: J  H  F: vint hexCharToInt(char hex) {
    hex = toupper(hex);
    if (isdigit(hex))
! {7 K& g% M0 n  W) D, S( D1 Z        return (hex - '0');
+ P# C, L% Z  w4 u5 d. y    if (isalpha(hex))
' P5 V' d9 A6 F- n- }        return (hex - 'A' + 10);
* k$ c& e# t0 b6 H! i( K+ P    return 0;
}
. D8 G1 M5 G9 i0 Y4 S; h% k" ^
* l6 U6 U- q" X3 x: H5 ~9 B; H# R9 |string bytesToHexString(const byte *in, size_t size) {
    string str;
2 Y0 q. {. e1 J. @8 P    for (size_t i = 0; i < size; ++i) {
0 O) @. V1 S  v4 z$ @        int t = in[i];
        int a = t / 16;
: i5 @4 O5 x6 S( M2 `        int b = t % 16;
        str.append(1, intToHexChar(a));
0 h4 M5 R) B) h, I        str.append(1, intToHexChar(b));
        if (i != size - 1)
            str.append(1, ' ');
    }
: @1 L6 ]* f! ?! D0 |* Y- @    return str;
}

size_t hexStringToBytes(const string &str, byte *out) {
0 F  }( ]+ ^: f4 \  y. R# i; k
$ G" |; b- i/ O3 {* T8 d    vector<string> vec;
; Y2 g! b# T9 n% [    string::size_type currPos = 0, prevPos = 0;
    while ((currPos = str.find(' ', prevPos)) != string::npos) {
% o0 S6 I- }5 a* W        string b(str.substr(prevPos, currPos - prevPos));
- H9 n6 v; x. x        vec.push_back(b);
        prevPos = currPos + 1;
    }
    if (prevPos < str.size()) {
        string b(str.substr(prevPos));
7 c0 j* |' C2 y" q        vec.push_back(b);
    }
    typedef vector<string>::size_type sz_type;
    sz_type size = vec.size();
4 P8 v8 G/ K0 D% i2 y    for (sz_type i = 0; i < size; ++i) {
        int a = hexCharToInt(vec[i][0]);
, b1 B( ]$ m$ Y* H& x, n        int b = hexCharToInt(vec[i][1]);
9 A; ~: ]% z, e# Z/ x9 E1 s        out[i] = a * 16 + b;
2 Z/ R$ G  Y& j( B8 U' m    }
' o+ J& o0 _% a, p# n: R6 x2 X2 e+ Y    return size;
}

天云上人

#ifndef TEA_H
. N: Z! s3 r, U2 F+ ~9 u#define TEA_H

. |  Z( s5 W1 V/ K0 @/*
*for htonl,htonl
- t+ {! b( a7 ?. E3 f3 Y*do remember link "ws2_32.lib"
*/
* L4 E& c/ m8 l/ U6 L1 |* v#include <winsock2.h>
#include "util.h"

class TEA {
+ D0 i, }9 Q( ]1 l* k6 Bpublic:
5 C! p2 H- X) u2 L1 F7 V: ~' x) d    TEA(const byte *key, int round = 32, bool isNetByte = false);
! r; Z. N! X  M+ T" R+ R    TEA(const TEA &rhs);
    TEA& operator=(const TEA &rhs);
    void encrypt(const byte *in, byte *out);
3 V# w- Y9 R- r2 |    void decrypt(const byte *in, byte *out);
private:
9 G8 \* }" j7 m) a) k8 K    void encrypt(const ulong *in, ulong *out);
    void decrypt(const ulong *in, ulong *out);
, g2 Q& p) n/ ]# |  z    ulong ntoh(ulong netlong) { return _isNetByte ? ntohl(netlong) : netlong; }
+ @/ O" U+ o9 V. ]: ?$ a    ulong hton(ulong hostlong) { return _isNetByte ? htonl(hostlong) : hostlong; }
6 f6 g% C  k( T2 yprivate:
    int _round; //iteration round to encrypt or decrypt
    bool _isNetByte; //whether input bytes come from network
, i  K" w7 a" p% L8 x    byte _key[16]; //encrypt or decrypt key
1 G2 C) _: Z0 j% e' ~) a7 H};
3 D4 \- Y1 o9 K5 P
* K5 B  I* f0 b8 M- f#endif/*TEA_H*/

天云上人

1 #include "tea.h"
2 #include <cstring> //for memcpy,memset
3  
4 using namespace std;
9 k5 N9 y2 g) q6 t 5  
. Q& \" N4 h/ E0 l 6 TEA::TEA(const byte *key, int round /*= 32*/, bool isNetByte /*= false*/)
7 :_round(round)
8 ,_isNetByte(isNetByte) {
9     if (key != 0)
10         memcpy(_key, key, 16);
11     else
1 [8 r- L* o* M' {; \; g% }  q12         memset(_key, 0, 16);
8 r- S0 ?( B! C0 [$ P+ g# D5 `# ]13 }
14  
8 T  ?3 Y9 a" X3 u3 ^15 TEA::TEA(const TEA &rhs)
16 :_round(rhs._round)
17 ,_isNetByte(rhs._isNetByte) {
' \1 ]/ ~4 W1 H$ `, A18     memcpy(_key, rhs._key, 16);
19 }
20  
+ h3 G& N4 _8 @' N' X; ?/ j% A21 TEA& TEA::operator=(const TEA &rhs) {
: _2 K0 d; P2 B: |5 d22     if (&rhs != this) {
23         _round = rhs._round;
# l6 k5 R$ U; I24         _isNetByte = rhs._isNetByte;
25         memcpy(_key, rhs._key, 16);
4 e0 W9 a' _! i) v- Q3 {26     }
27     return *this;
28 }
29  
30 void TEA::encrypt(const byte *in, byte *out) {
31     encrypt((const ulong*)in, (ulong*)out);
32 }
33  
34 void TEA::decrypt(const byte *in, byte *out) {
+ K/ E+ |: ?9 H7 K35     decrypt((const ulong*)in, (ulong*)out);
" v7 |5 U* ?: J+ R3 Y$ L36 }
6 U" k; E0 K+ h$ f9 m+ B/ R37  
38 void TEA::encrypt(const ulong *in, ulong *out) {
39  
40     ulong *k = (ulong*)_key;
41     register ulong y = ntoh(in[0]);
4 X1 u+ o7 N! j9 t42     register ulong z = ntoh(in[1]);
43     register ulong a = ntoh(k[0]);
) V" n7 K/ ^2 ^44     register ulong b = ntoh(k[1]);
$ t5 A" O! B2 C# b45     register ulong c = ntoh(k[2]);
46     register ulong d = ntoh(k[3]);
47     register ulong delta = 0x9E3779B9; /* (sqrt(5)-1)/2*2^32 */
48     register int round = _round;
49     register ulong sum = 0;
3 o$ R2 N: e6 Y9 I3 v) ]50  
  W+ o& |4 b7 Q* V51     while (round--) {    /* basic cycle start */
52         sum += delta;
6 L! g8 S. v6 S; j3 H/ ?53         y += ((z << 4) + a) ^ (z + sum) ^ ((z >> 5) + b);
54         z += ((y << 4) + c) ^ (y + sum) ^ ((y >> 5) + d);
3 F3 v+ \& K# c, j) S55     }    /* end cycle */
56     out[0] = ntoh(y);
6 \7 t" g, @6 P# \  [57     out[1] = ntoh(z);
58 }
5 b. N" [- f" E: K% @59  
' J+ C' @4 j2 C2 ?" A, W5 O60 void TEA::decrypt(const ulong *in, ulong *out) {
4 `) Z8 u3 L1 M( }61  
" m0 [" @& M% V62     ulong *k = (ulong*)_key;
! w0 i) E1 n1 d$ ~1 Y/ k( V63     register ulong y = ntoh(in[0]);
64     register ulong z = ntoh(in[1]);
65     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]);
  R! [: ?+ }& r; k4 V69     register ulong delta = 0x9E3779B9; /* (sqrt(5)-1)/2*2^32 */
70     register int round = _round;
71     register ulong sum = 0;
2 y( y& R$ y& @# `) o) z7 ]72  
$ h0 _6 Z/ N/ t# B4 X; S73     if (round == 32)
3 j: J3 }( \* ~" a( E- [74         sum = 0xC6EF3720; /* delta << 5*/
4 ~$ S; T/ f1 I. d1 t: ^- e75     else if (round == 16)
76         sum = 0xE3779B90; /* delta << 4*/
% @0 d1 a9 y9 \  W% D) k' g/ W7 @77     else
, f+ t2 J2 r6 P! n# l78         sum = delta << static_cast<int>(logbase(2, round));
6 A& p9 b' {% v2 }4 l79  
80     while (round--) {    /* basic cycle start */
81         z -= ((y << 4) + c) ^ (y + sum) ^ ((y >> 5) + d);
7 g0 b/ I6 Y+ T0 O* {  M1 b6 V82         y -= ((z << 4) + a) ^ (z + sum) ^ ((z >> 5) + b);
, e! O, u& }5 e8 h83         sum -= delta;
84     }    /* end cycle */
0 @  d5 c' m% ]1 S3 T" r% u85     out[0] = ntoh(y);
- j% A( J, z2 P4 P6 l3 m; w86     out[1] = ntoh(z);
, N9 _& ~9 L: \1 p& z0 ~! @87 }

8 B1 _& Y' G3 o9 K" k/ I8 M# V2 F2 G需要说明的是TEA的构造函数：
TEA(const byte *key, int round = 32, bool isNetByte = false);
1.key - 加密或解密用的128-bit(16byte)密钥。
/ M+ O9 U( I: Z  l/ X. j, i- F( g2.round - 加密或解密的轮数，常用的有64，32，16。
3.isNetByte - 用来标记待处理的字节是不是来自网络，为true时在加密/解密前先要转换成本地字节，执行加密/解密，然后再转换回网络字节。偷偷告诉你，QQ就是这样做的！
6 M1 S$ J0 g- V( d
最后当然少不了测试代码：

天云上人

1 #include "tea.h"
2 #include "util.h"
3 #include <iostream>
. \$ [0 D0 o1 x! y 4  
5 using namespace std;
6  
- E3 b) c* m* {  H1 E  D' H 7 int main() {
  D7 m! ]6 b3 P) @% b 8  
9     const string plainStr("AD DE E2 DB B3 E2 DB B3");
10     const string keyStr("3A DA 75 21 DB E2 DB B3 11 B4 49 01 A5 C6 EA D4");
: c6 c' }, {! k8 ?; K2 }11     const int SIZE_IN = 8, SIZE_OUT = 8, SIZE_KEY = 16;
12     byte plain[SIZE_IN], crypt[SIZE_OUT], key[SIZE_KEY];
13  
14     size_t size_in = hexStringToBytes(plainStr, plain);
( G6 K, ]+ W0 i2 |( P2 k, b15     size_t size_key = hexStringToBytes(keyStr, key);
  m( m: E4 T2 T& K" Q" R2 b16  
( d# J1 P% t  k5 ]# l$ T17     if (size_in != SIZE_IN || size_key != SIZE_KEY)
' Z) W: B& {- s18         return -1;
( Y" Q; C7 A( j1 c4 x* p19  
20     cout << "Plain: " << bytesToHexString(plain, size_in) << endl;
% m: ]) N& ]# \9 w4 G21     cout << "Key  : " << bytesToHexString(key, size_key) << endl;
22  
23     TEA tea(key, 16, true);
24     tea.encrypt(plain, crypt);
25     cout << "Crypt: " << bytesToHexString(crypt, SIZE_OUT) << endl;
- u  _$ U! f1 Q( C+ x5 C26  
. C8 |1 J. x, k1 q/ S' @27     tea.decrypt(crypt, plain);
3 r% X( r/ l* g/ A28     cout << "Plain: " << bytesToHexString(plain, SIZE_IN) << endl;
) I3 l/ Y9 L* v8 l29     return 0;
1 g8 i& X* J$ H30 }
- X/ e7 V& `9 u) ], g) k
本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/sailing0123/archive/2008/04/28/2339231.aspx
运行结果：
Plain: AD DE E2 DB B3 E2 DB B3
/ L) @1 v' u1 Y" RKey  : 3A DA 75 21 DB E2 DB B3 11 B4 49 01 A5 C6 EA D4
$ ]0 e9 ?! e  J2 g' a( e) V- J3 K' nCrypt: 3B 3B 4D 8C 24 3A FD F2
/ ^( ^7 v. S( c8 q  p$ TPlain: AD DE E2 DB B3 E2 DB B3