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 更有效率。
在 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 */
   8 b! C5 w# n9 K& i2 k
4.      unsigned long delta=0x9e3779b9;                 /* a key schedule constant */
   6 a) l$ R6 ]# h$ k8 x
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);
   
9.          z += ((y<<4) + c) ^ (y + sum) ^ ((y>>5) + d);/* end cycle */
   : N8 |/ L4 |/ {* e1 @7 }2 }! t
10.      }
    : L- B1 E, t9 |- ^; o
11.      v[0]=y;
    1 M& x. D* R* p& {! P9 V1 v
12.      v[1]=z;
    
13. }
    
14.   
    
15. void decrypt(unsigned long *v, unsigned long *k) {
    ) t! a2 o$ D: d7 P) V
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);
    
21.          y -= ((z<<4) + a) ^ (z + sum) ^ ((z>>5) + b);
    
22.          sum -= delta;                                /* end cycle */
    9 Q  t% X" ~5 v' D" ^, u/ b7 v
23.      }
    7 L! F$ X! F$ w# y% O
24.      v[0]=y;
    
25.      v[1]=z;
    3 O& X: H  a  g; D5 K  U
26. }
    

复制代码

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

天云上人

#ifndef UTIL_H
1 W4 o3 T! K- Q) d$ m. j#define UTIL_H

#include <string>
8 d/ }: ~- Z( Y% O1 h#include <cmath>
#include <cstdlib>
3 k' W$ _, j# g$ z$ F0 \8 J5 a0 q
typedef unsigned char byte;
typedef unsigned long ulong;
) M' f- D! l2 H( Q! U
4 f* n/ }& q4 `# J+ ^" w( W$ A. P" F& |inline double logbase(double base, double x) {
8 F$ m1 h$ Z+ k/ C6 a$ U. V; j    return log(x)/log(base);
}

. Y, q' P# v# i( m* I/ z/*
*convert int to hex char.
*example:10 -> 'A',15 -> 'F'
8 R, S8 T- ], ]- O# {  B% O! W! k*/
char intToHexChar(int x);

/*
3 K* s8 v$ a+ @9 X6 w4 _( j6 d*convert hex char to int.
( N5 T6 ~' s  F8 m; ]*example:'A' -> 10,'F' -> 15
*/
int hexCharToInt(char hex);
4 a$ V8 I( U2 S6 e
3 ~/ u1 @# A- [5 Nusing std::string;
/*
" n0 I- h- E/ ^*convert a byte array to hex string.
" |# n! g5 N- n, U- n3 M& h*hex string format example:"AF B0 80 7D"
*/
+ F8 Z/ T; F3 ^8 A7 a2 Q0 V+ o( Ostring bytesToHexString(const byte *in, size_t size);

! S4 R# m7 i3 N/ j6 W/*
*convert a hex string to a byte array.
*hex string format example:"AF B0 80 7D"
*/
1 [6 q1 l7 t& p5 p5 _; b) R) ~8 O& Osize_t hexStringToBytes(const string &str, byte *out);

#endif/*UTIL_H*/

天云上人

#include "util.h"
#include <vector>
8 ?# O; R4 g9 P  \
4 m6 z7 y: |5 i" ~0 iusing namespace std;
# i' o. N/ _4 q# U
char intToHexChar(int x) {
    static const char HEX[16] = {
        '0', '1', '2', '3',
" N8 o( _9 {3 s: V6 M' M4 c        '4', '5', '6', '7',
        '8', '9', 'A', 'B',
        'C', 'D', 'E', 'F'
    };
, k& _2 f; f- k: F3 ?, f    return HEX[x];
}
" E/ L) _+ t, E, _
- Y/ n7 j3 L% i8 R6 t2 Q4 ~int hexCharToInt(char hex) {
    hex = toupper(hex);
    if (isdigit(hex))
  I$ {) M# C8 n        return (hex - '0');
/ b7 D8 z' M& H+ ?$ n3 M    if (isalpha(hex))
        return (hex - 'A' + 10);
    return 0;
}

string bytesToHexString(const byte *in, size_t size) {
! B% y! L+ Q/ k2 a    string str;
    for (size_t i = 0; i < size; ++i) {
        int t = in[i];
        int a = t / 16;
        int b = t % 16;
$ \* ^: \/ G- B, }" o5 c        str.append(1, intToHexChar(a));
0 Z$ y1 ~" I5 d# F9 V        str.append(1, intToHexChar(b));
        if (i != size - 1)
, U  F- Q7 {' J' }; k            str.append(1, ' ');
0 d* e# y& {8 E$ j7 `/ H    }
    return str;
3 ]. T* U: E# c4 [7 t}

size_t hexStringToBytes(const string &str, byte *out) {

    vector<string> vec;
, d. N, J( e, x5 g; k/ l    string::size_type currPos = 0, prevPos = 0;
    while ((currPos = str.find(' ', prevPos)) != string::npos) {
        string b(str.substr(prevPos, currPos - prevPos));
  {& f4 a3 c5 R        vec.push_back(b);
        prevPos = currPos + 1;
    }
( x: r+ D+ J. k$ p    if (prevPos < str.size()) {
9 b* Z$ e" c( J  O+ L3 m1 q        string b(str.substr(prevPos));
: v3 l" Q" v1 p: o) ]        vec.push_back(b);
    }
* w+ g8 i' f- j+ W* n4 L    typedef vector<string>::size_type sz_type;
    sz_type size = vec.size();
    for (sz_type i = 0; i < size; ++i) {
        int a = hexCharToInt(vec[i][0]);
" f0 I+ A8 Z2 ^7 `1 [: [        int b = hexCharToInt(vec[i][1]);
8 _- S/ ^: n3 b        out[i] = a * 16 + b;
    }
0 z4 X2 u- T& N4 |- c+ _    return size;
}

天云上人

#ifndef TEA_H
#define TEA_H
2 c- ]" }0 _6 `6 N, t& @
  O! v, s- E. j( |/*
*for htonl,htonl
' I8 \5 d" r4 i: {+ T' C. L0 @$ G*do remember link "ws2_32.lib"
*/
! e2 @( G2 l) v0 s2 O#include <winsock2.h>
#include "util.h"

class TEA {
/ g8 s+ V: d' {+ P! a. O8 {public:
    TEA(const byte *key, int round = 32, bool isNetByte = false);
8 B* e; g4 ?$ Q& w6 @, G; f    TEA(const TEA &rhs);
    TEA& operator=(const TEA &rhs);
    void encrypt(const byte *in, byte *out);
    void decrypt(const byte *in, byte *out);
1 v) _9 m/ D1 }! B3 xprivate:
3 B; {, w3 R! x    void encrypt(const ulong *in, ulong *out);
& s' V# ]# P. P8 b& k* `( m2 W    void decrypt(const ulong *in, ulong *out);
    ulong ntoh(ulong netlong) { return _isNetByte ? ntohl(netlong) : netlong; }
5 x) y5 g( l2 d& f    ulong hton(ulong hostlong) { return _isNetByte ? htonl(hostlong) : hostlong; }
, V9 K6 g% l, C" r, B+ M" mprivate:
7 k. n" A" b1 r' o: Z( S2 |8 v  z    int _round; //iteration round to encrypt or decrypt
  X1 [8 a3 H- i2 p% J  L    bool _isNetByte; //whether input bytes come from network
    byte _key[16]; //encrypt or decrypt key
};

) Y5 s0 [& c' l0 b" I- d1 ]( N4 I#endif/*TEA_H*/

天云上人

1 #include "tea.h"
: T/ K* o) G) {/ u8 U  s 2 #include <cstring> //for memcpy,memset
3  
4 using namespace std;
5  
6 TEA::TEA(const byte *key, int round /*= 32*/, bool isNetByte /*= false*/)
7 :_round(round)
8 ^& F4 G9 a" x7 G7 v; P 8 ,_isNetByte(isNetByte) {
9     if (key != 0)
10         memcpy(_key, key, 16);
11     else
12         memset(_key, 0, 16);
13 }
14  
9 [# L, x. g7 {9 [6 H5 i, {15 TEA::TEA(const TEA &rhs)
+ P* }' q( h8 |* x, w16 :_round(rhs._round)
9 L1 _9 r4 ?" Y5 I" {17 ,_isNetByte(rhs._isNetByte) {
18     memcpy(_key, rhs._key, 16);
8 D) _" W7 ]2 I' t8 e' y19 }
20  
+ k2 R' |! I2 T  p0 ^0 Y. ~21 TEA& TEA::operator=(const TEA &rhs) {
22     if (&rhs != this) {
23         _round = rhs._round;
4 s" r" x, o: `) z24         _isNetByte = rhs._isNetByte;
3 P/ W0 N8 L' Z+ |25         memcpy(_key, rhs._key, 16);
26     }
1 o/ e7 L4 d/ a6 m1 V27     return *this;
2 I) j( k" p6 F( z0 a. ]# v28 }
  J3 V0 h% R; k; [! o29  
30 void TEA::encrypt(const byte *in, byte *out) {
31     encrypt((const ulong*)in, (ulong*)out);
32 }
2 N' O* f4 R0 p* M3 \/ A33  
( L/ F/ @* w% X3 c4 ^6 o34 void TEA::decrypt(const byte *in, byte *out) {
0 W: P/ V, K. e: Z1 T/ E& _2 y7 V35     decrypt((const ulong*)in, (ulong*)out);
: Q; i3 `+ w" R* b8 n0 {36 }
37  
- Z# p9 _1 ^# s38 void TEA::encrypt(const ulong *in, ulong *out) {
39  
40     ulong *k = (ulong*)_key;
41     register ulong y = ntoh(in[0]);
42     register ulong z = ntoh(in[1]);
  _: \* \7 F' }43     register ulong a = ntoh(k[0]);
44     register ulong b = ntoh(k[1]);
1 H! p+ {1 C  [+ l  Z0 m& Y45     register ulong c = ntoh(k[2]);
: s1 S* N6 ^& Q46     register ulong d = ntoh(k[3]);
47     register ulong delta = 0x9E3779B9; /* (sqrt(5)-1)/2*2^32 */
: c2 I- k/ ?: c& r9 O3 |5 ^* ?48     register int round = _round;
6 N& ~: U5 b7 Y, f2 f: ?9 @49     register ulong sum = 0;
# e( ^6 A8 i: ?7 U) l50  
51     while (round--) {    /* basic cycle start */
52         sum += delta;
53         y += ((z << 4) + a) ^ (z + sum) ^ ((z >> 5) + b);
54         z += ((y << 4) + c) ^ (y + sum) ^ ((y >> 5) + d);
$ U. g1 i3 J8 n- e% L9 Q55     }    /* end cycle */
56     out[0] = ntoh(y);
0 ~% A9 u% N( Q* K57     out[1] = ntoh(z);
+ y4 f: v; }$ `) Z) a- V58 }
" I! B4 t3 Q; K2 k  j  Y59  
60 void TEA::decrypt(const ulong *in, ulong *out) {
61  
7 z6 M2 {0 |8 @5 M# P62     ulong *k = (ulong*)_key;
  C9 }. _% w8 F& U, P& y63     register ulong y = ntoh(in[0]);
64     register ulong z = ntoh(in[1]);
: Q+ c3 Q( r1 n) m  J65     register ulong a = ntoh(k[0]);
! v+ r- C$ E8 K66     register ulong b = ntoh(k[1]);
67     register ulong c = ntoh(k[2]);
1 ?  P! v, y& P* F) o, E) ]' F68     register ulong d = ntoh(k[3]);
69     register ulong delta = 0x9E3779B9; /* (sqrt(5)-1)/2*2^32 */
70     register int round = _round;
. L1 J' h8 I* h) ^3 t6 f71     register ulong sum = 0;
72  
. ]  K7 t& J5 k8 f73     if (round == 32)
74         sum = 0xC6EF3720; /* delta << 5*/
75     else if (round == 16)
  a" u7 \/ u- f/ }76         sum = 0xE3779B90; /* delta << 4*/
0 }, Q: c6 N* M2 p0 Z% ?: w7 o& E$ k! d77     else
78         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);
9 n0 }* c7 T; Q! M) T82         y -= ((z << 4) + a) ^ (z + sum) ^ ((z >> 5) + b);
83         sum -= delta;
84     }    /* end cycle */
$ A' ]" S1 \7 Z, N3 \5 R6 O85     out[0] = ntoh(y);
86     out[1] = ntoh(z);
5 H4 |0 b' u4 z8 U7 [- t87 }
; O3 K' z" |' D$ r6 K
需要说明的是TEA的构造函数：
9 P, O% u5 S. y% x6 [6 GTEA(const byte *key, int round = 32, bool isNetByte = false);
1.key - 加密或解密用的128-bit(16byte)密钥。
2.round - 加密或解密的轮数，常用的有64，32，16。
# d2 i. z* q0 U2 V6 {3.isNetByte - 用来标记待处理的字节是不是来自网络，为true时在加密/解密前先要转换成本地字节，执行加密/解密，然后再转换回网络字节。偷偷告诉你，QQ就是这样做的！
5 g& V2 t# a2 X) O8 f
最后当然少不了测试代码：

天云上人

1 #include "tea.h"
2 #include "util.h"
3 #include <iostream>
4  
8 K! F0 x# j5 W5 }0 x+ M0 c 5 using namespace std;
6  
7 int main() {
1 H! z4 G1 N3 E! L; J3 z2 e6 b9 ^ 8  
; g; ~7 C# E' d 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");
8 c# _3 k5 ?4 C' M: \8 F- U11     const int SIZE_IN = 8, SIZE_OUT = 8, SIZE_KEY = 16;
9 l& I2 D/ ]" @8 A; l6 }7 Q7 ~; Y12     byte plain[SIZE_IN], crypt[SIZE_OUT], key[SIZE_KEY];
13  
14     size_t size_in = hexStringToBytes(plainStr, plain);
15     size_t size_key = hexStringToBytes(keyStr, key);
16  
$ i9 q8 L' x. n" o17     if (size_in != SIZE_IN || size_key != SIZE_KEY)
0 E- B% ^" M; k. K! U/ I# U5 y18         return -1;
9 p" _  l6 u, A- o19  
20     cout << "Plain: " << bytesToHexString(plain, size_in) << endl;
21     cout << "Key  : " << bytesToHexString(key, size_key) << endl;
22  
$ H3 x0 R7 j5 s  A& q23     TEA tea(key, 16, true);
! S0 H4 w0 B% }9 J1 {% p24     tea.encrypt(plain, crypt);
1 Z+ W5 Z* K9 {( y- x5 @25     cout << "Crypt: " << bytesToHexString(crypt, SIZE_OUT) << endl;
; |: j; x$ d6 ^/ t  B+ q26  
27     tea.decrypt(crypt, plain);
7 P0 E- f% H/ I* J5 A28     cout << "Plain: " << bytesToHexString(plain, SIZE_IN) << endl;
) I8 c( [& d) G3 W$ o$ Z& l3 X29     return 0;
30 }
0 M+ {% }# B- o4 F6 ]9 H7 M
本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/sailing0123/archive/2008/04/28/2339231.aspx
运行结果：
  [- |9 d2 e2 ~- h4 p4 MPlain: AD DE E2 DB B3 E2 DB B3
Key  : 3A DA 75 21 DB E2 DB B3 11 B4 49 01 A5 C6 EA D4
9 {/ f' T& V. N1 dCrypt: 3B 3B 4D 8C 24 3A FD F2
. W/ O5 a+ k! B# \: }' J4 ?5 L/ OPlain: AD DE E2 DB B3 E2 DB B3