Catturare Traffico Anomalo

Cattura del traffico con PyShark

Nel primo esempio di codice, abbiamo catturato il traffico con PyShark utilizzando `capture.sniff(timeout=capture_duration)`.
Questi pacchetti catturati contengono molte informazioni che dobbiamo estrarre, come durata della connessione, byte inviati e ricevuti, protocolli, ecc.

Estrazione dei dati dai pacchetti

Dobbiamo elaborare i pacchetti catturati da PyShark per ottenere un dataset strutturato.
PyShark ci permette di accedere a campi specifici di ogni pacchetto, come il protocollo, il numero di byte inviati e ricevuti, il tempo di invio, ecc.
Ecco un esempio di codice aggiornato per estrarre le caratteristiche rilevanti dal traffico catturato con **PyShark**: Estrazione dei dati da pacchetti PyShark

 
import pyshark
import pandas as pd
from sklearn.ensemble import IsolationForest
from sklearn.preprocessing import LabelEncoder

# Passo 1: Cattura il traffico con PyShark (simulazione di traffico in tempo reale)
tshark_path = '/usr/local/bin/tshark'  # Modifica con il percorso corretto su macOS
pyshark.tshark.tshark_path = tshark_path

# Cattura il traffico per 60 secondi
capture_duration = 60  # 60 secondi di cattura
interface_name = 'en0'  # Interfaccia di rete (modifica con la tua interfaccia)

capture = pyshark.LiveCapture(interface=interface_name)
capture.sniff(timeout=capture_duration)

# Passo 2: Estrazione dei dati rilevanti dai pacchetti catturati
packets_data = []

for packet in capture:
    try:
        # Estrai le informazioni principali dai pacchetti
        protocol = packet.transport_layer  # Livello di trasporto (TCP/UDP)
        src_bytes = int(packet.length)  # Lunghezza del pacchetto in byte
        dst_bytes = int(packet.ip.len) if hasattr(packet, 'ip') else 0  # Byte di destinazione (livello IP)
        duration = float(packet.sniff_timestamp)  # Timestamp del pacchetto

        # Memorizza i dati in un dizionario
        packet_info = {
            'protocol': protocol,
            'src_bytes': src_bytes,
            'dst_bytes': dst_bytes,
            'duration': duration,
        }
        packets_data.append(packet_info)

    except AttributeError:
        # Salta i pacchetti che non hanno i campi richiesti
        continue

# Converti i dati in un DataFrame
df_captured = pd.DataFrame(packets_data)

# Pulizia e preprocessamento
# Sostituiamo i valori nulli (alcuni pacchetti potrebbero non avere tutti i campi)
df_captured.fillna(0, inplace=True)

# Convertiamo il protocollo in numerico (TCP=0, UDP=1, ICMP=2)
df_captured['protocol'] = df_captured['protocol'].map({'TCP': 0, 'UDP': 1, 'ICMP': 2}).fillna(3)

# Passo 3: Carica il dataset NSL-KDD per l'addestramento
url = "https://raw.githubusercontent.com/defcom17/NSL_KDD/master/KDDTrain+.txt"
column_names = [
    'duration', 'protocol_type', 'service', 'flag', 'src_bytes', 'dst_bytes',
    'land', 'wrong_fragment', 'urgent', 'hot', 'num_failed_logins', 'logged_in',
    'num_compromised', 'root_shell', 'su_attempted', 'num_root', 'num_file_creations',
    'num_shells', 'num_access_files', 'num_outbound_cmds', 'is_host_login',
    'is_guest_login', 'count', 'srv_count', 'serror_rate', 'srv_serror_rate',
    'rerror_rate', 'srv_rerror_rate', 'same_srv_rate', 'diff_srv_rate',
    'srv_diff_host_rate', 'dst_host_count', 'dst_host_srv_count', 'dst_host_same_srv_rate',
    'dst_host_diff_srv_rate', 'dst_host_same_src_port_rate', 'dst_host_srv_diff_host_rate',
    'dst_host_serror_rate', 'dst_host_srv_serror_rate', 'dst_host_rerror_rate',
    'dst_host_srv_rerror_rate', 'label'
]

nsl_kdd = pd.read_csv(url, names=column_names)
categorical_columns = ['protocol_type', 'service', 'flag']
encoder = LabelEncoder()

for col in categorical_columns:
    nsl_kdd[col] = encoder.fit_transform(nsl_kdd[col])

X_train = nsl_kdd.drop(columns=['label'])
y_train = nsl_kdd['label'].apply(lambda x: 0 if x == 'normal' else 1)

# Passo 4: Addestramento del modello
model = IsolationForest(contamination=0.1, random_state=42)
model.fit(X_train)

# Passo 5: Previsione sulle anomalie con il traffico catturato
df_captured['anomaly'] = model.predict(df_captured)

# Valori -1 indicano anomalie, 1 indica traffico normale
print(df_captured)
 
 

Descrizione del Codice

• Cattura del traffico con PyShark: Il traffico viene catturato utilizzando PyShark sulla tua interfaccia di rete per 60 secondi. Vengono catturati vari campi dei pacchetti, come il protocollo (`TCP`, `UDP`), i byte inviati e ricevuti, e il timestamp (per calcolare la durata).
• Estrazione dei dati rilevanti: I dati del traffico catturato vengono estratti dai pacchetti PyShark e organizzati in un DataFrame. Alcuni pacchetti potrebbero non avere tutti i campi necessari, quindi vengono gestiti con try-except per evitare errori.
• Preprocessamento: I protocolli sono mappati a valori numerici (ad es. TCP=0, UDP=1). Vengono gestiti i valori mancanti e normalizzati i dati per l'uso con il modello di machine learning.
• Addestramento del modello: Il modello **Isolation Forest** viene addestrato utilizzando il dataset **NSL-KDD**. Il modello viene addestrato a distinguere tra traffico normale e anomalie.
• Previsione sulle anomalie: Il modello addestrato viene poi applicato al traffico catturato. I pacchetti vengono etichettati come anomalie (`-1`) o normali (`1`).

Output

Il DataFrame `df_captured` mostrerà il traffico catturato con una colonna aggiuntiva `anomaly`, in cui i pacchetti anomali vengono segnalati con `-1` e quelli normali con `1`.

   protocol  src_bytes  dst_bytes  duration  anomaly
0         0        100        500     1.23         1
1         1        150        520     1.45         1
2         0        200        550     1.67         1
3         1       3000       3000     1.89        -1  # Pacchetto anomalo

Conclusione

In questo esempio, abbiamo catturato il traffico di rete utilizzando PyShark, estratto i dati rilevanti dai pacchetti, e poi utilizzato un modello di machine learning addestrato su un dataset reale (**NSL-KDD**) per rilevare potenziali anomalie.
Questo approccio può essere esteso per monitorare il traffico di rete in tempo reale e identificare comportamenti sospetti o attacchi informatici.