O último ataque aos usuários do PyPI mostra que os bandidos estão ficando cada vez melhores

Mais de 400 pacotes maliciosos foram carregados recentemente no PyPI (Python Package Index), o repositório de código oficial da linguagem de programação Python, na mais recente indicação de que o direcionamento de desenvolvedores de software que usam essa forma de ataque não é uma moda passageira.

Todos os 451 pacotes encontrados recentemente pela empresa de segurança Phylum continham cargas maliciosas quase idênticas e foram carregados em rajadas que ocorreram em rápida sucessão. Uma vez instalados, os pacotes criam uma extensão JavaScript maliciosa que carrega toda vez que um navegador é aberto no dispositivo infectado, um truque que dá ao malware persistência durante as reinicializações.

O JavaScript monitora a área de transferência do desenvolvedor infectado em busca de qualquer endereço de criptomoeda que possa ser copiado para ele. Quando um endereço é encontrado, o malware o substitui por um endereço pertencente ao invasor. O objetivo: interceptar pagamentos que o desenvolvedor pretendia fazer para uma parte diferente.

Em novembro, a Phylum identificou dezenas de pacotes, baixados centenas de vezes, que usavam JavaScript altamente codificado para fazer a mesma coisa sub-repticiamente. Especificamente, ele:

• Criou uma área de texto na página
• Colado qualquer conteúdo da área de transferência nele
• Usou uma série de expressões regulares para pesquisar formatos comuns de endereço de criptomoeda
• Substituiu todos os endereços identificados pelos endereços controlados pelo invasor na área de texto criada anteriormente
• Copiou a área de texto para a área de transferência

“Se, a qualquer momento, um desenvolvedor comprometido copiar um endereço de carteira, o pacote malicioso substituirá o endereço por um endereço controlado pelo invasor”, escreveu o diretor técnico da Phylum, Louis Lang, no post de novembro. “Essa localização/substituição clandestina fará com que o usuário final envie inadvertidamente seus fundos para o invasor.”

Novo método de ofuscação

Além de aumentar enormemente o número de pacotes maliciosos carregados, a campanha mais recente também usa uma maneira significativamente diferente de cobrir seus rastros. Enquanto os pacotes divulgados em novembro usavam codificação para ocultar o comportamento do JavaScript, os novos pacotes gravam funções e identificadores de variáveis ​​no que parecem ser combinações aleatórias de 16 bits de ideogramas do idioma chinês encontradas na tabela a seguir:

Usando esta tabela, a linha de código

''.join(map(getattr(__builtins__, oct.__str__()[-3 << 0] + hex.__str__()[-1 << 2] + copyright.__str__()[4 << 0]), [(((1 << 4) - 1) << 3) - 1, ((((3 << 2) + 1)) << 3) + 1, (7 << 4) - (1 << 1), ((((3 << 2) + 1)) << 2) - 1, (((3 << 3) + 1) << 1)]))

cria a função interna chr e mapeia a função para a lista de inteiros [119, 105, 110, 51, 50]. Então a linha combina em uma string que finalmente cria 'win32'.

Os pesquisadores do filo explicaram:

Podemos ver uma série desses tipos de chamadas oct.__str__()[-3 << 0]. O [-3 << 0] avalia para [-3] e oct.__str__() avalia para a string '<built-in function oct>'. Usando o operador de índice do Python [] em uma corda com um -3 irá pegar o 3º caractere do final da string, neste caso '<built-in function oct>'[-3] irá avaliar para 'c'. Continuando com isso nos outros 2 aqui nos dá 'c' + 'h' + 'r' e simplesmente avaliar a complexa aritmética bit a bit anexada ao final nos deixa com:

''.join(map(getattr(__builtins__, 'c' + 'h' + 'r'), [119, 105, 110, 51, 50]))

O getattr(__builtins__, 'c' + 'h' + 'r') apenas nos dá a função interna chr e depois mapeia chr para a lista de ints [119, 105, 110, 51, 50] e, em seguida, junta tudo em uma string, finalmente nos dando 'win32'. Essa técnica é continuada em todo o código.

Embora dê a aparência de código altamente ofuscado, a técnica é fácil de derrotar, disseram os pesquisadores, simplesmente observando o que o código faz quando é executado.

O último lote de pacotes maliciosos tenta capitalizar os erros de digitação que os desenvolvedores cometem ao baixar um desses pacotes legítimos:

• bitcoinlib
• ccxt
• criptocomparar
• criptofeed
• freqtrade
• selênio
• Solana
• viper
• websockets
• yfinance
• pandas
• matplotlib
• aiohttp
• bela sopa
• tensorflow
• selênio
• raspado
• colorama
• scikit-learn
• pytorch
• pygame
• pyinstaller

Pacotes que visam o pacote vyper legítimo, por exemplo, usaram 13 nomes de arquivo que omitiram ou duplicaram um único caractere ou transpuseram dois caracteres do nome correto:

• sim
• vper
• vyer
• vype
• vvyper
• vyyper
• vypper
• vypeer
• vyperr
• yvper
• vpyer
• vyepr
• vypre

“Essa técnica é trivialmente fácil de automatizar com um script (deixamos isso como um exercício para o leitor) e, à medida que o tamanho do nome do pacote legítimo aumenta, também aumentam os possíveis erros de digitação”, escreveram os pesquisadores. “Por exemplo, nosso sistema detectou 38 typosquats do cryptocompare pacote publicado quase simultaneamente pelo usuário chamado pinigin.9494.”

A disponibilidade de pacotes maliciosos em repositórios de código legítimos que se assemelham muito aos nomes de pacotes legítimos data de pelo menos 2016, quando um estudante universitário carregou 214 pacotes armadilhados para os repositórios PyPI, RubyGems e NPM que continham nomes ligeiramente modificados de pacotes legítimos . O resultado: o código do impostor foi executado mais de 45.000 vezes em mais de 17.000 domínios separados, e mais da metade recebeu direitos administrativos poderosos. Os chamados ataques de typosquatting floresceram desde então.

Os nomes de todos os 451 pacotes maliciosos encontrados pelos pesquisadores do Phylum estão incluídos na postagem do blog. Não é uma má ideia para quem pretende baixar um dos pacotes legítimos destinados a verificar se não obteve inadvertidamente um doppelganger malicioso.