BabyRE
有人昨天以为rc4用的就是空秘钥，那么他是谁呢
通过在字符串里找到DASCTF的关键字，一直交叉引用可以找到主要逻辑
这里注册的三个函数就是整个题的流程了
第一个函数里有输入，可以发现flag仅为0-9，然后还通过atexit注册了check函数，是一个很普通的rc4加密
第二个函数先在write_table里通过取反拿到了一个01234567的表，然后通过atexit注册了一个sha-1，但是好像有一些改动，猜测这里仅仅是一个验证
可以通过上面4个magic number初步确定其是sha-1加密
最后一部分先hook了GetLastError函数，然后注册了base8加密
大概是通过填充密码常量来hook的，这部分不重要
通过之前观察的table的值等可以发现是base8加密，并且只有这个函数访问过最开始输入的flag明文
综合一下上面得到的信息，现在就该动调了。
这里可以解出一段flag是915572239428449843076691286116796614
随后类似sha-1的加密部分并没法看出什么东西
rc4的部分，可以看到key的长度为6，密文长度为112，但点进key后什么是一串0，昨天赛中做的有点急，以为真的是空秘钥，复现的时候发现：
上面那串是我们输入的flag，数了一下发现是42位，下面空的0是因为我的输入只有30位。
联系一下上面rc4部分，很容易想到：flag一共48位，并且使用flag后6位作为rc4的密钥。
现在的形式很明显了：由于密钥仅6位，我们爆破rc4密钥并反解密文后再解一次base8，如果解出来是明文那就符合要求
#include <bits/stdc++.h>
using namespace std;
void init(int *s, char *key, int len)
{
int t[256] = {0};
char tmp = 0;
for (int i = 0; i < 256; ++i)
{
s[i] = i;
t[i] = key[i % len];
}
int j = 0;
for (int i = 0; i < 256; ++i)
{
j = (j + s[i] + t[i]) % 256;
swap(s[i], s[j]);
}
}
void crypt(int *s, char *data, int len)
{
int i = 0, j = 0, t = 0;
char tmp;
for (int k = 0; k < len; ++k)
{
i = (i + 1) % 256;
j = (j + s[i]) % 256;
swap(s[i], s[j]);
t = (s[i] + s[j]) % 256;
data[k] ^= s[t];
}
}
int cip[2333] =
{
63, 149, 187, 242, 87, 241, 122, 90, 34, 97,
81, 67, 162, 250, 155, 111, 68, 99, 192, 8,
18, 101, 92, 138, 140, 76, 237, 94, 202, 118,
185, 133, 175, 5, 56, 237, 66, 62, 66, 223,
93, 190, 5, 139, 53, 109, 243, 28, 207, 248,
106, 115, 37, 228, 183, 185, 54, 251, 2, 17,
160, 240, 87, 171, 33, 198, 199, 70, 153, 189,
30, 97, 94, 238, 85, 24, 238, 3, 41, 132,
127, 148, 95, 180, 106, 41, 216, 108, 228, 192,
157, 107, 204, 213, 148, 92, 221, 204, 213, 61,
192, 239, 12, 41, 229, 176, 147, 241, 179, 222,
176, 112
};
char data[2333];
char key[2333];
int s[260];
void check()
{
for (int i = 0; i < 112; ++i)
{
if (data[i] < 32 || data[i] > 127) return;
}
printf("Key: %s\nData: %s\n", key, data);
}
void dfs(char now, int dep)
{
key[dep] = now;
if (dep == 5)
{
init(s, key, 6);
int len = 112;
for (int i = 0; i < len; ++i) data[i] = cip[i];
crypt(s, data, len);
check();
return;
}
for (int i = '0'; i <= '9'; ++i) dfs(i, dep + 1);
}
int main()
{
for (int i = '0'; i <= '9'; ++i) dfs(i, 0);
return 0;
}
把data用base8解码，再把key拼在后面，得到flag：DASCTF{561516915572239428449843076691286116796614807391}
Dual Personality
前面以为是加了一大堆反调试，后面发现只有32位切64位这一个反调试
在sub_401120之后会出现类似smc的变化
这里会变成jmp far ptr，这句话会远跳转到33:4011D0这个地址。远跳转有一个隐形的操作，他会将代码段寄存器CS设置为跳转到的这个段对应的段选择子，这里执行完了远跳转之后CS的值会变为0x33，熟悉天堂之门等玩意的话应该马上能联想到这里会切成64位程序。
随后我们从4011D0开始，把0全部nop掉，创建函数后就能勉强看见加密流程了
然后就跟着破碎的流程勉强走一次吧
#include <bits/stdc++.h>
using namespace std;
typedef unsigned int uint32;
typedef unsigned int uint;
typedef unsigned long long uint64;
#define _DWORD uint32
#define _QWORD uint64
template<class T> T __ROL__(T value, uint count)
{
const uint nbits = sizeof(T) * 8;
count %= nbits;
T high = value >> (nbits - count);
value <<= count;
value |= high;
return value;
}
template<class T> T __ROR__(T value, uint count)
{
const uint nbits = sizeof(T) * 8;
count %= nbits;
T low = value << (nbits - count);
value >>= count;
value |= low;
return value;
}
_DWORD flag[9];
_DWORD dword_407058 = 0x5DF966AE;
_DWORD key[] = {0x9D, 0x44, 0x37, 0xB5};
int main()
{
// Encrypt Part
/*
strcpy((char *)flag, "0123456789012345678901");
// sub_4011FE
*(_QWORD *)((char *)flag) = __ROL__(*(_QWORD *)((char *)flag), 12);
*(_QWORD *)((char *)flag + 8) = __ROL__(*(_QWORD *)((char *)flag + 8), 34);
*(_QWORD *)((char *)flag + 16) = __ROL__(*(_QWORD *)((char *)flag + 16), 56);
*(_QWORD *)((char *)flag + 24) = __ROL__(*(_QWORD *)((char *)flag + 24), 14);
// sub_4013EF
dword_407058 -= 0x21524111;
for (int i = 0; i < 8; ++i)
{
flag[i] += dword_407058;
dword_407058 ^= flag[i];
}
// sub_40128B
key[0] &= key[1];
key[1] |= key[2];
key[2] ^= key[3];
key[3] = ~key[3];
// sub_40146E
for (int i = 0; i < 32; ++i) *((char*)flag + i) ^= key[i % 4];
*/
char enflag[] = {0xAA, 0x4F, 0x0F, 0xE2, 0xE4, 0x41, 0x99, 0x54, 0x2C, 0x2B, 0x84, 0x7E, 0xBC, 0x8F, 0x8B, 0x78, 0xD3, 0x73, 0x88, 0x5E, 0xAE, 0x47, 0x85, 0x70, 0x31, 0xB3, 0x09, 0xCE, 0x13, 0xF5, 0x0D, 0xCA};
for (int i = 0; i < 8; ++i) flag[i] = *(_DWORD *)(enflag + (4 * i));
key[0] &= key[1];
key[1] |= key[2];
key[2] ^= key[3];
key[3] = ~key[3];
for (int i = 0; i < 32; ++i) *((char *)flag + i) ^= key[i % 4];
*(_QWORD *)((char *)flag + 24) = __ROR__(*(_QWORD *)((char *)flag + 24), 14);
*(_QWORD *)((char *)flag + 16) = __ROR__(*(_QWORD *)((char *)flag + 16), 56);
*(_QWORD *)((char *)flag + 8) = __ROR__(*(_QWORD *)((char *)flag + 8), 34);
*(_QWORD *)((char *)flag) = __ROR__(*(_QWORD *)((char *)flag), 12);
dword_407058 -= 0x21524111;
for (int i = 0; i < 8; ++i)
{
_DWORD tmp = flag[i];
flag[i] -= dword_407058;
dword_407058 ^= tmp;
}
cout << (char*) flag << endl;
}
逆算法的时候发现好像前面看加密的时候的顺序有点不对劲，不知道为什么，但至少做出来了（
DASCTF{6cc1e44811647d38a15017e389b3f704}
Berkeley
赛中费了很大的功夫去配bpf程序的编写环境，以为能动调，然后发现屁用没有，笑嘻了
标签：__,QWORD,Reverse,int,初赛,char,flag,key,论剑 From： https://www.cnblogs.com/Here-is-SG/p/17090521.html