C转易语言

130092934 · 发表于 2025-5-18 21:26:00

窗口程序集名	保留	保留	备注
窗口程序集_启动窗口

子程序名	返回值类型	公开	备注
解码	文本型
参数名	类型	参考	可空	数组	备注
文本	文本型

变量名	类型	静态	数组	备注
掩码1	字节集
掩码2	字节集
内容	字节集
量	整数型
数	整数型
字节	字节型
值	整数型
临时	整数型
下标	整数型
结果	字节集

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

计次循环首 (取字节集长度 (内容), 数)

字节＝内容 [数]

如果真 (字节＜十六进制 (“3C”))

跳出循环 ()

字节＝字节－十六进制 (“3C”)

如果真 (值 ≥ 2)

值＝ 0

下标＝位异或 (位或 (右移 (位与 (字节, 十六进制 (“3F”)), 6 －量), 临时), 十六进制 (“9E”))

结果＝结果＋到字节集 (到字节 (位异或 (掩码1 [下标＋ 1], 十六进制 (“34”))))

如果真 (量＞ 5)

量＝ 2

到循环尾 ()

量＝量＋ 2

临时＝位与 (掩码2 [量－ 2 ＋ 1], 左移 (字节, 量))

值＝值＋ 8 －量

计次循环尾 ()
' 调试输出 (1, 结果)
' 调试输出 (2, bin2hex (结果))

如果 (取字节集长度 (结果) ＝ 36)

结果＝取字节集右边 (内容, 取字节集长度 (内容) － 12)

结果＝取字节集右边 (结果, 取字节集长度 (结果) － 36)
' 调试输出 (1, 结果)
' 调试输出 (2, bin2hex (结果))
返回 (编码_Utf8到Ansi (结果))

子程序名	返回值类型	公开	备注
__启动窗口_创建完毕

变量名	类型	静态	数组	备注
文本	文本型
加密文本	文本型
测试	文本型
内容	字节集

' 这是加密的
文本＝ “5D 54 52 41 5D 55 76 41 5D 54 52 41 5D 54 52 41 74 44 52 41 5D 54 52 41 5D 54 50 59 5D 54 52 41 5D 54 52 41 5D 57 76 41 5D 54 52 41 5D 54 52 41 47 73 45 77 4A 73 3E 5D 76 48 79 6E 4A 63 46 7A 6B 5D 4E 6E 52 61 47 4F 41 3D 4C 50 50 67 47 79 68 5C 48 3F 52 61 47 79 70 6D 4C 50 50 5D 4C 69 47 57 76 6E 7B 53 45 4F 5D 54 52 41 5D 54 76 41 5D 54 50 4C 5D 54 52 41 76 74 52 41 5D 52 72 41 5D 54 50 61 40 47 6C 40 5D 54 52 41 5D 53 42 41 5D 54 51 59 57 54 52 41 45 6E 65 50 51 48 79 5C 3C 70 54 3F 52 67 74 50 3C 71 46 6E 6B 61 44”
' 这是解密的
测试＝ “00 00 00 00 1E 00 00 00 00 00 00 00 6E 00 00 00 00 00 00 00 5E 00 00 00 00 00 00 00 38 00 00 00 00 00 00 00 7B 22 55 73 65 72 49 44 22 3A 22 38 38 30 37 32 31 33 30 30 30 31 37 34 37 35 35 32 31 34 33 30 30 31 30 39 39 38 37 34 22 7D 00 00 00 00 01 00 00 00 14 00 00 00 21 00 00 00 05 00 00 00 D8 14 6D 02 00 00 00 00 17 00 00 00 D2 05 00 00 2B 47 4F 4F 44 2F 35 36 35 32 38 30 35 31 37 38 31 ”
调试输出 (解码 (文本))

i支持库列表	支持库注释
spec	特殊功能支持库

.版本 2<br />
.支持库 spec<br />
<br />
.程序集 窗口程序集_启动窗口<br />
<br />
.子程序 解码, 文本型<br />
.参数 文本, 文本型<br />
.局部变量 掩码1, 字节集<br />
.局部变量 掩码2, 字节集<br />
.局部变量 内容, 字节集<br />
.局部变量 量, 整数型<br />
.局部变量 数, 整数型<br />
.局部变量 字节, 字节型<br />
.局部变量 值, 整数型<br />
.局部变量 临时, 整数型<br />
.局部变量 下标, 整数型<br />
.局部变量 结果, 字节集<br />
<br />
掩码1 ＝ { 42, 231, 24, 111, 99, 157, 72, 234, 57, 205, 56, 184, 160, 171, 224, 16, 53, 153, 55, 9, 192, 105, 178, 164, 103, 136, 80, 52, 127, 252, 11, 190, 12, 68, 89, 182, 91, 156, 101, 214, 148, 235, 196, 59, 3, 60, 201, 62, 107, 154, 212, 246, 195, 77, 17, 36, 170, 255, 74, 237, 149, 147, 217, 70, 95, 150, 135, 48, 186, 202, 203, 250, 138, 26, 104, 92, 172, 7, 64, 96, 41, 112, 87, 83, 65, 18, 222, 29, 100, 20, 151, 114, 251, 141, 43, 8, 207, 244, 58, 0, 197, 145, 86, 169, 158, 113, 188, 163, 175, 166, 85, 218, 121, 187, 51, 165, 37, 21, 125, 238, 193, 44, 199, 208, 25, 216, 90, 232, 133, 253, 47, 106, 120, 69, 219, 181, 245, 30, 4, 117, 176, 122, 32, 242, 223, 211, 131, 243, 84, 144, 162, 198, 15, 128, 54, 78, 200, 1, 130, 118, 161, 46, 132, 134, 14, 71, 143, 225, 249, 124, 194, 116, 220, 38, 34, 206, 45, 79, 191, 13, 115, 39, 33, 179, 152, 31, 137, 236, 254, 82, 10, 140, 159, 168, 229, 230, 6, 139, 204, 247, 94, 227, 123, 210, 5, 73, 19, 233, 102, 183, 173, 180, 248, 167, 28, 241, 2, 126, 110, 23, 98, 76, 119, 142, 221, 240, 67, 40, 109, 97, 185, 215, 189, 61, 155, 146, 22, 239, 81, 35, 226, 177, 129, 49, 50, 88, 209, 93, 213, 108, 75, 228, 174, 66, 27, 63 }<br />
掩码2 ＝ { 252, 248, 240, 224, 192 }<br />
内容 ＝ hex2bin (删全部空 (文本))<br />
<br />
<br />
量 ＝ 2<br />
.计次循环首 (取字节集长度 (内容), 数)<br />
    字节 ＝ 内容 [数]<br />
    .如果真 (字节 ＜ 十六进制 (“3C”))<br />
        跳出循环 ()<br />
    .如果真结束<br />
    字节 ＝ 字节 － 十六进制 (“3C”)<br />
    .如果真 (值 ≥ 2)<br />
        值 ＝ 0<br />
        下标 ＝ 位异或 (位或 (右移 (位与 (字节, 十六进制 (“3F”)), 6 － 量), 临时), 十六进制 (“9E”))<br />
        结果 ＝ 结果 ＋ 到字节集 (到字节 (位异或 (掩码1 [下标 ＋ 1], 十六进制 (“34”))))<br />
<br />
<br />
        .如果真 (量 ＞ 5)<br />
            量 ＝ 2<br />
            到循环尾 ()<br />
        .如果真结束<br />
        量 ＝ 量 ＋ 2<br />
    .如果真结束<br />
    临时 ＝ 位与 (掩码2 [量 － 2 ＋ 1], 左移 (字节, 量))<br />
    值 ＝ 值 ＋ 8 － 量<br />
.计次循环尾 ()<br />
' 调试输出 (1, 结果)<br />
' 调试输出 (2, bin2hex (结果))<br />
<br />
.如果 (取字节集长度 (结果) ＝ 36)<br />
    结果 ＝ 取字节集右边 (内容, 取字节集长度 (内容) － 12)<br />
.否则<br />
    结果 ＝ 取字节集右边 (结果, 取字节集长度 (结果) － 36)<br />
.如果结束<br />
' 调试输出 (1, 结果)<br />
' 调试输出 (2, bin2hex (结果))<br />
<br />
<br />
<br />
返回 (编码_Utf8到Ansi (结果))<br />
<br />
.子程序 __启动窗口_创建完毕<br />
.局部变量 文本, 文本型<br />
.局部变量 加密文本, 文本型<br />
.局部变量 测试, 文本型<br />
.局部变量 内容, 字节集<br />
<br />
' 这是加密的<br />
文本 ＝ “5D 54 52 41 5D 55 76 41 5D 54 52 41 5D 54 52 41 74 44 52 41 5D 54 52 41 5D 54 50 59 5D 54 52 41 5D 54 52 41 5D 57 76 41 5D 54 52 41 5D 54 52 41 47 73 45 77 4A 73 3E 5D 76 48 79 6E 4A 63 46 7A 6B 5D 4E 6E 52 61 47 4F 41 3D 4C 50 50 67 47 79 68 5C 48 3F 52 61 47 79 70 6D 4C 50 50 5D 4C 69 47 57 76 6E 7B 53 45 4F 5D 54 52 41 5D 54 76 41 5D 54 50 4C 5D 54 52 41 76 74 52 41 5D 52 72 41 5D 54 50 61 40 47 6C 40 5D 54 52 41 5D 53 42 41 5D 54 51 59 57 54 52 41 45 6E 65 50 51 48 79 5C 3C 70 54 3F 52 67 74 50 3C 71 46 6E 6B 61 44”<br />
' 这是解密的<br />
测试 ＝ “00 00 00 00 1E 00 00 00 00 00 00 00 6E 00 00 00 00 00 00 00 5E 00 00 00 00 00 00 00 38 00 00 00 00 00 00 00 7B 22 55 73 65 72 49 44 22 3A 22 38 38 30 37 32 31 33 30 30 30 31 37 34 37 35 35 32 31 34 33 30 30 31 30 39 39 38 37 34 22 7D 00 00 00 00 01 00 00 00 14 00 00 00 21 00 00 00 05 00 00 00 D8 14 6D 02 00 00 00 00 17 00 00 00 D2 05 00 00 2B 47 4F 4F 44 2F 35 36 35 32 38 30 35 31 37 38 31 ”<br />
调试输出 (解码 (文本))

  这是大佬给我搞的  解密的  ,怎么搞加密的....下面这是源码

#include "pch.h"
#include "IDA.h"
uint8_t EncodeBitMasks[] = {
0x8C, 0x87, 0xD, 0x85, 0xD4, 0x64, 0x63, 0xE5, 0xBA,
0x7E, 0xB8, 0x68, 0x9D, 0x9F, 0xF5, 0xBC, 0xA0, 0xE3,
0x3A, 0x22, 0x19, 0x21, 0x39, 0x78, 0xEE, 0x27, 0x36,
0x15, 0x74, 0xC7, 0x97, 0xC9, 0xCE, 0xE2, 0x7B, 0x4C,
0x98, 0xA1, 0xC2, 0x59, 0x41, 0xC0, 0x1E, 0x2E, 0x95,
0xEB, 0xDE, 0x69, 0x1D, 0x5B, 0x53, 0xDA, 0xF4, 0xA,
0x4F, 0xBB, 0xB7, 0x24, 0x33, 0xF, 0xC8, 0x84, 0x29 ,
0x89, 0x3C, 0x1C, 8, 0x49, 0xC6, 0xFE, 0xCC, 0x23 ,
0x3E, 0xE1, 0x4E, 0x8B, 0x13, 0xE7, 0x1A, 0x5D, 0xCF,
0xB1, 0x47, 0x8F, 0xD8, 0x72, 0x4B, 0x93, 0x6E, 0x73,
0x4D, 0x94, 0xDD, 0x82, 0x14, 0xA7, 3, 0xF9, 0xF1 ,
0xC5, 0x8D, 0x79, 0x2A, 0xC4, 0xDC, 0x60, 0x5F, 0xD7,
0x62, 0xB5, 0xE9, 0xB3, 0xB6, 0x12, 0xA8, 0x32, 0xD9,
0xC3, 0x6A, 0x75, 0x4A, 0xA2, 0xC, 0x26, 0x91, 0x5A ,
0xAD, 0x6D, 0x44, 0x10, 0xB4, 0x46, 0x1B, 0x66, 0x81,
0x20, 0xFD, 0x7F, 0x88, 0x25, 0x9C, 0x71, 0xD3, 0xE6,
0x80, 0xE4, 0xFA, 0x42, 0x9B, 0x37, 1, 0xFC, 0xDB ,
0x45, 0x6B, 0xFB, 0x56, 0xF0, 0xAF, 0x9A, 0xBF, 0xAB,
0xD6, 0xCD, 2, 0xF2, 0x7C, 0xAA, 0xB2, 0x92, 0xFF ,
0x57, 0x2F, 0x86, 0xA6, 0x7D, 0x35, 0x17, 0x34, 0xD5,
0xE, 0x65, 9, 5, 0x28, 0xCA, 0x48, 0x31, 0x8E, 0x2D ,
0xDF, 0x52, 0xF6, 0x1F, 0xA4, 0x50, 0x76, 0x40, 0x18,
4, 0x8A, 0x16, 0x2B, 0xAE, 0x43, 0x3F, 0xD0, 0xCB ,
0x6C, 0x55, 0x54, 0x96, 0x99, 0x30, 0x67, 0x5E, 0x2C,
0xAC, 0xE0, 0x7A, 0xE8, 0x58, 0x90, 0xBE, 0xA5, 0x6F,
0xB0, 0x70, 0xEC, 0x61, 0x5C, 6, 0x3B, 0x77, 0xC1 ,
7, 0xEA, 0xA9, 0xF8, 0x11, 0xBD, 0xF3, 0, 0xED, 0x83,
0xEF, 0x3D, 0xA3, 0x51, 0x9E, 0x38, 0xF7, 0xB, 0xB9 ,
0xD2, 0xD1
};

uint8_t DecodeBitMasks[] = {

0x2A, 0xE7, 0x18, 0x6F, 0x63, 0x9D, 0x48, 0xEA, 0x39  ,
0xCD, 0x38, 0xB8, 0xA0, 0xAB, 0xE0, 0x10, 0x35, 0x99  ,
0x37, 9, 0xC0, 0x69, 0xB2, 0xA4, 0x67, 0x88, 0x50    ,
0x34, 0x7F, 0xFC, 0xB, 0xBE, 0xC, 0x44, 0x59, 0xB6 ,
0x5B, 0x9C, 0x65, 0xD6, 0x94, 0xEB, 0xC4, 0x3B, 3    ,
0x3C, 0xC9, 0x3E, 0x6B, 0x9A, 0xD4, 0xF6, 0xC3, 0x4D  ,
0x11, 0x24, 0xAA, 0xFF, 0x4A, 0xED, 0x95, 0x93, 0xD9  ,
0x46, 0x5F, 0x96, 0x87, 0x30, 0xBA, 0xCA, 0xCB, 0xFA  ,
0x8A, 0x1A, 0x68, 0x5C, 0xAC, 7, 0x40, 0x60, 0x29    ,
0x70, 0x57, 0x53, 0x41, 0x12, 0xDE, 0x1D, 0x64, 0x14  ,
0x97, 0x72, 0xFB, 0x8D, 0x2B, 8, 0xCF, 0xF4, 0x3A    ,
0, 0xC5, 0x91, 0x56, 0xA9, 0x9E, 0x71, 0xBC, 0xA3    ,
0xAF, 0xA6, 0x55, 0xDA, 0x79, 0xBB, 0x33, 0xA5, 0x25  ,
0x15, 0x7D, 0xEE, 0xC1, 0x2C, 0xC7, 0xD0, 0x19, 0xD8  ,
0x5A, 0xE8, 0x85, 0xFD, 0x2F, 0x6A, 0x78, 0x45, 0xDB  ,
0xB5, 0xF5, 0x1E, 4, 0x75, 0xB0, 0x7A, 0x20, 0xF2    ,
0xDF, 0xD3, 0x83, 0xF3, 0x54, 0x90, 0xA2, 0xC6, 0xF ,
0x80, 0x36, 0x4E, 0xC8, 1, 0x82, 0x76, 0xA1, 0x2E    ,
0x84, 0x86, 0xE, 0x47, 0x8F, 0xE1, 0xF9, 0x7C, 0xC2 ,
0x74, 0xDC, 0x26, 0x22, 0xCE, 0x2D, 0x4F, 0xBF, 0xD ,
0x73, 0x27, 0x21, 0xB3, 0x98, 0x1F, 0x89, 0xEC, 0xFE  ,
0x52, 0xA, 0x8C, 0x9F, 0xA8, 0xE5, 0xE6, 6, 0x8B, 0xCC,
0xF7, 0x5E, 0xE3, 0x7B, 0xD2, 5, 0x49, 0x13, 0xE9    ,
0x66, 0xB7, 0xAD, 0xB4, 0xF8, 0xA7, 0x1C, 0xF1, 2    ,
0x7E, 0x6E, 0x17, 0x62, 0x4C, 0x77, 0x8E, 0xDD, 0xF0  ,
0x43, 0x28, 0x6D, 0x61, 0xB9, 0xD7, 0xBD, 0x3D, 0x9B  ,
0x92, 0x16, 0xEF, 0x51, 0x23, 0xE2, 0xB1, 0x81, 0x31  ,
0x32, 0x58, 0xD1, 0x5D, 0xD5, 0x6C, 0x4B, 0xE4, 0xAE  ,
0x42, 0x1B, 0x3F

};

uint8_t Decode6BitMask[] = { 0xFC, 0xF8, 0xF0, 0xE0, 0xC0 };
namespace Decrypt
{
std::string vEnCode;
std::string vDecCode;
std::string vHeader;
std::string vCode;
std::string vString;

std::string UTF8_To_string(const std::string& str)
{
      int nwLen = MultiByteToWideChar(CP_UTF8, 0, str.c_str(), -1, NULL, 0);
      wchar_t* pwBuf = new wchar_t[nwLen + 1]; //一定要加1，不然会出现尾巴
      memset(pwBuf, 0, nwLen * 2 + 2);
      MultiByteToWideChar(CP_UTF8, 0, str.c_str(), str.length(), pwBuf, nwLen);
      int nLen = WideCharToMultiByte(CP_ACP, 0, pwBuf, -1, NULL, NULL, NULL, NULL);
      char* pBuf = new char[nLen + 1];
      memset(pBuf, 0, nLen + 1);
      WideCharToMultiByte(CP_ACP, 0, pwBuf, nwLen, pBuf, nLen, NULL, NULL);

      std::string strRet = pBuf;

      delete[]pBuf;
      delete[]pwBuf;
      pBuf = NULL;
      pwBuf = NULL;

      return strRet;
}

std::vector<int> PatternCode(const char* sSignature)
{
      auto    bytes = std::vector<int>{};
      const auto start = const_cast<char*>(sSignature);
      const auto end = const_cast<char*>(sSignature) + strlen(sSignature);

      for (auto current = start; current < end; ++current)
      {
         bytes.push_back(strtoul(current, &current, 16));
      }

      return bytes;
}

unsigned __int8* __fastcall Encode6BitBuf(unsigned __int8* result, char* a2, unsigned int a3, unsigned int* a4)
{
      int v4; // r8
      int v5; // r5
      unsigned int v6; // r12
      unsigned int v7; // r7
      int v8; // r6
      bool v9; // cc
      char v10; // r4
      unsigned int v11; // r5

      if (a3)
      {
         LOBYTE(v4) = 0;
         v5 = 0;
         v6 = 0;
         do
         {
            v7 = EncodeBitMasks[*result] ^ 9;
            v8 = v5 + 2;
            v9 = v5 + 2 < 6;
            a2[v6] = (((v7 >> (v5 + 2)) | v4) & 0x3F) + 0x3C;
            v10 = 6 - v5;
            v11 = v6 + 1;
            v4 = (unsigned __int8)(v7 << v10) >> 2;
            if (v9)
            {
                  ++v6;
                  v5 = v8;
            }
            else
            {
                  v6 += 2;
                  a2[v11] = v4 + 0x3C;
                  v5 = 0;
                  v4 = 0;
            }
            --a3;
            ++result;
         } while (a3);
         if (v5 > 0)
         {
            result = (unsigned __int8*)(v4 + 0x3C);
            a2[v6++] = v4 + 0x3C;
         }
      }
      else
      {
         v6 = 0;
      }
      *a4 = v6;
      return result;
}

int __fastcall Decode6BitBuf(char* result, unsigned char* a2, unsigned int a3, unsigned int* a4)
{
      int v4; // r12
      int v5; // r4
      int v6; // r10
      unsigned int v7; // lr
      int v8; // r6
      unsigned int v9; // r5
      unsigned __int8 v10; // r5

      if (a3)
      {
         v4 = 0;
         v5 = 2;
         LOBYTE(v6) = 0;
         v7 = 0;
         v8 = 0;
         while (1)
         {
            v9 = *(unsigned __int8*)(result + v4);
            if (v9 < 0x3C)
                  goto LABEL_12;
            v10 = v9 - 0x3C;
            if (v8 >= 2)
            {
                  unsigned char code = DecodeBitMasks[(((unsigned __int8)(v10 & 0x3F) >> (6 - v5)) | (unsigned __int8)v6) ^ 0x9E] ^ 0x34;
                  //printf("%02X ", code);
                  a2[v7++] = DecodeBitMasks[(((unsigned __int8)(v10 & 0x3F) >> (6 - v5)) | (unsigned __int8)v6) ^ 0x9E] ^ 0x34;

                  if (v5 > 5)
                  {
                     v5 = 2;
                     v8 = 0;
                     goto LABEL_9;
                  }
                  v5 += 2;
                  v8 = 0;
            }
            v6 = Decode6BitMask[v5 - 2] & (v10 << v5);
            v8 = v8 + 8 - v5;
         LABEL_9:
            if (++v4 >= a3)
                  goto LABEL_12;
         }
      }
      v7 = 0;
LABEL_12:
      *a4 = v7;
      return (int)result;
}

std::vector<int> __fastcall Encode6BitBuf(std::vector<int> result, unsigned int a3, unsigned int* a4)
{
      int v4; // r8
      int v5; // r5
      unsigned int v6; // r12
      unsigned int v7; // r7
      int v8; // r6
      bool v9; // cc
      char v10; // r4
      unsigned int v11; // r5
      std::vector<int> buffer;
      if (a3)
      {
         LOBYTE(v4) = 0;
         v5 = 0;
         v6 = 0;
         int i = 0;
         do
         {
            v7 = EncodeBitMasks[result] ^ 9;
            v8 = v5 + 2;
            v9 = v5 + 2 < 6;
            auto code = (((v7 >> (v5 + 2)) | v4) & 0x3F) + 0x3C;
            buffer.push_back(code);
            v10 = 6 - v5;
            v11 = v6 + 1;
            v4 = (unsigned __int8)(v7 << v10) >> 2;
            if (v9)
            {
                  ++v6;
                  v5 = v8;
            }
            else
            {
                  v6 += 2;
                  auto code2 = v4 + 0x3C;
                  buffer.push_back(code2);
                  v5 = 0;
                  v4 = 0;
            }
            --a3;
            ++i;
         } while (a3);
         if (v5 > 0)
         {
            auto code3 = v4 + 0x3C;
            buffer.push_back(code3);

         }
      }
      else
      {
         v6 = 0;
      }
      *a4 = v6;
      return buffer;
}

std::vector<int> __fastcall Decode6BitBuf(std::vector<int> result, unsigned int a3, unsigned int* a4)
{
      int v4; // r12
      int v5; // r4
      int v6; // r10
      unsigned int v7; // lr
      int v8; // r6
      unsigned int v9; // r5
      unsigned __int8 v10; // r5
      std::vector<int> buffer;
      if (a3)
      {
         v4 = 0;
         v5 = 2;
         LOBYTE(v6) = 0;
         v7 = 0;
         v8 = 0;
         while (1)
         {
            v9 = result[v4];
            if (v9 < 0x3C)
                  goto LABEL_12;
            v10 = v9 - 0x3C;
            if (v8 >= 2)
            {
                  unsigned char code = DecodeBitMasks[(((unsigned __int8)(v10 & 0x3F) >> (6 - v5)) | (unsigned __int8)v6) ^ 0x9E] ^ 0x34;
                  buffer.push_back(code);
                  if (v5 > 5)
                  {
                     v5 = 2;
                     v8 = 0;
                     goto LABEL_9;
                  }
                  v5 += 2;
                  v8 = 0;
            }
            v6 = Decode6BitMask[v5 - 2] & (v10 << v5);
            v8 = v8 + 8 - v5;
         LABEL_9:
            if (++v4 >= a3)
                  goto LABEL_12;
         }
      }
      v7 = 0;
LABEL_12:
      *a4 = v7;
      return buffer;
}

void DecryptCode(const char* sSignature)
{
      std::string Headerstr;
      std::string Codestr;
      std::string lpstr;
      char lpbuffer[0x1] = {};
      char lpCodebuffer[0x1] = {};
      uint32_t sRetsize = 0;
      std::vector<int> Code = PatternCode(sSignature);
      std::vector<int> buffer = Decode6BitBuf(Code, Code.size(), &sRetsize);

      if (buffer.size() == 36)
      {
         for (size_t i = 0; i < buffer.size(); i++)
         {
            sprintf(lpbuffer, "%02X ", buffer);

            Headerstr += lpbuffer;

         }
         vHeader = Headerstr;
         for (size_t i = buffer.size() + 12; i < Code.size(); i++)
         {
            sprintf(lpCodebuffer, "%02X ", Code);
            Codestr += lpCodebuffer;
            lpstr += char(Code);
         }
         vDecCode = vHeader + Codestr;
         vCode = Codestr;
         vString = UTF8_To_string(lpstr);

      }
      else
      {
         for (size_t i = 0; i < buffer.size(); i++)
         {
            if (i <= 35)
            {
                  sprintf(lpbuffer, "%02X ", buffer);
                  Headerstr += lpbuffer;

            }
            else if (i >= 36)
            {
                  sprintf(lpCodebuffer, "%02X ", buffer);
                  Codestr += lpCodebuffer;
                  lpstr += char(buffer);

            }
            vHeader = Headerstr;
            vDecCode = vHeader + Codestr;
            vCode = Codestr;
            vString = UTF8_To_string(lpstr);
         }
      }
}

void EncryptCode(std::string sSignature)
{
      std::string lpstr;
      char lpbuffer[0x1] = {};
      unsigned int sRetsize = 0;
      std::vector<int> code = PatternCode(sSignature.c_str());
      std::vector<int> buffer = Encode6BitBuf(code, code.size(), &sRetsize);
      vEnCode.clear();
      for (size_t i = 0; i < buffer.size(); i++)
      {
         sprintf(lpbuffer, "%02X ", buffer);
         lpstr += lpbuffer;

      }
      vEnCode = lpstr;
}

}

		自动登录	找回密码
密码			注册

[易语言] C转易语言

浏览过的版块