Quer evitar um vazamento de dados? Use a detecção de segredos

Para quem desenvolve software, garantir a segurança das aplicações é fundamental. Uma parte essencial desse trabalho é gerenciar segredos e usar uma ferramenta para detectá-los. Nesse contexto, segredos são dados confidenciais, como chaves de API, credenciais de banco de dados, chaves de criptografia e outras informações sigilosas. O acesso ou a exposição não autorizados podem ter consequências catastróficas, incluindo vazamentos de dados e graves prejuízos para os negócios.

Segredos codificados diretamente no código são comuns durante o desenvolvimento. Eles oferecem uma maneira rápida e fácil de se autenticar em serviços externos, bancos de dados ou outros componentes que exigem controle de acesso. Por exemplo, não é raro encontrar chaves de API ou credenciais de banco de dados inseridas diretamente nas aplicações, especialmente nas fases iniciais do desenvolvimento.

# Example of hardcoded database credentials
host = 'localhost'
database = 'my_database'
user = 'my_user'
password = 'my_password'

Essa abordagem pode parecer uma forma de economizar tempo, mas traz vários riscos de segurança que podem ser facilmente evitados com a detecção de segredos.

E se fosse possível evitar um vazamento de dados detectando segredos no início do desenvolvimento? Veja uma captura de tela da extensão do Snyk para a IDE IntelliJ detectando segredos codificados diretamente no código e outras credenciais de banco de dados usadas em uma aplicação JavaScript:

Desenvolvedores, equipes de DevOps e profissionais de segurança trabalham continuamente para garantir que os segredos sejam protegidos, controlados e monitorados adequadamente durante todo o ciclo de vida. No entanto, à medida que as arquiteturas de aplicações ficam mais complexas e distribuídas, gerenciar segredos com segurança e eficiência se torna um grande desafio.

O que são segredos no desenvolvimento de software?

No desenvolvimento de software, o termo "segredos" se refere a dados confidenciais cuja exposição pode levar ao acesso não autorizado e ao uso indevido de sistemas e dados. Entre esses segredos estão:

• Senhas: frases secretas ou sequências de caracteres usadas para autenticar usuários, comprovar sua identidade ou permitir acesso a um recurso.

• Chaves de API: identificadores exclusivos usados para autenticar um usuário, desenvolvedor ou programa que faz chamadas a uma API.

• Tokens: dados criados pelo servidor que podem conter informações para identificar um usuário, indicar a validade do token e registrar quando ele foi emitido. Um exemplo conhecido são os JSON Web Tokens (JWT).

Erros comuns cometidos por desenvolvedores ao lidar com segredos

Desenvolvedores costumam cometer alguns erros ao lidar com segredos. Veja alguns dos mais comuns:

1. Inserir segredos diretamente no código: Muitas vezes, desenvolvedores inserem segredos no código-fonte da aplicação. Essa prática é altamente insegura, pois qualquer pessoa com acesso à base de código pode recuperar esses segredos.

2. Armazenar segredos de forma inadequada: Guardar segredos em arquivos de texto simples, arquivos de configuração ou bancos de dados sem criptografia também é um erro comum.

3. Rotacionar segredos com pouca frequência: Alterar ou rotacionar segredos regularmente é uma boa prática de segurança. No entanto, muitos desenvolvedores deixam de fazer isso e mantêm os mesmos segredos por longos períodos.

# An example of hardcoding secrets in Python
password = "mySuperSecretPassword"
api_key = "myAPIKey1234"

As consequências de gerenciar segredos de forma inadequada

As consequências de gerenciar segredos de forma inadequada são amplas e graves, o que reforça a importância de usar mecanismos de detecção de segredos no ciclo de vida do desenvolvimento de software.

Vazamentos de dados: A consequência mais imediata e perigosa do gerenciamento inadequado de segredos é a possibilidade de um vazamento de dados. Um invasor que consiga acessar segredos expostos pode facilmente invadir seus sistemas, acessar dados confidenciais e até assumir o controle da sua infraestrutura. Por exemplo, ele pode usar chaves de API para se passar pela sua aplicação, credenciais de banco de dados para roubar ou manipular dados ou certificados para quebrar a criptografia implementada. Vazamentos de dados podem causar grandes prejuízos financeiros, danos à reputação e consequências jurídicas.

Descumprimento de regulamentações: Em um cenário em que as regulamentações de privacidade e segurança de dados estão cada vez mais rigorosas, o gerenciamento inadequado de segredos pode levar ao descumprimento de normas. Violações de regulamentações como GDPR, CCPA e HIPAA podem resultar em multas elevadas e penalidades jurídicas.

Perda de competitividade nos negócios: Segredos muitas vezes dão acesso a algoritmos proprietários, lógica de negócios e dados estratégicos. A exposição pode resultar na perda de vantagem competitiva e no roubo de propriedade intelectual.

Veja como é fácil expor um segredo em um repositório Git:

# Initial commit with a secret
echo "SECRET = 'my_super_secret_key'" > config.py
git add config.py
git commit -m "Initial commit"

# Realize the mistake and remove the secret
echo "SECRET = 'REMOVED'" > config.py
git commit -am "Remove secret"

Mesmo que o segredo tenha sido removido no segundo commit, ele continua no histórico do repositório e pode ser recuperado por qualquer pessoa com acesso a ele.

Para evitar essas consequências e fortalecer a segurança das suas aplicações, é essencial usar soluções de detecção e gerenciamento de segredos. Ferramentas como a Snyk ajudam você a identificar segredos expostos na base de código no início do desenvolvimento, quando os desenvolvedores instalam a extensão da Snyk para IDE, ou durante o pipeline de CI/CD, quando você integra os recursos de detecção de segredos da Snyk.

Como funciona a detecção de segredos

A detecção de segredos é o processo de identificar informações confidenciais, ou "segredos", como chaves de API, senhas e tokens, que podem estar expostas na base de código. A exposição ou o uso indevido desses segredos pode levar ao acesso não autorizado ou a vazamentos de dados.

A detecção de segredos é essencial para evitar vazamentos de dados, pois identifica e sinaliza segredos potencialmente expostos antes que possam ser explorados. Por exemplo, se um segredo for enviado por engano para um repositório público, ele poderá ser detectado e removido antes de ser encontrado por agentes mal-intencionados. A chave para uma detecção eficaz é usar ferramentas de análise automatizada que vasculham a base de código para localizar e sinalizar possíveis segredos. Uma forma de fazer isso é usar expressões regulares (regex) e padrões conhecidos para identificar possíveis segredos.

Por exemplo, uma chave de API pode ser detectada por um padrão como este:

import re

# This is a very simplified example
API_KEY_REGEX = r'[A-Za-z0-9]{32}'

def detect_secrets(text):
    return re.findall(API_KEY_REGEX, text)

Este é um exemplo simplificado, mas o conceito é o mesmo: ao buscar padrões conhecidos, é possível identificar possíveis segredos no código. Em situações reais, ferramentas de detecção de segredos como a Snyk usam técnicas muito mais sofisticadas para detectá-los.

Como integrar a detecção de segredos ao pipeline de CI/CD

Para aproveitar ao máximo os benefícios da detecção de segredos, ela deve ser integrada ao pipeline de integração e entrega contínuas (CI/CD). Assim, você identifica possíveis segredos o mais cedo possível no processo de desenvolvimento.

Por exemplo, você pode configurar o pipeline de CI/CD para executar uma análise de detecção de segredos sempre que um novo commit for enviado. Se algum segredo for detectado, o pipeline pode falhar e alertar a equipe sobre o problema.

# This is a simplified example of a CI/CD pipeline configuration steps:
  - name: Run Secrets Detection
    run: snyk code test
  - name: Build
    run: make build
  - name: Deploy
    run: make deploy

Neste exemplo, o comando snyk code test executa uma análise de detecção de segredos como primeira etapa do pipeline. Se algum segredo for detectado, o pipeline falhará e as etapas de build e deploy não serão executadas.

Como implementar a detecção de segredos com a Snyk

Vazamentos de dados podem ser desastrosos, prejudicar sua reputação e a confiança dos clientes, além de levar a penalidades financeiras. Se forem expostos, segredos como chaves de API, tokens e senhas podem abrir um caminho fácil para que agentes mal-intencionados invadam seu sistema. Uma forma eficaz de se proteger é implementar a detecção de segredos no pipeline de desenvolvimento. Neste capítulo, você vai aprender a usar o SAST da Snyk para evitar o envio de segredos ao repositório e prevenir possíveis vazamentos de dados.

Conheça os recursos de detecção de segredos da Snyk

A Snyk oferece detecção robusta de segredos como parte de sua solução abrangente de segurança de aplicações. Ela analisa seus repositórios de código em busca de possíveis segredos e notifica você dessas descobertas com segurança. Esse recurso está integrado ao produto Snyk Code, que oferece feedback e sugestões em tempo real enquanto você programa.

O recurso de detecção de segredos da Snyk usa padrões e heurísticas sofisticados, projetados para encontrar no código possíveis segredos que poderiam ser explorados por invasores.

Como configurar as extensões da Snyk para IDE para detectar segredos em tempo real

Para começar a usar os recursos de detecção de segredos da Snyk, você precisa configurar a extensão da Snyk para IDE. Ela integra os recursos da Snyk diretamente ao seu ambiente de desenvolvimento e oferece feedback e sugestões em tempo real enquanto você programa.

Para configurar a extensão para IDE:

1. Acesse a seção de extensões da sua IDE (Visual Studio Code, IntelliJ etc.).

2. Pesquise por 'Snyk'.

3. Instale a extensão da Snyk.

4. Inicie o plugin ou reinicie sua IDE.

Depois de instalada, a extensão da Snyk começará automaticamente a analisar seu código em busca de possíveis segredos durante o desenvolvimento.

# Example of a Snyk scan output
Detected secrets:
- AWS Access Key ID: AKIAIOSFODNN7EXAMPLE
- AWS Secret Access Key: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY

Boas práticas para usar a Snyk e evitar o envio de segredos ao repositório

Ao usar a Snyk para detectar segredos, é importante seguir algumas boas práticas.

• Nunca envie segredos para seus repositórios de código. Mesmo que você use repositórios privados, sempre existe o risco de exposição. Se a Snyk detectar um segredo, remova-o do código e, se possível, invalide-o.

• Use variáveis de ambiente para armazenar segredos. Em vez de inserir segredos diretamente no código, use variáveis de ambiente. Assim, fica mais fácil gerenciá-los e diminui o risco de serem enviados ao repositório de código.

• Analise seus repositórios de código regularmente com a Snyk. Análises frequentes ajudam a garantir que nenhum segredo passe despercebido. Você pode configurar análises automatizadas com a Snyk para facilitar esse processo.

• Oriente sua equipe sobre a importância do gerenciamento de segredos. Todas as pessoas da equipe devem entender os riscos de enviar segredos ao repositório e a importância dos recursos de detecção de segredos da Snyk.

Seguir essas boas práticas e usar a Snyk pode reduzir significativamente o risco de exposição de segredos e possíveis vazamentos de dados. Lembre-se: segurança não é uma tarefa pontual, mas um processo contínuo. Comece sua jornada rumo a mais segurança inscrevendo-se na Snyk aqui.

Acesse os recursos de aprendizado da Snyk para saber mais sobre gerenciamento de segredos, ferramentas e boas práticas.

Estratégias avançadas para gerenciar segredos

No universo da segurança de aplicações e do desenvolvimento de software, gerenciar segredos como chaves de API, senhas e certificados é uma tarefa importante. O gerenciamento eficaz de segredos ajuda a cumprir normas e evita vazamentos de dados. A seguir, exploramos algumas estratégias avançadas que podem aprimorar seus esforços nessa área.

Use variáveis de ambiente para gerenciar segredos

Uma forma segura de gerenciar segredos é usar variáveis de ambiente. Elas podem ser usadas em muitas linguagens de programação e permitem separar os segredos da base de código. Isso é fundamental para evitar a exposição acidental de segredos, especialmente em projetos de código aberto.

Veja um exemplo em Python:

import os
SECRET_KEY = os.environ.get('SECRET_KEY')

Neste exemplo, SECRET_KEY é uma variável de ambiente que armazena a chave secreta. A função os.environ.get() busca o valor da variável de ambiente. Se ela não for encontrada, a função retorna None.

Use ferramentas e serviços de gerenciamento de segredos

Usar ferramentas e serviços de gerenciamento de segredos pode aumentar significativamente a segurança deles. Ferramentas como o HashiCorp Vault e serviços de nuvem como o AWS Secrets Manager ou o Azure Key Vault ajudam a armazenar segredos com segurança e controlar rigorosamente o acesso a eles.

Veja um exemplo de como recuperar um segredo do AWS Secrets Manager usando o AWS SDK para Python:

import boto3
secretsmanager = boto3.client('secretsmanager')
response = secretsmanager.get_secret_value(SecretId='my_secret')

Neste exemplo, my_secret é o nome do segredo armazenado no AWS Secrets Manager. A função get_secret_value() recupera o segredo.

Automatize a rotação de segredos

Automatizar a rotação de segredos é essencial para o gerenciamento de segredos. Alterá-los regularmente pode impedir que um possível invasor use um segredo antigo para obter acesso não autorizado.

Isso pode ser feito com serviços de gerenciamento de segredos, como o AWS Secrets Manager, que oferece suporte à rotação automática de segredos para Amazon RDS, Amazon DocumentDB e Amazon Redshift.

Veja um exemplo de como configurar a rotação automática de segredos no AWS Secrets Manager:

import boto3
secretsmanager = boto3.client('secretsmanager')
response = secretsmanager.rotate_secret(
  SecretId='my_secret',
  RotationLambdaARN='my_lambda_function',
  RotationRules={
    'AutomaticallyAfterDays': 30
  }
)

Neste exemplo, my_secret é o nome do segredo que será rotacionado, my_lambda_function é a função do AWS Lambda que realiza a rotação, e AutomaticallyAfterDays indica a frequência da rotação em dias.

Para reforçar a segurança da sua aplicação, considere usar uma solução de segurança como o Snyk. O Snyk oferece um recurso de detecção de segredos que identifica segredos na sua base de código e impede que sejam expostos. Cadastre-se no Snyk aqui.

As estratégias apresentadas aqui são algumas das muitas maneiras de aprimorar o gerenciamento de segredos. Combiná-las com outras medidas proativas de segurança pode fortalecer significativamente a defesa da sua aplicação contra ameaças e garantir que seus esforços de desenvolvimento de software e conformidade sejam seguros e eficazes.

Violações históricas de dados causadas por segredos expostos

As violações de dados são um problema persistente na segurança de aplicações e no desenvolvimento de software. Segredos ou credenciais expostos são uma causa comum, que pode levar a acessos não autorizados e vazamentos de dados. Nesta seção, vamos analisar algumas violações históricas de dados causadas por segredos expostos, além das lições aprendidas e da importância da detecção de segredos.

Violação de dados da Uber: o resultado de credenciais expostas

Em 2016, a Uber sofreu uma grave violação de dados, que expôs informações de 57 milhões de clientes e motoristas. A causa? Credenciais da AWS expostas em um repositório privado do GitHub usado pelos desenvolvedores da empresa. Os invasores obtiveram acesso a essas credenciais e, em seguida, acessaram a conta da Uber na AWS e baixaram uma grande quantidade de dados confidenciais.

Esse incidente reforça a importância de armazenar credenciais com segurança e os riscos de guardar esses segredos em repositórios de código, mesmo que sejam privados.

Cloudflare: o impacto de um token de autenticação da Okta roubado

Em 2019, a Cloudflare foi vítima de uma grande violação de dados. O incidente ocorreu porque um invasor roubou no GitHub o token de autenticação da Okta de um funcionário da Cloudflare. Ele usou esse token para acessar os sistemas internos da Cloudflare e expor dados confidenciais de clientes.

Esse incidente demonstra os riscos potenciais de armazenar chaves secretas, como tokens de autenticação, em repositórios de código, mesmo quando são considerados seguros.

Codecov: como segredos codificados diretamente levaram a uma violação de grandes proporções

Em 2021, a Codecov, uma plataforma usada por desenvolvedores para gerar relatórios de cobertura de código, sofreu uma grave violação de dados. Os invasores exploraram uma falha no processo de criação de imagens Docker, que levou à exposição de segredos codificados diretamente. Eles usaram esses segredos para modificar o script Bash Uploader da Codecov e exportar dados confidenciais dos ambientes dos usuários.

A lição desse incidente? Segredos codificados diretamente representam um risco significativo. Para reduzir esses riscos, é recomendável usar ferramentas como o Snyk para detectar e gerenciar segredos.

Sumo Logic: lições aprendidas

Em 2023, a Sumo Logic, empresa de gerenciamento de logs baseada na nuvem, anunciou uma violação de segurança envolvendo o comprometimento de sua conta da AWS, detectado em 3 de novembro de 2023. Apesar do acesso não autorizado por meio de uma credencial comprometida, a empresa confirmou que suas redes e sistemas não foram afetados e que os dados dos clientes continuaram protegidos por criptografia. Em resposta, a Sumo Logic protegeu a infraestrutura afetada e atualizou as credenciais que poderiam ter sido expostas.

GitHub: o caso de uma chave SSH privada exposta 

Em um dos incidentes mais irônicos, o GitHub, plataforma amplamente usada para hospedar código, sofreu uma violação de dados devido à exposição de uma chave SSH privada. A chave foi enviada por engano a um repositório público e usada por um usuário não autorizado para acessar os sistemas internos do GitHub.

Esse incidente, assim como muitos dos casos mencionados acima, destaca a importância do gerenciamento e da detecção adequados de segredos para prevenir violações de dados.