Sistema de Detección de Malware con YARA

Código Fuente Completo


import yara
import os
import pymongo

# Variables de configuración MongoDB
MONGO_URI = "mongodb://localhost:27017"  # URI de conexión a MongoDB
DB_NAME = "memes"  # Nombre de la base de datos
COLLECTION_NAME = "metadata"  # Nombre de la colección
RUTA_REGLAS = "./reglas"  # Ruta donde se encuentran las reglas YARA

def obtener_archivosde_mongodb():
    listado_archivos = []
    """
    Conecta a MongoDB y obtiene la lista de archivos en la colección.

    Returns:
        list: Lista de archivos en la colección
    """
    client = pymongo.MongoClient(MONGO_URI)
    db = client[DB_NAME]
    collection = db[COLLECTION_NAME]

    # Obtener todos los documentos en la colección
    archivos = list(collection.find({}))

    for archivo in archivos:
        listado_archivos.append(archivo["ruta"])
        print(archivo["ruta"])

    client.close()
    return listado_archivos

def obtener_lista_reglas_yara(ruta):
    lista= []
    for root, dir, filenames in os.walk(ruta):
        for filename in filenames:
            if filename.endswith('.yar') or filename.endswith('.yara'):
                lista.append(os.path.join(root, filename))
    return lista

def scan_file_with_yara(filepath, rules_filepath):
    """
    Escanea un archivo dado utilizando un conjunto de reglas YARA.

    Args:
        filepath (str): La ruta al archivo que se desea escanear.
        rules_filepath (str): La ruta al archivo que contiene las reglas YARA (.yar).

    Returns:
        list: Una lista de objetos Match que representan las reglas que coincidieron.
              Devuelve una lista vacía si no hay coincidencias o si hay un error.
    """
    if not os.path.exists(filepath):
        print(f"Error: El archivo '{filepath}' no existe.")
        return []

    if not os.path.exists(rules_filepath):
        print(f"Error: El archivo de reglas YARA '{rules_filepath}' no existe.")
        return []

    try:
        # Compila las reglas YARA desde el archivo
        rules = yara.compile(filepath=rules_filepath)

        # Escanea el archivo y obtiene las coincidencias
        matches = rules.match(filepath=filepath)

        return matches

    except yara.Error as e:
        print(f"Error al compilar las reglas YARA o al escanear: {e}")
        return []
    except Exception as e:
        print(f"Ocurrió un error inesperado: {e}")
        return []

if __name__ == "__main__":
    archivos_a_escanear = obtener_archivosde_mongodb()

    for archivo_a_escanear in archivos_a_escanear:
        print(f"Escaneando archivo: {archivo_a_escanear}")
        rules_files = obtener_lista_reglas_yara(RUTA_REGLAS)

        for rule in rules_files:
            #print(f"Escaneando {archivo_a_escanear} con reglas {rule}")
            results = scan_file_with_yara(archivo_a_escanear, rule)

            if results:
                print(f"¡Malware detectado en '{archivo_a_escanear}' con la regla '{rule}'!")
                for match in results:
                    print(f"  - Regla: {match.rule}")
                    print(f"  - Meta: {match.meta}")
                    print(f"  - Cadenas coincidentes: {match.strings}")
            else:
                #print(f"No se detectó malware en '{archivo_a_escanear}' con la regla '{rule}'.")
                pass

    print("Escaneo completado.")

Funcionalidad del Sistema

Descripción General: Este script implementa un sistema automatizado de detección de malware que utiliza el motor de análisis YARA para escanear archivos almacenados en una base de datos MongoDB.

obtener_archivosde_mongodb()

Conecta con la base de datos MongoDB
Obtiene la lista de rutas de archivos desde la colección 'metadata'
Retorna una lista con las rutas de todos los archivos

obtener_lista_reglas_yara()

Escanea recursivamente el directorio de reglas
Identifica archivos con extensiones .yar y .yara
Retorna una lista con todas las reglas disponibles

scan_file_with_yara()

Función principal de análisis que:

Valida la existencia del archivo objetivo
Verifica la disponibilidad de las reglas YARA
Compila las reglas YARA dinámicamente
Ejecuta el análisis del archivo
Gestiona errores de compilación y ejecución
Retorna los resultados de coincidencias

Tecnologías Empleadas

Python 3.x

Lenguaje de programación principal del sistema

YARA Engine

Motor de análisis de malware mediante patrones y reglas

MongoDB

Base de datos NoSQL para almacenar metadatos de archivos

Dependencias del Sistema:

pip install yara-python - Motor YARA para Python
pip install pymongo - Cliente MongoDB para Python
import os - Biblioteca estándar de Python

Flujo de Trabajo del Sistema

1. Inicialización del Sistema

El script establece la conexión con MongoDB usando la URI configurada y define las rutas de trabajo.

2. Obtención de Archivos

Se consulta la colección 'metadata' en la base de datos 'memes' para obtener la lista de archivos a analizar.

3. Carga de Reglas YARA

El sistema escanea recursivamente el directorio './reglas' buscando archivos .yar y .yara.

4. Análisis Cruzado

Cada archivo se analiza contra todas las reglas YARA disponibles de forma sistemática.

5. Detección y Reporte

Si se detecta malware, se muestran los detalles de la regla coincidente, metadatos y cadenas detectadas.

6. Finalización

Una vez completado el análisis de todos los archivos, el sistema muestra un mensaje de confirmación.

Características de Seguridad:

Validación de Archivos: Verifica la existencia de archivos antes del análisis
Gestión de Errores: Captura excepciones de YARA y errores generales
Análisis Exhaustivo: Cada archivo se evalúa contra múltiples reglas
Reporte Detallado: Proporciona información específica sobre cada detección

Configuración y Uso

Configuración

MONGO_URI: URI de conexión a MongoDB
DB_NAME: Base de datos "memes"
COLLECTION_NAME: Colección "metadata"
RUTA_REGLAS: Directorio "./reglas"

Ejecución

python malware_scanner.py

El script se ejecuta automáticamente al ser invocado, realizando un análisis completo de todos los archivos registrados en MongoDB.