CSAW 2024 - Archeology

2025년 3월 28일
2분 읽기
Tags:
ctf,
reversing,
virtual machine

0x00. Introduction

➜  ls
chal  hieroglyphs.txt  message.txt
➜  file chal 
chal: ELF 64-bit LSB pie executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, BuildID[sha1]=bbcf6cbfa61b68c7b8bfa3145852d06580a55643, for GNU/Linux 3.2.0, not stripped

0x01. Concept

int __fastcall main(int argc, const char **argv, const char **envp)
{
  ...
  if ( argc == 2 )
  {
    *(_DWORD *)magic = 0xDDCCBBAA;
    magic[4] = 0xEE;
    plain = (char *)argv[1];
    plain_len = strlen(plain);
    index = 0;
    printf("Encrypted data: ");
    washing_machine(plain, plain_len);
    ...
  }
}

먼저 바이너리를 실행할 때 입력한 인자를 washing_machine()에 전달해서 실행한다.

int __fastcall main(int argc, const char **argv, const char **envp)
{
    ...
    for ( i = 0; i < plain_len; ++i )
    {
      buf[index] = 0; 
      buf[index + 1] = 1;
      buf[index + 2] = plain[i];
      index += 3;
      for ( j = 0; j <= 9; ++j )
      {
        buf[index] = 0; 
        buf[index + 1] = 0;
        buf[index + 2] = magic[(10 * i + j) % 5];
        buf[index + 3] = 8; 
        buf[index + 4] = 1;
        buf[index + 5] = 3;
        buf[index + 6] = 3; 
        buf[index + 7] = 1;
        buf[index + 8] = 1; 
        buf[index + 9] = 1;
        buf[index + 10] = 0;
        buf[index + 11] = 2; 
        buf[index + 12] = 1;
        buf[index + 13] = 3;
        index += 14;
      }
      buf[index] = 4; 
      buf[index + 1] = 1;
      buf[index + 2] = i;
      index += 3;
    }
    buf[index] = 7; 
    runnnn(buf);
    washing_machine((char *)memory, plain_len);
    ...
}

그 다음 washing_machine()에 의해 변경된 plain의 값을 buf에 한 바이트씩 템플릿처럼 넣어준다. 이 buf는 runnnn()의 인자로 들어가고, 함수 내부에서는 값에 맞는 동작을 수행한다.

말하자면 바이너리는 사전 정의된 instruction set을 가지는 virtual machine이고, buf에 값을 넣어주는 행위는 shellcode를 만들어주는 동작이라고 보면 된다.

Goal

int __fastcall main(int argc, const char **argv, const char **envp)
{
    ...
    stream = fopen("hieroglyphs.txt", "r");
    if ( stream )
    {
      for ( k = 0; fgets(&symbols[256 * k], 256, stream) && k <= 255; ++k )
        *(&savedregs + 256 * k + strcspn(&symbols[256 * k], "\n") - (char *)&unk_12730) = 0;
      fclose(stream);
      for ( m = 0; m < plain_len; ++m )
        printf("%s", &symbols[256 * memory[m]]);
      putchar(10);
      exit(0);
    }
    perror("Failed to open hieroglyphs.txt");
    return 1;
    ...
}

연산이 끝나면 hieroglyphs.txt를 읽어서 왜인지 모르겠지만 256바이트마다 상형문자의 유니코드 값을 로드한다. 그리고 memory의 값을 읽어 그 값 번째의 상형문자를 출력해준다.

말이 어려운데, memory[0]에 저장된 값이 123이라고 하면 123번째 상형문자를 출력해준다.

따라서 목표는 어떤 plaintext를 입력해야 message.txt에 쓰여진 내용이 출력되는지 역산하는 것이다.

0x02. Exploit

Ciphertext가 생성되는 과정을 pseudocode로 나타내면 다음과 같다.

tmp = washing_machine(plain)
shellcode = generate_shellcode(tmp)
runnnn(shellcode)
cipher = washing_machine(memory)

generate_shellcode()는 그렇다치고, washing_machine()과 runnnn()의 동작을 리버싱해야한다.

washing_machine

unsigned __int64 __fastcall washing_machine(char *data, unsigned __int64 data_len)
{
  ...
  curr = *data;
  for ( i = 1LL; i < data_len; ++i )
  {
    next = curr ^ data[i];
    data[i] = next;
    curr = next;
  }
  for ( j = 0LL; ; ++j )
  {
    result = data_len >> 1;
    if ( j >= data_len >> 1 )
      break;
    tmp = data[j];
    data[j] = data[data_len - j - 1];
    data[data_len - j - 1] = tmp;
  }
  return result;
}

다음과 같이 크게 두 가지 연산을 한다.

data[i] = data[i] ^ data[i + 1]
문자열 뒤집기

따라서 이 연산을 복호화하려면 다음과 같다.

def dewashing_machine(data):
    res = data[::-1]
    for i in range(len(res) - 1, 0, -1):
        res[i] = res[i] ^ res[i - 1]
    return res

runnnn

int __fastcall runnnn(__int64 start)
{
  ...
  cnt = 0;
  flag = 1;
  while ( flag )
  {
    index = cnt++;
    opcode = *(index + start);
    switch ( opcode )
    {
      case 0u:                                  // mov regs[op1], op2
        op1 = *(start + cnt);
        op2 = *(start + cnt + 1);
        cnt += 2;
        regs[op1] = op2;
        break;
      ...
      default:
        LODWORD(v2) = puts("Invalid instruction");
        flag = 0;
        break;
    }
  }
}

runnnn()은 위와 같은데, 다 보기엔 너무 많으니 정리하자면 다음과 같다.

opcode	instruction
0	`mov regs[op1], op2`
1	`xor regs[op1], regs[op2]`
2	`rol regs[op1], op2`
3	`sbox regs[op1]`
4	`mov memory[op2], regs[op1]`
8	`mov regs[op1], memory[op2]`
6	`print regs[op1]`
7	`exit`
8	`ror regs[op1], op2`

참고로 sbox regs[op1]은 sbox에서 regs[op1]에 담긴 값의 인덱스에 저장된 값을 가져오는 instruction이다. 이를 바탕으로 buf를 해석해보면 다음과 같다.

for ( i = 0; i < plain_len; ++i )
{
  mov regs[1], plain[i];
  for ( j = 0; j < 10; ++j )
  {
    mov regs[0], AA | BB | CC | DD | EE
    ror regs[1], 3
    sbox regs[1]
    xor regs[1], regs[0]
    rol regs[1], 3
  }
  mov memory[i], reg[1]
}
exit