锦州市广厦电脑维修|上门维修电脑|上门做系统|0416-3905144热诚服务,锦州广厦维修电脑,公司IT外包服务
topFlag1 设为首页
topFlag3 收藏本站
 
maojin003 首 页 公司介绍 服务项目 服务报价 维修流程 IT外包服务 服务器维护 技术文章 常见故障
锦州市广厦电脑维修|上门维修电脑|上门做系统|0416-3905144热诚服务技术文章
[.NET逆向] 南方排八字专业程序破解追码注册教程及爆破版

作者: 佚名  日期:2017-04-20 16:22:25   来源: 本站整理

软件名称:南方排八字专业程序 V7.30
下载地址:http://www.nfzhouyi.com/qita/Download.htm
工具地址:http://down.52pojie.cn/Tools/NET/

2017-4-22
这2天出差,利用时间把注册机重新写了一下。换用vb .net语言,可能比Vb运行起来,兼容性要好一些吧,同时修复了上一版的一个Bug,
计算出来的码,部分会注册不成功,是原算法里面有一处替换,O与0要替换成8,在Dnspy显示的时候,分不清是字母还是数字,出了一
点小差错,这次修复了,同时把南方周易系列可以收集到的,都整合在了一起,分别是排八字、批八字、起名。其中批八字是坛友提供的
安装包,感觉和排八字没有大差别。

新注册机下载地址:  南方周易注册机.zip (12.17 KB, 下载次数: 63) 
有需要的下载这个,大家发现有注册不上的,随时联系我

 

用户组升级了,可以上传3M的附件,咱们不用百度云那个了,我把注册机重新传一下。
那个因为是VB6写的,用了个图标是32位色的,有些系统会 抛出 "末预期错误“
就又更新了一下。对不住大家了。
更新批八字注册机。
只会用一点点的VB,来写出这么个注册机。大家不要玩坏它,不会捕捉Error,这个就会老老实实根据机器码来算注册码。
还有,我是在win10环境下编译的,其它环境没试验,不知道可不可以运行。另外就是界面丑的不忍直视



 

2017-4-18:
在这里感谢steven2016、Mopoo 这两位坛友,是他们提醒和指导我,注册码验证计算的第2步骤,那个是MD5的计算。至此,注册机应该可以写出来了。
新鲜的小白在逆向这条路上,还有好多东西都不知道,谢谢这些乐于助人的坛友,帮助我们来提高。再一次的对吾爱的兄弟姐妹们表示感谢!!
注册机稍后奉上

备注一下:下载回去的补丁,随便输入个假码,就注册成功了:1234CKBA1234B81 输入这个吧。

通过认真学习本贴,80%的可以追到注册码,30%的同学,可以将类似的软件追到注册码,还有10%的同学,应该可以写出注册机。

感谢@spguangz 提醒及处理此贴
前言:之前好像看见过论坛里面有人发这个软件的破解教程,正好想着来学习一下。自去年开始接触逆向,小小的爆破了一个软件后,
就再也没有大进展,还是小白新人一枚。多说一些费话,刚接触逆向的时候,怕.net的程序,现在有些喜欢.net的程序。因为.net的逆向
可以看见源码,比汇编的代码能更加容易的看见程序的逻辑结构和走向。特别是找到了注册验证的核心后,就能够找到注册码(由于刚
刚逆向成功一个软件,不知道其它的软件是不是也这样,就妄自猜测一下。),如果有编程功底的,更是可以追出算法,写出注册机。这
次我们在找出注册码的同时、爆破程序,并且向写"注册机"来挑战,言归正传,开始小白的.net逆向之旅。


需要准备的工具和了解的概念。
1.1、工具篇。       
       刚开始接触这个,就知道有个Reflector这软件是专门针对.net程序的,而之前常用的OD就不在适用.net的逆向。工具可以论坛的爱盘
去下载。有几款工具超级值得推荐,Dnspy、De4dot、Reflector、Reflexi插件、Sanid、Dot Net id,其中Dnspy是动态调试.net程序的,
特别的好用。Reflector需要配合Reflexi插件,就可以修改程序了。工具大致就是这些,后面使用到的时候,会在接着介绍。
1.2、概念或者术语
       需要了解的一些概念或者叫做术语,由于也是刚刚接触.net的程序,很多东西都不懂。搜索论坛及百度,大致知道一些“行话”,列出
来,让和我一样的入门的小白,能更多的了解一些。也不知道理解的对不对,如果有不对的,请大神指点一下。谢谢:)
混淆:
         我理解的意思就是相当于给.net的程序加壳,还有就是使程序中调用的各种方法或者类(不知道这样叫准确不准确,姑且这样叫)都重
新命名,使得调用的关系混乱,不能根据名称来大致猜测出代码的功能。
强命名:
        本意应该是.net的一个特性,就是不充许对软件的修改,造成名称的变化,而影响软件的运行。看一下截图,红线框住的部分,那些用
”单字母”命名的应该是有问题的。我开始以为是强命名的问题,后来我觉得应该是混淆造成的。具体是啥样的,望大神指点。

 


二、开工 Let's GO


2.1、查壳


老套路,开始干活之前,咱们都是先查一下壳,用PEID查一下,看是.net的程序。接着又用ScanID也扫描一下


                          


Scan ID显示有Dotfuscator>>>>>Dotfuscator 208030:0:0:5.26.0.4551,这个是Dotfusctor混淆,通过这2天的调试,
除了上面截图那个,跟踪有些费力,到没有影响分析。


小结:在我们拿到软件,查壳是必需先要做的事情,我们可以知道是否加壳,软件是用什么语言编写的,心里面有一个大概的了解。
同时也可以有针对性的使用不同的工具,比如Delphi就有DD,另外,对于加壳,.net的程序应该就得要想办法去掉,也叫反混淆。而
非.net的程序,有时脱不掉,也可以带壳在OD里面运行起来,同样也可以调试,特别是在载入的时候,搜索不到关键字符的时候,可以
试着把运行F9运行起来,这时壳应该把原程序的代码都释放出来,在搜索关键字就差不多能搜索到了。


2.2、调试开始
        费话这么多,终于进入主题了,开始是使用Reflector来分析的,可是想着这要是能够像OD那样动态调试就好了,在论坛找找,
才知道有Dnspy这神器。太霸道了,之后的分析都是在Dnspy中完成,后面的爆破是用的Reflector+Reflexi完成的。首先把dnspy打
开,载入南方排八字。
 
        打开程序,点击注册,随便输入个假码,会出现"注册码不对"的提示信息,我们在Dnspy中就搜索 "注册"这个关键字,会返回5个调
用的方法其中m那个为注册的关键方法。双击 m 进到代码区。

[C#] 纯文本查看 复制代码
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
string text3 = Strings.Trim(this.o().Text);
IL_AE:
num2 = 14;
bool flag2 = text3.Length < 14 | text3.Length > 15;
if (!flag2)
{
        goto IL_E8;
}
IL_CE:
num2 = 15;
this.m().Text = "注册码不对!";
IL_E2:
goto IL_84E;
IL_E8:
IL_E9:
num2 = 18;


通过上面代码,知道注册码的长度要符合15位,否则注册失败。

[C#] 纯文本查看 复制代码
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
022
023
024
025
026
027
028
029
030
031
032
033
034
035
036
037
038
039
040
041
042
043
044
045
046
047
048
049
050
051
052
053
054
055
056
057
058
059
060
061
062
063
064
065
066
067
068
069
070
071
072
073
074
075
076
077
078
079
080
081
082
083
084
085
086
087
088
089
090
091
092
093
094
095
096
097
098
099
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
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
string text4 = Strings.Mid(text3, 1, 4) + Strings.Mid(text3, 9, 4);
IL_106:
num2 = 19;
string text5 = Strings.Mid(text3, 5, 1);
IL_114:
num2 = 20;
string text6 = Strings.Mid(text3, 6, 1);
IL_122:
num2 = 21;
string text7 = Strings.Mid(text3, 7, 1);
IL_130:
num2 = 22;
string text8 = Strings.Mid(text3, 8, 1);
IL_13E:
num2 = 23;
string text9 = Strings.Mid(text3, 13, 1);
IL_14D:
num2 = 24;
string str2 = Strings.Mid(text3, 14, 1);
IL_15C:
num2 = 25;
bool flag3 = Operators.CompareString(text5, "6", true) == 0 | Operators.CompareString(text5, "7", true) == 0 | Operators.CompareString(text5, "B", true) == 0;
if (!flag3)
{
        goto IL_1A1;
}
IL_197:
num2 = 26;
text5 = "1";
IL_1A1:
num2 = 27;
bool flag4 = Operators.CompareString(text5, "8", true) == 0 | Operators.CompareString(text5, "9", true) == 0 | Operators.CompareString(text5, "C", true) == 0;
if (!flag4)
{
        goto IL_1E6;
}
IL_1DC:
num2 = 28;
text5 = "2";
IL_1E6:
num2 = 29;
bool flag5 = Operators.CompareString(text6, "A", true) == 0;
if (!flag5)
{
        goto IL_209;
}
IL_1FF:
num2 = 30;
text6 = "0";
IL_209:
num2 = 31;
bool flag6 = Operators.CompareString(text6, "B", true) == 0;
if (!flag6)
{
        goto IL_22C;
}
IL_222:
num2 = 32;
text6 = "1";
IL_22C:
num2 = 33;
bool flag7 = Operators.CompareString(text6, "C", true) == 0;
if (!flag7)
{
        goto IL_24F;
}
IL_245:
num2 = 34;
text6 = "2";
IL_24F:
num2 = 35;
bool flag8 = Operators.CompareString(text6, "D", true) == 0;
if (!flag8)
{
        goto IL_272;
}
IL_268:
num2 = 36;
text6 = "3";
IL_272:
num2 = 37;
bool flag9 = Operators.CompareString(text6, "E", true) == 0;
if (!flag9)
{
        goto IL_295;
}
IL_28B:
num2 = 38;
text6 = "4";
IL_295:
num2 = 39;
bool flag10 = Operators.CompareString(text6, "F", true) == 0;
if (!flag10)
{
        goto IL_2B8;
}
IL_2AE:
num2 = 40;
text6 = "5";
IL_2B8:
num2 = 41;
bool flag11 = Operators.CompareString(text6, "G", true) == 0;
if (!flag11)
{
        goto IL_2DB;
}
IL_2D1:
num2 = 42;
text6 = "6";
IL_2DB:
num2 = 43;
bool flag12 = Operators.CompareString(text6, "H", true) == 0;
if (!flag12)
{
        goto IL_2FE;
}
IL_2F4:
num2 = 44;
text6 = "7";
IL_2FE:
num2 = 45;
bool flag13 = Operators.CompareString(text6, "J", true) == 0;
if (!flag13)
{
        goto IL_321;
}
IL_317:
num2 = 46;
text6 = "8";
IL_321:
num2 = 47;
bool flag14 = Operators.CompareString(text6, "K", true) == 0;
if (!flag14)
{
        goto IL_344;
}
IL_33A:
num2 = 48;
text6 = "9";
IL_344:
num2 = 49;
string value = "20" + text5 + text6;
IL_357:
num2 = 50;
bool flag15 = Operators.CompareString(text7, "6", true) == 0 | Operators.CompareString(text7, "7", true) == 0 | Operators.CompareString(text7, "B", true) == 0;
if (!flag15)
{
        goto IL_39C;
}
IL_392:
num2 = 51;
text7 = "1";
IL_39C:
num2 = 52;
bool flag16 = Operators.CompareString(text7, "4", true) == 0 | Operators.CompareString(text7, "5", true) == 0 | Operators.CompareString(text7, "A", true) == 0;
if (!flag16)
{
        goto IL_3E1;
}
IL_3D7:
num2 = 53;
text7 = "0";
IL_3E1:
num2 = 54;
bool flag17 = Operators.CompareString(text8, "A", true) == 0;
if (!flag17)
{
        goto IL_404;
}
IL_3FA:
num2 = 55;
text8 = "0";
IL_404:
num2 = 56;
bool flag18 = Operators.CompareString(text8, "B", true) == 0;
if (!flag18)
{
        goto IL_427;
}
IL_41D:
num2 = 57;
text8 = "1";
IL_427:
num2 = 58;
bool flag19 = Operators.CompareString(text8, "C", true) == 0;
if (!flag19)
{
        goto IL_44A;
}
IL_440:
num2 = 59;
text8 = "2";
IL_44A:
num2 = 60;
bool flag20 = Operators.CompareString(text8, "D", true) == 0;
if (!flag20)
{
        goto IL_46D;
}
IL_463:
num2 = 61;
text8 = "3";
IL_46D:
num2 = 62;
bool flag21 = Operators.CompareString(text8, "E", true) == 0;
if (!flag21)
{
        goto IL_490;
}
IL_486:
num2 = 63;
text8 = "4";
IL_490:
num2 = 64;
bool flag22 = Operators.CompareString(text8, "F", true) == 0;
if (!flag22)
{
        goto IL_4B3;
}
IL_4A9:
num2 = 65;
text8 = "5";
IL_4B3:
num2 = 66;
bool flag23 = Operators.CompareString(text8, "G", true) == 0;
if (!flag23)
{
        goto IL_4D6;
}
IL_4CC:
num2 = 67;
text8 = "6";
IL_4D6:
num2 = 68;
bool flag24 = Operators.CompareString(text8, "H", true) == 0;
if (!flag24)
{
        goto IL_4F9;
}
IL_4EF:
num2 = 69;
text8 = "7";
IL_4F9:
num2 = 70;
bool flag25 = Operators.CompareString(text8, "J", true) == 0;
if (!flag25)
{
        goto IL_51C;
}
IL_512:
num2 = 71;
text8 = "8";
IL_51C:
num2 = 72;
bool flag26 = Operators.CompareString(text8, "K", true) == 0;
if (!flag26)
{
        goto IL_53F;
}
IL_535:
num2 = 73;
text8 = "9";
IL_53F:
num2 = 74;
string value2 = text7 + text8;
IL_54D:
num2 = 75;
bool flag27 = Operators.CompareString(text9, "A", true) == 0;
if (!flag27)
{
        goto IL_570;
}
IL_566:
num2 = 76;
text9 = "0";
IL_570:
num2 = 77;
bool flag28 = Operators.CompareString(text9, "B", true) == 0;
if (!flag28)
{
        goto IL_593;
}
IL_589:
num2 = 78;
text9 = "1";
IL_593:
num2 = 79;
bool flag29 = Operators.CompareString(text9, "C", true) == 0;
if (!flag29)
{
        goto IL_5B6;
}
IL_5AC:
num2 = 80;
text9 = "2";
IL_5B6:
num2 = 81;
string value3 = text9 + str2;
IL_5C4:
num2 = 82;
[C#] 纯文本查看 复制代码
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
int num3 = Conversions.ToInteger(value);
IL_663:
num2 = 88;
int num4 = Conversions.ToInteger(value2);
IL_66F:
num2 = 89;
int num5 = Conversions.ToInteger(value3);
IL_67B:
num2 = 90;
bool flag32 = num5 < 1 | num5 > 28 | num3 < 2013 | num3 > 2030 | num4 < 1 | num4 > 12 | num3 < DateAndTime.Now.Year | (num3 == DateAndTime.Now.Year & num4 < DateAndTime.Now.Month);
if (!flag32)
{
        goto IL_704;
}
IL_6EA:
num2 = 91;
this.m().Text = "注册码不对!";
[C#] 纯文本查看 复制代码
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
bool flag36 = aa.a(ref text2, ref text4) & !File.Exists(ac.j + "\\syspbaz730.dll");
if (!flag36)
{
        IL_837:
        num2 = 111;
        this.m().Text = "注册码不对!";
        IL_84B:
        goto IL_84C;
}
IL_7CB:
num2 = 106;
c.e().Registry.SetValue("HKEY_CURRENT_USER\\Software\\NanfangSoft .net\\PaiBazi730", "Name", this.n().Text);
IL_7F3:
num2 = 107;
string text10 = Strings.UCase(text4);
ac.a(ref text2, ref text10, ref value, ref value2, ref value3);
IL_80F:
num2 = 108;
ac.l = true;
IL_818:
num2 = 109;
this.m().Text = "注册成功!点击'退出'。" + str;
IL_833:
IL_84C:
IL_84D:
goto IL_84E;



通过这3段的代码,一点点的跟踪,我们知道了以下几个信息,这个程序的注册验证过程分为2个步骤。
2.2.1、根据注册码中的第5、6、7、8、13、14位来计算出授权日期,这个日期要在2030年12月份以内,并且大于当前日期。
其中:5/6位拼接年份数据的后2位,然后和20拼接;7/8位拼接月份、13/14位拼接日子数据,第15位应该算是校验位,没发现有啥用。
举例:以第5、6位为例子详解,第5位只能取6、7、B、8、9、C这6个字符,如果是6、7、B则返回1,8、9、C返回2,第
6位只能取A/B/C/D/E/F/G/H/I/K这10个字符,分别对应0-9,
如果假码我们输入:1234CKBA1234B81,


小结:这个假码,开始的时候是用123456789012345来试的,然后又参照程序的代码,大致分析出来每一位表示什么意思,这
个过程,有时不是一下子就能看清,特别是刚刚接触的小白,都是反复的试验。幸好我们所用的工具可以随时跟踪显示变量的值。
让我们可以看见代码执行后,是不是我们想要的,在这里,.net的反汇编出来的内容和OD反汇编出来的可读性要好很多,OD里面
的汇编代码是真心的看不懂,只能根据/jnz/jz /je、test之类的硬猜。




对应下面的表,我们可以计算出注册码的第一部分日期授权的数据。
5、6位查表可知年份日期为2029年,7、8位对应的是10月份、13、14位的日期是18号,上面的注册码计算出的授权日期是:2029-10-18日。


注册码授权日期对应计算表。
 


2.2.2、取机器码的前10位,后5位进行一系列的计算后生成一个8位的码,要和注册码的1-4位与9-12位拼接的8位相等,即注册成功。


得出上面2个结论,花了相当多的时间,这个幸好有Dnspy这工具,可以动态的来调试程序,让我这样的初入门的小白,可以边调试
、边猜测语句的意思,然后用运行结果来验证猜测。在没有一个可以商量的同伴,只有这样摸索的前行。


3、机器码计算部分
       经过前面的这一段分析,信心满满,就继续往后走,见下图,从下面的代码往后不远处,有一个Flag36的标志位,那里就是计算机器
码的关键部分,在Dnspy反汇编出来的方法是aa.a(这名字,看着都恶心,应该就是混淆后的结果,下午找资料用De4dot去混淆,提示成功
却又变成Class+数字的形式,还没现在这样看着舒服,有大神看到这,回帖指点一下。),这个位置的关键点是,要用鼠标点击那个aa.a
向更深入的函数进军。

 

从这个aa.a单击跟进后,仔细的阅读代码,凡是遇见有判断,要越过的地方,就相应的进去,在这里有一点要注意的是,就是观察Dnspy下方的局部变量窗口
凡是我认为挺重要的地方,我红色大字号标出来,新人会有用的,通过观察各个变量的值,有助于我们了解程序的代码计算过程,帮助我们推测和验证我们的猜想。
在这里接着点y.a进行核心算法。

 
 

[C#] 纯文本查看 复制代码
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public static bool a(ref string A_0, ref string A_1)
{
        bool flag = Operators.CompareString(A_0, "", true) == 0 | Operators.CompareString(A_1, "", true) == 0;
        bool result;
        if (flag)
        {
                result = false;
        }
        else
        {
                global::y.a(ref A_0);
                bool flag2 = Operators.CompareString(Strings.UCase(global::y.c), Strings.UCase(A_1), true) == 0;
                if (flag2)
                {
                        global::y.c = "a@^*(^*ga$(&%io";
                        result = true;
                }
                else
                {
                        result = false;
                }
        }
        return result;



在机器码计算这一部分,又大致分了三个过程,分别是y.a、x.a、y.b,这里仍然要跟踪进去,进行详细的分析。
2.3.1、y.a过程:
       将20位机器码取前10、后5拼接成15位,然后通过位移、逻辑运算,取右边的6位,用于第2步计算。
2.3.2、x.a过程:
      第1步传过来的数据,通过计算(在这里我跟丢了,转晕了,看不太明白,想过将代码直接利用,但是没有成功,可能里面有
自定义的函数,或者是引用的命名空间,不是太懂这些。在这里希望能得到高人的指点。),依据2.3.1的值计算出32位长的字符
2.3.3、y.b过程:
     将2.3.2计算出的32位的值,分别从6、8、14、12、17、9位截取2位拼接出一个12位长度的字符。对这12位字符进行循环,继续
在7、5、11、9位取2位数字拼接成最终的结果。

[C#] 纯文本查看 复制代码
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
022
023
024
025
026
027
028
029
030
031
032
033
034
035
036
037
038
039
040
041
042
043
044
045
046
047
048
049
050
051
052
053
054
055
056
057
058
059
060
061
062
063
064
065
066
067
068
069
070
071
072
073
074
075
076
077
078
079
080
081
082
083
084
085
086
087
088
089
090
091
092
093
094
095
096
097
098
099
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
281
282
283
284
285
286
287
public static string a(ref string A_0)
{
        x.d[0] = 1;
        x.d[1] = 3;
        x.d[2] = 7;
        x.d[3] = 15;
        x.d[4] = 31;
        x.d[5] = 63;
        x.d[6] = 127;
        x.d[7] = 255;
        x.d[8] = 511;
        x.d[9] = 1023;
        x.d[10] = 2047;
        x.d[11] = 4095;
        x.d[12] = 8191;
        x.d[13] = 16383;
        x.d[14] = 32767;
        x.d[15] = 65535;
        x.d[16] = 131071;
        x.d[17] = 262143;
        x.d[18] = 524287;
        x.d[19] = 1048575;
        x.d[20] = 2097151;
        x.d[21] = 4194303;
        x.d[22] = 8388607;
        x.d[23] = 16777215;
        x.d[24] = 33554431;
        x.d[25] = 67108863;
        x.d[26] = 134217727;
        x.d[27] = 268435455;
        x.d[28] = 536870911;
        x.d[29] = 1073741823;
        x.d[30] = 2147483647;
        x.e[0] = 1;
        x.e[1] = 2;
        x.e[2] = 4;
        x.e[3] = 8;
        x.e[4] = 16;
        x.e[5] = 32;
        x.e[6] = 64;
        x.e[7] = 128;
        x.e[8] = 256;
        x.e[9] = 512;
        x.e[10] = 1024;
        x.e[11] = 2048;
        x.e[12] = 4096;
        x.e[13] = 8192;
        x.e[14] = 16384;
        x.e[15] = 32768;
        x.e[16] = 65536;
        x.e[17] = 131072;
        x.e[18] = 262144;
        x.e[19] = 524288;
        x.e[20] = 1048576;
        x.e[21] = 2097152;
        x.e[22] = 4194304;
        x.e[23] = 8388608;
        x.e[24] = 16777216;
        x.e[25] = 33554432;
        x.e[26] = 67108864;
        x.e[27] = 134217728;
        x.e[28] = 268435456;
        x.e[29] = 536870912;
        x.e[30] = 1073741824;
        object value = A_0;
        object arg_42E_0 = x.c(ref value);
        A_0 = Conversions.ToString(value);
        object[] array = (object[])arg_42E_0;
        object obj = 1732584193;
        object obj2 = -271733879;
        object obj3 = -1732584194;
        object obj4 = 271733878;
        object obj5;
        object loopObj;
        bool flag = ObjectFlowControl.ForLoopControl.ForLoopInitObj(obj5, 0, Information.UBound(array, 1), 16, ref loopObj, ref obj5);
        if (flag)
        {
                do
                {
                        object objectValue = RuntimeHelpers.GetObjectValue(obj);
                        object objectValue2 = RuntimeHelpers.GetObjectValue(obj2);
                        object objectValue3 = RuntimeHelpers.GetObjectValue(obj3);
                        object objectValue4 = RuntimeHelpers.GetObjectValue(obj4);
                        object[] arg_4EA_4_cp_0 = array;
                        int arg_4EA_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 0));
                        value = 7;
                        object obj6 = -680876936;
                        x.d(ref obj, ref obj2, ref obj3, ref obj4, ref arg_4EA_4_cp_0[arg_4EA_4_cp_1], ref value, ref obj6);
                        object[] arg_528_4_cp_0 = array;
                        int arg_528_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 1));
                        obj6 = 12;
                        value = -389564586;
                        x.d(ref obj4, ref obj, ref obj2, ref obj3, ref arg_528_4_cp_0[arg_528_4_cp_1], ref obj6, ref value);
                        object[] arg_566_4_cp_0 = array;
                        int arg_566_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 2));
                        value = 17;
                        obj6 = 606105819;
                        x.d(ref obj3, ref obj4, ref obj, ref obj2, ref arg_566_4_cp_0[arg_566_4_cp_1], ref value, ref obj6);
                        object[] arg_5A4_4_cp_0 = array;
                        int arg_5A4_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 3));
                        obj6 = 22;
                        value = -1044525330;
                        x.d(ref obj2, ref obj3, ref obj4, ref obj, ref arg_5A4_4_cp_0[arg_5A4_4_cp_1], ref obj6, ref value);
                        object[] arg_5E1_4_cp_0 = array;
                        int arg_5E1_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 4));
                        value = 7;
                        obj6 = -176418897;
                        x.d(ref obj, ref obj2, ref obj3, ref obj4, ref arg_5E1_4_cp_0[arg_5E1_4_cp_1], ref value, ref obj6);
                        object[] arg_61F_4_cp_0 = array;
                        int arg_61F_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 5));
                        obj6 = 12;
                        value = 1200080426;
                        x.d(ref obj4, ref obj, ref obj2, ref obj3, ref arg_61F_4_cp_0[arg_61F_4_cp_1], ref obj6, ref value);
                        object[] arg_65D_4_cp_0 = array;
                        int arg_65D_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 6));
                        value = 17;
                        obj6 = -1473231341;
                        x.d(ref obj3, ref obj4, ref obj, ref obj2, ref arg_65D_4_cp_0[arg_65D_4_cp_1], ref value, ref obj6);
                        object[] arg_69B_4_cp_0 = array;
                        int arg_69B_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 7));
                        obj6 = 22;
                        value = -45705983;
                        x.d(ref obj2, ref obj3, ref obj4, ref obj, ref arg_69B_4_cp_0[arg_69B_4_cp_1], ref obj6, ref value);
                        object[] arg_6D8_4_cp_0 = array;
                        int arg_6D8_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 8));
                        value = 7;
                        obj6 = 1770035416;
                        x.d(ref obj, ref obj2, ref obj3, ref obj4, ref arg_6D8_4_cp_0[arg_6D8_4_cp_1], ref value, ref obj6);
                        object[] arg_717_4_cp_0 = array;
                        int arg_717_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 9));
                        obj6 = 12;
                        value = -1958414417;
                        x.d(ref obj4, ref obj, ref obj2, ref obj3, ref arg_717_4_cp_0[arg_717_4_cp_1], ref obj6, ref value);
                        object[] arg_756_4_cp_0 = array;
                        int arg_756_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 10));
                        value = 17;
                        obj6 = -42063;
                        x.d(ref obj3, ref obj4, ref obj, ref obj2, ref arg_756_4_cp_0[arg_756_4_cp_1], ref value, ref obj6);
                        object[] arg_795_4_cp_0 = array;
                        int arg_795_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 11));
                        obj6 = 22;
                        value = -1990404162;
                        x.d(ref obj2, ref obj3, ref obj4, ref obj, ref arg_795_4_cp_0[arg_795_4_cp_1], ref obj6, ref value);
                        object[] arg_7D3_4_cp_0 = array;
                        int arg_7D3_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 12));
                        value = 7;
                        obj6 = 1804603682;
                        x.d(ref obj, ref obj2, ref obj3, ref obj4, ref arg_7D3_4_cp_0[arg_7D3_4_cp_1], ref value, ref obj6);
                        object[] arg_812_4_cp_0 = array;
                        int arg_812_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 13));
                        obj6 = 12;
                        value = -40341101;
                        x.d(ref obj4, ref obj, ref obj2, ref obj3, ref arg_812_4_cp_0[arg_812_4_cp_1], ref obj6, ref value);
                        object[] arg_851_4_cp_0 = array;
                        int arg_851_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 14));
                        value = 17;
                        obj6 = -1502002290;
                        x.d(ref obj3, ref obj4, ref obj, ref obj2, ref arg_851_4_cp_0[arg_851_4_cp_1], ref value, ref obj6);
                        object[] arg_890_4_cp_0 = array;
                        int arg_890_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 15));
                        obj6 = 22;
                        value = 1236535329;
                        x.d(ref obj2, ref obj3, ref obj4, ref obj, ref arg_890_4_cp_0[arg_890_4_cp_1], ref obj6, ref value);
                        object[] arg_8CD_4_cp_0 = array;
                        int arg_8CD_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 1));
                        value = 5;
                        obj6 = -165796510;
                        x.c(ref obj, ref obj2, ref obj3, ref obj4, ref arg_8CD_4_cp_0[arg_8CD_4_cp_1], ref value, ref obj6);
                        object[] arg_90B_4_cp_0 = array;
                        int arg_90B_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 6));
                        obj6 = 9;
                        value = -1069501632;
                        x.c(ref obj4, ref obj, ref obj2, ref obj3, ref arg_90B_4_cp_0[arg_90B_4_cp_1], ref obj6, ref value);
                        object[] arg_94A_4_cp_0 = array;
                        int arg_94A_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 11));
                        value = 14;
                        obj6 = 643717713;
                        x.c(ref obj3, ref obj4, ref obj, ref obj2, ref arg_94A_4_cp_0[arg_94A_4_cp_1], ref value, ref obj6);
                        object[] arg_988_4_cp_0 = array;
                        int arg_988_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 0));
                        obj6 = 20;
                        value = -373897302;
                        x.c(ref obj2, ref obj3, ref obj4, ref obj, ref arg_988_4_cp_0[arg_988_4_cp_1], ref obj6, ref value);
                        object[] arg_9C5_4_cp_0 = array;
                        int arg_9C5_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 5));
                        value = 5;
                        obj6 = -701558691;
                        x.c(ref obj, ref obj2, ref obj3, ref obj4, ref arg_9C5_4_cp_0[arg_9C5_4_cp_1], ref value, ref obj6);
                        object[] arg_A04_4_cp_0 = array;
                        int arg_A04_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 10));
                        obj6 = 9;
                        value = 38016083;
                        x.c(ref obj4, ref obj, ref obj2, ref obj3, ref arg_A04_4_cp_0[arg_A04_4_cp_1], ref obj6, ref value);
                        object[] arg_A43_4_cp_0 = array;
                        int arg_A43_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 15));
                        value = 14;
                        obj6 = -660478335;
                        x.c(ref obj3, ref obj4, ref obj, ref obj2, ref arg_A43_4_cp_0[arg_A43_4_cp_1], ref value, ref obj6);
                        object[] arg_A81_4_cp_0 = array;
                        int arg_A81_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 4));
                        obj6 = 20;
                        value = -405537848;
                        x.c(ref obj2, ref obj3, ref obj4, ref obj, ref arg_A81_4_cp_0[arg_A81_4_cp_1], ref obj6, ref value);
                        object[] arg_ABF_4_cp_0 = array;
                        int arg_ABF_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 9));
                        value = 5;
                        obj6 = 568446438;
                        x.c(ref obj, ref obj2, ref obj3, ref obj4, ref arg_ABF_4_cp_0[arg_ABF_4_cp_1], ref value, ref obj6);
                        object[] arg_AFE_4_cp_0 = array;
                        int arg_AFE_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 14));
                        obj6 = 9;
                        value = -1019803690;
                        x.c(ref obj4, ref obj, ref obj2, ref obj3, ref arg_AFE_4_cp_0[arg_AFE_4_cp_1], ref obj6, ref value);
                        object[] arg_B3C_4_cp_0 = array;
                        int arg_B3C_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 3));
                        value = 14;
                        obj6 = -187363961;
                        x.c(ref obj3, ref obj4, ref obj, ref obj2, ref arg_B3C_4_cp_0[arg_B3C_4_cp_1], ref value, ref obj6);
                        object[] arg_B7A_4_cp_0 = array;
                        int arg_B7A_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 8));
                        obj6 = 20;
                        value = 1163531501;
                        x.c(ref obj2, ref obj3, ref obj4, ref obj, ref arg_B7A_4_cp_0[arg_B7A_4_cp_1], ref obj6, ref value);
                        object[] arg_BB8_4_cp_0 = array;
                        int arg_BB8_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 13));
                        value = 5;
                        obj6 = -1444681467;
                        x.c(ref obj, ref obj2, ref obj3, ref obj4, ref arg_BB8_4_cp_0[arg_BB8_4_cp_1], ref value, ref obj6);
                        object[] arg_BF6_4_cp_0 = array;
                        int arg_BF6_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 2));
                        obj6 = 9;
                        value = -51403784;
                        x.c(ref obj4, ref obj, ref obj2, ref obj3, ref arg_BF6_4_cp_0[arg_BF6_4_cp_1], ref obj6, ref value);
                        object[] arg_C34_4_cp_0 = array;
                        int arg_C34_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 7));
                        value = 14;
                        obj6 = 1735328473;
                        x.c(ref obj3, ref obj4, ref obj, ref obj2, ref arg_C34_4_cp_0[arg_C34_4_cp_1], ref value, ref obj6);
                        object[] arg_C73_4_cp_0 = array;
                        int arg_C73_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 12));
                        obj6 = 20;
                        value = -1926607734;
                        x.c(ref obj2, ref obj3, ref obj4, ref obj, ref arg_C73_4_cp_0[arg_C73_4_cp_1], ref obj6, ref value);
                        object[] arg_CB0_4_cp_0 = array;
                        int arg_CB0_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 5));
                        value = 4;
                        obj6 = -378558;
                        x.b(ref obj, ref obj2, ref obj3, ref obj4, ref arg_CB0_4_cp_0[arg_CB0_4_cp_1], ref value, ref obj6);
                        object[] arg_CEE_4_cp_0 = array;
                        int arg_CEE_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 8));
                        obj6 = 11;
                        value = -2022574463;
                        x.b(ref obj4, ref obj, ref obj2, ref obj3, ref arg_CEE_4_cp_0[arg_CEE_4_cp_1], ref obj6, ref value);
                        object[] arg_D2D_4_cp_0 = array;
                        int arg_D2D_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 11));
                        value = 16;
                        obj6 = 1839030562;
                        x.b(ref obj3, ref obj4, ref obj, ref obj2, ref arg_D2D_4_cp_0[arg_D2D_4_cp_1], ref value, ref obj6);
                        object[] arg_D6C_4_cp_0 = array;
                        int arg_D6C_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 14));
                        obj6 = 23;
                        value = -35309556;
                        x.b(ref obj2, ref obj3, ref obj4, ref obj, ref arg_D6C_4_cp_0[arg_D6C_4_cp_1], ref obj6, ref value);
                        object[] arg_DA9_4_cp_0 = array;
                        int arg_DA9_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 1));
                        value = 4;
                        obj6 = -1530992060;
                        x.b(ref obj, ref obj2, ref obj3, ref obj4, ref arg_DA9_4_cp_0[arg_DA9_4_cp_1], ref value, ref obj6);
                        object[] arg_DE7_4_cp_0 = array;
                        int arg_DE7_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 4));
                        obj6 = 11;
                        value = 1272893353;
                        x.b(ref obj4, ref obj, ref obj2, ref obj3, ref arg_DE7_4_cp_0[arg_DE7_4_cp_1], ref obj6, ref value);
                        object[] arg_E25_4_cp_0 = array;
                        int arg_E25_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 7));
                        value = 16;
                        obj6 = -155497632;
                        x.b(ref obj3, ref obj4, ref obj, ref obj2, ref arg_E25_4_cp_0[arg_E25_4_cp_1], ref value, ref obj6);
                        object[] arg_E64_4_cp_0 = array;
                        int arg_E64_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 10));
                        obj6 = 23;
                        value = -1094730640;
                        x.b(ref obj2, ref obj3, ref obj4, ref obj, ref arg_E64_4_cp_0[arg_E64_4_cp_1], ref obj6, ref value);
                        object[] arg_EA2_4_cp_0 = array;
                        int arg_EA2_4_cp_1 = Conversions.ToInteger(Operators.AddObject(obj5, 13));
                        value = 4;
                        obj6 = 681279174;

[1] [2]  下一页



热门文章
  • 机械革命S1 PRO-02 开机不显示 黑...
  • 联想ThinkPad NM-C641上电掉电点不...
  • 三星一体激光打印机SCX-4521F维修...
  • 通过串口命令查看EMMC擦写次数和判...
  • IIS 8 开启 GZIP压缩来减少网络请求...
  • 索尼kd-49x7500e背光一半暗且闪烁 ...
  • 楼宇对讲门禁读卡异常维修,读卡芯...
  • 新款海信电视机始终停留在开机界面...
  • 常见打印机清零步骤
  • 安装驱动时提示不包含数字签名的解...
  • 共享打印机需要密码的解决方法
  • 图解Windows 7系统快速共享打印机的...
  • 锦州广厦电脑上门维修

    报修电话:13840665804  QQ:174984393 (联系人:毛先生)   
    E-Mail:174984393@qq.com
    维修中心地址:锦州广厦电脑城
    ICP备案/许可证号:辽ICP备2023002984号-1
    上门服务区域: 辽宁锦州市区
    主要业务: 修电脑,电脑修理,电脑维护,上门维修电脑,黑屏蓝屏死机故障排除,无线上网设置,IT服务外包,局域网组建,ADSL共享上网,路由器设置,数据恢复,密码破解,光盘刻录制作等服务

    技术支持:微软等