Go跨平台环境变量污染链：Shell启动方式（login/non-login）、systemd –scope、Docker ENTRYPOINT、IDE调试器注入——5类PATH/LD_LIBRARY_PATH污染场景与隔离方案

第一章：Go跨平台环境变量污染链的全景认知

Go语言的跨平台编译能力常被开发者视为优势，但其构建过程对环境变量的高度依赖，却在不同操作系统间埋下了隐蔽的污染风险。GOOS、GOARCH、CGO_ENABLED等变量不仅控制目标平台行为，还会与PATH、LD_LIBRARY_PATH（Linux/macOS）或PATH、CGO_LDFLAGS（Windows）产生连锁反应，导致同一代码在不同环境生成不一致的二进制产物。

环境变量的隐式传播路径

当执行go build时，Go工具链会按如下顺序读取并合并变量：

• 系统级全局环境（如/etc/environment或注册表）
• Shell启动配置（.bashrc、.zshrc、$PROFILE）
• 当前Shell会话显式设置（export GOOS=windows）
• 构建脚本中env子命令或go env -w持久化配置
  任意层级的变量残留都可能穿透CI/CD流水线，在交叉编译场景下引发静默失效。

典型污染案例复现

以下命令可验证当前环境是否已被污染：

# 检查所有Go相关环境变量（含隐式继承项）
go env -json | jq 'select(.GOOS or .GOARCH or .CGO_ENABLED)'

# 清除CGO相关变量后重新构建，对比符号表差异
env -u CGO_ENABLED -u CC -u CXX go build -o clean-bin main.go
file clean-bin  # 观察是否为纯静态链接

关键污染变量对照表

变量名	Linux影响	Windows影响	风险等级
CC	控制C编译器路径，影响cgo调用	通常被忽略（除非启用MSVC）	⚠️⚠️⚠️
PKG_CONFIG_PATH	导致动态库路径误判，链接失败	无作用	⚠️⚠️
GOROOT_FINAL	若被修改，破坏标准库路径解析	同样破坏runtime初始化逻辑	⚠️⚠️⚠️⚠️

防御性构建实践

始终采用显式隔离环境执行构建：

# 使用env -i启动纯净Shell，仅注入必需变量
env -i \
  GOOS=linux \
  GOARCH=amd64 \
  CGO_ENABLED=0 \
  PATH="/usr/local/go/bin:/usr/bin" \
  go build -ldflags="-s -w" -o dist/app-linux main.go

该方式彻底切断父进程环境泄漏，确保构建结果可重现。

第二章：Shell启动方式引发的PATH/LD_LIBRARY_PATH污染

2.1 login shell与non-login shell的环境初始化机制剖析与实测对比

启动场景差异

• login shell：由内核调用 execv 启动，如 ssh user@host、login 或 bash -l，读取 /etc/profile → ~/.bash_profile（或 ~/.bash_login/~/.profile）
• non-login shell：子进程启动，如终端中直接执行 bash，仅加载 ~/.bashrc

初始化文件加载路径对比

Shell类型	加载文件顺序（优先级从高到低）
login shell	/etc/profile → ~/.bash_profile → ~/.bashrc（若显式source）
non-login shell	~/.bashrc（仅此）

# 检测当前shell类型
echo $0          # login shell显示为"-bash"（破折号前缀），non-login为"bash"
shopt login_shell  # 输出 "login_shell on" 或 "off"

shopt login_shell 是 Bash 内置命令，直接查询 shell 的启动标志位；$0 前缀破折号由 kernel 在 execve 时设置，是 POSIX 标准约定。

初始化流程可视化

graph TD
    A[Shell启动] --> B{是否login?}
    B -->|Yes| C[/etc/profile]
    C --> D[~/.bash_profile]
    D --> E[显式source ~/.bashrc?]
    B -->|No| F[~/.bashrc]

2.2 /etc/profile、~/.bashrc、~/.bash_profile加载顺序对Go构建路径的实际影响

Shell启动时的配置文件加载顺序直接影响$GOPATH与$PATH的最终值，进而决定go build能否定位到本地模块或工具（如gopls）。

加载时机差异

• 登录shell（如SSH登录）：依次读取 /etc/profile → ~/.bash_profile（若存在）→ ~/.bashrc（仅当显式source）
• 非登录交互shell（如新终端Tab）：仅加载 ~/.bashrc

关键路径覆盖示例

# ~/.bash_profile 中误写（未export）
GOPATH=$HOME/go
PATH=$PATH:$GOPATH/bin  # ❌ 未export，子进程不可见

# ~/.bashrc 中正确声明
export GOPATH="$HOME/go"
export PATH="$PATH:$GOPATH/bin"  # ✅ 生效于所有交互shell

该片段导致go install生成的二进制在新终端中“命令未找到”，因$PATH未被导出继承。

实际影响对比表

文件	是否影响go build	是否影响go install生成命令调用	原因
/etc/profile	是	否（除非全局export）	系统级，但用户级PATH易覆盖
~/.bash_profile	仅登录shell生效	是（若正确export）	启动时一次性注入
~/.bashrc	是（所有交互shell）	是（推荐位置）	每次新开终端均生效

加载逻辑流程图

graph TD
    A[Shell启动] --> B{是否为登录shell?}
    B -->|是| C[/etc/profile]
    C --> D[~/.bash_profile]
    D --> E[是否source ~/.bashrc?]
    E -->|是| F[~/.bashrc]
    B -->|否| F

2.3 Go toolchain在不同shell类型下解析GOROOT/GOPATH的差异性行为验证

Go工具链依赖shell环境变量展开机制，bash、zsh与fish对$GOROOT和$GOPATH的解析存在本质差异。

环境变量展开时机差异

• bash/zsh：在启动时静态展开export GOPATH=$HOME/go（仅首次求值）
• fish：动态延迟展开，支持set -gx GOPATH $HOME/go实时重求值

实测行为对比

Shell	export GOPATH=$HOME/go 后执行 go env GOPATH	是否生效
bash	/home/user/go（若$HOME已定义）	✅
fish	$HOME/go（字面量未展开）	❌

# fish中正确写法（显式展开）
set -gx GOPATH (echo $HOME)/go

此命令调用echo $HOME子shell获取真实路径，避免fish的变量延迟展开缺陷；-gx确保全局+导出，等效于bash的export。

解析流程示意

graph TD
    A[Shell启动] --> B{Shell类型}
    B -->|bash/zsh| C[环境变量静态展开]
    B -->|fish| D[变量名字面保留]
    C --> E[go command读取$GOPATH]
    D --> F[需显式展开或使用$HOME内建]

2.4 使用strace+env -i复现Go程序启动时环境变量继承漏洞的完整实验流程

构建易受攻击的Go程序

package main
import "os"
func main() {
    println("PATH:", os.Getenv("PATH"))
    println("HOME:", os.Getenv("HOME"))
}

该程序未显式清理环境，直接读取PATH与HOME——这是漏洞触发点。Go运行时默认继承父进程全部环境变量，包括敏感项（如LD_PRELOAD）。

复现命令链

• env -i PATH=/bin:/usr/bin HOME=/tmp strace -e trace=execve ./main
• env -i LD_PRELOAD=./malicious.so strace -e trace=execve ./main

关键观察表

环境设置方式	是否继承LD_PRELOAD	execve系统调用可见性
env -i	否（被清空）	显示干净envp数组
env -i ... LD_PRELOAD=...	是（显式注入）	显示恶意so路径被传递

漏洞链路

graph TD
A[env -i注入LD_PRELOAD] --> B[strace捕获execve]
B --> C[Go runtime执行syscall]
C --> D[动态链接器加载恶意so]

2.5 构建shell wrapper脚本隔离Go构建环境的工程化实践（含bash/zsh/fish兼容方案）

设计目标

统一管理 GOROOT、GOPATH 及 Go 版本，避免污染宿主环境，支持多项目并行构建。

跨Shell兼容核心逻辑

# detect shell and set appropriate hook
case "${0##*/}" in
  bash|zsh)  set -o allexport ;;
  fish)      set -gx GOROOT "$GO_INSTALL_DIR" ;;
esac
export GOROOT="$GO_INSTALL_DIR"
export GOPATH="$PROJECT_ROOT/.gopath"
export PATH="$GOROOT/bin:$GOPATH/bin:$PATH"

此段通过 $0 解析当前执行 Shell 类型：bash/zsh 使用 set -o allexport 自动导出后续变量；fish 则用 set -gx 全局导出。路径严格限定为项目内 .gopath，实现完全隔离。

支持的 Shell 特性对比

Shell	变量导出语法	配置加载点	兼容性保障
bash	export VAR=val	source wrapper.sh	✅ POSIX 兼容
zsh	同 bash	source wrapper.sh	✅ 启用 allexport
fish	set -gx VAR val	source wrapper.fish	✅ 单独适配脚本

执行流程

graph TD
  A[调用 wrapper.sh] --> B{检测 SHELL 类型}
  B -->|bash/zsh| C[启用 allexport + 导出环境]
  B -->|fish| D[跳转至 wrapper.fish]
  C & D --> E[执行 go build]

第三章：systemd –scope与Go服务进程的环境变量逃逸

3.1 systemd unit上下文与–scope临时scope的环境继承模型深度解析

systemd 的 --scope 机制并非简单创建新 cgroup，而是构建一个环境继承链：临时 scope 默认继承调用者（如 shell）的全部 Environment, WorkingDirectory, User/Group, 以及 Capabilities 上下文，但不继承 Limit* 和 OOMScoreAdjust 等资源策略。

环境继承的关键规则

• 环境变量：父进程 env → scope unit 的 Environment=（只读快照，后续 export 不影响 unit）
• 工作目录：--scope 自动捕获当前 pwd，等效于隐式设置 WorkingDirectory=
• 权限上下文：--scope 进程始终运行在调用者 UID/GID 下，除非显式指定 --scope --user

实例验证

# 启动带环境标记的临时 scope
systemd-run --scope --scope --property=Environment="TRACE=1" \
            --property=WorkingDirectory="/tmp" \
            sh -c 'echo "PWD: $PWD, TRACE: $TRACE"'

此命令中 --property=Environment 覆盖默认继承，而 WorkingDirectory 显式设为 /tmp；若省略该 property，则 $PWD 将继承调用时的实际路径。--scope 的 --property 可叠加修改继承上下文，但不可绕过安全边界（如 RootDirectory）。

继承项	是否默认继承	可否通过 --property 覆盖
Environment	✅	✅
WorkingDirectory	✅	✅
MemoryLimit	❌	✅（需 root 权限）

graph TD
    A[调用进程] -->|fork+exec| B[systemd-run]
    B --> C[scope.slice 单元]
    C --> D[继承 Environment/UID/CWD]
    C --> E[忽略 LimitCPU/LimitMEM]

3.2 LD_LIBRARY_PATH在systemd服务中被意外继承导致CGO动态链接失败的典型案例复现

当 systemd 启动 Go 服务（含 CGO）时，若父进程（如 shell）设置了 LD_LIBRARY_PATH，该变量可能被继承，干扰 libgcc 或自定义 C 库的符号解析。

复现步骤

• 编写含 import "C" 的 Go 程序，调用 dlopen("libfoo.so", RTLD_NOW)
• 在用户 shell 中执行：export LD_LIBRARY_PATH="/tmp/invalid:/usr/local/lib"
• 使用 systemctl --user start mygo.service 启动（未显式清理环境）

关键 systemd 配置缺失

[Service]
Environment="LD_LIBRARY_PATH="
# 或更安全地：
UnsetEnvironment=LD_LIBRARY_PATH

⚠️ 分析：Environment= 是清空赋值（非追加），而 UnsetEnvironment 显式剥离变量；若省略，systemd 默认继承 LD_LIBRARY_PATH（尤其在 --user 模式下受 login session 影响更大）。

错误表现对比表

场景	LD_LIBRARY_PATH 是否继承	CGO 调用结果
交互式 go run	是（shell 提供）	成功（路径存在）
systemd 服务（无清理）	是（意外继承）	dlopen: file not found（优先搜索 /tmp/invalid）
systemd 服务（显式 UnsetEnvironment）	否	回退系统默认路径，成功

graph TD
    A[systemd 启动服务] --> B{是否 UnsetEnvironment=LD_LIBRARY_PATH?}
    B -->|否| C[继承父进程 LD_LIBRARY_PATH]
    B -->|是| D[环境变量被剥离]
    C --> E[CGO dlopen 按错误顺序搜索路径]
    D --> F[使用 /etc/ld.so.cache + 默认路径]

3.3 使用systemd-run –scope –collect + ExecStartPre环境净化策略保障Go二进制纯净执行

环境污染的典型诱因

Go 二进制虽静态链接，但仍受 LD_LIBRARY_PATH、PATH、GODEBUG 等变量干扰，导致非预期行为（如 cgo fallback、GC 调度偏差）。

核心防护组合

• systemd-run --scope --collect：创建瞬时 scope 单元，进程退出后自动清理资源与命名空间残留；
• ExecStartPre：在主服务启动前强制重置关键环境变量。

# 启动脚本片段（service unit 中）
ExecStartPre=/bin/sh -c 'unset LD_LIBRARY_PATH GODEBUG CGO_ENABLED && export PATH="/usr/bin:/bin"'
ExecStart=/opt/app/myapp

逻辑分析：ExecStartPre 在 systemd fork 子进程前执行 shell 命令，unset 清除危险变量，export PATH 锁定最小可信路径。--scope --collect 确保即使进程崩溃，其 cgroup、namespace 及挂载点亦被自动回收，杜绝环境“泄漏”。

净化效果对比

环境变量	默认行为	净化后状态
LD_LIBRARY_PATH	可能加载非系统 libc	完全 unset
GODEBUG	影响 GC/调度调试	强制清除
PATH	包含用户自定义 bin	限定为 /usr/bin:/bin

graph TD
    A[systemd-run --scope --collect] --> B[创建临时 scope cgroup]
    B --> C[执行 ExecStartPre 清理环境]
    C --> D[启动 Go 二进制]
    D --> E[进程退出]
    E --> F[自动 collect：cgroup 销毁 + namespace 解绑]

第四章：容器化与IDE调试场景下的Go环境污染

4.1 Docker ENTRYPOINT执行模式（shell vs exec）对Go应用环境变量注入路径的差异化影响

Shell 模式下的环境变量可见性陷阱

当使用 ENTRYPOINT ["sh", "-c", "go run main.go"] 时，Shell 进程作为 PID 1 启动，继承全部 docker run -e 注入的环境变量，但 Go 应用通过 os.Getenv() 读取时实际依赖 shell 的变量展开时机。

# shell 模式：变量在 shell 解析阶段注入
ENTRYPOINT ["sh", "-c", "echo \"ENV: $APP_ENV\" && exec go run main.go"]

此处 $APP_ENV 在 sh 解析命令字符串时即被替换（若未定义则为空），Go 进程无法动态感知后续 docker run -e APP_ENV=prod 的值——除非改用 $$APP_ENV 延迟展开。

Exec 模式下的纯净继承

ENTRYPOINT ["go", "run", "main.go"] 直接 exec，绕过 shell，环境变量由 Docker 守护进程直接注入 Go 进程的 environ，os.Getenv("APP_ENV") 可实时获取运行时传入值。

模式	PID 1 进程	环境变量注入时机	Go os.Getenv() 可见性
shell	/bin/sh	ENTRYPOINT 字符串解析时	❌（仅限静态展开）
exec	go run	容器启动时内核级注入	✅（完整 runtime 可见）

关键差异流程

graph TD
    A[docker run -e APP_ENV=prod] --> B{ENTRYPOINT 类型}
    B -->|shell| C[sh -c “...” → 展开$APP_ENV]
    B -->|exec| D[execve(go, [...]) → environ 直接传递]
    C --> E[Go 进程读取空/默认值]
    D --> F[Go 进程读取 prod]

4.2 CGO_ENABLED=1时LD_LIBRARY_PATH在多阶段构建中跨镜像层污染的溯源与阻断方法

污染根源：构建阶段环境变量残留

当 CGO_ENABLED=1 时，Go 编译器依赖系统动态链接器（如 ld-linux-x86-64.so），并读取 LD_LIBRARY_PATH 加载 .so 文件。若该变量在 builder 阶段被显式设置（如 ENV LD_LIBRARY_PATH=/usr/local/lib），其值可能通过 COPY --from= 或隐式层继承意外带入 final 阶段。

复现验证代码

# 构建阶段（builder）
FROM golang:1.22 AS builder
ENV LD_LIBRARY_PATH=/tmp/custom-libs  # ⚠️ 污染源
RUN go build -o /app/main .

# 最终阶段（alpine，无 libc 兼容性）
FROM alpine:3.20
COPY --from=builder /app/main /app/main
# 此时 LD_LIBRARY_PATH 未被清除，但 alpine 中该路径无效且触发静默失败

逻辑分析：ENV 指令创建的环境变量在 --from 复制时不传递，但若 builder 中通过 RUN export LD_LIBRARY_PATH=... && ./build.sh 临时设置，且脚本将变量写入二进制元数据（如 cgo 的 -ldflags="-linkmode external"），则 runtime 仍会尝试解析该路径——尤其当 binary 含 rpath 或 DT_RUNPATH 条目时。

阻断策略对比

方法	是否清除 LD_LIBRARY_PATH	是否重置 rpath	适用场景
CGO_ENABLED=0	✅（完全规避）	—	纯 Go 项目
strip --strip-all + patchelf --remove-rpath	❌（需手动清理）	✅	必须启用 cgo 的场景
FROM scratch + 显式 COPY /lib/ld-musl-x86_64.so.1	✅（无 shell 环境）	—	musl 链接

推荐防御流程

graph TD
    A[Builder 阶段] --> B[编译前 unset LD_LIBRARY_PATH]
    B --> C[使用 patchelf 清除 rpath]
    C --> D[Final 阶段仅 COPY 二进制]
    D --> E[ENTRYPOINT 不继承任何 ENV]

4.3 VS Code Delve调试器注入机制导致GOROOT/GOPATH被覆盖的调试会话级复现与修复

复现场景

当 VS Code 启动 dlv 调试会话时，会通过 env 注入预设环境变量，优先级高于用户 shell 配置，导致 GOROOT 和 GOPATH 被覆盖。

关键注入逻辑

VS Code 的 launch.json 中若配置 "env" 字段，将直接合并至调试进程环境：

{
  "env": {
    "GOROOT": "/usr/local/go-1.21",
    "GOPATH": "${workspaceFolder}/.gopath"
  }
}

此处 ${workspaceFolder} 由 VS Code 解析为绝对路径；GOROOT 若指向非标准安装路径，Delve 可能因 go version 检查失败而静默降级行为。

修复方案对比

方案	是否持久	是否影响多项目	推荐度
修改 launch.json 移除 env 中 GOROOT/GOPATH	✅ 调试会话级生效	✅ 隔离	⭐⭐⭐⭐
使用 "envFile" 加载 .env（含正确路径）	✅ 支持变量复用	✅	⭐⭐⭐
全局禁用自动注入（不推荐）	❌ 破坏其他扩展兼容性	❌	⚠️

根本解决流程

graph TD
  A[VS Code 启动调试] --> B[读取 launch.json]
  B --> C{env 字段是否显式声明 GOROOT/GOPATH？}
  C -->|是| D[覆盖 shell 环境变量]
  C -->|否| E[继承父进程环境]
  D --> F[Delve 初始化失败/模块解析异常]
  E --> G[正常加载 go.mod & GOPROXY]

4.4 GoLand远程调试通道中环境变量自动注入行为分析及launch.json精准控制实践

GoLand 在远程调试（如 Attach 到 Docker 容器或远程主机）时，默认会将本地 IDE 环境变量（如 GOROOT、GOPATH、GO111MODULE）自动注入到调试进程，可能覆盖容器内预设值，导致模块解析失败或路径错误。

自动注入的典型干扰场景

• 容器内使用 go mod vendor 但本地 GO111MODULE=on 强制启用模块模式
• 远程 GOROOT 指向 /usr/local/go，而本地注入了 /opt/go 导致 runtime 包版本不匹配

launch.json 的显式覆盖策略

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Remote Debug (Docker)",
      "type": "go",
      "request": "attach",
      "mode": "exec",
      "processId": 0,
      "env": {
        "GO111MODULE": "off",
        "GOROOT": "/usr/local/go",
        "GODEBUG": "asyncpreemptoff=1"
      },
      "envFile": "${workspaceFolder}/.env.remote"
    }
  ]
}

该配置中 env 字段完全替代自动注入行为（非合并），确保远程运行时环境确定性；envFile 支持外部变量复用，避免硬编码敏感值。

行为类型	是否可禁用	控制粒度
IDE 全局变量注入	❌ 否	仅通过 env 覆盖
envFile 加载	✅ 是	按配置项独立生效
env 合并本地	❌ 否（全量替换）	必须显式声明全部

graph TD
  A[启动远程调试] --> B{GoLand 检测调试模式}
  B -->|Attach/Exec| C[读取 launch.json]
  C --> D[忽略本地环境变量]
  C --> E[严格应用 env 字段]
  E --> F[执行 dlv --headless]

第五章：Go跨平台环境变量污染治理的统一范式

环境变量污染的真实代价

某金融级CLI工具在Windows构建时因GOROOT被CI脚本误设为C:\go\1.20，而实际运行时宿主系统安装的是C:\go\1.21，导致go run静默降级至旧版本编译器，生成的二进制文件在生产环境触发runtime: goroutine stack exceeds 1000000000-byte limit崩溃。该问题在Linux/macOS测试中完全不可复现，排查耗时37小时。

Go标准库的隐式依赖链

os/exec调用exec.LookPath时会遍历PATH中每个目录查找可执行文件；net/http默认读取HTTP_PROXY并自动启用代理；crypto/tls在Windows上依赖SSL_CERT_FILE或注册表证书存储。这些行为均不显式声明依赖，却构成跨平台脆弱性基线。

污染源分类与检测矩阵

污染类型	典型场景	检测命令	修复优先级
静态继承污染	Docker build中ENV GOPROXY=...	go env -json \| jq '.GOPROXY'	⚠️⚠️⚠️
动态注入污染	GitHub Actions env:块覆盖GOOS	echo $GOOS; go version	⚠️⚠️⚠️⚠️
用户配置污染	~/.bashrc中export CGO_ENABLED=0	grep CGO_ENABLED ~/.bashrc	⚠️⚠️

统一初始化守卫模式

在main.go入口强制执行环境净化：

func init() {
    // 清除所有Go相关环境变量（保留GOOS/GOARCH用于交叉编译）
    for _, key := range []string{"GOROOT", "GOPATH", "GOCACHE", "GOPROXY"} {
        if os.Getenv(key) != "" && key != "GOOS" && key != "GOARCH" {
            os.Unsetenv(key)
        }
    }
    // 强制设置可信值
    os.Setenv("GOMODCACHE", filepath.Join(os.TempDir(), "gomodcache"))
}

构建时环境快照验证

使用go list -f '{{.Env}}' -m std获取模块构建环境快照，并与基准签名比对：

# 生成黄金快照（Linux x86_64）
go list -f '{{.Env}}' -m std | sha256sum > baseline.env.sha256

# CI中验证
go list -f '{{.Env}}' -m std | sha256sum -c baseline.env.sha256 || exit 1

跨平台Mermaid污染路径追踪

flowchart LR
    A[CI Runner启动] --> B{OS检测}
    B -->|Linux| C[读取/etc/environment]
    B -->|Windows| D[读取注册表HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\Environment]
    C --> E[加载shell profile]
    D --> F[加载User Environment Variables]
    E & F --> G[执行go build]
    G --> H[go env输出污染变量]
    H --> I[静态分析识别异常值]

实战案例：Electron-Go混合应用

某桌面应用在macOS打包时因CGO_ENABLED=1被用户.zshrc全局设置，导致libusb动态链接失败；切换至CGO_ENABLED=0后又因net包DNS解析退化引发API超时。最终采用双阶段构建：第一阶段用CGO_ENABLED=1编译USB驱动模块，第二阶段用CGO_ENABLED=0构建主程序，并通过-ldflags="-s -w"剥离符号表降低体积。

环境变量白名单机制

定义最小必要变量集，在容器启动脚本中执行严格过滤：

# whitelist.sh
WHITELIST="GOOS GOARCH GOPROXY GOSUMDB"
for var in $(env | cut -d= -f1); do
    if ! echo "$WHITELIST" | grep -q "\b$var\b"; then
        unset "$var"
    fi
done

Windows注册表劫持防御

在init()中检测并重置危险键值：

if runtime.GOOS == "windows" {
    k, err := registry.OpenKey(registry.LOCAL_MACHINE,
        `SOFTWARE\Microsoft\Windows\CurrentVersion\Run`,
        registry.READ)
    if err == nil {
        defer k.Close()
        // 检查是否存在恶意启动项注入GO环境变量
    }
}