【Golang云原生逃逸实战】：从containerd shimv2到runc hook bypass的5层容器逃逸路径

第一章：Golang云原生逃逸的底层认知与攻防边界

云原生环境中，Golang 二进制因其静态链接、无依赖、高密度部署等特性，成为容器镜像的主流载体；但恰恰是这些优势，掩盖了其在运行时逃逸路径上的隐蔽性——它不依赖 libc，却深度耦合内核 syscall 接口；不加载动态库，却可通过 unsafe、reflect 和 syscall 包直接触达内核边界。理解 Golang 逃逸的本质，需回归两个核心维度：编译时约束（如 CGO_ENABLED=0 下的纯静态链接）与运行时契约（goroutine 调度器对 ptrace、/proc/self/status 等资源的访问权限）。

进程视角下的容器边界失效点

当 Golang 程序以 root 用户启动并挂载 /proc、/sys 或 hostPID: true 时，其可通过 syscall.Syscall 直接调用 unshare(CLONE_NEWNS) 或 mount() 实现挂载命名空间逃逸。示例代码片段：

// 触发 mount namespace 逃逸（需 CAP_SYS_ADMIN）
func escapeMountNS() {
    // 1. 创建新 mount ns
    syscall.Unshare(syscall.CLONE_NEWNS)
    // 2. 将 / 重新挂载为可读写（原容器 rootfs 通常为 ro）
    syscall.Mount("", "/", "", syscall.MS_REMOUNT|syscall.MS_RW, "")
    // 3. 挂载宿主机根目录（假设 /host 已绑定）
    syscall.Mount("/host", "/mnt/host", "none", syscall.MS_BIND, "")
}

容器运行时对 Golang 的特殊信任陷阱

Docker 和 containerd 默认允许 syscall 调用，且不拦截 SYS_unshare、SYS_mount 等敏感系统调用——这与 Java/JVM 的沙箱机制形成鲜明对比。常见加固策略对比：

措施	对 Golang 有效性	原因
--read-only 镜像	❌ 低	Go 程序可自行 unshare + remount 绕过
--cap-drop=ALL	⚠️ 中	需显式保留 CAP_SYS_ADMIN 才能调用 mount，但多数生产镜像仍保留该能力
seccomp.json 白名单	✅ 高	可精确禁用 unshare, mount, openat（含 /proc/*/mem）等逃逸关键 syscall

内核对象引用的隐式提权链

Golang 的 netlink socket 创建、epoll fd 复用、甚至 os/exec 启动子进程时的 clone() 行为，均可能触发 cgroup v1 的 release_agent 提权或 cgroup v2 的 cgroup.procs 写入竞争。防御关键在于：限制 bpf() 系统调用、禁用 release_agent、启用 cgroup2 并设置 noexec 挂载选项。

第二章：containerd shimv2协议栈深度逆向与利用

2.1 shimv2 gRPC接口设计缺陷与未授权调用路径挖掘

shimv2 的 RuntimeService 接口未对 ListContainers 等只读方法实施身份上下文校验，导致任意 TCP 连接可直连 shim socket 发起 gRPC 调用。

关键漏洞点：缺失 Authorization 拦截器

// runtime.proto（精简）
service RuntimeService {
  rpc ListContainers(ListContainersRequest) returns (ListContainersResponse);
  rpc StartContainer(StartContainerRequest) returns (StartContainerResponse);
}

该定义未声明 google.api.auth 注解，且服务端未注册 UnaryInterceptor 校验 context.Context 中的 authz.Token 字段。

未授权调用链路

• 攻击者构造裸 gRPC 请求（无需 TLS/证书）
• 直连 /run/containerd/shim/v2/{id}/shim.sock
• 调用 ListContainers → 获取容器 ID → 后续调用 ExecSync（若权限配置宽松）

方法名	是否校验 auth	可触发条件
ListContainers	❌	任意 UNIX socket 连接
ExecSync	⚠️（仅校验 namespace）	需已知容器 ID

graph TD
  A[攻击者] -->|HTTP/2 over Unix socket| B[shimv2 gRPC server]
  B --> C{UnaryServerInterceptor?}
  C -->|missing| D[直接进入 ListContainers handler]
  D --> E[返回所有容器元数据]

2.2 Go runtime goroutine调度劫持实现shim进程上下文窃取

Go runtime 的 g0（系统栈goroutine）与 m->gsignal 在信号处理时构成关键调度锚点。通过修改 m->g0->sched 中的 pc 和 sp，可将控制流重定向至自定义 shim 函数。

核心劫持点

• 调用 runtime.entersyscall 前触发 sigaltstack
• 利用 sigaction 注册 SIGURG 处理器，嵌入上下文快照逻辑
• 在 runtime.sigtramp 返回前篡改 g->sched

shim上下文窃取流程

// shim入口：劫持后执行的轻量级上下文捕获函数
func shimCapture() {
    // 读取当前m/g状态，绕过GC write barrier
    m := getg().m
    g0 := m.g0
    // 保存寄存器现场到shim私有内存页（m->shimCtx）
    saveRegisters(&m.shimCtx.regs, g0.sched.sp, g0.sched.pc)
}

此函数在非GC安全栈执行，直接操作 g0.sched 字段；sp 指向系统栈顶，pc 为被中断的用户goroutine返回地址，二者共同构成可恢复的执行上下文快照。

字段	来源	用途
g0.sched.sp	系统栈指针	定位寄存器保存位置
g0.sched.pc	中断前指令地址	构建跳转回点
m.shimCtx.regs	mmap分配的私有页	避免GC扫描干扰

graph TD
    A[goroutine进入syscall] --> B[触发SIGURG]
    B --> C[进入sigtramp]
    C --> D[篡改g0.sched.pc/sp]
    D --> E[跳转至shimCapture]
    E --> F[快照寄存器+栈帧]

2.3 shimv2插件机制中的unsafe.Pointer内存越界写入实践

shimv2通过PluginManager动态加载插件，其Register接口允许传入函数指针。当插件误用unsafe.Pointer进行跨边界写入时，会绕过Go内存安全检查。

越界写入触发场景

• 插件调用(*C.struct_plugin_ctx)(unsafe.Pointer(&ctx)).data访问超出分配长度的data字段
• ctx结构体末尾未预留足够padding，导致写入覆盖相邻内存

典型漏洞代码

// ctx.data 指向仅分配16字节的缓冲区
buf := C.CBytes(make([]byte, 16))
ctx.data = (*C.uchar)(buf)
// 危险：写入24字节 → 越界8字节
C.memcpy(unsafe.Pointer(ctx.data), unsafe.Pointer(&payload), 24) // payload为24字节

该调用使memcpy越过buf边界，污染后续堆块元数据，引发SIGSEGV或堆损坏。

安全加固对照表

措施	是否启用	效果
GODEBUG=gcstoptheworld=1	❌	无法拦截越界写入
CGO_CHECK=1	✅	仅校验C指针有效性，不检测越界
plugin包沙箱隔离	⚠️	shimv2未启用，依赖宿主进程权限

graph TD
    A[shimv2 Register] --> B[Plugin调用C.memcpy]
    B --> C{len(payload) > allocated}
    C -->|true| D[覆盖相邻内存]
    C -->|false| E[安全执行]

2.4 基于Go reflect包动态篡改shimv2 Task服务状态机实战

shimv2 的 Task 状态机（如 CREATED → READY → RUNNING → STOPPED）由不可导出字段 state uint32 和同步方法保护，常规调用无法绕过状态校验。

状态字段反射定位

// 获取 task 实例的 state 字段地址（需已知 struct 内存布局）
tValue := reflect.ValueOf(task).Elem()
stateField := tValue.FieldByName("state") // 注意：shimv2 v1.7+ 中为 unexported field
if stateField.CanAddr() && stateField.CanSet() {
    stateField.SetUint(3) // 强制设为 RUNNING (3)
}

逻辑分析：FieldByName 在非导出字段上仅当 reflect.Value 来自可寻址对象（如指针解引用）且包内可访问时才生效；CanSet() 返回 true 需满足 addressable && addressable 两重条件。参数 3 对应 runtime.TaskState_RUNNING 枚举值。

关键限制与风险

• ⚠️ Go 1.19+ 启用 unsafe 检查后，跨包修改未导出字段可能触发 panic
• ✅ 仅限测试/调试场景，生产环境禁止使用

修改方式	是否绕过校验	是否触发回调	安全等级
正常 API 调用	是	是	★★★★☆
reflect 强制写入	否（跳过）	否	★☆☆☆☆

graph TD A[获取Task指针] –> B[reflect.ValueOf().Elem()] B –> C[FieldByName“state”] C –> D{CanSet?} D –>|true| E[SetUint(newState)] D –>|false| F[panic: cannot set unexported field]

2.5 shimv2日志管道劫持与隐蔽信道构建（Go io.Copy+syscall.ForkExec）

shimv2 通过 stdout/stderr 文件描述符继承实现日志透传，攻击者可利用 io.Copy 非阻塞特性劫持父子进程间日志流。

日志管道劫持原理

容器运行时启动 shim 时，将日志 fd（如 3）传递给子进程。Go 中可通过 syscall.ForkExec 手动构造继承关系：

cmd := &syscall.ProcAttr{
    Files: []uintptr{0, 1, 2, uintptr(logFD)}, // 重用 logFD 为 fd=3
}
pid, err := syscall.ForkExec("/bin/sh", []string{"sh"}, cmd)

Files[3] 显式继承日志 fd，使子进程写入 fd=3 即等同于向 shim 日志管道写入——无需修改容器配置，即可注入可控日志数据。

隐蔽信道构建路径

• ✅ 利用 io.Copy(os.Stdout, conn) 将网络连接映射至 stdout（fd=1），再由 shim 转发至 runtime 日志系统
• ✅ 通过 syscall.Dup2(logFD, 3) 重定向任意 fd 至日志通道，规避常规 fd 检查

阶段	关键操作	隐蔽性
启动	ForkExec 继承日志 fd	无新进程、无网络连接
传输	io.Copy 流式转发	日志流中不可见协议头
解析	runtime 侧按行解析日志	依赖日志采集器未过滤二进制内容

graph TD
    A[恶意容器进程] -->|Write to fd=3| B[shimv2 日志管道]
    B --> C[containerd 日志模块]
    C --> D[ELK/Splunk 日志平台]
    D -->|Base64/Hex 编码载荷| E[攻击者解码端]

第三章：runc生命周期管理中的Go原语绕过点

3.1 runc init进程Go init函数链劫持与prestart hook bypass

Go init函数链的执行时序

runc 的 init 进程在容器启动早期即执行 Go 标准库的 init() 函数链（runtime.main → init → main）。该链在 main() 之前完成，且不可被 prestart hook 干预——因 hook 在 fork/exec 后、init 进程 execve 前注入，而 Go init 已在 main() 入口前静态绑定。

劫持点：runtime.SetFinalizer + init 重定向

func init() {
    // 劫持时机：在标准 init 链中插入恶意初始化逻辑
    runtime.SetFinalizer(&dummy, func(interface{}) {
        // 实际执行 hook 绕过后的特权操作（如挂载 /proc）
        syscall.Mount("none", "/proc", "proc", 0, "")
    })
}

此代码利用 Go init 的确定性执行顺序，在 runtime 初始化阶段注册终器，但终器触发依赖对象回收——实际不可靠；更稳定方式是直接 patch os.Args 或劫持 os/exec.Command 的 Run 方法。

prestart hook 失效原因对比

Hook 类型	注入时机	是否可见 Go init 链	是否可修改 runtime 状态
prestart (OCI)	runc create 后、runc start 中 fork() 之后	❌ 不可见	❌ 无法干预 init 进程的 Go 初始化
poststart	init 进程 execve 成功后	✅ 可见	✅ 可调用 ptrace 或 /proc/[pid]/mem

绕过路径图

graph TD
    A[runc start] --> B[fork child]
    B --> C[execve /proc/self/exe --no-new-privs]
    C --> D[Go runtime.init chain]
    D --> E[main.main]
    subgraph Hook Injection Point
        B -.-> F[prestart hook runs here]
    end
    F -. cannot affect .-> D

3.2 Go net/http server在runc monitor中暴露的未鉴权debug endpoint利用

runc monitor 默认启用 net/http 服务，监听 127.0.0.1:6060/debug/pprof/，但未做任何访问控制。

未鉴权端点暴露面

• /debug/pprof/：返回所有可用 profile 列表
• /debug/pprof/goroutine?debug=2：获取完整 goroutine 栈跟踪（含运行时状态）
• /debug/pprof/heap：导出内存堆快照

典型利用链

// 启动 monitor 时未禁用 debug 端口（默认行为）
if debugAddr != "" {
    go func() {
        log.Println(http.ListenAndServe(debugAddr, nil)) // ❌ 无 Handler 限制，nil 即 pprof.DefaultServeMux
    }()
}

该代码直接暴露 pprof 内置路由，且 ListenAndServe 绑定到 127.0.0.1 —— 若容器网络配置异常（如 hostNetwork 或特权模式），可能被外部访问。

端点	敏感信息	利用场景
/debug/pprof/goroutine?debug=2	协程栈、函数参数、环境变量引用	泄露 credential 初始化路径
/debug/pprof/heap	对象分配位置、结构体字段名	辅助逆向 runc 内部状态机

graph TD
    A[攻击者发起 HTTP GET] --> B[/debug/pprof/goroutine?debug=2]
    B --> C[返回全部 goroutine 栈帧]
    C --> D[定位 monitor 主循环与 container state channel]
    D --> E[推断容器生命周期事件监听逻辑]

3.3 runc spec解析器中json.Unmarshal导致的Go panic逃逸链构造

runc spec 命令调用 json.Unmarshal 解析用户传入的 config.json，但未对嵌套结构做深度校验。当输入含非法递归引用（如 $ref 循环）或超深嵌套对象时，encoding/json 的反射解码器会触发栈溢出或无限递归，最终 panic 逃逸至 main.main 外部。

关键逃逸路径

• json.Unmarshal → unmarshalType → reflect.Value.Set → panic("invalid memory address")
• runc 默认未设置 recover() 捕获机制，panic 直接终止进程

典型触发 payload

{
  "ociVersion": "1.0.2",
  "process": {
    "args": ["sh", "-c", "echo hello"],
    "env": [{"name":"A","value":"${A}"}]
  }
}

注：该 JSON 在 runc v1.1.12 中因 env 字段被误解析为嵌套结构，触发 json.(*Unmarshaler).UnmarshalJSON 递归调用，导致栈帧失控增长。

阶段	函数调用栈深度	是否可控
初始解析	3–5 层	是
递归引用展开	>100 层	否（panic 前无检查）
panic 传播	至 runtime.goPanic	逃逸链完成

graph TD
    A[runc spec -f config.json] --> B[json.Unmarshal]
    B --> C[decodeState.unmarshal]
    C --> D[reflect.Value.Set]
    D --> E{栈深度 > 1024?}
    E -->|是| F[panic: stack overflow]
    E -->|否| G[继续解码]

第四章：Golang标准库与容器运行时耦合漏洞挖掘

4.1 syscall.SyscallContext在runc create流程中的context.Done()竞态绕过

竞态根源：syscall.SyscallContext的上下文感知缺陷

syscall.SyscallContext 在 runc create 中被用于阻塞式系统调用（如 clone），但其未原子性地监听 context.Done() 与内核态进入之间的窗口期。

关键代码路径

// runc/libcontainer/process_linux.go:267
_, _, err := syscall.SyscallContext(ctx, syscall.SYS_CLONE, flags, uintptr(unsafe.Pointer(&stack[0])), 0)
if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
    return err // 仅检查返回值，不保证调用未进入内核
}

逻辑分析：SyscallContext 仅在系统调用返回后检查 ctx.Err()，若 context.Cancel() 在 clone() 进入内核后、返回前触发，则 goroutine 无法及时退出，子进程已创建却无人接管——形成“孤儿容器”竞态。

竞态窗口对比表

阶段	是否可中断	检测时机	风险
context.WithCancel() 调用	✅	用户空间	安全
clone() 进入内核	❌	内核态	竞态窗口
SyscallContext 返回	✅	用户空间	滞后检测

修复策略流向

graph TD
    A[ctx.Cancel()] --> B{syscall.SyscallContext}
    B --> C[进入clone内核态]
    C --> D[内核创建子进程]
    D --> E[返回用户态]
    E --> F[检查ctx.Err\(\)]
    F -->|延迟| G[子进程已运行但未被监控]

4.2 Go os/exec.CommandContext超时机制失效导致hook阻塞逃逸

根本成因：Context取消信号未传递至子进程树

os/exec.CommandContext 仅向直接启动的进程发送 SIGKILL，但若该进程 fork 出子进程且未正确处理信号传播（如未设置 Setpgid: true 或忽略 SIGINT/SIGTERM），则 Context 超时后父进程虽退出，子进程仍持续运行——形成 hook 阻塞逃逸。

复现代码示例

ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
defer cancel()

cmd := exec.CommandContext(ctx, "sh", "-c", "sleep 5 && echo 'done'")
// ❌ 缺少 syscall.Setpgid，子进程脱离控制组
err := cmd.Run()

逻辑分析：cmd.Run() 在超时后终止 sh 进程，但 sleep 子进程继承原会话、未被信号覆盖，继续运行直至自然结束。ctx.Done() 触发仅杀主进程，无法级联终止整个进程组。

关键修复方案对比

方案	是否解决逃逸	适用场景	风险
cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}	✅	Linux/macOS	需 root 权限启用 PR_SET_CHILD_SUBREAPER
exec.Command("timeout", "1s", "sh", "-c", "...")	⚠️	快速兼容	依赖系统 timeout 工具

正确实践流程

graph TD
    A[创建带超时的Context] --> B[设置SysProcAttr.Setpgid=true]
    B --> C[启动命令并加入进程组]
    C --> D[超时触发kill -TERM -pgid]
    D --> E[全组进程同步终止]

4.3 net/url.Parse与oci-runtime-spec中URI解析不一致引发的hook注入

OCI 运行时规范要求 hook URI 必须为绝对路径或合法网络 URI（如 file:///etc/hooks/prestart），但 Go 标准库 net/url.Parse 将 file://etc/hooks 解析为 Scheme="file"、Path="/etc/hooks"，而 file:etc/hooks 却被解析为 Scheme="file"、Path="etc/hooks" —— 缺少根路径导致绕过校验。

URI 解析差异对比

输入字符串	net/url.Parse 结果（Scheme, Path）	OCI 规范预期
file:///etc/hook	"file", "/etc/hook"	✅ 合法绝对路径
file:etc/hook	"file", "etc/hook"	❌ 相对路径，应拒绝

漏洞触发链

u, _ := url.Parse("file:../host/etc/shadow") // ⚠️ 被解析为 Path="../host/etc/shadow"
if !strings.HasPrefix(u.Path, "/") {
    // 错误地认为这是安全的相对路径，未拦截
    runHook(u.Path) // 实际触发宿主机路径遍历
}

url.Parse 不校验 file: 前缀后的路径合法性；OCI runtime 依赖此输出做白名单判断，导致 file:../ 类向量绕过防护。

修复建议

• 使用 filepath.IsAbs() + filepath.Clean() 双重校验路径；
• 强制要求 file:// scheme 后必须为绝对 URI（即 u.Scheme == "file" && u.Host == "" && filepath.IsAbs(u.Path)）。

4.4 Go plugin包动态加载特性在containerd shim插件中的提权滥用

Go 的 plugin 包允许运行时加载 .so 文件，但不进行符号可见性校验与权限沙箱隔离。containerd shim v2 插件机制（如 shim-v2）依赖 plugin.Open() 加载用户提供的 shim.so，而该过程以 containerd 主进程 UID 执行。

动态加载流程风险点

// shim/loader.go 片段
p, err := plugin.Open("/path/to/shim.so") // 无路径白名单、无签名验证
if err != nil { return err }
sym, _ := p.Lookup("ShimCreate")          // 直接解析任意导出符号
shimFn := sym.(func(...))                 // 类型断言绕过编译期检查

plugin.Open() 以当前进程权限读取并 mmap 共享库，Lookup 可调用任意导出函数——包括 os.Setuid(0) 或 syscall.Setsid() 等特权操作。

攻击链路示意

graph TD
    A[攻击者编译恶意shim.so] --> B[注入containerd插件目录]
    B --> C[containerd调用plugin.Open]
    C --> D[恶意符号执行setuid(0)]
    D --> E[获得root shim进程上下文]

风险维度	默认状态	缓解建议
插件路径校验	无	强制限定 /usr/lib/containerd/shim/
二进制签名验证	缺失	集成 cosign 验证 .so 签名
运行时能力限制	宽松	使用 ambient capabilities 降权加载

第五章：云原生容器逃逸的防御范式重构与Go安全编码守则

防御范式从边界守卫转向运行时纵深感知

传统容器安全依赖于镜像扫描与网络策略，但2023年CNCF威胁报告指出，73%的生产环境逃逸事件发生在运行时——攻击者利用特权容器挂载宿主机/proc、滥用CAP_SYS_ADMIN能力或通过runc漏洞（如CVE-2024-21626）劫持容器运行时。某金融客户在K8s集群中部署了合规镜像，却因未禁用hostPath卷且Pod配置了allowPrivilegeEscalation: true，导致恶意容器通过/dev/kmsg写入内核日志并触发eBPF模块提权。防御必须嵌入到容器生命周期各阶段：构建时强制启用docker build --security-opt=no-new-privileges，部署时通过OPA Gatekeeper策略拒绝含privileged: true的PodSpec，运行时使用eBPF驱动的Falco规则实时检测openat(AT_FDCWD, "/host/", ...)系统调用。

Go语言中危险syscall的零容忍封装

Go标准库syscall包直接暴露底层接口，易引发容器逃逸链。以下代码片段存在严重风险：

// ❌ 危险：直接调用unshare()创建新命名空间，绕过Kubernetes安全上下文约束
_, _, err := syscall.Syscall(syscall.SYS_UNSHARE, uintptr(syscall.CLONE_NEWNS), 0, 0)

// ✅ 安全：封装为显式禁止函数，编译期拦截
func forbidUnshare() {
    panic("unshare syscall forbidden in containerized context")
}

团队在CI流水线中集成gosec静态扫描，并自定义规则标记所有syscall.Syscall*调用，同时将os/exec.Command的SysProcAttr字段设为不可导出结构体，强制开发者使用预审策略的SafeExecRunner。

基于eBPF的容器进程行为基线建模

进程类型	允许系统调用	禁止访问路径	监控粒度
Nginx工作进程	read, write, sendto	/proc/sys/, /sys/fs/cgroup/	每秒采样5次
Go微服务主进程	epoll_wait, accept4	/dev/mem, /host/boot/	调用栈深度≤3

采用libbpf-go构建内核探针，在tracepoint/syscalls/sys_enter_openat处注入校验逻辑：若进程PID所属cgroup路径包含kubepods/burstable/pod-前缀，且目标路径以/host/开头，则立即向Prometheus推送container_escape_attempt_total{pod="payment-api-7f9d"}指标，并触发K8s Admission Webhook终止Pod。

容器运行时加固的自动化验证清单

• [ ] runc版本≥1.1.12（修复runc exec -d竞争条件）
• [ ] containerd配置no_new_privileges = true全局生效
• [ ] 所有PodSpec中securityContext.seccompProfile.type设为RuntimeDefault
• [ ] kubelet启动参数包含--feature-gates=RestrictServiceExternalIP=true

某电商大促期间，通过Ansible Playbook自动轮询集群节点，发现3台Node的/etc/containerd/config.toml未启用seccomp_default，脚本立即执行sed -i '/\[plugins."io.containerd.grpc.v1.cri"\]/a\ seccomp_default = true'并滚动重启containerd服务。

Go安全编码的十二项强制契约

所有Go服务必须满足：禁用unsafe包导入（go vet -tags=unsafe失败即阻断CI）、http.Server必须设置ReadTimeout: 5 * time.Second、crypto/rand.Read替代math/rand、template.Parse前对用户输入执行strings.ReplaceAll(input, "{{", "[[")转义。某支付网关曾因模板注入导致{{.Env.POD_NAME}}泄露集群拓扑，现强制所有HTML模板编译前经html/template沙箱二次解析。

flowchart LR
    A[CI Pipeline] --> B[go mod vendor]
    B --> C[gosec -exclude=G104,G107]
    C --> D[custom linter: forbid syscall.*]
    D --> E[build with -ldflags '-extldflags \"-z noexecstack\"']
    E --> F[container image scan via Trivy]

持续交付流水线中，每个Go二进制文件在CGO_ENABLED=0模式下交叉编译，生成的静态链接可执行文件经readelf -l ./svc | grep 'GNU_STACK'验证栈不可执行属性，最终镜像层仅保留/app/svc单个文件，彻底消除/bin/sh等攻击面。