Las autoridades judiciales y de ciberseguridad de Estados Unidos, de la mano de sus pares en el Reino Unido entre otros aliados, anunciaron este martes el desmantelamiento de la  considerada como una de las más potentes, peligrosas y persistentes armas del ciberespionaje ruso: el malware o  software malicioso Snake, creado por el Servicio Federal de Seguridad (FSB), la organización estatal de espionaje heredera del KGB.

• Llevaba cerca de 20 años obteniendo información confidencial de instituciones, gobiernos y medios de comunicación en al menos 50 países,
• Snake fue apodado “el implante de malware de ciberespionaje a largo plazo más sofisticado del FSB”, lo que permite a sus usuarios instalar malware de forma remota en dispositivos comprometidos, robar documentos e información privada (como credenciales de autenticación), mantener la persistencia y ocultar sus actividades maliciosas al utilizar este “red encubierta de igual a igual”.
  

Los rusos supuestamente usaron el malware para robar información confidencial de los sistemas informáticos en al menos 50 países y para espiar a periodistas y otros “objetivos de interés” rusos, dijeron funcionarios del Departamento de Justicia y del FBI. Los funcionarios rusos supuestamente robarían los materiales y los enrutarían a través de computadoras estadounidenses que habían sido infectadas con malware para tratar de evitar la detección.

"Snake" está considerada la herramienta de espionaje cibernético más peligrosa y sofisticada diseñada y utilizada por el FSB ruso -el KGB moderno- para la recopilación de inteligencia a largo plazo sobre objetivos sensibles. Para realizar operaciones con esta herramienta, el FSB creó una red encubierta "peer-to-peer" (P2P) de numerosos ordenadores infectadas con "Snake" en todo el mundo.

El gobierno de EEUU lanzó la “Operación Medusa” para desactivar de forma encubierta a Snake, dijeron las autoridades. El FBI hizo esto mediante la creación de una herramienta cibernética llamada “Perseus”, que esencialmente usaba codificación para exigir que el malware Snake se sobrescribiera a sí mismo.

El Departamento de Justicia de EE.UU., el FBI, la Agencia estadounidense de Seguridad Cibernética y de Infraestructuras (Cisa) y el Centro Nacional británico de Ciberseguridad fueron algunos de los órganos que publicaron una alerta con las claves del desciframiento de Snake y la explicación de sus consecuencias.

"Hemos identificado la infraestructura de Snake en más de 50 países de América del Norte, América del Sur, Europa, África, Asia y Australia, incluidos los Estados Unidos y la propia Rusia", anunciaron las agencias participantes en la operación.

Aunque Snake atacaba infraestructuras de todo tipo de entidades e industrias, su orientación tenía una naturaleza táctica y su propósito prioritario era "recopilar inteligencia confidencial de objetivos de alta prioridad, como redes gubernamentales, instituciones de investigación y periodistas", indicaron los expertos de los órganos oficiales.

El objetivo era robar información secreta de redes diplomáticas y gubernamentales, centros de investigación y periodistas

El FSB utilizó el programa "durante casi dos decenios" para invadir y extraer documentos confidenciales de relaciones internacionales y comunicaciones diplomáticas que incluyeron "una víctima en un país de la OTAN".

Dentro de Estados Unidos, el FSB entró efectivamente en ordenadores de redes gubernamentales, centros de investigación, instituciones académicas y educativas, pequeñas empresas y medios de comunicación.

 Para poder llevar a cabo el ataque, el FBI ha contado con una orden judicial que les ha permitido acceder a ordenadores de múltiples jurisdicciones que estaban infectadas con el malware. Según la declaración jurada, el FBI pudo identificar 19 direcciones IP asociadas con ordenadores estadounidenses que habían sido infectados con Snake, pero no han detallado el número total de máquinas afectadas en este y el resto de países. La agencia llevaría desde 2015 trabajando con varias organizaciones de víctimas para obtener más información sobre Snake.

En el operativo trabajaron las agencias la Agencia Nacional de Seguridad de EEUU (NSA), la Oficina Federal de Investigaciones (FBI), la Agencia de Seguridad de Infraestructura y Ciberseguridad (CISA), la Fuerza de Misión Nacional Cibernética (CNMF), el Centro Canadiense de Seguridad Cibernética (CCCS), el Centro Nacional de Seguridad Cibernética del Reino Unido (NCSC- Reino Unido), el Centro de Seguridad Cibernética de Australia (ACSC) y el Centro Nacional de Seguridad Cibernética de Nueva Zelanda (NCSC-NZ).

Reporte técnico (TTP)

• https://www.cisa.gov/sites/default/files/2023-05/aa23-129a_snake_malware_1.pdf

Cómo detectar Malware Snake

El siguiente complemento para el marco de análisis de memoria Volatility Plugin buscará en todos los procesos de la máquina el componente del modo de usuario de Snake que se ha inyectado en un proceso. Si se descubre, el complemento mostrará tanto el proceso inyectado como la ubicación de la memoria virtual en la que se carga el componente del modo de usuario de Snake. Si no se encuentra, el complemento no hará nada.

 # This plugin to identify the injected usermode component of Snake is based
# on the malfind plugin released with Volatility3
#
# This file is Copyright 2019 Volatility Foundation and licensed under the
# Volatility Software License 1.0
# which is available at https://www.volatilityfoundation.org/license/vsl-v1.0
import logging
from typing import Iterable, Tuple
from volatility3.framework import interfaces, symbols, exceptions, renderers
from volatility3.framework.configuration import requirements
from volatility3.framework.objects import utility
from volatility3.framework.renderers import format_hints
from volatility3.plugins.windows import pslist, vadinfo
vollog = logging.getLogger(__name__)
class snake(interfaces.plugins.PluginInterface):
 _required_framework_version = (2, 4, 0)

 @classmethod
 def get_requirements(cls):
 return [
 requirements.ModuleRequirement(name = 'kernel',
 description = 'Windows kernel',
 architectures = ["Intel32", "Intel64"]),
 requirements.VersionRequirement(name = 'pslist',
 component = pslist.PsList, version = (2, 0, 0)),
 requirements.VersionRequirement(name = 'vadinfo',
 component = vadinfo.VadInfo, version = (2, 0, 0))]
 @classmethod
 def list_injections(
 cls, context: interfaces.context.ContextInterface,
 kernel_layer_name: str, symbol_table: str,
 proc: interfaces.objects.ObjectInterface) -> Iterable[
 Tuple[interfaces.objects.ObjectInterface, bytes]]:
 proc_id = "Unknown"
 try:
 proc_id = proc.UniqueProcessId
 proc_layer_name = proc.add_process_layer()
 except exceptions.InvalidAddressException as excp:
 vollog.debug("Process {}: invalid address {} in layer {}".
 format(proc_id, excp.invalid_address, excp.layer_name))
 return
 proc_layer = context.layers[proc_layer_name]
 for vad in proc.get_vad_root().traverse():
 protection_string = vad.get_protection(vadinfo.VadInfo.
 protect_values(context, kernel_layer_name, symbol_table),
 vadinfo.winnt_protections)
 if not "PAGE_EXECUTE_READWRITE" in protection_string:
 continue
 if (vad.get_private_memory() == 1
 and vad.get_tag() == "VadS") or (vad.get_private_memory()
 == 0 and protection_string !=
 "PAGE_EXECUTE_WRITECOPY"):
 data = proc_layer.read(vad.get_start(),
 vad.get_size(), pad = True)
 if data.find(b'\x4d\x5a') != 0:
 continue
 yield vad, data
 def _generator(self, procs):
 kernel = self.context.modules[self.config['kernel']]
 is_32bit_arch = not symbols.symbol_table_is_64bit(self.context,
 kernel.symbol_table_name)
 for proc in procs:
 process_name = utility.array_to_string(proc.ImageFileName)
 for vad, data in self.list_injections(self.context,
 kernel.layer_name, kernel.symbol_table_name, proc):
 strings_to_find = [b'\x25\x73\x23\x31',b'\x25\x73\x23\x32',
 b'\x25\x73\x23\x33',b'\x25\x73\x23\x34',
 b'\x2e\x74\x6d\x70', b'\x2e\x73\x61\x76',
 b'\x2e\x75\x70\x64']
 if not all(stringToFind in data for
 stringToFind in strings_to_find):
 continue
 yield (0, (proc.UniqueProcessId, process_name,
 format_hints.Hex(vad.get_start()),
 format_hints.Hex(vad.get_size()),
 vad.get_protection(
 vadinfo.VadInfo.protect_values(self.context,
 kernel.layer_name, kernel.symbol_table_name),
 vadinfo.winnt_protections)))
 return
 def run(self):
 kernel = self.context.modules[self.config['kernel']]
 return renderers.TreeGrid([("PID", int), ("Process", str),
 ("Address", format_hints.Hex), ("Length", format_hints.Hex),
 ("Protection", str)], self._generator(pslist.PsList.list_processes(
 context = self.context, layer_name = kernel.layer_name,
 symbol_table = kernel.symbol_table_name)))

Fuentes:

https://www.lavanguardia.com/internacional/20230509/8954599/estados-unidos-aliados-desmantelan-malware-ruso-espionaje-cibernetico.html

https://www.elespanol.com/omicrono/software/20230510/golpe-historico-fbi-hackers-llevaban-decadas-espiando/762673761_0.html

https://www.infobae.com/wapo/2023/05/09/eeuu-desmantelo-una-de-las-principales-herramientas-rusas-de-espionaje-online/