AsyncRAT usa payloads Python e túneis TryCloudflare

Postado por Gerson Raymond em fev 5, 2025 em DIVERSOS |

Comentários desativados

Campanha AsyncRAT usa payloads Python e túneis TryCloudflare para ataques furtivos

Uma campanha de malware recentemente observada está distribuindo um Remote Access Trojan (RAT) chamado AsyncRAT por meio de payloads em Python e túneis TryCloudflare. Essa campanha destaca como os atacantes estão utilizando ferramentas legítimas e técnicas avançadas para realizar ataques furtivos e eficazes.

Neste artigo, vamos explorar como essa campanha funciona, como você pode se proteger e, ainda, como a programação em Python pode ser usada tanto para mitigar quanto para entender (em um contexto ético) esses ataques. Vamos apresentar exemplos de scripts que podem ajudar a identificar e bloquear comportamentos maliciosos.

O que é o AsyncRAT?

O AsyncRAT é um trojan de acesso remoto que explora o padrão async/await para comunicação assíncrona eficiente. Ele permite que os atacantes controlem sistemas infectados de forma furtiva, exfiltrem dados e executem comandos enquanto permanecem ocultos. Essa capacidade o torna uma ameaça cibernética significativa.

A campanha começa com um e-mail de phishing que contém um link para o Dropbox. Ao clicar no link, um arquivo ZIP é baixado. Dentro do ZIP, há um arquivo de atalho da internet (URL) que redireciona para um arquivo LNK do Windows. Esse arquivo LNK, por sua vez, executa um código JavaScript via PowerShell, que baixa e executa um script em lote (BAT). Esse script é responsável por baixar um segundo arquivo ZIP contendo o payload em Python que instala o AsyncRAT e outros malwares, como Venom RAT e Xworm.

Como o TryCloudflare é usado?

O TryCloudflare é um serviço legítimo oferecido pela Cloudflare que permite expor servidores web à internet sem abrir portas. Ele cria um túnel temporário (um subdomínio em trycloudflare[.]com) que redireciona o tráfego para o servidor do atacante. Nessa campanha, os criminosos usam o TryCloudflare para hospedar arquivos maliciosos e evitar detecção, aproveitando a confiança associada ao nome Cloudflare.

Mitigação com Python: exemplos práticos

A programação em Python pode ser uma grande aliada na luta contra campanhas como essa. Abaixo, apresentamos dois exemplos de scripts que podem ajudar a identificar e bloquear atividades suspeitas.

1. Detector de URLs maliciosas

Este script verifica se uma URL está em uma lista de domínios suspeitos ou se contém palavras-chave associadas a golpes.

# Lista de domínios suspeitos e palavras-chave
dominios_suspeitos = ["trycloudflare.com", "dropbox.com"]
palavras_chave_golpes = ["login", "credentials", "password", "update"]

def verificar_url_suspeita(url):
    url = url.lower()
    for dominio in dominios_suspeitos:
        if dominio in url:
            return f"ATENÇÃO: A URL {url} contém um domínio suspeito: {dominio}."
    for palavra in palavras_chave_golpes:
        if palavra in url:
            return f"ATENÇÃO: A URL {url} contém uma palavra-chave suspeita: '{palavra}'."
    return "A URL parece segura."

# Exemplo de uso
url_recebida = "https://trycloudflare.com/malicious-link"
print(verificar_url_suspeita(url_recebida))

2. Monitor de processos suspeitos

Este script monitora processos em execução no sistema e alerta se detectar atividades suspeitas, como o uso de PowerShell para baixar scripts.

import psutil

# Lista de processos suspeitos
processos_suspeitos = ["powershell.exe", "cmd.exe", "python.exe"]

def monitorar_processos():
    for processo in psutil.process_iter(['pid', 'name']):
        if processo.info['name'] in processos_suspeitos:
            print(f"ATENÇÃO: Processo suspeito detectado - PID: {processo.info['pid']}, 
Nome: {processo.info['name']}")

# Exemplo de uso
monitorar_processos()

Criar um script para detectar e alertar sobre uma simulação de shell remoto é uma prática importante para monitorar atividades suspeitas em um sistema. Abaixo, apresento um exemplo de script em Python que monitora conexões de rede e processos em execução para identificar possíveis tentativas de abrir um shell remoto. O script envia alertas quando detecta atividades suspeitas, como conexões em portas incomuns ou processos de shell sendo executados.

Script de detecção e alerta de shell remoto

Este script monitora:

Conexões de rede: Verifica se há conexões suspeitas em portas comuns usadas por shells remotos.
Processos em execução: Detecta processos como bash, sh, cmd.exe, powershell.exe, etc., que podem indicar a execução de um shell.

Quando uma atividade suspeita é detectada, o script envia um alerta (por exemplo, exibe uma mensagem no console ou envia um e-mail).

import psutil
import socket
import time
import smtplib
from email.mime.text import MIMEText

# Configurações de alerta
ALERTA_PORTA = 9999  # Porta comum para shells remotos
ALERTA_EMAIL = "[email protected]"
SERVIDOR_SMTP = "smtp.dominio.com"
PORTA_SMTP = 587
USUARIO_SMTP = "[email protected]"
SENHA_SMTP = "sua_senha"

# Lista de processos suspeitos (shells)
PROCESSOS_SUSPEITOS = ["bash", "sh", "cmd.exe", "powershell.exe", "python"]

def enviar_alerta(mensagem):
    """Envia um alerta por e-mail."""
    try:
        msg = MIMEText(mensagem)
        msg["Subject"] = "Alerta de Segurança: Shell Remoto Detectado"
        msg["From"] = USUARIO_SMTP
        msg["To"] = ALERTA_EMAIL

        with smtplib.SMTP(SERVIDOR_SMTP, PORTA_SMTP) as servidor:
            servidor.starttls()
            servidor.login(USUARIO_SMTP, SENHA_SMTP)
            servidor.sendmail(USUARIO_SMTP, ALERTA_EMAIL, msg.as_string())
        print(f"Alerta enviado para {ALERTA_EMAIL}: {mensagem}")
    except Exception as e:
        print(f"Erro ao enviar e-mail: {e}")

def monitorar_conexoes():
    """Monitora conexões de rede em busca de portas suspeitas."""
    try:
        conexoes = psutil.net_connections()
        for conexao in conexoes:
            if conexao.status == "ESTABLISHED" and conexao.laddr.port == ALERTA_PORTA:
                mensagem = f"Conexão suspeita detectada na porta {ALERTA_PORTA} 
com {conexao.raddr.ip}:{conexao.raddr.port}"
                print(mensagem)
                enviar_alerta(mensagem)
    except Exception as e:
        print(f"Erro ao monitorar conexões: {e}")

def monitorar_processos():
    """Monitora processos em execução em busca de shells suspeitos."""
    try:
        for processo in psutil.process_iter(['pid', 'name']):
            if processo.info['name'] in PROCESSOS_SUSPEITOS:
                mensagem = f"Processo suspeito detectado: {processo.info['name']} 
(PID: {processo.info['pid']})"
                print(mensagem)
                enviar_alerta(mensagem)
    except Exception as e:
        print(f"Erro ao monitorar processos: {e}")

def main():
    """Função principal do script."""
    print("[*] Iniciando monitoramento de shell remoto...")
    while True:
        monitorar_conexoes()
        monitorar_processos()
        time.sleep(10)  # Verifica a cada 10 segundos

if __name__ == "__main__":
    main()

Como se proteger?

Desconfie de e-mails não solicitados: Nunca clique em links ou baixe anexos de remetentes desconhecidos.
Verifique URLs e domínios: Use ferramentas como o script acima para identificar URLs suspeitas.
Monitore processos em execução: Fique atento a atividades suspeitas no seu sistema.
Mantenha-se atualizado: Aplique patches de segurança e use soluções antivírus atualizadas.

Conclusão

A campanha do AsyncRAT usando payloads em Python e túneis TryCloudflare é um exemplo claro de como os atacantes estão se tornando mais sofisticados. No entanto, com as ferramentas certas e um pouco de programação, você pode se proteger. O Python é uma linguagem poderosa que pode ser usada tanto para mitigar esses ataques quanto para entender como eles funcionam (em um contexto ético).

Lembre-se: a segurança cibernética começa com você. Fique atento, mantenha-se informado e use as ferramentas disponíveis para proteger seus sistemas e dados.

Fique seguro!

Fonte e imagens: https://thehackernews.com/2025/02/asyncrat-campaign-uses-python-payloads.html?_m=3n%2e009a%2e3584%2eis0ao0d70p%2e2lsc