2018 ROOT CTF Reversing Writeup
ROOT_Process_1
int sub_EA1860()
{
int v0; // edx
int v1; // ecx
int v2; // edx
int v3; // ecx
int v4; // edx
int v5; // ecx
int v6; // edx
int v7; // ecx
int v8; // edx
int v9; // ecx
int v10; // edx
int v11; // ecx
int v12; // edx
int v13; // ecx
int v14; // edx
int v15; // ecx
int v16; // edx
int v17; // edx
int v18; // ecx
int v19; // ST08_4
DWORD v21; // [esp+250h] [ebp-448h]
HWND hWnd; // [esp+25Ch] [ebp-43Ch]
int j; // [esp+268h] [ebp-430h]
CHAR *v24; // [esp+274h] [ebp-424h]
unsigned int i; // [esp+280h] [ebp-418h]
BOOL v26; // [esp+28Ch] [ebp-40Ch]
PROCESSENTRY32 pe; // [esp+298h] [ebp-400h]
char Dst[280]; // [esp+3C8h] [ebp-2D0h]
size_t v29; // [esp+4E0h] [ebp-1B8h]
int v30; // [esp+4ECh] [ebp-1ACh]
int v31; // [esp+4F8h] [ebp-1A0h]
int v32; // [esp+504h] [ebp-194h]
DWORD dwProcessId; // [esp+510h] [ebp-188h]
HANDLE hSnapshot; // [esp+528h] [ebp-170h]
int v35; // [esp+640h] [ebp-58h]
int v36; // [esp+644h] [ebp-54h]
int v37; // [esp+648h] [ebp-50h]
int v38; // [esp+64Ch] [ebp-4Ch]
int v39; // [esp+650h] [ebp-48h]
int v40; // [esp+654h] [ebp-44h]
int v41; // [esp+658h] [ebp-40h]
int v42; // [esp+65Ch] [ebp-3Ch]
int v43; // [esp+660h] [ebp-38h]
int v44; // [esp+664h] [ebp-34h]
int v45; // [esp+668h] [ebp-30h]
int v46; // [esp+66Ch] [ebp-2Ch]
int v47; // [esp+670h] [ebp-28h]
int v48; // [esp+674h] [ebp-24h]
int v49; // [esp+678h] [ebp-20h]
int v50; // [esp+67Ch] [ebp-1Ch]
int v51; // [esp+680h] [ebp-18h]
int v52; // [esp+684h] [ebp-14h]
int v53; // [esp+688h] [ebp-10h]
int v54; // [esp+68Ch] [ebp-Ch]
int v55; // [esp+694h] [ebp-4h]
int savedregs; // [esp+698h] [ebp+0h]
sub_EA1235(&unk_EAC017);
system("title Very_easy_Reversing!");
sub_EA123F(v1, v0);
v35 = 31;
v36 = 41;
v37 = 66;
v38 = 15;
v39 = 58;
v40 = 50;
v41 = 40;
v42 = 29;
v43 = 23;
v44 = 49;
v45 = 19;
v46 = 21;
v47 = 71;
v48 = 87;
v49 = 65;
v50 = 69;
v51 = 71;
v52 = 11;
v53 = 31;
v54 = 68;
hSnapshot = j_CreateToolhelp32Snapshot(2u, 0);
GetCurrentProcessId();
dwProcessId = sub_EA123F(v3, v2);
GetCurrentThread();
v32 = sub_EA123F(v5, v4);
OpenProcess(0x2000000u, 1, dwProcessId);
v31 = sub_EA123F(v7, v6);
GetCurrentProcessId();
v30 = sub_EA123F(v9, v8);
j_memset(Dst, 0, 0x104u);
if ( hSnapshot )
{
pe.dwSize = 296;
v26 = j_Process32First(hSnapshot, &pe);
while ( v26 )
{
v26 = j_Process32Next(hSnapshot, &pe);
v29 = j_strlen(pe.szExeFile);
for ( i = 0; i < 0x14; ++i )
pe.szExeFile[i] ^= *(&v35 + 4 * i);
j_memset(Dst, 0, 4u);
v24 = pe.szExeFile;
for ( j = 0; j < 20; ++j )
Dst[j] = v24[j];
FindWindowA(0, Dst);
hWnd = sub_EA123F(v11, v10);
if ( hWnd )
{
GetWindowThreadProcessId(hWnd, &v21);
sub_EA123F(v13, v12);
if ( v21 == v30 )
{
sub_EA104B("Correct\n");
system("pause");
sub_EA123F(v15, v14);
goto LABEL_15;
}
}
}
}
system("pause");
sub_EA123F(v18, v17);
LABEL_15:
sub_EA1262(&savedregs, &dword_EA1B9C, 0, v16);
return sub_EA123F(&savedregs ^ v55, v19);
}
중간에 보면 0x14길이 만큼 테이블값과 xor해주는 연산이 있다.
프로세스 이름과 *(&v35 + 4 * i)이 xor해준다.
table=[0x1f,0x29,0x42,0xf,0x3a,0x32,0x28,0x1d,0x17,0x31,0x13,0x15,0x47,0x57,0x41,0x45,0x47,0xb,0x1f,0x44]
process = "Very_easy_Reversing!"
print ''.join(chr(table[i]^ord(process[i])) for i in range(20))
FLAG : IL0veWInnnAp1236.exe
ROOT_Process_2
위에 변수가 9195개 선언되어있는데 생략했다.
너무 커서 헥스레이가 안돌아가는데 hexrays.cfg를 고쳐서 10000넘게 고쳐주면 헥스레이로 볼 수 있다.
memset(&Dst, 0, 0x44u);
ProcessHandle = 0;
ThreadHandle = 0;
v11 = 0;
v12 = 0;
Context.ContextFlags = 65543;
sub_401020("input : ", savedregs);
v9199 = &v14;
sub_401050("%[^\n]s", &v14);
GetModuleFileNameA(0, &Filename, 0x104u);
CreateProcessA(&Filename, 0, 0, 0, 0, 4u, 0, 0, &Dst, &ProcessHandle);
lpAddress = VirtualAlloc(0, 0x240Au, 0x3000u, 4u);
v9198 = &Src;
v9197 = lpAddress;
memcpy(lpAddress, &Src, 0x2400u);
if ( *lpAddress == 23117 )
{
v6 = lpAddress + lpAddress[15];
NtGetContextThread(ThreadHandle, &Context);
NtReadVirtualMemory(ProcessHandle, (Context.Ebx + 8), &Buffer, 4u, 0);
if ( Buffer == *(v6 + 52) )
NtUnmapViewOfSection(ProcessHandle, Buffer);
v9199 = 64;
v9198 = 12288;
v9197 = *(v6 + 80);
v9196 = *(v6 + 52);
BaseAddress = VirtualAllocEx(ProcessHandle, v9196, v9197, 0x3000u, 0x40u);
if ( BaseAddress )
{
v9199 = 0;
NtWriteVirtualMemory(ProcessHandle, BaseAddress, lpAddress, *(v6 + 84), 0);
for ( i = 0; i < *(v6 + 6); ++i )
{
v2 = (&lpAddress[10 * i + 62] + lpAddress[15]);
v9199 = 0;
NtWriteVirtualMemory(ProcessHandle, &BaseAddress[v2[3]], lpAddress + v2[5], v2[4], 0);
}
Context.Eax = &BaseAddress[*(v6 + 40)];
NtWriteVirtualMemory(ProcessHandle, (Context.Ebx + 8), (v6 + 52), 4u, 0);
NtSetContextThread(ThreadHandle, &Context);
NtResumeThread(ThreadHandle, 0);
NtWaitForSingleObject(ProcessHandle, 0, 0);
NtClose(ThreadHandle);
NtClose(ProcessHandle);
VirtualFree(lpAddress, 0, 0x8000u);
result = 0;
}
else
{
NtTerminateProcess(ProcessHandle, 1);
result = -1;
}
}
else
{
NtTerminateProcess(ProcessHandle, 1);
result = 1;
}
return result;
}
Codegate Open CTF에서도 나온 Process Hollowing 기법이다.
아래 처럼 동작한다. 나는 동적 디버깅해서 win32_remote.exe가 뜨는건데 그 밑에 ROOT_Process2.exe 보면 된다.
Process를 하나 생성해주니까 대충 생성되어 쓴 곳에서 브레이크 걸고 그때 프로세스 pid 가져와서 메모리 덤프 떠주면 된다.
그러면 그 덤프뜬 파일을 보면 제대로 덤프를 떠졌다.
signed int __cdecl sub_401000(int a1, int a2)
{
signed int result; // eax
int v3; // edi
int v4; // esi
char v5; // bl
char v6; // al
int v7; // esi
int v8; // eax
int v9; // edx
char v10[260]; // [esp+4h] [ebp-11Ch]
__int128 v11; // [esp+108h] [ebp-18h]
int v12; // [esp+118h] [ebp-8h]
char v13; // [esp+11Ch] [ebp-4h]
const char **v14; // [esp+128h] [ebp+8h]
srand(1u);
v12 = 139343166;
v13 = 123;
v11 = xmmword_402130;
if ( a1 == 1 )
{
MessageBoxA(0, "Incorrect", "ROOTCTF", 0);
result = -1;
}
else
{
v3 = a1 - 1;
v4 = 0;
if ( a1 - 1 > 0 )
{
v14 = (a2 + 4);
do
{
v5 = rand() % 127;
v6 = atoi(*v14);
++v14;
v10[v4++] = v5 ^ v6;
}
while ( v4 < v3 );
}
v7 = 0;
v8 = 0;
if ( v3 <= 0 )
goto LABEL_15;
do
{
v9 = v7 + 1;
if ( v10[v8] != *(&v11 + v8) )
v9 = v7;
++v8;
v7 = v9;
}
while ( v8 < v3 );
if ( v9 != 21 )
{
LABEL_15:
MessageBoxA(0, "Incorrect", "ROOTCTF", 0);
result = 0;
}
else
{
MessageBoxA(0, "Correct", "ROOTCTF", 0);
result = 0;
}
}
return result;
}
srand(1)이고 rand() % 127 값과 테이블이 xor 연산을 하는 것을 알 수 있다. 쉽게 역연산해서 구할 수 있다.
from ctypes import *
xmmword_402130 = [0x6f,0x78,0x2e,0x13,0x0c,0x35,0x00,0x7a,0x72,0x0f,0x44,0x20,0x62,0x5a,0x54,0x2e,0x3e,0x35,0x4e,0x08,0x7b]
libc = CDLL('msvcrt')
libc.srand(1)
flag = []
for i in range(len(xmmword_402130)):
flag.append(xmmword_402130[i]^(libc.rand()%127))
print ''.join(chr(flag[i]) for i in range(len(xmmword_402130)))
FLAG : FLAG{R0oT_1nJec@t1On}