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 */
   
4.      unsigned long delta=0x9e3779b9;                 /* a key schedule constant */
   ! o/ c  M# |: ?
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;
   2 ]7 S, K- B- I4 |$ Z  B. v9 j" O
8.          y += ((z<<4) + a) ^ (z + sum) ^ ((z>>5) + b);
   
9.          z += ((y<<4) + c) ^ (y + sum) ^ ((y>>5) + d);/* end cycle */
   & d: w# }" f" }1 E( \
10.      }
    
11.      v[0]=y;
    
12.      v[1]=z;
    
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 */
    
17.      unsigned long delta=0x9e3779b9;                  /* a key schedule constant */
    4 O! t0 ~; `9 M! M) {6 F2 a
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);
    & l6 a- l0 u0 o! m: v8 s
22.          sum -= delta;                                /* end cycle */
    
23.      }
    # j6 _6 ?& w6 j# r. Q$ k4 K& G8 u6 E
24.      v[0]=y;
    + G4 j/ [( J9 i( W2 w
25.      v[1]=z;
    
26. }
    

复制代码

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

天云上人

#ifndef UTIL_H
6 |9 g3 i: j  d; r#define UTIL_H
% H7 a; K* j& ^4 P4 W6 }& j
#include <string>
#include <cmath>
#include <cstdlib>
3 a7 g2 K9 \# b6 p1 O) {2 C
& k! T/ B+ V" r9 Ctypedef unsigned char byte;
typedef unsigned long ulong;
- `3 y8 t, t* v
3 b9 Z9 [/ F! \: v) I- f9 q0 jinline double logbase(double base, double x) {
: ?) E4 ~" g7 W4 B6 X1 x- l    return log(x)/log(base);
}

/*
# p! f# r, t; |0 u' e) ]*convert int to hex char.
*example:10 -> 'A',15 -> 'F'
3 H+ U  m- e8 N, G7 n0 N3 }' ^4 a1 m*/
  L$ _) m) W; `& Zchar intToHexChar(int x);
# ^/ r$ x1 r5 r* X7 D
& A  U' y5 P6 N/ m  Y. J  K/*
( p+ T" v2 l3 L4 K/ ~*convert hex char to int.
3 o! N2 Q# z2 B5 \+ u*example:'A' -> 10,'F' -> 15
0 n9 i: p  c- E; g*/
  [3 T& a* n% S  ?6 Kint hexCharToInt(char hex);
9 J5 ^2 {6 l' D+ X, ?" {6 r' q2 v
9 w0 p: j% y/ |" u- Wusing std::string;
/*
: q" S! z9 x8 f5 f* K*convert a byte array to hex string.
*hex string format example:"AF B0 80 7D"
*/
string bytesToHexString(const byte *in, size_t size);

; s0 b  n. y2 [& e3 J$ L" \/*
*convert a hex string to a byte array.
: V% d  }! a# t+ m% s*hex string format example:"AF B0 80 7D"
*/
size_t hexStringToBytes(const string &str, byte *out);
. O$ S' x" y3 L5 U6 o
#endif/*UTIL_H*/

天云上人

#include "util.h"
+ b' J6 L& ~% R8 M& K! C  b#include <vector>

using namespace std;
' _4 n7 B- s& S+ _7 k7 A
( x+ |) }3 S7 b% Q6 g$ M1 E% o% Hchar intToHexChar(int x) {
: h7 q7 v% s( \* s* ?" r- f    static const char HEX[16] = {
4 J  O/ R+ G7 w9 X* w2 S2 g8 C        '0', '1', '2', '3',
        '4', '5', '6', '7',
        '8', '9', 'A', 'B',
        'C', 'D', 'E', 'F'
    };
    return HEX[x];
}
; m: ?/ {6 X) F0 U& O. ~
4 F& b9 M8 ~9 b0 V8 _$ Fint hexCharToInt(char hex) {
    hex = toupper(hex);
2 _4 r3 E% }) Y0 h7 V7 f    if (isdigit(hex))
+ c: d/ J, S: b' B9 B, N/ ~: [        return (hex - '0');
    if (isalpha(hex))
% D( X$ L" H+ [: N" A        return (hex - 'A' + 10);
    return 0;
}

8 T# B( Y  F& _string bytesToHexString(const byte *in, size_t size) {
/ I% N; R' x+ Y    string str;
9 h1 W8 B" j4 I" u( {- P) ?/ r) e# ~    for (size_t i = 0; i < size; ++i) {
4 ]: X0 M" d  M( t" ]: U) X- s- c  t        int t = in[i];
7 ?! N1 \  D& l) D3 I0 j! o0 l: b        int a = t / 16;
        int b = t % 16;
, M/ i& F" ^, M- H( K        str.append(1, intToHexChar(a));
        str.append(1, intToHexChar(b));
        if (i != size - 1)
            str.append(1, ' ');
' P1 Q3 m2 z" d# f& R7 F, [7 t    }
: Y5 t$ X0 F: B- T# S* h    return str;
}

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

    vector<string> vec;
7 m2 f8 F" m4 g$ M. E  I  I    string::size_type currPos = 0, prevPos = 0;
    while ((currPos = str.find(' ', prevPos)) != string::npos) {
        string b(str.substr(prevPos, currPos - prevPos));
6 o1 K% i: \0 [8 J# \- t8 T        vec.push_back(b);
        prevPos = currPos + 1;
# V4 d  ~% J2 ~0 G    }
$ {7 J, \0 o3 @' }# I, R    if (prevPos < str.size()) {
+ w+ a5 Q- q2 W+ Z! N7 k8 N        string b(str.substr(prevPos));
        vec.push_back(b);
    }
* W) G4 T2 }  d% f) X7 Y0 a1 @    typedef vector<string>::size_type sz_type;
# X6 z0 h8 C. z1 J; `5 f    sz_type size = vec.size();
, l4 {& s* b: @" V5 H$ @    for (sz_type i = 0; i < size; ++i) {
        int a = hexCharToInt(vec[i][0]);
- q" q. z% b. I: ]' M; z- Q        int b = hexCharToInt(vec[i][1]);
) Y+ {8 Y8 _8 S: I        out[i] = a * 16 + b;
& N9 x. T9 k8 f5 G1 i, z    }
    return size;
}

天云上人

#ifndef TEA_H
#define TEA_H

3 o* W( }8 W' d/ ^4 i1 i" o; p/*
*for htonl,htonl
*do remember link "ws2_32.lib"
6 q* q8 u4 @; z0 d- U7 v, P. q/ X; V*/
( j* {: T; p9 Y#include <winsock2.h>
$ r2 P+ b. E3 }. \& M( k4 X#include "util.h"

0 {) W# T' z0 E8 m& yclass TEA {
public:
9 \# V+ _. ?5 L0 j& A* ]4 u$ S    TEA(const byte *key, int round = 32, bool isNetByte = false);
  M6 \6 A' S1 V( p    TEA(const TEA &rhs);
    TEA& operator=(const TEA &rhs);
8 \  h( `8 Y# v7 Q$ h    void encrypt(const byte *in, byte *out);
    void decrypt(const byte *in, byte *out);
private:
    void encrypt(const ulong *in, ulong *out);
    void decrypt(const ulong *in, ulong *out);
% K$ ]) d3 a; @' ]' W$ q    ulong ntoh(ulong netlong) { return _isNetByte ? ntohl(netlong) : netlong; }
    ulong hton(ulong hostlong) { return _isNetByte ? htonl(hostlong) : hostlong; }
* `" l5 U4 [/ p/ q$ ]: Z# V  Hprivate:
    int _round; //iteration round to encrypt or decrypt
    bool _isNetByte; //whether input bytes come from network
; ]& a4 `' {* T8 h    byte _key[16]; //encrypt or decrypt key
};

#endif/*TEA_H*/

天云上人

1 #include "tea.h"
; M2 ]# \9 O0 ~# d( |* a 2 #include <cstring> //for memcpy,memset
3  
4 using namespace std;
5  
: d3 E: u" x) C6 g* B, O 6 TEA::TEA(const byte *key, int round /*= 32*/, bool isNetByte /*= false*/)
) F/ A* ~( Z3 t# u 7 :_round(round)
8 ,_isNetByte(isNetByte) {
9     if (key != 0)
% h) Z! T5 W0 j6 e7 C. [10         memcpy(_key, key, 16);
- i/ |8 T: j0 G3 ]! A% l11     else
/ ]+ K$ Q& ]6 y5 q12         memset(_key, 0, 16);
13 }
14  
15 TEA::TEA(const TEA &rhs)
16 :_round(rhs._round)
( ?% B$ h& q/ B7 I17 ,_isNetByte(rhs._isNetByte) {
18     memcpy(_key, rhs._key, 16);
19 }
20  
21 TEA& TEA::operator=(const TEA &rhs) {
: X3 k2 x; k4 ^( i' P; K22     if (&rhs != this) {
) V. x" L7 l9 E- u6 l; s23         _round = rhs._round;
- }$ q' v1 c1 r8 R24         _isNetByte = rhs._isNetByte;
- U3 z5 C- g* W+ d3 i( Q& d8 W25         memcpy(_key, rhs._key, 16);
26     }
27     return *this;
2 z2 u- G3 `. P1 ~& }7 x28 }
  y% X& o: ~/ d* ]29  
( W  a# b8 [  c0 {' K  d1 _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) {
2 b  R- G0 k) q: [4 M4 S35     decrypt((const ulong*)in, (ulong*)out);
36 }
( j+ ?% A* t. T' g/ E% ~6 \4 q37  
38 void TEA::encrypt(const ulong *in, ulong *out) {
3 d5 `# X9 @, K/ ^- D39  
40     ulong *k = (ulong*)_key;
41     register ulong y = ntoh(in[0]);
42     register ulong z = ntoh(in[1]);
# k: P3 j& B* `0 b43     register ulong a = ntoh(k[0]);
44     register ulong b = ntoh(k[1]);
45     register ulong c = ntoh(k[2]);
# R- @( o' N- s4 U. v- S46     register ulong d = ntoh(k[3]);
47     register ulong delta = 0x9E3779B9; /* (sqrt(5)-1)/2*2^32 */
" G: j/ U" |9 B4 `$ j8 n48     register int round = _round;
49     register ulong sum = 0;
50  
51     while (round--) {    /* basic cycle start */
52         sum += delta;
% T6 L& `& N2 o! O" U53         y += ((z << 4) + a) ^ (z + sum) ^ ((z >> 5) + b);
5 I: R- c4 a; E' k54         z += ((y << 4) + c) ^ (y + sum) ^ ((y >> 5) + d);
55     }    /* end cycle */
) Q" q7 F6 L6 x, i$ Y% a3 D56     out[0] = ntoh(y);
$ G1 H7 t; q( [# Y57     out[1] = ntoh(z);
58 }
59  
% T6 p! X; I1 f) k- I60 void TEA::decrypt(const ulong *in, ulong *out) {
61  
62     ulong *k = (ulong*)_key;
, w& Q3 ]0 G: l* [8 S4 J63     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]);
) w& @5 Z' \% d1 n% W0 B67     register ulong c = ntoh(k[2]);
& g( {6 `6 s/ G! E68     register ulong d = ntoh(k[3]);
0 _8 Q# P6 L' a4 c, k2 y69     register ulong delta = 0x9E3779B9; /* (sqrt(5)-1)/2*2^32 */
70     register int round = _round;
2 p# G5 j/ e! |% \) m7 {71     register ulong sum = 0;
72  
& B( N$ a8 M$ V$ w) H73     if (round == 32)
74         sum = 0xC6EF3720; /* delta << 5*/
75     else if (round == 16)
7 U7 L2 w( B# K2 @" G76         sum = 0xE3779B90; /* delta << 4*/
# X& F8 L# A: C77     else
- g9 V, E+ }" {- X5 @0 a  ?78         sum = delta << static_cast<int>(logbase(2, round));
* _: r+ S3 {/ X% C79  
80     while (round--) {    /* basic cycle start */
. G8 F4 n- ~9 Y* ^! d9 l81         z -= ((y << 4) + c) ^ (y + sum) ^ ((y >> 5) + d);
82         y -= ((z << 4) + a) ^ (z + sum) ^ ((z >> 5) + b);
* M8 B3 s- }$ ?) ?4 f83         sum -= delta;
% d1 d+ w) X3 L  F3 n0 E2 k" I84     }    /* end cycle */
3 `1 S4 u1 z5 Q9 K; N85     out[0] = ntoh(y);
& b6 j* R( ~5 k86     out[1] = ntoh(z);
87 }

需要说明的是TEA的构造函数：
. r7 t  H+ e: w6 H% _# E# [TEA(const byte *key, int round = 32, bool isNetByte = false);
1.key - 加密或解密用的128-bit(16byte)密钥。
7 q9 ?+ E  M+ S9 T" e3 M2.round - 加密或解密的轮数，常用的有64，32，16。
3.isNetByte - 用来标记待处理的字节是不是来自网络，为true时在加密/解密前先要转换成本地字节，执行加密/解密，然后再转换回网络字节。偷偷告诉你，QQ就是这样做的！

( _, p( {; \8 ]" A, d最后当然少不了测试代码：

天云上人

1 #include "tea.h"
2 #include "util.h"
: z4 X# ^$ Q, b# O' q# Z  f& O 3 #include <iostream>
4  
/ b$ G# [- ^  D  c 5 using namespace std;
# w: K& S$ k, ~ 6  
& p) X$ X' W7 r" T. u' @ 7 int main() {
  l0 ?8 _: c# \+ c 8  
1 V" ]* p5 t: Y' { 9     const string plainStr("AD DE E2 DB B3 E2 DB B3");
/ x+ F6 `1 L* X+ u& [( F: H7 Q10     const string keyStr("3A DA 75 21 DB E2 DB B3 11 B4 49 01 A5 C6 EA D4");
9 y3 F; n% m( }& G11     const int SIZE_IN = 8, SIZE_OUT = 8, SIZE_KEY = 16;
% }3 d& D2 x7 s: |# A12     byte plain[SIZE_IN], crypt[SIZE_OUT], key[SIZE_KEY];
: p! |  a0 N# D3 ?! }13  
14     size_t size_in = hexStringToBytes(plainStr, plain);
15     size_t size_key = hexStringToBytes(keyStr, key);
6 w8 m: \7 V6 z7 B16  
17     if (size_in != SIZE_IN || size_key != SIZE_KEY)
18         return -1;
6 \+ O4 [$ ^* j3 o7 {2 y$ V19  
6 K& d3 B/ B. X20     cout << "Plain: " << bytesToHexString(plain, size_in) << endl;
21     cout << "Key  : " << bytesToHexString(key, size_key) << endl;
$ z9 S1 y/ S; Y22  
23     TEA tea(key, 16, true);
24     tea.encrypt(plain, crypt);
9 g9 y9 Y$ g* p25     cout << "Crypt: " << bytesToHexString(crypt, SIZE_OUT) << endl;
26  
4 Z  H3 t+ F2 ?/ t" @7 b/ i27     tea.decrypt(crypt, plain);
5 v8 t$ o* b" {6 Y- B& f28     cout << "Plain: " << bytesToHexString(plain, SIZE_IN) << endl;
- B# R0 ?0 S: t- q  U  H( c29     return 0;
! ^6 m, I5 z. b' m! Y30 }

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/sailing0123/archive/2008/04/28/2339231.aspx
: V* l; E8 K0 |8 F4 J: i运行结果：
3 l2 q7 C  i" R# g% hPlain: 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
% b5 `- i8 a, U- e4 t& nPlain: AD DE E2 DB B3 E2 DB B3