[原创] 看雪 2023 KCTF 年度赛第七题智能联盟计划-CTF对抗-看雪-安全社区|安全招聘|kanxue.com

[原创] 看雪 2023 KCTF 年度赛第七题智能联盟计划
发表于: 2023-9-17 07:12 11405
[原创] 看雪 2023 KCTF 年度赛第七题智能联盟计划

mb_mgodlfyn 活跃值
2023-9-17 07:12
11405
（印象中这题之前好像放在第八题的位置上，是因为赶上周末所以把难题调整顺序了？）  
第七题
Archaia
方案二  
众多熟悉的因素叠加  
writeup正文开始前，先看一个有关Archaia战队的合订本。  
战队名称：Archaia
战队签名&战队介绍：武汉科锐学员队
注册时间：2019-06-08
（以上信息来自 https://ctf.kanxue.com/team-myctf-101159.htm)  
从注册时间往后看，最早能追溯到2019看雪CTF晋级赛Q2  
Archaia战队第一次防守方出的题，思路颇有特色。
但从第二次开始(至少直到上次)，所有题目的思路高度雷同（甚至有的题目算法都相同）：windows程序+方案二+一些计算算法检查序列号+混淆&|加壳+从不公开混淆&加壳程序的源代码+官方题解从未给出过自动化去混淆脚本  
2019看雪CTF晋级赛Q2 第八题：迷雾中的琴声：输入作为shellcode执行，目标是弹框Win+通过crc校验，无壳，多解。
2019看雪CTF晋级赛Q3 第十题：传家之宝：2880层自解密自复制蜗牛壳，每层都包含核心逻辑的少量分片，程序正常运行都需要若干秒才能结束。序列号的检查逻辑是魔改AES算法
2019看雪CTF总决赛 第六题：三道八佛：1401层smc，只在最后一层有核心逻辑；上次的脱壳脚本可以复用。序列号的检查逻辑是一个自定义数据算法。与2019Q3的题混淆/加壳相同，算法改变了。
看雪.深信服 2021 KCTF 春季赛 第七题 千里寻根：2021层smc，每层的蜗牛壳代码都不一样（重中之重，这一个小改动导致攻破此题的三个攻击方都没有像先前的题一样做到完美抠出核心逻辑的指令交给IDA，而是更多的依赖调试和看汇编，体力活更大了；另外，赛后出题人在题解里轻飘飘的说了句 “脚本log出来的数据需要自己提取出有用的"肉代码". 可以人肉搞定, 或者找到规律后写脚本一通字符串操作也能搞定.这里给出前几层肉代码的分析, 后面层的同理.”(链接)，但等了两年出题人却迟迟没有公开这个脚本，合理质疑下出题人真的验证过这样的简单性吗？又或许每层壳虽然代码不同但只有有限种组合，那么出题人是不是应该公开加壳处理的代码证明一下这一点呢？）。算法部分与2019Q4类似，只做了小改动。
看雪.众安 2021 KCTF 秋季赛 第九题 万事俱备：还是代码混淆，语言换成了python字节码。算法也是2021H1的老算法+微小修改。解释器改opcode是常规但对于攻击方而言除了徒增工作量以外毫无学习意义；而字节码混淆，出题人说“只要攻击方能击破代码混淆, 就是看"源码"写逆算法的活了”(链接)，不过读几位攻击方大佬的writeup，实际处理起来似乎并没有这么轻松；同样，出题人没有公开自己的处理脚本，合理质疑下出题人验题真的尝试正面破解过自己的代码混淆吗？
看雪 2022·KCTF 春季赛 第五题 危机四伏：基于2021H1题目继续加难，蜗牛壳没了，但每层的垃圾指令混淆还在。三个公开的攻击方writeup全是非预期（算法几乎完全没变，只改了异或常量），而出题人的预期仍然说的非常轻松：想办法处理xxx、找出xxx的规律、根据特征xxx、写脚本将垃圾指令除去、等(链接)。但是，具体用什么办法？规律和特征是怎样的？脚本怎么写？出题人仍然什么都没公开。
看雪 2022·KCTF 秋季赛 第十一题 衣锦昼行：这次终于换了算法，但不变的还是代码混淆+出题人对于具体怎么去混淆只字未谈（所以，题目发布前是怎么验题的？）。另外序列号在程序计算过程中暴露，导致题目被迅速非预期。  
结合2022H1-2021H1-2019Q4-2019Q3题目的延续性，以及2022H2的题目被非预期，当Archaia出现在今年的防守方列表时，就有预感大概率是把2022H2的题目修了非预期再出。  
正文开始  
IDA打开，看到main函数立刻证明了这就是基于2022H2题目修改而来。下载2022H2题目出题人公开的源代码(链接)，对照main函数，把所有变量和函数重命名并修正类型。  
注意这些被调用函数的调用约定都是"__cdecl"，需要先手动修正过来，否则IDA对栈上临时变量的识别会出问题。  
调用的Encode_{X}、RSHash、sub_40F9AF、Encode_For_Serial、sub_403ACA、Decode_For_Serial函数都加了混淆，主要是花指令+垃圾指令+控制流跳转混淆。（例如，jz xxx ; jnz xxx 两个相邻且条件相反的条件跳转指令，等价于一条绝对跳转。）  
大概看了一下，感觉模式匹配或许能处理一部分；或者，不处理混淆，动态调试单步执行硬跟的复杂度也能接受。  
在此之前，main函数没有混淆，先梳理一下name和serial的数据流。  
name输入后，先经过48个Encode_{X}函数运算，再经过RSHash运算，得到szHash2Hash_，作为最后strcmp的第一个参数参与比较。
然后对szHash2Hash先做两次sub_40F9AF_0(以0作为第三个参数调用sub_40F9AF)运算再做21次Encode_For_Serial运算可得到szCurrentSer。
serial输入后，先hexdecode，再与szCurrentSer一起做sub_403ACA运算，然后是22次Decode_For_Serial运算，最后是sub_40F9AF_1(以1作为第三个参数调用sub_40F9AF)运算，得到szDecCurrent_，作为最后strcmp的第二个参数参与比较，如果与szHash2Hash_相等则通过校验。  
但是，如果在输入serial之前最后一个调用的Encode_For_Serial和输入serial之后第一个调用的Decode_For_Serial下断点，可以发现它们的参数是互逆的。这表明，从szHash2Hash出发，依次做 2次sub_40F9AF_0 -> 22次Encode_For_Serial -> 22次Decode_For_Serial -> 1次sub_40F9AF_1，会得到与szHash2Hash相等的值，而已知Encode_For_Serial与Decode_For_Serial互逆，所以 2次sub_40F9AF_0 与 1次sub_40F9AF_0 互逆，这几个函数混淆后的代码都无需关注。  
所以，现在只有sub_403ACA的逻辑未知且找不到它的逆函数。动态调试发现它的前两个参数是输入，第三个参数是输出。    
当已知name时，沿着数据流可以正向得到szCurrentSer作为sub_403ACA的第二个参数，同时可以正向得到szHash2Hash，经判等转到szDecCurrent_，再逆向 1次sub_40F9AF_1+22次Decode_For_Serial可得到sub_403ACA的第三个参数 (前面验证了这个逆向的过程等同于 2次sub_40F9AF_0+22次Encode_For_Serial，所以直接在0x40347A，即最后一个Encode_For_Serial的位置下断点看此时栈上的参数即可获得具体值) 。  
总结下来，在已知name时，sub_403ACA的第二个参数和第三个参数都可以获得，而第一个参数是待求的serial，所以只需要逆向这一个函数即可。  
静态逆向？代码混淆着实非常讨厌，这里从动态调试入手分析。  
动态调试观察到sub_403ACA函数的三个参数，每个长度都是16字节，且前两个参数即使改一个bit第三个参数的输出也会完全改变，所以这很可能是某种16字节的块加密算法。  
对前两个参数所在的内存下硬件数据读写断点，在经历一次数据复制后到达了栈上19EDB4的位置，此后的数据访问都发生在这里。
实测发现，需要对第一个参数（即serial）的4个四字节都下上硬件读写断点，如果偷懒只下一个或两个程序有可能会闪退。具体原因未深究，但是注意到main函数有启动一个新的线程，且如果patch掉这块代码，程序会在sub_403ACA闪退，所以这里可能有特殊的检测。代码混淆太恶心了，不想去碰。  
初始：name和serial分别输入题目提供的值：CCFE84316BD02C02和D532E41AFE55A4265D7789C84BF40384  
对第二个参数下好4个断点，逐步按F9并跟随数据复制修改断点位置，发现代码在逐渐填充19ECF0到19EDAF之间的数据，填充数量合计11*4个四字节。  
对第一个参数下好4个断点，同样按F9并跟随数据复制修改断点位置，观察到19EDB4数据的变化，发现有逐单字节改变和逐四字节改变的交替  
重新开始单步调试，观察到这里数据的变化有几个阶段：
初始：
19EDB4的数据清零；堆区有分配的serial值（注意8BD8D8这个地址不是固定的）
第一步：把serial值复制到19EDB4处，复制时以4为间隔步长（另一个角度理解，相当于4*4矩阵的转置）
新的数值：
第二步：19EDB4开始的4个四字节，分别与19ECF8、19ED24、19ED50、19ED7C的4个四字节异或
待异或的值：
异或之后的值：
第三步：19EDB4位置，4个字节一组，第一组不变，第二组循环左移1字节，第三组循环左移3字节，第四组循环左移2字节
变化之后的值：  
第四步：19EDB4的每个字节做一次查表变换，表在0x62C700，位于程序的.rdata段  
变换之后：  
至此，数据的变换已经出现了明显的AES特征。第二、三、四步分别可能对应addroundkey、shiftrows/invshiftrows、subbytes/invsubbytes。  
回顾一下10轮AES-128加密和解密的步骤：  
加密：  
解密：  
目前的第二、三、四步，与加密的前三步不同，与解密的前三步能对应上，且能够确认的是invshiftrows有魔改（每行移位的数量与标准算法不同）、invsbox有修改。  
按照AES解密的逻辑，下一个步骤应该是invmixcolumns。先前找到了魔改过的invsbox在全局变量byte_62C700，而它附近的byte_62C800恰好是对应的sbox，且在.text段有交叉引用（这或许预示着sub_403ACA的逆函数就在程序里，但那又有什么用呢，代码混淆解开之前根本找不到入口点在哪里）；再看附近的内存，byte_62C900 (02 03 01 01 01 02 03 01  01 01 02 03 03 01 01 02) 和byte_62C910分别是mixcolumns和invmixcolumns矩阵的标准形式，所以invmixcolumns应该没有经过魔改。继续单步调试，数据变换与标准的invmixcolumns计算结果相同，证明确实如此。    
最后是addroundkey使用的轮密钥，调试发现是19ECF0到19EDAF之间填充的值，但每轮并不是按顺序取值。在这块区域下数据访问断点，多调试几轮，可以找出具体顺序。  
基于以上分析，写出aes_dec复现sub_403ACA的逻辑，动态调试验证结果正确后改写为aes_enc，得到serial生成脚本如下：  
最终答案：
多解：
hexdecode之前只检查了不出现小写字母，但调试发现如果输入的字符不在[0-9A-F]会视为0，所以serial中的0可以替换为几乎所有字符，例如：
8BCBB6979E174CB7ECAEACDA1G4522CA
（题目过滤小写字母大概是想避免2022H2的大小写多解，但是，基于黑名单的过滤总是容易出现意外惊喜；既然做了字符过滤，换成白名单，限制只允许[0-9A-F]即可轻松解决（用哈希虽然也能限制多解，但是缺了灵魂））  
正文结束  
最后，作为对攻击方“在最终成绩公布前请在【答案提交区】发表解题分析文章、所用工具、源代码等材料，且文章有理有据能够详细完成说明自己获得答案的整个过程”的对等要求，在此恳请组委会，要求此题防守方能公开此题做混淆处理过程的源代码(注意这不同于crackme混淆前的源代码)（ref：看雪·2023 KCTF 年度赛【防守方】规则 方案二，“所提交的壳或VM或其他手工处理的方法将在赛后向广大会员公开”，https://bbs.kanxue.com/thread-276642.htm，这里是不是应该理解为用出题人公开的源代码按照出题人公开的方法要能够生成最终的二进制文件？另外.obj文件显然并不等同于源代码），以及，验题时出题人/验题人以攻击者视角做题时的具体去混淆方法和处理代码（这里 描述的破解思路，显然过于简洁，并不满足“有理有据能够详细完成说明自己获得答案的整个过程”的(虽然这是对攻击方的要求，但防守方自己出的题，达成同样的要求会更简单)；或者说，出题人给出的题解，至少要充分详细到让一个完全没有做过这道题的人照着抄答案能够破解掉题目，对于加了混淆的题目，详细且可复现的去混淆方法当然是必备的）。  
// bad sp value at call has been detected, the output may be wrong!

int __cdecl main(int argc, const char **argv, const char **envp)
{

  int v3; // eax

  int v4; // eax

  char szInput_encrypted[256]; // [esp+0h] [ebp-1140h] BYREF

  char szKeySerialConcat[500]; // [esp+100h] [ebp-1040h] BYREF

  _BYTE szKeySerialConcat_[50][8]; // [esp+2F4h] [ebp-E4Ch] BYREF

  char szInput[256]; // [esp+4E8h] [ebp-C58h] BYREF

  char szAllHash[50][8]; // [esp+5E8h] [ebp-B58h] BYREF

  char White_message[50]; // [esp+778h] [ebp-9C8h] BYREF

  char szKeySerial[50][9]; // [esp+7ACh] [ebp-994h] BYREF

  char Black_message10[16]; // [esp+970h] [ebp-7D0h] BYREF

  char Black_message6[16]; // [esp+980h] [ebp-7C0h] BYREF

  char Black_message5[16]; // [esp+990h] [ebp-7B0h] BYREF

  char Black_message4[16]; // [esp+9A0h] [ebp-7A0h] BYREF

  char Black_message48[16]; // [esp+9B0h] [ebp-790h] BYREF

  char Black_message47[16]; // [esp+9C0h] [ebp-780h] BYREF

  char Black_message46[16]; // [esp+9D0h] [ebp-770h] BYREF

  char Black_message42[16]; // [esp+9E0h] [ebp-760h] BYREF

  char Black_message41[16]; // [esp+9F0h] [ebp-750h] BYREF

  char Black_message40[16]; // [esp+A00h] [ebp-740h] BYREF

  char Black_message36[16]; // [esp+A10h] [ebp-730h] BYREF

  char Black_message35[16]; // [esp+A20h] [ebp-720h] BYREF

  char Black_message34[16]; // [esp+A30h] [ebp-710h] BYREF

  char Black_message30[16]; // [esp+A40h] [ebp-700h] BYREF

  char Black_message29[16]; // [esp+A50h] [ebp-6F0h] BYREF

  char Black_message28[16]; // [esp+A60h] [ebp-6E0h] BYREF

  char Black_message24[16]; // [esp+A70h] [ebp-6D0h] BYREF

  char Black_message23[16]; // [esp+A80h] [ebp-6C0h] BYREF

  char Black_message22[16]; // [esp+A90h] [ebp-6B0h] BYREF

  char Black_message18[16]; // [esp+AA0h] [ebp-6A0h] BYREF

  char Black_message17[16]; // [esp+AB0h] [ebp-690h] BYREF

  char Black_message16[16]; // [esp+AC0h] [ebp-680h] BYREF

  char Black_message12[16]; // [esp+AD0h] [ebp-670h] BYREF

  char Black_message11[16]; // [esp+AE0h] [ebp-660h] BYREF

  char My_key33[8]; // [esp+AF0h] [ebp-650h] BYREF

  char My_key34[8]; // [esp+AF8h] [ebp-648h] BYREF

  char My_key35[8]; // [esp+B00h] [ebp-640h] BYREF

  char My_key36[8]; // [esp+B08h] [ebp-638h] BYREF

  char Black_message45[16]; // [esp+B10h] [ebp-630h] BYREF

  char Black_message44[16]; // [esp+B20h] [ebp-620h] BYREF

  char Black_message43[16]; // [esp+B30h] [ebp-610h] BYREF

  char Black_message39[16]; // [esp+B40h] [ebp-600h] BYREF

  char Black_message38[16]; // [esp+B50h] [ebp-5F0h] BYREF

  char Black_message37[16]; // [esp+B60h] [ebp-5E0h] BYREF

  char Black_message33[16]; // [esp+B70h] [ebp-5D0h] BYREF

  char Black_message32[16]; // [esp+B80h] [ebp-5C0h] BYREF

  char Black_message31[16]; // [esp+B90h] [ebp-5B0h] BYREF

  char Black_message27[16]; // [esp+BA0h] [ebp-5A0h] BYREF

  char Black_message26[16]; // [esp+BB0h] [ebp-590h] BYREF

  char Black_message25[16]; // [esp+BC0h] [ebp-580h] BYREF

  char Black_message21[16]; // [esp+BD0h] [ebp-570h] BYREF

  char Black_message20[16]; // [esp+BE0h] [ebp-560h] BYREF

  char Black_message19[16]; // [esp+BF0h] [ebp-550h] BYREF

  char Black_message15[16]; // [esp+C00h] [ebp-540h] BYREF

  char Black_message14[16]; // [esp+C10h] [ebp-530h] BYREF

  char Black_message13[16]; // [esp+C20h] [ebp-520h] BYREF

  char Black_message9[16]; // [esp+C30h] [ebp-510h] BYREF

  char Black_message8[16]; // [esp+C40h] [ebp-500h] BYREF

  char Black_message7[16]; // [esp+C50h] [ebp-4F0h] BYREF

  char Black_message3[16]; // [esp+C60h] [ebp-4E0h] BYREF

  char Black_message2[16]; // [esp+C70h] [ebp-4D0h] BYREF

  char Black_message1[16]; // [esp+C80h] [ebp-4C0h] BYREF

  char My_key37[8]; // [esp+C90h] [ebp-4B0h] BYREF

  char My_key38[8]; // [esp+C98h] [ebp-4A8h] BYREF

  char My_key43[8]; // [esp+CA0h] [ebp-4A0h] BYREF

  char My_key45[8]; // [esp+CA8h] [ebp-498h] BYREF

  char My_key46[8]; // [esp+CB0h] [ebp-490h] BYREF

  char My_key47[8]; // [esp+CB8h] [ebp-488h] BYREF

  char My_key48[8]; // [esp+CC0h] [ebp-480h] BYREF

  char My_key39[8]; // [esp+CC8h] [ebp-478h] BYREF

  char My_key40[8]; // [esp+CD0h] [ebp-470h] BYREF

  char My_key41[8]; // [esp+CD8h] [ebp-468h] BYREF

  char My_key42[8]; // [esp+CE0h] [ebp-460h] BYREF

  char My_key44[8]; // [esp+CE8h] [ebp-458h] BYREF

  char My_key32[8]; // [esp+CF0h] [ebp-450h] BYREF

  char My_key31[8]; // [esp+CF8h] [ebp-448h] BYREF

  char My_key30[8]; // [esp+D00h] [ebp-440h] BYREF

  char My_key29[8]; // [esp+D08h] [ebp-438h] BYREF

  char My_key28[8]; // [esp+D10h] [ebp-430h] BYREF

  char My_key27[8]; // [esp+D18h] [ebp-428h] BYREF

  char My_key26[8]; // [esp+D20h] [ebp-420h] BYREF

  char My_key25[8]; // [esp+D28h] [ebp-418h] BYREF

  char My_key24[8]; // [esp+D30h] [ebp-410h] BYREF

  char My_key23[8]; // [esp+D38h] [ebp-408h] BYREF

  char My_key22[8]; // [esp+D40h] [ebp-400h] BYREF

  char My_key21[8]; // [esp+D48h] [ebp-3F8h] BYREF

  char My_key20[8]; // [esp+D50h] [ebp-3F0h] BYREF

  char My_key19[8]; // [esp+D58h] [ebp-3E8h] BYREF

  char My_key18[8]; // [esp+D60h] [ebp-3E0h] BYREF

  char My_key17[8]; // [esp+D68h] [ebp-3D8h] BYREF

  char My_key16[8]; // [esp+D70h] [ebp-3D0h] BYREF

  char My_key15[8]; // [esp+D78h] [ebp-3C8h] BYREF

  char My_key14[8]; // [esp+D80h] [ebp-3C0h] BYREF

  char My_key13[8]; // [esp+D88h] [ebp-3B8h] BYREF

  char My_key12[8]; // [esp+D90h] [ebp-3B0h] BYREF

  char My_key11[8]; // [esp+D98h] [ebp-3A8h] BYREF

  char My_key10[8]; // [esp+DA0h] [ebp-3A0h] BYREF

  char My_key9[8]; // [esp+DA8h] [ebp-398h] BYREF

  char My_key8[8]; // [esp+DB0h] [ebp-390h] BYREF

  char My_key7[8]; // [esp+DB8h] [ebp-388h] BYREF

  char My_key6[8]; // [esp+DC0h] [ebp-380h] BYREF

  char My_key5[8]; // [esp+DC8h] [ebp-378h] BYREF

  char My_key4[8]; // [esp+DD0h] [ebp-370h] BYREF

  char My_key3[8]; // [esp+DD8h] [ebp-368h] BYREF

  char My_key2[8]; // [esp+DE0h] [ebp-360h] BYREF

  char My_key1[8]; // [esp+DE8h] [ebp-358h] BYREF

  char RSHashResult34[9]; // [esp+DF0h] [ebp-350h] BYREF

  char RSHashResult30[9]; // [esp+DFCh] [ebp-344h] BYREF

  char RSHashResult28[9]; // [esp+E08h] [ebp-338h] BYREF

  char RSHashResult24[9]; // [esp+E14h] [ebp-32Ch] BYREF

  char RSHashResult23[9]; // [esp+E20h] [ebp-320h] BYREF

  char RSHashResult22[9]; // [esp+E2Ch] [ebp-314h] BYREF

  char RSHashResult18[9]; // [esp+E38h] [ebp-308h] BYREF

  char RSHashResult17[9]; // [esp+E44h] [ebp-2FCh] BYREF

  char RSHashResult16[9]; // [esp+E50h] [ebp-2F0h] BYREF

  char RSHashResult12[9]; // [esp+E5Ch] [ebp-2E4h] BYREF

  char RSHashResult11[9]; // [esp+E68h] [ebp-2D8h] BYREF

  char RSHashResult10[9]; // [esp+E74h] [ebp-2CCh] BYREF

  char RSHashResult6[9]; // [esp+E80h] [ebp-2C0h] BYREF

  char RSHashResult5[9]; // [esp+E8Ch] [ebp-2B4h] BYREF

  char RSHashResult4[9]; // [esp+E98h] [ebp-2A8h] BYREF

  char RSHashResult29[9]; // [esp+EA4h] [ebp-29Ch] BYREF

  char RSHashResult48[9]; // [esp+EB0h] [ebp-290h] BYREF

  char RSHashResult47[9]; // [esp+EBCh] [ebp-284h] BYREF

  char RSHashResult46[9]; // [esp+EC8h] [ebp-278h] BYREF

  char RSHashResult42[9]; // [esp+ED4h] [ebp-26Ch] BYREF

  char RSHashResult41[9]; // [esp+EE0h] [ebp-260h] BYREF

  char RSHashResult40[9]; // [esp+EECh] [ebp-254h] BYREF

  char RSHashResult36[9]; // [esp+EF8h] [ebp-248h] BYREF

  char RSHashResult35[9]; // [esp+F04h] [ebp-23Ch] BYREF

  HANDLE (__stdcall *CreateThread)(LPSECURITY_ATTRIBUTES, SIZE_T, LPTHREAD_START_ROUTINE, LPVOID, DWORD, LPDWORD); // [esp+F10h] [ebp-230h]

  char *szInput_hexdecoded; // [esp+F14h] [ebp-22Ch]

  int nInput; // [esp+F18h] [ebp-228h]

  char RSHashResult15[9]; // [esp+F1Ch] [ebp-224h] BYREF

  char RSHashResult27[9]; // [esp+F28h] [ebp-218h] BYREF

  char RSHashResult26[9]; // [esp+F34h] [ebp-20Ch] BYREF

  char RSHashResult25[9]; // [esp+F40h] [ebp-200h] BYREF

  char RSHashResult21[9]; // [esp+F4Ch] [ebp-1F4h] BYREF

  char RSHashResult20[9]; // [esp+F58h] [ebp-1E8h] BYREF

  char RSHashResult19[9]; // [esp+F64h] [ebp-1DCh] BYREF

  char RSHashResult2[9]; // [esp+F70h] [ebp-1D0h] BYREF

  char RSHashResult14[9]; // [esp+F7Ch] [ebp-1C4h] BYREF

  char RSHashResult13[9]; // [esp+F88h] [ebp-1B8h] BYREF

  char RSHashResult9[9]; // [esp+F94h] [ebp-1ACh] BYREF

  char RSHashResult8[9]; // [esp+FA0h] [ebp-1A0h] BYREF

  char RSHashResult7[9]; // [esp+FACh] [ebp-194h] BYREF

  char RSHashResult3[9]; // [esp+FB8h] [ebp-188h] BYREF

  char RSHashResult1[9]; // [esp+FC4h] [ebp-17Ch] BYREF

  char RSHashResult32[9]; // [esp+FD0h] [ebp-170h] BYREF

  char RSHashResult33[9]; // [esp+FDCh] [ebp-164h] BYREF

  char RSHashResult37[9]; // [esp+FE8h] [ebp-158h] BYREF

  char RSHashResult38[9]; // [esp+FF4h] [ebp-14Ch] BYREF

  char RSHashResult39[9]; // [esp+1000h] [ebp-140h] BYREF

  char RSHashResult31[9]; // [esp+100Ch] [ebp-134h] BYREF

  char RSHashResult43[9]; // [esp+1018h] [ebp-128h] BYREF

  char RSHashResult44[9]; // [esp+1024h] [ebp-11Ch] BYREF

  char RSHashResult45[9]; // [esp+1030h] [ebp-110h] BYREF

  char szHash2Hash_[12]; // [esp+103Ch] [ebp-104h] BYREF

  char szDecCurrent_[12]; // [esp+1048h] [ebp-F8h] BYREF

  void *pSerial_Rest21; // [esp+1054h] [ebp-ECh]

  HMODULE hModule; // [esp+1058h] [ebp-E8h]

  void *pSerial_Rest2; // [esp+105Ch] [ebp-E4h]

  void *pSerial_Rest1; // [esp+1060h] [ebp-E0h]

  void *pSerial_Rest3; // [esp+1064h] [ebp-DCh]

  void *pSerial_Rest4; // [esp+1068h] [ebp-D8h]

  void *pSerial_Rest5; // [esp+106Ch] [ebp-D4h]

  void *pSerial_Rest6; // [esp+1070h] [ebp-D0h]

  void *pSerial_Rest7; // [esp+1074h] [ebp-CCh]

  void *pSerial_Rest8; // [esp+1078h] [ebp-C8h]

  void *pSerial_Rest9; // [esp+107Ch] [ebp-C4h]

  void *pSerial_Rest10; // [esp+1080h] [ebp-C0h]

  void *pSerial_Rest11; // [esp+1084h] [ebp-BCh]

  void *pSerial_Rest12; // [esp+1088h] [ebp-B8h]

  void *pSerial_Rest13; // [esp+108Ch] [ebp-B4h]

  void *pSerial_Rest14; // [esp+1090h] [ebp-B0h]

  void *pSerial_Rest15; // [esp+1094h] [ebp-ACh]

  void *pSerial_Rest16; // [esp+1098h] [ebp-A8h]

  void *pSerial_Rest17; // [esp+109Ch] [ebp-A4h]

  void *pSerial_Rest18; // [esp+10A0h] [ebp-A0h]

  void *pSerial_Rest19; // [esp+10A4h] [ebp-9Ch]

  void *pSerial_Rest20; // [esp+10A8h] [ebp-98h]

  char szHash2Hash[9]; // [esp+10ACh] [ebp-94h] BYREF

  char Format[12]; // [esp+10B8h] [ebp-88h] BYREF

  char v186[4]; // [esp+10C4h] [ebp-7Ch] BYREF

  char v187[10]; // [esp+10C8h] [ebp-78h] BYREF

  char v188[4]; // [esp+10D2h] [ebp-6Eh] BYREF

  int m; // [esp+10D8h] [ebp-68h]

  int i; // [esp+10DCh] [ebp-64h]

  size_t k; // [esp+10E0h] [ebp-60h]

  int j; // [esp+10E4h] [ebp-5Ch]

  char szDecCurrent[17]; // [esp+10E8h] [ebp-58h] BYREF

  char szSerialNum_Real[17]; // [esp+10FCh] [ebp-44h] BYREF

  char szDecResult[17]; // [esp+1110h] [ebp-30h] BYREF

  char szCurrentSer[17]; // [esp+1124h] [ebp-1Ch] BYREF

  char White_message_8[8]; // [esp+1138h] [ebp-8h] BYREF
 
  memset(szKeySerial, 0, sizeof(szKeySerial));

  memset(szAllHash, 0, sizeof(szAllHash));

  qmemcpy(My_key1, "qrstuvwx", sizeof(My_key1));

  memset(White_message, 0, sizeof(White_message));

  memset(White_message_8, 0, sizeof(White_message_8));

  memset(Black_message1, 0, sizeof(Black_message1));

  memset(RSHashResult1, 0, sizeof(RSHashResult1));

  Format[0] = 0xC7;

  Format[1] = 0xEB;

  Format[2] = 0xCA;

  Format[3] = 0xE4;

  Format[4] = 0xC8;

  Format[5] = 0xEB;

  Format[6] = 0xD3;

  Format[7] = 0xC3;

  Format[8] = 0xBB;

  Format[9] = 0xA7;

  Format[10] = 0xC3;

  Format[11] = 0xFB;

  strcpy(v186, ":\n");

  printf(Format);    // 请输入用户名:

  gets_s(White_message, 50u);

  v3 = strlen(White_message);

  nInput = RSHash(White_message, v3);

  itoa(nInput, White_message_8, 16);

  Encode_1(My_key1, White_message_8, Black_message1, RSHashResult1);

  memcpy(szKeySerial, Black_message1, 8u);

  memcpy(szAllHash, RSHashResult1, 8u);

  qmemcpy(My_key2, "abcdefgh", sizeof(My_key2));

  memset(Black_message2, 0, sizeof(Black_message2));

  memset(RSHashResult2, 0, sizeof(RSHashResult2));

  Encode_2(My_key2, White_message_8, Black_message2, RSHashResult2);

  memcpy(szKeySerial[1], Black_message2, 8u);

  memcpy(szAllHash[1], RSHashResult2, sizeof(char[8]));

  qmemcpy(My_key3, "ijklmnop", sizeof(My_key3));

  memset(Black_message3, 0, sizeof(Black_message3));

  memset(RSHashResult3, 0, sizeof(RSHashResult3));

  Encode_2(My_key3, White_message_8, Black_message3, RSHashResult3);

  memcpy(szKeySerial[2], Black_message3, 8u);

  memcpy(szAllHash[2], RSHashResult3, sizeof(char[8]));

  qmemcpy(My_key4, "qrstuvwx", sizeof(My_key4));

  memset(Black_message4, 0, sizeof(Black_message4));

  memset(RSHashResult4, 0, sizeof(RSHashResult4));

  Encode_4(My_key4, White_message_8, Black_message4, RSHashResult4);

  qmemcpy(My_key5, "abcdefgh", sizeof(My_key5));

  memset(Black_message5, 0, sizeof(Black_message5));

  memset(RSHashResult5, 0, sizeof(RSHashResult5));

  Encode_5(My_key5, White_message_8, Black_message5, RSHashResult5);

  qmemcpy(My_key6, "ijklmnop", sizeof(My_key6));

  memset(Black_message6, 0, sizeof(Black_message6));

  memset(RSHashResult6, 0, sizeof(RSHashResult6));

  Encode_6(My_key6, White_message_8, Black_message6, RSHashResult6);

  qmemcpy(My_key7, "qrstuvwx", sizeof(My_key7));

  memset(Black_message7, 0, sizeof(Black_message7));

  memset(RSHashResult7, 0, sizeof(RSHashResult7));

  Encode_7(My_key7, White_message_8, Black_message7, RSHashResult7);

  memcpy(szKeySerial[3], Black_message7, 8u);

  memcpy(szAllHash[3], RSHashResult7, sizeof(char[8]));

  qmemcpy(My_key8, "abcdefgh", sizeof(My_key8));

  memset(Black_message8, 0, sizeof(Black_message8));

  memset(RSHashResult8, 0, sizeof(RSHashResult8));

  Encode_8(My_key8, White_message_8, Black_message8, RSHashResult8);

  memcpy(szKeySerial[4], Black_message8, 8u);

  memcpy(szAllHash[4], RSHashResult8, sizeof(char[8]));

  qmemcpy(My_key9, "ijklmnop", sizeof(My_key9));

  memset(Black_message9, 0, sizeof(Black_message9));

  memset(RSHashResult9, 0, sizeof(RSHashResult9));

  Encode_9(My_key9, White_message_8, Black_message9, RSHashResult9);

  memcpy(szKeySerial[4], Black_message9, 8u);

  memcpy(szAllHash[4], RSHashResult9, sizeof(char[8]));

  qmemcpy(My_key10, "qrstuvwx", sizeof(My_key10));

  memset(Black_message10, 0, sizeof(Black_message10));

  memset(RSHashResult10, 0, sizeof(RSHashResult10));

  Encode_10(My_key10, White_message_8, Black_message10, RSHashResult10);

  qmemcpy(My_key11, "abcdefgh", sizeof(My_key11));

  memset(Black_message11, 0, sizeof(Black_message11));

  memset(RSHashResult11, 0, sizeof(RSHashResult11));

  Encode_11(My_key11, White_message_8, Black_message11, RSHashResult11);

  qmemcpy(My_key12, "ijklmnop", sizeof(My_key12));

  memset(Black_message12, 0, sizeof(Black_message12));

  memset(RSHashResult12, 0, sizeof(RSHashResult12));

  Encode_12(My_key12, White_message_8, Black_message12, RSHashResult12);

  qmemcpy(My_key13, "qrstuvwx", sizeof(My_key13));

  memset(Black_message13, 0, sizeof(Black_message13));

  memset(RSHashResult13, 0, sizeof(RSHashResult13));

  Encode_13(My_key13, White_message_8, Black_message13, RSHashResult13);

  memcpy(szKeySerial[6], Black_message13, 8u);

  memcpy(szAllHash[6], RSHashResult13, sizeof(char[8]));

  qmemcpy(My_key14, "abcdefgh", sizeof(My_key14));

  memset(Black_message14, 0, sizeof(Black_message14));

  memset(RSHashResult14, 0, sizeof(RSHashResult14));

  Encode_14(My_key14, White_message_8, Black_message14, RSHashResult14);

  memcpy(szKeySerial[7], Black_message14, 8u);

  memcpy(szAllHash[7], RSHashResult14, sizeof(char[8]));

  qmemcpy(My_key15, "ijklmnop", sizeof(My_key15));

  memset(Black_message15, 0, sizeof(Black_message15));

  memset(RSHashResult15, 0, sizeof(RSHashResult15));

  Encode_15(My_key15, White_message_8, Black_message15, RSHashResult15);

  memcpy(szKeySerial[8], Black_message15, 8u);

  memcpy(szAllHash[8], RSHashResult15, sizeof(char[8]));

  qmemcpy(My_key16, "qrstuvwx", sizeof(My_key16));

  memset(Black_message16, 0, sizeof(Black_message16));

  memset(RSHashResult16, 0, sizeof(RSHashResult16));

  Encode_16(My_key16, White_message_8, Black_message16, RSHashResult16);

  qmemcpy(My_key17, "abcdefgh", sizeof(My_key17));

  memset(Black_message17, 0, sizeof(Black_message17));

  memset(RSHashResult17, 0, sizeof(RSHashResult17));

  Encode_17(My_key17, White_message_8, Black_message17, RSHashResult17);

  qmemcpy(My_key18, "ijklmnop", sizeof(My_key18));

  memset(Black_message18, 0, sizeof(Black_message18));

  memset(RSHashResult18, 0, sizeof(RSHashResult18));

  Encode_18(My_key18, White_message_8, Black_message18, RSHashResult18);

  qmemcpy(My_key19, "qrstuvwx", sizeof(My_key19));

  memset(Black_message19, 0, sizeof(Black_message19));

  memset(RSHashResult19, 0, sizeof(RSHashResult19));

  Encode_19(My_key19, White_message_8, Black_message19, RSHashResult19);

  memcpy(szKeySerial[9], Black_message19, 8u);

  memcpy(szAllHash[9], RSHashResult19, sizeof(char[8]));

  qmemcpy(My_key20, "abcdefgh", sizeof(My_key20));

  memset(Black_message20, 0, sizeof(Black_message20));

  memset(RSHashResult20, 0, sizeof(RSHashResult20));

  Encode_20(My_key20, White_message_8, Black_message20, RSHashResult20);

  memcpy(szKeySerial[10], Black_message20, 8u);

  memcpy(szAllHash[10], RSHashResult20, sizeof(char[8]));

  qmemcpy(My_key21, "ijklmnop", sizeof(My_key21));

  memset(Black_message21, 0, sizeof(Black_message21));

  memset(RSHashResult21, 0, sizeof(RSHashResult21));

  Encode_21(My_key21, White_message_8, Black_message21, RSHashResult21);

  memcpy(szKeySerial[11], Black_message21, 8u);

  memcpy(szAllHash[11], RSHashResult21, sizeof(char[8]));

  qmemcpy(My_key22, "qrstuvwx", sizeof(My_key22));

  memset(Black_message22, 0, sizeof(Black_message22));

  memset(RSHashResult22, 0, sizeof(RSHashResult22));

  Encode_22(My_key22, White_message_8, Black_message22, RSHashResult22);

  qmemcpy(My_key23, "abcdefgh", sizeof(My_key23));

  memset(Black_message23, 0, sizeof(Black_message23));

  memset(RSHashResult23, 0, sizeof(RSHashResult23));

  Encode_23(My_key23, White_message_8, Black_message23, RSHashResult23);

  qmemcpy(My_key24, "ijklmnop", sizeof(My_key24));

  memset(Black_message24, 0, sizeof(Black_message24));

  memset(RSHashResult24, 0, sizeof(RSHashResult24));

  Encode_24(My_key24, White_message_8, Black_message24, RSHashResult24);

  qmemcpy(My_key25, "qrstuvwx", sizeof(My_key25));

  memset(Black_message25, 0, sizeof(Black_message25));

  memset(RSHashResult25, 0, sizeof(RSHashResult25));

  Encode_25(My_key25, White_message_8, Black_message25, RSHashResult25);

  memcpy(szKeySerial[12], Black_message25, 8u);

  memcpy(szAllHash[12], RSHashResult25, sizeof(char[8]));

  qmemcpy(My_key26, "abcdefgh", sizeof(My_key26));

  memset(Black_message26, 0, sizeof(Black_message26));

  memset(RSHashResult26, 0, sizeof(RSHashResult26));

  Encode_26(My_key26, White_message_8, Black_message26, RSHashResult26);

  memcpy(szKeySerial[13], Black_message26, 8u);

  memcpy(szAllHash[13], RSHashResult26, sizeof(char[8]));

  qmemcpy(My_key27, "ijklmnop", sizeof(My_key27));

  memset(Black_message27, 0, sizeof(Black_message27));

  memset(RSHashResult27, 0, sizeof(RSHashResult27));

  Encode_27(My_key27, White_message_8, Black_message27, RSHashResult27);

  memcpy(szKeySerial[14], Black_message27, 8u);

  memcpy(szAllHash[14], RSHashResult27, sizeof(char[8]));

  qmemcpy(My_key28, "qrstuvwx", sizeof(My_key28));

  memset(Black_message28, 0, sizeof(Black_message28));

  memset(RSHashResult28, 0, sizeof(RSHashResult28));

  Encode_28(My_key28, White_message_8, Black_message28, RSHashResult28);

  qmemcpy(My_key29, "abcdefgh", sizeof(My_key29));

  memset(Black_message29, 0, sizeof(Black_message29));

  memset(RSHashResult29, 0, sizeof(RSHashResult29));

  Encode_29(My_key29, White_message_8, Black_message29, RSHashResult29);

  qmemcpy(My_key30, "ijklmnop", sizeof(My_key30));

  memset(Black_message30, 0, sizeof(Black_message30));

  memset(RSHashResult30, 0, sizeof(RSHashResult30));

  Encode_30(My_key30, White_message_8, Black_message30, RSHashResult30);

  qmemcpy(My_key31, "qrstuvwx", sizeof(My_key31));

  memset(Black_message31, 0, sizeof(Black_message31));

  memset(RSHashResult31, 0, sizeof(RSHashResult31));

  Encode_31(My_key31, White_message_8, Black_message31, RSHashResult31);

  memcpy(szKeySerial[15], Black_message31, 8u);

  memcpy(szAllHash[15], RSHashResult31, sizeof(char[8]));

  qmemcpy(My_key32, "abcdefgh", sizeof(My_key32));

  memset(Black_message32, 0, sizeof(Black_message32));

  memset(RSHashResult32, 0, sizeof(RSHashResult32));

  Encode_32(My_key32, White_message_8, Black_message32, RSHashResult32);

  memcpy(szKeySerial[16], Black_message32, 8u);

  memcpy(szAllHash[16], RSHashResult32, sizeof(char[8]));

  qmemcpy(My_key33, "ijklmnop", sizeof(My_key33));

  memset(Black_message33, 0, sizeof(Black_message33));

  memset(RSHashResult33, 0, sizeof(RSHashResult33));

  Encode_33(My_key33, White_message_8, Black_message33, RSHashResult33);

  memcpy(szKeySerial[17], Black_message33, 8u);

  memcpy(szAllHash[17], RSHashResult33, sizeof(char[8]));

  qmemcpy(My_key34, "qrstuvwx", sizeof(My_key34));

  memset(Black_message34, 0, sizeof(Black_message34));

  memset(RSHashResult34, 0, sizeof(RSHashResult34));

  Encode_34(My_key34, White_message_8, Black_message34, RSHashResult34);

  qmemcpy(My_key35, "abcdefgh", sizeof(My_key35));

  memset(Black_message35, 0, sizeof(Black_message35));

  memset(RSHashResult35, 0, sizeof(RSHashResult35));

  Encode_35(My_key35, White_message_8, Black_message35, RSHashResult35);

  qmemcpy(My_key36, "ijklmnop", sizeof(My_key36));

  memset(Black_message36, 0, sizeof(Black_message36));

  memset(RSHashResult36, 0, sizeof(RSHashResult36));

  Encode_36(My_key36, White_message_8, Black_message36, RSHashResult36);

  qmemcpy(My_key37, "qrstuvwx", sizeof(My_key37));

  memset(Black_message37, 0, sizeof(Black_message37));

  memset(RSHashResult37, 0, sizeof(RSHashResult37));

  Encode_37(My_key37, White_message_8, Black_message37, RSHashResult37);

  memcpy(szKeySerial[18], Black_message37, 8u);

  memcpy(szAllHash[18], RSHashResult37, sizeof(char[8]));

  qmemcpy(My_key38, "abcdefgh", sizeof(My_key38));

  memset(Black_message38, 0, sizeof(Black_message38));

  memset(RSHashResult38, 0, sizeof(RSHashResult38));

  Encode_38(My_key38, White_message_8, Black_message38, RSHashResult38);

  memcpy(szKeySerial[19], Black_message38, 8u);

  memcpy(szAllHash[19], RSHashResult38, sizeof(char[8]));

  qmemcpy(My_key39, "ijklmnop", sizeof(My_key39));

  memset(Black_message39, 0, sizeof(Black_message39));

  memset(RSHashResult39, 0, sizeof(RSHashResult39));

  Encode_39(My_key39, White_message_8, Black_message39, RSHashResult39);

  memcpy(szKeySerial[20], Black_message39, 8u);

  memcpy(szAllHash[20], RSHashResult39, sizeof(char[8]));

  qmemcpy(My_key40, "qrstuvwx", sizeof(My_key40));

  memset(Black_message40, 0, sizeof(Black_message40));

  memset(RSHashResult40, 0, sizeof(RSHashResult40));

  Encode_40(My_key40, White_message_8, Black_message40, RSHashResult40);

  qmemcpy(My_key41, "abcdefgh", sizeof(My_key41));

  memset(Black_message41, 0, sizeof(Black_message41));

  memset(RSHashResult41, 0, sizeof(RSHashResult41));

  Encode_41(My_key41, White_message_8, Black_message41, RSHashResult41);

  qmemcpy(My_key42, "ijklmnop", sizeof(My_key42));

  memset(Black_message42, 0, sizeof(Black_message42));

  memset(RSHashResult42, 0, sizeof(RSHashResult42));

  Encode_42(My_key42, White_message_8, Black_message42, RSHashResult42);

  qmemcpy(My_key43, "qrstuvwx", sizeof(My_key43));

  memset(Black_message43, 0, sizeof(Black_message43));

  memset(RSHashResult43, 0, sizeof(RSHashResult43));

  Encode_43(My_key43, White_message_8, Black_message43, RSHashResult43);

  memcpy(szKeySerial[21], Black_message43, 8u);

  memcpy(szAllHash[21], RSHashResult43, sizeof(char[8]));

  qmemcpy(My_key44, "abcdefgh", sizeof(My_key44));

  memset(Black_message44, 0, sizeof(Black_message44));

  memset(RSHashResult44, 0, sizeof(RSHashResult44));

  Encode_44(My_key44, White_message_8, Black_message44, RSHashResult44);

  memcpy(szKeySerial[22], Black_message44, 8u);

  memcpy(szAllHash[22], RSHashResult44, sizeof(char[8]));

  qmemcpy(My_key45, "ijklmnop", sizeof(My_key45));

  memset(Black_message45, 0, sizeof(Black_message45));

  memset(RSHashResult45, 0, sizeof(RSHashResult45));

  Encode_45(My_key45, White_message_8, Black_message45, RSHashResult45);

  memcpy(szKeySerial[23], Black_message45, 8u);

  memcpy(szAllHash[23], RSHashResult45, sizeof(char[8]));

  qmemcpy(My_key46, "qrstuvwx", sizeof(My_key46));

  memset(Black_message46, 0, sizeof(Black_message46));

  memset(RSHashResult46, 0, sizeof(RSHashResult46));

  Encode_46(My_key46, White_message_8, Black_message46, RSHashResult46);

  qmemcpy(My_key47, "abcdefgh", sizeof(My_key47));

  memset(Black_message47, 0, sizeof(Black_message47));

  memset(RSHashResult47, 0, sizeof(RSHashResult47));

  Encode_47(My_key47, White_message_8, Black_message47, RSHashResult47);

  qmemcpy(My_key48, "ijklmnop", sizeof(My_key48));

  memset(Black_message48, 0, sizeof(Black_message48));

  memset(RSHashResult48, 0, sizeof(RSHashResult48));

  Encode_48(My_key48, White_message_8, Black_message48, RSHashResult48);

  memset(szHash2Hash, 0, sizeof(szHash2Hash));

  memset(szHash2Hash_, 0, 9);

  v4 = RSHash(szAllHash[0], 192);

  sprintf_s(szHash2Hash, 9u, "%08x", v4);

  memcpy(szHash2Hash_, szHash2Hash, 9u);

  memset(szKeySerialConcat, 0, sizeof(szKeySerialConcat));

  memset(szKeySerialConcat_, 0, 500u);

  for ( i = 0; i < 50; ++i )

    strcat_s(szKeySerialConcat, 0x400u, szKeySerial[i]);

  memmove(szKeySerialConcat_, szKeySerialConcat, 500u);

  sub_40F9AF(szHash2Hash, szKeySerialConcat_[0], 0);// sub_40F9AF: first arg is key, second arg is value

  for ( j = 0; j < 50; ++j )

    memmove(szKeySerial[j], szKeySerialConcat_[j], 8u);

  sub_40F9AF(szKeySerialConcat_[0], szHash2Hash, 0);

  memset(szCurrentSer, 0, sizeof(szCurrentSer));

  memset(szSerialNum_Real, 0, sizeof(szSerialNum_Real));

  Encode_For_Serial(szKeySerial[0], szHash2Hash, szCurrentSer);

  pSerial_Rest1 = malloc(8u);

  memcpy(pSerial_Rest1, &szCurrentSer[8], 8u);

  Encode_For_Serial(szKeySerial[1], szCurrentSer, szSerialNum_Real);

  pSerial_Rest2 = malloc(8u);

  memcpy(pSerial_Rest2, &szSerialNum_Real[8], 8u);

  Encode_For_Serial(szKeySerial[2], szSerialNum_Real, szCurrentSer);

  pSerial_Rest3 = malloc(8u);

  memcpy(pSerial_Rest3, &szCurrentSer[8], 8u);

  Encode_For_Serial(szKeySerial[3], szCurrentSer, szSerialNum_Real);

  pSerial_Rest4 = malloc(8u);

  memcpy(pSerial_Rest4, &szSerialNum_Real[8], 8u);

  Encode_For_Serial(szKeySerial[4], szSerialNum_Real, szCurrentSer);

  pSerial_Rest5 = malloc(8u);

  memcpy(pSerial_Rest5, &szCurrentSer[8], 8u);

  Encode_For_Serial(szKeySerial[5], szCurrentSer, szSerialNum_Real);

  pSerial_Rest6 = malloc(8u);

  memcpy(pSerial_Rest6, &szSerialNum_Real[8], 8u);

  Encode_For_Serial(szKeySerial[6], szSerialNum_Real, szCurrentSer);

  pSerial_Rest7 = malloc(8u);

  memcpy(pSerial_Rest7, &szCurrentSer[8], 8u);

  Encode_For_Serial(szKeySerial[7], szCurrentSer, szSerialNum_Real);

  pSerial_Rest8 = malloc(8u);

  memcpy(pSerial_Rest8, &szSerialNum_Real[8], 8u);

  Encode_For_Serial(szKeySerial[8], szSerialNum_Real, szCurrentSer);

  pSerial_Rest9 = malloc(8u);

  memcpy(pSerial_Rest9, &szCurrentSer[8], 8u);

  Encode_For_Serial(szKeySerial[9], szCurrentSer, szSerialNum_Real);

  pSerial_Rest10 = malloc(8u);

  memcpy(pSerial_Rest10, &szSerialNum_Real[8], 8u);

  Encode_For_Serial(szKeySerial[10], szSerialNum_Real, szCurrentSer);

  pSerial_Rest11 = malloc(8u);

  memcpy(pSerial_Rest11, &szCurrentSer[8], 8u);

  Encode_For_Serial(szKeySerial[11], szCurrentSer, szSerialNum_Real);

  pSerial_Rest12 = malloc(8u);

  memcpy(pSerial_Rest12, &szSerialNum_Real[8], 8u);

  Encode_For_Serial(szKeySerial[12], szSerialNum_Real, szCurrentSer);

  pSerial_Rest13 = malloc(8u);

  memcpy(pSerial_Rest13, &szCurrentSer[8], 8u);

  Encode_For_Serial(szKeySerial[13], szCurrentSer, szSerialNum_Real);

  pSerial_Rest14 = malloc(8u);

  memcpy(pSerial_Rest14, &szSerialNum_Real[8], 8u);

  Encode_For_Serial(szKeySerial[14], szSerialNum_Real, szCurrentSer);

  pSerial_Rest15 = malloc(8u);

  memcpy(pSerial_Rest15, &szCurrentSer[8], 8u);

  Encode_For_Serial(szKeySerial[15], szCurrentSer, szSerialNum_Real);

  pSerial_Rest16 = malloc(8u);

  memcpy(pSerial_Rest16, &szSerialNum_Real[8], 8u);

  Encode_For_Serial(szKeySerial[16], szSerialNum_Real, szCurrentSer);

  pSerial_Rest17 = malloc(8u);

  memcpy(pSerial_Rest17, &szCurrentSer[8], 8u);

  Encode_For_Serial(szKeySerial[17], szCurrentSer, szSerialNum_Real);

  pSerial_Rest18 = malloc(8u);

  memcpy(pSerial_Rest18, &szSerialNum_Real[8], 8u);

  Encode_For_Serial(szKeySerial[18], szSerialNum_Real, szCurrentSer);

  pSerial_Rest19 = malloc(8u);

  memcpy(pSerial_Rest19, &szCurrentSer[8], 8u);

  Encode_For_Serial(szKeySerial[19], szCurrentSer, szSerialNum_Real);

  pSerial_Rest20 = malloc(8u);

  memcpy(pSerial_Rest20, &szSerialNum_Real[8], 8u);

  Encode_For_Serial(szKeySerial[20], szSerialNum_Real, szCurrentSer);

  pSerial_Rest21 = malloc(8u);

  memcpy(pSerial_Rest21, &szCurrentSer[8], 8u);

  Encode_For_Serial(szKeySerial[21], szCurrentSer, szSerialNum_Real);

  hModule = LoadLibraryA(LibFileName);

  if ( hModule )

  {

    CreateThread = (HANDLE (__stdcall *)(LPSECURITY_ATTRIBUTES, SIZE_T, LPTHREAD_START_ROUTINE, LPVOID, DWORD, LPDWORD))GetProcAddress(hModule, ProcName);

    ((void (__cdecl *)(HANDLE (__stdcall *)(LPSECURITY_ATTRIBUTES, SIZE_T, LPTHREAD_START_ROUTINE, LPVOID, DWORD, LPDWORD)))loc_409DE1)(CreateThread);

  }

  memset(szInput, 0, sizeof(szInput));

  v187[0] = 0xCA;

  v187[1] = 0xE4;

  v187[2] = 0xC8;

  v187[3] = 0xEB;

  v187[4] = 0xD0;

  v187[5] = 0xF2;

  v187[6] = 0xC1;

  v187[7] = 0xD0;

  v187[8] = 0xBA;

  v187[9] = 0xC5;

  strcpy(v188, ":\n");

  printf(v187);    // 输入序列号:

  gets_s(szInput, 0x100u);

  if ( strlen(szInput) >= 0x21 )

    goto LABEL_20;

  for ( k = 0; k < strlen(szInput); ++k )

  {

    if ( szInput[k] >= 'a' && szInput[k] <= 'z' )

      goto LABEL_20;

  }

  szInput_hexdecoded = hexdecode(szInput, 32);

  memset(szInput_encrypted, 0, sizeof(szInput_encrypted));

  sub_403ACA(szInput_hexdecoded, szCurrentSer, szInput_encrypted);

  Encode_For_Serial(szKeySerial[21], szCurrentSer, szSerialNum_Real);

  memset(szDecResult, 0, sizeof(szDecResult));

  memset(szDecCurrent, 0, sizeof(szDecCurrent));

  Decode_For_Serial(szKeySerial[21], szDecResult, szInput_encrypted);

  memcpy(&szDecResult[8], pSerial_Rest21, 8u);

  Decode_For_Serial(szKeySerial[20], szDecCurrent, szDecResult);

  memcpy(&szDecCurrent[8], pSerial_Rest20, 8u);

  Decode_For_Serial(szKeySerial[19], szDecResult, szDecCurrent);

  memcpy(&szDecResult[8], pSerial_Rest19, 8u);

  Decode_For_Serial(szKeySerial[18], szDecCurrent, szDecResult);

  memcpy(&szDecCurrent[8], pSerial_Rest18, 8u);

  Decode_For_Serial(szKeySerial[17], szDecResult, szDecCurrent);

  memcpy(&szDecResult[8], pSerial_Rest17, 8u);

  Decode_For_Serial(szKeySerial[16], szDecCurrent, szDecResult);

  memcpy(&szDecCurrent[8], pSerial_Rest16, 8u);

  Decode_For_Serial(szKeySerial[15], szDecResult, szDecCurrent);

  memcpy(&szDecResult[8], pSerial_Rest15, 8u);

  Decode_For_Serial(szKeySerial[14], szDecCurrent, szDecResult);

  memcpy(&szDecCurrent[8], pSerial_Rest14, 8u);

  Decode_For_Serial(szKeySerial[13], szDecResult, szDecCurrent);

  memcpy(&szDecResult[8], pSerial_Rest13, 8u);

  Decode_For_Serial(szKeySerial[12], szDecCurrent, szDecResult);

  memcpy(&szDecCurrent[8], pSerial_Rest12, 8u);

  Decode_For_Serial(szKeySerial[11], szDecResult, szDecCurrent);

  memcpy(&szDecResult[8], pSerial_Rest11, 8u);

  Decode_For_Serial(szKeySerial[10], szDecCurrent, szDecResult);

  memcpy(&szDecCurrent[8], pSerial_Rest10, 8u);

  Decode_For_Serial(szKeySerial[9], szDecResult, szDecCurrent);

  memcpy(&szDecResult[8], pSerial_Rest9, 8u);

  Decode_For_Serial(szKeySerial[8], szDecCurrent, szDecResult);

  memcpy(&szDecCurrent[8], pSerial_Rest8, 8u);

  Decode_For_Serial(szKeySerial[7], szDecResult, szDecCurrent);

  memcpy(&szDecResult[8], pSerial_Rest7, 8u);

  Decode_For_Serial(szKeySerial[6], szDecCurrent, szDecResult);

  memcpy(&szDecCurrent[8], pSerial_Rest6, 8u);

  Decode_For_Serial(szKeySerial[5], szDecResult, szDecCurrent);

  memcpy(&szDecResult[8], pSerial_Rest5, 8u);

  Decode_For_Serial(szKeySerial[4], szDecCurrent, szDecResult);

  memcpy(&szDecCurrent[8], pSerial_Rest4, 8u);

  Decode_For_Serial(szKeySerial[3], szDecResult, szDecCurrent);

  memcpy(&szDecResult[8], pSerial_Rest3, 8u);

  Decode_For_Serial(szKeySerial[2], szDecCurrent, szDecResult);

  memcpy(&szDecCurrent[8], pSerial_Rest2, 8u);

  Decode_For_Serial(szKeySerial[1], szDecResult, szDecCurrent);

  memcpy(&szDecResult[8], pSerial_Rest1, 8u);

  Decode_For_Serial(szKeySerial[0], szDecCurrent, szDecResult);

  szDecCurrent_[8] = 0;

  memcpy(szDecCurrent_, szDecCurrent, 8u);

  memset(szKeySerialConcat, 0, sizeof(szKeySerialConcat));

  for ( m = 0; m < 50; strcat_s(szKeySerialConcat, 0x400u, szKeySerial[m++]) )

    ;

  memmove(szKeySerialConcat_, szKeySerialConcat, 500u);

  sub_40F9AF(szKeySerialConcat_[0], szDecCurrent_, 1);

  if ( !strcmp(szHash2Hash_, szDecCurrent_) )

    MessageBoxA(0, Text, Caption, 0);

  else
LABEL_20:

    MessageBoxA(0, aFail_0, aFail, 0);

  return 0;
}
// bad sp value at call has been detected, the output may be wrong!

int __cdecl main(int argc, const char **argv, const char **envp)
{

  int v3; // eax

  int v4; // eax

  char szInput_encrypted[256]; // [esp+0h] [ebp-1140h] BYREF

  char szKeySerialConcat[500]; // [esp+100h] [ebp-1040h] BYREF

  _BYTE szKeySerialConcat_[50][8]; // [esp+2F4h] [ebp-E4Ch] BYREF

  char szInput[256]; // [esp+4E8h] [ebp-C58h] BYREF

  char szAllHash[50][8]; // [esp+5E8h] [ebp-B58h] BYREF

  char White_message[50]; // [esp+778h] [ebp-9C8h] BYREF

  char szKeySerial[50][9]; // [esp+7ACh] [ebp-994h] BYREF

  char Black_message10[16]; // [esp+970h] [ebp-7D0h] BYREF

  char Black_message6[16]; // [esp+980h] [ebp-7C0h] BYREF

  char Black_message5[16]; // [esp+990h] [ebp-7B0h] BYREF

  char Black_message4[16]; // [esp+9A0h] [ebp-7A0h] BYREF

  char Black_message48[16]; // [esp+9B0h] [ebp-790h] BYREF

  char Black_message47[16]; // [esp+9C0h] [ebp-780h] BYREF

  char Black_message46[16]; // [esp+9D0h] [ebp-770h] BYREF

  char Black_message42[16]; // [esp+9E0h] [ebp-760h] BYREF

  char Black_message41[16]; // [esp+9F0h] [ebp-750h] BYREF

  char Black_message40[16]; // [esp+A00h] [ebp-740h] BYREF

  char Black_message36[16]; // [esp+A10h] [ebp-730h] BYREF

  char Black_message35[16]; // [esp+A20h] [ebp-720h] BYREF

  char Black_message34[16]; // [esp+A30h] [ebp-710h] BYREF

  char Black_message30[16]; // [esp+A40h] [ebp-700h] BYREF

  char Black_message29[16]; // [esp+A50h] [ebp-6F0h] BYREF

  char Black_message28[16]; // [esp+A60h] [ebp-6E0h] BYREF

  char Black_message24[16]; // [esp+A70h] [ebp-6D0h] BYREF

  char Black_message23[16]; // [esp+A80h] [ebp-6C0h] BYREF

  char Black_message22[16]; // [esp+A90h] [ebp-6B0h] BYREF

  char Black_message18[16]; // [esp+AA0h] [ebp-6A0h] BYREF

  char Black_message17[16]; // [esp+AB0h] [ebp-690h] BYREF

  char Black_message16[16]; // [esp+AC0h] [ebp-680h] BYREF

  char Black_message12[16]; // [esp+AD0h] [ebp-670h] BYREF

  char Black_message11[16]; // [esp+AE0h] [ebp-660h] BYREF

  char My_key33[8]; // [esp+AF0h] [ebp-650h] BYREF

  char My_key34[8]; // [esp+AF8h] [ebp-648h] BYREF

  char My_key35[8]; // [esp+B00h] [ebp-640h] BYREF

  char My_key36[8]; // [esp+B08h] [ebp-638h] BYREF

  char Black_message45[16]; // [esp+B10h] [ebp-630h] BYREF

  char Black_message44[16]; // [esp+B20h] [ebp-620h] BYREF

  char Black_message43[16]; // [esp+B30h] [ebp-610h] BYREF

  char Black_message39[16]; // [esp+B40h] [ebp-600h] BYREF

  char Black_message38[16]; // [esp+B50h] [ebp-5F0h] BYREF

  char Black_message37[16]; // [esp+B60h] [ebp-5E0h] BYREF

  char Black_message33[16]; // [esp+B70h] [ebp-5D0h] BYREF

  char Black_message32[16]; // [esp+B80h] [ebp-5C0h] BYREF

  char Black_message31[16]; // [esp+B90h] [ebp-5B0h] BYREF

  char Black_message27[16]; // [esp+BA0h] [ebp-5A0h] BYREF

  char Black_message26[16]; // [esp+BB0h] [ebp-590h] BYREF

  char Black_message25[16]; // [esp+BC0h] [ebp-580h] BYREF

  char Black_message21[16]; // [esp+BD0h] [ebp-570h] BYREF

  char Black_message20[16]; // [esp+BE0h] [ebp-560h] BYREF

  char Black_message19[16]; // [esp+BF0h] [ebp-550h] BYREF

  char Black_message15[16]; // [esp+C00h] [ebp-540h] BYREF

  char Black_message14[16]; // [esp+C10h] [ebp-530h] BYREF

  char Black_message13[16]; // [esp+C20h] [ebp-520h] BYREF

  char Black_message9[16]; // [esp+C30h] [ebp-510h] BYREF

  char Black_message8[16]; // [esp+C40h] [ebp-500h] BYREF

  char Black_message7[16]; // [esp+C50h] [ebp-4F0h] BYREF

  char Black_message3[16]; // [esp+C60h] [ebp-4E0h] BYREF

  char Black_message2[16]; // [esp+C70h] [ebp-4D0h] BYREF

  char Black_message1[16]; // [esp+C80h] [ebp-4C0h] BYREF

  char My_key37[8]; // [esp+C90h] [ebp-4B0h] BYREF

  char My_key38[8]; // [esp+C98h] [ebp-4A8h] BYREF

  char My_key43[8]; // [esp+CA0h] [ebp-4A0h] BYREF

  char My_key45[8]; // [esp+CA8h] [ebp-498h] BYREF

  char My_key46[8]; // [esp+CB0h] [ebp-490h] BYREF

  char My_key47[8]; // [esp+CB8h] [ebp-488h] BYREF

  char My_key48[8]; // [esp+CC0h] [ebp-480h] BYREF

  char My_key39[8]; // [esp+CC8h] [ebp-478h] BYREF

  char My_key40[8]; // [esp+CD0h] [ebp-470h] BYREF

  char My_key41[8]; // [esp+CD8h] [ebp-468h] BYREF

  char My_key42[8]; // [esp+CE0h] [ebp-460h] BYREF

  char My_key44[8]; // [esp+CE8h] [ebp-458h] BYREF

  char My_key32[8]; // [esp+CF0h] [ebp-450h] BYREF

  char My_key31[8]; // [esp+CF8h] [ebp-448h] BYREF

  char My_key30[8]; // [esp+D00h] [ebp-440h] BYREF

  char My_key29[8]; // [esp+D08h] [ebp-438h] BYREF

  char My_key28[8]; // [esp+D10h] [ebp-430h] BYREF

  char My_key27[8]; // [esp+D18h] [ebp-428h] BYREF

  char My_key26[8]; // [esp+D20h] [ebp-420h] BYREF

  char My_key25[8]; // [esp+D28h] [ebp-418h] BYREF

  char My_key24[8]; // [esp+D30h] [ebp-410h] BYREF

  char My_key23[8]; // [esp+D38h] [ebp-408h] BYREF

  char My_key22[8]; // [esp+D40h] [ebp-400h] BYREF

  char My_key21[8]; // [esp+D48h] [ebp-3F8h] BYREF

  char My_key20[8]; // [esp+D50h] [ebp-3F0h] BYREF

  char My_key19[8]; // [esp+D58h] [ebp-3E8h] BYREF

  char My_key18[8]; // [esp+D60h] [ebp-3E0h] BYREF

  char My_key17[8]; // [esp+D68h] [ebp-3D8h] BYREF

  char My_key16[8]; // [esp+D70h] [ebp-3D0h] BYREF

  char My_key15[8]; // [esp+D78h] [ebp-3C8h] BYREF

  char My_key14[8]; // [esp+D80h] [ebp-3C0h] BYREF

  char My_key13[8]; // [esp+D88h] [ebp-3B8h] BYREF

  char My_key12[8]; // [esp+D90h] [ebp-3B0h] BYREF

  char My_key11[8]; // [esp+D98h] [ebp-3A8h] BYREF

  char My_key10[8]; // [esp+DA0h] [ebp-3A0h] BYREF

  char My_key9[8]; // [esp+DA8h] [ebp-398h] BYREF

  char My_key8[8]; // [esp+DB0h] [ebp-390h] BYREF

  char My_key7[8]; // [esp+DB8h] [ebp-388h] BYREF

  char My_key6[8]; // [esp+DC0h] [ebp-380h] BYREF

  char My_key5[8]; // [esp+DC8h] [ebp-378h] BYREF

  char My_key4[8]; // [esp+DD0h] [ebp-370h] BYREF

  char My_key3[8]; // [esp+DD8h] [ebp-368h] BYREF

  char My_key2[8]; // [esp+DE0h] [ebp-360h] BYREF

  char My_key1[8]; // [esp+DE8h] [ebp-358h] BYREF

  char RSHashResult34[9]; // [esp+DF0h] [ebp-350h] BYREF

  char RSHashResult30[9]; // [esp+DFCh] [ebp-344h] BYREF

  char RSHashResult28[9]; // [esp+E08h] [ebp-338h] BYREF

  char RSHashResult24[9]; // [esp+E14h] [ebp-32Ch] BYREF

  char RSHashResult23[9]; // [esp+E20h] [ebp-320h] BYREF

  char RSHashResult22[9]; // [esp+E2Ch] [ebp-314h] BYREF

  char RSHashResult18[9]; // [esp+E38h] [ebp-308h] BYREF

  char RSHashResult17[9]; // [esp+E44h] [ebp-2FCh] BYREF

  char RSHashResult16[9]; // [esp+E50h] [ebp-2F0h] BYREF

  char RSHashResult12[9]; // [esp+E5Ch] [ebp-2E4h] BYREF

  char RSHashResult11[9]; // [esp+E68h] [ebp-2D8h] BYREF

  char RSHashResult10[9]; // [esp+E74h] [ebp-2CCh] BYREF

  char RSHashResult6[9]; // [esp+E80h] [ebp-2C0h] BYREF

  char RSHashResult5[9]; // [esp+E8Ch] [ebp-2B4h] BYREF

  char RSHashResult4[9]; // [esp+E98h] [ebp-2A8h] BYREF

  char RSHashResult29[9]; // [esp+EA4h] [ebp-29Ch] BYREF

  char RSHashResult48[9]; // [esp+EB0h] [ebp-290h] BYREF

  char RSHashResult47[9]; // [esp+EBCh] [ebp-284h] BYREF

  char RSHashResult46[9]; // [esp+EC8h] [ebp-278h] BYREF

  char RSHashResult42[9]; // [esp+ED4h] [ebp-26Ch] BYREF

  char RSHashResult41[9]; // [esp+EE0h] [ebp-260h] BYREF

  char RSHashResult40[9]; // [esp+EECh] [ebp-254h] BYREF

  char RSHashResult36[9]; // [esp+EF8h] [ebp-248h] BYREF

  char RSHashResult35[9]; // [esp+F04h] [ebp-23Ch] BYREF

  HANDLE (__stdcall *CreateThread)(LPSECURITY_ATTRIBUTES, SIZE_T, LPTHREAD_START_ROUTINE, LPVOID, DWORD, LPDWORD); // [esp+F10h] [ebp-230h]

  char *szInput_hexdecoded; // [esp+F14h] [ebp-22Ch]

  int nInput; // [esp+F18h] [ebp-228h]

  char RSHashResult15[9]; // [esp+F1Ch] [ebp-224h] BYREF

  char RSHashResult27[9]; // [esp+F28h] [ebp-218h] BYREF

  char RSHashResult26[9]; // [esp+F34h] [ebp-20Ch] BYREF

  char RSHashResult25[9]; // [esp+F40h] [ebp-200h] BYREF

  char RSHashResult21[9]; // [esp+F4Ch] [ebp-1F4h] BYREF

  char RSHashResult20[9]; // [esp+F58h] [ebp-1E8h] BYREF

  char RSHashResult19[9]; // [esp+F64h] [ebp-1DCh] BYREF

  char RSHashResult2[9]; // [esp+F70h] [ebp-1D0h] BYREF

  char RSHashResult14[9]; // [esp+F7Ch] [ebp-1C4h] BYREF

  char RSHashResult13[9]; // [esp+F88h] [ebp-1B8h] BYREF

  char RSHashResult9[9]; // [esp+F94h] [ebp-1ACh] BYREF

  char RSHashResult8[9]; // [esp+FA0h] [ebp-1A0h] BYREF

  char RSHashResult7[9]; // [esp+FACh] [ebp-194h] BYREF

  char RSHashResult3[9]; // [esp+FB8h] [ebp-188h] BYREF

  char RSHashResult1[9]; // [esp+FC4h] [ebp-17Ch] BYREF

  char RSHashResult32[9]; // [esp+FD0h] [ebp-170h] BYREF

  char RSHashResult33[9]; // [esp+FDCh] [ebp-164h] BYREF

  char RSHashResult37[9]; // [esp+FE8h] [ebp-158h] BYREF

  char RSHashResult38[9]; // [esp+FF4h] [ebp-14Ch] BYREF

  char RSHashResult39[9]; // [esp+1000h] [ebp-140h] BYREF

  char RSHashResult31[9]; // [esp+100Ch] [ebp-134h] BYREF

  char RSHashResult43[9]; // [esp+1018h] [ebp-128h] BYREF

  char RSHashResult44[9]; // [esp+1024h] [ebp-11Ch] BYREF

  char RSHashResult45[9]; // [esp+1030h] [ebp-110h] BYREF

  char szHash2Hash_[12]; // [esp+103Ch] [ebp-104h] BYREF

  char szDecCurrent_[12]; // [esp+1048h] [ebp-F8h] BYREF

  void *pSerial_Rest21; // [esp+1054h] [ebp-ECh]

  HMODULE hModule; // [esp+1058h] [ebp-E8h]

  void *pSerial_Rest2; // [esp+105Ch] [ebp-E4h]

  void *pSerial_Rest1; // [esp+1060h] [ebp-E0h]

  void *pSerial_Rest3; // [esp+1064h] [ebp-DCh]

  void *pSerial_Rest4; // [esp+1068h] [ebp-D8h]

  void *pSerial_Rest5; // [esp+106Ch] [ebp-D4h]

  void *pSerial_Rest6; // [esp+1070h] [ebp-D0h]

  void *pSerial_Rest7; // [esp+1074h] [ebp-CCh]

  void *pSerial_Rest8; // [esp+1078h] [ebp-C8h]

  void *pSerial_Rest9; // [esp+107Ch] [ebp-C4h]

  void *pSerial_Rest10; // [esp+1080h] [ebp-C0h]

  void *pSerial_Rest11; // [esp+1084h] [ebp-BCh]

  void *pSerial_Rest12; // [esp+1088h] [ebp-B8h]

  void *pSerial_Rest13; // [esp+108Ch] [ebp-B4h]

  void *pSerial_Rest14; // [esp+1090h] [ebp-B0h]

  void *pSerial_Rest15; // [esp+1094h] [ebp-ACh]

  void *pSerial_Rest16; // [esp+1098h] [ebp-A8h]

  void *pSerial_Rest17; // [esp+109Ch] [ebp-A4h]

  void *pSerial_Rest18; // [esp+10A0h] [ebp-A0h]

  void *pSerial_Rest19; // [esp+10A4h] [ebp-9Ch]

  void *pSerial_Rest20; // [esp+10A8h] [ebp-98h]

  char szHash2Hash[9]; // [esp+10ACh] [ebp-94h] BYREF

  char Format[12]; // [esp+10B8h] [ebp-88h] BYREF

  char v186[4]; // [esp+10C4h] [ebp-7Ch] BYREF

  char v187[10]; // [esp+10C8h] [ebp-78h] BYREF

  char v188[4]; // [esp+10D2h] [ebp-6Eh] BYREF

  int m; // [esp+10D8h] [ebp-68h]

  int i; // [esp+10DCh] [ebp-64h]

  size_t k; // [esp+10E0h] [ebp-60h]

  int j; // [esp+10E4h] [ebp-5Ch]

  char szDecCurrent[17]; // [esp+10E8h] [ebp-58h] BYREF

  char szSerialNum_Real[17]; // [esp+10FCh] [ebp-44h] BYREF

  char szDecResult[17]; // [esp+1110h] [ebp-30h] BYREF

  char szCurrentSer[17]; // [esp+1124h] [ebp-1Ch] BYREF

  char White_message_8[8]; // [esp+1138h] [ebp-8h] BYREF
 
  memset(szKeySerial, 0, sizeof(szKeySerial));

  memset(szAllHash, 0, sizeof(szAllHash));

  qmemcpy(My_key1, "qrstuvwx", sizeof(My_key1));

  memset(White_message, 0, sizeof(White_message));

  memset(White_message_8, 0, sizeof(White_message_8));

  memset(Black_message1, 0, sizeof(Black_message1));

  memset(RSHashResult1, 0, sizeof(RSHashResult1));

  Format[0] = 0xC7;

  Format[1] = 0xEB;

  Format[2] = 0xCA;

  Format[3] = 0xE4;

  Format[4] = 0xC8;

  Format[5] = 0xEB;

  Format[6] = 0xD3;

  Format[7] = 0xC3;

  Format[8] = 0xBB;

  Format[9] = 0xA7;

  Format[10] = 0xC3;

  Format[11] = 0xFB;

  strcpy(v186, ":\n");

  printf(Format);    // 请输入用户名:

  gets_s(White_message, 50u);

  v3 = strlen(White_message);

  nInput = RSHash(White_message, v3);

  itoa(nInput, White_message_8, 16);

  Encode_1(My_key1, White_message_8, Black_message1, RSHashResult1);

  memcpy(szKeySerial, Black_message1, 8u);

  memcpy(szAllHash, RSHashResult1, 8u);

  qmemcpy(My_key2, "abcdefgh", sizeof(My_key2));

  memset(Black_message2, 0, sizeof(Black_message2));

  memset(RSHashResult2, 0, sizeof(RSHashResult2));

  Encode_2(My_key2, White_message_8, Black_message2, RSHashResult2);

  memcpy(szKeySerial[1], Black_message2, 8u);

  memcpy(szAllHash[1], RSHashResult2, sizeof(char[8]));

  qmemcpy(My_key3, "ijklmnop", sizeof(My_key3));

  memset(Black_message3, 0, sizeof(Black_message3));

  memset(RSHashResult3, 0, sizeof(RSHashResult3));

  Encode_2(My_key3, White_message_8, Black_message3, RSHashResult3);

  memcpy(szKeySerial[2], Black_message3, 8u);

  memcpy(szAllHash[2], RSHashResult3, sizeof(char[8]));

  qmemcpy(My_key4, "qrstuvwx", sizeof(My_key4));

  memset(Black_message4, 0, sizeof(Black_message4));

  memset(RSHashResult4, 0, sizeof(RSHashResult4));

  Encode_4(My_key4, White_message_8, Black_message4, RSHashResult4);

  qmemcpy(My_key5, "abcdefgh", sizeof(My_key5));

  memset(Black_message5, 0, sizeof(Black_message5));

  memset(RSHashResult5, 0, sizeof(RSHashResult5));

  Encode_5(My_key5, White_message_8, Black_message5, RSHashResult5);

  qmemcpy(My_key6, "ijklmnop", sizeof(My_key6));

  memset(Black_message6, 0, sizeof(Black_message6));

  memset(RSHashResult6, 0, sizeof(RSHashResult6));

  Encode_6(My_key6, White_message_8, Black_message6, RSHashResult6);

  qmemcpy(My_key7, "qrstuvwx", sizeof(My_key7));

  memset(Black_message7, 0, sizeof(Black_message7));

  memset(RSHashResult7, 0, sizeof(RSHashResult7));

  Encode_7(My_key7, White_message_8, Black_message7, RSHashResult7);

  memcpy(szKeySerial[3], Black_message7, 8u);

  memcpy(szAllHash[3], RSHashResult7, sizeof(char[8]));

  qmemcpy(My_key8, "abcdefgh", sizeof(My_key8));

  memset(Black_message8, 0, sizeof(Black_message8));

  memset(RSHashResult8, 0, sizeof(RSHashResult8));

  Encode_8(My_key8, White_message_8, Black_message8, RSHashResult8);

  memcpy(szKeySerial[4], Black_message8, 8u);

  memcpy(szAllHash[4], RSHashResult8, sizeof(char[8]));

  qmemcpy(My_key9, "ijklmnop", sizeof(My_key9));

  memset(Black_message9, 0, sizeof(Black_message9));

  memset(RSHashResult9, 0, sizeof(RSHashResult9));

  Encode_9(My_key9, White_message_8, Black_message9, RSHashResult9);

  memcpy(szKeySerial[4], Black_message9, 8u);

  memcpy(szAllHash[4], RSHashResult9, sizeof(char[8]));

  qmemcpy(My_key10, "qrstuvwx", sizeof(My_key10));

  memset(Black_message10, 0, sizeof(Black_message10));

  memset(RSHashResult10, 0, sizeof(RSHashResult10));

  Encode_10(My_key10, White_message_8, Black_message10, RSHashResult10);

  qmemcpy(My_key11, "abcdefgh", sizeof(My_key11));

  memset(Black_message11, 0, sizeof(Black_message11));

  memset(RSHashResult11, 0, sizeof(RSHashResult11));

  Encode_11(My_key11, White_message_8, Black_message11, RSHashResult11);

  qmemcpy(My_key12, "ijklmnop", sizeof(My_key12));

  memset(Black_message12, 0, sizeof(Black_message12));

  memset(RSHashResult12, 0, sizeof(RSHashResult12));

  Encode_12(My_key12, White_message_8, Black_message12, RSHashResult12);

  qmemcpy(My_key13, "qrstuvwx", sizeof(My_key13));

  memset(Black_message13, 0, sizeof(Black_message13));

  memset(RSHashResult13, 0, sizeof(RSHashResult13));

  Encode_13(My_key13, White_message_8, Black_message13, RSHashResult13);

  memcpy(szKeySerial[6], Black_message13, 8u);

  memcpy(szAllHash[6], RSHashResult13, sizeof(char[8]));

  qmemcpy(My_key14, "abcdefgh", sizeof(My_key14));

  memset(Black_message14, 0, sizeof(Black_message14));

  memset(RSHashResult14, 0, sizeof(RSHashResult14));

  Encode_14(My_key14, White_message_8, Black_message14, RSHashResult14);

  memcpy(szKeySerial[7], Black_message14, 8u);

  memcpy(szAllHash[7], RSHashResult14, sizeof(char[8]));

  qmemcpy(My_key15, "ijklmnop", sizeof(My_key15));

  memset(Black_message15, 0, sizeof(Black_message15));

  memset(RSHashResult15, 0, sizeof(RSHashResult15));

  Encode_15(My_key15, White_message_8, Black_message15, RSHashResult15);

  memcpy(szKeySerial[8], Black_message15, 8u);

  memcpy(szAllHash[8], RSHashResult15, sizeof(char[8]));

  qmemcpy(My_key16, "qrstuvwx", sizeof(My_key16));

  memset(Black_message16, 0, sizeof(Black_message16));

  memset(RSHashResult16, 0, sizeof(RSHashResult16));

  Encode_16(My_key16, White_message_8, Black_message16, RSHashResult16);

  qmemcpy(My_key17, "abcdefgh", sizeof(My_key17));

  memset(Black_message17, 0, sizeof(Black_message17));

  memset(RSHashResult17, 0, sizeof(RSHashResult17));

  Encode_17(My_key17, White_message_8, Black_message17, RSHashResult17);

  qmemcpy(My_key18, "ijklmnop", sizeof(My_key18));

  memset(Black_message18, 0, sizeof(Black_message18));

  memset(RSHashResult18, 0, sizeof(RSHashResult18));

  Encode_18(My_key18, White_message_8, Black_message18, RSHashResult18);

  qmemcpy(My_key19, "qrstuvwx", sizeof(My_key19));

  memset(Black_message19, 0, sizeof(Black_message19));

  memset(RSHashResult19, 0, sizeof(RSHashResult19));

  Encode_19(My_key19, White_message_8, Black_message19, RSHashResult19);

  memcpy(szKeySerial[9], Black_message19, 8u);

  memcpy(szAllHash[9], RSHashResult19, sizeof(char[8]));

  qmemcpy(My_key20, "abcdefgh", sizeof(My_key20));

  memset(Black_message20, 0, sizeof(Black_message20));

  memset(RSHashResult20, 0, sizeof(RSHashResult20));

  Encode_20(My_key20, White_message_8, Black_message20, RSHashResult20);

  memcpy(szKeySerial[10], Black_message20, 8u);

  memcpy(szAllHash[10], RSHashResult20, sizeof(char[8]));

  qmemcpy(My_key21, "ijklmnop", sizeof(My_key21));

  memset(Black_message21, 0, sizeof(Black_message21));

  memset(RSHashResult21, 0, sizeof(RSHashResult21));

  Encode_21(My_key21, White_message_8, Black_message21, RSHashResult21);

  memcpy(szKeySerial[11], Black_message21, 8u);

  memcpy(szAllHash[11], RSHashResult21, sizeof(char[8]));

  qmemcpy(My_key22, "qrstuvwx", sizeof(My_key22));

  memset(Black_message22, 0, sizeof(Black_message22));

  memset(RSHashResult22, 0, sizeof(RSHashResult22));

  Encode_22(My_key22, White_message_8, Black_message22, RSHashResult22);

  qmemcpy(My_key23, "abcdefgh", sizeof(My_key23));

  memset(Black_message23, 0, sizeof(Black_message23));

  memset(RSHashResult23, 0, sizeof(RSHashResult23));

  Encode_23(My_key23, White_message_8, Black_message23, RSHashResult23);

  qmemcpy(My_key24, "ijklmnop", sizeof(My_key24));

  memset(Black_message24, 0, sizeof(Black_message24));

  memset(RSHashResult24, 0, sizeof(RSHashResult24));

  Encode_24(My_key24, White_message_8, Black_message24, RSHashResult24);

  qmemcpy(My_key25, "qrstuvwx", sizeof(My_key25));

  memset(Black_message25, 0, sizeof(Black_message25));

  memset(RSHashResult25, 0, sizeof(RSHashResult25));

  Encode_25(My_key25, White_message_8, Black_message25, RSHashResult25);

  memcpy(szKeySerial[12], Black_message25, 8u);

  memcpy(szAllHash[12], RSHashResult25, sizeof(char[8]));

  qmemcpy(My_key26, "abcdefgh", sizeof(My_key26));

  memset(Black_message26, 0, sizeof(Black_message26));

  memset(RSHashResult26, 0, sizeof(RSHashResult26));

  Encode_26(My_key26, White_message_8, Black_message26, RSHashResult26);

  memcpy(szKeySerial[13], Black_message26, 8u);

  memcpy(szAllHash[13], RSHashResult26, sizeof(char[8]));

  qmemcpy(My_key27, "ijklmnop", sizeof(My_key27));

  memset(Black_message27, 0, sizeof(Black_message27));

  memset(RSHashResult27, 0, sizeof(RSHashResult27));

  Encode_27(My_key27, White_message_8, Black_message27, RSHashResult27);

  memcpy(szKeySerial[14], Black_message27, 8u);

  memcpy(szAllHash[14], RSHashResult27, sizeof(char[8]));

  qmemcpy(My_key28, "qrstuvwx", sizeof(My_key28));

  memset(Black_message28, 0, sizeof(Black_message28));

  memset(RSHashResult28, 0, sizeof(RSHashResult28));

  Encode_28(My_key28, White_message_8, Black_message28, RSHashResult28);

  qmemcpy(My_key29, "abcdefgh", sizeof(My_key29));

  memset(Black_message29, 0, sizeof(Black_message29));

  memset(RSHashResult29, 0, sizeof(RSHashResult29));

  Encode_29(My_key29, White_message_8, Black_message29, RSHashResult29);

  qmemcpy(My_key30, "ijklmnop", sizeof(My_key30));

  memset(Black_message30, 0, sizeof(Black_message30));

  memset(RSHashResult30, 0, sizeof(RSHashResult30));

  Encode_30(My_key30, White_message_8, Black_message30, RSHashResult30);

  qmemcpy(My_key31, "qrstuvwx", sizeof(My_key31));

  memset(Black_message31, 0, sizeof(Black_message31));

  memset(RSHashResult31, 0, sizeof(RSHashResult31));

  Encode_31(My_key31, White_message_8, Black_message31, RSHashResult31);

  memcpy(szKeySerial[15], Black_message31, 8u);

  memcpy(szAllHash[15], RSHashResult31, sizeof(char[8]));

  qmemcpy(My_key32, "abcdefgh", sizeof(My_key32));

  memset(Black_message32, 0, sizeof(Black_message32));

  memset(RSHashResult32, 0, sizeof(RSHashResult32));

  Encode_32(My_key32, White_message_8, Black_message32, RSHashResult32);

  memcpy(szKeySerial[16], Black_message32, 8u);

  memcpy(szAllHash[16], RSHashResult32, sizeof(char[8]));

  qmemcpy(My_key33, "ijklmnop", sizeof(My_key33));

  memset(Black_message33, 0, sizeof(Black_message33));

  memset(RSHashResult33, 0, sizeof(RSHashResult33));

  Encode_33(My_key33, White_message_8, Black_message33, RSHashResult33);

  memcpy(szKeySerial[17], Black_message33, 8u);

  memcpy(szAllHash[17], RSHashResult33, sizeof(char[8]));

  qmemcpy(My_key34, "qrstuvwx", sizeof(My_key34));

  memset(Black_message34, 0, sizeof(Black_message34));

  memset(RSHashResult34, 0, sizeof(RSHashResult34));

  Encode_34(My_key34, White_message_8, Black_message34, RSHashResult34);

  qmemcpy(My_key35, "abcdefgh", sizeof(My_key35));

  memset(Black_message35, 0, sizeof(Black_message35));

  memset(RSHashResult35, 0, sizeof(RSHashResult35));

  Encode_35(My_key35, White_message_8, Black_message35, RSHashResult35);

  qmemcpy(My_key36, "ijklmnop", sizeof(My_key36));

  memset(Black_message36, 0, sizeof(Black_message36));

  memset(RSHashResult36, 0, sizeof(RSHashResult36));

  Encode_36(My_key36, White_message_8, Black_message36, RSHashResult36);

  qmemcpy(My_key37, "qrstuvwx", sizeof(My_key37));

  memset(Black_message37, 0, sizeof(Black_message37));

				登录后可查看完整内容
			
[招生]科锐逆向工程师培训(2025年3月11日实地，远程教学同时开班, 第52期)！

		最后于  2023-9-18 21:34		
				被mb_mgodlfyn编辑
				
		，原因： 		
	
		#CrackMe
		#Reverse
收藏・2
免费・3
支持
赞赏记录
参与人
雪币
留言
时间
PLEBFE
为你点赞~
2024-1-2 01:09
0x指纹
为你点赞~
2023-9-18 08:44
v0id_
为你点赞~
2023-9-17 13:12
最新回复 (5)
v0id_ 雪币： 8533 活跃值： (5151) 能力值： ( LV4，RANK：45 ) 在线值：发帖 7 回帖 243 粉丝 34 关注私信	v0id_ 2 楼哈哈哈，《当Archaia出现在今年的防守方列表时，就有预感大概率是把2022H2的题目修了非预期再出。》 2023-9-17 13:15 0
ThisCha 雪币： 7 活跃值： (77) 能力值： ( LV3，RANK：25 ) 在线值：发帖 1 回帖 3 粉丝 0 关注私信	ThisCha 3 楼这个,由于混淆模式是固定的,通过调试识别相应的混淆代码,手工查找替换或者编写脚本就能反混淆,本身也是没有对调试是没有限制的 2023-9-17 14:42 0
0x指纹雪币： 5077 活跃值： (19365) 能力值： ( LV13，RANK：317 ) 在线值：发帖 12 回帖 223 粉丝 610 关注私信	0x指纹 6 4 楼感谢分享，很精彩 2023-9-18 08:44 0
秋狝雪币： 4277 活跃值： (31521) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 1569 粉丝 38 关注私信	秋狝 5 楼感谢分享 2023-9-18 08:45 1
method 雪币： 435 活跃值： (5448) 能力值： ( LV5，RANK：70 ) 在线值：发帖 12 回帖 118 粉丝 88 关注私信	method 1 6 楼确实，出题方管杀不管埋 2023-9-18 11:54 0
	游客登录 \| 注册方可回帖回帖表情雪币赚取及消费高级回复
mb_mgodlfyn
发帖
回帖
1744
RANK
关注
私信
他的文章
关于我们
联系我们
企业服务
看雪公众号
最新回复 (5)
v0id_ 雪币： 8533 活跃值： (5151) 能力值： ( LV4，RANK：45 ) 在线值：发帖 7 回帖 243 粉丝 34 关注私信	v0id_ 2 楼哈哈哈，《当Archaia出现在今年的防守方列表时，就有预感大概率是把2022H2的题目修了非预期再出。》 2023-9-17 13:15 0
ThisCha 雪币： 7 活跃值： (77) 能力值： ( LV3，RANK：25 ) 在线值：发帖 1 回帖 3 粉丝 0 关注私信	ThisCha 3 楼这个,由于混淆模式是固定的,通过调试识别相应的混淆代码,手工查找替换或者编写脚本就能反混淆,本身也是没有对调试是没有限制的 2023-9-17 14:42 0
0x指纹雪币： 5077 活跃值： (19365) 能力值： ( LV13，RANK：317 ) 在线值：发帖 12 回帖 223 粉丝 610 关注私信	0x指纹 6 4 楼感谢分享，很精彩 2023-9-18 08:44 0
秋狝雪币： 4277 活跃值： (31521) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 1569 粉丝 38 关注私信	秋狝 5 楼感谢分享 2023-9-18 08:45 1
method 雪币： 435 活跃值： (5448) 能力值： ( LV5，RANK：70 ) 在线值：发帖 12 回帖 118 粉丝 88 关注私信	method 1 6 楼确实，出题方管杀不管埋 2023-9-18 11:54 0
	游客登录 \| 注册方可回帖回帖表情雪币赚取及消费高级回复
[原创] 看雪 2023 KCTF 年度赛 第七题 智能联盟计划

账号登录 验证码登录

[原创] 看雪 2023 KCTF 年度赛第七题智能联盟计划

账号登录

验证码登录
