Rainbow Table 分析（转）

来源：NCPH

===================
Rainbow Table
===================

Rainbow Table 是由Philippe Oechsilin在Making a Faster Cryptanalytic Time-Memory Trade-Off中
提出的一种改进型的PreComputering Table. 主要目的是为了提高成功率, 并且减少存储空间.

rainbowcrack-1.2-src是Zhu Shuanglei对此的一个实现, 针对他的实现写下了这些说明Rainbow Table的笔记.

1. Rainbow Table的组织和生成(rtgen说明)

Rainbow Table 是由很多16bytes的RainbowChain组成的.

RainbowChain的结构如下:
struct RainbowChain
{
+000  uint64 nIndexS;
+008  uint64 nIndexE;
};

rainbowTable的数量是由字符空间决定的, 事先计算好再由argv[7]传入.
int nRainbowChainCount   = atoi(argv[7]);

nIndexS由函数cwc.GenerateRandomIndex()随机生成( 这样生成是有目的的, 将在后面解释 )
与此同时这个index也被放入了CChainWalkContext.m_nIndex中, m_nindex启到中间记录作用
nIndexE经过nRainbowChainLen次计算而来的.

整个过程如下:

1) 将随机生成m_nindex(开始即nIndexS)通过cwc.IndexToPlain() 见[1]得到由字符空间定义表示字符
整个转换过程和二进制转16进制差不多, 只不过变成了明文字符长度进制(m_nPlainCharsetLen)

2) 对步骤1得到字符进行预先设定的HASH函数 - cwc.PlainToHash()

3) 对生成的HASH进行Reduce, 在此Reduce函数为cwc.HashToIndex(nPos) 见[2]
最后得到的m_nindex还是必须规定在字符空间的范围内( .'. % m_nPlainSpaceTotal).

将上面三步重复nRainBowChainLen次后, 将m_nindex放入到nIndexE中. nRainBowChainLen就是Chain长度.
并且所有的RainbowChain均是重复上述步骤.

也可以表示成如下过程:

PLAIN      HASH       Reduce
K1 -------> C -------> H  --------> K2 ----->....

index       plain       hash      reduced hash
(new index)  <----- 减少存储空间的关键

由于在整个过程中会产生新的index, 虽然并不记录, 但还是可以推算得到的, 因为所有函数都是单向的.
所以严格按照排列生成 nIndexS就变得没有必要了. 这些新的index很可能就已经包括在内了, 当然这些
新的index会有一定reduce范围, 这是由m_nReduceOffset造成的. 成功率的概念也是由于这个原因, 很可能
整个Random的过程并没有覆盖到每一个排列, 增加多张同一个ReduceOffset表的目的也是为提高覆盖率, 但是
还是会有miss率, 哪怕是0.01%甚至更小.

根据Philippe Oechsilin的Paper中将 K1 -> K2 的过程定义为ｆｎ, 而ｆｎ不同原因主要在于Reduce函数不同
(造成这中不同的原因在于nPos的增加 见[2])

2. Rainbow Table的排序(rtsort的说明)

rtsort 使用了快速排序 和 外部排序
排序的对象就是 RainbowChain.nIndexE, 这一点需要十分注意.

外部排序只有在内存容量很低的时候, 才会采用.

外部排序的过程:

1) 根据内存的大小从rainbow table文件中读取相应的大小的内容.

2) 使用快速排序将相应的chain进行排序, 存放到temp文件中.

3) 相应的信息存放到CSortedSegment结构的链表中

4) 重复上述1-3步, 直到读取完rainbow table的所有内容.

5) 将链表中的所有的项进行归并.(并非使用二路归并, 而是一起归并)
归并从所有的经过排序的项中取最小的一个, 排序的对象是 RainbowChain.nIndexE , 后8个字节

+++---
此时还作了一些优化:

GetNextChain会预先在文件中读取m_nFileChainCount放到RainbowChain.m_chain[]的数组中.
但大小超过1024, 也只读取1024.
if (m_nChainCount == m_nNextChainIndex) 是一个判断 可能进行下一次读取的条件
返回m_nNextChainIndex指向的m_chain[m_nNextChainIndex]的地址(RainbowChain *)

RemoveTopChain 主要作用就是 更新m_nNextChainIndex, 但全部读完后, 返回true, 让MergeSortedSegment删去该链项(list.erase)
---+++

6) 将归并后的项放入原来的文件中.

PrepareSortedSegment函数        过程  1 - 4
MergeSortedSegment  函数        过程  5 , 6

3. Rainbow Table的使用(rcrack的说明)

更应该说rcrack的过程就是查表的过程.

1)  针对每个rt文件进行搜索
for (i = 0; i < vPathName.size() && hs.AnyhashLeft(); i++)
{
SearchRainbowTable(vPathName[i], hs);
printf("\n");
}

2)  在SearchRainbowTable中根据内存大小, 分成一块块的进行Search.
调用SearchTableChunk函数.

3)  以下为rcrack的关键函数

SearchTableChunk(pChain, nRainbowChainLen, nRainbowChainCountRead, hs);

pChain - 存放在内存中Rainbow Table的Chain表, 可能Rainbow Table中的项要比内存大得多,
所以用CMemoryPool实现根据内存大小分配空间. pChain使用CMemoryPool.Alloc分配的.

nRainbowChainLen - RainbowChain的长度

nRainbowChainCountRead - 读入pChain中RainbowChain的数量, 读入文件大小/16 (当然必须是16的倍数)

hs    -  存放将要检验的HASH, 并且还要存放Crack的结果, 是否发现原始HASH, 是否发现, 明文等等.
//++
vector<string> m_vHash;
vector<bool>   m_vFound;
vector<string> m_vPlain;
vector<string> m_vBinary;
//--

整个查表过程如下
a. 首先作一些准备工作
HASH的设置,转换之类的工作
RequestWalk的目的是为某个需要破解的HASH, 生成一个存放用于匹配pChain[i].nIndexE的数组.
RequestWalk会在第一次时创建, 会根据Chain的长度和相应Pos的位置计算好所要匹配的项. (见[4-1])
只需按Pos的位置定义, 所以只需再开始时计算一次, 以后该HASH的计算均可使用.

b. 计算过程和比对过程
第一次将HASH使用nPos位置的Reduce函数(Rn-1 n为ChainLen), 与pChain[i].nIndexE中的所有项相比较.
若找到了相匹配的值, 则使用CheckAlarm函数来进行检验. CheckAlarm根据猜测的所在位置, 从nIndexS
开始推, 重复f函数的步骤, 到达最后nPos位置的时候, 不会再使用f函数中Reduce函数, 而只推到HASH值.(见[5])
能够推到的那个HASH的那个index就表示为数字的明文.
注意当然也可能有匹配值有多个的情况, 因为Reduce函数的收敛性的问题,
原始的HASH和reduce函数的解空间只有缩减的份, 因为Reduce函数只取HASH开头的8bytes作运算.
所以就需要在一个匹配域中进行查找, 如果CheckAlarm函数验证不通过的, 则说明这个nPos不是所要的位置.
这样的一种情况就被称为False Alarm.

如果第一次匹配不成功, 则认为这个HASH是前一个index经过HASH函数推出来的.
Rn-2, 得到一个新的index, 然后一步一步的推到最后, 即Chain链的结束(当然这里只有一次f n-1)
和上面比较过程相同, 相同的话就可以确定猜测的位置.不同的话, 继续相同的步骤, 只是将Pos的位置向前移.
直到Pos为0 为止.

最后将结果放到HASHSET中(hs), 不管是找到了明文, 还是没有发现.
将明文的信息存放到hs中的工作是由CheckAlarm完成的.(见[5])

4. 遗留问题

参数的设定和优化还是有很多不理解的地方. 有一篇关于此的论文无法找到.
chainlen的确定, 还有一些不理解.
仅大致知道受M = m × l × m0 和 T = t × l × t0 限制(即根据内存大小, 得出最佳计算时间以及成功率)
还需要仔细仔细地研究一下, 未完待续...

==============
Appendix
==============

函数注释:

[1]

void CChainWalkContext::IndexToPlain()
{
int i;
for (i = m_nPlainLenMax - 1; i >= m_nPlainLenMin - 1; i--)
{
if (m_nIndex >= m_nPlainSpaceUpToX[i])
{
m_nPlainLen = i + 1;
break;
}
}
//  根据 m_nIndex的大小来判断m_nPlainLen的大小
//  m_nIndex 就是开始随机生成的, 和之后中间步骤
//  m_nPlainSpaceUpToX 用来计算Pxx的
//  当i 时 P 应该有的大小.
//  P的概率统计的东东.

uint64 nIndexOfX = m_nIndex - m_nPlainSpaceUpToX[m_nPlainLen - 1]

//此段密码长度应该有的偏移大小.

/*
// Slow version
for (i = m_nPlainLen - 1; i >= 0; i--)
{
m_Plain[i] = m_PlainCharset[nIndexOfX % m_nPlainCharsetLen];
nIndexOfX /= m_nPlainCharsetLen;
}
*/

//  事实上完全可以用上面的那个慢速版本来完成
//  为了避免64位的除法运行
//  当数据还是32位时, 就截成32位来算

// Fast version
for (i = m_nPlainLen - 1; i >= 0; i--)
{
#ifdef _WIN32
if (nIndexOfX < 0x100000000I64)
break;
#else
if (nIndexOfX < 0x100000000llu)
break;
#endif
// m_Plain 的方式和16 进制差不多, 不过是明文字符长度进制
// 最先算出来的是最后一位.
m_Plain[i] = m_PlainCharset[nIndexOfX % m_nPlainCharsetLen]; //根据明文字符的内容, 来取关于的大小
nIndexOfX /= m_nPlainCharsetLen;
}

// 算完了 64位, 为什么还要计算32位呢?(见上)
unsigned int nIndexOfX32 = (unsigned int)nIndexOfX;
for (; i >= 0; i--)
{
//m_Plain[i] = m_PlainCharset[nIndexOfX32 % m_nPlainCharsetLen];
//nIndexOfX32 /= m_nPlainCharsetLen;

unsigned int nPlainCharsetLen = m_nPlainCharsetLen;
unsigned int nTemp;
#ifdef _WIN32
__asm
{
mov eax, nIndexOfX32
xor edx, edx
div nPlainCharsetLen
mov nIndexOfX32, eax
mov nTemp, edx
}
#else
__asm__ __volatile__ ( "mov %2, %%eax;"
"xor %%edx, %%edx;"
"divl %3;"
"mov %%eax, %0;"
"mov %%edx, %1;"
: "=m"(nIndexOfX32), "=m"(nTemp)
: "m"(nIndexOfX32), "m"(nPlainCharsetLen)
: "%eax", "%edx"
);
#endif
m_Plain[i] = m_PlainCharset[nTemp];
}
}

[2]

void CChainWalkContext::HashToIndex(int nPos)
{
m_nIndex = (*(uint64*)m_Hash + m_nReduceOffset + nPos) % m_nPlainSpaceTotal;
// nPos 的目的就是要有所变化,每次有加1
// 这就是每个Reduce 函数不同的原因了
// m_nReduceOffset与RaombowTableIndex 相关 见[3]
// m_nReduceOffset = 65536 * nRainbowTableIndex;
// m_Hash是取HASH值的前8  个字节, 因为HASH可能会超过8 bytes
}

[3]

rtgen lm alpha 1 7 3 2100 8000000 all

bool CChainWalkContext::SetRainbowTableIndex(int nRainbowTableIndex)  <--------- argv[5] 即 3
{
if (nRainbowTableIndex < 0)
return false;
m_nRainbowTableIndex = nRainbowTableIndex;  // 将所要计算的表分成几张表, 而最后all(argv[8]仅仅是生成表的名字罢了)
// 的重复则是为了增加成功率.
m_nReduceOffset = 65536 * nRainbowTableIndex;

return true;
}

[4]

void CCrackEngine::SearchTableChunk(RainbowChain* pChain, int nRainbowChainLen, int nRainbowChainCount, CHashSet& hs)
{
vector<string> vHash;
hs.GetLeftHashWithLen(vHash, CChainWalkContext::GetHashLen());
printf("searching for %d hash%s...\n", vHash.size(),vHash.size() > 1 ? "es" : "");

int nChainWalkStep = 0;
int nFalseAlarm = 0;
int nChainWalkStepDueToFalseAlarm = 0;

int nHashIndex;
for (nHashIndex = 0; nHashIndex < vHash.size(); nHashIndex++)// 针对每个HASH 进行验证
{
unsigned char TargetHash[MAX_HASH_LEN];
int nHashLen;
ParseHash(vHash[nHashIndex], TargetHash, nHashLen);// string -> binary
if (nHashLen != CChainWalkContext::GetHashLen())
printf("debug: nHashLen mismatch\n");

// Rqeuest ChainWalk
bool fNewlyGenerated;
uint64* pStartPosIndexE = m_cws.RequestWalk(TargetHash,    // 一些结构的准备
nHashLen,

CChainWalkContext::GetHashRoutineName(),
CChainWalkContext::GetPlainCharsetName(),

CChainWalkContext::GetPlainLenMin(),
CChainWalkContext::GetPlainLenMax(),

CChainWalkContext::GetRainbowTableIndex(),
nRainbowChainLen,
fNewlyGenerated);
//printf("debug: using %s walk for %s\n", fNewlyGenerated ? "newly generated" : "existing",
//          vHash[nHashIndex].c_str());

// Walk
int nPos;
for (nPos = nRainbowChainLen - 2; nPos >= 0; nPos--)
{

[4-1]

if (fNewlyGenerated) // 是否是新建的.   RequestWalk中返回相应的信息
{
CChainWalkContext cwc;
cwc.SetHash(TargetHash);
cwc.HashToIndex(nPos);    // 这个就是R n-1 , 第二次 R n-2
int i;
for (i = nPos + 1; i <= nRainbowChainLen - 2; i++)
{
cwc.IndexToPlain();   //  三步为
cwc.PlainToHash();    //  f n-1.
cwc.HashToIndex(i);   //
}

pStartPosIndexE[nPos] = cwc.GetIndex();  // 得到的值将和pChain[i].nIndexE的所有项进行比较
nChainWalkStep += nRainbowChainLen - 2 - nPos;  // 第几步了
}
uint64 nIndexEOfCurPos = pStartPosIndexE[nPos];

// Search matching nIndexE
int nMatchingIndexE = BinarySearch(pChain, nRainbowChainCount, nIndexEOfCurPos); // 二分查找
if (nMatchingIndexE != -1)  //找到了
{
int nMatchingIndexEFrom, nMatchingIndexETo;
GetChainIndexRangeWithSameEndpoint(pChain, nRainbowChainCount,
nMatchingIndexE,
nMatchingIndexEFrom,

nMatchingIndexETo);

// 找到相同的区域, 因为完全有可能相同.
// 因为函数的收敛性的问题, 原始的HASH和reduce函数的解空间只有缩减的份
int i;
for (i = nMatchingIndexEFrom; i <= nMatchingIndexETo; i++)
{
// 原来相关的明文存放的是在CheckAlarm 函数中操作的
// 找到一个确实的, 就放入然后退出, 该HASH 的encryptanalysis
if (CheckAlarm(pChain + i, nPos, TargetHash, hs))  // 再进行判断一次. 再正向过程一次.
{
//printf("debug: discarding walk for %s\n", vHash[nHashIndex].c_str());
m_cws.DiscardWalk(pStartPosIndexE);
goto NEXT_HASH;
}
else // 如果不是则说明是一次误报, false alarm.
{
nChainWalkStepDueToFalseAlarm += nPos + 1;
nFalseAlarm++;
}
}
}
}
NEXT_HASH:;
}

//printf("debug: chain walk step: %d\n", nChainWalkStep);
//printf("debug: false alarm: %d\n", nFalseAlarm);
//printf("debug: chain walk step due to false alarm: %d\n", nChainWalkStepDueToFalseAlarm);

m_nTotalChainWalkStep += nChainWalkStep;
m_nTotalFalseAlarm += nFalseAlarm;
m_nTotalChainWalkStepDueToFalseAlarm += nChainWalkStepDueToFalseAlarm;
}

[5]

bool CCrackEngine::CheckAlarm(RainbowChain* pChain, int nGuessedPos, unsigned char* pHash, CHashSet& hs)
{
CChainWalkContext cwc;
cwc.SetIndex(pChain->nIndexS);
int nPos;
for (nPos = 0; nPos < nGuessedPos; nPos++) //根据猜测的位置从头nIndexS推到相应的位置
{
cwc.IndexToPlain();
cwc.PlainToHash();
cwc.HashToIndex(nPos);
}
cwc.IndexToPlain();     +-
cwc.PlainToHash();       \ 只作了一个HASH, 并没有什么Reduce函数(cwc.HashToIndex(nPos) ), 就是为了验证

if (cwc.CheckHash(pHash))     // 验证函数, 比较pHash和生成的函数
{
printf("plaintext of %s is %s\n", cwc.GetHash().c_str(), cwc.GetPlain().c_str());
hs.SetPlain(cwc.GetHash(), cwc.GetPlain(), cwc.GetBinary());  // 结果的放入
return true;
}

return false;

[6]

RequestWalk的目的是为某个需要破解的HASH, 生成一个存放用于匹配pChain[i].nIndexE的数组.
uint64* CChainWalkSet::RequestWalk(unsigned char* pHash, int nHashLen,
string sHashRoutineName,
string sPlainCharsetName, int nPlainLenMin,
int nPlainLenMax,
int nRainbowTableIndex,
int nRainbowChainLen,
bool& fNewlyGenerated)
{
if (   m_sHashRoutineName   != sHashRoutineName        // 如果相应的参数有所变化, 则所有的东东全部重新设置.
|| m_sPlainCharsetName  != sPlainCharsetName
|| m_nPlainLenMin       != nPlainLenMin
|| m_nPlainLenMax       != nPlainLenMax
|| m_nRainbowTableIndex != nRainbowTableIndex
|| m_nRainbowChainLen   != nRainbowChainLen)
{
DiscardAll();                                  //  <-----------  Here

m_sHashRoutineName   = sHashRoutineName;
m_sPlainCharsetName  = sPlainCharsetName;
m_nPlainLenMin       = nPlainLenMin;
m_nPlainLenMax       = nPlainLenMax;
m_nRainbowTableIndex = nRainbowTableIndex;
m_nRainbowChainLen   = nRainbowChainLen;

ChainWalk cw;
memcpy(cw.Hash, pHash, nHashLen);
cw.pIndexE = new uint64[nRainbowChainLen - 1];
m_lChainWalk.push_back(cw);

fNewlyGenerated = true;
return cw.pIndexE;
}

list<ChainWalk>::iterator it;
for (it = m_lChainWalk.begin(); it != m_lChainWalk.end(); it++)
{
if (memcmp(it->Hash, pHash, nHashLen) == 0) // 判断这个HASH 是否是新,
{
fNewlyGenerated = false;
return it->pIndexE;                 // 如是, 则返回该 8字节数组的指针
}
}

ChainWalk cw;                                     // ChainWalk 有两个结构 一个放hash值, 另一个放后面8 字节数组的指针
memcpy(cw.Hash, pHash, nHashLen);
cw.pIndexE = new uint64[nRainbowChainLen - 1];    // 一个存放用于匹配pChain[i].mIndexE的数组.
m_lChainWalk.push_back(cw);                       // 如没有整个HASH, 新建一个, 加入到ChainWalk结构的List

fNewlyGenerated = true;
return cw.pIndexE;                           //返回的是指向一个放8字节的数组指针
}