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 */
   5 }: U( _: o0 U! V3 p
4.      unsigned long delta=0x9e3779b9;                 /* a key schedule constant */
   
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 */
   5 i  n" r+ ^  x9 F4 y8 r% r3 F; C
10.      }
    
11.      v[0]=y;
    
12.      v[1]=z;
    - v- ^3 k  c% A1 q) L; A
13. }
    
14.   
    
15. void decrypt(unsigned long *v, unsigned long *k) {
    
16.      unsigned long y=v[0], z=v[1], sum=0xC6EF3720, i; /* set up */
    ' D: z' O6 v, }5 e, @0 f
17.      unsigned long delta=0x9e3779b9;                  /* a key schedule constant */
    * c! D. y& C/ Y3 J' z
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 */
    4 t- H( C; T2 V) |
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 */
    
23.      }
    
24.      v[0]=y;
    # S% G7 H3 J0 Q, n
25.      v[1]=z;
    
26. }
    , u$ {# `! _" `

复制代码

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

天云上人

#ifndef UTIL_H
4 C3 ], p/ t7 w# s. I' I#define UTIL_H
8 ], g; @9 S: k# T  m
#include <string>
#include <cmath>
1 t0 q6 W% Y& Q/ x1 e#include <cstdlib>
/ q6 e$ ^4 U" K6 H$ ~4 c- p
% B. l% X; I3 A. Otypedef unsigned char byte;
4 d1 e% O4 w: }$ e% |7 N3 R% ]typedef unsigned long ulong;
: F' B) k* a$ Q; t0 t+ {: v/ P
inline double logbase(double base, double x) {
    return log(x)/log(base);
}
3 _& m2 ^5 A' A; Y4 g& i
8 a% v: ~) p9 b) M  J, t  ?/*
! E3 X4 H' S! A% j*convert int to hex char.
4 m2 ^4 Q1 ~& S! e5 ~  @*example:10 -> 'A',15 -> 'F'
2 L0 m" I; ^  J- [1 K*/
char intToHexChar(int x);

" V1 v2 `9 C7 _/*
*convert hex char to int.
*example:'A' -> 10,'F' -> 15
*/
int hexCharToInt(char hex);

3 l( \# K' |0 R2 }7 V% b+ Qusing std::string;
/ y. x. ?/ k/ N: n1 A/ v, m+ Y/*
& X9 e) s1 v4 O6 e7 e/ A  Z*convert a byte array to hex string.
*hex string format example:"AF B0 80 7D"
*/
& H; B+ D  q$ {9 }3 Y. K* Istring bytesToHexString(const byte *in, size_t size);
0 w+ ~! i. D5 `; F. t8 U8 s
2 e( Q, h- r2 y. b* R+ f0 U: q/*
4 L: ]% [4 h, }) K  r$ @3 V*convert a hex string to a byte array.
*hex string format example:"AF B0 80 7D"
*/
* X" t; \0 \* N) |, c4 wsize_t hexStringToBytes(const string &str, byte *out);
# o8 w# B8 g; G9 k% f
8 d5 [% Z1 S  k2 \0 J5 [4 m#endif/*UTIL_H*/

天云上人

#include "util.h"
#include <vector>
- b* `: |+ R% E% H4 }
! X& Y0 c3 A+ @, @/ V7 Y& x7 Kusing namespace std;
2 {. G6 S7 O0 Y, w( o* }
1 Y- a  `1 b* y5 y- k# ]char intToHexChar(int x) {
- m( e5 T' ]" _    static const char HEX[16] = {
        '0', '1', '2', '3',
        '4', '5', '6', '7',
! W0 S* n6 y3 a$ j        '8', '9', 'A', 'B',
+ `4 [0 P1 k0 n+ C; t: Z! n8 b        'C', 'D', 'E', 'F'
    };
    return HEX[x];
}

, V/ ~) X% }0 C% s6 Q$ X- cint hexCharToInt(char hex) {
# [- k9 B" N1 I/ b7 X8 n    hex = toupper(hex);
) l) N0 z1 Z# l- O2 W    if (isdigit(hex))
$ O8 R8 s! b5 o* E1 d7 F        return (hex - '0');
    if (isalpha(hex))
  R7 M, V$ ^7 W  ?$ r9 C        return (hex - 'A' + 10);
    return 0;
: }% ~) K4 ]! q+ Q/ _}

9 _5 |) F0 i3 }% c4 Ostring bytesToHexString(const byte *in, size_t size) {
) Q& T/ Z9 V% c    string str;
7 M& W6 q' V! t    for (size_t i = 0; i < size; ++i) {
        int t = in[i];
        int a = t / 16;
3 o2 a4 y9 q* c9 h        int b = t % 16;
        str.append(1, intToHexChar(a));
        str.append(1, intToHexChar(b));
        if (i != size - 1)
            str.append(1, ' ');
" D1 |% e5 G) @4 Z    }
; n. e: m3 q" g" }0 K6 J    return str;
) C5 P, S7 {" r6 `2 ^9 U$ _}

size_t hexStringToBytes(const string &str, byte *out) {
; }6 {2 n# K# z- ^7 [, w& \
    vector<string> vec;
    string::size_type currPos = 0, prevPos = 0;
    while ((currPos = str.find(' ', prevPos)) != string::npos) {
! Y; ~! b, M) \# s+ _3 s* _5 E7 w        string b(str.substr(prevPos, currPos - prevPos));
' I4 \$ p) u' S  {        vec.push_back(b);
        prevPos = currPos + 1;
- Z! r6 `. P6 g5 I) G: k4 O    }
) {' R; g9 F& R- W! N% [    if (prevPos < str.size()) {
/ X2 }1 i0 p# j        string b(str.substr(prevPos));
        vec.push_back(b);
    }
    typedef vector<string>::size_type sz_type;
; x. w4 k' X0 A5 n    sz_type size = vec.size();
5 \7 E' y& Y4 }1 B& r8 T% x; u    for (sz_type i = 0; i < size; ++i) {
. o& l: C2 O% D        int a = hexCharToInt(vec[i][0]);
        int b = hexCharToInt(vec[i][1]);
        out[i] = a * 16 + b;
, k6 h! f3 y5 a9 q6 N! B, U    }
    return size;
3 {6 {5 a7 W- }  }}

天云上人

#ifndef TEA_H
* o" l; H/ ?+ N7 e7 G#define TEA_H
) I- Q/ O& \- ]4 I  z* k
/*
*for htonl,htonl
*do remember link "ws2_32.lib"
. |1 g0 T$ `# a% @7 y7 x+ Z) T3 i*/
#include <winsock2.h>
" p/ r9 U; @! q$ d* D  c; L#include "util.h"
3 c" w! J5 V: i2 o' r
class TEA {
& l3 D+ `/ `; G( R& Wpublic:
    TEA(const byte *key, int round = 32, bool isNetByte = false);
" a  Z8 q" `) e4 Z    TEA(const TEA &rhs);
/ r& ?# V4 p9 V1 R; M  o    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 j8 D7 B/ X8 k2 d: @" d    void decrypt(const ulong *in, ulong *out);
    ulong ntoh(ulong netlong) { return _isNetByte ? ntohl(netlong) : netlong; }
    ulong hton(ulong hostlong) { return _isNetByte ? htonl(hostlong) : hostlong; }
private:
- J, w$ L+ \$ Z$ ]& H    int _round; //iteration round to encrypt or decrypt
    bool _isNetByte; //whether input bytes come from network
    byte _key[16]; //encrypt or decrypt key
};

#endif/*TEA_H*/

天云上人

1 #include "tea.h"
2 #include <cstring> //for memcpy,memset
0 l% T: P/ Q2 e" X: `& S; V 3  
1 e$ Z/ u2 @! G( N8 P 4 using namespace std;
5  
! o+ s* [% Z6 L. K' w: n% S, n 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
/ ^$ r/ Z; [! n6 `  D% p12         memset(_key, 0, 16);
% d& h# t+ l# c% D13 }
14  
15 TEA::TEA(const TEA &rhs)
16 :_round(rhs._round)
17 ,_isNetByte(rhs._isNetByte) {
1 v2 ~/ r& g" C18     memcpy(_key, rhs._key, 16);
: ]; x( r5 v( }: n1 y19 }
6 I. v; u9 h0 S2 F8 L3 e20  
- Y* ?- \+ q. C- Z21 TEA& TEA::operator=(const TEA &rhs) {
9 k8 |4 x3 R) X& C* @; \& p9 }22     if (&rhs != this) {
23         _round = rhs._round;
24         _isNetByte = rhs._isNetByte;
) \, _! w/ W7 Z8 [7 x9 ?( N; |25         memcpy(_key, rhs._key, 16);
( ?7 l' K* u8 h8 S. [, F26     }
/ J! O% b* r* R# {& J/ Y) Y27     return *this;
28 }
29  
, v. d. W; q2 ^2 F. S# C30 void TEA::encrypt(const byte *in, byte *out) {
31     encrypt((const ulong*)in, (ulong*)out);
32 }
7 r& Y. K, B, _  p33  
! B) L6 ?) T+ {34 void TEA::decrypt(const byte *in, byte *out) {
35     decrypt((const ulong*)in, (ulong*)out);
" ]" y" @! `  i, d" E% f36 }
7 i. K  N! u, t* K; C7 r  x1 T# T37  
38 void TEA::encrypt(const ulong *in, ulong *out) {
, U7 b0 U2 @8 L% ?) j39  
40     ulong *k = (ulong*)_key;
41     register ulong y = ntoh(in[0]);
42     register ulong z = ntoh(in[1]);
: W: y( _! w: m4 H) ~; G5 |3 |43     register ulong a = ntoh(k[0]);
44     register ulong b = ntoh(k[1]);
$ P* p: j& x1 i( E! t+ D. _45     register ulong c = ntoh(k[2]);
46     register ulong d = ntoh(k[3]);
& Q/ U( B1 B9 ]" S47     register ulong delta = 0x9E3779B9; /* (sqrt(5)-1)/2*2^32 */
48     register int round = _round;
49     register ulong sum = 0;
& R) C5 N: _4 _+ L8 J50  
- F# B8 \* s4 H5 v/ ~51     while (round--) {    /* basic cycle start */
8 m& n  Q+ `. G9 v! B52         sum += delta;
  `. S! Y. _, G+ A- T5 D53         y += ((z << 4) + a) ^ (z + sum) ^ ((z >> 5) + b);
54         z += ((y << 4) + c) ^ (y + sum) ^ ((y >> 5) + d);
55     }    /* end cycle */
' f' E' D8 D5 u9 v56     out[0] = ntoh(y);
57     out[1] = ntoh(z);
58 }
/ g9 _8 F5 E# G59  
  e* |6 I8 l: g- |% a" x60 void TEA::decrypt(const ulong *in, ulong *out) {
, `" P: c6 }. q( F8 A61  
; s/ f5 j7 y% k& ~3 m4 N5 \62     ulong *k = (ulong*)_key;
- Z- D) @' e. q) d63     register ulong y = ntoh(in[0]);
+ g2 E" E$ h3 M: j64     register ulong z = ntoh(in[1]);
65     register ulong a = ntoh(k[0]);
; n( M. \9 B" `66     register ulong b = ntoh(k[1]);
; J8 s3 C) ]* s; {  t( w+ d! ]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;
. O; F% |. O; z+ n  Z: O71     register ulong sum = 0;
6 n2 t' l! }1 W& N8 X7 m72  
73     if (round == 32)
  U# X8 H% v/ S! u74         sum = 0xC6EF3720; /* delta << 5*/
9 o* e  z7 V& F( v6 |75     else if (round == 16)
3 M; U' d# T8 A" v$ W76         sum = 0xE3779B90; /* delta << 4*/
4 d" u  M, ]+ [8 \$ e9 {77     else
& P1 R9 W) x. F% Y78         sum = delta << static_cast<int>(logbase(2, round));
79  
+ `' C3 l& H8 ]7 D; c80     while (round--) {    /* basic cycle start */
2 ~2 Z8 Y+ V) B: S' X) u+ \4 L/ m81         z -= ((y << 4) + c) ^ (y + sum) ^ ((y >> 5) + d);
82         y -= ((z << 4) + a) ^ (z + sum) ^ ((z >> 5) + b);
83         sum -= delta;
( O" J- ?8 w/ K7 }5 k# ]84     }    /* end cycle */
85     out[0] = ntoh(y);
# A: @9 ?/ m$ x) H4 J7 {86     out[1] = ntoh(z);
) x: C- f: l5 A: [4 M4 B87 }

/ s0 i/ w2 y  B6 V* n1 K% Z7 m需要说明的是TEA的构造函数：
TEA(const byte *key, int round = 32, bool isNetByte = false);
1.key - 加密或解密用的128-bit(16byte)密钥。
1 s8 F& S5 O( \! {% ^7 e! O; e3 X2.round - 加密或解密的轮数，常用的有64，32，16。
3.isNetByte - 用来标记待处理的字节是不是来自网络，为true时在加密/解密前先要转换成本地字节，执行加密/解密，然后再转换回网络字节。偷偷告诉你，QQ就是这样做的！

' \/ l7 s4 I' m. l$ O' e& v0 ~最后当然少不了测试代码：

天云上人

1 #include "tea.h"
3 a1 Z+ j* f/ W+ j 2 #include "util.h"
" X+ k2 i$ H4 E# }. T# n' d 3 #include <iostream>
, k; }8 X# S- i 4  
5 using namespace std;
2 w3 \' X. x1 S, x/ G% h 6  
) l  W$ g' P/ d0 A$ y3 u1 R# ? 7 int main() {
8  
' G' ]/ L* u) ? 9     const string plainStr("AD DE E2 DB B3 E2 DB B3");
- Z$ K$ }/ J# @9 ^/ W; Q$ z( N10     const string keyStr("3A DA 75 21 DB E2 DB B3 11 B4 49 01 A5 C6 EA D4");
6 y+ s# }6 C# P) J+ [11     const int SIZE_IN = 8, SIZE_OUT = 8, SIZE_KEY = 16;
1 ]" Q4 c' H4 r" n6 e7 R$ w, W7 ]+ V12     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);
) e' t1 B/ x6 X( f( h' E16  
17     if (size_in != SIZE_IN || size_key != SIZE_KEY)
) Y$ W8 B3 r) v/ L) \5 M7 K18         return -1;
19  
20     cout << "Plain: " << bytesToHexString(plain, size_in) << endl;
21     cout << "Key  : " << bytesToHexString(key, size_key) << endl;
. T$ @* Z# z: M22  
23     TEA tea(key, 16, true);
) K  X9 a0 [1 D" Y4 L& b24     tea.encrypt(plain, crypt);
25     cout << "Crypt: " << bytesToHexString(crypt, SIZE_OUT) << endl;
) O  h; g2 [- x! j8 X- x26  
, ~' x0 {6 r7 _% M! i  t, D# {: Q27     tea.decrypt(crypt, plain);
28     cout << "Plain: " << bytesToHexString(plain, SIZE_IN) << endl;
29     return 0;
  g$ B, ?. Z9 H* ~5 D30 }
6 h& v2 ]. b5 ]
本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/sailing0123/archive/2008/04/28/2339231.aspx
5 K  G, I" [, ]1 @运行结果：
5 i2 K( Z0 e% [; h; iPlain: 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
Crypt: 3B 3B 4D 8C 24 3A FD F2
Plain: AD DE E2 DB B3 E2 DB B3