Hur man använder Lua Dissector i Wireshark

Som ett av världens bästa verktyg för nätverkspaketfångst låter Wireshark dig få specifika datapaket så att du kan analysera dem både offline och i realtid. Se appen som ett sätt att noggrant undersöka data som flödar genom ditt nätverk, så att du kan fånga problem och oegentligheter.

Du kan använda dissektorer om du vill analysera en specifik del av ett pakets data. Som namnet antyder 'dissikerar' denna process koden, vilket gör att du kan klippa bort vissa aspekter som behöver din uppmärksamhet. Den här handledningen förklarar hur man skapar och använder dissektorer i Wireshark med hjälp av skriptspråket Lua.

Innan du börjar – Vad du behöver veta om dissektorer

Även om dissektorer erbjuder ett snabbt sätt att analysera delar av ett datapaket i Wireshark, måste de följa vissa protokoll för att fungera effektivt. Dessa protokoll inkluderar följande:

• Varje dissektor du skapar måste registreras för att hantera en viss typ av nyttolast från ett annat protokoll. För att slutföra denna registrering måste du tilldela ett 'Proto'-objekt till din dissektor, vilket du ser nedan.
• När du ringer en dissektor via Wireshark får den tre saker från appen:
  • TVB Object – En TVB-buffert från datapaketet.
  • TreeItem Object – En trädrot som representerar en enda nod i ett dataträd.
  • Pinfo Object – En paketinformationspost.
• Du kan bara anropa en dissektor om ditt datapaket matchar den DissectorTable som du ställt in på ditt 'Proto'-objekt.
  • Du kan kringgå detta krav genom att tvinga fram en dissektor via funktionen 'Avkoda som'. Men även då kan du bara tvinga dissektorn om den DissectorTable du ställer in på ditt 'Proto'-objekt är av rätt typ.

Konfigurera din dissektor med LUA

Eftersom Wireshark både är skrivet i och använder programmeringsspråket C, är de flesta dissektorer skrivna på liknande sätt i C. Du kanske vill använda Lua. Detta skriptspråk är enklare än C och därmed mer tillgängligt för kodande nykomlingar eller de som helt enkelt vill skapa en dissektor med ett lättare språk.

Även om din kod kommer att vara enklare, är dissektorn du får när du använder Lua vanligtvis långsammare än den du skulle skapa med C. Ändå är dessa steg att följa om du vill skapa en Wireshark-dissektor med Lua.

Steg 1 – Konfigurera Lua i Wireshark

Du måste ställa in Lua om du inte har använt den i Wireshark tidigare:

1. Klicka på 'Hjälp' följt av 'Om Wireshark.'
   
2. Klicka på 'Mappar'.
   
3. Välj något av följande för att skapa ett aktivt Lua-skript:
   
   • Globala Lua-plugins
   • Personliga Lua-plugins
   • Personlig

När det har aktiverats kommer ditt skript att vara klart när du startar Wireshark. Varje gång du gör en ändring i det skriptet måste du antingen starta om Wireshark för att registrera ändringen eller trycka på 'Ctrl + Shift + L' för att ladda om alla dina Lua-skript för att göra dina ändringar aktiva.

Steg 2 – De grundläggande stegen för att skapa din dissektor

Om du redan är bekant med Lua kan du använda följande steg för att skapa ditt eget dissektorskript som fungerar i Wireshark:

hur man lägger till nya teckensnitt i Google Docs

• Deklarera protokollet för din dissektor, vilket kräver att du anger både ett långt namn för användning i protokollträdet och ett kort namn som fungerar som dissektorns visningsfilternamn.
  • Skapa följande tre fält, med lämpliga typer:
  • Fråga – Visar frågetypen.
  • Svar – Visar svarstypen.
• MessageType – Demonstrerar om ditt paket begär en fråga eller ett svar.
• Registrera dina fält så att Wireshark vet hur de ska visas. Utan registrerade fält kommer du att få ett 'Lua Error'-meddelande som vanligtvis talar om att ditt Tree Item ProtoField är ogiltigt.
• Skapa en dissektionsfunktion som inkluderar den tidigare nämnda Pinfo (innehåller data om ditt paket) och Tree Item (skapar trädet som du lägger till ett underträd). Du måste också skapa en 'buffert', som sitter ovanpå din TCP.
• Ange både protokollet och porten som Wireshark måste använda dissektorn för. Till exempel kan du ställa in protokollet till 'TCP' och portnumret till vilket du vill använda.

Steg 3 – Lägg till din dissektor till Wireshark

Just nu är din dissektor som en glödlampa utan elektricitet. Det finns, men det är till ingen nytta för dig förrän du kan köra lite kraft genom det. Med andra ord, din dissektor har inte lagts till i Wireshark än, så du måste lägga till den manuellt för att få den att köras genom att använda dessa steg:

1. Klicka på 'Hjälp' och gå till menyn 'Om Wireshark'.
   
2. Välj fliken 'Mapp' för att hitta en lista med sökvägar för din Lua-fil.
   
3. Välj 'Personliga Lua Plugins.' Skapa en katalog om det behövs.
   
4. Kopiera och klistra in Lua-filen du skapade i katalogen 'Personal Lua Plugins'. Ladda om Wireshark för att slå på dissektorn.

Det är en bra idé att köra ett test på din nya dissektor genom att öppna några av paketen du har fångat. Wireshark ska leverera ett meddelande som visar det långa namnet du valde för din dissektor, tillsammans med information om meddelandetypen (fråga eller svar) och resultatet av din kontroll.

Några exempel på kod

Om du inte har skapat en dissektor tidigare (eller om du är ny på Lua), Wireshark erbjuder ett praktiskt exempel på en dissektor som du kan prova:

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)

Postdissektorer och kedjade dissektorer

Du kanske vill gå lite mer på djupet med din dissektoranvändning när du har bemästrat att skapa dem i Lua. Wireshark erbjuder ytterligare två typer av dissektorer – postdissektorer och kedjade dissektorer – som erbjuder mer funktionalitet.

En postdissektor är ungefär som en sista kontroll av alla dissektorer som du har kört för ett paket. Du registrerar den för att få ett meddelande när Wireshark har ringt till varannan dissektor som du vill att den ska använda, och du kan använda den för att filtrera kolumnerna 'Protokoll' och 'Info'. Den här funktionen är särskilt användbar om du vill filtrera bort flera paket i en session där du har haft ett långt mellanrum mellan datamängder och inte kan återkalla var och en individuellt.

Kedjning av dissektorer har en liknande funktion (åtminstone när det gäller filtrering genom tidigare använda dissektorer) genom att ge dig tillgång till en enskild dissektors data. Den viktigaste fördelen här är att den kedjade dissektorn inte behöver köra igenom varje paket igen, vilket ger dig ett resultat utan att tvinga dig att vänta på att den ursprungliga dissektorn ska köras igen.

Dissekera i Lua

Med tanke på att Wireshark redan erbjuder möjligheten att skapa dissektorer i C (dess naturliga språk), kanske du inte ser behovet av att skapa dem i Lua också. Ändå kan de som inte är bekväma med C, såväl som de som redan behärskar Lua, upptäcka att det lätta skriptet av Lua gör det lättare att skapa sina dissektorer. Visst, du måste byta ut en längre laddningstid när du kör processen jämfört med C-baserade dissektorer, men det är bra att ha alternativet oavsett.

Med det sagt vill vi höra från dig. Hur ofta använder du dissektorer i Wireshark? Har du testat att skapa dem i C tidigare, och vilka fördelar tror du att det ger att göra dissektorer i Lua? Låt oss veta i kommentarsfältet nedan.