petabi/snifflesSniffles: Generatore di Cattura di Pacchetti per IDS e Valutazione delle Espressioni Regolari
Sniffles è uno strumento per creare catture di pacchetti che testeranno gli IDS che utilizzano pattern fissi o espressioni regolari per rilevare comportamenti sospetti. Sniffles funziona in modo molto semplice. Prende un insieme di espressioni regolari o regole e sceglie casualmente un'espressione regolare o una regola. Genera quindi contenuti basati su quella regola o espressione regolare. Per stringhe fisse, ciò significa aggiungere la stringa direttamente ai dati (possibilmente con offset o altre opzioni come da regole Snort). Per espressioni regolari il processo è un po' più complesso. L'espressione regolare viene convertita in un NFA e viene scelto un percorso casuale attraverso l'NFA (dall'inizio alla fine). I dati risultanti corrisponderanno all'espressione regolare. Infine, Sniffles può essere impostato per corrispondenza completa o parziale. Con una corrispondenza completa, i dati del pacchetto corrisponderanno assolutamente ad almeno una regola o espressione regolare (alcune opzioni Snort non sono pienamente considerate). Una corrispondenza parziale cancellerà l'ultimo carattere da una sequenza di caratteri corrispondente a una sequenza che non dovrebbe corrispondere (potrebbe però corrispondere a un'altra regola). Le regole corrispondenti dovrebbero causare il maggior carico su un IDS. Quindi, è possibile determinare quanto bene l'IDS gestisce il traffico nel caso peggiore. Il traffico a corrispondenza parziale causerà quasi lo stesso carico del traffico corrispondente. Infine, Sniffles può anche generare traffico che ha dati completamente casuali. Tali dati casuali offrono uno scenario migliore poiché è molto improbabile che i dati casuali corrispondano a qualsiasi regola. Quindi, possono essere elaborati alla massima velocità. Così, Sniffles permette la creazione di catture di pacchetti per il funzionamento nel caso migliore e peggiore dell'ispezione approfondita dei pacchetti IDS.
Oltre a quanto sopra, Sniffles ha anche la capacità di creare catture di pacchetti di valutazione. Esistono due tipi di catture di pacchetti di valutazione. La prima cattura di pacchetti di valutazione creerà esattamente un pacchetto per ogni regola o espressione regolare, in sequenza. Quindi è possibile testare e vedere che ogni regola corrisponde come previsto. La valutazione completa va un passo oltre e crea un pacchetto per ogni possibile ramo in un'espressione regolare. Una singola espressione regolare potrebbe avere migliaia di possibili rami. Questo testa per garantire che tutti i possibili rami di un'espressione regolare siano gestiti correttamente. Le catture di pacchetti di valutazione dovrebbero corrispondere a tutti i pacchetti. Eventuali pacchetti non corrispondenti molto probabilmente rappresentano un fallimento dell'IDS e necessitano di ulteriori indagini. Ovviamente, c'è sempre la possibilità che Sniffles non stia creando il pacchetto corretto per un dato IDS, o non riconosca una particolare opzione per una regola. Controlla le funzionalità delle regole supportate per maggiori informazioni.
Infine, Sniffles può anche fare molto per generare traffico di rete casuale. Per impostazione predefinita, il traffico casuale è TCP, UDP o ICMP e unidirezionale. Tuttavia, può anche generare traffico TCP con ACK, handshake e teardown per ogni flusso. Genererà numeri di sequenza e checksum corretti. Inoltre, gli indirizzi MAC possono essere impostati secondo le distribuzioni desiderate, e gli indirizzi di rete IP possono essere definiti da spazi di indirizzi Home ed External. Inoltre, è possibile simulare scansioni all'interno di una cattura di traffico.
RICHIEDE: Python 3.3+ e il modulo SortedContainers
Sniffles consiste nei seguenti file:
Per installare:
python3.x setup.py install.Note sull'installazione:
python3.x setup.py build per compilare localmente, poi vai nella directory della libreria, trova la lib e usa python3.4 -c "from sniffles import sniffles; sniffles.main()" per eseguire localmente.Snort: Regole di alert Snort (la regola dovrebbe iniziare con la direttiva Alert). I tag Content sono riconosciuti e analizzati correttamente. I tag PCRE sono anch'essi analizzati correttamente. I tag HTTP vengono elaborati consecutivamente, quindi potrebbero non creare il pacchetto desiderato. Il contenuto (e il contenuto PCRE o HTTP) può essere modificato da distance, within e offset. Una regola può utilizzare un'opzione di controllo del flusso, sebbene da essa venga derivata solo la direzione dei dati. L'opzione nocase viene ignorata e viene utilizzata la lettera maiuscola/minuscola presentata. Tutte le altre opzioni sono ignorate. I valori dell'intestazione vengono analizzati e verrà generato un pacchetto che soddisfa tali valori. Se vengono utilizzati spazi di indirizzi di rete Home ed External, verrà utilizzato lo spazio corretto per le rispettive variabili $HOME_NET e $EXTERNAL_NET. Esempio:
alert tcp $EXTERNAL_NET any -> $HOME_NET 8080 (msg:"SERVER-APACHE Apache Tomcat UNIX platform directory traversal"; flow:to_server; content:"/..|5C|/"; content:"/..|5C|/"; http_raw_uri;
Espressioni regolari: Espressioni regolari grezze, una per riga, scritte come abc o /abc/i. Attualmente supporta le opzioni i, s e m. Altre opzioni sono ignorate. Esempio:
/ab*c(d|e)f/i
Formato regola Sniffles descritto di seguito.
-a TCP Ack: Invia un acknowledgment TCP per ogni pacchetto di dati inviato. Disattivato per impostazione predefinita. I pacchetti di acknowledgment non hanno dati per impostazione predefinita.
-b Bidirezionale: I dati verranno generati in entrambe le direzioni di un flusso TCP. Gli ACK verranno attivati. Questa funzione è disattivata per impostazione predefinita.
-B [Protocollo traffico di fondo:Percentuale]: Imposta almeno un protocollo con valore compreso tra 1 e 100 per produrre traffico di fondo. Questo valore rappresenta la percentuale del totale del traffico. Protocolli disponibili: FTP, HTTP, IMAP, POP e SMTP. Ad esempio: "http:20,ftp:30,smtp:10". Inserisci un solo numero come valore dell'argomento per generare traffico casuale. Ad esempio: "80".
-c Conteggio: Numero di flussi da creare. Ogni flusso conterrà un minimo di 1 pacchetto. Il pacchetto sarà tra due endpoint come definiti dalla regola o scelti casualmente. tcp_handshake, tcp_teardown e packets_per_stream aumenteranno il numero di pacchetti per flusso. Attualmente, i dati in un flusso scorrono in una sola direzione. Se si utilizza l'opzione -b, i dati dovrebbero fluire in entrambe le direzioni. Inoltre, le regole Sniffles possono designare dati per fluire in entrambe le direzioni.
-C Flussi concorrenti: Numero di flussi che saranno aperti contemporaneamente. Sforzo massimo: se ci sono meno flussi del numero di flussi concorrenti designati, verranno utilizzati tutti i flussi correnti. Ad esempio, se rimangono solo 1000 flussi, ma il numero di flussi concorrenti era impostato a 10000, verranno comunque scritti solo 1000 flussi in quel momento. Il valore predefinito è 1000. Se utilizzato con durata, i flussi -C verranno mantenuti per tutta la durata, che alla fine ignorerà qualsiasi input da -c. Nota, lo scopo è creare un pcap diversificato in cui i pacchetti degli stessi flussi siano distribuiti anziché uno accanto all'altro e per creare l'illusione di molti flussi concorrenti. Nei nostri test, siamo arrivati fino a 2-3 milioni di flussi concorrenti prima che la memoria diventasse un problema. Inoltre, dovremmo menzionare che diverse latenze tra i flussi possono causare la terminazione anticipata di alcuni flussi rispetto ad altri.
-d Directory regole: percorso per la directory contenente i file delle regole. Leggerà ogni regola abilitata in tutti i file delle regole nella directory. Presuppone che tutte le regole terminino con l'estensione .rules. Usa questa opzione o -f, ma non entrambe. Il simbolo # viene utilizzato per disattivare (cioè commentare) una regola.
-D Durata: Genera in base alla durata piuttosto che al conteggio. La durata è in secondi. Tieni presente che la latenza predefinita tra i pacchetti è in media di 1-200 microsecondi. Per latenze basse, una durata lunga potrebbe comportare milioni di pacchetti che potrebbero richiedere molto tempo per essere costruiti. Inoltre, la durata è uno sforzo massimo. Essenzialmente, nuovi flussi non vengono creati dopo che la durata è stata raggiunta, ma potrebbero esserci flussi che non sono stati completati. Questi vengono comunque scritti, quindi la durata effettiva potrebbe essere più lunga di quella designata, ma non dovrebbe essere inferiore. Infine, imposta una latenza maggiore se desideri che vengano creati meno flussi durante la generazione.
NOTA: tutti gli esempi presuppongono che tu abbia installato il pacchetto sniffles.
Per generare un pcap da un singolo file di espressioni regolari con 10 flussi in cui ogni pacchetto corrisponde a una regola
sniffles -c 10 -f myre.re -m
Per generare un pcap da un singolo file di regole snort in cui ogni pacchetto corrisponde quasi a una regola
sniffles -c 10 -f myrules.rules
Per generare un pcap da più file di regole snort in una singola directory in cui ogni pacchetto corrisponde a una regola.
sniffles -c 10 -d myrulesdir -m
Per generare lo stesso pcap di cui sopra, usando le stesse regole, ma con contenuto casuale (il contenuto è casuale, le intestazioni seguiranno comunque le regole--non funziona con regex o regole Sniffles):
sniffles -c 10 -d myrulesdir -r
Per generare un pcap con 10 flussi (1 pacchetto ciascuno) e con dati casuali:
sniffles -c 10
Per generare un pcap con 10 flussi in cui il 50% dei flussi sarà traffico di fondo e il resto dei flussi conterrà pacchetti corrispondenti a una regola:
sniffles -c 10 -B 50 myrules.rules
Per generare un pcap con 10 flussi, ogni flusso con 5 pacchetti, con ACK e handshake e teardown oltre a una lunghezza fissa di 50 per i dati in ogni pacchetto con dati:
sniffles -c 10 -p 5 -l 50 -t -T -a
Per generare un pcap con 20 flussi casuali con una rete home di 192.168.1-2.x:
sniffles -c 20 -h 192.168.1,192.168.2
Per generare un pcap con 20 flussi casuali con una rete home di 192.168.1.x per IPv4 e 2001:8888:8888 per IPv6 con il 50% del traffico IPv6:
sniffles -c 20 -h 192.168.1 -H 2001:8888:8888 -i 50
Per generare una cattura di pacchetti di 5 secondi di pacchetti casuali con un intervallo medio tra i pacchetti di 100 microsecondi:
sniffles -D 5 -L 100
Per generare un pcap che creerà un pacchetto corrispondente a ogni regola in un file di regole (o file regex) in sequenza:
sniffles -f myrules.rules -e
Per generare un pcap che creerà un pacchetto per ogni possibile ramo di una regex per ogni regex in un insieme di regex e poi salvare quel file in un pcap chiamato everything.pcap è come sotto. Tuttavia, questa funzione può funzionare in tempo esponenziale se la regex ha una grande quantità di conteggio min-max, quindi potrebbe richiedere molto tempo per essere eseguita. Inoltre, tutte le altre opzioni tranne le due illustrate di seguito vengono ignorate.
sniffles -f myrules.rules -o everything.pcap -E
Per generare traffico casuale con un attacco di scansione che si verifica 2 secondi dopo e che dura 2 secondi con 1000 pacchetti di scansione al secondo e con l'intera cattura con una durata di 5 secondi e un tempo di intervallo di 50us e con porta di partenza 80 (ricerca sequenziale delle porte da 80):
sniffles -D 5 -O 2 -W 2 -I 1000 -L 50 -s 192.168.1.2 -P 80
Simile a sopra, ma creerà più attacchi di scansione, ciascuno con durata di 1 secondo e un offset medio tra gli attacchi di 2 secondi. Inoltre, scansiona solo le porte designate. Inoltre, prende di mira l'indirizzo IP nell'intervallo 192.168.1.0-255 in modo casuale.
sniffles -D 8 -O 2 -W 1 -I 10 -L 50 -s 192.168.1 -P 80,8080,8000,8001
Sniffles supporta diversi formati di regole. In primo luogo, Sniffles può analizzare le regole Snort e le espressioni regolari (una per riga). Oltre a questo, Sniffles ha anche un proprio formato di regola che può essere utilizzato per controllare esplicitamente il traffico. Ciò viene fatto attraverso l'uso di file xml che descriveranno il traffico. Quando viene utilizzato questo formato, le altre opzioni per Sniffles potrebbero essere irrilevanti. Esempi di file di regole possono essere trovati nella directory examples. Questi file di regole vengono utilizzati semplicemente designando il file di regole con l'opzione -f (cioè sniffles -f rules.xml)
Il formato regola Sniffles è il seguente:```xml
<petabi_rules> <traffic_stream proto="tcp" src="any" dst="any" sport="any" dport="any" handshake="True" teardown="True" synch="True" ip="4"> </traffic_stream> <traffic_stream proto="tcp" src="any" dst="any" sport="any" dport="any" handshake="True" teardown="True" synch="True"> </traffic_stream> </petabi_rules>
Nel dettaglio, i tag funzionano come segue:
- `<petabi_rules> </petabi_rules>`: Questo definisce tutte le regole per questo
file di regole. Dovrebbe esserci un solo insieme di questi tag che apre e
chiude tutti i flussi di traffico designati.
- `<rule > </rule>`: Designa una singola regola. Una singola regola può generare
un numero arbitrario di flussi di traffico o pacchetti. Può esserci qualsiasi numero
di regole in un singolo file.
- Opzioni:
- name: Il nome di questa regola. Principalmente a scopo di documentazione, nessuna
funzione reale.
- `<traffic_stream> </traffic_stream>`: Un flusso di traffico definisce il traffico
tra due endpoint. Tutti i pacchetti designati all'interno di un singolo flusso
di traffico condivideranno gli stessi endpoint. Qualsiasi numero di flussi di traffico
può essere designato per una data regola. Flussi di traffico diversi all'interno
della stessa regola possono avere endpoint diversi oppure no, a seconda delle
impostazioni seguenti.
- Opzioni:
- typets: Specifica quale tipo di flusso di traffico utilizzeremo per
generare i pacchetti. Attualmente abbiamo Standard, ScanAttack e
BackgroundTraffic.
- scantype: 1==Syn scan (predefinito) 2 == Connection scan.
Viene utilizzato con ScanAttack.
- target: Specifica l'indirizzo IP di destinazione per Scan Attack.
- targetports: Per un attacco di scansione. Fornisce un elenco separato da virgole di
porte possibili, o una singola porta di partenza. Altrimenti le porte verranno
scansionate in modo casuale. Se viene fornita una singola porta di partenza,
le porte verranno scansionate in ordine da quel punto fino a 65535,
dopo di che tornerà al punto di partenza. Questa opzione
viene utilizzata insieme a typets impostato su 'ScanAttack'
- srcport: Specifica la porta di origine per Scan Attack. Casuale per impostazione predefinita
- duration: La finestra, o durata, in secondi di un attacco di scansione
se typets è 'ScanAttack'
- intensity: Intensità dell'attacco di scansione se typets è 'ScanAttack'.
- offset: Offset prima di avviare un attacco di scansione. Viene anche utilizzato quando
si inseriscono più scansioni nel traffico.
- replychance: Probabilità che una scansione abbia una risposta.
In altre parole, probabilità che la porta di destinazione sia aperta
(predefinito 20%). Viene utilizzato con ScanAttack.
- proto: Designa il protocollo di questo flusso di traffico.
Dovrebbe essere TCP o UDP o ICMP (non testato).
- src: Indirizzo IP di origine. Può essere un indirizzo in formato xxx.xxx.xxx.xxx,
$EXTERNAL_NET (per un indirizzo esterno – presuppone che una rete
domestica sia stata designata), $HOME_NET, o any (seleziona
casualmente l'indirizzo IP).
- dst: Indirizzo IP di destinazione. Uguale all'indirizzo IP di origine.
- sport: Porta di origine (presuppone TCP o UDP). Può utilizzare la formattazione
delle porte di snort che può essere un elenco separato da virgole tra parentesi
(es. [80,88,89]), un intervallo (es. [10:1000]), o any
(es. scelta casuale da 0 a 65535).
- dport: Porta di destinazione come per sport.
- handshake: Genererà un handshake TCP all'inizio del
flusso. Se escluso, non ci sarà handshake. I valori validi
sono true o false. Il valore predefinito è false.
- latency: imposta la latenza media tra i pacchetti (in microsecondi).
- teardown: Chiuderà il flusso quando tutto il traffico è stato inviato
aggiungendo il teardown TCP alla fine del flusso di traffico.
I valori validi sono true o false. Il valore predefinito è false.
- synch: I flussi di traffico sono sincroni o meno. Quando è true, un
flusso di traffico deve terminare prima che il successivo flusso di traffico
inizi. Quando è false, tutti i flussi contigui che sono false
(cioè asincroni) verranno eseguiti contemporaneamente.
- tcp_overlap: Il valore predefinito è false. Quando è true, dal
secondo pacchetto verrà aggiunto un contenuto extra e il numero
di sequenza TCP verrà ridotto di uno per simulare la sovrapposizione
del numero di sequenza TCP.
- ipv: Designa IPv4 o IPv6. Le opzioni valide sono 4 o 6.
Il valore predefinito è 4.
- out_of_order: Fa sì che i pacchetti arrivino in modo casuale fuori ordine.
Nota: funziona solo con pacchetti che utilizzano l'opzione
'times'. Inoltre, questa opzione dovrebbe essere utilizzata anche con ack in modo
che i duplicati di ack appropriati appaiano nella traccia del traffico.
I valori validi sono true o false. Il valore predefinito è false.
- out_of_order_prob: Imposta la probabilità che i pacchetti arrivino
fuori ordine. Ad esempio, 10 significherebbe che c'è una probabilità del 10%
per ogni pacchetto di arrivare fuori ordine. I pacchetti fuori ordine
arrivano dopo tutti i pacchetti in ordine.
Inoltre, vengono anche mescolati in modo casuale. Pertanto,
se si determina che i primi pacchetti 2 e 5 su 10 pacchetti sono fuori
ordine, arriveranno per ultimi tra i 10 pacchetti
(slot 9 e 10) e saranno in un ordine arbitrario
(cioè il 5 può arrivare prima del 2 o viceversa). Il valore
per questo deve essere compreso tra 1 e 99. Il valore predefinito è 50.
- packet_loss: Fa sì che i pacchetti vengano persi in modo casuale (cioè non arrivino).
Funziona solo con l'opzione 'times'. Inoltre, questa opzione
dovrebbe essere utilizzata anche con l'opzione ack impostata su true in modo che
duplicati di ack appaiano nella traccia del traffico. I valori validi
sono da 1 a 99 e rappresentano la probabilità che un pacchetto venga perso.
Nota: la perdita di pacchetti avviene solo sui pacchetti contenenti dati, non
sugli ack.
- ack: Fa sì che ogni pacchetto di dati in questo flusso sia seguito da
un ACK dal server. I valori validi sono true o false.
Il valore predefinito è false.
- percentage: Questo si applica solo a BackgroundTraffic e dovrebbe esserci
solo una regola di BackgroundTraffic in un file di regole o directory.
La percentuale indica la percentuale di flusso di traffico di background
da creare nel flusso di traffico totale.
- http: Distribuzione percentuale dei protocolli applicativi http nel
flusso di traffico di background.
- ftp: Distribuzione percentuale dei protocolli applicativi ftp nel
flusso di traffico di background.
- pop: Distribuzione percentuale dei protocolli applicativi pop nel
flusso di traffico di background.
- smtp: Distribuzione percentuale dei protocolli applicativi smtp nel
flusso di traffico di background.
- imap: Distribuzione percentuale dei protocolli applicativi imap nel
flusso di traffico di background.
- `<pkt > </pkt>`: Questa direttiva designa un singolo
pacchetto o una serie di pacchetti. La funzionalità times può essere utilizzata per fare in modo che una
direttiva `<pkt> </pkt>` generi diversi pacchetti. Altrimenti, è
necessario designare esplicitamente ogni pacchetto in ogni direzione.
- Opzioni:
- dir: La direzione del pacchetto. I valori validi sono to server
o to client. L'IP sorgente iniziale è considerato il client,
e l'IP destinazione iniziale è il server. Quindi 'to server' invia un
pacchetto dal client al server e 'to client' invia un pacchetto
dal server al client. Il valore predefinito è to server.
- content: Espressione regolare che designa il contenuto per questo
pacchetto. La dimensione del pacchetto dipenderà dall'espressione
regolare.
- fragment: Indica se frammentare o meno questo pacchetto.
Funziona solo con ipv4. Dovrebbe avere un valore maggiore di 2.
Verranno creati tanti frammenti quanti sono validi o quanti designati
(il minore dei due). Il valore predefinito è 0, che significa nessun
frammento.
- ack: Inviare un ack a questo pacchetto o no. I valori validi sono
true o false. Il valore predefinito è false.
- split: Suddividere il contenuto tra il numero designato di
pacchetti. Per impostazione predefinita, tutto il contenuto viene inviato in un singolo
pacchetto (i frammenti rappresentano una piccola eccezione a questa regola).
- times: Invia questo pacchetto x volte. Il valore predefinito è 1;
un valore positivo invierà esattamente x pacchetti (possibilmente
con ack se ack è true), mentre un numero negativo invierà
un numero casuale di pacchetti compreso tra 1 e abs(-x).
- ttl: imposta il valore time to live per il pacchetto. Per impostazione predefinita,
sniffles genererà un valore TTL casuale.
- ttl_expiry: simula l'attacco di scadenza TTL suddividendo
i pacchetti in più pacchetti con un pacchetto dannoso
tra due pacchetti buoni. Per impostazione predefinita, il valore è 0
(nessun pacchetto dannoso). Se il valore è diverso da zero, verrà
inserito un pacchetto dannoso con ttl uguale al valore ttl_expiry.
Se il valore ttl è impostato, il pacchetto buono verrà impostato
con il nuovo valore ttl.
Note finali: Il nuovo formato delle regole è solo un inizio e potrebbe contenere problemi.
Segnalami eventuali incongruenze o errori. Inoltre, l'intenzione è di
espandere le opzioni per fornire sempre più funzionalità secondo necessità.
Contattami per funzionalità desiderate. Infine, questo prodotto è
fornito così com'è. Non vi è alcuna garanzia di funzionalità o
accuratezza. Sentiti libero di eseguire il fork di questo progetto per soddisfare le tue esigenze.
Crediti:
--------
Questa applicazione ti è offerta da Petabi, Inc., dove realizziamo
soluzioni di sicurezza affidabili, realistiche e velocissime.
Autori:
- Victor C. Valgenti
- Min Sik Kim
- Tu Le
- Moosuk Pyun
Nuove funzionalità:
-------------
- 11/21/2014: Versione 1.4.0 Aggiunta della suddivisione del traffico e di traffobot per la
generazione di traffico bidirezionale. Corretto un bug per cui veniva generata un'eccezione
quando la quantità di traffico generato poteva essere contenuta in una singola
chiamata di scrittura del traffico. Riformattato e abilitato l'utilizzo. Infine, aggiunti
test unitari per traffobot e l'analisi XML.
- 02/03/2015: Versione 2.0. Risritura completa del funzionamento dei flussi per ridurre i
requisiti di memoria durante la generazione di grandi flussi utilizzando regole speciali. Attualmente,
può gestire circa 2-3 milioni di flussi concorrenti prima che le cose rallentino. Ho
aggiunto alcune funzionalità per aiutare nella creazione di grandi flussi. In primo luogo,
genera con una concorrenza di circa 2-3 milioni di flussi. Inoltre, non utilizzare
teardown per questi flussi. Una frazione dei flussi durerà dall'inizio
fino alla fine della cattura, mentre i rimanenti verranno chiusi ogni
periodo batch. Lavorerò per rendere questo più efficiente, ma gestire
tutte le opzioni complesse in Sniffles ora non può essere fatto a buon mercato in
memoria. L'unica altra soluzione è procurarsi una macchina più potente con più RAM.
Questa versione contiene anche una varietà di correzioni.
- 02/11/2015: Aggiunta la probabilità per i pacchetti fuori ordine per consentire la regolazione
della frequenza dei pacchetti fuori ordine.
- 03/05/2015: Modificato il teardown TCP in una sequenza di teardown standard.
Ora il contenuto può essere distribuito su più pacchetti senza utilizzare frammenti.
- 04/09/2015: Corretto il traffico di scansione, era parzialmente danneggiato durante una delle modifiche
precedenti. Il timestamp di inizio del pcap ora è predefinito all'ora corrente e può
essere impostato con l'opzione -g. Infine, il 3° pacchetto nell'handshake TCP a 3 vie
ora conterrà dati se il client deve inviare dati per primo.
- 05/22/2015: Riscritto l'analisi delle regole per semplificare la capacità di estendere il
parser delle regole per supportare più formati. Incorporata la traversata dell'nfa e
pcre direttamente in sniffles. Pulito il codice e preparato per la pubblicazione.
- 05/27/2015: Aggiornata la documentazione, unite le librerie pcre e
la costruzione dell'nfa per rendere sniffles un pacchetto autonomo.
Aggiunti il Generatore di Regex e il Generatore di Regole Casuali come
parte del pacchetto Sniffles. Versione aggiornata alla 3.0.0
e pubblicata su github.
- 08/12/2015: Implementato un gran numero di correzioni di bug e nuove
funzionalità. Modificata radicalmente la gestione di flussi e stream
per consentire una migliore estensibilità. Aggiunta la latenza per
flusso. Documentazione aggiornata.
Generatore di Espressioni Regolari
====================================
Questo è un semplice generatore di espressioni regolari.
Crea espressioni regolari in modo completamente casuale, oppure
basate su una serie di distribuzioni.
I controlli che possono essere applicati su come vengono generate le
espressioni regolari sono strutturali piuttosto che contestuali. In altre parole,
non si fa alcuno sforzo per far apparire determinati token di stringa nelle
espressioni regolari generate. Tuttavia, le distribuzioni di probabilità
possono essere modificate per influenzare i tipi di caratteristiche
trovate nelle regole, come classi di caratteri, alternanza, ripetizione, ecc.
Installazione
-------
Verrà installato automaticamente con il resto di Sniffles.
Opzioni
-------
regexgen--Generatore casuale di espressioni regolari.
usage: regexgen [-C distribuzione caratteri] [-c numero regex]
[-D distribuzione classi] [-f file re di output]
[-l lambda per generazione lunghezza] [-M lunghezza massima regex]
[-m lunghezza minima regex] [-n probabilità negazione]
[-o probabilità opzioni] [-R probabilità ripetizione] [-r distribuzione ripetizione]
[-t distribuzione tipo struttura re] [-?] [-g]
- -C Distribuzione caratteri: imposta la possibilità di vedere
particolari caratteri o tipi di caratteri. Vedi una breve spiegazione delle
distribuzioni qui sotto per esempi su come usarlo. Per impostazione predefinita
questa distribuzione è una distribuzione equa. Questa distribuzione
ha cinque slot: caratteri ASCII, caratteri binari in formato \x00,
lettere alfabetiche (maiuscole o minuscole), cifre e classi di sostituzione
(come \w). Un esempio di input potrebbe essere "10,20,10,40,20"
che significherebbe 10% di probabilità che qualsiasi carattere generato provenga dal 10% ASCII,
20% binario, 10% lettere, ecc. Una avvertenza: i caratteri ASCII
che potrebbero causare problemi con le espressioni regolari (come `[` o `{`)
vengono convertiti in rappresentazione esadecimale (\x3b ad esempio).
- -c Numero di espressioni regolari da generare. Il valore predefinito è uno.
- -D Distribuzione classi: ci sono solo due slot nella distribuzione
delle classi. Il primo slot è la probabilità che la classe sia
composta da un certo numero di caratteri generati casualmente. Il
secondo slot è la probabilità che la classe sia composta da
intervalli (come a-z).
- -f Nome del file di output. Imposta il nome del file in cui vengono
memorizzate le espressioni regolari. Il valore predefinito è un file chiamato rand.re
nella directory di lavoro corrente.
- -g Gruppi: tutte le espressioni regolari avranno un prefisso comune con
almeno un'altra espressione regolare (a condizione che ce ne siano
più di una). Un prefisso comune è semplicemente un'espressione regolare
che è la stessa per un insieme di espressioni regolari. Il numero
totale di possibili prefissi comuni va da 1 a 1/2 della dimensione
totale delle espressioni regolari da generare. Il valore predefinito per
questa opzione è false. Questa opzione non accetta parametri.
- -l Lambda per lunghezza: è la lunghezza media per una distribuzione
esponenziale delle lunghezze delle espressioni regolari. Il valore predefinito è 10.
- -M Lunghezza massima regex: imposta una lunghezza strutturale massima
per le espressioni regolari. Per impostazione predefinita, la lunghezza massima non è limitata.
- -m Lunghezza minima regex: imposta una lunghezza minima per le
espressioni regolari. Il valore predefinito è 3 e verrà automaticamente impostato a 1
se l'input è zero o inferiore.
- -n Probabilità negazione: probabilità che una classe di caratteri sia
una classe di negazione ([^xyz]) piuttosto che una classe di caratteri normale ([xyz]).
La probabilità predefinita è 50%.
- -o Probabilità opzione: è la probabilità che un'opzione venga aggiunta
all'espressione regolare. Le opzioni attuali sono 'i', 'm' e 's'.
Un numero casuale di opzioni viene aggiunto all'elenco con quelle opzioni
scelte tramite una distribuzione uniforme.
- -R Probabilità ripetizione: probabilità di ripetizione dopo
l'aggiunta di qualsiasi componente strutturale all'espressione regolare.
- -r Distribuzione ripetizione: distribuzione delle strutture di ripetizione.
Gli slot sono: Zero a uno (?), Zero a molti (*), uno a molti (+), e
conteggio ({x,y}).
- -t Distribuzione tipo struttura re: distribuzione per i componenti
strutturali primari dell'espressione regolare. Questi
comprendono tre slot, o categorie: caratteri, classi,
e alternanza. Nota: l'alternanza genererà semplicemente un'espressione
regolare più piccola fino alla dimensione della lunghezza rimanente
dell'espressione regolare. In altre parole, l'alternanza produrrà
diverse espressioni regolari più piccole unite nell'espressione regolare
complessiva. L'alternanza utilizza esattamente la stessa metodologia
per creare quelle espressioni regolari più piccole.
- -? Stampa questo aiuto.
Questo generatore creerà espressioni regolari casuali. È possibile
regolare le strutture all'interno delle espressioni regolari secondo una
distribuzione di probabilità, ma attualmente non il contenuto. Questo è
desiderabile per esplorare la massima diversità nelle possibili
espressioni regolari (sebbene non necessariamente espressioni regolari
realistiche). Le distribuzioni vengono gestite creando un elenco di probabilità
per le varie possibilità, o slot, per una particolare distribuzione.
Queste vengono aggiunte come argomenti della riga di comando utilizzando una semplice
stringa di elenco come: "10,30,40,20". L'elenco dovrebbe avere tanti valori
quanti sono gli slot. La somma di tutti i valori nell'elenco dovrebbe essere
100 e non dovrebbero esserci frazioni. Il valore in ogni slot
è la probabilità che quel venga scelto. Ad esempio,
la distribuzione del tipo di struttura RE di base ha tre slot. Il
primo slot è la probabilità che il prossimo tipo di struttura sia
un carattere (dove un carattere può essere una lettera, cifra, binario, ASCII,
o classe di sostituzione (come \w)). Il secondo slot è per le classi
di caratteri come [ab@%], [^123] o [a-z]. L'ultimo slot è la probabilità
di alternanza come (ab|cd). Con questi tre slot puoi regolare
la frequenza con cui desideri che le strutture appaiano nelle tue espressioni
regolari. Ad esempio, regexgen -c 10 -t "80,10,10" creerebbe
10 espressioni regolari in cui l'80% delle strutture utilizzate sarebbero
caratteri, il 10% sarebbero classi di caratteri e il 10% alternanza.
Generatore Casuale di Regole
=============================
Il Generatore Casuale di Regole fornisce un modo per creare un numero di regole generate
casualmente con cui testare una particolare piattaforma. Attualmente,
le regole generate rispettano il formato delle regole Snort o sono semplicemente righe
di testo. Affinché il Generatore Casuale di Regole funzioni, devi avere
un insieme di caratteristiche definite. Esempi di caratteristiche possono essere trovati nella
cartella example_features e sono ulteriormente descritte di seguito.
Installazione
-------
Installato automaticamente con Sniffles
Nota: Il Generatore Casuale di Regole utilizza il
Generatore Casuale di Regex per creare contenuti di qualsiasi tipo.Opzioni
-------
Generatore di Regole Casuali
utilizzo: rulegen -c [numero di regole] -f [set di caratteristiche] -o [file_output] [-s]
- -c Numero di regole: Il numero di regole da generare.
Il valore predefinito è uno.
- -f Set di caratteristiche: Il file contenente la descrizione del set di caratteristiche.
Si prega di consultare la documentazione per ulteriori spiegazioni sui
set di caratteristiche e su come descriverli.
- -o File di output: file di output in cui vengono scritte le regole.
Il valore predefinito è rules.txt
- -s Formato regole Snort: scrive le regole in formato regole Snort.
Nessun parametro, disattivato per impostazione predefinita. Quando disattivato, le regole vengono semplicemente
convertite in un formato stringa, qualsiasi esso sia basato sul
parser delle caratteristiche.
Set di Caratteristiche
-----------
Le caratteristiche sono utilizzate per descrivere potenziali aspetti delle regole utilizzate negli
IDS. Ad esempio, un filtro di pacchetti potrebbe utilizzare regole che mirano
agli indirizzi IP di origine e destinazione. In quel caso, sarebbe possibile
creare un set di caratteristiche che descrive come dovrebbero essere generati quegli indirizzi
IP di origine e destinazione. Più specificamente, facciamo la
distinzione tra regole semplici e regole complesse. La differenza
tra queste due è la presenza di notazioni ambigue. Per
esempio, se possedessimo una notazione ambigua come * per indicare qualsiasi
indirizzo IP, allora potremmo dire che * rappresenta una notazione ambigua.
Inoltre, sappiamo che una regola può anche utilizzare una notazione non ambigua,
come 192.168.1.1. Questo rappresenterebbe un indirizzo IP semplice poiché
è un singolo indirizzo IP fisso senza alcuna possibile notazione ambigua.
Definiamo quindi ulteriormente l'intervallo delle particolari
caratteristiche (ad esempio, indirizzi IP su tutti i oltre 4 miliardi di
possibili indirizzi IPv4, o solo un sottoinsieme di essi).
Le caratteristiche definiscono infine tutti gli aspetti di una
regola arbitraria. Dato un set di caratteristiche e un formato di regola valido,
diventa possibile generare casualmente un numero arbitrario
di regole che utilizzano quelle caratteristiche. In questo modo, è possibile
generare set di regole di test che esamineranno l'IDS lungo un
vettore spesso trascurato.
Le caratteristiche sono definite in un elenco separato da punto e virgola, una caratteristica per riga
type=feature; elenco di argomenti in coppie chiave=valore, elenchi utilizzando la formattazione
Python (ad esempio [a, ..., z]). Le caratteristiche definiscono porzioni specifiche di un
formato di regola target. Le caratteristiche possono essere estese per aggiungere più funzionalità.
Opzionalmente, si può estendere la capacità delle caratteristiche creando un nuovo
formato di regola.
Tipi di Caratteristiche Correnti:
1. Feature -- caratteristica generica
2. Content -- Caratteristica Content
3. IP -- Caratteristica IP
4. Protocol -- Caratteristica di Protocollo
Gli elenchi ambigui dovrebbero essere scritti come elenchi come [x:y]
per un intervallo, [x,y] per un elenco, {x1,x2,x3} per un insieme
o semplicemente * per un carattere jolly o simile opzione singola.
Esempio di elenco ambiguo:```
ambiguity_list=[[2:9]]
it will generate [3:4], [5:6], etc (any [x:y] such that
x <= y and x >= 2 and y > x and y <= 9).
ambiguity_list=[[3,20]]
it will generate [3,9,10], [3,4,8,12], etc (any list [x1,x2,x3,..]
such that all values falling between 3 and 20.
ambiguity_list=[{5,6,10}]
it will generate a subset of {5,6,10} such as {5,10}, {5}.
ambiguity_list=[[2:9],[3,20],{5,6,11}]
it will pick one of [2:9], [3,20], and {5,6,11} and
generate a corresponding instance (see above)
Esempio per file di feature:``` type=protocol; name=proto; proto_list=[TCP,UDP,ICMP]; complexity_prob=0;ambiguity_list=None; type=ip; name=sip; version=4; complexity_prob=100;
quanto sopra definisce due caratteristiche, una caratteristica di protocollo e una caratteristica di IP sorgente. Il protocollo si chiama proto, che è importante solo per il formattatore di regole, e i protocolli validi sono: IP, TCP, UDP e ICMP. La caratteristica IP è definita come IPv4 e tutte le regole saranno complesse. La complessità IP fa già parte della classe e non deve essere aggiunta nella definizione della caratteristica. Questo creerà indirizzi IP utilizzando la notazione CIDR.
Generic Feature Attributes:
- Feature_name: Attributo informativo, potenzialmente utile per il formattatore di regole.
- lower_bound: Il limite inferiore dei valori possibili. Presuppone che la caratteristica sia un numero.
- upper_bound: Opposto di lower_bound.
- complexity_prob: La probabilità di utilizzare caratteristiche complesse per una regola. Da 0 a 100. Il valore predefinito è 0.
Quando vengono utilizzate caratteristiche complesse, una notazione ambigua viene selezionata casualmente dalla lista di ambiguità, oppure
se la caratteristica definisce un'ambiguità specifica (come gli indirizzi IP) allora viene utilizzata quella. Quando
non vengono utilizzate caratteristiche complesse, viene generato un valore utilizzando i limiti, o, nel caso di Content,
utilizzando un insieme di valori di distribuzione che limiteranno la stringa generata a una serie
di caratteri ASCII.
- ambiguity_list: Una lista di possibili notazioni ambigue.
Lista separata da virgole utilizzando la formattazione Python
(es. [a, b, c]).
- toString(): Stampa un'istanza di una regola dato questo particolare
insieme di caratteristiche.
Content Feature -- Inherits from Feature:
- regex: Vero o Falso. Se Vero, utilizzerà la formattazione PCRE per
le regex oltre a poter aggiungere le opzioni i, s o
m alla regex.
- length: Definisce la lunghezza media del contenuto generato.
- min_regex_length: Definisce la lunghezza minima della regex.
Protocol Feature -- Inherits from Feature:
- proto_list: Definisce la lista dei possibili protocolli,
come lista separata da virgole (es. [TCP,
UDP]).
IP Feature -- Inherits from Feature:
- version: 4 per IP versione 4, 6 per IP versione 6.
Il valore predefinito è la versione 4.
Notazione ambigua per intervalli, liste, insiemi:
Notazione per intervalli:
[x:y] significa da x a y (inclusi).
Notazione per liste:
[x,y] significa lista di un numero di valori determinato casualmente
dove ogni valore è maggiore o uguale a x
e minore o uguale a y.
Notazione per insiemi:
{x1,x2,x3,x4} significa un insieme di valori x1, x2, x3, x4. Genera
un sottoinsieme dell'insieme originale.
Si prega di consultare gli insiemi di caratteristiche di esempio nella cartella example_features per ulteriori esempi.
Ulteriori dettagli, così come la teoria accademica alla base di ciò, sono programmati per essere aggiunti in seguito.
-e eval: Crea un solo pacchetto per ogni regola nel set di regole. Ignora tutti gli altri input tranne -f. Ogni pacchetto avrà contenuto corrispondente alla regola selezionata.
-E Full Eval: Crea un pacchetto per ogni percorso valido in una regola pcre nel set di regole. In altre parole, ab(c|d)e creerebbe due pacchetti: abce e abde. Ignora tutti gli altri input tranne -f.
-f File regole: legge un singolo file di regole secondo il percorso e il nome file forniti.
-F Config: Designa un file di configurazione per le opzioni di Sniffles. Il file di configurazione è un modo per fissare i parametri utilizzati per un'esecuzione di Sniffles.
-g Timestamp: imposta l'ora di inizio per il timestamp pcap. Questo sarà il numero di secondi dal 31/12/1969. Il valore predefinito è l'ora corrente.
-h Prefissi IP Home: Un elenco di prefissi di rete Home IP. Gli indirizzi IP destinati a provenire da un indirizzo interno utilizzeranno questi prefissi. I prefissi possono designare un intero indirizzo IPv4 a 4 byte in formato xxx.xxx. Ad esempio: "10.192.168,172.16".
-H Prefissi Home IPv6: Come i prefissi Home IPv4, solo per IPv6. Eccezioni notevoli: il separatore è un due punti con due byte rappresentati tra i due punti.
-i Percentuale IPv6: Imposta questo valore tra 1 e 100 per generare pacchetti con IPv6. Questo determinerà la percentuale di flussi che saranno IPv6.
-I Intensità dell'attacco di scansione (cioè pacchetti al secondo.)
-l Lunghezza contenuto: Fissa la lunghezza del contenuto al numero di byte designato. Meno di uno imposterà la lunghezza uguale al contenuto generato da nfa, o a un numero casuale tra 10 e 1410 se anche le intestazioni sono casuali. Troncherà o riempirà il pacchetto come necessario.
-L Latenza: Latenza media in microsecondi. Se non impostata, viene determinata una latenza media casuale tra 1 e 200 microsecondi per ogni flusso. Quindi, i pacchetti per un determinato flusso avranno una latenza media di tempo tra ogni pacchetto nel flusso.
-M Permette l'uso di una distribuzione MAC per avere indirizzi MAC personalizzati nel traffico. Per impostazione predefinita, gli indirizzi MAC sono generati casualmente. Maggiori informazioni sul file di definizione MAC si trovano in examples/mac_definition_file.txt. Nota: puoi specificare fino a due file di definizione MAC per impostare valori diversi a seconda della sorgente o della destinazione dei MAC. Se specifichi un solo file, verrà utilizzato per entrambe le direzioni. Se usi la seguente notazione puoi specificare per direzioni specifiche. Ad esempio: 'percorso1:percorso2'. Percorso1 sarà il file di definizione MAC per i MAC sorgente e percorso2 sarà il file di definizione MAC per i MAC destinazione. Puoi anche usare un punto interrogativo (?) per designare l'uno o l'altro come casuale, come in: '?:percorso2' per avere MAC sorgente casuali ma usare il file per.
-n Non corrispondere completamente. Imposta il contenuto generato da una regola per non corrispondere completamente (cioè verrà automaticamente troncato degli ultimi caratteri). Il comportamento predefinito è far corrispondere il contenuto della regola completamente.
-o file di output: designa il nome del file di output. Per impostazione predefinita, il file si chiama: sniffles.pcap.
-O Offset: Offset prima di iniziare un attacco di scansione. Viene anche utilizzato quando si inseriscono più scansioni nel traffico. Questo è il numero di secondi prima che inizi la scansione. Se usato con -R, questo diventa il numero medio di secondi prima dell'inizio.
-p Pacchetti per flusso: Designa il numero di pacchetti con contenuto per un singolo flusso. Se viene fornito un valore positivo come argomento, esattamente x (dove x è l'intero fornito) pacchetti con contenuto appariranno per ogni flusso. Se x è negativo, apparirà un numero casuale di pacchetti per ogni flusso (da 1 a abs(x)). Per impostazione predefinita, questo valore è 1.
-P Elenco porte di destinazione: Per un attacco di scansione. Fornisci un elenco separato da virgole di possibili porte, o una singola porta di partenza. Altrimenti le porte verranno scansionate casualmente. Se viene fornita una singola porta di partenza, le porte verranno scansionate in ordine da quel punto a 65535, dopodiché tornerà al punto di partenza. Se viene fornito un elenco, le porte nell'elenco verranno scansionate a turno.
-r Casuale: Genera contenuto casuale anziché dalle regole. Se vengono ancora fornite regole, queste vengono utilizzate nella generazione delle intestazioni. Nota: molte caratteristiche nelle regole possono sovrascrivere alcuni aspetti della generazione casuale.
-R Attacchi di scansione casuali: Userà l'offset per creare attacchi di scansione nel traffico, ma userà l'offset solo come mediana. L'offset viene utilizzato per determinare la quantità di tempo tra il termine di una scansione e l'inizio di una nuova scansione.
-s Attacco di scansione: seguito da un elenco separato da virgole di indirizzi ipv4 che indicano quale indirizzo IP prendere di mira. Ogni intervallo IP creerà un attacco di scansione. Gli intervalli dovrebbero essere come: 192.168.1.1 che prenderebbe di mira esattamente quell'indirizzo IP, mentre 192.168.1 prenderebbe di mira un indirizzo IP casuale tra 192.168.1.0 e 192.168.1.255.
-S Tipo di scansione: 1==Scansione Syn (predefinita) 2 == Scansione di connessione.
-t Handshake TCP: Include un handshake TCP in tutti i flussi TCP. Disattivato per impostazione predefinita.
-T Teardown TCP: Include un teardown TCP in tutti i flussi TCP. Disattivato per impostazione predefinita.
-v Verbosità: Aumenta il livello dei messaggi di output.
-w Scrivi contenuto: Scrive le stringhe di contenuto in un file chiamato 'all.re'
-W Finestra: La finestra, o durata, in secondi di un attacco di scansione.
-Z Probabilità di risposta: probabilità che una scansione abbia una risposta. In altre parole, probabilità che la porta di destinazione sia aperta (predefinito 20%).