Essendo uno dei migliori strumenti di acquisizione di pacchetti di rete al mondo, Wireshark ti consente di ottenere pacchetti di dati specifici in modo da poterli analizzare sia offline che in tempo reale. Pensa all'app come a un modo per esaminare da vicino i dati che fluiscono attraverso la tua rete, permettendoti di rilevare problemi e irregolarità.
È possibile utilizzare i dissettori se si desidera analizzare una parte specifica dei dati di un pacchetto. Come suggerisce il nome, questo processo 'seziona' il codice, permettendoti di eliminare alcuni aspetti che richiedono la tua attenzione. Questo tutorial spiega come creare e utilizzare i dissettori in Wireshark utilizzando il linguaggio di scripting Lua.
come installare apk su amazon fire stick?
Prima di iniziare: cosa devi sapere sui dissettori
Sebbene i dissettori offrano un modo rapido per analizzare parti di un pacchetto di dati in Wireshark, devono seguire alcuni protocolli per funzionare in modo efficace. Questi protocolli includono quanto segue:
- Ogni dissettore che crei deve essere registrato per gestire un determinato tipo di payload da un protocollo diverso. Per completare questa registrazione, devi assegnare un oggetto 'Proto' al tuo dissettore, che vedrai di seguito.
- Quando chiami un dissettore tramite Wireshark, riceve tre cose dall'app:
- Oggetto TVB: un buffer TVB dal pacchetto di dati.
- Oggetto TreeItem: una radice dell'albero che rappresenta un singolo nodo in un albero di dati.
- Oggetto Pinfo: un record di informazioni sul pacchetto.
- Puoi chiamare un dissettore solo se il tuo pacchetto di dati corrisponde alla DissectorTable che hai impostato sull'oggetto 'Proto'.
- È possibile aggirare questo requisito forzando l'uso di un dissettore tramite la funzione 'Decodifica come'. Ma anche in questo caso, puoi forzare il dissettore solo se il DissectorTable che hai impostato sul tuo oggetto 'Proto' è del tipo corretto.
Configurazione del dissettore tramite LUA
Poiché Wireshark è scritto e utilizza il linguaggio di programmazione C, la maggior parte dei dissettori sono scritti in modo simile in C. Tuttavia, potresti voler utilizzare Lua. Questo linguaggio di scripting è più semplice del C e quindi più accessibile ai neofiti della programmazione o a coloro che vogliono semplicemente creare un dissettore utilizzando un linguaggio più leggero.
Sebbene il tuo codice sia più semplice, il dissettore che ottieni quando usi Lua è solitamente più lento di quello che creeresti usando C. Tuttavia, questi sono i passaggi da seguire se vuoi creare un dissettore Wireshark usando Lua.
Passaggio 1: configurare Lua in Wireshark
Dovrai configurare Lua se non l'hai mai usato in Wireshark prima:
- Fai clic su 'Guida', seguito da 'Informazioni su Wireshark'.
- Fai clic su 'Cartelle'.
- Scegli una delle seguenti opzioni per creare uno script Lua attivo:
- Plugin Lua globali
- Plugin Lua personali
- Personale
Una volta attivato, il tuo script sarà pronto ogni volta che avvii Wireshark. Ogni volta che apporti una modifica a quello script, devi riavviare Wireshark per registrare la modifica o premere 'Ctrl + Maiusc + L' per ricaricare tutti i tuoi script Lua per rendere attive le modifiche.
Passaggio 2: i passaggi di base per creare il tuo dissettore
Se hai già familiarità con Lua, puoi utilizzare i seguenti passaggi per creare il tuo script di dissettore che funzionerà in Wireshark:
- Dichiara il protocollo per il tuo dissettore, che richiede di impostare sia un nome lungo da utilizzare nella struttura del protocollo sia un nome breve che funge da nome del filtro di visualizzazione del dissettore.
- Crea i seguenti tre campi, con i tipi appropriati:
- Domanda: mostra il tipo di domanda.
- Risposta: mostra il tipo di risposta.
- MessageType – Indica se il tuo pacchetto richiede una domanda o una risposta.
- Registra i tuoi campi in modo che Wireshark sappia come visualizzarli. Senza campi registrati, riceverai un messaggio 'Lua Error', che di solito ti dice che il tuo Tree Item ProtoField non è valido.
- Crea una funzione di dissezione che includa il già citato Pinfo (contenente i dati sul tuo pacchetto) e Tree Item (creando l'albero che aggiungerai a un sottoalbero). Devi anche creare un 'buffer', che si trova sopra il tuo TCP.
- Specifica sia il protocollo che la porta per cui Wireshark deve utilizzare il dissettore. Ad esempio, puoi impostare il protocollo su 'TCP' e il numero di porta su quello che desideri utilizzare.
Passaggio 3: aggiungi il tuo dissettore a Wireshark
In questo momento, il tuo dissettore è come una lampadina senza elettricità. Esiste, ma non ti serve finché non riesci a far passare un po' di potere attraverso di essa. In altre parole, il tuo dissettore non è ancora stato aggiunto a Wireshark, quindi devi aggiungerlo manualmente per farlo funzionare seguendo questi passaggi:
- Fai clic su 'Aiuto' e vai al menu 'Informazioni su Wireshark'.
- Seleziona la scheda 'Cartella' per trovare un elenco di percorsi per il tuo file Lua.
- Scegli 'Plugin Lua personali'. Creare una directory se necessario.
- Copia e incolla il file Lua che hai creato nella directory 'Personal Lua Plugins'. Ricarica Wireshark per attivare il dissettore.
È una buona idea eseguire un test sul tuo nuovo dissettore aprendo alcuni dei pacchetti che hai catturato. Wireshark dovrebbe consegnare un messaggio che mostra il nome lungo che hai scelto per il tuo dissettore, insieme alle informazioni sul tipo di messaggio (domanda o risposta) e il risultato del tuo controllo.
Alcuni esempi di codice
Se non hai mai creato un dissettore prima (o sei nuovo su Lua), Wireshark offre un pratico dissettore di esempio da provare:
local p_multi = Proto("multi", "MultiProto");
local vs_protos = {
[2] = "mtp2",
[3] = "mtp3",
[4] = "alcap",
[5] = "h248",
[6] = "ranap",
[7] = "rnsap",
[8] = "nbap"
}
local f_proto = ProtoField.uint8("multi.protocol", "Protocol", base.DEC, vs_protos)
local f_dir = ProtoField.uint8("multi.direction", "Direction", base.DEC, { [1] = "incoming", [0] = "outgoing"})
local f_text = ProtoField.string("multi.text", "Text")
p_multi.fields = { f_proto, f_dir, f_text }
local data_dis = Dissector.get("data")
local protos = {
[2] = Dissector.get("mtp2"),
[3] = Dissector.get("mtp3"),
[4] = Dissector.get("alcap"),
[5] = Dissector.get("h248"),
[6] = Dissector.get("ranap"),
[7] = Dissector.get("rnsap"),
[8] = Dissector.get("nbap"),
[9] = Dissector.get("rrc"),
[10] = DissectorTable.get("sctp.ppi"):get_dissector(3), -- m3ua
[11] = DissectorTable.get("ip.proto"):get_dissector(132), -- sctp
}
function p_multi.dissector(buf, pkt, tree)
local subtree = tree:add(p_multi, buf(0,2))
subtree:add(f_proto, buf(0,1))
subtree:add(f_dir, buf(1,1))
local proto_id = buf(0,1):uint()
local dissector = protos[proto_id]
if dissector ~= nil then
-- Dissector was found, invoke subdissector with a new Tvb,
-- created from the current buffer (skipping first two bytes).
dissector:call(buf(2):tvb(), pkt, tree)
elseif proto_id < 2 then
subtree:add(f_text, buf(2))
-- pkt.cols.info:set(buf(2, buf:len() - 3):string())
else
-- fallback dissector that just shows the raw data.
data_dis:call(buf(2):tvb(), pkt, tree)
end
end
local wtap_encap_table = DissectorTable.get("wtap_encap")
local udp_encap_table = DissectorTable.get("udp.port")
wtap_encap_table:add(wtap.USER15, p_multi)
wtap_encap_table:add(wtap.USER12, p_multi)
udp_encap_table:add(7555, p_multi)
Postdissettore e Dissettore concatenato
Potresti voler approfondire un po' di più il tuo utilizzo del dissettore una volta che avrai imparato a crearli in Lua. Wireshark offre due ulteriori tipi di dissettori - postdissettori e dissettori concatenati - che offrono più funzionalità.
Un postdissector è molto simile a un controllo finale di tutti i dissector che hai eseguito per un pacchetto. Lo registri per ricevere una notifica una volta che Wireshark ha chiamato ogni altro dissettore che vuoi che utilizzi e puoi usarlo per filtrare le colonne 'Protocollo' e 'Informazioni'. Questa funzione è particolarmente utile se desideri filtrare più pacchetti in una sessione in cui hai avuto un lungo intervallo tra i set di dati e non riesci a richiamarli singolarmente.
Il concatenamento dei dissettori svolge una funzione simile (almeno in termini di filtraggio attraverso i dissettori utilizzati in precedenza) dando accesso ai dati di un singolo dissettore. Il vantaggio chiave qui è che il dissettore incatenato non deve eseguire nuovamente ogni pacchetto, dandoti un risultato senza costringerti ad aspettare che il dissettore originale venga eseguito di nuovo.
Sezionare in Lua
Dato che Wireshark offre già la possibilità di creare dissettori in C (il suo linguaggio naturale), potresti non vedere la necessità di crearli anche in Lua. Tuttavia, coloro che non si sentono a proprio agio con C, così come coloro che hanno già imparato Lua, potrebbero scoprire che lo scripting leggero di Lua rende più facile creare i propri dissettori. Certo, devi sacrificare un tempo di caricamento più lungo quando esegui il processo rispetto ai dissettori basati su C, ma è utile avere l'opzione a prescindere.
Detto questo, vogliamo sentire la tua opinione. Quanto spesso usi i dissettori in Wireshark? Hai già provato a crearli in C e quali vantaggi pensi che la creazione di dissettori in Lua offra? Fateci sapere nella sezione commenti qui sotto.
