Ransomware HellCat

Ransomware HellCat: Táticas inovadoras de humilhação 

A cibersegurança está em constante evolução, e os cibercriminosos estão sempre buscando novas maneiras de explorar vulnerabilidades e pressionar suas vítimas. Um exemplo recente e alarmante é o caso da gangue de ransomware HellCat, que tem adotado táticas inovadoras de humilhação para forçar o pagamento de resgates. Em um ataque recente, a HellCat exigiu um resgate de US$ 125.000 em “baguetes” da Schneider Electric após roubar 40 GB de dados. 

No contexto do ataque de ransomware da gangue HellCat à Schneider Electric, o termo “baguetes” foi utilizado de forma irônica e humilhante pelos cibercriminosos. Em vez de exigir o resgate em criptomoedas (como Bitcoin, que é o padrão na maioria dos ataques de ransomware), a gangue exigiu o pagamento em “baguetes”, um tipo de pão francês alongado e tradicional da culinária francesa.

Essa exigência absurda e inusitada tem dois propósitos principais:

• Ridicularização pública: Ao exigir um resgate em “baguetes”, a gangue busca ridicularizar a vítima publicamente, aumentando o constrangimento e a pressão psicológica. Essa tática visa forçar a empresa a pagar o resgate para evitar o escárnio e o dano à sua reputação.

• Cobertura midíática: Ações incomuns e chamativas, como exigir um resgate em pães, têm maior probabilidade de atrair a atenção da mídia. Isso amplifica o impacto do ataque e aumenta a notoriedade da gangue, o que pode ser parte de uma estratégia para intimidar futuras vítimas.

No caso específico da Schneider Electric, a exigência de “baguetes” foi claramente simbólica, já que o pagamento real do resgate provavelmente seria feito em criptomoedas ou outra forma de valor monetário. A escolha do termo “baguetes” pode estar relacionada ao fato de a Schneider Electric ser uma empresa francesa, o que reforça o aspecto de humilhação direcionada à identidade nacional da vítima.

Essa tática inovadora e provocativa ilustra como os grupos de ransomware estão evoluindo para além da extorsão financeira tradicional, incorporando elementos de humilhação e manipulação psicológica em seus ataques.

Neste artigo, exploraremos as táticas utilizadas pela HellCat, os riscos associados e como você pode mitigar esses riscos utilizando scripts em Python para fortalecer a segurança da sua organização.

O Modus operandi da HellCat

A HellCat tem se destacado por sua abordagem agressiva e inovadora no cenário do cibercrime. Aqui estão algumas das principais características de seus ataques:

• Dupla extorsão: A gangue exfiltra dados sensíveis antes de criptografar os sistemas das vítimas. Isso permite que eles ameacem vazar informações confidenciais caso o resgate não seja pago.

• Exploração de vulnerabilidades: A HellCat tem explorado falhas em softwares empresariais populares, como o Jira, para obter acesso inicial aos sistemas.

• Humilhação pública: Além de exigir resgates em criptomoedas, a gangue tem adotado táticas de humilhação, como exigir pagamentos em itens absurdos (como “baguetes”) para ridicularizar as vítimas.

• Venda de acesso root: A HellCat tem oferecido acesso root a servidores comprometidos em fóruns da dark web, aumentando o risco para empresas e instituições.

• Infraestrutura compartilhada: Relatórios indicam que a HellCat pode estar compartilhando infraestrutura com outras gangues, como a Morpheus, o que sugere uma rede de cibercrime bem organizada.

Medidas de mitigação com Python

Para combater ameaças como a HellCat, é essencial adotar uma abordagem proativa de segurança. Abaixo, apresentamos exemplos de scripts em Python que podem ajudar a mitigar os riscos associados a ransomware.

1. Monitoramento de atividades suspeitas

Um dos primeiros passos para detectar um ataque de ransomware é monitorar atividades suspeitas, como acessos não autorizados ou tentativas de exfiltração de dados. O script abaixo monitora alterações em arquivos sensíveis e envia alertas caso algo incomum seja detectado.

import os
import hashlib
import time

# Lista de arquivos sensíveis para monitorar
sensitive_files = ["/var/www/html/data.csv", "/etc/passwd", "/home/user/secret.txt"]

# Função para calcular o hash de um arquivo
def calculate_hash(file_path):
    hasher = hashlib.md5()
    with open(file_path, "rb") as f:
        buf = f.read()
        hasher.update(buf)
    return hasher.hexdigest()

# Dicionário para armazenar os hashes originais
original_hashes = {file: calculate_hash(file) for file in sensitive_files}

# Monitoramento contínuo
while True:
    time.sleep(60)  # Verifica a cada minuto
    for file in sensitive_files:
        current_hash = calculate_hash(file)
        if current_hash != original_hashes[file]:
            print(f"ALERTA: O arquivo {file} foi alterado!")
            # Enviar alerta por e-mail ou outra forma de notificação
    time.sleep(60)

import psutil
import socket

# Limite de tráfego de saída (em MB)
TRAFFIC_THRESHOLD = 100  # 100 MB

# Função para monitorar o tráfego de rede
def monitor_traffic():
    connections = psutil.net_connections(kind='inet')
    for conn in connections:
        if conn.status == 'ESTABLISHED' and conn.raddr:
            ip, port = conn.raddr
            if ip != "127.0.0.1":  # Ignorar tráfego local
                sent_bytes = psutil.net_io_counters().bytes_sent
                if sent_bytes > TRAFFIC_THRESHOLD * 1024 * 1024:  
# Converter MB para bytes
                    print(f"ALERTA: Grande volume de dados enviado para {ip}:{port}")
                    # Bloquear o IP ou tomar outras medidas de mitigação

# Monitoramento contínuo
while True:
    monitor_traffic()
    time.sleep(60)  # Verifica a cada minuto

3. Backup automatizado de dados

Manter backups regulares é uma das melhores defesas contra ransomware. O script abaixo automatiza o processo de backup de diretórios críticos.

import shutil
import datetime
import os

# Diretórios para backup
directories_to_backup = ["/var/www/html", "/home/user/documents"]

# Local de armazenamento do backup
backup_dir = "/backup"

# Função para criar backup
def create_backup():
    timestamp = datetime.datetime.now().strftime("%Y%m%d%H%M%S")
    backup_path = os.path.join(backup_dir, f"backup_{timestamp}")
    os.makedirs(backup_path)
    for directory in directories_to_backup:
        shutil.copytree(directory, os.path.join(backup_path, os.path.basename(directory)))
    print(f"Backup criado em {backup_path}")

# Executar backup diariamente
while True:
    create_backup()
    time.sleep(86400)  # Esperar 24 horas

4. Detecção de Vulnerabilidades em Softwares

A HellCat explora vulnerabilidades em softwares como o Jira. O script abaixo verifica se há atualizações disponíveis para pacotes instalados, ajudando a garantir que os sistemas estejam sempre atualizados.

import os
import subprocess

# Função para verificar atualizações
def check_for_updates():
    try:
        subprocess.run(["apt-get", "update"], check=True)
        outdated_packages = subprocess.run(["apt-get", "upgrade", "-s"], 
capture_output=True, text=True)
        if "upgraded" in outdated_packages.stdout:
            print("Atualizações disponíveis:")
            print(outdated_packages.stdout)
        else:
            print("Todos os pacotes estão atualizados.")
    except subprocess.CalledProcessError as e:
        print(f"Erro ao verificar atualizações: {e}")

# Verificar atualizações diariamente
while True:
    check_for_updates()
    time.sleep(86400)  # Esperar 24 horas

Fonte e imagens: https://www.cisoadvisor.com.br/ransomware-exige-resgate-de-us-125-mil-em-baguetes/