Backdoor baseado em Golang usa API de Telegram

Novo backdoor baseado em Golang usa API de bot do Telegram para operações evasivas de C2

Recentemente, pesquisadores de segurança cibernética identificaram um novo backdoor baseado em Golang que utiliza a API do Telegram como mecanismo para operações de comando e controle (C2). Descoberto pela Netskope Threat Labs, o malware, possivelmente de origem russa, é funcional e está em desenvolvimento ativo. Ele se destaca por sua capacidade de se comunicar com um bot do Telegram para receber comandos e executar ações maliciosas em sistemas comprometidos.

Neste artigo, exploraremos como esse malware opera e forneceremos exemplos de scripts em Python que podem ser usados para mitigar ou detectar atividades suspeitas relacionadas a esse tipo de ameaça.

Como o backdoor funciona

O backdoor, uma vez executado, verifica se está rodando em um local específico (C:\Windows\Temp\svchost.exe). Caso contrário, ele se copia para esse diretório e cria um novo processo para se executar, encerrando a instância original. Ele utiliza uma biblioteca de código aberto que oferece bindings em Golang para a API do Telegram Bot, permitindo que os atacantes enviem comandos remotamente por meio de um chat controlado por eles.

Os comandos suportados incluem:

• /cmd: Executa comandos via PowerShell.

• /persist: Relança o backdoor no diretório C:\Windows\Temp\svchost.exe.

• /screenshot: Ainda não implementado, mas envia uma mensagem de confirmação falsa.

• /selfdestruct: Exclui o arquivo C:\Windows\Temp\svchost.exe e encerra a execução.

A saída dos comandos é enviada de volta ao chat do Telegram, permitindo que os atacantes monitorem e controlem o sistema comprometido.

Estratégias de mitigação

Para combater esse tipo de ameaça, é essencial adotar uma abordagem proativa, incluindo a detecção de atividades suspeitas e a implementação de medidas preventivas. Abaixo, apresentamos exemplos de scripts em Python que podem ajudar nessa tarefa.

1. Monitoramento de processos suspeitos

O backdoor se copia para C:\Windows\Temp\svchost.exe e cria um novo processo. Podemos monitorar processos suspeitos nesse diretório usando a biblioteca psutil em Python.

import psutil
import os

def monitor_temp_processes():
    temp_path = r"C:\Windows\Temp"
    for proc in psutil.process_iter(['pid', 'name', 'exe']):
        try:
            if proc.info['exe'] and temp_path in proc.info['exe']:
                print(f"Processo suspeito encontrado: 
{proc.info['name']} (PID: {proc.info['pid']})")
        except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
            pass

if __name__ == "__main__":
    monitor_temp_processes()

Esse script verifica se há processos em execução no diretório C:\Windows\Temp e alerta sobre possíveis atividades maliciosas.

2. Bloqueio de comunicação com a API do Telegram

Como o backdoor usa a API do Telegram para C2, podemos bloquear tráfego de rede para os endereços IP associados ao Telegram. Abaixo, um exemplo de como listar conexões de rede suspeitas:

import psutil

def check_telegram_connections():
    telegram_ips = ["149.154.160.0", "91.108.4.0"]  # Faixas de IP do Telegram
    for conn in psutil.net_connections(kind='inet'):
        if conn.raddr and any(conn.raddr.ip.startswith(ip) for ip in telegram_ips):
            print(f"Conexão suspeita encontrada: {conn.laddr} -> {conn.raddr}")

if __name__ == "__main__":
    check_telegram_connections()

Esse script identifica conexões de rede para os IPs do Telegram, que podem indicar comunicação maliciosa.

3. Detecção de comandos PowerShell suspeitos

O backdoor executa comandos via PowerShell. Podemos monitorar a execução de comandos PowerShell suspeitos usando o módulo subprocess:

import subprocess

def monitor_powershell():
    command = "Get-WinEvent -LogName Microsoft-Windows-PowerShell/Operational | 
Where-Object { $_.Id -eq 4104 }"
    result = subprocess.run(["powershell", "-Command", command], capture_output=True, 
text=True)
    
    if "cmd" in result.stdout.lower():
        print("Comando suspeito detectado no log do PowerShell!")

if __name__ == "__main__":
    monitor_powershell()

Esse script verifica logs do PowerShell em busca de comandos suspeitos, como os enviados pelo backdoor.

4. Exclusão de arquivos maliciosos

Caso o backdoor seja detectado, podemos criar um script para excluir o arquivo malicioso e interromper sua execução:

import os
import psutil

def remove_malicious_file():
    malicious_path = r"C:\Windows\Temp\svchost.exe"
    if os.path.exists(malicious_path):
        os.remove(malicious_path)
        print(f"Arquivo malicioso removido: {malicious_path}")
        
        # Encerra processos associados ao arquivo
        for proc in psutil.process_iter(['pid', 'name', 'exe']):
            try:
                if proc.info['exe'] == malicious_path:
                    proc.kill()
                    print(f"Processo encerrado: PID {proc.info['pid']}")
            except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
                pass

if __name__ == "__main__":
    remove_malicious_file()

Esse script remove o arquivo malicioso e encerra qualquer processo associado a ele.

Conclusão

O uso de aplicativos em nuvem, como o Telegram, para operações de C2 representa um desafio significativo para os defensores de segurança cibernética. No entanto, com ferramentas e scripts adequados, é possível detectar e mitigar essas ameaças de forma eficaz. Os exemplos de Python fornecidos neste artigo são um ponto de partida para fortalecer suas defesas contra backdoors baseados em Golang e outras ameaças semelhantes.

Lembre-se de que a segurança cibernética é um processo contínuo. Mantenha-se atualizado sobre as últimas ameaças e adapte suas estratégias de defesa conforme necessário.

Fonte e imagens: https://thehackernews.com/2025/02/new-golang-based-backdoor-uses-telegram.html