Este guia mostra como encontrar e remover segredos que foram commitados por engano em projetos e repositórios hospedados no GitLab. Confirmamos que os segredos da infraestrutura do próprio GitLab estão protegidos.
No Claude Code, o agente de programação da Anthropic, é possível aprovar um comando de shell selecionando “Yes, and don’t ask again”. O Claude então salva exatamente esse comando em .claude/settings.local.json, na pasta do projeto, e passa a executá-lo sem pedir confirmação. Se o comando continha uma senha ou um token, o arquivo também passa a conter:
{
"permissions": {
"allow": [
"Bash(npm test:*)",
"Bash(curl --header \"PRIVATE-TOKEN: glpat-EXAMPLEdummyTOKEN1234\" \"https://gitlab.com/api/v4/projects/1234567/issues?state=closed\")"
]
}
}
O Claude Code mantém o arquivo fora do Git pelas exclusões globais pessoais de quem desenvolve, e não pelo .gitignore do projeto. Essa proteção fica em um único notebook e não acompanha o repositório; por isso, o arquivo acaba sendo commitado e enviado por push para onde quer que o repositório esteja. No início de novembro de 2026, a Apiiro relatou (em inglês) que esse problema fez 104.185 cópias do arquivo aparecerem em repositórios públicos, 1.122 delas com pelo menos um segredo. Outras centenas de segredos estavam apenas no histórico, em arquivos que já tinham sido excluídos.
Se a sua equipe usa o Claude Code com repositórios hospedados no GitLab, este guia mostra como evitar que isso aconteça daqui para frente, avaliar a exposição atual ou passada e limpar todos os projetos afetados de uma só vez.
Prevenir: mantenha o arquivo fora do repositório
Algumas medidas garantem que ninguém consiga commitar o arquivo por acidente e que, se uma cópia escapar, alguém fique sabendo. São quatro camadas, cada uma um pouco mais trabalhosa que a anterior, e a ordem abaixo é uma boa sequência a seguir. Todas são configurações que um Owner do grupo altera uma única vez. Esta é a única parte do processo em que o GitLab Duo pode orientar o passo a passo, mas não pode executar o trabalho, já que o acesso dele às configurações do GitLab é somente leitura.
Comece pelo .gitignore
A correção mais simples é também a que o Claude Code deveria ter feito, mas não faz: uma linha .claude/settings.local.json no .gitignore de cada repositório. O Claude Code só adiciona a exclusão à configuração global do Git de quem desenvolve, que fica naquele notebook.
No Premium ou no Ultimate, coloque a mesma linha no .gitignore do projeto de templates de arquivos do grupo (no grupo, acesse Settings > General > Templates). Assim, todo projeto criado a partir de agora herda essa linha sem que ninguém precise se lembrar disso.
Bloqueie o nome do arquivo com uma regra de push (Premium e Ultimate)
Uma regra de push transforma a convenção em algo que o GitLab faz valer. No grupo, acesse Settings > Repository > Pre-defined push rules e, em Prohibited filenames, insira:
(^|/)\.claude/settings\.local\.json$
A partir daí, todo push que tentar adicionar esse arquivo, na raiz do repositório ou em qualquer subdiretório, em qualquer branch, é rejeitado antes de chegar ao repositório, e quem fez o push vê uma mensagem com o padrão bloqueado.
Há dois pontos sobre o comportamento das regras de push que fazem diferença aqui. A regra verifica apenas arquivos que estão sendo adicionados, não alterações em um arquivo que já é rastreado. Por isso, a limpeza das cópias existentes, descrita na seção Mitigar, precisa vir primeiro. Além disso, uma regra definida no grupo é copiada para os projetos criados depois daquele momento; ela não alcança os projetos que já existem. Para esses, defina a mesma regra em cada projeto, em Settings > Repository > Push rules do próprio projeto ou, se forem mais do que alguns poucos, com um loop sobre os IDs dos projetos do grupo:
POST /api/v4/projects/<id>/push_rule
{"file_name_regex": "(^|/)\\.claude/settings\\.local\\.json$"}
Para um projeto que já tem regras de push próprias, use PUT no mesmo caminho; com POST, a resposta será 422 Project push rule exists.
Adicione a Secret Push Protection para os tokens (Ultimate)
A regra de push barra o arquivo pelo nome. A Secret Push Protection analisa o conteúdo de cada push, seja qual for o nome do arquivo, e o rejeita se encontrar um formato de token conhecido. No GitLab Self-Managed e no Dedicated, primeiro é preciso permitir o recurso na instância, em Admin > Settings > Security and compliance; no GitLab.com, essa etapa já está feita. Depois, ative-o em cada projeto, em Secure > Security configuration > Secret push protection, ou em um grupo inteiro de uma vez pela API de configurações de segurança do grupo.
Faça a varredura de tudo com uma única política (Ultimate)
Uma política de execução de varredura no grupo de nível superior executa a GitLab Secret Detection em todos os projetos, inclusive nos que não têm nenhum .gitlab-ci.yml, e os projetos não podem desativá-la individualmente. Crie a política em Group > Secure > Policies > New policy > Scan execution policy, com uma regra que roda em toda pipeline e outra que roda em uma programação semanal. A execução programada percorre o histórico na primeira vez que roda; adicione a variável SECRET_DETECTION_HISTORIC_SCAN: 'true' a essa regra se quiser que toda execução semanal cubra o histórico completo, e não apenas os commits novos. A política detecta os mesmos formatos de token que a Secret Push Protection e também cobre o que já está no repositório, incluindo o histórico quando a varredura histórica está ativada.
Avaliar: o arquivo existe nos seus repositórios?
Além das medidas preventivas, é preciso saber se o .claude/settings.local.json existe em algum dos seus repositórios, agora ou em algum momento no passado. O conteúdo do arquivo só importa quando a lista de repositórios afetados estiver pronta, e há algumas formas de obtê-la, dependendo do que a sua assinatura do GitLab inclui.
Pergunte ao GitLab Duo
Se o seu grupo tem o GitLab Duo (Duo Core no Premium e no Ultimate, ou GitLab Credits em um grupo Free no GitLab.com), o caminho mais rápido é abrir o Agentic Chat do GitLab Duo, parte da GitLab Duo Agent Platform, no grupo de nível superior e colar isto:
Algum projeto do grupo <GRUPO> já teve um arquivo chamado .claude/settings.local.json, incluindo projetos em que o arquivo foi excluído depois e projetos em que ele só existe em uma branch diferente da padrão? Para cada projeto, diga se ele tem o arquivo agora e, se não tiver, o commit em que ele foi adicionado e o commit em que foi removido. Explique como a verificação foi feita.
O GitLab Duo percorre o grupo e seus subgrupos, consulta o histórico de commits de cada projeto para esse caminho exato, lista as branches de todo projeto com ocorrência e busca o arquivo atual para distinguir uma cópia que ainda existe de uma que foi excluída.
O resultado é uma única tabela: o projeto, se o arquivo existe agora, os commits que o adicionaram e removeram e uma observação quando uma versão excluída ainda continha um segredo. Os forks dentro do grupo também entram na verificação, porque cada fork é um projeto com histórico próprio, e o GitLab Duo termina dizendo o que não verificou, como projetos fora do grupo. Como ele lê o histórico em vez de um índice de busca, um grupo com cerca de cem projetos leva vários minutos, e é justamente esse cuidado que permite encontrar as cópias excluídas que uma busca não encontra.
Se o seu grupo tem o GitLab Orbit, o GitLab Duo pode usar esse grafo de conhecimento no lugar do índice de busca para as cópias atuais, o que traz essa parte da resposta em cerca de um minuto, com os mesmos resultados.
Faça a busca por conta própria (Premium e Ultimate)
Sem o GitLab Duo, a forma mais rápida de encontrar as cópias atuais é a busca de código. Em cada grupo de nível superior, abra Search, escolha o escopo Code e marque “Include archived”. A consulta depende do mecanismo de busca que o grupo usa, e a página de resultados mostra qual é. Onde a busca exata de código está ativa, o que acontece nos planos pagos do GitLab.com e em instâncias Self-Managed com Zoekt, ative as expressões regulares e busque por:
file:\.claude/settings\.local\.json$
Onde a busca avançada está ativa, o que inclui o GitLab Dedicated e instâncias Self-Managed com Elasticsearch, a consulta é:
filename:settings.local.json path:.claude
A busca de código funciona em um grupo de nível superior por vez, incluindo os subgrupos. Para quem tem vários grupos, a API faz esse loop sem dor de cabeça, e o formato com filename: e path: funciona nos dois mecanismos:
GET /api/v4/groups?owned=true&top_level_only=true&per_page=100
GET /api/v4/groups/<id>/search?scope=blobs&search=filename:settings.local.json%20path:.claude&exclude_forks=false&per_page=100
Mantenha exclude_forks=false, porque, sem esse parâmetro, a busca exata de código deixa os forks de fora. Em uma instância GitLab Self-Managed com busca avançada ou busca exata de código ativada, um administrador pode dispensar o loop e buscar na instância inteira com GET /api/v4/search?scope=blobs&search=filename:settings.local.json%20path:.claude. Use um token de administrador, porque a API só retorna os projetos que quem faz a chamada consegue ver.
Seja qual for o mecanismo, lembre-se de que a busca mostra a branch padrão como ela está hoje. Um arquivo excluído, ou que está em outra branch, fica invisível para ela, e é por isso que existe a próxima verificação.
Verifique o histórico (todos os planos)
Um arquivo commitado e depois excluído continua sendo um vazamento; por isso, é preciso saber, em cada projeto, se o arquivo já existiu em alguma branch. A API de commits responde a essa pergunta, funciona em todos os planos e modalidades de implantação e não exige que nada seja ativado antes:
GET /api/v4/groups/<id>/projects?include_subgroups=true&per_page=100
GET /api/v4/projects/<id>/repository/commits?path=.claude/settings.local.json&all=true&follow=false&per_page=100
Se a segunda chamada retornar commits, o conteúdo está no histórico do projeto; se retornar uma lista vazia, ele nunca esteve lá. Essa também é a verificação que encontra forks, já que eles são projetos como quaisquer outros.
Um detalhe importa mais do que parece: não remova follow=false. Quando all=true é combinado com um caminho, o GitLab percorre primeiro os commits mais recentes do repositório inteiro e só depois filtra pelo caminho; assim, um repositório com mais de uma página de commits pode voltar vazio, mesmo que o arquivo esteja no histórico. Com follow=false, a busca é filtrada pelo caminho desde o início, e a primeira página lista todos os commits que já mexeram no arquivo.
Verifique os forks
Cada fork de um projeto afetado mantém a própria cópia do arquivo e o próprio histórico. Liste os forks com GET /api/v4/projects/<id>/forks e repita as verificações acima para cada um.
Mitigar: rotacionar, remover, limpar o histórico
Sejam quais forem os segredos encontrados, a ordem é esta: rotacionar, depois remover e, por fim, limpar o histórico. Trate como público todo segredo que o arquivo já conteve, a partir da data do primeiro commit em que ele apareceu, e faça a rotação no provedor antes de mexer no arquivo. Excluir o arquivo, por si só, não resolve nada: o valor continua no histórico do repositório e em todos os forks, e segue utilizável até que o segredo seja trocado.
Remova o arquivo de todos os projetos de uma vez (com o GitLab Duo)
Com a rotação em andamento, abra o Agentic Chat no grupo de nível superior e cole:
No grupo <GRUPO>, para cada projeto que tem atualmente um .claude/settings.local.json commitado na branch padrão, abra uma merge request que remova o arquivo e adicione .claude/settings.local.json ao .gitignore do projeto. Não faça merge de nada. Ignore os projetos que já têm uma merge request desse tipo aberta. Ao terminar, me dê uma única tabela: projeto, link da merge request e os tipos de segredo que o arquivo continha (sem os valores). Depois, diga o que ainda resta para eu fazer em todos eles.
O GitLab Duo encontra os projetos afetados (pelo GitLab Orbit, quando o grupo tem, ou pela busca, caso contrário) e prepara um commit por projeto que exclui o arquivo e adiciona a entrada no .gitignore. Em seguida, ele pausa duas vezes para pedir aprovação: uma para todos os commits juntos e outra para todas as merge requests juntas. Ou seja, limpar um grupo inteiro custa dois cliques. No fim, vem uma tabela com os projetos, os links das merge requests e os tipos de segredo de cada arquivo, sem reproduzir nenhum valor, seguida da lista do que ainda fica por sua conta. Só falta revisar as merge requests e fazer o merge.
Sem o GitLab Duo, a mesma mudança em cada projeto leva quatro comandos:
git rm --cached .claude/settings.local.json
echo '.claude/settings.local.json' >> .gitignore
git add .gitignore
git commit -m "Stop tracking Claude Code local settings"
Limpe o conteúdo do histórico
Remover o arquivo só o tira da árvore atual. As versões antigas continuam no repositório até que o histórico seja reescrito; por isso, faça essa limpeza em todo projeto em que o arquivo tinha um segredo, depois de rotacionar os segredos.
No projeto, acesse Settings > Repository > Repository maintenance > Remove blobs, cole os IDs das versões antigas do arquivo (abra a árvore do repositório em um commit antigo para copiá-los) e confirme. Em seguida, execute o housekeeping, aguarde 30 minutos e remova os objetos inacessíveis (prune unreachable objects).
Para confirmar que funcionou: os IDs dos commits posteriores ao blob removido mudam, e a verificação de histórico da seção Avaliar não retorna nada para o caminho. Se nada mudar depois de alguns minutos, confira o seu e-mail, porque uma reescrita com falha só é informada por lá, para quem a iniciou.
Dois casos exigem cuidado. Se o projeto é um fork, ou um projeto público com forks, o pool de objetos compartilhado mantém o conteúdo acessível mesmo depois da reescrita; desvincule os forks primeiro ou limpe cada repositório separadamente. E, depois de qualquer reescrita, merge requests abertas podem precisar de rebase, e todo mundo precisa clonar o repositório de novo.
Resumo
Em resumo: pergunte ao GitLab Duo se o arquivo existe, agora ou no passado. Rotacione tudo o que os arquivos continham. Peça ao GitLab Duo para abrir as merge requests de limpeza em todo o grupo, revise-as e faça o merge. Limpe o histórico onde havia segredos. Configure a regra de push, ative a Secret Push Protection e adicione a política. Dois prompts no total, dois cliques de aprovação e alguns minutos de configuração ajudam a manter seus repositórios livres desse tipo de vazamento.
Saiba mais
Documentação do GitLab (em inglês):
- GitLab Duo Agentic Chat
- Secret Push Protection e Pipeline Secret Detection
- Push rules: nomes de arquivo proibidos
- Scan execution policies
- Remove blobs e manutenção do repositório




