六、逆算准备
根据J和K的关系，很容易就可以根据数组个数计算出实际字符个数。
建立相应的字符对象数组，并使用密码表中不存在的字符（这里是空格符）初始化。
为Bts属性指定一个和原数组个数一样的全0数组，用于存放结果，
而Bts2中放置原数组。因此，我们所要做的事情就是，对于这个字符对象数组中的每一个对象，
找到一个合适的N，使得Bts中的数据和Bts2一样。这个时候每个字符对象对应的字符就是密码表中的第N个字符。
ReCalc中建立了一个列表数组lists，用于存放每个字节受哪些字符对象“控制”（由该字符对象参数生成）。
七、开始逆算
准备好上面的工作后，就可以开始逆算了。
对于字节数组中start位置的字节，它的控制列表为list=lists[start]，
也就是说，所有影响这个位置的字节码生成的字符对象ID，都存放在这个list中。
我们只需要遍历这个list中每一个字符对象的所有NList可能，就可以计算出所有Bts[start]的可能，
取其中Bts[start]=Bts2[start]的就是了。
因为J的关系，list中最大的元素个数是3，所以，最多只需要3层循环。
此外，还有一个技巧需要说明，最后一个字节的控制列表只有一个字符对象，并且一定是最后的那个，这些从
J和K那里可以得知。
每一次NList的循环之前，都需要先备份K和M处的字节数据，以备下一轮循环前还原。
循环把NList的每一个N可能赋值给这个字符对象的N，然后执行Cal计算字节数据。
循环内部再嵌套控制列表list中的下一个字符对象。
在最里面一层循环里面，对比Bts[start]是否等于Bts2[start]，
如果相等，表明该层控制列表各字符对象的N值符合要求（但不是唯一的可能，还可能有别的组合）。
此时，就可以进入start－1层的计算了，该是递归上场的时候了。
且慢，在这之前，还需要做一些准备工作。
这一层已经计算好的字符对象，在下一层的时候可不能重新参与计算，否则就会影响这一层已经计算好的值了。
根据递归原则，我们应该“锁定”这些对象，不允许子递归修改这些对象，
子递归只能通过循环控制列表中的其它对象来“凑”出一个合适的Bts(start)。
八、总结
整个递归算法是深度搜索算法。由于字符与字符之前有相互关系，所以必须是深度搜索，
但又因为这个关系只存在相邻字符之间，所以深度搜索不必每次“到底”。
运算速度还不错，所以就不做性能优化了。
历时24小时左右（20＋4，中间小睡了一会）
大石头
QQ:99363590
Email:gxuhy#21cn.com
http://www.nnhy.org
2007-12-02 01:04
C#逆向算法分析
1
2
/**//// <summary>
3
/// 搜索
4 /// </summary>
5 /// <param name="ts"></param>
6 /// <param name="lists"></param>
7 /// <param name="start"></param>
8
/// <returns></returns> 9 public static Boolean Find(CharObject[] ts, List<Int32> locks, List<Int32>[] lists, Int32 start)
10 
{
11 Console.WriteLine(new String(' ', 12 - start) + "第{0}层", start.ToString());
12
13 //结束条件
14 if (start < 0)
15
{
16 StringBuilder sb = new StringBuilder();
17 for (int i = 0; i < ts.Length; i++)
18 {
19 if (ts[i] == null) break;
20 sb.Append(ts[i].C);
21
}
22 Console.WriteLine(sb.ToString());
23 //如果需要取得所有结果，只需要把下面改成return false;
24 //return false;
25 return true;
26 }
27
28 //递归过程
29 List<Int32> list = new List<int>();
30 //排除锁定项
31 foreach (Int32 t in lists[start])
32 {
33 if (!locks.Contains(t)) list.Add(t);
34 }
35 if (list.Count < 1) return true;
36 list.Sort(IntSort);
37
38 CharObject A = ts[list[0]];
39 Byte[] Bts = A.Bts;
40 Byte[] Bts2 = A.Bts2;
41
42 //处理start以下的字节
43 //上层递归最多到达start处，而本层就要用到start-1了，
44 //处理一下，以免别的子递归曾经修改过start-1
45 if (start > 0) Bts[start - 1] = 0;
46
47 //备份A控制的两个字节，而不一定是Bts[start]和Bts[start－1]
48 Byte[] temp_a = new Byte[2];
49 temp_a[0] = Bts[A.K];
50 temp_a[1] = Bts[A.M];
51 foreach (Int32 a in A.NList)
52 {
53 Bts[A.K] = temp_a[0];
54 Bts[A.M] = temp_a[1];
55 A.N = a;
56 A.Cal();
57 if (list.Count < 2)
58 {
59 if (Bts[start] != Bts2[start]) continue;
60 locks.Add(A.ID);
61 if (Find(ts, locks, lists, start - 1)) return true;
62 locks.Remove(A.ID);
63 continue;
64 }
65 CharObject B = ts[list[1]];
66 Byte[] temp_b = new Byte[2];
67 temp_b[0] = Bts[B.K];
68 temp_b[1] = Bts[B.M];
69 foreach (Int32 b in B.NList)
70 {
71 Bts[B.K] = temp_b[0];
72 Bts[B.M] = temp_b[1];
73 B.N = b;
74 B.Cal();
75 if (list.Count < 3)
76 {
77 //有限个数控制，马上判断
78 if (Bts[start] != Bts2[start]) continue;
79 locks.Add(A.ID);
80 locks.Add(B.ID);
81 if (Find(ts, locks, lists, start - 1)) return true;
82 locks.Remove(A.ID);
83 locks.Remove(B.ID);
84 continue;
85 }
86 CharObject C = ts[list[2]];
87 Byte[] temp_c = new Byte[2];
88 temp_c[0] = Bts[C.K];
89 temp_c[1] = Bts[C.M];
90 foreach (Int32 c in C.NList)
91 {
92 Bts[C.K] = temp_c[0];
93 Bts[C.M] = temp_c[1];
94 C.N = c;
95 C.Cal();
96 //有限个数控制，马上判断
97 if (Bts[start] != Bts2[start]) continue;
98 locks.Add(A.ID);
99 locks.Add(B.ID);
100 locks.Add(C.ID);
101 if (Find(ts, locks, lists, start - 1)) return true;
102 locks.Remove(A.ID);
103 locks.Remove(B.ID);
104 locks.Remove(C.ID);
105 }
106 Bts[C.K] = temp_c[0];
107 Bts[C.M] = temp_c[1];
108 }
109 Bts[B.K] = temp_b[0];
110 Bts[B.M] = temp_b[1];
111 }
112 Bts[A.K] = temp_a[0];
113 Bts[A.M] = temp_a[1];
114 return false;
115 }
116
我不相信神话，我只相信汗水！我不相信命运，我只相信双手！