Reversing on My Life

[Dreamhack] REV Small Counter

Wed, 31 May 2023 09:00:00 +0900

이번 문제는 Dreamhack CTF Season 3 Round #4 (🌱Div2)에 출제된 리버싱 문제이다. 오랜만에 풀어보는 리버싱 문제인데, 리눅스 기반 ELF 바이너리다. 일단 실행시켜보자.

root@dig06161-virtual-machine:/home/dig06161/file/dreamhack/Small_Counter# ./chall
---Counter---
10
9
8
7
6
5
4
3
2
1
---END---
root@dig06161-virtual-machine:/home/dig06161/file/dreamhack/Small_Counter#

10부터 1까지 출력한다. 여기서 flag를 출력하는 부분을 찾아 실행해야 할 것 같다. 우선 ghidra를 통해 바이너리를 열어보자. main함수의 어셈블리와 디컴파일 코드는 다음과 같다.

0x0000555555555494 <+0>:     endbr64 
   0x0000555555555498 <+4>:     push   rbp
   0x0000555555555499 <+5>:     mov    rbp,rsp
   0x000055555555549c <+8>:     sub    rsp,0xf0
   0x00005555555554a3 <+15>:    mov    DWORD PTR [rbp-0x4],0x0
   0x00005555555554aa <+22>:    lea    rax,[rip+0xb53]        # 0x555555556004
   0x00005555555554b1 <+29>:    mov    rdi,rax
   0x00005555555554b4 <+32>:    call   0x555555555090 <puts@plt>
   0x00005555555554b9 <+37>:    mov    DWORD PTR [rbp-0x4],0xa
   0x00005555555554c0 <+44>:    jmp    0x5555555555a0 <main+268>
   0x00005555555554c5 <+49>:    mov    eax,DWORD PTR [rbp-0x4]
   0x00005555555554c8 <+52>:    mov    esi,eax
   0x00005555555554ca <+54>:    lea    rax,[rip+0xb41]        # 0x555555556012
   0x00005555555554d1 <+61>:    mov    rdi,rax
   0x00005555555554d4 <+64>:    mov    eax,0x0
   0x00005555555554d9 <+69>:    call   0x5555555550b0 <printf@plt>
   0x00005555555554de <+74>:    cmp    DWORD PTR [rbp-0x4],0x3
   0x00005555555554e2 <+78>:    jne    0x55555555559c <main+264>
   0x00005555555554e8 <+84>:    movabs rax,0x38383830357b4d49
   0x00005555555554f2 <+94>:    movabs rdx,0x6a37386a32336a39
   0x00005555555554fc <+104>:   mov    QWORD PTR [rbp-0xf0],rax
   0x0000555555555503 <+111>:   mov    QWORD PTR [rbp-0xe8],rdx
   0x000055555555550a <+118>:   movabs rax,0x3035363435676a39
   0x0000555555555514 <+128>:   movabs rdx,0x6a68383234303438
   0x000055555555551e <+138>:   mov    QWORD PTR [rbp-0xe0],rax
   0x0000555555555525 <+145>:   mov    QWORD PTR [rbp-0xd8],rdx
   0x000055555555552c <+152>:   movabs rax,0x6838306969326968
   0x0000555555555536 <+162>:   movabs rdx,0x3833356a68693437
   0x0000555555555540 <+172>:   mov    QWORD PTR [rbp-0xd0],rax
   0x0000555555555547 <+179>:   mov    QWORD PTR [rbp-0xc8],rdx
   0x000055555555554e <+186>:   movabs rax,0x3667376a33343568
   0x0000555555555558 <+196>:   movabs rdx,0x68696a386b6a356b
   0x0000555555555562 <+206>:   mov    QWORD PTR [rbp-0xc0],rax
   0x0000555555555569 <+213>:   mov    QWORD PTR [rbp-0xb8],rdx
   0x0000555555555570 <+220>:   mov    DWORD PTR [rbp-0xb0],0x7d663232
   0x000055555555557a <+230>:   mov    BYTE PTR [rbp-0xac],0x0
   0x0000555555555581 <+237>:   lea    rcx,[rbp-0xf0]
   0x0000555555555588 <+244>:   lea    rax,[rbp-0x50]
   0x000055555555558c <+248>:   mov    edx,0x45
   0x0000555555555591 <+253>:   mov    rsi,rcx
   0x0000555555555594 <+256>:   mov    rdi,rax
   0x0000555555555597 <+259>:   call   0x5555555550c0 <memcpy@plt>
   0x000055555555559c <+264>:   sub    DWORD PTR [rbp-0x4],0x1
   0x00005555555555a0 <+268>:   cmp    DWORD PTR [rbp-0x4],0x0
   0x00005555555555a4 <+272>:   jg     0x5555555554c5 <main+49>
   0x00005555555555aa <+278>:   cmp    DWORD PTR [rbp-0x4],0x5
   0x00005555555555ae <+282>:   jne    0x5555555555fe <main+362>
   0x00005555555555b0 <+284>:   lea    rax,[rip+0xa5f]        # 0x555555556016
   0x00005555555555b7 <+291>:   mov    rdi,rax
   0x00005555555555ba <+294>:   call   0x555555555090 <puts@plt>
   0x00005555555555bf <+299>:   mov    eax,DWORD PTR [rbp-0x4]
   0x00005555555555c2 <+302>:   mov    DWORD PTR [rbp-0x8],eax
   0x00005555555555c5 <+305>:   mov    edx,DWORD PTR [rbp-0x8]
   0x00005555555555c8 <+308>:   lea    rcx,[rbp-0xa0]
   0x00005555555555cf <+315>:   lea    rax,[rbp-0x50]
   0x00005555555555d3 <+319>:   mov    rsi,rcx
   0x00005555555555d6 <+322>:   mov    rdi,rax
   0x00005555555555d9 <+325>:   call   0x5555555551c9 <flag_gen>
   0x00005555555555de <+330>:   lea    rax,[rbp-0xa0]
   0x00005555555555e5 <+337>:   mov    rsi,rax
   0x00005555555555e8 <+340>:   lea    rax,[rip+0xa2d]        # 0x55555555601c
   0x00005555555555ef <+347>:   mov    rdi,rax
   0x00005555555555f2 <+350>:   mov    eax,0x0
   0x00005555555555f7 <+355>:   call   0x5555555550b0 <printf@plt>
   0x00005555555555fc <+360>:   jmp    0x55555555560d <main+377>
   0x00005555555555fe <+362>:   lea    rax,[rip+0xa1c]        # 0x555555556021
   0x0000555555555605 <+369>:   mov    rdi,rax
   0x0000555555555608 <+372>:   call   0x555555555090 <puts@plt>
   0x000055555555560d <+377>:   mov    eax,0x0
   0x0000555555555612 <+382>:   leave  
   0x0000555555555613 <+383>:   ret

undefined8 main(void)

{
  undefined8 local_f8;
  undefined8 local_f0;
  undefined8 local_e8;
  undefined8 local_e0;
  undefined8 local_d8;
  undefined8 local_d0;
  undefined8 local_c8;
  undefined8 local_c0;
  undefined4 local_b8;
  undefined local_b4;
  undefined local_a8 [80];
  char local_58 [72];
  uint local_10;
  uint local_c;
  
  local_c = 0;
  puts("---Counter---");
  for (local_c = 10; 0 < (int)local_c; local_c = local_c - 1) {
    printf("%d\n",(ulong)local_c);
    if (local_c == 3) {
      local_f8 = 0x38383830357b4d49;
      local_f0 = 0x6a37386a32336a39;
      local_e8 = 0x3035363435676a39;
      local_e0 = 0x6a68383234303438;
      local_d8 = 0x6838306969326968;
      local_d0 = 0x3833356a68693437;
      local_c8 = 0x3667376a33343568;
      local_c0 = 0x68696a386b6a356b;
      local_b8 = 0x7d663232;
      local_b4 = 0;
      memcpy(local_58,&local_f8,0x45);
    }
  }
  if (local_c == 5) {
    puts("Nice!");
    local_10 = local_c;
    flag_gen(local_58,(long)local_a8,local_c);
    printf("\n%s\n",local_a8);
  }
  else {
    puts("---END---");
  }
  return 0;
}

코드를 분석해보면 플레그를 만들어주는 함수는 flag_gen 함수이고 for 가 동작하는 반복문과 별개의 코드로 if가 동작해야지 플래그를 출력한다. if가 동작하기 위해서는 반복문이 끝난 후 local_c가 5를 가지고 있어야 동작한다. 다만 반복문이 종료되면 local_c가 0을 가지게 된다. 따라서 gdb를 통해 bp를 반복분이 끝나는 시점에 걸고 local_c 값을 강제로 5로 바꾸면 풀 수 있을 것이다.

다만 바이너리에 bp를 걸면 좀 이상하게 동작한다. PIE가 걸려있어 바이너리를 실행할 때 마다 주소값이 바뀌는 문제가 있다. gdb에서는 디버깅의 편의를 위해 PIE 보호기법이 걸린 바이너리는 코드영역 주소값을 0x555555555000로 가진다. 따라서 한번 실행한 후 main함수를 disass 하면 0x0000555555555494주소를 가진다. 이 부분에 bp를 걸고 이후 main+278부분에 bp를 걸어주면 중단지점을 설정할 수 있다. 이후 set 기능을 이용해 rbp - 4 부분을 5로 쓰면 플래그를 얻을 수 있다.

pwndbg> $rbp-4
Undefined command: "$rbp-4".  Try "help".
pwndbg> p $rbp-4
$1 = (void *) 0x7fffffffe32c
pwndbg> x/x 0x7fffffffe32c
0x7fffffffe32c: 0x00000000
pwndbg> set *0x7fffffffe32c=5
pwndbg> x/x 0x7fffffffe32c
0x7fffffffe32c: 0x00000005
pwndbg> c
Continuing.
Nice!

DH{389998e56e90e8eb34238948469ce중략...}
[Inferior 1 (process 48876) exited normally]
pwndbg>

Dreamhack rev-basic-7 문제풀이

Sun, 01 May 2022 06:30:00 +0900

이번 문제는 드림핵 rev-basic-7 리버싱 문제를 풀어보자.

우선 basic-6과 동일하게 문자열을 입력 받고 정답이면 Correct, 아니면 Wrong을 출력한다. 바이너리 실행결과는 다음과 같다.

우선 가장 먼저 해야할 일은 main함수를 찾는것이다. 윈도우 바이너리인 PE파일의 헤더 구조를 보면 매우 많은 정보들이 들어있다. 그것들 중 리버싱을 할떄 중점으로 봐야할 부분은 .text영역이다. 실질적으로 코드가 컴파일되어 저장되는 영역으로 대부분의 main함수는 이 영역 시작 지점과 인접하게 존재한다. 컴파일러의 보안 미티게이션의 추가로 메모리 주소 랜덤화가 자동으로 걸려 0x401000주소에 main이 들어가는 경우는 이젠 없을 것이다.

바이너리는 input : 과 Wrong 이라는 문자열을 출력했다. 따라서 문자열 검사를 통해 해당 문자열이 사용되는 지점을 찾아 BP를 걸어준다.

00007FF7CEE21090 | 40:57                    | push rdi                                |
00007FF7CEE21092 | 48:81EC 30010000         | sub rsp,130                             |
00007FF7CEE21099 | 48:8B05 881F0000         | mov rax,qword ptr ds:[7FF7CEE23028]     |
00007FF7CEE210A0 | 48:33C4                  | xor rax,rsp                             |
00007FF7CEE210A3 | 48:898424 20010000       | mov qword ptr ss:[rsp+120],rax          |
00007FF7CEE210AB | 48:8D4424 20             | lea rax,qword ptr ss:[rsp+20]           |
00007FF7CEE210B0 | 48:8BF8                  | mov rdi,rax                             |
00007FF7CEE210B3 | 33C0                     | xor eax,eax                             |
00007FF7CEE210B5 | B9 00010000              | mov ecx,100                             |
00007FF7CEE210BA | F3:AA                    | rep stosb                               |
00007FF7CEE210BC | 48:8D0D 4D110000         | lea rcx,qword ptr ds:[7FF7CEE22210]     | rcx:"asdf", 00007FF7CEE22210:"Input : "
00007FF7CEE210C3 | E8 58000000              | call chall7.7FF7CEE21120                |
00007FF7CEE210C8 | 48:8D5424 20             | lea rdx,qword ptr ss:[rsp+20]           |
00007FF7CEE210CD | 48:8D0D 48110000         | lea rcx,qword ptr ds:[7FF7CEE2221C]     | rcx:"asdf", 00007FF7CEE2221C:"%256s"
00007FF7CEE210D4 | E8 D7000000              | call chall7.7FF7CEE211B0                |
00007FF7CEE210D9 | 48:8D4C24 20             | lea rcx,qword ptr ss:[rsp+20]           |
00007FF7CEE210DE | E8 1DFFFFFF              | call chall7.7FF7CEE21000                |
00007FF7CEE210E3 | 85C0                     | test eax,eax                            |
00007FF7CEE210E5 | 74 0F                    | je chall7.7FF7CEE210F6                  |
00007FF7CEE210E7 | 48:8D0D 3A110000         | lea rcx,qword ptr ds:[7FF7CEE22228]     | rcx:"asdf", 00007FF7CEE22228:"Correct"
00007FF7CEE210EE | FF15 94100000            | call qword ptr ds:[<&puts>]             |
00007FF7CEE210F4 | EB 0D                    | jmp chall7.7FF7CEE21103                 |
00007FF7CEE210F6 | 48:8D0D 33110000         | lea rcx,qword ptr ds:[7FF7CEE22230]     | rcx:"asdf", 00007FF7CEE22230:"Wrong"
00007FF7CEE210FD | FF15 85100000            | call qword ptr ds:[<&puts>]             |
00007FF7CEE21103 | 33C0                     | xor eax,eax                             |
00007FF7CEE21105 | 48:8B8C24 20010000       | mov rcx,qword ptr ss:[rsp+120]          |
00007FF7CEE2110D | 48:33CC                  | xor rcx,rsp                             |
00007FF7CEE21110 | E8 AB010000              | call chall7.7FF7CEE212C0                |
00007FF7CEE21115 | 48:81C4 30010000         | add rsp,130                             |
00007FF7CEE2111C | 5F                       | pop rdi                                 |
00007FF7CEE2111D | C3                       | ret                                     |

해당 문제는 올바른 값을 입력하면 Corrent라는 문구가 출력되며 입력한 값이 flag가 되는 문제이다. 따라서 바이너리 역분석을 통해 적절한 입력값을 찾아야 한다.

우선 테스트 값으로 aaaaaaaaaaa라는 문자열을 입력하고 이를 검사하는 부분을 찾아야 한다. 어셈블리를 살펴보면

00007FF7CEE210D9 | 48:8D4C24 20             | lea rcx,qword ptr ss:[rsp+20]           |
00007FF7CEE210DE | E8 1DFFFFFF              | call chall7.7FF7CEE21000                |
00007FF7CEE210E3 | 85C0                     | test eax,eax                            |
00007FF7CEE210E5 | 74 0F                    | je chall7.7FF7CEE210F6                  |

위와 같은 부분이 존재한다. 함수를 Call하고 test를 통한 eax 초기화 후 je를 통해 분기하는 것을 알 수 있다. 따라서 Call 하는 chall7.7FF7CEE21000 부분이 문자열을 검사하는 곳이라고 추측할 수 있다.

해당 부분의 어셈블리는 다음과 같다.

00007FF7CEE21000 | 48:894C24 08             | mov qword ptr ss:[rsp+8],rcx            |
00007FF7CEE21005 | 48:83EC 18               | sub rsp,18                              |
00007FF7CEE21009 | C70424 00000000          | mov dword ptr ss:[rsp],0                |
00007FF7CEE21010 | EB 08                    | jmp chall7.7FF7CEE2101A                 |
00007FF7CEE21012 | 8B0424                   | mov eax,dword ptr ss:[rsp]              |
00007FF7CEE21015 | FFC0                     | inc eax                                 |
00007FF7CEE21017 | 890424                   | mov dword ptr ss:[rsp],eax              |
00007FF7CEE2101A | 48:630424                | movsxd rax,dword ptr ss:[rsp]           |
00007FF7CEE2101E | 48:83F8 1F               | cmp rax,1F                              |
00007FF7CEE21022 | 73 41                    | jae chall7.7FF7CEE21065                 |
00007FF7CEE21024 | 8B0424                   | mov eax,dword ptr ss:[rsp]              |
00007FF7CEE21027 | 83E0 07                  | and eax,7                               |
00007FF7CEE2102A | 48:630C24                | movsxd rcx,dword ptr ss:[rsp]           |
00007FF7CEE2102E | 48:894C24 08             | mov qword ptr ss:[rsp+8],rcx            |
00007FF7CEE21033 | 48:8B5424 20             | mov rdx,qword ptr ss:[rsp+20]           | [rsp+20]:"aaaaaaaaaaa"
00007FF7CEE21038 | 0FB6C8                   | movzx ecx,al                            |
00007FF7CEE2103B | 48:8B4424 08             | mov rax,qword ptr ss:[rsp+8]            |
00007FF7CEE21040 | 0FB60402                 | movzx eax,byte ptr ds:[rdx+rax]         |
00007FF7CEE21044 | D2C0                     | rol al,cl                               |
00007FF7CEE21046 | 0FB6C0                   | movzx eax,al                            |
00007FF7CEE21049 | 330424                   | xor eax,dword ptr ss:[rsp]              |
00007FF7CEE2104C | 48:630C24                | movsxd rcx,dword ptr ss:[rsp]           |
00007FF7CEE21050 | 48:8D15 A91F0000         | lea rdx,qword ptr ds:[7FF7CEE23000]     |
00007FF7CEE21057 | 0FB60C0A                 | movzx ecx,byte ptr ds:[rdx+rcx]         |
00007FF7CEE2105B | 3BC1                     | cmp eax,ecx                             |
00007FF7CEE2105D | 74 04                    | je chall7.7FF7CEE21063                  |
00007FF7CEE2105F | 33C0                     | xor eax,eax                             |
00007FF7CEE21061 | EB 07                    | jmp chall7.7FF7CEE2106A                 |
00007FF7CEE21063 | EB AD                    | jmp chall7.7FF7CEE21012                 |
00007FF7CEE21065 | B8 01000000              | mov eax,1                               |
00007FF7CEE2106A | 48:83C4 18               | add rsp,18                              |
00007FF7CEE2106E | C3                       | ret                                     |

어셈블리를 살펴보면 처음보는 명령어가 있다. 바로 rol이라는 연산인데, 쉬프트 연산의 일종이다. al 레지스터의 값을 cl레지스터 값 만큼 rol연산 해 al 레지스터에 저장하는 연산이다. 일반적인 쉬프트 연산에서 자리수를 넘어가는 값이 나오면 그 수는 그냥 버려지는것이 일반적이지만 ROL(왼쪽)과 ROR(오른쪽)연산의 경우 마지막 자리수에서 쉬프트 연산을 통해 자리올림이 발생했을 때, 반대쪽 자리로 옮겨 올라간 자리를 표시한다.

예를 들면 이렇다. al, cl은 각각 8비트의 길이를 가지고 있기 때문에 8비트로 설명을 해보겠다. 0000 0001을 ROL연산을 하면 0000 0010이 된다. 다만 0000 0001을 ROR연산을 하면 1000 0000이 된다. 이것이 일반적인 쉬프트 연산과 다른점이다.

해당 로직을 실행시켜 레지스터 값 변화와 같이 분석해보면 다음과 같다. 입력한 문자열이 저장된 스택 시작주소에서 반복문 횟수 만큼 값을 더해 결과적으로 각 자리 문자를 가져와 al 레지스터에 저장하는 역할을 한다. 이후 반복분의 횟수는 cl레지스터에 저장되며 al 레지스터에 저장된 값을 cl 레지스터 값 만큼 rol연산한 후 반복분 횟수와 XOR연산해 EAX에 저장한다. 이후 스텍에 저장된 정답 문자열 주소에 반복분 횟수 만큼 더한 자리의 값을 가져와 ECX에 저장한다. EAX와 ECX를 비교 후 같지 않으면 0을 리턴하고 같으면 jmp를 통해 다음 자리의 문자를 검사한다.

(각 자리수의 hex값 ROL 자리수(몇번째 자리인지)) XOR 자리수(몇번째 자리인지) == 비교대상 정답
위 값이 참일경우 반복문 동작, 거짓일 경우 0을 리턴하고 main함수에서 Wrong을 출력

# 입력된 문자열만큼 반복
# 자리수는 0부터 시작후 1씩 증가
# 결과 값을 7FF7CEE23000에 위치한 hex값과 비교해 정답 유무 확인

위 수식을 입력 받은 글자 수 만큼 반복하면서 비교한다. XOR의 경우 A ⊕ B = C와 A ⊕ C = B가 성립하므로 위 수식의 역을 구하면 다음과 같다.

(비교대상 정답 XOR 자리수) ROR 자리수 = 각 자리수의 hex값

위 수식을 검산하면서 간과했던 점이 al, cl 레지스터는 8비트 크기를 가지지만 윈도우 계산기의 기본 설정은 QWORD로 64비트의 자리수를 가지고 있다. 따라서 계산기로 검증하면서 byte로 설정을 바꾸어 계산을 진행했다.

이제 파이썬 코드를 작성해보자

def ROL(data, shift, size=8):
        shift %= size
        remains = data >> (size - shift)
        body = (data << shift) - (remains << size )
        return (body + remains)

def ROR(data, shift, size=8):
        shift %= size
        body = data >> shift
        remains = (data << (size - shift)) - (body << size)
        return (body + remains)

a = [0x52, 0xDF, 0xB3, 0x60, 0xF1, 0x8B, 0x1C, 0xB5, 0x57, 0xD1, 0x9F, 0x38, 0x4B, 0x29, 0xD9, 0x26
, 0x7F, 0xC9, 0xA3, 0xE9, 0x53, 0x18, 0x4F, 0xB8, 0x6A, 0xCB, 0x87, 0x58, 0x5B, 0x39, 0x1E]
b = 0
temp = ""

for i in a:
        temp = (i ^ b)
        temp = ROR(temp, b)
        print(chr(temp), end='')
        b = b + 1
""

찾아보니 파이썬에는 ROL, ROR 연산 함수가 없어 https://bbolmin.tistory.com/133 블로그에서 코드를 빌려왔다. 감사하게도 ROL, ROR 코드를 작성해 올려주셨다.

위 코드를 보면 ROR 함수에 size 값이 8인것을 볼 수 있다. 이 또한 al의 크기인 8비트를 맞춰주기 위해 코드를 수정했다.

a의 리스트 값은 입력값과 비교하는 데이터로 7FF7CEE23000 위치에서 가져왔다.

위 코드를 돌리면 플레그를 얻을 수 있다.

Dreamhack rev-basic-6 문제풀이

Wed, 13 Apr 2022 18:30:00 +0900

이번에는 드림핵 리버싱 베이직 6번 문제를 풀어보자.

이전에 올렸던 rev-basic-5 문제와 동일하게 바이너리를 실행 시키면

input :

이라는 문자열과 함께 문자열을 입력 받고 정답이면 Correct, 아니면 Wrong을 출력한다.

우선 동일하게 x64 디버거를 이용해 어셈블리를 분석해보자.

해당 프로그램 main의 어셈블리는 다음과 같다.

00007FF782681120 | 40:57                    | push rdi                                | rdi:&"ALLUSERSPROFILE=C:\\ProgramData"
00007FF782681122 | 48:81EC 30010000         | sub rsp,130                             |
00007FF782681129 | 48:8B05 F81F0000         | mov rax,qword ptr ds:[7FF782683128]     |
00007FF782681130 | 48:33C4                  | xor rax,rsp                             |
00007FF782681133 | 48:898424 20010000       | mov qword ptr ss:[rsp+120],rax          |
00007FF78268113B | 48:8D4424 20             | lea rax,qword ptr ss:[rsp+20]           |
00007FF782681140 | 48:8BF8                  | mov rdi,rax                             | rdi:&"ALLUSERSPROFILE=C:\\ProgramData"
00007FF782681143 | 33C0                     | xor eax,eax                             |
00007FF782681145 | B9 00010000              | mov ecx,100                             |
00007FF78268114A | F3:AA                    | rep stosb                               |
00007FF78268114C | 48:8D0D BD100000         | lea rcx,qword ptr ds:[7FF782682210]     | 00007FF782682210:"Input : "
00007FF782681153 | E8 58000000              | call chall6.7FF7826811B0                |
00007FF782681158 | 48:8D5424 20             | lea rdx,qword ptr ss:[rsp+20]           |
00007FF78268115D | 48:8D0D B8100000         | lea rcx,qword ptr ds:[7FF78268221C]     | 00007FF78268221C:"%256s"
00007FF782681164 | E8 A7000000              | call chall6.7FF782681210                |
00007FF782681169 | 48:8D4C24 20             | lea rcx,qword ptr ss:[rsp+20]           |
00007FF78268116E | E8 8DFEFFFF              | call chall6.7FF782681000                |
00007FF782681173 | 85C0                     | test eax,eax                            |
00007FF782681175 | 74 0F                    | je chall6.7FF782681186                  |
00007FF782681177 | 48:8D0D AA100000         | lea rcx,qword ptr ds:[7FF782682228]     | 00007FF782682228:"Correct"
00007FF78268117E | FF15 04100000            | call qword ptr ds:[<&puts>]             |
00007FF782681184 | EB 0D                    | jmp chall6.7FF782681193                 |
00007FF782681186 | 48:8D0D A3100000         | lea rcx,qword ptr ds:[7FF782682230]     | 00007FF782682230:"Wrong"
00007FF78268118D | FF15 F50F0000            | call qword ptr ds:[<&puts>]             |
00007FF782681193 | 33C0                     | xor eax,eax                             |
00007FF782681195 | 48:8B8C24 20010000       | mov rcx,qword ptr ss:[rsp+120]          |
00007FF78268119D | 48:33CC                  | xor rcx,rsp                             |
00007FF7826811A0 | E8 5B010000              | call chall6.7FF782681300                |
00007FF7826811A5 | 48:81C4 30010000         | add rsp,130                             |
00007FF7826811AC | 5F                       | pop rdi                                 | rdi:&"ALLUSERSPROFILE=C:\\ProgramData"
00007FF7826811AD | C3                       | ret                                     |

여기서 정답의 로직을 분석하는 부분은 00007FF78268116E이다.

테스트로 AAAAA를 입력한 뒤, 위 주소부분의 어셈블리를 살펴보자.

00007FF782681000 | 48:894C24 08             | mov qword ptr ss:[rsp+8],rcx            | [rsp+8]:"%256s"
00007FF782681005 | 48:83EC 18               | sub rsp,18                              |
00007FF782681009 | C70424 00000000          | mov dword ptr ss:[rsp],0                |
00007FF782681010 | EB 08                    | jmp chall6.7FF78268101A                 |
00007FF782681012 | 8B0424                   | mov eax,dword ptr ss:[rsp]              |
00007FF782681015 | FFC0                     | inc eax                                 |
00007FF782681017 | 890424                   | mov dword ptr ss:[rsp],eax              |
00007FF78268101A | 48:630424                | movsxd rax,dword ptr ss:[rsp]           |
00007FF78268101E | 48:83F8 12               | cmp rax,12                              |
00007FF782681022 | 73 31                    | jae chall6.7FF782681055                 |
00007FF782681024 | 48:630424                | movsxd rax,dword ptr ss:[rsp]           |
00007FF782681028 | 48:8B4C24 20             | mov rcx,qword ptr ss:[rsp+20]           |
00007FF78268102D | 0FB60401                 | movzx eax,byte ptr ds:[rcx+rax]         | rcx+rax*1:"AAAA"
00007FF782681031 | 48:8D0D E81F0000         | lea rcx,qword ptr ds:[7FF782683020]     | rcx:"AAAAA"
00007FF782681038 | 0FB60401                 | movzx eax,byte ptr ds:[rcx+rax]         | rcx+rax*1:"AAAA"
00007FF78268103C | 48:630C24                | movsxd rcx,dword ptr ss:[rsp]           |
00007FF782681040 | 48:8D15 B91F0000         | lea rdx,qword ptr ds:[7FF782683000]     |
00007FF782681047 | 0FB60C0A                 | movzx ecx,byte ptr ds:[rdx+rcx]         |
00007FF78268104B | 3BC1                     | cmp eax,ecx                             |
00007FF78268104D | 74 04                    | je chall6.7FF782681053                  |
00007FF78268104F | 33C0                     | xor eax,eax                             |
00007FF782681051 | EB 07                    | jmp chall6.7FF78268105A                 |
00007FF782681053 | EB BD                    | jmp chall6.7FF782681012                 |
00007FF782681055 | B8 01000000              | mov eax,1                               |
00007FF78268105A | 48:83C4 18               | add rsp,18                              |
00007FF78268105E | C3                       | ret                                     |

중요한 부분은 00007FF782681031 부터 00007FF78268104B를 보면 될것 같다.

입력받은 문자열을 순서대로 비교하는 로직이다. 위 주소를 살펴보면 7FF782683020 + 입력받은 문자열의 hex값 을 계산해 7FF782683000와 비교한다. 이를 역산하면 7FF782683000에 있는 hex값이 7FF782683020로부터 얼마만큼 떨어져 있는지 확인하면 쉽게 답을 찾을 수 있다. 이런 로직을 보고 파이썬 코드를 작성했다.

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

for i in a:
        b_count = 0x00
        for j in b:
                if(i == j):
                        break
                else:
                        b_count=b_count+1
        print(chr(b_count), end='')

위 코드에서 변수 a 는 7FF782683000에 있는 hex값이고, 변수 b 는 7FF782683020에 있는 hex값을 의미하며 반복문을 통해 순서대로 돌면서 떨어진 거리를 계산한다.

위 코드를 돌리면 플레그 값을 확인할 수 있다.

Dreamhack rev-basic-5 문제풀이

Sat, 09 Apr 2022 18:30:00 +0900

이번 문제는 드림핵 리버싱문제 rev-basic-5이다. 확실히 베이직 문제이다 보니 약간의 분석과정만 거치면 풀이법이 보여 쉬운편에 속했다.

우선 exe 파일을 다운 받으면 chall5.exe라는 바이너리가 다운로드 된다. 이후 이 바이너리를 실행 시키면

input :

구문으로 문자열을 입력 받고 맞으면 Correct 틀리면 Wrong이라는 문자열을 출력한다.

이제 이 바이너리를 x64 디버거로 분석 해보자.

00007FF6A16C1130 | 40:57                    | push rdi                                | rdi:L"샰櫚Ʊ"
00007FF6A16C1132 | 48:81EC 30010000         | sub rsp,130                             |
00007FF6A16C1139 | 48:8B05 E81E0000         | mov rax,qword ptr ds:[7FF6A16C3028]     |
00007FF6A16C1140 | 48:33C4                  | xor rax,rsp                             |
00007FF6A16C1143 | 48:898424 20010000       | mov qword ptr ss:[rsp+120],rax          |
00007FF6A16C114B | 48:8D4424 20             | lea rax,qword ptr ss:[rsp+20]           |
00007FF6A16C1150 | 48:8BF8                  | mov rdi,rax                             | rdi:L"샰櫚Ʊ"
00007FF6A16C1153 | 33C0                     | xor eax,eax                             |
00007FF6A16C1155 | B9 00010000              | mov ecx,100                             |
00007FF6A16C115A | F3:AA                    | rep stosb                               |
00007FF6A16C115C | 48:8D0D AD100000         | lea rcx,qword ptr ds:[7FF6A16C2210]     | 00007FF6A16C2210:"Input : "
00007FF6A16C1163 | E8 58000000              | call chall5.7FF6A16C11C0                |
00007FF6A16C1168 | 48:8D5424 20             | lea rdx,qword ptr ss:[rsp+20]           |
00007FF6A16C116D | 48:8D0D A8100000         | lea rcx,qword ptr ds:[7FF6A16C221C]     | 00007FF6A16C221C:"%256s"
00007FF6A16C1174 | E8 A7000000              | call chall5.7FF6A16C1220                |
00007FF6A16C1179 | 48:8D4C24 20             | lea rcx,qword ptr ss:[rsp+20]           |
00007FF6A16C117E | E8 7DFEFFFF              | call chall5.7FF6A16C1000                |
00007FF6A16C1183 | 85C0                     | test eax,eax                            |
00007FF6A16C1185 | 74 0F                    | je chall5.7FF6A16C1196                  |
00007FF6A16C1187 | 48:8D0D 9A100000         | lea rcx,qword ptr ds:[7FF6A16C2228]     | 00007FF6A16C2228:"Correct"
00007FF6A16C118E | FF15 F40F0000            | call qword ptr ds:[<&puts>]             |
00007FF6A16C1194 | EB 0D                    | jmp chall5.7FF6A16C11A3                 |
00007FF6A16C1196 | 48:8D0D 93100000         | lea rcx,qword ptr ds:[7FF6A16C2230]     | 00007FF6A16C2230:"Wrong"
00007FF6A16C119D | FF15 E50F0000            | call qword ptr ds:[<&puts>]             |
00007FF6A16C11A3 | 33C0                     | xor eax,eax                             |
00007FF6A16C11A5 | 48:8B8C24 20010000       | mov rcx,qword ptr ss:[rsp+120]          |
00007FF6A16C11AD | 48:33CC                  | xor rcx,rsp                             |
00007FF6A16C11B0 | E8 5B010000              | call chall5.7FF6A16C1310                |
00007FF6A16C11B5 | 48:81C4 30010000         | add rsp,130                             |
00007FF6A16C11BC | 5F                       | pop rdi                                 | rdi:L"샰櫚Ʊ"
00007FF6A16C11BD | C3                       | ret                                     |

다음과 같은 형태의 바이너리이다. 여기서 문자열을 입력 받고 정답임을 검사하는 함수의 위치는 00007FF6A16C117E 이다. 임의 값을 넣고 함수에 bp를 걸어 동작을 확인해보자.

AAAAA 라는 문자열을 입력 하였고 정답을 검증하는 함수의 어셈블리는 다음과 같다.

00007FF6A16C1000 | 48:894C24 08             | mov qword ptr ss:[rsp+8],rcx            | [rsp+8]:"%256s"
00007FF6A16C1005 | 48:83EC 18               | sub rsp,18                              |
00007FF6A16C1009 | C70424 00000000          | mov dword ptr ss:[rsp],0                |
00007FF6A16C1010 | EB 08                    | jmp chall5.7FF6A16C101A                 |
00007FF6A16C1012 | 8B0424                   | mov eax,dword ptr ss:[rsp]              |
00007FF6A16C1015 | FFC0                     | inc eax                                 |
00007FF6A16C1017 | 890424                   | mov dword ptr ss:[rsp],eax              |
00007FF6A16C101A | 48:630424                | movsxd rax,dword ptr ss:[rsp]           |
00007FF6A16C101E | 48:83F8 18               | cmp rax,18                              |
00007FF6A16C1022 | 73 39                    | jae chall5.7FF6A16C105D                 |
00007FF6A16C1024 | 48:630424                | movsxd rax,dword ptr ss:[rsp]           |
00007FF6A16C1028 | 48:8B4C24 20             | mov rcx,qword ptr ss:[rsp+20]           |
00007FF6A16C102D | 0FB60401                 | movzx eax,byte ptr ds:[rcx+rax]         | rcx+rax*1:"AAAA"
00007FF6A16C1031 | 8B0C24                   | mov ecx,dword ptr ss:[rsp]              |
00007FF6A16C1034 | FFC1                     | inc ecx                                 |
00007FF6A16C1036 | 48:63C9                  | movsxd rcx,ecx                          | rcx:"AAAAA"
00007FF6A16C1039 | 48:8B5424 20             | mov rdx,qword ptr ss:[rsp+20]           |
00007FF6A16C103E | 0FB60C0A                 | movzx ecx,byte ptr ds:[rdx+rcx]         |
00007FF6A16C1042 | 03C1                     | add eax,ecx                             |
00007FF6A16C1044 | 48:630C24                | movsxd rcx,dword ptr ss:[rsp]           |
00007FF6A16C1048 | 48:8D15 B11F0000         | lea rdx,qword ptr ds:[7FF6A16C3000]     |
00007FF6A16C104F | 0FB60C0A                 | movzx ecx,byte ptr ds:[rdx+rcx]         |
00007FF6A16C1053 | 3BC1                     | cmp eax,ecx                             |
00007FF6A16C1055 | 74 04                    | je chall5.7FF6A16C105B                  |
00007FF6A16C1057 | 33C0                     | xor eax,eax                             |
00007FF6A16C1059 | EB 07                    | jmp chall5.7FF6A16C1062                 |
00007FF6A16C105B | EB B5                    | jmp chall5.7FF6A16C1012                 |
00007FF6A16C105D | B8 01000000              | mov eax,1                               |
00007FF6A16C1062 | 48:83C4 18               | add rsp,18                              |
00007FF6A16C1066 | C3                       | ret                                     |

00007FF6A16C1039 부터 00007FF6A16C1053 부분이 주요 부분이고 이 부분을 분석해보면 첫번째 사이클에서 입력받은 첫번째 문자열의 아스키코드 값과 두번째 아스키코드 값을 서로 더하여 7FF6A16C3000에 위치하는 hex값과 비교하는 절차를 가지고 있다.

이걸 분석 해보면 다양한 경우의 수가 나올것 같다. 우선 수기로 검증을 해보고 파이선 코드를 작성해 A부터 Z까지 넣었을 경우의 경우의 수를 전부 출력했다.

코드는 다음과 같다.

a = [0xAD, 0xD8, 0xCB, 0xCB, 0x9D, 0x97, 0xCB, 0xC4, 0x92, 0xA1, 0xD2, 0xD7, 0xD2, 0xD6, 0xA8, 0xA5, 0xDC, 0xC7, 0xAD, 0xA3, 0xA1, 0x98, 0x4C]
start = 0x00
temp = 0x00

b = 0x41
while(b<0x5b):
        start = b;
        print("start : "+chr(b))
        for i in a:
                temp = i - start
                print (chr(start), end='')
                start = temp
        print("\n\n")

        b = b+1

위 코드는 [목표값 = 첫번째 값 + 두번째 값] 와 [두번째 값 = 목표값 - 첫번째 값] 이 동일하다는 간단한 식으로 작성하였다. 변수 a는 7FF6A16C3000에 들어있는 목표값 들이고 시작 아스키 코드를 A에 해당하는 hex 0x41로 주어 반복문을 돌렸다.

이후 결과는 다음과 같다.

딱 보면 정답같아 보이는 부분이 있다. A로 시작하는 부분이 플레그 값이다.

Dreamhack rev-basic-4 문제풀이

Fri, 11 Mar 2022 21:00:00 +0900

이번 문제는 드림핵 리버싱문제 rev-basic-4이다.

우선 문제파일을 다운받으면 chall4.exe라는 프로그램이 나온다. 이 프로그램을 실행 시키면 iput : 이라는 문구와 함께 입력창이 활성화 된다. 이후 임의 문자열을 입력하면 Wrong이라는 문자열을 표시하고 종료된다.

이제 이 프로그램을 x64디버거로 열어보자.

이 프로그램의 main부분이다 input 이후에

call chall4.7FF68AC31000

부분에서 문자열을 비교해 je 명령어로 Correct와 Wrong을 나눠준다.

이부분에 bp를 걸고 쭉 진행해 임의의 문자열을 입력하고 내용을 보자.

위와같은 함수의 어셈블리가 보여진다.

간단히 돌려보며 해석을 해보자. 일단 임의값을 “AAAAA"로 입력했다.

jae chall4.7FF68AC31065

위 명령어를 통해 반복문을 진행하며 한글자씩 불러 검사하는 로직이다.

간단한 해석을 붙이면 입력받은 문자열을 AAAAA라고 했을때, 입력받은 문자열의 첫번째 글자를 오른쪽으로 4만큼 시프트 연산한 후 eax에 넣는다. 이후 입력받은 문자열의 첫번째 글자 A를 왼쪽으로 4만큼 시프트 연산 이후 F0와 AND연산 후 ecx에 넣는다. 그다음 eax와 ecx를 OR연산하여 eax에 넣고 7FF68AC33000에 위치한 문자열의 첫번째 글자를 불러 ecx에 넣는다. 이후 cmp명령어를 통해 서로 일치할 경우 jmp를 통해 두번째 문자열의 비교를 시작한다.

그러면 문자열 A를 직접 계산기를 이용해 계산해보자. A의 hex값은 41이며 이진수로 표현하면 0100 0001이다. 41를 위 계산을 통해나온 결과를 보면 0001 0100이라는 값을 가지고 있다.

다른 숫자로 몇번 더 계산을 해보면 hex또는 2진수의 좌우를 바꿔주는것을 볼수 있다.

그러면 7FF68AC33000에 위치한 문자열들의 hex값의 좌우를 바꿔주면 쉽게 flag를 구할 수 있다.

00007FF68AC33000  24 27 13 C6 C6 13 16 E6 47 F5 26 96 47 F5 46 27  $'.ÆÆ..æGõ&.GõF'  
00007FF68AC33010  13 26 26 C6 56 F5 C3 C3 F5 E3 E3 00 00 00 00 00  .&&ÆVõÃÃõãã.....

위의 hex값을 파이썬을 이용해 좌우 자릿수를 바꿔보자.

a = [0x24,0x27,0x13,0xC6,0xC6,0x13,0x16,0xE6,0x47,0xF5,0x26,0x96,0x47,0xF5,0x46,0x27,0x13,0x26,0x26,0xC6,0x56,0xF5,0xC3,0xC3,0xF5,0xE3,0xE3]

for i in a:
        b = i >> 4
        c = i % 0x10
        result = (c*0x10)+b
        print (chr(result), end='')
print("\n")

위 코드는 16진수 배열을 하나씩 불러와 자리수를 서로 바꿔준 후 아스키코드 문자열로 출력해주는 코드이다. 예를 들면 16진수 24를 42로 바꾸어 42에 해당하는 아스키코드인 “B"를 출력한다.

위 코드를 돌리면 플레그 값을 얻을 수 있다.