-->

Intelligenza Artificiale

A un certo punto non fu più la biologia a dominare il destino dell'uomo, ma il prodotto del suo cervello: la cultura.
Cosicché: "Le uniche leggi della materia sono quelle che la nostra mente deve architettare e le uniche leggi della mente sono architettate per essa dalla materia".
JAMES CLERK MAXWELL

Analisi Statica Malware


Codice PYTHON Per eseguire un'analisi statica malware utilizzando YARA e PDE su un dataset come quello di Kaggle.

Analisi statica del malware

Per eseguire un'analisi statica del malware utilizzando YARA e PDE su un dataset come quello di Kaggle (Microsoft Malware Classification Challenge), dobbiamo seguire i seguenti passaggi:
Passi generali:
1. Scaricare ed estrarre le caratteristiche statiche dai file PE (Portable Executable).
2. Definire regole YARA per identificare pattern statici specifici.
3. Applicare il PDE (Probabilistic Data Embedding) per ridurre la dimensionalità delle caratteristiche estratte.
4. Addestrare un modello di machine learning utilizzando il dataset Kaggle.
5. Valutare e rilevare malware.

Ecco un esempio di codice Python che esegue un'analisi statica con YARA e utilizza PDE per il rilevamento:

Prerequisiti

Prima di eseguire il codice, assicurati di avere installati i seguenti pacchetti:
- yara-python per le regole YARA:

pip install yara-python


- Pandas, NumPy e Scikit-learn:

pip install pandas numpy scikit-learn


- Umap-learn (per PDE):

pip install umap-learn


Scarica il dataset da Kaggle

Assicurati di avere accesso al dataset e di scaricarlo prima di procedere.
Puoi scaricarlo da Kaggle Microsoft Malware Classification Challenge
Scarica Kaggle

Codice Python per l'analisi statica del malware


import os
import yara
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report
import umap

# 1. Funzione per applicare regole YARA sui file
def apply_yara_rules(file_path, rule_path):
    rules = yara.compile(filepath=rule_path)
    try:
        matches = rules.match(file_path)
        return len(matches)  # Restituisce il numero di match delle regole YARA
    except yara.YaraError:
        return 0

# 2. Funzione per estrarre le feature statiche (es. dimensione, sezioni, YARA match)
def extract_static_features(file_path, yara_rule_path):
    try:
        file_size = os.path.getsize(file_path)
        yara_matches = apply_yara_rules(file_path, yara_rule_path)
        return [file_size, yara_matches]
    except Exception as e:
        print(f"Errore nell'analisi del file {file_path}: {e}")
        return [0, 0]

# 3. Funzione per riduzione della dimensionalità tramite PDE (UMAP)
def apply_pde(X, n_components=2):
    umap_model = umap.UMAP(n_components=n_components, random_state=42)
    return umap_model.fit_transform(X)

# 4. Carica il dataset Kaggle (Microsoft Malware Classification Challenge)
def load_kaggle_data():
    labels = pd.read_csv('trainLabels.csv')  # Etichette di addestramento
    return labels

# 5. Estrai le feature dai file PE e applica YARA
def generate_features(data_dir, yara_rule_path, labels):
    features = []
    targets = []
    for _, row in labels.iterrows():
        file_path = os.path.join(data_dir, row['Id'] + '.bytes')  # Path dei file binari
        file_features = extract_static_features(file_path, yara_rule_path)
        features.append(file_features)
        targets.append(row['Class'])  # La classe del malware
    return np.array(features), np.array(targets)

# 6. Addestra il modello di machine learning
def train_ml_model(X_train, y_train, X_test, y_test):
    # Modello di classificazione Random Forest
    clf = RandomForestClassifier(n_estimators=100, random_state=42)
    clf.fit(X_train, y_train)
    
    # Predizioni
    y_pred = clf.predict(X_test)
    
    # Valutazione del modello
    accuracy = accuracy_score(y_test, y_pred)
    print(f'Accuratezza del modello: {accuracy}')
    print(classification_report(y_test, y_pred))

# Percorso ai file
data_dir = 'kaggle_malware_data/train'  # Directory con i file binari di Kaggle
yara_rule_path = 'rules.yar'  # Regole YARA da definire

# 7. Carica il dataset e genera le feature
labels = load_kaggle_data()
X, y = generate_features(data_dir, yara_rule_path, labels)

# 8. Applica PDE (UMAP per riduzione dimensionale)
X_pde = apply_pde(X, n_components=10)

# 9. Dividi i dati in training e test set
X_train, X_test, y_train, y_test = train_test_split(X_pde, y, test_size=0.3, random_state=42)

# 10. Addestra e valuta il modello
train_ml_model(X_train, y_train, X_test, y_test)

Spiegazione del codice

1. YARA: Utilizziamo YARA per analizzare i file binari e rilevare pattern associati a malware noti. Le regole YARA sono definite in un file `.yar` che puoi personalizzare in base ai pattern che vuoi cercare.
2. Estrazione delle feature statiche: Estraiamo due semplici caratteristiche: la dimensione del file e il numero di corrispondenze alle regole YARA.
3. PDE (UMAP): Utilizziamo UMAP per ridurre la dimensionalità dei dati e rendere il modello di machine learning più efficiente.
4. Addestramento del modello: Utilizziamo una Random Forest per classificare il malware in base alle feature estratte. I dati sono divisi in training e test set per valutare l'accuratezza del modello.

Creazione delle regole YARA


Ecco un esempio di regola YARA che può essere utilizzata per rilevare alcune stringhe o pattern specifici nei file binari:

rule ExampleMalwareRule
{
    meta:
        description = "Rilevamento di stringhe specifiche in malware"
        author = "Analisi Malware"
        date = "2024-09-23"

    strings:
        $a = "malicious_string_1"
        $b = { 6A 40 68 00 30 00 00 6A 14 8D 91 }  # Pattern binario specifico

    condition:
        any of them
}

Conclusione

Questo esempio combina YARA e PDE per eseguire un'analisi statica del malware, riducendo le dimensioni del dataset tramite UMAP e utilizzando Random Forest per il rilevamento e la classificazione del malware.
Puoi personalizzare le regole YARA per riconoscere specifici pattern di malware e ottimizzare il modello con ulteriori caratteristiche e tecniche di machine learning.