value = key3CharBuf[0]*64*64 + key3CharBuf [1]*64 + key3CharBuf[0]。然后索引g_constKey[64][64][64]常量表， 因此取索引对应的数值作为下层相应的钥匙。 g_constKey存储的数据范围为：(0~63)。

 6、中间层循环

        使index数值从0 开始依次循环16次，从而获得下层的所有16把钥匙，才可以到最外层循环，进入到下一层。需要注意的是：

        当进行索引第i把钥匙，首先要确定索引 table的位置，即为table[i][i]开始，比如：

        索引第0把钥匙，则取 table[0][0] ~ table[0][15]

        索引第1把钥匙，则取 table[1][1] ~table[1][15]、 table[1][0]

       通过分析中间层循环不难得出下一层钥匙与本次钥匙的关系，假如当前层是a，其16把钥匙为 a0-a15, 下一层为b,其16把钥匙为b0-b15:    

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

b0        =      g_constKey[ a0*64*64               +             a1*64               +                a2] b1        =      g_constKey[ a3*64*64               +             a4*64               +                a0]  b2        =      g_constKey[ a5*64*64               +             a6*64               +                a0]   b3        =      g_constKey[ a5*64*64               +             a7*64               +                a1] b4        =      g_constKey[ a4*64*64               +             a6*64               +                a1]  b5        =      g_constKey[ a8*64*64               +             a2*64               +                a3]        b6        =      g_constKey[ a9*64*64               +             a8*64               +                a4]  b7        =      g_constKey[ a7*64*64               +             a10*64              +                a3]  b8        =      g_constKey[ a8*64*64               +             a12*64              +                a5]  b9        =      g_constKey[ a11*64*64              +             a13*64              +                a6] b10       =      g_constKey[ a12*64*64              +             a13*64              +                a7] b11       =      g_constKey[ a11*64*64              +             a14*64              +                a9] b12       =      g_constKey[ a14*64*64              +             a8*64               +                a10] b13       =      g_constKey[ a15*64*64              +             a9*64               +                a10] b14       =      g_constKey[ a15*64*64              +             a11*64              +                a12] b15       =      g_constKey[ a15*64*64              +             a13*64              +                a14]

7、最外层循环

         获得下层所有钥匙后，就可以开启下层的门锁，从而进入下一层，依次循环一共循环20次。

8、第20次循环的钥匙即： inputIndexKey [19]与全局变量byte_40DA68[16]必须相等，如果不同则返回失败，如果相同，则输入第9层相关信息，成功。

二、算法分析

        现在我们需要做的是，根据最后一层的钥匙，来逆推前一层的钥匙，一直到第0层，从而拿到key。可以利用本层与下层的钥匙关系，进行暴力穷举，是可以获得最原始的初始钥匙，获得key大概需要4个小时。下面是个优化的算法，大概需要3-5分钟获得原始钥匙。

         已知本层所有钥匙，来获得上一层的所有钥匙：

         存在16把钥匙，就是存在16个方程，通过遍历 g_constKey 表，可知每个方程共有4096个解。假定本层第0把钥匙对应的上层3把钥匙a0, a1,a2确定，则可知本层第1、2、3、4、5、6把钥匙都分别有64个解。然后再以第1把钥匙为基础，遍历其64中可能，通过各钥匙之间的关系，可知其中每一种可能都可以锁定剩余11把钥匙的可能性。以次为基础，开始依次遍历校验，先获取16把钥匙每把的可能4096个解，然后循环4096*64次即可碰撞出上一层所有钥匙。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280

#include "stdafx.h" #include <windows.h>      extern char g_constKey[0x40000]; extern unsigned char g_indexKey[0x100]; typedef struct {     unsigned char x;     unsigned char y;     unsigned char z; }result; typedef struct nextRest{     unsigned char m;     unsigned char n; }nextRest; typedef struct nextRestInfo{     int count;     nextRest result[640]; }nextRestInfo; typedef struct {     //0--a0,a1,a2     //1--a3,a4,a0     result r[16][40960]; }allResult; unsigned char arm[16] = { 0x14, 0x22, 0x1E, 0x10, 0x38, 0x30, 0x18, 0x10, 0x04, 0x1A, 0x24, 0x08, 0x02, 0x26, 0x38, 0x2A }; char srt[] = "abcdefghijklmnopqrstuvwxyz+-ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; unsigned char newArm[16]; nextRestInfo nr56; nextRestInfo nr34; nextRestInfo nr57; nextRestInfo nr46; nextRestInfo nr83; nextRestInfo nr94; allResult allr; bool getmnResult(nextRestInfo* nr, unsigned char a, int index, int xyz) {     int count = 0;     for (int i = 0; i < 4096; i++)     {         if (1 == xyz)         {             if (allr.r[index][i].x == a)             {                 nr->result[count].m = allr.r[index][i].y;                 nr->result[count].n = allr.r[index][i].z;                 if (count < 64)                     count++;                 else                 {                     printf("ERROR:   count > 64");                     return false;                 }             }         }         if (2 == xyz)         {             if (allr.r[index][i].y == a)             {                 nr->result[count].m = allr.r[index][i].x;                 nr->result[count].n = allr.r[index][i].z;                 if (count < 64)                     count++;                 else                 {                     printf("ERROR:   count > 64");                     return false;                 }             }         }         if (3 == xyz)         {             if (allr.r[index][i].z == a)             {                 nr->result[count].m = allr.r[index][i].x;                 nr->result[count].n = allr.r[index][i].y;                 if (count < 64)                 {                     count++;                 }                 else                 {                     printf("ERROR:   count > 64");                     return false;                 }             }           }     }     return true; }   unsigned char geta7Bya5(unsigned char a5) {     for (int i = 0; i < 64; i++)     {         if (nr57.result[i].m == a5)             return nr57.result[i].n;     }     return 0xff; } unsigned char geta4Bya6(unsigned char a6) {     for (int i = 0; i < 64; i++)     {         if (nr46.result[i].n == a6)             return nr46.result[i].m;     }     return 0xff; } unsigned char geta3Bya4(unsigned char a4) {     for (int i = 0; i < 64; i++)     {         if (nr34.result[i].n== a4)             return nr34.result[i].m;     }     return 0xff; } unsigned char geta8Bya3(unsigned char a3) {     for (int i = 0; i < 64; i++)     {         if (nr83.result[i].n == a3)             return nr34.result[i].m;     }     return 0xff; } unsigned char geta9Bya4(unsigned char a4) {     for (int i = 0; i < 64; i++)     {         if (nr94.result[i].n == a4)             return nr94.result[i].m;     }     return 0xff; } unsigned char geta10Bya7a3() {     for (int i = 0; i < 4096; i++)     {         if (allr.r[7][i].x == newArm[7] && allr.r[7][i].z == newArm[3])             return allr.r[7][i].y;     }     return 0xff; } unsigned char geta12Bya8a5() {     for (int i = 0; i < 4096; i++)     {         if (allr.r[8][i].x == newArm[8] && allr.r[8][i].z == newArm[5])             return allr.r[8][i].y;     }     return 0xff; } unsigned char geta13Bya11a6() {     for (int i = 0; i < 4096; i++)     {         if (allr.r[9][i].x == newArm[11] && allr.r[9][i].z == newArm[6])             return allr.r[9][i].y;     }     return 0xff; } unsigned char geta14Bya8a10() {     for (int i = 0; i < 4096; i++)     {         if (allr.r[12][i].y == newArm[8] && allr.r[12][i].z == newArm[10])             return allr.r[12][i].x;     }     return 0xff; } unsigned char geta11Bya14a9() {     for (int i = 0; i < 4096; i++)     {         if (allr.r[11][i].y == newArm[14] && allr.r[11][i].z == newArm[9])             return allr.r[11][i].x;     }     return 0xff; } unsigned char geta15Bya9a10() {     for (int i = 0; i < 4096; i++)     {         if (allr.r[13][i].y == newArm[9] && allr.r[13][i].z == newArm[10])             return allr.r[13][i].x;     }     return 0xff; } int _tmain(int argc, _TCHAR* argv[]) {     int count = 0;     unsigned char block = 0;     unsigned char  hh = 0;     unsigned char ll = 0;     int binggo = 0;           printf("开始遍历: \r\n");     for (int loop = 0; loop < 19; loop++)     {         //获取16组解         for (int k = 0; k <16 ; k++)         {             int count = 0;             for (int i = 0; i < 0x40000; i++)             {                 if (g_constKey[i] == arm[k])                 {                     block = i / (64 * 64);                     hh = (i % (64 * 64)) / 64;                     ll = i - block*(4 * 16 * 64) - 64 * hh;                     allr.r[k][count].x = block;                     allr.r[k][count].y = hh;                     allr.r[k][count].z = ll;                     count++;                 }             }         }         for (int indexa1a2a3 = 0; indexa1a2a3 < 4096; indexa1a2a3++)         {             newArm[0] = allr.r[0][indexa1a2a3].x;             newArm[1] = allr.r[0][indexa1a2a3].y;             newArm[2] = allr.r[0][indexa1a2a3].z;             //根据a0获得a3，a4可能解集合             //m=x,n=y             getmnResult(&nr34, newArm[0],1,3);             getmnResult(&nr56, newArm[0],2,3);             getmnResult(&nr57, newArm[1],3,3);             getmnResult(&nr46, newArm[1],4,3);             getmnResult(&nr83, newArm[2],5,2);             getmnResult(&nr94, newArm[2],6,2);             for (int mnIndex = 0; mnIndex < 64; mnIndex++)             {                 newArm[5] = nr56.result[mnIndex].m;                 newArm[6] = nr56.result[mnIndex].n;                 newArm[7] = geta7Bya5(newArm[5]);                 newArm[4] = geta4Bya6(newArm[6]);                 newArm[3] = geta3Bya4(newArm[4]);                 newArm[8] = geta8Bya3(newArm[3]);                 newArm[9] = geta9Bya4(newArm[4]);                 newArm[10] = geta10Bya7a3();                 newArm[12] = geta12Bya8a5();                 newArm[14] = geta14Bya8a10();                 newArm[11] = geta11Bya14a9();                 newArm[13] = geta13Bya11a6();                 newArm[15] = geta15Bya9a10();                         if (g_constKey[64 * 64 * newArm[0] + 64 * newArm[1] + newArm[2]] != arm[0])continue;                 if (g_constKey[64 * 64 * newArm[3] + 64 * newArm[4] + newArm[0]] != arm[1])continue;                 if (g_constKey[64 * 64 * newArm[5] + 64 * newArm[6] + newArm[0]] != arm[2])continue;                 if (g_constKey[64 * 64 * newArm[5] + 64 * newArm[7] + newArm[1]] != arm[3])continue;                 if (g_constKey[64 * 64 * newArm[4] + 64 * newArm[6] + newArm[1]] != arm[4])continue;                 if (g_constKey[64 * 64 * newArm[8] + 64 * newArm[2] + newArm[3]] != arm[5])continue;                 if (g_constKey[64 * 64 * newArm[9] + 64 * newArm[2] + newArm[4]] != arm[6])continue;                 if (g_constKey[64 * 64 * newArm[7] + 64 * newArm[10] + newArm[3]] != arm[7])continue;                 if (g_constKey[64 * 64 * newArm[8] + 64 * newArm[12] + newArm[5]] != arm[8])continue;                 if (g_constKey[64 * 64 * newArm[11] + 64 * newArm[13] + newArm[6]] != arm[9])continue;                 if (g_constKey[64 * 64 * newArm[12] + 64 * newArm[13] + newArm[7]] != arm[10])continue;                 if (g_constKey[64 * 64 * newArm[11] + 64 * newArm[14] + newArm[9]] != arm[11])continue;                 if (g_constKey[64 * 64 * newArm[14] + 64 * newArm[8] + newArm[10]] != arm[12])continue;                 if (g_constKey[64 * 64 * newArm[15] + 64 * newArm[9] + newArm[10]] != arm[13]) continue;                 if (g_constKey[64 * 64 * newArm[15] + 64 * newArm[11] + newArm[12]] != arm[14]) continue;                 if (g_constKey[64 * 64 * newArm[15] + 64 * newArm[13] + newArm[14]] != arm[15]) continue;                   //获得结果                 binggo++;                 printf("倒数第%2d轮: ", 19-loop);                 for (int c = 0; c < 16; c++)                     printf("0x%02x ", newArm[c]);                 printf("\r\n");                 memcpy(arm, newArm, 16);                 break;             }         }     }     printf("\n遍历完成:sn = ");     for (int i = 0; i < 16; i++)     {         arm[i] = srt[arm[i]];         printf("%c", arm[i]);     }     return 0; }

 运行结果如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

开始遍历: 倒数第19轮: 0x0f 0x0b 0x07 0x0b 0x35 0x03 0x19 0x1f 0x0b 0x31 0x3b 0x33 0x03 0x07 0x15 0x37 倒数第18轮: 0x3a 0x26 0x00 0x3a 0x34 0x06 0x2c 0x3c 0x0e 0x1e 0x0a 0x26 0x24 0x18 0x3c 0x18 倒数第17轮: 0x0f 0x07 0x0d 0x15 0x23 0x3f 0x3f 0x19 0x11 0x0d 0x03 0x25 0x37 0x3b 0x19 0x31 倒数第16轮: 0x0c 0x36 0x16 0x06 0x06 0x26 0x04 0x2e 0x0c 0x0c 0x3a 0x10 0x10 0x16 0x36 0x22 倒数第15轮: 0x0f 0x1f 0x33 0x0d 0x2b 0x2b 0x19 0x19 0x3f 0x33 0x35 0x2d 0x27 0x1b 0x11 0x07 倒数第14轮: 0x3a 0x12 0x3c 0x0e 0x2c 0x3c 0x2e 0x08 0x1e 0x22 0x3c 0x12 0x26 0x18 0x0e 0x0e 倒数第13轮: 0x19 0x2f 0x03 0x29 0x15 0x03 0x11 0x29 0x15 0x3f 0x33 0x09 0x1f 0x1d 0x23 0x33 倒数第12轮: 0x38 0x1e 0x38 0x2a 0x0e 0x16 0x1e 0x2a 0x16 0x2c 0x1a 0x1e 0x3e 0x10 0x08 0x28 倒数第11轮: 0x27 0x3d 0x25 0x3f 0x2d 0x29 0x19 0x21 0x27 0x39 0x33 0x05 0x17 0x13 0x0d 0x15 倒数第10轮: 0x30 0x1c 0x28 0x22 0x24 0x08 0x22 0x10 0x00 0x16 0x10 0x24 0x0c 0x1c 0x1c 0x06 倒数第 9轮: 0x25 0x05 0x1f 0x2d 0x27 0x33 0x19 0x0b 0x01 0x0d 0x21 0x31 0x15 0x31 0x3b 0x17 倒数第 8轮: 0x16 0x2e 0x36 0x10 0x08 0x28 0x02 0x20 0x06 0x00 0x28 0x0e 0x14 0x0a 0x04 0x22 倒数第 7轮: 0x35 0x2d 0x31 0x17 0x3b 0x1d 0x29 0x03 0x21 0x0b 0x0b 0x3f 0x05 0x31 0x11 0x1d 倒数第 6轮: 0x3e 0x0a 0x2a 0x02 0x2a 0x08 0x24 0x1e 0x1e 0x3a 0x38 0x1e 0x2c 0x2a 0x1c 0x3c 倒数第 5轮: 0x13 0x01 0x27 0x39 0x2f 0x25 0x1b 0x09 0x2d 0x13 0x11 0x1d 0x31 0x0b 0x37 0x17 倒数第 4轮: 0x2e 0x22 0x24 0x0e 0x2a 0x36 0x00 0x0e 0x34 0x2a 0x32 0x00 0x14 0x20 0x14 0x08 倒数第 3轮: 0x21 0x1f 0x17 0x03 0x27 0x2b 0x29 0x01 0x15 0x1f 0x1b 0x05 0x25 0x39 0x35 0x23 倒数第 2轮: 0x20 0x30 0x32 0x16 0x32 0x12 0x06 0x32 0x3c 0x1a 0x16 0x18 0x30 0x22 0x24 0x1e 倒数第 1轮: 0x11 0x2b 0x21 0x05 0x3f 0x01 0x25 0x0b 0x39 0x13 0x33 0x09 0x3f 0x39 0x35 0x25   遍历完成:sn = rPFf9bJl3tXj93ZJ

sn 为 “rPFf9bJl3tXj93ZJ”