Segredos em código: como evitar o vazamento de chaves e senhas
Chaves e senhas commitadas no Git vazam e são exploradas em minutos. Aprenda a tirar segredos do código, rotacioná-los e evitar que voltem.
Neste artigo
Poucos erros de segurança são tão comuns e ao mesmo tempo tão evitáveis quanto deixar segredos dentro do código. Uma chave de API digitada direto no arquivo, uma senha de banco no arquivo de configuração versionado, um token colado numa constante: cada um desses deslizes coloca uma credencial valiosa num lugar de onde ela vai vazar mais cedo ou mais tarde. E quando vaza, o estrago é rápido, porque existe uma economia inteira de atacantes automatizados dedicada a encontrar e explorar segredos expostos em minutos.
Este texto explica por que segredo em código é tão grave, quais são os tipos de segredo que você precisa proteger, onde os segredos devem morar em vez do código, como impedir que voltem a aparecer e o que fazer quando um vazamento acontece. O tema atravessa toda a stack, do frontend ao pipeline, e a disciplina aqui é uma das mais rentáveis em segurança.
Por que segredo em código é tão grave
O primeiro motivo é a permanência. Sistemas de controle de versão como o Git guardam o histórico completo de tudo. Se você commitou uma chave e depois a removeu num commit seguinte, ela continua lá, no histórico, acessível para quem clonar o repositório e olhar o passado. Remover a linha não remove o segredo; ele permanece gravado em cada versão anterior. Muita gente acredita ter resolvido o problema apagando a linha e commitando de novo, quando na verdade o segredo continua totalmente exposto.
O segundo motivo é a velocidade da exploração. Repositórios públicos são varridos continuamente por bots que procuram padrões de credenciais, e um segredo exposto num repositório público costuma ser encontrado e usado em questão de minutos, às vezes antes mesmo de você perceber o erro. Mesmo repositórios privados não são um cofre: eles podem se tornar públicos por engano, ser acessados por alguém que não deveria, vazar em backups, ou ser expostos quando um colaborador tem a conta comprometida. Tratar "é privado" como segurança suficiente é uma aposta perigosa.
O terceiro motivo é a amplitude do dano. Uma única chave vazada pode dar acesso a um serviço de nuvem inteiro, a um banco de dados de produção, à capacidade de enviar mensagens em nome da sua empresa ou de gastar o seu crédito num provedor pago. O segredo é, por definição, a chave que abre algo importante; expô-lo é entregar essa abertura.
Os tipos de segredo que você precisa proteger
Segredo não é só senha. Vale ter em mente a lista de credenciais que precisam de proteção: chaves de API de serviços de terceiros, senhas de bancos de dados e de outros serviços, tokens de acesso, chaves privadas de criptografia e de assinatura, segredos usados para assinar tokens de sessão, credenciais de acesso a provedores de nuvem, chaves de webhooks. Qualquer valor cujo conhecimento por um estranho comprometeria a segurança é um segredo, e todos eles compartilham a mesma regra: fora do código, fora do histórico, fora do alcance de quem não precisa deles.
O segredo nunca vai para o cliente
Existe uma variante do erro que merece destaque próprio porque é frequente e especialmente perigosa: colocar segredo no frontend. Qualquer valor que chega ao navegador do usuário está acessível a ele, sem exceção. O código do frontend é baixado pelo cliente e pode ser inteiramente lido; não existe "esconder" uma chave ali. Isso vale também para as variáveis de ambiente que os frameworks de frontend expõem deliberadamente ao navegador por meio de prefixos especiais: esses prefixos existem justamente para marcar o que será público, então colocar um segredo numa variável assim é publicá-lo por definição.
A regra é absoluta e não admite exceção: segredo vive apenas no servidor. Se o navegador precisa de uma funcionalidade que depende de uma chave secreta, essa chamada passa por um backend seu, que guarda a chave e faz a requisição em nome do cliente. O cliente fala com o seu servidor, e só o servidor fala com o serviço que exige o segredo. Esse princípio é um dos pilares que aparecem repetidamente no princípio do menor privilégio e em toda discussão séria de arquitetura segura.
Onde os segredos devem morar
Se não é no código, onde então? A abordagem básica e mínima é injetar segredos por variáveis de ambiente, mantendo-os fora dos arquivos versionados. O arquivo local que carrega essas variáveis em desenvolvimento deve estar explicitamente ignorado pelo controle de versão, para nunca ser commitado por acidente. Essa é a linha de base, e já resolve o caso mais comum de segredo em código.
Para além do mínimo, um gerenciador de segredos dedicado é a solução robusta. São serviços e cofres que guardam segredos de forma cifrada, controlam quem pode acessar cada um, registram os acessos e permitem rotação. A aplicação busca o segredo do cofre no momento em que precisa, autenticando-se para isso, e o segredo nunca fica gravado em texto no código, na imagem do contêiner ou em arquivos de configuração versionados. Além de mais seguro, isso centraliza a gestão e facilita auditar e rotacionar. Segregue segredos por ambiente: as credenciais de desenvolvimento, de teste e de produção são distintas, para que o comprometimento de um ambiente menos protegido não entregue as chaves do ambiente crítico.
Impedindo que segredos voltem
Tirar os segredos do código uma vez não basta; é preciso impedir que voltem, porque a pressa do dia a dia sempre tenta reintroduzi-los. A ferramenta central aqui é a varredura automática de segredos. Existem scanners que analisam o código em busca de padrões que parecem credenciais e alertam ou bloqueiam quando encontram. O ideal é rodá-los em dois pontos: localmente, antes de cada commit, para pegar o segredo antes que ele sequer entre no histórico; e no pipeline de integração contínua, como uma barreira que recusa mudanças que contenham segredos. Essa dupla verificação transforma o esquecimento humano em bloqueio automático, e conversa diretamente com as práticas de segurança em pipelines de CI/CD.
Vale também varrer o histórico existente do repositório, não só as mudanças novas, porque segredos antigos podem estar lá esperando serem encontrados. Se a varredura revelar segredos no passado, o tratamento correto não é apenas reescrever o histórico, mas rotacionar os segredos expostos, como veremos.
O que fazer quando um segredo vaza
Quando um segredo vaza, a reação mais importante e mais mal compreendida é esta: rotacione o segredo imediatamente. Trocar a credencial por uma nova e invalidar a antiga é a única ação que realmente fecha a exposição. Muita gente, ao descobrir um segredo commitado, corre para apagá-lo do código e reescrever o histórico, e acha que resolveu. Não resolveu. A partir do momento em que o segredo apareceu em qualquer lugar acessível, você tem de assumir que ele foi visto e copiado. Reescrever o histórico limpa o repositório, mas não invalida a credencial que já vazou; só a rotação faz isso.
O procedimento de resposta é claro. Gere uma nova credencial no serviço afetado. Atualize a aplicação para usar a nova, pelos canais seguros que discutimos. Revogue a credencial antiga, para que ela deixe de funcionar mesmo nas mãos de quem a copiou. Verifique os registros de uso do serviço em busca de acessos suspeitos que possam ter ocorrido enquanto o segredo esteve exposto. E só então, como higiene complementar, limpe o histórico do repositório. A ordem importa: primeiro corte o poder do segredo vazado, depois arrume a casa.
Rotação regular como higiene
Mesmo sem vazamento conhecido, rotacionar segredos periodicamente é boa higiene. Credenciais de vida longa acumulam risco: quanto mais tempo uma chave existe, mais lugares ela pode ter vazado sem você saber, mais pessoas tiveram contato com ela. Rotação regular limita a janela de utilidade de qualquer segredo que tenha escapado silenciosamente. Combine isso com o menor privilégio nas próprias credenciais: cada chave deve ter apenas as permissões estritamente necessárias para a sua função, de modo que, mesmo comprometida, ela abra o mínimo possível. Uma chave que só pode ler um recurso específico causa muito menos dano do que uma chave com acesso total.
O ciclo de vida de um segredo bem gerido
Ajuda pensar em segredo não como um valor estático que você define uma vez, mas como algo que tem um ciclo de vida, do nascimento à aposentadoria, e que precisa ser gerido em cada fase. No nascimento, o segredo é gerado, e já aqui valem escolhas: ele deve ser gerado por um mecanismo criptograficamente forte, ter o menor escopo de permissão possível para a sua função, e nascer segregado por ambiente, de modo que a chave de produção nunca seja a mesma de desenvolvimento. Um segredo que nasce com permissão excessiva carrega esse excesso por toda a vida.
Na fase de uso, o segredo deve viver apenas onde precisa viver: no servidor, injetado por ambiente ou buscado de um cofre no momento do uso, nunca gravado em texto no código, na imagem do contêiner ou em logs. Um erro sutil e comum é o segredo vazar não pelo código, mas pelos registros da aplicação, quando um valor sensível é acidentalmente incluído numa mensagem de log. Registrar requisições inteiras, cabeçalhos ou corpos sem filtrar é um caminho silencioso de vazamento, e vale tratar os logs com o mesmo cuidado que se dá ao código quanto a não conter segredos.
Na fase de manutenção, o segredo é rotacionado periodicamente, trocado por um novo enquanto o antigo é revogado, o que limita a janela de utilidade de qualquer cópia que tenha escapado sem você saber. E na aposentadoria, quando um serviço deixa de existir ou uma integração é descontinuada, os segredos associados precisam ser revogados de fato, não apenas esquecidos, porque um segredo órfão que ainda funciona é uma porta aberta que ninguém está vigiando. Pensar nesse ciclo completo, e não apenas no momento de definir o valor, é o que transforma a gestão de segredos de um esforço pontual numa disciplina contínua. Cada fase tem seu risco próprio, e um segredo bem gerido é aquele acompanhado do nascimento à aposentadoria, com o menor privilégio em todas elas.
Conclusão
Segredo em código é um erro grave justamente por ser fácil de cometer e caro de remediar: o histórico do controle de versão o guarda para sempre, bots o encontram em minutos, e uma única chave pode abrir sistemas inteiros. A defesa é uma disciplina de várias camadas: tirar todos os segredos do código e mantê-los em variáveis de ambiente ignoradas pelo versionamento ou, melhor, num cofre dedicado; jamais colocar segredo no cliente, onde ele é público por definição; barrar o retorno com varredura automática antes do commit e no pipeline; e, quando algo vazar, rotacionar imediatamente antes de qualquer outra coisa. Some rotação regular e menor privilégio das credenciais, e você transforma o segredo de uma bomba-relógio esquecida num ativo gerenciado, protegido e substituível.
