tea演算法破解

Ⅰ 如何實現php的TEA演算法

演算法簡單,而且效率高,每次可以操作8個位元組的數據,加密解密的KEY為16位元組,即包含4個int數據的int型數組,加密輪數應為8的倍數,一般比較常用的輪數為64,32,16,QQ原來就是用TEA16來還原密碼的.

TEA演算法

核心為：

#include<stdint.h>

voidencrypt(uint32_t*v,uint32_t*k){
uint32_tv0=v[0],v1=v[1],sum=0,i;/*setup*/
uint32_tdelta=0x9e3779b9;/*akeyscheleconstant*/
uint32_tk0=k[0],k1=k[1],k2=k[2],k3=k[3];/*cachekey*/
for(i=0;i<32;i++){/*basiccyclestart*/
sum+=delta;
v0+=((v1<<4)+k0)^(v1+sum)^((v1>>5)+k1);
v1+=((v0<<4)+k2)^(v0+sum)^((v0>>5)+k3);
}/*endcycle*/
v[0]=v0;v[1]=v1;
}

voiddecrypt(uint32_t*v,uint32_t*k){
uint32_tv0=v[0],v1=v[1],sum=0xC6EF3720,i;/*setup*/
uint32_tdelta=0x9e3779b9;/*akeyscheleconstant*/
uint32_tk0=k[0],k1=k[1],k2=k[2],k3=k[3];/*cachekey*/
for(i=0;i<32;i++){/*basiccyclestart*/
v1-=((v0<<4)+k2)^(v0+sum)^((v0>>5)+k3);
v0-=((v1<<4)+k0)^(v1+sum)^((v1>>5)+k1);
sum-=delta;
}/*endcycle*/
v[0]=v0;v[1]=v1;
}

PHP部分代碼非我原創，大家可以了解一下這方面的知識

<?php
$date='8345354023476-3434';
$key='12345';
$t=newtea();
$tea=$t->encrypt($date,$key);
$eetea=$t->decrypt($tea,$key);
var_mp($tea);
var_mp($eetea);
classtea{
private$a,$b,$c,$d;
private$n_iter;
publicfunction__construct(){
$this->setIter(32);
}
privatefunctionsetIter($n_iter){
$this->n_iter=$n_iter;
}
privatefunctiongetIter(){
return$this->n_iter;
}
publicfunctionencrypt($data,$key){
//resizedatato32bits(4bytes)
$n=$this->_resize($data,4);

//convertdatatolong
$data_long[0]=$n;
$n_data_long=$this->_str2long(1,$data,$data_long);

//resizedata_longto64bits(2longsof32bits)
$n=count($data_long);
if(($n&1)==1){
$data_long[$n]=chr(0);
$n_data_long++;
}

//resizekeytoamultipleof128bits(16bytes)
$this->_resize($key,16,true);
if(''==$key)
$key='0000000000000000';

//convertkeytolong
$n_key_long=$this->_str2long(0,$key,$key_long);

//encryptthelongdatawiththekey
$enc_data='';
$w=array(0,0);
$j=0;
$k=array(0,0,0,0);
for($i=0;$i<$n_data_long;++$i){
//getnextkeypartof128bits
if($j+4<=$n_key_long){
$k[0]=$key_long[$j];
$k[1]=$key_long[$j+1];
$k[2]=$key_long[$j+2];
$k[3]=$key_long[$j+3];
}else{
$k[0]=$key_long[$j%$n_key_long];
$k[1]=$key_long[($j+1)%$n_key_long];
$k[2]=$key_long[($j+2)%$n_key_long];
$k[3]=$key_long[($j+3)%$n_key_long];
}
$j=($j+4)%$n_key_long;

$this->_encipherLong($data_long[$i],$data_long[++$i],$w,$k);

//
$enc_data.=$this->_long2str($w[0]);
$enc_data.=$this->_long2str($w[1]);
}

return$enc_data;
}
publicfunctiondecrypt($enc_data,$key){
//convertdatatolong
$n_enc_data_long=$this->_str2long(0,$enc_data,$enc_data_long);

//resizekeytoamultipleof128bits(16bytes)
$this->_resize($key,16,true);
if(''==$key)
$key='0000000000000000';

//convertkeytolong
$n_key_long=$this->_str2long(0,$key,$key_long);

//decryptthelongdatawiththekey
$data='';
$w=array(0,0);
$j=0;
$len=0;
$k=array(0,0,0,0);
$pos=0;

for($i=0;$i<$n_enc_data_long;$i+=2){
//getnextkeypartof128bits
if($j+4<=$n_key_long){
$k[0]=$key_long[$j];
$k[1]=$key_long[$j+1];
$k[2]=$key_long[$j+2];
$k[3]=$key_long[$j+3];
}else{
$k[0]=$key_long[$j%$n_key_long];
$k[1]=$key_long[($j+1)%$n_key_long];
$k[2]=$key_long[($j+2)%$n_key_long];
$k[3]=$key_long[($j+3)%$n_key_long];
}
$j=($j+4)%$n_key_long;

$this->_decipherLong($enc_data_long[$i],$enc_data_long[$i+1],$w,$k);

//(removepadding)
if(0==$i){
$len=$w[0];
if(4<=$len){
$data.=$this->_long2str($w[1]);
}else{
$data.=substr($this->_long2str($w[1]),0,$len%4);
}
}else{
$pos=($i-1)*4;
if($pos+4<=$len){
$data.=$this->_long2str($w[0]);

if($pos+8<=$len){
$data.=$this->_long2str($w[1]);
}elseif($pos+4<$len){
$data.=substr($this->_long2str($w[1]),0,$len%4);
}
}else{
$data.=substr($this->_long2str($w[0]),0,$len%4);
}
}
}
return$data;
}
privatefunction_encipherLong($y,$z,&$w,&$k){
$sum=(integer)0;
$delta=0x9E3779B9;
$n=(integer)$this->n_iter;

while($n-->0){
//Cv0+=((v1<<4)+k0)^(v1+sum)^((v1>>5)+k1);
//Cv1+=((v0<<4)+k2)^(v0+sum)^((v0>>5)+k3);
$sum=$this->_add($sum,$delta);
$y=$this->_add($y,$this->_add(($z<<4),$this->a)^$this->_add($z,$sum)^$this->_add($this->_rshift($z,5),$this->b));
$z=$this->_add($z,$this->_add(($y<<4),$this->a)^$this->_add($y,$sum)^$this->_add($this->_rshift($y,5),$this->b));
}

$w[0]=$y;
$w[1]=$z;
}
privatefunction_decipherLong($y,$z,&$w,&$k){
//sum=delta<<5,ingeneralsum=delta*n
$sum=0xC6EF3720;
$delta=0x9E3779B9;
$n=(integer)$this->n_iter;

while($n-->0){
//Cv1-=((v0<<4)+k2)^(v0+sum)^((v0>>5)+k3);
//Cv0-=((v1<<4)+k0)^(v1+sum)^((v1>>5)+k1);
$z=$this->_add($z,-($this->_add(($y<<4),$this->a)^$this->_add($y,$sum)^$this->_add($this->_rshift($y,5),$this->b)));
$y=$this->_add($y,-($this->_add(($z<<4),$this->a)^$this->_add($z,$sum)^$this->_add($this->_rshift($z,5),$this->b)));
$sum=$this->_add($sum,-$delta);
}

$w[0]=$y;
$w[1]=$z;
}
privatefunction_resize(&$data,$size,$nonull=false){
$n=strlen($data);
$nmod=$n%$size;
if(0==$nmod)
$nmod=$size;

if($nmod>0){
if($nonull){
for($i=$n;$i<$n-$nmod+$size;++$i){
$data[$i]=$data[$i%$n];
}
}else{
for($i=$n;$i<$n-$nmod+$size;++$i){
$data[$i]=chr(0);
}
}
}
return$n;
}
privatefunction_hex2bin($str){
$len=strlen($str);
returnpack('H'.$len,$str);
}
privatefunction_str2long($start,&$data,&$data_long){
$n=strlen($data);

$tmp=unpack('N*',$data);
$j=$start;

foreach($tmpas$value)
$data_long[$j++]=$value;

return$j;
}
privatefunction_long2str($l){
returnpack('N',$l);
}


privatefunction_rshift($integer,$n){
//convertto32bits
if(0xffffffff<$integer||-0xffffffff>$integer){
$integer=fmod($integer,0xffffffff+1);
}

//converttounsignedinteger
if(0x7fffffff<$integer){
$integer-=0xffffffff+1.0;
}elseif(-0x80000000>$integer){
$integer+=0xffffffff+1.0;
}

//dorightshift
if(0>$integer){
$integer&=0x7fffffff;//removesignbitbeforeshift
$integer>>=$n;//rightshift
$integer|=1<<(31-$n);//setshiftedsignbit
}else{
$integer>>=$n;//usenormalrightshift
}

return$integer;
}
privatefunction_add($i1,$i2){
$result=0.0;

foreach(func_get_args()as$value){
//removesignifnecessary
if(0.0>$value){
$value-=1.0+0xffffffff;
}

$result+=$value;
}

//convertto32bits
if(0xffffffff<$result||-0xffffffff>$result){
$result=fmod($result,0xffffffff+1);
}

//converttosignedinteger
if(0x7fffffff<$result){
$result-=0xffffffff+1.0;
}elseif(-0x80000000>$result){
$result+=0xffffffff+1.0;
}

return$result;
}

//}}}
}
?>

上面的是TEA的演算法，XTEA的演算法為：

#include <stdint.h>

void encipher(unsigned int num_rounds, uint32_t v[2], uint32_t const k[4]) {

unsigned int i;

uint32_t v0=v[0], v1=v[1], sum=0, delta=0x9E3779B9;

for (i=0; i < num_rounds; i++) {

v0 += (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + k[sum & 3]);

sum += delta;

v1 += (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + k[(sum>>11) & 3]);

}

v[0]=v0; v[1]=v1;

}

void decipher(unsigned int num_rounds, uint32_t v[2], uint32_t const k[4]) {

unsigned int i;

uint32_t v0=v[0], v1=v[1], delta=0x9E3779B9, sum=delta*num_rounds;

for (i=0; i < num_rounds; i++) {

v1 &#8722;= (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + k[(sum>>11) & 3]);

sum &#8722;= delta;

v0 &#8722;= (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + k[sum & 3]);

}

v[0]=v0; v[1]=v1;

}

那PHP中只需要把運算的位置改下就OK

private function _teaencipherLong($y, $z, &$w, &$k) {

$sum = ( integer ) 0;

$delta = 0x9E3779B9;

$n = ( integer ) $this->n_iter;

while ( $n -- > 0 ) {

$y = $this->_add ( $y, $this->_add ( $z << 4 ^ $this->_rshift ( $z, 5 ), $z ) ^ $this->_add ( $sum, $k [$sum & 3] ) );

$sum = $this->_add ( $sum, $delta );

$z = $this->_add ( $z, $this->_add ( $y << 4 ^ $this->_rshift ( $y, 5 ), $y ) ^ $this->_add ( $sum, $k [$this->_rshift ( $sum, 11 ) & 3] ) );

}

$w [0] = $y;

$w [1] = $z;

}

private function _decipherLong($y, $z, &$w, &$k) {

// sum = delta<<5, in general sum = delta * n

$sum = 0xC6EF3720;

$delta = 0x9E3779B9;

$n = ( integer ) $this->n_iter;

while ( $n -- > 0 ) {

$z = $this->_add ( $z, - ($this->_add ( $y << 4 ^ $this->_rshift ( $y, 5 ), $y ) ^ $this->_add ( $sum, $k [$this->_rshift ( $sum, 11 ) & 3] )) );

$sum = $this->_add ( $sum, - $delta );

$y = $this->_add ( $y, - ($this->_add ( $z << 4 ^ $this->_rshift ( $z, 5 ), $z ) ^ $this->_add ( $sum, $k [$sum & 3] )) );

}

$w [0] = $y;

$w [1] = $z;

Ⅱ Tea演算法的疑問

我想你能搜到TEA演算法的源碼吧，不管如何，我也貼一份， encrypt是加密，decrpty是解密。 第一個輸入參數是要被加密/解密的信息，是64bit，也就是一個int32數組，數組是兩個元素。 第二個參數是128bit的密鑰，也就是4個元素的int32數組。密鑰你可以理解成密碼，只不過在TEA演算法中，要求密鑰必須是128bit。
所以，TEA演算法一次加密／解密64bit信息，如果你要加密/解密的信息長於64bit,那你要分多次進行，如果小於64bit，比如你只想加密一個數字 123,那你應該把這個信息補全到64bit，比如前32bit是你要加密的數字，後32位隨便是什麼。

看一下我下面的例子， 我用 "0123456789abcdef" 這個字元串（剛好16個字元，128bit）作為密鑰，要加密的信息是 {123, 321} 兩個整數 (剛好64bit）。然後列印出加密後得到的內容，以及解密後得到的內容（解密後得到的內容就合加密前一樣，是{123,321}）

另外，你可能會注意到 加密解密時候用到的 delta=0x9e3779b9; 這個數字的得來是 2^32 除以一個常數，這個常數就是傳說中的黃金比例 1.6180339887。

我不了解QQ是如何使用TEA的，但是無非就是將用戶密碼根據一定的方式轉換成 128bit的密鑰，然後再應用 encrypt/decrypt 函數來對收發數據進行加密/解密，一次處理64bit，和我的例子沒有什麼實質性的區別。

#include <stdio.h>
#include <stdint.h>
#include <string.h>
void encrypt (uint32_t* v, uint32_t* k) {
uint32_t v0=v[0], v1=v[1], sum=0, i; /* set up */
uint32_t delta=0x9e3779b9; /* a key schele constant */
uint32_t k0=k[0], k1=k[1], k2=k[2], k3=k[3]; /* cache key */
for (i=0; i < 32; i++) { /* basic cycle start */
sum += delta;
v0 += ((v1<<4) + k0) ^ (v1 + sum) ^ ((v1>>5) + k1);
v1 += ((v0<<4) + k2) ^ (v0 + sum) ^ ((v0>>5) + k3);
} /* end cycle */
v[0]=v0; v[1]=v1;
}

void decrypt (uint32_t* v, uint32_t* k) {
uint32_t v0=v[0], v1=v[1], sum=0xC6EF3720, i; /* set up */
uint32_t delta=0x9e3779b9; /* a key schele constant */
uint32_t k0=k[0], k1=k[1], k2=k[2], k3=k[3]; /* cache key */
for (i=0; i<32; i++) { /* basic cycle start */
v1 -= ((v0<<4) + k2) ^ (v0 + sum) ^ ((v0>>5) + k3);
v0 -= ((v1<<4) + k0) ^ (v1 + sum) ^ ((v1>>5) + k1);
sum -= delta;
} /* end cycle */
v[0]=v0; v[1]=v1;
}

int main()
{
const char *passwd = "0123456789abcdef";
uint32_t value[2] = {123, 321};
uint32_t key[4];
char *p = NULL;

memcpy(key, passwd, sizeof(key));

encrypt(value, key);

printf("After encrypt {%u, %u}\n", value[0], value[1]);

decrypt(value, key);

printf("After descrpt {%u, %u}\n", value[0], value[1]);

return 0;
}

密鑰不是胡編亂造的，密鑰就相當於密碼，不同的人會有不同的密碼。但是每個人的密碼長度可能與加密演算法需要的密碼長度不同，這樣就要按照一定的規則將用戶密碼變成符合要求的密鑰，比如用 MD5演算法 就可以將任意字元串轉換成128bit的密鑰，然後就可以應用 TEA 來加密數據。要破解這樣的數據，除非你知道那個128bit的密鑰，也就是只有你知道用戶本身的密碼是什麼，你才能得到128bit的密鑰，你才能解密數據。

我的例子里的密鑰只是隨便寫了一個舉例用的，你可以改成任何你想要的內容。

Ⅲ 什麼是TEA演算法

TEA演算法被廣泛地應用於計算機數據加密領域，OICQ的數據安全採用了TEA演算法。本文討論了TEA的演算法的原理及實現，並揭示了QQ中該演算法的應用，本文是靈鑰科技公司(www.panakes.com)在即時通信密碼研究公開的第一篇論文，今後我們將陸續發表相關的論文及相應的產品。

TEA演算法簡介
TEA演算法是由劍橋大學計算機實驗室的DavidWheeler和RogerNeedham於1994年發明.TEA是TinyEncryptionAlgorithm的縮寫。特點是加密速度極快，高速高效，但是抗差分攻擊能力差。

TEA加密演算法是一種分組密碼演算法，其明文密文塊64比特（8位元組），密鑰長度128比特(16位元組)。TEA加密演算法的迭代次數可以改變，建議的迭代次數為32輪，盡管演算法的發明人強調加密16輪就很充分了。兩個TEAFeistel周期算為一輪。圖1示例了TEA一輪的加密流程。

以下示例了TEA的C語言加密演算法，TEA的解密演算法與加密演算法類似。

#defineTEA_ROUNDS0x20
#defineTEA_DELTA0x9E3779B9
#defineTEA_SUM0xE3779B90

voidtiny_encrypt(unsignedlong*constv,unsignedlong*constw,
constunsignedlong*constk)
{
registerunsignedlong
y=v[0],
z=v[1],
a=k[0],
b=k[1],
c=k[2],
d=k[3],
n=TEA_ROUNDS,
sum=0,
delta=TEA_DELTA;

while(n-->0){
sum+=delta;
y+=(z<<4)+a^z+sum^(z>>5)+b;
z+=(y<<4)+c^y+sum^(y>>5)+d;
}
w[0]=y;
w[1]=z;
}

TEA演算法利用的不斷增加的(即源程序中的delta)值作為變化，，就是黃金分割率。它的作用是使得每輪的加密是不同。的准確值可能不太重要。但是在這里，它被初始化為

=0x9e3779b

QQ是如何利用TEA進行加密的?
TEA演算法被廣泛應用於QQ的數據加密中，QQ採用16輪的TEA演算法加密，在這時採取16輪加密時而不採取標準的32輪加密時為了減少驗證伺服器的壓力。QQ在數據加密前採用了密碼學中的常用的填充及交織技術，減少加密數據的相關性，增加破譯者的破解難度。

下表列出了QQ應用TEA演算法幾個方面

序號
應用
相關文件

1
通訊報文的加密/解密

2
消息記錄的加密/解密
MsgEx.db

3
本地消息密碼、首次登錄時間、提示內容驗證密碼
Matrix.db

4
消息備份文件
*.bak

QQ的TEA演算法源程序分析
QQ在進行TEA加密前採用ntohl函數對原文數據和加密密鑰進行了變換，從網路位元組順序轉換位主機位元組順序進行加密後，再通過htonl函數將數據轉換為網路位元組順序的數據。

為什麼要這樣做呢？因為不同的計算機使用不同的位元組順序存儲數據。因此任何從Winsock函數對IP地址和埠號的引用和傳給Winsock函數的IP地址和埠號均時按照網路順序組織的。

為防止分析者分析出QQ是採用TEA加密演算法的，程序的設計者採用了subeax,61C88647h指令，而不採用Addeax9e3779b9h指令。因為分析者只需要判斷9e3779b9h（即是我們前面提的黃金分割率的值）就知道採用了TEA加密演算法。

sub_409A43procnear;CODEXREF:sub_409B8C+AEp
;sub_409B8C+109p...

var_10=dwordptr-10h
var_C=dwordptr-0Ch
var_8=dwordptr-8
var_4=dwordptr-4
arg_0=dwordptr8
arg_4=dwordptr0Ch
arg_8=dwordptr10h

pushebp
movebp,esp
subesp,10h
pushebx
pushesi
movesi,[ebp+arg_0]
pushedi
pushdwordptr[esi];netlong
callntohl
pushdwordptr[esi+4];netlong
movedi,eax;y
callntohl
movebx,eax;z
moveax,[ebp+arg_4]
leaecx,[ebp+var_10]
leaesi,[ebp+var_10]
subeax,ecx
mov[ebp+arg_0],4
mov[ebp+arg_4],eax
jmpshortloc_409A7C
;哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪?
.text:00409A79
loc_409A79:;CODEXREF:sub_409A43+49j
moveax,[ebp+arg_4]

loc_409A7C:;CODEXREF:sub_409A43+34j
pushdwordptr[eax+esi];netlong
callntohl;對k[0],k[1],k[2],k[3]進行ntohl變化,
mov[esi],eax
addesi,4
dec[ebp+arg_0]
jnzshortloc_409A79

push10h;做十六輪TEA運算
xoreax,eax
popecx

loc_409A93:;CODEXREF:sub_409A43+88j
movedx,ebx
movesi,ebx
shredx,5;z>>5
addedx,[ebp+var_C];z>>5+k[1]
subeax,61C88647h;sum=sum+deltadelta:0x9e3779b9
shlesi,4;z<<4
addesi,[ebp+var_10];z<<4+k[0]
xoredx,esi;(z>>5+k[1])^(z<<4+k[0])
leaesi,[eax+ebx];sum+z
xoredx,esi;(z<<4+k[0])^(sum+z)^(z>>5+k[1])
addedi,edx;y+=(z<<4+k[0])^(sum+z)^(z>>5+k[1])

movedx,edi
movesi,edi
shredx,5;y>>5
addedx,[ebp+var_4];y>>5+k[3]
shlesi,4;y<<4
addesi,[ebp+var_8];y<<4+k[2]
xoredx,esi;(y>>5+k[3])^(y<<4+k[2])
leaesi,[eax+edi];(sum+y)
xoredx,esi;(y<<4+k[2])^(sum+y)^(y>>5+k[3])
addebx,edx;z+=(y<<4+k[2])^(sum+y)^(y>>5+k[3])
dececx
jnzshortloc_409A93

pushedi;hostlong
callhtonl
movesi,[ebp+arg_8]
pushebx;hostlong
mov[esi],eax;加密結果
callhtonl
mov[esi+4],eax;加密結果
popedi
popesi
popebx
leave
retn
sub_409A43endp

結論
作為一種分組加密演算法，TEA加密演算法在其發展的過程中，目前出現了幾種針對TEA演算法設計的缺陷攻擊方法，使得原有的TEA加密演算法變得不安全，在過去的十幾年中，TEA演算法進行了若干次的改進，歷經XTEA,BlockTEA,XXTEA幾個版本。目前最新的演算法是XXTEA。

QQ採用了最初的TEA演算法做其核心的加密演算法，QQ在採用TEA演算法時採用了16輪的加密，其加密復雜度比32輪減了許多。利用TEA演算法的設計缺陷，使得快速破解QQ密碼成為可能。

值得一提的QQ在利用TEA演算法做加密時，採用了交織及隨機填充隨機數的技術，增加了密碼分析者分析難度，從一定程度上保護了信息的安全。

更多信息請訪問www.panakes.com

TEA(Tiny Encryption Algorithm) 是一種優秀的數據加密演算法，雖然它比 DES(Data Encryption Standard) 要簡單得多， 但有很強的抗差分分析能力，加密速度也比 DES 快得多，而且對 64 位數據加密的密鑰長達 128 位，安全性相當好。 下面的程序來自盧開澄《計算機密碼學》（清華大學出版社）。

補充：為了使這段程序更加實用，我將其整理為幾個單元， 分別用於 Delphi 和 C++Builder 。包括對數據流 TMemoryStream 和字元串的加密/解密功能， 對字元串的加密/解密還通過 Base64 編碼/解碼，保持加密後的字元串仍為字元串。

// v[2] : 64bit data, k[4] : 128bit key

void encipher( unsigned long * const v, const unsigned long * const k )
{
register unsigned long y = v[0], z = v[1], sum = 0, delta = 0x9E3779B9,
a = k[0], b = k[1], c = k[2], d = k[3], n = 32;

while ( n-- > 0 )
{
sum += delta;
y += ( z << 4 ) + a ^ z + sum ^ ( z >> 5 ) + b;
z += ( y << 4 ) + c ^ y + sum ^ ( y >> 5 ) + d;
}
v[0] = y;
v[1] = z;
}

void decipher( unsigned long * const v, const unsigned long * const k )
{
register unsigned long y = v[0], z = v[1], sum = 0xC6EF3720, delta = 0x9E3779B9,
a = k[0], b = k[1], c = k[2], d = k[3], n = 32;

// sum = delta << 5, in general sum = delta * n
while ( n-- > 0 )
{
z -= ( y << 4 ) + c ^ y + sum ^ ( y >> 5 ) + d;
y -= ( z << 4 ) + a ^ z + sum ^ ( z >> 5 ) + b;
sum -= delta;
}
v[0] = y;
v[1] = z;
}

Ⅳ TEA加密演算法的內容

代碼如下：
void qq_encipher(unsigned long *const plain, const unsigned long *const key, unsigned long *const crypt)
//參數為8位元組的明文輸入和16位元組的密鑰，輸出8位元組密文
{
unsigned long left = plain[0],right = plain[1],
a = key[0], b = key[1],
c = key[2], d = key[3],
n = 32, sum = 0,
delta = 0x9E3779B9;
// 明文輸入被分為左右兩部分，密鑰分為四部分存入寄存器，n表示加密輪數推薦32。Delta為一常數。
while (n-- > 0) {
sum += delta;
left += ((right << 4) + a) ^ (right + sum) ^ ((right >> 5) + b);
right += ((left << 4) + c) ^ (left + sum) ^ ((left >> 5) + d);
}
crypt[0] = left ;
crypt[1] = right ;
}
void decrypt(unsigned long *v, unsigned long *k) {
unsigned long y=v[0], z=v[1], sum=0xC6EF3720, i; /* set up */
unsigned long delta=0x9e3779b9; /* a key schele constant */
unsigned long a=k[0], b=k[1], c=k[2], d=k[3]; /* cache key */
for(i=0; i<32; i++){ /* basic cycle start */
z -= ((y<<4) + c) ^ (y + sum) ^ ((y>>5) + d);
y -= ((z<<4) + a) ^ (z + sum) ^ ((z>>5) + b);
sum -= delta; /* end cycle */}v[0]=y;v[1]=z;}
雖然TEA演算法比 DES(Data Encryption Standard) 要簡單得多， 但有很強的抗差分分析能力，加密速度也比 DES 快得多，而且對 64 位數據加密的密鑰長達 128 位，安全性相當好。其可靠性是通過加密輪數而不是演算法的復雜度來保證的。從中可以看到TEA 演算法主要運用了移位和異或運算。密鑰在加密過程中始終不變。

Ⅳ 招新——第一次嘗試破解tea演算法

           開始接觸逆向分析時，入門級別的一道題目，是一個師兄寫的考核題《sotired》，嘗試著破解了下，以下是具體的過程。

1、雙擊發現打不開，應該是linux系統下的文件（事實證明確實如此，我在虛擬機那裡驗證了一下，隨便輸入字元串，得到的答案是sorry~，給人crakeme的感覺，哈哈）

2、使用反匯編工具ida64位，將文件拖進去，找到main函數，使用F5大法，得到下面的界面：

看到sorry~和wow！congratulation！的字元串，可以推斷出有字元串的對比，看到if語句，沒錯就是它了，看來temp[k]裡面有我們想要的東西（用於匹配比較的正確密文）點進去，得到

這里利用一個小插件lazyida，哈哈哈（我比較懶），得到密文,

在這里需要聲明下，因為最後讀出來的那個0x00111885B有誤（lazyida的原因），其實是0x32111885B才對，所以是 0x572CB9C1, 0x73A6EB63, 0x069E6A55, 0x818E33D9, 0x7ED0A862, 0x3211885B，這些16進制的數就是密文啦！有了密文，我們要破解它，就需要找密鑰啦，回去看函數

想像下，用戶輸入一組字元串，for循環了3次，atoui函數猜測應該是某種轉換函數，點進去

果然是移位加密轉換，結果是int 型，所以v11[6]的字元數據全部被轉換了數字，繼續往下

又有3次循環，看到encipher函數應該是加密函數來的，然後傳遞了兩個參數，一個是轉化後的v11，另一個v7，這里就可以懷疑了，v7應該是密鑰，而且用了引用，難道是地址嗎？很奇怪，點進去v7，得到

這里又要懷疑了，前面4個都是？一個數字有4個數據，感覺很像數組的樣子，於是嘗試一波

轉換為數組，然後F5大法刷新下！得到

看來我們的推斷是正確的，v7是一個數組，裡面的數據應該是密鑰了！到此，我們成功地拿到了密文和密鑰了，接下來就是解密了，解密前需要知道是怎麼加密的，回到剛剛的encipher函數，進去

看到這里有人可能要很激動了，這個演算法不就是tea演算法嗎？！（沒錯，雖然我一開始也不知道，於是我去谷歌了一波！）

tea演算法就是把密文結合密鑰進行移位再異或的運算，總共進行32輪。解密則是反過來求解，不過需要先算出delta的值，即9e3779b9*32後得到13c6ef3720，明顯溢出了（手賤算了下，溢出。tea演算法把溢出的忽略了，emmmm，我也不太懂其中的原因，能用先用著，哈哈哈），於是乎，可以寫腳本了，打開c++，寫入腳本

我們的密文和密鑰修改好後，因為有密文有6個16進制的數，所以解密3次，得到結果

好啦，這就是我們的flag了，但是看不懂是吧，沒關系，去轉換下，谷歌走起！

大家記得把空格消除，然後把它和在一起轉化，好啦，虛擬機linux操作系統打開，文件打開，輸入flag，得到的就是WOw！congratulation！

以上便是我花了一個下午整理出來的一個逆向題目，希望對大家有幫助，也希望能多多交流哦，嘻嘻~

Ⅵ tea演算法的介紹

在安全學領域，TEA（Tiny Encryption Algorithm）是一種分組加密演算法，它的實現非常簡單，通常只需要很精短的幾行代碼。TEA 演算法最初是由劍橋計算機實驗室的 David Wheeler 和 Roger Needham 在 1994 年設計的。TEA演算法使用64位的明文分組和128位的密鑰，它使用Feistel分組加密框架，需要進行 64 輪迭代，盡管作者認為 32 輪已經足夠了。該演算法使用了一個神秘常數δ作為倍數，它來源於黃金比率，以保證每一輪加密都不相同。但δ的精確值似乎並不重要，這里 TEA 把它定義為 δ=「(√5 - 1)231」（也就是程序中的 0×9E3779B9）。之後 TEA 演算法被發現存在缺陷，作為回應，設計者提出了一個 TEA 的升級版本——XTEA（有時也被稱為「tean」）。XTEA 跟 TEA 使用了相同的簡單運算，但它採用了截然不同的順序，為了阻止密鑰表攻擊，四個子密鑰（在加密過程中，原 128 位的密鑰被拆分為 4 個 32 位的子密鑰）採用了一種不太正規的方式進行混合，但速度更慢了。

Ⅶ 如何破解sqlite資料庫文件

針對sqlite資料庫文件，進行加密。現有兩種方案如下:

1.對資料庫中的數據進行加密。
2.對資料庫文件進行加密

1.uin怎麼獲取？

這個uin不是登錄的帳號，而是屬於內部的、程序界面上不可見的一個編號。

至於查看，最簡單的方法就是登錄web微信後，按F12打開網頁調試工具，然後ctrl+F搜索「uin」，可以找到一串長長的URL，裡面的uin就是當前登錄的微信的uin。

還
有一種方法就是配置文件里，導出的微信目錄下有幾個cfg文件，這幾個文件里有保存，不過是java的hashmap，怎麼解析留給小夥伴們自己琢磨吧，

還有就是有朋友反應退出微信（後台運行不叫退出）或者注銷微信後會清空這些配置信息，所以小夥伴們導出的時候記得在微信登陸狀態下導出。博主自己鼓搗了一
個小程序來完成解析。

2.一個手機多個登錄帳號怎麼辦（沒有uin怎麼辦）

根
據博主那個解密的帖子，必須知道串號和uin。串號好說，配置中一般都有可以搞到，uin從配置中讀取出來的時候只有當前登錄的或者最後登錄的，其他的幾
個記錄都沒辦法解密。網上某軟體的解決方法是讓用戶一個一個登錄後再導出。這個解決方法在某些情況下是不可能的，或者有時候根本不知道uin。

後來經過一個朋友的指點，博主終於發現了解決方法，可以從配置中秒讀出來這個uin，這個方法暫時不透漏了，只是說明下這個異常情況。

3.串號和uin怎麼都正確的怎麼還是沒辦法解密

先
說說串號這個玩意，幾個熱心的朋友反饋了這個問題，經過博主測試發現不同的手機使用的不一定是IMEI，也可能是IMSI等等，而且串號也不一定是標準的

15位，可能是各種奇葩，比如輸入*#06#出來的是一個，但是在微信程序里用的卻是另一個非常奇葩的東西，這種情況多在雙卡雙待和山寨機中出現，經過嚴
格的測試，現在已經能做到精確識別，那幾位熱心的朋友也贈與了不同的代碼表示鼓勵。

4.計算出來了正確的key為什麼無法打開資料庫文件

微
信這個變態用的不是標準的sqlite資料庫，那個帖子也提到了不是資料庫加密，是文件的內容加密，其實是sqlcipher。官方上竟然還賣到
149$，不過倒是開放了源碼，水平夠高的可以自己嘗試編譯。google還能搜索到sqlcipher for
windows這個很好編譯，不過博主不知是長相問題還是人品問題，編譯出來的無法打開微信的資料庫，後來改了這份代碼才完成。

5.資料庫文件內容是加密的，怎麼還原

這
個是某些特殊情況下用到的，比如聊天記錄刪除了資料庫中就沒了，但是某個網友測試說資料庫無法查詢出來了，但是在文件中還是有殘留的。這個情況我沒測試
過，不過想想感覺有這個可能，就跟硬碟上刪除了文件其實就是刪除了文件的硬碟索引，內容還是殘留在硬碟上可以還原一樣，sqlite資料庫刪除的條目只是
抹去了索引，內容還存在這個文件中。

網上的都是直接打開讀取，並沒有解密還原這個文件成普通的sqlite資料庫，使用sqlcipher
的導出方法也只是將可查詢的內容導出。後來博主花了時間通讀了內容加密的方式，做了一個小程序將加密的文件內容直接解密，不操作修改任何數據，非資料庫轉
換，直接數據流解密，完全還原出來了原始的未加密的資料庫文件，大小不變，無內容損失，可以直接用sqlite admin等工具直接打開。

6.已經刪除的聊天內容可以恢復么

通過上述第5的方式還原出原數據後，經測試可以恢復。sqlite的刪除並不會從文件中徹底刪掉，而是抹掉索引，所以可以通過掃描原始文件恢復。前提是沒有重裝過微信。。。

兩種加密方式的優缺點，比較如下：

一、對資料庫中的數據進行加密

優點：

1.實現數據加密快速，只需添加兩個方法

一是：對明文數據進行加密返回密文數據

二是：對密文數據進行解密返回明文數據

2.程序無需進行太大變動，僅在對數據進行添加，修改，刪除，查詢時。針對指定的表欄位進行修改進行加密，解密的欄位即可。

不足：

1.由於對數據進行了加密。所以為了看到明文，必須密文進行解密。因此會增加處理器的消耗。因終端手機的處理能力有限，可能會出現處理數據緩慢的現象發生。

2.僅僅對數據進行了加密，還是可以看到數據表的sql語句，可能猜測到表的作用。另外，如果沒有對一個表中的所有欄位加密，則可以看沒有加密的明文數據。

需要做的工作：

1.無需考慮平台差異性，qt,android,ios都能快速的實現。只需在每個平台上，使用各自的語言，實現同樣的加密，解密演算法即可。

2.需要對加密演算法進行了解，選擇一種加密演算法，進行實現。

二、對資料庫文件進行加密

優點：

1.對整個文件進行了加密，用戶通過編輯器看不到任何有用的數據，用戶使用sqlite browser軟體也無法打開文件查看數據，保證了數據安全。

2.進行打開資料庫時，使用程序sqlite3_key(db,」********」,8);即可對文件解密，對數據表的操作無需進行加密，採用明文即可。

不足：

1.需要修改sqlite的源代碼，這個工作難度比較大。

2.需要對修改後的sqlite進行編譯，需要對makefile有所了解，手動編寫makefile文件，對源程序進行編譯。因平台差異性，可能會造成某個平台無法編譯生成動態鏈接庫的可能。

3.需要對數據訪問層代碼進行修改，例如qt平台需要將以前對資料庫操作使用的QSqlQuery類，更改為使用sqlite3.h文件中定義操作，對資料庫操作。其他平台也一樣，都要做這一步的修改。

4.在程序編譯時，要加入使用加密的動態鏈接庫（linux為共享庫.so文件）windows平台最容易，只需將所使用的dll文件到應用程序中即可。其他平台需要實驗，看如何引入庫,如果編譯。

需要做的工作：

1.修改sqlite源代碼，追加對資料庫文件進行加密的功能。

2.編譯含有加密功能的程序源代碼，生成各自平台需要使用的庫文件。

3.將加密sqlite庫文件引入各自平台中，修改資料庫訪問層代碼。

4.進行程序的部署，測試。

三、資料庫加密原理

目前主流的資料庫都採用了各種安全措施，主要包括用戶認證、訪問控制、數據加密存儲和資料庫操作審計等措施。

用戶認證：用戶或者程序向資料庫提供自己的有效身份證明，資料庫鑒別用戶的身份是否合法，只有合法的用戶才能存取數據

庫中的數據。用戶認證是所有安全機制的前提，只有通過認證才能進行授權訪問和審計。

訪問控制：資料庫管理系統為不同的用戶分配不同的許可權，保證用戶只能進行授權的訪問。目前，一些大型資料庫(如Oracle 等)

都採用了基於角色的訪問控制機制，即為用戶授予不同的角色，如db—owner，security administrator 等，不同的角色允許對資料庫執行不同的操作。

資料庫加密：用戶認證以及訪問控制對訪問資料庫進行了控制，但攻擊者可能會利用操作系統或資料庫漏洞，或物理接觸計算機，而直接接觸資料庫系統文件，從而可能繞過身份認證和存取控制而直接竊取或篡改資料庫內容。對資料庫中的數據進行加密是防範這類威脅的有效手段。

資料庫操作審計：監視和記錄用戶對資料庫所做的各種操作的安全機制，它記錄並存儲用戶的操作，用於事後分析，以檢查導致資料庫現狀的原因以及提供追蹤攻擊者的線索。資料庫的備份與恢復：當資料庫發生不可恢復的故障時，可以將資料庫恢復到先前的某個一致性的狀態。

四、SQLite 加密

由於SQLite 是開放源碼的，並且在其源碼中預留了加密介面，我們可以通過實現其預留的加密介面實現口令認證和資料庫加密以完善其加密機制。

1.口令認證

SQLite 資料庫文件是一個普通文本文件，對它的訪問首先依賴於文件的訪問控制。在此基礎上，再增加進一步的口令認證，即在訪問資料庫時必須提供正確的口令，如果通過認證就可以對資料庫執行創建、查詢、修改、插入、刪除和修改等操作；否則，不允許進一步的訪問。

2.資料庫加密

資料庫加密有兩種方式：

1)在資料庫管理系(Data Base Management System，DBMS)中實現加密功能，即在從資料庫中讀數據和向資料庫中寫數據時執行加解密操作；

2)應用層加密，即在應用程序中對資料庫的某些欄位的值進行加密，DBMS 管理的是加密後的密文。
前者與DBMS 結合好，加密方式對用戶透明，但增加了DBMS 的負載，並且需要修改DBMS的原始代碼；後者則需要應用程序在寫入數據前加密，在讀出數據後解密，因而會增大應用程序的負載。在此，通過實現SQLite 源碼中預留的加密介面，實現DBMS 級的加密。

3.使用xxx-tea 演算法加密SQLite 資料庫

微型加密演算法（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-JuhaniSaarinen 給出了一個可有效攻擊 Block TEA 演算法的代碼，但之後很快 David
J. Wheeler 和 Roger M.Needham 就給出了 Block TEA 演算法的修訂版，這個演算法被稱為 XXTEA。XXTEA
使用跟 Block TEA 相似的結構，但在處理塊中每個字時利用了相鄰字。它利用一個更復雜的 MX 函數代替了 XTEA 輪循函數，MX 使用 2
個輸入量。

Ⅷ tea演算法的密文解密

抽凱巴煙，最後被賣煙的老闆
點了一根長長的蠟燭，
我們被強制聚在它交融的空氣里，
那些滿蓋著金合歡樹的群山，
如露出一絲曙光的希望
一么中中熟悉的的印哈哈

Ⅸ tea 演算法的原理

TEA加密和解密時都使用一個常量值，這個常量值為0x9e3779b，這個值是近似黃金分割率，注意，有些編程人員為了避免在程序中直接出現"mov 變數，0x9e3779b"，以免被破解者直接搜索0x9e3779b這個常數得知使用TEA演算法，所以有時會使用"sub 變數，0x61C88647"代替"mov 變數，0x9e3779b"，0x61C88647=－(0x9e3779b)。

TEA演算法每一次可以操作64bit(8byte)，採用128bit(16byte)作為key，演算法採用迭代的形式，推薦的迭代輪數是64輪，最少32輪。

Ⅹ tea加解密演算法經過Keil編譯在單片機中運行結果錯誤，求幫助

c並沒有規定int,long 之類的數據類型對應幾個char,所以造成按位運算在不同的編譯器下運行結果不一樣
解決辦法
#define int8 char
#define uint8 uchar
#define int16 int //16位mcu
#define int16 (short int)//32位mcu
.......
這個樣子就可以避免數據類型的差異所帶來的影響(不知道int代表幾個char,就用sizeof(int))
還有,你的long btea(long* v,char n,long* k);
而你調用的時候btea(plainbuffer, 2,key);
函數簽名和定義的數據類型不一致,也會發生錯誤(不要以為unsigned可有可無)
你這樣調整一下,應該就沒有問題了