HACK THE WORLD

C++ Demangling (함수, 변수이름 심볼 인코딩 복원하기)

JUNFUTURE — Fri, 10 Apr 2026 13:50:48 +0900

Demangling은 C++ 컴파일러가 함수나 변수 이름을 링크용 심볼로 인코딩한 것을 사람이 읽을 수 있는 원래 이름으로 복원하는 과정이다.

C++은 함수 오버로딩, 네임스페이스, 클래스, 템플릿 같은 정보까지 심볼에 담아야 하므로, 예를 들어
MyApp::Renderer::instance() 같은 이름이 바이너리에서는
__ZN5MyApp8Renderer8instanceEv 처럼 mangling된다.

이 인코딩된 이름을 다시 원래 C++ 형태로 푸는 작업이 demangling이다.

직접 해보면:

echo "__ZZN5MyApp8Renderer8instanceEvE6object" | c++filt
=> MyApp::Renderer::instance()::object
 

해석해보면:

_ZN → namespace / class 스코프 시작
5MyApp → "MyApp" (숫자는 문자열 길이)
8Renderer → "Renderer"
8instanceEv → instance() (v는 void 인자)
_ZZ...E6object → 함수 내부의 static local 변수 object
_ZGV... → 해당 static 변수의 초기화 여부를 관리하는 guard variable

즉, demangling은 디스어셈블리나 심볼 분석 중 보이는 난독화된 C++ 심볼을 원래의 함수/변수 선언 형태에 가깝게 복원하는 작업이라고 보면 된다.

아 신기하다 진짜

진짜 어카노

JUNFUTURE — Wed, 8 Apr 2026 10:00:32 +0900

https://red.anthropic.com/2026/mythos-preview/

Claude Mythos Preview \ red.anthropic.com

April 7, 2026 Nicholas Carlini, Newton Cheng, Keane Lucas, Michael Moore, Milad Nasr, Vinay Prabhushankar, Winnie Xiao Evyatar Ben Asher, Hakeem Angulu, Jackie Bow, Keir Bradwell, Ben Buchanan, Daniel Freeman, Alex Gaynor, Xinyang Ge, Logan Graham, Hasnain

red.anthropic.com

진짜 어카노?

Javascript worker와 blob(동적 코드 주입)

JUNFUTURE — Tue, 31 Mar 2026 11:00:31 +0900

들어가며

아래 코드를 이해해보자

// 1. 워커에서 실행될 코드를 문자열로 정의 (템플릿 리터럴 활용)
const workerCode = `
  self.onmessage = function(e) {
    console.log('[Worker] Received data from main thread:', e.data);
    
    // 무거운 연산을 시뮬레이션 (메인 스레드 방해 없음)
    const result = e.data * e.data;
    
    // 결과를 다시 메인 스레드로 전송
    self.postMessage(result);
  };
`;

// 2. 문자열을 Blob 객체로 변환 (타입은 반드시 javascript)
const blob = new Blob([workerCode], { type: 'application/javascript' });

// 3. Blob을 가리키는 고유한 URL 생성
const blobURL = URL.createObjectURL(blob);
console.log('[Main] Created Blob URL:', blobURL);

// 4. 생성된 URL을 사용하여 워커 인스턴스 생성
const myWorker = new Worker(blobURL);

// 5. 워커로부터 오는 메시지를 처리할 핸들러 등록
myWorker.onmessage = function(e) {
  console.log('[Main] Worker computed result:', e.data);
  
  // 6. 사용이 끝난 URL은 메모리 해제를 위해 폐기 (중요!)
  URL.revokeObjectURL(blobURL);
  console.log('[Main] Blob URL has been released from memory.');
};

// 7. 워커에게 작업 지시 (데이터 전송)
console.log('[Main] Sending 10 to the worker.');
myWorker.postMessage(10);

Worker

worker는 js 파일을 받아서 실행해준다. 정확히 말하면 worker는 "Worker Thread"의 개념이다.

woker가 등장하게된 배경은 브라우저의 main thread와 분리되어 서로 다른 context에서 데이터를 주고받으며 js를 실행하기위함이다.

브라우저의 main thread는 UI를 담당한다. window, document(DOM) 접근을 관리하고

worker thread는 이외에 백그라운드 연산(당연히 다른 .js 코드 실행을 뜻한다)을 수행한다.

이때 둘 thread 간의 통신이 필요할텐데, 오직 message를 이용해서만 통신을 하고 이때 아래와 같은 핸들러들을 이용해서 통신하는 것이다.

Worker - Main thread 통신 규격 (Event driven)

보낼 때 : postMessage(data)

받을 때 : onmessage 이벤트 핸들러

const myWorker = new Worker('worker.js');

// 1. 워커가 나에게 보낸 메시지를 받을 준비
myWorker.onmessage = function(event) {
    console.log("워커가 보낸 답장:", event.data);
};

// 2. 워커에게 메시지 던지기
myWorker.postMessage("안녕 워커!");

worker를 생성하는 쪽(main thread)에서는 반드시 위와 같은 코드가 필요할 것이다.

생성되는 worker의 코드는 아래와 같은 패턴이 있을 것이다.

// 3. 메인이 보낸 메시지를 받을 준비 (자신을 가리키는 self 사용)
self.onmessage = function(event) {
    const receivedData = event.data;
    console.log("메인이 보낸 내용:", receivedData);

    // 4. 메인에게 다시 답장 던지기
    const reply = "받았다: " + receivedData;
    self.postMessage(reply); 
};

worker 코드 내부에 self??

(TBD)

Blob (Binary large object)

메모리 내부에 존재하는 바이너리 데이터다.

MIME 타입

C도 많이 해봤으면 알듯이 메모리에 저장된 데이터를 어떻게 해석할까?의 문제를 해결해주는게 바로 MIME 타입이다.

그러니까... 이런식으로 blob을 정의 한다는 건 쌩짜로 바이너리 데이터 넣는거니까 이걸 브라우저에서 뭐 어떤 데이터 인지 알아야 이걸 처리(렌더링) 할테니까, 타입을 알려주는게 필요하다.

아래에서 workerCode는 위에서 봤던 self.onmessage로 시작하는 코드 일 것이다.

const blob = new Blob([workerCode], { type: 'application/javascript' });

MIME 타입(Multipurpose Internet Mail Extensions)은 파일의 성격과 형식을 나타내는 식별자로, type/subtype 구조(text/html, image/png 등)로 웹에서 데이터 형식을 정의합니다. 주로 HTTP 헤더(Content-Type)를 통해 서버가 브라우저에게 파일 종류를 알리고, 브라우저는 이에 따라 파일을 랜더링하거나 다운로드한다.
text/html: HTML 문서
image/png: PNG 이미지
application/json: JSON 데이터
application/javascript: 자바스크립트 파일

URL.createObjectURL(blob)

blob:https://현재도메인/무작위-UUID 형태의 가짜 주소를 생성하고,

이 주소가 현재 내 컴퓨터 RAM의 특정 지점(Blob 데이터가 있는 곳 - 주소, URL)을 가리키도록 연결

const blobURL = URL.createObjectURL(blob);

Blob을 이용한 동적 js 코드 주입

// 정적으로 코드 주입(code injection)
const myWorker = new Worker('worker.js');

// 동적으로 코드 주입(code injection)
const workerCode = `
  self.onmessage = function(e) {
    console.log('[Worker] Received data from main thread:', e.data);
    
    // 무거운 연산을 시뮬레이션 (메인 스레드 방해 없음)
    const result = e.data * e.data;
    
    // 결과를 다시 메인 스레드로 전송
    self.postMessage(result);
  };
`;

const blob = new Blob([workerCode], { type: 'application/javascript' });
const blobURL = URL.createObjectURL(blob);
const myWorker = new Worker(blobURL);

MacOS(ARM, M1,M2..) 에서 UTM을 이용해 Ubuntu VM실행하기

JUNFUTURE — Thu, 19 Mar 2026 10:01:27 +0900

1. UTM 설치

QEMU 기반 VM을 GUI로 감싼 툴이라고 한다.

무료이고 이게 압도적으로 편하다는 설이 많다.

2. ubuntu server for arm iso 설치

ubuntu server를 설치한 뒤

아래 명령어를 치면 ubuntu desktop처럼 사용할 수 있다

$ sudo apt update
$ sudo apt install ubuntu-desktop
$ sudo reboot

3. boot from next volume

이후에 boot from next volume으로 접속하면 우분투 접속이 된다.

Javascript의 객체와 prototype inheritance(프로토타입 기반 상속)

JUNFUTURE — Thu, 5 Mar 2026 15:45:05 +0900

들어가며

javascript 는 프로토타입 기반 객체지향 프로그래밍 언어이다.

프로토타입이 뭘까?

Prototype의 의미

중복으로 사용되는 곳이 너무 많아 정리한다

1. 일반 공학에서의 prototype : 최종 제품을 만들기 전에 만든 초기 시험 모델(시제품)

2. C언어에서의 함수 prototype : 함수를 정의하기 전에 컴파일러에게 함수의 이름, 반환형, 매개변수 타입을 미리 알려주는 선언
3. javascript의 prototype : 객체가 다른 객체의 속성과 메서드를 상속받기 위해 연결하는 상위 객체 참조

이 글에서는 3번만 얘기할거니까 헷갈리지 말자

표현을 정리하자면, 프로토타입 패턴이라는 것은 객체를 생성하는 방법을 다루는 디자인 패턴을 뜻한다.

Javascript의 객체

객체라 함은 메모리에 저장되는 일련의 데이터 덩어리라고 생각하면된다.

자바스크립트는 모든 것이 객체(object)라는 설계철학을 가지고있다.

함수도 객체, 배열도 객체, 문자열도 객체 전부 다 객체이다.

자바스크립트에서 모든 인스턴스들(함수, 배열, 문자열 인스턴스들) 은 생성되는 순간, 부모의 객체 메모리 주소 값을 자신의 내부 포인터인 [[Prototype]]에 저장한다.

따라서 자바스크립트의 모든 객체 인스턴스들은 Object.prototype을 조상으로 갖는다.

아래 구조(prototype chain)로 구성되어있는 것이다.

obj
 └── [[Prototype]] → parent
                          └── [[Prototype]] → Object.prototype

진짜다.

여기서 __proto__는 객체의 내부 prototype ( [[Prototype]] )에 접근하는 getter/setter
obj.__proto__ 는 실제로 obj.[[Prototype]]

여기서 .constructor는 해당 prototype을 만든 생성자 함수. (어떤 객체가 어떤 생성자에서 왔는가?)
String.prototype.constructor === String
Array.prototype.constructor === Array
Function.prototype.constructor === Function
Object.prototype.constructor === Object

생성자 함수? -> 객체를 만들기 위한 함수

function Dog(name) {
  this.name = name;
}

const d = new Dog("puppy");

여기서 Dog이 생성자 함수다.

Javascript의 객체 생성

전통적인 클래스 기반 언어(C++, Java)는 인스턴스를 만들 때 새로운 메모리 덩어리를 찍어내지만, 자바스크립트는 복사하지 않고 클래스간 연결만 한다.

연결이란? 객체가 생성되는 순간 부모가 될 다른 객체의 메모리 주소값을 자신의 [[Prototype]] 포인터에 저장하는 것

직접 객체 생성하기 (new없이)

const parent = { gold: 100 };
const child = Object.create(parent); // child -> parent 연결

parent 객체 생성: 메모리 주소 0x111에 생성. 내부에 gold: 100이 저장
child 객체 생성: 메모리 주소 0x222에 생성. 내부 데이터는 비어있음
연결 : Object.create()는 새 객체를 만들면서 그 객체(child)의 [[Prototype]]을 원하는 객체(parent)로 직접 지정하는 함수 child 객체의 헤더 영역에 있는 [[Prototype]] 필드에 0x111이라는 주소가 기록됨

child
├─ own properties: (없음)
└─ [[Prototype]] ──> parent
                    ├─ gold: 100
                    └─ [[Prototype]] → Object.prototype
                    
child.__proto__ === parent

위와 같은 형태로 객체가 생성되며 ECMAScript spec(자바스크립트 표준) 에서 Object.create(proto)의 동작은 아래의 알고리즘이다.

1. 새로운 빈 객체 O 생성
2. O.[[Prototype]] = proto
3. O 반환

Javascript Delegation

내가 어떤 데이터나 함수를 가지고 있지 않을 때, 내 메모리에 저장된 주소를 타고 상위 객체(prototype에 연결되어있는 객체)의 메모리 영역으로 이동해서 그 데이터를 빌려오는 것이다.

아까 Object.create로 객체를 생성했을때를 생각해보자.

1. child 객체(0x222) 자체에서 gold 찾기
2. 없으면 child.[[Prototype]] → parent
3. parent (0x111)에서 gold 발견 → 100 반환

new의 동작

이런식으로 new 를 이용하면 prototype을 연결하는 것 뿐만 아니라, constructor를 실행한다.

방식	prototype 연결	constructor 실행
new	O	O
Object.create()	O	X

const d = new Dog("puppy");

javascript에서 new를 이용해 객체를 생성하면 엔진 내부에서 아래와 같은 순서로 실행된다.

객체 생성 -> prototype 연결 -> constructor 실행 -> 객체 반환

//1. 빈 객체 생성
{}

//2. prototype 연결
obj.[[Prototype]] = Dog.prototype

//3. constructor 실행
Dog.call(obj, "puppy")

//4. 객체 반환
return obj

사실상 아래와 같은 함수가 동작하는 거다

function fakeNew(constructor, ...args) {

  const obj = Object.create(constructor.prototype);

  constructor.apply(obj, args);

  return obj;
}

이 과정을 거쳐서 최종적으로 아래 구조를 갖는 객체가 탄생한다.

d
 ├─ name: "puppy"
 └─ [[Prototype]] → Dog.prototype

Prototype 상속

자바스크립트에서 상속이란 (prototype 기반 상속) 특정 인스턴스의 [[Prototype]] 포인터를 상위 객체를 가리키게 설정하는 것을 의미한다.

class Dog extends Animal {}

Dog.prototype.__proto__ = Animal.prototype

자바 스크립트에도 class라는 키워드는 있지만 이건 그냥 Syntactic Sugar(사람 눈에만 예뻐보이는 문법) 라고 한다.

굳이 Syntactic Sugar라고 말하는 이유는 C++이나 자바 같은 prototype기반 언어가 아닌 경우 class를 선언하는 것은 실제로 해당 타입을 만드는 개념이다.

즉, C++과 JAVA와 같은 프로그래밍 언어의 상속은 class와 class 간의 type hierarchy의 개념이고

Javascript 에서의 상속은 object와 object 간의 prototype delegation의 개념이다.

┌──────────────┐
│ 배열 arr1    │  ┐
├──────────────┤  │
│ length: 0    │  │ arr1 객체
│ [[Prototype]]:──┼─→ 같은 메모리 주소 가리킴
└──────────────┘  │
                  │
┌──────────────┐  │
│ 배열 arr2    │  │
├──────────────┤  │
│ length: 0    │  │ arr2 객체
│ [[Prototype]]:──┼─→ (같은 Array.prototype)
└──────────────┘  │
                  │
        ↓ 모두 가리키는 곳
┌────────────────────┐
│ Array.prototype    │  (하나만 메모리 존재)
├────────────────────┤
│ push: function     │
│ pop: function      │
│ slice: function    │
│ ...배열 메서드들   │
└────────────────────┘

이제 아래를 완벽히 이해할 수 있다.

Object.prototype.toTest = function () { return 'test1' }
console.log( "abc".toTest() );
// "test1"

function fn () {}
fn.prototype.name = 'test2'
var newFn = new fn();
console.log(newFn.name)
// "test2"
console.log(newFn.toTest());
// "test1"

출처 : Javascript는 프로토타입 기반 언어이다

왜 이러는 거???

이런 식으로 특정한 객체가 반복되어 인스턴스로 생성되면 딱 한번만 생성하고 이후부터는 생성된 객체를 복사해서 쓰자 라는 관점으로 접근하는 것이 프로토타입 패턴

// 이건 너무 객체 생성 비용이 높으니까...
Player evan = new Player();
Player john = new Player();
Player wilson = new Player();

// 이런 방법으로 접근해보는 것은 어떨까?
Player player = new Player();
Player evan = player.clone();
Player john = player.clone();
Player wilson = player.clone();

출처 : https://evan-moon.github.io/2019/10/23/js-prototype/

참고

JavaScript Object Property Lookup이란 (자바 스크립트 객체가 property를 찾는 순서)

JUNFUTURE — Wed, 4 Mar 2026 18:05:52 +0900

ㅇㄱ ㅈㅉㅇㅇ???

Javascript를 보면 위와 같은 충격적인 상황을 마주할 수 있다.

이것이 가능한 이유는 JavaScript는 모든 것이 객체이고 객체의 property를 찾을때 자바스크립트 엔진은 spec에 근거한 lookup 과정을 거치기 때문이다.

배열의 arr[index] 접근도 일반 객체의 property lookup과 같은 규칙을 따르기 때문이다. property lookup이라 함은 특정한 객체의 property를 찾는 과정을 의미하는데, 자바스크립트의 특정 객체 인스턴스의 property를 탐색하는 순서가 있다.

1. obj 자체에 property 있는지 확인
2. 없으면 obj.[[Prototype]] 로 이동
3. 거기서 property 찾기
4. 계속 반복
5. 끝까지 없으면 undefined

이게 property를 찾는 순서인데, 이 과정을 property lookup이라고 부른다.

Prototype-based Inheritance

Prototype이랑 property랑 단어가 비슷해서 헷갈리지 집중해서 보자.

javascript는 prototype-based inheritance를 디자인 패턴으로 채택했다.

https://juntheworld.tistory.com/247

Javascript의 객체와 prototype inheritance(프로토타입 기반 상속)

들어가며javascript 는 프로토타입 기반 객체지향 프로그래밍 언어이다.프로토타입이 뭘까? Prototype의 의미중복으로 사용되는 곳이 너무 많아 정리한다1. 일반 공학에서의 prototype : 최종 제품을 만

juntheworld.tistory.com

자바스크립트의 모든 객체(배열 포함)는 내부적으로 다른 객체를 가리키는 [[Prototype]]이라는 포인터를 가지고 배열의 경우, 그 [[Prototype]]이 Array.prototype 이다.

┌──────────────┐
│ 배열 arr1    │  ┐
├──────────────┤  │
│ length: 0    │  │ arr1 객체
│ [[Prototype]]:──┼─→ 같은 메모리 주소 가리킴
└──────────────┘  │
                  │
┌──────────────┐  │
│ 배열 arr2    │  │
├──────────────┤  │
│ length: 0    │  │ arr2 객체
│ [[Prototype]]:──┼─→ (같은 Array.prototype)
└──────────────┘  │
                  │
        ↓ 모두 가리키는 곳
┌────────────────────┐
│ Array.prototype    │  (하나만 메모리 존재)
├────────────────────┤
│ push: function     │
│ pop: function      │
│ slice: function    │
│ ...배열 메서드들   │
└────────────────────┘

Property Lookup

이걸 생각하고 위의 코드를 다시 보면

arr[0] → 없음 → Array.prototype[0] → 있음(999 가져옴)

이런 식으로 동작한 것이다.

arr
├─ elements: []
├─ length: 0
└─ [[Prototype]]: ──┐
                    ↓
         Array.prototype
         ├─ '0': 999  ← 이걸 찾음!
         ├─ 'length': (함수)
         ├─ 'push': (함수)
         └─ [[Prototype]]: Object.prototype

property를 찾는 obj에 never assigned element (arr[0]) 가 있어도(즉, property가 없어도)

javascript는 spec 상으로 prototype chain을 찾아보게 설계되어있다.

리눅스 권한 이제는 좀 이해하기 (Owner, Group, Other과 프로세스 권한 ruid, euid, suid 까지)

JUNFUTURE — Wed, 4 Mar 2026 10:31:53 +0900

리눅스 권한을 이해할때 크게

0. 권한은 파일(리눅스에서는 디렉터리도 파일이다)에 부여된다

1. 어떤 권한이 있는가 (rwx)

2. 누구에게 그 권한이 있는가 (owner, group, other)

개념을 이해하면 된다.

1번 rwx는 표현법만 익히면 되는거니 그냥 넘어가고

owner, group, other 개념을 확실히 익혀보자.

바로 예제

아래와 같이 파일들이 있다고 했을때 (ls -l로 확인가능하다)

-r-------- 1 pwned pwned      69 flag-4a366de5f9250ee00973d579cd8a9e87
-r-sr-x--- 1 pwned pwn   17552 flag_reader-2b6cfa9d53f87254b7c90bbd12d17ab6
-rwxr-xr-x 1 root  root     30 run.sh
-rw-r--r-- 1 root  root    534 runner.py
drwxr-xr-x 4 pwn   pwn    4096 x64.release
-rw-r--r-- 1 root  root 59528158 x64.release.zip

flag 파일의 경우 owner 에게만 r 권한이 있다. (400)

-r--------

- r-- --- ---
│ │   │   │
│ │   │   └ other
│ │   └ group
│ └ owner
└ file type

이거다.

그다음 숫자

1 pwned pwned      69 flag-4a366de5f9250ee00973d579cd8a9e87

여기 맨 앞에 1은 hard link 갯수 이다 (ln file file2) 했을때 쌓인다.

그다음에 pwned pwned가 순서대로

owner / group이 누군지를 나타내는거다

owner? group? other?

owner -> 파일을 만들거나 소유권을 가진 user

group -> 유저들을 묶은 그룹 : 그룹 권한이 적용됨. 리눅스에서 유저는 owner가 될 자격을 가진 개인이면서 group에 속할 수 있는 개인이다.

other -> owner도 아니고 group도 아닌 모든 user (외부 프로세스에서 접속한 사람 등등)

Local Privilege Escalation

사실 이 글을 쓰게 된 것이 LPE를 이해하기 위함인데,

예를 들어 아래와 같이 RCE를 성공한 상황을 가정해보자.

RCE 직후 cat flag를 하면 permission deny가 떴다.

지금 ctf 문제에서는 문제 바이너리를 프로세스로 실행하는 유저는 pwn이고 flag 파일 만들어둔 주체(owner)는 pwned고 ./flag reader로 pwned 권한을 얻어서 읽는것이다.

위 디렉터리에서 flag_reader는 아래와 같은 코드로 표현할 수 있는데

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

int main(int argc, char **argv, char **envp)
{
    uid_t euid1;
    uid_t euid2;

    euid1 = geteuid();
    euid2 = geteuid();

    setreuid(euid2, euid1);

    system("/bin/bash");

    return 0;
}

이제 이 코드를 하나하나 이해하면 LPE를 이해할 수 있을거다.

geteuid() 를 이용해 현재 프로세스의 effective UID를 가져온다.

질문 1. effective UID가 뭔가???

setreuid()는 프로세스가 가지는 UID 값 read uid와 effective uid를 동시에 변경한다.

질문 2. 프로세스가 UID를 가진다?
질문 3. read uid와 effective uid가 뭔가?

setreuid()는 현재 프로세스가 사용하는 UID credential(ruid,euid)을 바꿔서 프로세스의 권한 컨텍스트를 변경하는 함수다.

질문 4. UID credentail이 뭔가??

UID(UserID) credentail - 프로세스가 가지는 권한

리눅스에서 커널이 권한을 체크할때 "유저의 권한"을 보는 것이 아니라 "프로세스에 붙어있는 UID credentail"을 본다.

그 말인 즉슨

예를 들어 cat flag 명령을 RCE 이후에 특정 프로세스 권한을 이용해 연 쉘에서 수행한다고해보자.

그럼 아래와 같이 커널 syscall을 이용해서 파일을 읽는다(파일을 읽는다는게 syscall 필요하니까)

cat → open("flag")
      → syscall open()
      → kernel

이때 커널이 파일 접근을 검사하는데, 아래와 같은 흐름으로 검사한다.

process = current
euid = process->cred->euid # 현재 프로세스 uid
inode_owner = file->inode->uid # 열려는 파일의 uid

if (euid == inode_owner) # 둘이 같음?? 
    owner permission 적용

즉, 커널이 확인하는건 '현재 프로세스를 실행한 유저' 의 권한이 아니라 '현재 실행중인 프로세스'의 권한을 본다는 것이다.

왜???????? 유저 권한 매번 확인하면 되는거 아니냐? - UNIX의 설계철학이다. "process delegation" 권한 모델.

권한은 “프로세스 실행 시점에 결정”된다. 유저의 권한은 프로세스 생성 시점에 위임 (delegation) 되는 설계철학.

ruid/euid/suid 이야기는 이미 프로그램이 실행된 이후의 프로세스 credential 상태를 말하는 것이고, 거기까지 오려면 그 이전 단계에서 반드시 유저가 파일을 +x 할 수 있는 권한 체크가 통과되어야 한다.

process
 └ credentials
      ├ ruid  (real uid) # 이 프로세스를 실행한 실제 사용자
      ├ euid  (effective uid) # 커널이 권한 체크할 때 사용하는 uid
      └ suid  (saved uid) # 이전 privilege를 복구하기 위해 저장하는 uid

suid???? - 이전 권한을 복구하기 위해 저장??????

: 잠시 프로세스가 권한을 올렸다가 낮출 필요가 있는 경우가 많은데, 그때 높은 권한을 저장해두기 위함

아래와 같은 동작을 하는 프로그램이 있을때

1. config file 읽기
2. user input 처리
3. privileged 작업

보통 이런 식의 동작을 하면 높은 권한으로 시작을 하고

-rwsr-xr-x root root program

# 권한을 내려놓음 (drop privilege)
seteuid(ruid);

ruid = user
euid = user
suid = root

# 다시 올림
seteuid(suid);

ruid = user
euid = root
suid = root

# suid가 없으면 
seteuid(user)
# root 권한 영구적으로 잃음

(suid 얘기 끝)

쨋든 그래서 LPE를 하고 싶으면 실행중인 프로그램의 uid를 바꿔주면 된다.

처음 RCE를 했을때 Permission Deny가 되는 원리는

# RCE로 shell 따기 성공
/bin/sh
uid=1000(pwn)

# 현재 프로세스(/bin/sh의 uid - RCE성공한 프로세스의 uid 상속)
ruid = 1000
euid = 1000

# 커널 명령 수행
cat flag

# 커널 딴 체크 -> 파일 권한이랑 안맞음
process.euid = 1000
flag owner = 1001

Permission denied

setuid를 실행하면 해당 프로세스의 euid를 바꿔버려서 아래와 같이 되어버리는 것

./flag_reader

ruid = 1000 (pwn)
euid = 1001 (pwned) # 이게 바뀜

# 커널 체크 성공!
process.euid = 1001
flag owner = 1001

다시 돌아와서,

flag_reader의 권한은

-r-sr-x--- 1 pwned pwn 17552 May 4 2023 flag_reader-2b6cfa9d53f87254b7c90bbd12d17ab6

위와 같았다.

여기서 owner의 s 권한이 바로 setuid buit 인데 -> 이 비트가 있으면 프로세스의 euid를 파일 owner의 UID로 바꾼다.

프로세스가 실행될때 프로세스의 권한은 아래와 같은 순서로 세팅된다.

1 execute permission 체크 -> +x 권한 있음?
2 setuid bit 처리 =? +s 권한 있음? 있으면 실행 후 euid 권한 owner로 변경
3 프로세스 시작

따라서 flag_reader를 실행하면 프로세스의 uid가 아래와 같이 세팅된다.

ruid = pwn
euid = pwned
suid = pwned

아래가 이제 euid를 가져와서 ruid랑 euid 둘 다 지금 euid로 바꿔버리겠다 (setreuid)라는 명령어인데, 그 이유는 bash 보안 로직 내부에 setuid 환경을 감지 (ruid != euid) 인 경우 privilege drop을 시도하는 경우가 있기 때문이라고 한다. (충분히 상식적인 보안로직)

    uid_t euid1;
    uid_t euid2;

    euid1 = geteuid();
    euid2 = geteuid();

    setreuid(euid2, euid1);

그래서 결론적으로 위의 코드를 실행하면 아래와 같이 세팅된 프로세스의 권한으로 쉘을 사용할 수 있다.

ruid = pwn
euid = pwned
suid = pwned

참고.. setreuid 의 존재 이유에 대해

프로세스 권한(privilege)은 euid로 확인한다면서 프로세스 내부에서 ruid까지 바꿔버리는 setreuid 이런 함수를 만든 이유가 뭘까?

ruid = identity
euid = privilege

ruid가 identity 역할로 프로세스가 identity를 바꿀 필요가 있다는 뜻인데.. 어쩌피 프로세스의 privilege는 euid로 검사하는데, 프로세스가 직접 함수 호출을 이용해서 identity를 변환해야되는 이유가 뭐냐는 말이다.

찾아보니 user에게 아예 ownership을 넘기는 경우가 있기 때문이다.

identity 까지 넘겨버리는.. 예를들면 로그인과 웹서버, 그리고 UNIX에 일부 시스템 콜 kill ptrace 같은 경우에 ruid도 검증을 한다고 한다. 이럴때는 ruid와 euid까지 넘겨버리는 것.

이 정도면 납득.

Type Casting과 Type Punning의 차이

JUNFUTURE — Wed, 25 Feb 2026 11:04:57 +0900

Cast (형변환): "데이터의 의미를 유지하며 형태를 바꿈"

Cast는 데이터를 다른 타입으로 바꾸되, 그 값(Value)의 의미가 유지되도록 비트를 재구성하는 과정

동작: 컴퓨터가 CPU 연산을 통해 비트 패턴을 새로 만듬
예시: 정수 1을 실수 1.0으로 캐스팅할 때.
- 정수 1: 0x00000001
- 실수 1.0: 0x3f800000 (IEEE 754 방식)

=> 비트 패턴이 완전히 달라졌지만, 인간이 읽는 '값'은 여전히 1

Punning (타입 퍼닝): "비트는 그대로 두고 해석만 바꿈"

Punning은 메모리에 저장된 비트 패턴을 단 1비트도 건드리지 않고, 그것을 바라보는 타입만 바꿔서 읽는 기법

동작: 추가적인 CPU 연산(번역) 없이, 메모리 주소에 있는 값을 그대로 가져와 다른 타입으로 우깁니다.
예시: 정수 1065353216 (0x3f800000)이 들어있는 메모리를 실수 타입으로 퍼닝할 때.
- 메모리: 0x3f800000
- 결과: 1.0이라는 실수

=> 메모리 내부 비트 패턴은 똑같지만, 해석된 '값'은 완전히 달라짐

VMware 에서 Ubuntu 디스크 용량 늘린 후에 적용하는법

JUNFUTURE — Tue, 24 Feb 2026 17:09:05 +0900

Vmware나 Naver Cloud 등에서 Disk 크기를 조정한다

Ubuntu Disk 용량 늘리기 -> Ubuntu 내부 Disk Setting 이용하면 가능!

https://kysf.tistory.com/20

Ubuntu 디스크 용량 늘리는 방법

STEP 1. VMware 설정에서 용량 확장1) 수정하고자 하는 machine의 설정 페이지에 들어간다."Edit virtual machine settings" 2) 현재 할당된 Hard Disk의 용량을 확인후, Expand 버튼을 클릭한다. 3) 늘리고자 하는 크

kysf.tistory.com

V8(d8) 빌드 및 gdb를 이용한 디버깅 방법

JUNFUTURE — Mon, 23 Feb 2026 09:54:35 +0900

타겟 빌드

V8 빌드 도구(depot_tools) 다운

ninja나 관련된 모든 빌드 도구들이 depot_tools에 들어있다.

git clone https://chromium.googlesource.com/chromium/tools/depot_tools.git
export PATH=$PATH:$(pwd)/depot_tools

V8 소스코드 다운

fetch v8
cd v8
# 특정 CVE가 수정되기 전의 특정 커밋으로 이동 (예: 2024년 3월 중순)
git checkout 28877c5520
gclient sync

예를 들어) CVE-2024-2887의 경우 패치전 (취약버전)이 28877c5520 커밋

V8 빌드 (d8 쉘 생성)

./tools/dev/gm.py x64.debug
./tools/dev/gm.py x64.release

V8 실행

./out.gn/x64.release/d8 *.js
# 혹은
./out/x64.release/d8 *.js

V8 디버깅

v8을 디버깅한다는 것은 v8의 쉘 역할을 해주는 d8 바이너리를 이용해서 .js 코드의 동작을 해석하는 브라우저 엔진의 동작을 분석한다는 뜻이다.

d8은 리눅스 바이너리(ELF)다

d8은 리눅스 바이너리이기 때문에 gdb를 이용해서 디버깅이 당연히 가능하다. 근데 이제 .js 파일을 인자로 받아서. 따라서 gdb를 실행할때 인자로 .js 파일을 넘겨주어여야 한다는 것만 생각하면 된다.

gdb <d8 바이너리>
# 이 시점에 브레이크 포인트 걸기
r --allow-natives-syntax <.js파일>

예시

트러블 슈팅

python3 /home/jun/CVE-2024-2887/v8/build/config/linux/pkg-config.py -s ../../build/linux/debian_bullseye_amd64-sysroot -a x64 glib-2.0 gmodule-2.0 gobject-2.0 gthread-2.0

➜  v8 git:(afe6883a2a5) ./tools/dev/gm.py x64.debug
# mkdir -p /home/jun/CVE-2024-2887/v8/out/x64.debug
# echo > /home/jun/CVE-2024-2887/v8/out/x64.debug/args.gn << EOF
is_component_build = true
is_debug = true
symbol_level = 2
target_cpu = "x64"
v8_enable_sandbox = true
v8_enable_backtrace = true
v8_enable_fast_mksnapshot = true
v8_enable_slow_dchecks = true
v8_optimized_debug = false
EOF
# gn gen out/x64.debug
ERROR at //build/config/linux/pkg_config.gni:152:19: Script returned non-zero exit code.
      pkgresult = exec_script(pkg_config_script, _script_args, "json")
                  ^----------
Current dir: /home/jun/CVE-2024-2887/v8/out/x64.debug/
Command: python3 /home/jun/CVE-2024-2887/v8/build/config/linux/pkg-config.py -s ../../build/linux/debian_bullseye_amd64-sysroot -a x64 glib-2.0 gmodule-2.0 gobject-2.0 gthread-2.0
Returned 1.
stderr:

Traceback (most recent call last):
  File "/home/jun/CVE-2024-2887/v8/build/config/linux/pkg-config.py", line 252, in <module>
    sys.exit(main())
             ^^^^^^
  File "/home/jun/CVE-2024-2887/v8/build/config/linux/pkg-config.py", line 142, in main
    prefix = GetPkgConfigPrefixToStrip(options, args)
             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/home/jun/CVE-2024-2887/v8/build/config/linux/pkg-config.py", line 80, in GetPkgConfigPrefixToStrip
    prefix = subprocess.check_output([options.pkg_config,
             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/home/jun/CVE-2024-2887/depot_tools/bootstrap-2@3.11.8.chromium.35_bin/python3/lib/python3.11/subprocess.py", line 466, in check_output
    return run(*popenargs, stdout=PIPE, timeout=timeout, check=True,
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/home/jun/CVE-2024-2887/depot_tools/bootstrap-2@3.11.8.chromium.35_bin/python3/lib/python3.11/subprocess.py", line 548, in run
    with Popen(*popenargs, **kwargs) as process:
         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/home/jun/CVE-2024-2887/depot_tools/bootstrap-2@3.11.8.chromium.35_bin/python3/lib/python3.11/subprocess.py", line 1026, in __init__
    self._execute_child(args, executable, preexec_fn, close_fds,
  File "/home/jun/CVE-2024-2887/depot_tools/bootstrap-2@3.11.8.chromium.35_bin/python3/lib/python3.11/subprocess.py", line 1953, in _execute_child
    raise child_exception_type(errno_num, err_msg, err_filename)
FileNotFoundError: [Errno 2] No such file or directory: 'pkg-config'

See //build/config/linux/BUILD.gn:58:3: whence it was called.
  pkg_config("glib") {
  ^-------------------
See //build/config/compiler/BUILD.gn:354:18: which caused the file to be included.
    configs += [ "//build/config/linux:compiler" ]
                 ^------------------------------

해결

sudo apt-get update
sudo apt-get install -y pkg-config libglib2.0-dev

Code TurboFan 최적화 안되어있을때

=> 먼저 d8 실행시켜두고 gdb붙이기

# 실행
./x64.release/d8 --allow-natives-syntax ./ex.js

# 프로세스 id 찾기
ps aux | grep d8

# gdb 붙기
sudo gdb -p 82223