Լավագույն գրիչի փորձարկող գործիքները՝ sniffer և փաթեթների մշակում: Wireshark. Ցանցային փաթեթների հոտի դասականը

Wireshark-ը հզոր ցանցային անալիզատոր է, որը կարող է օգտագործվել ձեր համակարգչի ցանցային միջերեսով անցնող թրաֆիկը վերլուծելու համար: Դա ձեզ կարող է անհրաժեշտ լինել ցանցային խնդիրները հայտնաբերելու և լուծելու, ձեր վեբ հավելվածները վրիպազերծելու համար, ցանցային ծրագրերկամ կայքեր. Wireshark-ը թույլ է տալիս ամբողջությամբ դիտել փաթեթի բովանդակությունը բոլոր մակարդակներում, որպեսզի ավելի լավ հասկանաք, թե ինչպես է ցանցն աշխատում ցածր մակարդակում:

Բոլոր փաթեթները պահվում են իրական ժամանակում և տրամադրվում են հեշտ ընթերցվող ձևաչափով: Ծրագիրն աջակցում է շատ հզոր զտման համակարգին, գունային ընդգծմանը և այլ հնարավորությունների, որոնք կօգնեն ձեզ գտնել ձեզ անհրաժեշտ փաթեթները: Այս ձեռնարկում մենք կանդրադառնանք, թե ինչպես օգտագործել Wireshark-ը թրաֆիկը վերլուծելու համար: Վերջերս մշակողները տեղափոխվել են Wireshark 2.0 ծրագրի երկրորդ ճյուղի վրա աշխատելու, դրանում կատարվել են բազմաթիվ փոփոխություններ և բարելավումներ, հատկապես ինտերֆեյսի համար։ Դա այն է, ինչ մենք կօգտագործենք այս հոդվածում:

Նախքան երթևեկության վերլուծության ուղիները քննարկելը, դուք պետք է հաշվի առնեք, թե ինչ գործառույթներ է աջակցում ծրագիրը ավելի մանրամասն, ինչ արձանագրություններով այն կարող է աշխատել և ինչ անել: Ահա ծրագրի հիմնական հատկանիշները.

• Գրեք իրական ժամանակի փաթեթներ լարային կամ ցանկացած այլ տեսակի ցանցային ինտերֆեյսներից, ինչպես նաև ֆայլից ընթերցում;
• Աջակցվում են գրավման հետևյալ միջերեսները. Ethernet, IEEE 802.11, PPP և տեղական վիրտուալ միջերեսներ;
• Փաթեթները կարող են զտվել տարբեր պարամետրերով, օգտագործելով զտիչներ.
• Բոլոր հայտնի արձանագրությունները ընդգծված են ցանկում տարբեր գույներ, ինչպիսիք են TCP, HTTP, FTP, DNS, ICMP և այլն;
• VoIP զանգերի երթևեկության գրանցման աջակցություն;
• HTTPS տրաֆիկի ապակոդավորումը ապահովվում է վկայագրի առկայության դեպքում.
• WEP, WPA տրաֆիկի վերծանում անլար ցանցերբանալու և ձեռքսեղմման առկայության դեպքում;
• Ցանցի բեռնվածության վիճակագրության ցուցադրում;
• Դիտեք փաթեթների բովանդակությունը ցանցի բոլոր շերտերի համար;
• Ցուցադրում է փաթեթների ուղարկման և ստացման ժամանակը:

Ծրագիրն ունի շատ այլ հնարավորություններ, բայց սրանք այն հիմնականներն էին, որոնք կարող են հետաքրքրել ձեզ:

Ինչպես օգտագործել Wireshark-ը

Ես ենթադրում եմ, որ դուք արդեն տեղադրել եք ծրագիրը, բայց եթե ոչ, կարող եք տեղադրել այն պաշտոնական պահոցներից: Դա անելու համար մուտքագրեք հրամանը Ubuntu-ում.

sudo apt տեղադրել wireshark

Տեղադրվելուց հետո ծրագիրը կարող եք գտնել բաշխման հիմնական ընտրացանկում: Դուք պետք է գործարկեք Wireshark-ը գերօգտագործողի իրավունքներով, քանի որ հակառակ դեպքում այն ​​չի կարողանա վերլուծել ցանցի փաթեթները: Դա կարելի է անել հիմնական ընտրացանկից կամ տերմինալի միջոցով՝ օգտագործելով KDE-ի հրամանը.

Իսկ Gnome/Unity-ի համար՝

Ծրագրի հիմնական պատուհանը բաժանված է երեք մասի՝ առաջին սյունակը պարունակում է վերլուծության համար հասանելի ցանցային ինտերֆեյսների ցանկ, երկրորդը՝ ֆայլեր բացելու տարբերակներ, իսկ երրորդը՝ օգնություն:

Ցանցային տրաֆիկի վերլուծություն

Վերլուծությունը սկսելու համար ընտրեք ցանցային ինտերֆեյսը, օրինակ eth0, և սեղմեք կոճակը սկսել.

Դրանից հետո կբացվի հաջորդ պատուհանը՝ արդեն ինտերֆեյսի միջով անցնող փաթեթների հոսքով։ Այս պատուհանը նույնպես բաժանված է մի քանի մասի.

• Վերին մաս- սրանք ընտրացանկեր և վահանակներ են տարբեր կոճակներով.
• Փաթեթների ցուցակ- հետագայում ցուցադրվում է ցանցային փաթեթների հոսքը, որը դուք կվերլուծեք.
• Փաթեթի բովանդակությունը- գտնվում է ընտրված փաթեթի բովանդակությունից անմիջապես ներքև, այն բաժանված է կատեգորիաների ՝ կախված տրանսպորտի մակարդակից.
• Իրական կատարում- հենց ներքևում փաթեթի բովանդակությունը ցուցադրվում է իրական ձևով, ինչպես նաև HEX-ի տեսքով:

Դուք կարող եք սեղմել ցանկացած փաթեթի բովանդակությունը վերլուծելու համար.

Այստեղ մենք տեսնում ենք DNS հարցման փաթեթ՝ կայքի IP հասցեն ստանալու համար, հարցման մեջ ինքնին ուղարկվում է տիրույթը, իսկ պատասխան փաթեթում մենք ստանում ենք մեր հարցը, ինչպես նաև պատասխանը:

Ավելի հարմար դիտելու համար փաթեթը կարող եք բացել նոր պատուհանում՝ կրկնակի սեղմելով մուտքի վրա.

Wireshark զտիչներ

Շատ անհարմար է փաթեթները ձեռքով դասավորելը՝ ձեզ անհրաժեշտ փաթեթները գտնելու համար, հատկապես ակտիվ հոսքի դեպքում: Հետեւաբար, նման առաջադրանքի համար ավելի լավ է օգտագործել զտիչներ: Մենյուի տակ կա ֆիլտրեր մուտքագրելու հատուկ տող: կարող եք սեղմել արտահայտությունֆիլտրի ստեղծողը բացելու համար, բայց դրանք շատ են, ուստի մենք կանդրադառնանք ամենահիմնականներին.

• ip.dst- թիրախային IP հասցե;
• ip.src- ուղարկողի IP-հասցե;
• ip.addr- ուղարկողի կամ ստացողի IP;
• ip.proto- արձանագրություն;
• tcp.dstport- նպատակակետ նավահանգիստ;
• tcp.srcport- ուղարկողի նավահանգիստ;
• ip.ttl- զտել ըստ ttl-ի, որոշում է ցանցի հեռավորությունը.
• http.request_uri- կայքի պահանջվող հասցեն:

Դուք կարող եք օգտագործել հետևյալ օպերատորները՝ ֆիլտրում դաշտի և արժեքի միջև կապը նշելու համար.

• == - հավասար է;
• != - ոչ հավասար;
• < - պակաս;
• > - ավելին;
• <= - պակաս կամ հավասար;
• >= - ավելի կամ հավասար;
• լուցկի- կանոնավոր արտահայտություն;
• պարունակում է- պարունակում է.

Մի քանի արտահայտություններ միավորելու համար կարող եք օգտագործել.

• && - երկու արտահայտությունները պետք է ճշմարիտ լինեն փաթեթի համար.
• || - արտահայտություններից մեկը կարող է ճիշտ լինել.

Այժմ եկեք ավելի սերտ նայենք մի քանի ֆիլտրերի օրինակներին և փորձենք հասկանալ հարաբերությունների բոլոր նշանները:

Նախ, եկեք զտենք 194.67.215 համարին ուղարկված բոլոր փաթեթները: Մուտքագրեք տող ֆիլտրի դաշտում և սեղմեք դիմել. Հարմարության համար Wireshark ֆիլտրերը կարող են պահպանվել կոճակի միջոցով Պահպանել:

ip.dst == 194.67.215.125

Եվ ոչ միայն ուղարկված փաթեթներ ստանալու, այլև այս հանգույցից ի պատասխան ստանալու համար կարող եք համատեղել երկու պայման.

ip.dst == 194.67.215.125 || ip.src == 194.67.215.125

Մենք կարող ենք նաև ընտրել փոխանցված մեծ ֆայլեր.

http.content_length > 5000

Բովանդակության տեսակը զտելով՝ մենք կարող ենք ընտրել բոլոր վերբեռնված նկարները; անենք վերլուծությունը Wireshark տրաֆիկ, փաթեթներ, որոնք պարունակում են պատկեր բառը.

http.content_type պարունակում է պատկեր

Զտիչը մաքրելու համար կարող եք սեղմել կոճակը Պարզ. Պատահում է, որ դուք միշտ չէ, որ գիտեք զտման համար անհրաժեշտ բոլոր տեղեկությունները, այլ պարզապես ցանկանում եք ուսումնասիրել ցանցը։ Դուք կարող եք ցանկացած փաթեթի դաշտ ավելացնել որպես սյունակ և դիտել դրա բովանդակությունը յուրաքանչյուր փաթեթի ընդհանուր պատուհանում:

Օրինակ, ես ուզում եմ ցուցադրել փաթեթի ttl (ապրելու ժամանակը) որպես սյունակ: Դա անելու համար բացեք փաթեթի տեղեկատվությունը, գտեք այս դաշտը IP բաժնում: Հետո զանգահարեք համատեքստային մենյուև ընտրեք տարբերակը Կիրառել որպես սյունակ:

Նույն կերպ, դուք կարող եք ստեղծել ֆիլտր, որը հիմնված է ցանկացած ցանկալի դաշտի վրա: Ընտրեք այն և զանգահարեք համատեքստի ընտրացանկը, ապա սեղմեք Կիրառել որպես զտիչկամ Պատրաստել որպես ֆիլտր, ապա ընտրեք ընտրված,ցուցադրել միայն ընտրված արժեքները, կամ Ընտրված չէդրանք հեռացնելու համար.

Նշված դաշտը և դրա արժեքը կկիրառվեն կամ, երկրորդ դեպքում, կփոխարինվեն ֆիլտրի դաշտում.

Այս կերպ դուք կարող եք ֆիլտրում ավելացնել ցանկացած փաթեթի կամ սյունակի դաշտ: Համատեքստի ընտրացանկում կա նաև այս տարբերակը: Արձանագրությունների զտման համար կարող եք օգտագործել ավելին պարզ պայմաններ. Օրինակ, եկեք վերլուծենք Wireshark տրաֆիկը HTTP և DNS արձանագրությունների համար.

Ծրագրի մեկ այլ հետաքրքիր առանձնահատկությունն այն է, որ Wireshark-ի օգտագործումը օգտատիրոջ համակարգչի և սերվերի միջև որոշակի սեսիա հետևելու համար: Դա անելու համար բացեք փաթեթի համատեքստային ընտրացանկը և ընտրեք Հետևեք TCP հոսքին.

Այնուհետև կբացվի պատուհան, որտեղ դուք կգտնեք սերվերի և հաճախորդի միջև փոխանցված բոլոր տվյալները.

Wireshark-ի խնդիրների ախտորոշում

Դուք կարող եք մտածել, թե ինչպես օգտագործել Wireshark 2.0 ցանցի խնդիրները հայտնաբերելու համար: Դա անելու համար պատուհանի ներքևի ձախ անկյունում կա կլոր կոճակ, որի վրա սեղմելիս բացվում է պատուհան. Փորձագիտական ​​գործիքներ. Դրանում Wireshark-ը հավաքում է սխալի և ցանցի ձախողման բոլոր հաղորդագրությունները.

Պատուհանը բաժանված է ներդիրների, ինչպիսիք են Սխալներ, Զգուշացումներ, Ծանուցումներ, Զրույցներ: Ծրագիրը կարող է զտել և գտնել բազմաթիվ ցանցային խնդիրներ, և այստեղ դուք կարող եք շատ արագ տեսնել դրանք: Wireshark ֆիլտրերը նույնպես աջակցվում են այստեղ:

Wireshark տրաֆիկի վերլուծություն

Դուք կարող եք շատ հեշտությամբ հասկանալ, թե կոնկրետ ինչ են ներբեռնել օգտվողները և ինչ ֆայլեր են դիտել, եթե կապը գաղտնագրված չէ: Ծրագիրը շատ լավ աշխատանք է կատարում բովանդակություն հանելու հարցում:

Դա անելու համար նախ պետք է դադարեցնել երթևեկի ֆիքսումը` օգտագործելով վահանակի կարմիր քառակուսին: Այնուհետև բացեք ընտրացանկը Ֆայլ -> Արտահանման օբյեկտներ -> http:

Ցանցային փաթեթների անալիզատորները կամ sniffers-ը ի սկզբանե մշակվել են որպես լուծման միջոց ցանցային խնդիրներ. Նրանք կարողանում են որսալ, մեկնաբանել և պահպանել ցանցով փոխանցված փաթեթները՝ հետագա վերլուծության համար: Սա մի կողմից թույլ է տալիս համակարգի ադմինիստրատորներև սպասարկման ինժեներներ տեխնիկական աջակցությունդիտարկել, թե ինչպես են տվյալները փոխանցվում ցանցով, ախտորոշել և ուղղել առաջացող խնդիրները: Այս առումով, փաթեթային sniffers են հզոր գործիքցանցային խնդիրների ախտորոշում. Մյուս կողմից, ինչպես շատ այլ հզոր գործիքներ, որոնք ի սկզբանե նախատեսված էին ադմինիստրացիայի համար, ժամանակի ընթացքում սնիֆերները օգտագործվել են բոլորովին այլ նպատակներով։ Իրոք, հարձակվողի ձեռքում հայտնաբերողը բավականին վտանգավոր գործիք է և կարող է օգտագործվել գաղտնաբառեր և այլ գաղտնի տեղեկատվություն տիրանալու համար: Այնուամենայնիվ, մի կարծեք, որ sniffers-ը ինչ-որ կախարդական գործիք է, որի միջոցով ցանկացած հաքեր կարող է հեշտությամբ դիտել ցանցով փոխանցված գաղտնի տեղեկատվությունը: Իսկ մինչ ապացուցենք, որ նժույգների վտանգը այնքան էլ մեծ չէ, որքան հաճախ է ներկայացվում, եկեք մանրամասն անդրադառնանք դրանց գործունեության սկզբունքներին։

Ինչպես է աշխատում փաթեթների ախտահանիչը

Հետագայում այս հոդվածում մենք կքննարկենք միայն Ethernet ցանցերի համար նախատեսված ծրագրային ապահովման սնիֆերները: Sniffer-ը ծրագիր է, որն աշխատում է NIC (Network Interface Card) ցանցային ադապտերի (հղման շերտ) մակարդակով և գաղտագողի ընդհատում է ողջ տրաֆիկը: Քանի որ sniffers-ը գործում է OSI մոդելի տվյալների կապի շերտում, նրանք այլևս ստիպված չեն խաղալ պրոտոկոլային կանոններով: բարձր մակարդակ. Sniffer-ները շրջանցում են զտման մեխանիզմները (հասցեներ, նավահանգիստներ և այլն), որոնք Ethernet դրայվերները և TCP/IP ստեկը օգտագործում են տվյալների մեկնաբանման համար: Փաթեթային հոտառիչները ֆիքսում են այն ամենը, ինչ անցնում է դրա միջով մետաղալարից: Sniffers-ը կարող է պահպանել շրջանակները երկուական ձևաչափով և հետագայում վերծանել դրանք՝ ներսում թաքնված ավելի բարձր մակարդակի տեղեկատվությունը բացահայտելու համար (Նկար 1):

Որպեսզի sniffer-ը կարողանա ընդհատել միջով անցնող բոլոր փաթեթները ցանցային ադապտեր, ցանցային ադապտերի դրայվերը պետք է աջակցի անառակ ռեժիմին (անառակ ռեժիմ): Ցանցային ադապտերի աշխատանքի այս ռեժիմում է, որ սնիֆերը կարողանում է ընդհատել բոլոր փաթեթները: Այս ռեժիմըՑանցային ադապտերի աշխատանքը ավտոմատ կերպով ակտիվանում է, երբ sniffer-ը գործարկվում է կամ ձեռքով կարգաբերվում է Sniffer-ի համապատասխան կարգավորումներով:

Ամբողջ գաղտնալսված տրաֆիկը փոխանցվում է փաթեթների ապակոդավորիչին, որը նույնացնում և բաժանում է փաթեթները հիերարխիայի համապատասխան մակարդակների: Կախված որոշակի սնուցչի հնարավորություններից, փաթեթների մասին ներկայացված տեղեկատվությունը կարող է հետագայում վերլուծվել և զտվել:

Sniffer սահմանափակումներ

Sniffers-ը ամենամեծ վտանգը ներկայացնում էր այն ժամանակներում, երբ տեղեկատվությունը ցանցով փոխանցվում էր հստակ տեքստով (առանց կոդավորման), իսկ տեղական ցանցերը կառուցվում էին համակենտրոնացման (հանգույցների) հիման վրա: Այնուամենայնիվ, այդ ժամանակները ընդմիշտ անցել են, և մեր օրերում օգտագործվող sniffers-ը հասանելիություն ձեռք բերելու համար գաղտնի տեղեկատվությունԽնդիրն ամենևին էլ հեշտ չէ։

Փաստն այն է, որ հանգույցների վրա հիմնված տեղական ցանցեր կառուցելիս կա տվյալների փոխանցման որոշակի ընդհանուր միջոց ( ցանցային մալուխ) և ցանցի բոլոր հանգույցները փոխանակում են փաթեթներ՝ մրցելով այս միջավայրին հասանելիության համար (նկ. 2), ավելին, մեկ ցանցային հանգույցի կողմից ուղարկված փաթեթը փոխանցվում է հանգույցի բոլոր նավահանգիստներին, և այդ փաթեթը լսվում է ցանցի մյուս հանգույցների կողմից, բայց միայն այն հանգույցը, որին այն ուղղված է: Ավելին, եթե ցանցի հանգույցներից մեկի վրա տեղադրված է փաթեթների խուզարկիչ, ապա այն կարող է ընդհատել ցանցի այս հատվածի հետ կապված բոլոր ցանցային փաթեթները (ցանց, որը ձևավորվում է հանգույցի կողմից):

Անջատիչները ավելի խելացի են, քան հեռարձակման հանգույցները և մեկուսացված ցանցային տրաֆիկ. Անջատիչը գիտի յուրաքանչյուր պորտին միացված սարքերի հասցեները և փաթեթները փոխանցում է միայն պահանջվող պորտերի միջև: Սա թույլ է տալիս բեռնաթափել այլ նավահանգիստներ՝ առանց դրանց փոխանցելու յուրաքանչյուր փաթեթ, ինչպես դա անում է հանգույցը: Այսպիսով, որոշակի ցանցային հանգույցի կողմից ուղարկված փաթեթը փոխանցվում է միայն անջատիչ պորտին, որին միացված է փաթեթի ստացողը, իսկ մյուս բոլոր ցանցային հանգույցները չեն կարողանում հայտնաբերել այս փաթեթը (նկ. 3):

Հետևաբար, եթե ցանցը կառուցված է անջատիչի հիման վրա, ապա ցանցային համակարգիչներից մեկի վրա տեղադրված սնիֆերը կարող է գաղտնալսել միայն այն փաթեթները, որոնք փոխանակվում են։ այս համակարգիչըցանցի այլ հանգույցների հետ: Արդյունքում, որպեսզի կարողանանք գաղտնալսել այն փաթեթները, որոնք հարձակվողին հետաքրքրող համակարգիչը կամ սերվերը փոխանակում է ցանցի մնացած հանգույցների հետ, անհրաժեշտ է այս համակարգչի (սերվերի) վրա տեղադրել sniffer-ը, ինչը իրականում այդպես չէ։ պարզ. Այնուամենայնիվ, պետք է հիշել, որ որոշ փաթեթների sniffers գործարկվում են հրամանի տողև կարող է չունենալ գրաֆիկական ինտերֆեյս: Նման sniffers-ները, սկզբունքորեն, կարող են տեղադրվել և գործարկվել հեռակա և անտեսանելի օգտագործողի համար:

Բացի այդ, պետք է նաև նկատի ունենալ, որ թեև անջատիչները մեկուսացնում են ցանցի երթևեկությունը, բոլոր կառավարվող անջատիչները ունեն պորտի փոխանցման կամ նավահանգիստների արտացոլման գործառույթ: Այսինքն, անջատիչ պորտը կարող է կարգավորվել այնպես, որ անջատիչի այլ նավահանգիստներ հասնող բոլոր փաթեթները կրկնօրինակվեն դրա վրա: Եթե ​​այս դեպքում փաթեթների ախտահանիչ ունեցող համակարգիչը միացված է նման պորտին, ապա այն կարող է ընդհատել ցանցի այս հատվածում համակարգիչների միջև փոխանակված բոլոր փաթեթները: Այնուամենայնիվ, որպես կանոն, անջատիչը կարգավորելու հնարավորությունը հասանելի է միայն ցանցի ադմինիստրատորին: Սա, իհարկե, չի նշանակում, որ նա չի կարող հարձակվող լինել, բայց ցանցի ադմինիստրատորի համար կան բազմաթիվ այլ եղանակներ՝ վերահսկելու բոլոր օգտատերերին։ տեղական ցանց, և դժվար թե նա ձեզ հետևի այդքան բարդ ձևով։

Մեկ այլ պատճառ, թե ինչու սնիֆերներն այլևս նախկինի պես վտանգավոր չեն, այն է, որ մեր օրերում ամենակարևոր տվյալները փոխանցվում են կոդավորված ձևով: Բաց, չգաղտնագրված ծառայություններն արագորեն անհետանում են ինտերնետից: Օրինակ՝ կայքեր այցելելիս այն ավելի ու ավելի է օգտագործվում SSL արձանագրություն(Secure Sockets Layer); SFTP (Secure FTP) օգտագործվում է բաց FTP-ի փոխարեն, իսկ մյուս ծառայությունները, որոնք լռելյայնորեն չեն օգտագործում գաղտնագրում, ավելի ու ավելի են օգտագործում վիրտուալ մասնավոր ցանցեր (VPN):

Այսպիսով, նրանք, ովքեր անհանգստացած են փաթեթային sniffers-ի չարամիտ օգտագործման հնարավորությամբ, պետք է նկատի ունենան հետևյալը. Նախ, ձեր ցանցի համար լուրջ վտանգ ներկայացնելու համար sniffers պետք է բնակվեն հենց ցանցում: Երկրորդ, այսօրվա գաղտնագրման ստանդարտները չափազանց դժվարացնում են գաղտնի տեղեկատվության գաղտնալսումը: Հետևաբար, ներկայումս փաթեթների ախտահանիչները աստիճանաբար կորցնում են իրենց արդիականությունը որպես հաքերների համար գործիքներ, բայց միևնույն ժամանակ մնում են ցանցերի ախտորոշման արդյունավետ և հզոր գործիք: Ավելին, sniffers-ը կարող է հաջողությամբ օգտագործվել ոչ միայն ցանցային խնդիրների ախտորոշման և տեղայնացման, այլ նաև ցանցի անվտանգության աուդիտի համար: Մասնավորապես, փաթեթային անալիզատորների օգտագործումը թույլ է տալիս հայտնաբերել չարտոնված երթևեկությունը, հայտնաբերել և բացահայտել չարտոնված ծրագրային ապահովում, բացահայտել չօգտագործված արձանագրությունները դրանք ցանցից հեռացնելու համար, ստեղծել երթևեկություն ներթափանցման փորձարկման համար (ներթափանցման թեստ) պաշտպանական համակարգը փորձարկելու համար, աշխատել ներխուժման հայտնաբերման համակարգերի հետ (Intrusion Detection System, IDS):

Ծրագրային փաթեթների Sniffers-ի ակնարկ

Բոլոր ծրագրային sniffer-ները կարելի է մոտավորապես բաժանել երկու կատեգորիայի՝ sniffers, որոնք աջակցում են գործարկումը հրամանի տողից, և sniffers, որոնք ունեն GUI. Միևնույն ժամանակ, մենք նշում ենք, որ կան sniffers, որոնք համատեղում են այս երկու հատկանիշները: Բացի այդ, sniffer-ները միմյանցից տարբերվում են իրենց կողմից աջակցվող արձանագրություններով, գաղտնալսված փաթեթների վերլուծության խորությամբ, ֆիլտրերի կազմաձևման ունակությամբ և այլ ծրագրերի հետ համատեղելիության հնարավորությամբ:

Որպես կանոն, գրաֆիկական ինտերֆեյս ունեցող ցանկացած sniffer-ի պատուհանը բաղկացած է երեք տարածքից: Առաջինը ցուցադրում է գրավված փաթեթների ամփոփագիրը: Սովորաբար այս տարածքը ցուցադրում է նվազագույն դաշտեր, մասնավորապես՝ փաթեթների հավաքման ժամանակը; Փաթեթի ուղարկողի և ստացողի IP հասցեները. Փաթեթների սկզբնաղբյուր և նպատակակետ MAC հասցեներ, սկզբնաղբյուր և նպատակակետ նավահանգիստների հասցեներ; արձանագրության տեսակը (ցանց, տրանսպորտ կամ կիրառական շերտ); որոշ ամփոփ տեղեկություններ գաղտնալսված տվյալների մասին: Երկրորդ տարածքը ցուցադրվում է վիճակագրական տեղեկատվությունառանձին ընտրված փաթեթի մասին, և վերջապես, երրորդ տարածքում փաթեթը ներկայացված է տասնվեցական ձևով կամ ASCII նիշերի տեսքով:

Գրեթե բոլոր փաթեթների անալիզատորները թույլ են տալիս վերլուծել վերծանված փաթեթները (այդ պատճառով էլ փաթեթների անալիզատորները կոչվում են նաև փաթեթային անալիզատորներ կամ արձանագրության անալիզատորներ): Սնիֆերը բաժանում է գաղտնալսված փաթեթները ըստ շերտերի և արձանագրությունների: Որոշ փաթեթային անալիզատորներ կարողանում են ճանաչել արձանագրությունը և ցուցադրել հավաքագրված տեղեկատվությունը: Այս տեսակի տեղեկատվությունը սովորաբար ցուցադրվում է sniffer պատուհանի երկրորդ տարածքում: Օրինակ, ցանկացած sniffer կարող է ճանաչել TCP արձանագրությունը, և առաջադեմ sniffers կարող են որոշել, թե որ հավելվածն է ստեղծել այս տրաֆիկը: Արձանագրությունների անալիզատորներից շատերը ճանաչում են ավելի քան 500 տարբեր արձանագրություններ և կարող են նկարագրել և վերծանել դրանք անունով: Որքան ավելի շատ տեղեկատվություն sniffer-ը կարողանա վերծանել և ցուցադրել էկրանին, այնքան ավելի քիչ պետք է ձեռքով վերծանել:

Խնդիրներից մեկը, որին կարող են հանդիպել փաթեթների խուզողները, այն է, որ չկարողանալը ճիշտ նույնականացնել արձանագրությունը՝ օգտագործելով լռելյայն նավահանգիստից այլ նավահանգիստ: Օրինակ, անվտանգությունը բարելավելու համար որոշ հայտնի հավելվածներ կարող են կազմաձևվել այնպես, որ օգտագործեն այլ նավահանգիստներ, քան լռելյայն նավահանգիստները: Այսպիսով, վեբ սերվերի համար նախատեսված ավանդական 80 պորտի փոխարեն, տրված սերվերկարող է ստիպել վերակազմավորվել 8088-ի կամ որևէ այլ նավահանգստի վրա: Որոշ փաթեթային անալիզատորներ այս իրավիճակում չեն կարողանում ճիշտ որոշել արձանագրությունը և ցուցադրում են միայն տեղեկատվություն ցածր մակարդակի արձանագրության մասին (TCP կամ UDP):

Կան ծրագրային ապահովման sniffers, որոնք գալիս են ծրագրային ապահովման վերլուծական մոդուլների հետ, որպես plug-ins կամ ներկառուցված մոդուլներ, որոնք թույլ են տալիս ստեղծել հաշվետվություններ գաղտնալսված տրաֆիկի մասին օգտակար վերլուծական տեղեկություններով:

Ծրագրային փաթեթների խուզարկողների մեծամասնության մեկ այլ բնորոշ առանձնահատկությունն այն է, որ ֆիլտրերը կարգավորելու ունակությունն է թրաֆիկը գրավելուց առաջ և հետո: Զտիչներն առանձնացնում են որոշակի փաթեթներ ընդհանուր տրաֆիկից՝ ըստ տրված չափանիշի, ինչը թույլ է տալիս ազատվել ավելորդ տեղեկատվությունից՝ թրաֆիկը վերլուծելիս։

Ընդհանուր սխեմա

Քայլերի հաջորդականությունը, որ ծրագիրը, որն օգտագործում է pcap գրադարանը (PacketCAPture-ից) պետք է հետևի իր առաջադրանքը կատարելու համար.

• Որոշեք ցանցային ինտերֆեյսը, որը պետք է լսվի: (Linux-ում սա կարող է լինել eth0, BSD xl1-ում):
• Նախաձեռնել pcap-ը: Այս դեպքում գրադարանին ասվում է, թե որ ինտերֆեյսի վրա ենք լսելու տվյալները։ Հնարավոր է միաժամանակ մի քանի ինտերֆեյս լսել (տարբեր նիստերում):
• Անհրաժեշտության դեպքում ստեղծեք զտիչ (օրինակ՝ մեզ հետաքրքրում է միայն 23-րդ նավահանգիստ ժամանող TCP փաթեթները), «կազմեք» այս ֆիլտրը և կիրառեք այն որոշակի սեսիայի վրա։
• Գնացեք փաթեթի ստացման հանգույց: Դրանից հետո, երբ հաջորդ փաթեթը գալիս է և այն անցնում է նշված ֆիլտրով, կանչվում է ֆունկցիա, որը պետք է նախապես սահմանված լինի։ Այս ֆունկցիան կարող է անել այն, ինչ ուզում ենք։ Այն կարող է վերլուծել փաթեթը և տալ այն օգտագործողին, պահել այն սկավառակի վրա կամ ընդհանրապես ոչինչ չանել:
• Աշխատանքի ավարտին անհրաժեշտ է փակել բոլոր բաց նիստերը:

Եկեք մանրամասն նայենք այս քայլերին:

Ինտերֆեյսի սահմանում

Գոյություն ունեն երկու եղանակ՝ որոշելու, թե որ ինտերֆեյսը լսել:

Առաջինն այն է, որ ինտերֆեյսի անունը սահմանվում է օգտագործողի կողմից: Դիտարկենք հետևյալ ծրագիրը.

#ներառում #ներառում int main (int argc, char *argv) ( char *dev = argv; printf ("Սարք՝ %s\n", dev); return(0); )

Օգտագործողը սահմանում է ինտերֆեյս՝ իր անունը փոխանցելով մեր ծրագրին առաջին արգումենտով: Բնականաբար, օգտագործողի կողմից նշված ինտերֆեյսը պետք է գոյություն ունենա:

Երկրորդ ճանապարհը ինտերֆեյսի անունը հենց գրադարանից ստանալն է.

#ներառում #ներառում int main() (char *dev, erbuf; dev = pcap_lookupdev(errbuf); printf("Սարք՝ %s\n", dev); return(0); )

Այս դեպքում pcap-ը մեզ տալիս է այն ինտերֆեյսի անվանումը, որն իրեն պատկանում է: errbuf տողը կպարունակի սխալի նկարագրությունը, եթե այդպիսիք կան, pcap_lookupdev()-ին զանգը կատարելիս:

Փաթեթներ գրավելու համար ինտերֆեյսի բացում

Երթևեկության ընդհատման նիստ ստեղծելու համար անհրաժեշտ է զանգահարել pcap_open_live() ֆունկցիան: Այս ֆունկցիայի նախատիպը (pcap man էջից) ունի հետևյալ տեսքը.

pcap_t *pcap_open_live (char *սարք, int snaplen, int promisc, int to_ms, char *ebuf)

Առաջին փաստարկը սարքի անվանումն է, որը մենք սահմանել ենք նախորդ քայլում: snaplen-ը ամբողջ թիվ է, որը նշում է ցանցի շրջանակի բայթերի առավելագույն քանակը, որոնք կգրանցվեն գրադարանի կողմից: Եթե ​​promisc-ը դրված է true, ապա ինտերֆեյսը մտնում է այսպես կոչված անառակ ռեժիմ (ցանցի այլ կայաններին հասցեագրված փաթեթները խափանում են): to_ms - ժամանակի վերջ միլիվայրկյաններով (եթե արժեքը զրո է, ընթերցումը տեղի կունենա մինչև առաջին սխալը, մինուս մեկ՝ անորոշ ժամանակով): Վերջապես, errbuf-ն այն տողն է, որտեղ մենք կստանանք սխալի հաղորդագրություն: Ֆունկցիան վերադարձնում է նիստի բռնակ (նկարագրիչ):

Ցույց տալու համար հաշվի առեք կոդի հատված.

#ներառում Pcap_t *բռնակ; handle = pcap_open_live (somedev, BUFSIZ, 1, 0, errbuf);

Սա բացում է ինտերֆեյսը, որի անունը նշված է somedev տողում՝ նշելով, թե փաթեթի քանի բայթ պետք է գրավել (BUFSIZ արժեքը սահմանված է pcap.h-ում): Ցանցային ինտերֆեյսը անցնում է անառակ ռեժիմի: Տվյալները կկարդացվեն մինչև սխալ առաջանա: Սխալի դեպքում կարող եք էկրանին ցուցադրել դրա տեքստային նկարագրությունը՝ օգտագործելով errbuf ցուցիչը։

Նշում անառակ և ոչ անառակ ռեժիմներում երթևեկության գաղտնալսման մասին. երկու մեթոդները շատ տարբեր են: Ոչ սանձարձակ ռեժիմով երթևեկության գաղտնալսման դեպքում հանգույցը ստանում է միայն այն տրաֆիկը, որն ուղղված է կամ կապված է դրան: Միայն երթևեկությունը դեպի հյուրընկալող, դեպի տնից և երթուղի կանցնի մեր ծրագրի կողմից: Անառակ ռեժիմում ցանցային ինտերֆեյսը ընդունում է մալուխի միջոցով եկող բոլոր փաթեթները: Չանջատված միջավայրում սա կարող է լինել ամբողջ ցանցային տրաֆիկը: Դրա հստակ առավելությունն այն է, որ այն ապահովում է ավելի շատ փաթեթներ գրավելու համար, որոնք կարող են (կամ չեն կարող) օգտակար լինել՝ կախված նրանից, թե ինչի համար եք գրավում ցանցի հոսքը:

Այնուամենայնիվ, երթևեկությունը անառակ ռեժիմում կարող է հայտնաբերվել. մեկ այլ հանգույց կարող է բարձր ճշգրտությամբ որոշել, թե արդյոք մենք օգտագործում ենք անառակ ռեժիմ: Նաև այն աշխատում է միայն չփոխարկվող միջավայրերում (օրինակ՝ հանգույցներ կամ անջատիչներ, որոնք ողողված են arp փաթեթներով): Երրորդ, եթե ցանցը շատ ծանրաբեռնված է, մեր ծրագիրը կօգտագործի մեծ քանակությամբ համակարգի ռեսուրսները.

Երթևեկության զտում

Հաճախ ոչ բոլորը, այլ միայն որոշակի փաթեթները գաղտնալսելու համար անհրաժեշտ է փաթեթների ընկալիչ: Օրինակ՝ լինում են դեպքեր, երբ մենք ցանկանում ենք գաղտնաբառեր փնտրելիս գաղտնաբառեր փնտրելիս գաղտնաբառեր փնտրել 23-րդ նավահանգստում (տելնետ) տրաֆիկը: Կամ գուցե մենք ուզում ենք ընդհատել ֆայլը, որն ուղարկվում է 21-րդ նավահանգստում (FTP): Միգուցե մենք միայն ցանկանում ենք գրավել DNS տրաֆիկը (UDP պորտ 53): Ամեն դեպքում, շատ հազվադեպ է անհրաժեշտ բոլոր տվյալները գաղտնալսել։ pcap_compile() և pcap_setfilter() ֆունկցիաները նախատեսված են երթեւեկության զտման համար։

Այն բանից հետո, երբ մենք կանչեցինք pcap_open_live()-ը և ստացանք ֆունկցիոնալ նկարահանման նիստ, մենք կարող ենք կիրառել մեր զտիչը: Իհարկե, հնարավոր է ձեռքով ներդնել զտիչը՝ փաթեթը ստանալուց հետո վերլուծելով ETH/IP/TCP վերնագրերը, սակայն ներքին pcap ֆիլտրի օգտագործումն ավելի արդյունավետ է և նաև ավելի հեշտ:

Նախքան ֆիլտր կիրառելը, դուք պետք է «կազմեք» այն: Ֆիլտրի արտահայտությունը պահվում է սովորական տողի մեջ (նիշերի զանգված): Նման արտահայտությունների շարահյուսությունը մանրամասն ներկայացված է tcpdump man էջում (man tcpdump):

Ֆիլտրը կազմելու համար օգտագործվում է pcap_compile() ֆունկցիան։ Նրա նախատիպն ունի հետևյալ տեսքը.

Int pcap_compile (pcap_t *p, struct bpf_program *fp, char *str, int optimize, bpf_u_int32 ցանցային դիմակ)

Առաջին արգումենտը մեր նիստի բռնիչն է (նկարագրիչը) (pcap_t *handle նախորդ օրինակում): Հաջորդ արգումենտը ցուցիչ է դեպի հիշողության տարածք, որտեղ մենք կպահենք մեր ֆիլտրի կազմված տարբերակը: Հաջորդը գալիս է ֆիլտրի արտահայտությունն ինքնին որպես կանոնավոր տող: Հաջորդ պարամետրը որոշում է, թե արդյոք մեր արտահայտությունը պետք է օպտիմալացվի, թե ոչ (ինչպես սովորաբար, 0-ը նշանակում է «ոչ», 1-ը նշանակում է «այո»): Վերջին պարամետրը ցանցային դիմակն է, որի վրա կիրառվում է մեր զտիչը: Ֆունկցիան սխալի դեպքում վերադարձնում է -1, մնացած բոլոր արժեքները ցույց են տալիս հաջողություն:

Հենց որ արտահայտությունը կազմվի, այն պետք է կիրառվի, որն արվում է pcap_setfilter() ֆունկցիայի միջոցով։ Դրա նախատիպն է.

int pcap_setfilter (pcap_t *p, struct bpf_program *fp)

Առաջին արգումենտը մեր փաթեթների հավաքագրման նիստի բռնակն է (բռնակը), երկրորդը ֆիլտրի արտահայտության կոմպիլացված տարբերակի ցուցիչն է (սովորաբար pcap_compile() ֆունկցիայի երկրորդ արգումենտը):

Հետևյալ օրինակը ցույց է տալիս ֆիլտրի օգտագործումը.

#ներառում Pcap_t *բռնակ; // նիստի նկարագրիչ char dev = "eth0"; // ինտերֆեյս, որի վրա մենք կլսենք char errbuf; // Error line struct bpf_program filter; // Կազմված արտահայտություն char ֆիլտրի համար filter_app = «port 23»; // Զտիչ արտահայտություն bpf_u_int32 դիմակ; // Մեր ինտերֆեյսի ցանցային դիմակ bpf_u_int32 net; // Մեր ինտերֆեյսի pcap_lookupnet IP հասցեն (dev, &net, &mask, errbuf); handle = pcap_open_live (dev, BUFSIZ, 1, 0, errbuf); pcap_compile (բռնակ, &զտիչ, filter_app, 0, ցանց); pcap_setfilter (բռնակ, &զտիչ);

Այս ծրագիրը պատրաստում է sniffer փաթեթների համար 23 նավահանգիստ կամ այնտեղից, անառակ ռեժիմում, eth0 ինտերֆեյսի վրա: Օրինակը պարունակում է pcap_lookupnet() ֆունկցիան, որը վերադարձնում է ցանցի հասցեն և ցանցի դիմակը՝ որպես պարամետր տրված սարքի համար: Դրա օգտագործումը անհրաժեշտ է, քանի որ ֆիլտր կիրառելու համար մենք պետք է իմանանք հասցեն և ցանցի դիմակը։

Փաթեթի գրավում

Փաթեթների գրավման երկու տեխնիկա կա. Դուք կարող եք միաժամանակ մեկ փաթեթ գրավել և մշակել, կամ կարող եք աշխատել մի խումբ փաթեթների հետ՝ սահմանելով հատուկ հանգույց, որը կաշխատի այնքան ժամանակ, մինչև pcap-ը չգրավի փաթեթների նշված թիվը: Առաջին ռեժիմում աշխատելու համար օգտագործվում է pcap_next() ֆունկցիան։ pcap_next() նախատիպ.

U_char *pcap_next(pcap_t *p, struct pcap_pkthdr *h)

Առաջին արգումենտը մեր նստաշրջանի բռնիչն է, երկրորդը ցուցիչ է դեպի կառուցվածք, որը կպահի փաթեթի մասին տեղեկությունները, ինչպիսիք են այն ժամանակ, երբ այն փակվել է, փաթեթի երկարությունը և դրա առանձին մասի երկարությունը (օրինակ, եթե փաթեթը մասնատված է): pcap_next()-ը վերադարձնում է u_char ցուցիչը հիշողության վայր, որտեղ պահվում է այս կառուցվածքով նկարագրված փաթեթը:

Մեկ փաթեթ գրավելու համար pcap_next()-ի օգտագործման ցուցադրում.

#ներառում #ներառում int main() (pcap_t *handle; char *dev; char errbuf; // սխալի նկարագրություն string struct bpf_program filter; // compiled filter char filter_app = "port 23"; // filter bpf_u_int32 mask; // network mask bpf_u_int32 net ; // մեր ip հասցեն կառուցում է pcap_pkthdr վերնագիրը; // փաթեթի վերնագիր, որը կլցնի pcap const u_char *փաթեթը; // փաթեթն ինքնին // սահմանում է միջերեսը dev = pcap_lookupdev(errbuf); // ստացիր ցանցի հասցեն և ինտերֆեյսի դիմակ pcap_lookupnet (dev, &net): , &mask, errbuf); // բացել նկարահանման սեսիան անառակ ռեժիմով handle = pcap_open_live (dev, BUFSIZ, 1, 0, errbuf); // կազմել և կիրառել փաթեթի ֆիլտրը pcap_compile (handle, &filter, filter_app, 0, net) ; pcap_setfilter(handle, &filter); // capture the packet = pcap_next(handle, &header); // տպել դրա երկարությունը վահանակի վրա printf("Jacked a packet with [%d]\n", header.len ); / / փակել նիստը pcap_close (handle); վերադարձ (0); )

Այս ծրագիրը ֆիքսում է փաթեթները սարքի վրա, որոնք վերադարձվում են pcap_lookupdev()-ով, այն դնելով ծակոտկեն ռեժիմի: Այն հայտնաբերում է մի փաթեթ, որն անցնում է 23-րդ պորտով (տելնետ) և ցուցադրում է դրա չափը բայթերով: Pcap_close()-ը զանգահարելով փակում է բաց նկարահանման նիստը:

Այլընտրանքային մեթոդը, թեև ավելի դժվար հասկանալի է, հավանաբար ավելի օգտակար կլինի: Շատ քիչ են (եթե այդպիսիք կան) փաթեթներ, որոնք օգտագործում են pcap_next(): Դեպքերի ճնշող մեծամասնությունում նրանք օգտագործում են pcap_loop() կամ pcap_dispatch() (որն իր հերթին օգտագործում է pcap_loop()): Այս երկու գործառույթների օգտագործումը հասկանալու համար դուք պետք է հասկանաք հետադարձ կապի գործառույթների հայեցակարգը:

Հետադարձ զանգի գործառույթները սովորաբար կիրառվող ծրագրավորման տեխնիկա են: Սկզբունքը բավականին պարզ է. Ենթադրենք, դուք ունեք ծրագիր, որը սպասում է ինչ-որ իրադարձության: Օրինակ՝ ստեղնաշարի մշակման նպատակով։ Ամեն անգամ, երբ ստեղնը սեղմվում է, ես ուզում եմ կանչել գործառույթ, որը կկարգավորի այդ իրադարձությունը: Գործառույթը, որը ես օգտագործում եմ, հետ կանչելու գործառույթն է: Ամեն անգամ, երբ օգտվողը սեղմում է ստեղնը, իմ ծրագիրը կկանչի հետադարձ զանգի գործառույթը: Հետադարձ զանգի գործառույթներն օգտագործվում են pcap-ում, սակայն դրանք կանչելու փոխարեն, երբ օգտագործողը սեղմում է ստեղնը, pcap-ը կանչում է դրանք, երբ ստանում է հաջորդ փաթեթը: pcap_loop() և pcap_dispatch() ֆունկցիաներ են, որոնք օգտագործում են հետադարձման մեխանիզմը մոտավորապես նույն կերպ: Երկուսն էլ հետ կանչում են ամեն անգամ, երբ pcap-ը գրավում է փաթեթ, որն անցնում է ֆիլտրի միջով (եթե, իհարկե, ֆիլտրը չի հավաքվում և չի կիրառվում նիստի վրա, հակառակ դեպքում բոլոր գրավված փաթեթները փոխանցվում են հետադարձ զանգերին)

pcap_loop() ֆունկցիայի նախատիպը.

int pcap_loop (pcap_t *p, int cnt, pcap_handler հետադարձ զանգ, u_char *user);

Առաջին փաստարկը մեր նիստի բռնակն է: Հաջորդ ամբողջ թիվը հայտնում է pcap_loop()-ին, թե քանի փաթեթ պետք է հավաքել ընդհանուր առմամբ (բացասական արժեքը նշանակում է, որ փաթեթի գրավումը պետք է տեղի ունենա մինչև սխալ տեղի ունենա): Երրորդ արգումենտը հետ կանչելու ֆունկցիայի անունն է (միայն անունը, առանց փակագծերի): Վերջին արգումենտն օգտագործվում է որոշ հավելվածներում, բայց սովորաբար այն պարզապես սահմանվում է NULL: pcap_dispatch()-ը գրեթե նույնական է, միակ տարբերությունն այն է, թե ինչպես են գործառույթները վարում ժամանակի վերջնաժամկետը, որը սահմանվում է pcap_open_live()-ը կանչելիս: pcap_loop()-ը պարզապես անտեսում է ժամանակի վերջնաժամկետը, ի տարբերություն pcap_dispatch()-ի: Մանրամասների համար տե՛ս man pcap:

Նախքան pcap_loop()-ի օգտագործման օրինակ բերելը, մենք պետք է հաշվի առնենք մեր հետադարձ կապի ֆունկցիայի ձևաչափը: Մենք չենք կարող կամայականորեն սահմանել հետադարձ կապի ֆունկցիայի նախատիպ, քանի որ pcap_loop()-ը չի իմանա, թե ինչ անել դրա հետ: Մեր հետադարձ կապի ֆունկցիայի նախատիպը պետք է լինի այսպիսին.

void got_packet (u_char *args, const struct pcap_pkthdr *header, const u_char *packet);

Դիտարկենք այն ավելի մանրամասն: Նախ, ֆունկցիան վերադարձնում է դատարկ արժեք (անվավեր): Սա տրամաբանական է, քանի որ pcap_loop()-ը չի կարող իմանալ, թե ինչ անել վերադարձվող արժեքի հետ: Առաջին արգումենտը նույնն է, ինչ վերջին արգումենտը pcap_loop(): Ինչ արժեք էլ որ օգտագործվի որպես pcap_loop()-ի վերջին արգումենտ, այն որպես առաջին արգումենտ փոխանցվում է հետադարձ կապի ֆունկցիային ամեն անգամ, երբ այն կանչվում է pcap_loop()-ից: Երկրորդ արգումենտը pcap վերնագիրն է, որը պարունակում է տեղեկատվություն այն մասին, թե երբ է գրավվել փաթեթը, դրա չափը և այլն: pcap_pkthdr կառուցվածքը pcap.h-ում սահմանվում է հետևյալ կերպ.

Struct pcap_pkthdr (struct timeval ts; // timestamp bpf_u_int32 caplen; // փաթեթի գրավված մասի երկարությունը bpf_u_int32 len; // փաթեթի ընդհանուր երկարությունը);

Հետ կանչելու ֆունկցիայի վերջին փաստարկն ամենահետաքրքիրն է: Սա ցուցիչ է դեպի բուֆեր, որը պարունակում է, փաստորեն, ամբողջ փաթեթը, որը գրավվել է pcap_loop()-ի միջոցով:

Ինչպե՞ս օգտագործել փաթեթի փոփոխականը: Փաթեթը պարունակում է բազմաթիվ ատրիբուտներ, այնպես որ, ինչպես կարող եք պատկերացնել, դա իրականում տող չէ, այլ կառուցվածքների մի շարք (օրինակ, TCP/IP փաթեթը պարունակում է ethernet-, ip-, tcp- վերնագիր և հենց տվյալները) . Փաթեթի պարամետրը, որը u_char տիպի է, իրականում այս կառույցների սերիական տարբերակն է: Այս կառույցներից օգտակար տվյալներ ստանալու համար մենք պետք է որոշ փոխակերպումներ կատարենք։

Առաջին հերթին մենք պետք է ունենանք ծրագրում սահմանված կառուցվածքներ, որոնք մենք օգտագործելու ենք։ Մենք կօգտագործենք հետևյալ կառուցվածքները (իրականում, մենք կարող ենք դրանք վերցնել անմիջապես վերնագրի ֆայլերից, բայց կառուցվածքի դաշտերի անվանումները տարբեր հարթակներից տարբերվում են, ուստի դրանք օգտագործվում են ցուցադրական նպատակներով).

Struct sniff_ethernet ( u_char ether_dhost; u_char ether_shost; u_short ether_type; /* IP? ARP? RARP? և այլն */ ); // IP վերնագրի կառուցվածքը sniff_ip ( #if BYTE_ORDER == LITTLE_ENDIAN u_int ip_hl:4, ip_v:4; #endif #if BYTE_ORDER == BIG_ENDIAN u_int ip_v:4, /* տարբերակ */ ip_hl:4; /* վերնագրի երկարությունը */ #endif /* not _IP_VHL */ u_char ip_tos; u_short ip_len; u_short ip_id; u_short ip_off; #define IP_RF 0x8000 /* Reserved fragment flag */ #define IP_DF 0x4000 /* Dontde F fragmente more*0 դրոշ */ #define IP_OFFMASK 0x1fff /* դիմակ մասնատման բիթերի համար */ u_char ip_ttl; /* ապրելու ժամանակը */ u_char ip_p; /* արձանագրություն */ u_short ip_sum; /* checksum */ struct in_addr ip_src,ip_dst; /* աղբյուրը և նպատակակետի հասցեն */ ); struct sniff_tcp ( u_short th_sport; u_short th_dport; tcp_seq th_seq; /* հաջորդականության համարը */ tcp_seq th_ack; /* ճանաչման համարը */ #if BYTE_ORDER == LITTLE_END_x /th_unt; * տվյալների շեղում */ #endif #if BYTE_ORDER == BIG_ENDIAN u_int th_off:4, /* տվյալների շեղում */ th_x2:4; /* (չօգտագործված) */ #endif u_char th_flags; #define TH_FIN 0x01 #define TH_SYN TH_RST 0x04 #սահմանել TH_PUSH 0x08 #սահմանել TH_ACK 0x10 #սահմանել TH_URG 0x20 #սահմանել TH_ECE 0x40 #սահմանել TH_CWR 0x80 #սահմանել TH_ACK u**սահմանել TH_ACK u**սահմանել TH_ACK u; checksum */ u_short th_urp; /* հրատապ ցուցիչ */ );

Եթե ​​օգտագործվում են ստանդարտ վերնագրի ֆայլերի կառուցվածքի նկարագրությունները, ապա երբեմն, որպեսզի TCP վերնագրի նկարագրությունը օգտագործող ծրագիրն առանց սխալների կոմպիլյացիայի ենթարկվի, անհրաժեշտ է սահմանել _BSD_SOURCE նշանը՝ նախքան վերնագրի ֆայլերը ներառելը: Այլընտրանքային ճանապարհ- սահմանել կառուցվածքները, որոնք նկարագրում են TCP վերնագիրը ձեռքով:

pcap-ը, բնականաբար, օգտագործում է նույն կառուցվածքը փաթեթներ գրավելիս: Այնուհետև այն պարզապես ստեղծում է u_char տող (բուֆեր) և պատճենում է կառուցվածքների տվյալները դրա մեջ: Ինչպե՞ս վերլուծել տողը կառուցվածքների մեջ: Սա հեշտությամբ արվում է ցուցիչների և տիպերի փոխակերպումների միջոցով:

Նախ, եկեք հայտարարենք այն փոփոխականները, որոնք մեզ անհրաժեշտ են u_char փաթեթը առանձին վերնագրերի մեջ վերլուծելու համար.

const struct sniff_ethernet *ethernet; const struct sniff_ip *ip; const struct sniff_tcp *tcp; const char *օգտակար; int size_ethernet = sizeof(struct sniff_ethernet); int size_ip = sizeof(struct sniff_ip); int size_tcp = sizeof(struct sniff_tcp);

Այժմ մենք կատարում ենք տիպի փոխարկում.

Ethernet = (struct sniff_ethernet*) (փաթեթ); ip = (struct sniff_ip*) (packet + size_ethernet); tcp = (struct sniff_tcp*) (փաթեթ + size_ethernet + size_ip); ծանրաբեռնվածություն = (u_char *) (փաթեթ + size_ethernet + size_ip + size_tcp);

Դրանից հետո մենք կարող ենք մուտք գործել բոլոր կառույցների դաշտերը սովորական ձևով, օրինակ.

Եթե ​​(tcp->th_flags & TH_URG) ( ... ); ... printf("TTL = %d\n", ip->ip_ttl);

Անջատել

Ավարտելուց հետո դուք պետք է փակեք նիստը: Դա արվում է pcap_close() ֆունկցիայի միջոցով:

SmartSniffթույլ է տալիս ընդհատել ցանցային տրաֆիկը և ցուցադրել դրա բովանդակությունը ASCII-ում: Ծրագիրը գրավում է ցանցային ադապտերով անցնող փաթեթները և ցուցադրում փաթեթների պարունակությունը տեքստի ձևը(արձանագրություններ http, pop3, smtp, ftp) և որպես տասնվեցական աղբանոց: TCP/IP փաթեթները գրավելու համար SmartSniff-ն օգտագործում է հետևյալ տեխնիկան՝ չմշակված վարդակներ՝ RAW Sockets, WinCap Capture Driver և Microsoft Network Monitor Driver: Ծրագիրը աջակցում է ռուսերենին և հեշտ է օգտագործել:

Փաթեթների սնիֆեր ծրագիր

SmartSniff-ը ցուցադրում է հետևյալ տեղեկությունները. արձանագրության անվանումը, տեղական և հեռավոր հասցե, տեղական և հեռավոր նավահանգիստ, տեղային հոսթ, ծառայության անվանում, տվյալների ծավալ, ընդհանուր չափ, հավաքման ժամանակը և վերջին փաթեթի ժամանակը, տևողությունը, տեղական և հեռավոր MAC հասցե, երկրներ և բովանդակություն: տվյալների փաթեթը. Ծրագիրն ունի ճկուն կարգավորումներ, այն ունի գրավման ֆիլտրի գործառույթ, http պատասխանները բացում է, ip հասցեները փոխակերպում, կոմունալը նվազագույնի է հասցվում համակարգի սկուտեղին: SmartSniff-ը ձևով ստեղծում է փաթեթի հոսքի հաշվետվություն HTML էջեր. Ծրագրում հնարավոր է արտահանել TCP/IP հոսքեր։

Երբեմն ինտերնետից օգտվելիս առաջանում են իրավիճակներ, երբ երթևեկության արտահոսք կամ համակարգի ռեսուրսների չնախատեսված սպառում է տեղի ունենում: Արագ վերլուծելու և խնդրի աղբյուրը գտնելու համար օգտագործեք հատուկ ցանցային գործիքներ: Նրանցից մեկը՝ WireShark-ը, կքննարկվի հոդվածում։

ընդհանուր տեղեկություն

WireShark-ն օգտագործելուց առաջ դուք պետք է ծանոթանաք դրա շրջանակին, ֆունկցիոնալությանը և հնարավորություններին: Մի խոսքով, ծրագիրը թույլ է տալիս իրական ժամանակում գաղտնալսել փաթեթները լարային և անլար ցանցերում: ցանցային միացումներ. Օգտագործվում է Ethernet, IEEE 802.11, PPP և նմանատիպ արձանագրություններում: Կարող եք նաև օգտագործել VoIP զանգերի տրաֆիկի գաղտնալսումը:

Ծրագիրը տարածվում է GNU GPL լիցենզիայի ներքո, ինչը նշանակում է անվճար և բաց կոդով։ աղբյուր կոդը. Դուք կարող եք այն գործարկել բազմաթիվ Linux բաշխումների, MacOS-ի վրա, և կա նաև դրա տարբերակ օպերացիոն համակարգ Windows.

Ինչպե՞ս օգտագործել WireShark-ը:

Նախ, դուք պետք է նախ տեղադրեք այն համակարգում: Քանի որ ամենատարածվածներից մեկը Linux բաշխումներ Ubuntu-ն է, ապա բոլոր օրինակները կցուցադրվեն դրանում:

Տեղադրելու համար պարզապես մուտքագրեք հետևյալ հրամանը վահանակում.

sudo apt-get տեղադրել wireshark

Դրանից հետո ծրագիրը կհայտնվի հիմնական ցանկում: Դուք կարող եք այն գործարկել այնտեղից: Բայց ավելի լավ է դա անել տերմինալից, քանի որ նա կարիք ունի գերօգտագործողի իրավունքների: Սա կարելի է անել այսպես.

Արտաքին տեսք

Ծրագիրն ունի օգտագործողի համար հարմար գրաֆիկական ինտերֆեյս: Օգտագործողի առջև կհայտնվի բարեկամական պատուհան՝ բաժանված 3 մասի։ Առաջինն ուղղակիորեն կապված է գրավման հետ, երկրորդը վերաբերում է ֆայլերի և նմուշների բացմանը, իսկ երրորդը՝ օգնությունն ու աջակցությունը:

Capture բլոկը պարունակում է ցանցային ինտերֆեյսների ցանկ, որոնք հասանելի են գրավման համար: Երբ ընտրեք, օրինակ, eth0 և սեղմեք Start կոճակը, կսկսվի ընդհատման գործընթացը:

Գաղտնագրված տվյալներով պատուհանը նույնպես տրամաբանորեն բաժանված է մի քանի մասի։ Վերևում տարբեր տարրերով կառավարման վահանակ է: Դրան հաջորդում է փաթեթների ցանկը։ Այն ներկայացված է աղյուսակի տեսքով։ Այստեղ դուք կարող եք տեսնել փաթեթի սերիական համարը, դրա գաղտնալսման ժամանակը, մեկնման և ստացման հասցեն: Կարող եք նաև հեռացնել օգտագործված արձանագրությունների, երկարության և այլ օգտակար տեղեկությունների մասին տվյալները:

Ցանկի տակ պատուհան է ընտրված փաթեթի տեխնիկական տվյալների բովանդակությամբ: Եվ նույնիսկ ավելի ցածր ցուցադրվում է տասնվեցական ձևով:

Յուրաքանչյուր դիտում կարելի է առավելագույնի հասցնել մեծ պատուհանում՝ տվյալների ավելի հեշտ ընթերցման համար:

Զտիչների կիրառում

Ծրագրի աշխատանքի ընթացքում տասնյակ կամ նույնիսկ հարյուրավոր փաթեթներ միշտ կաշխատեն օգտատիրոջ առջև: Նրանց ձեռքով մաքրելը բավականին դժվար է և ժամանակատար: Հետեւաբար, պաշտոնական WireShark հրահանգը խորհուրդ է տալիս օգտագործել զտիչներ:

Նրանց համար ծրագրի պատուհանում կա հատուկ դաշտ՝ Filter: Զտիչը ավելի ճշգրիտ կարգավորելու համար կա Արտահայտման կոճակ:

Բայց շատ դեպքերում, ֆիլտրերի ստանդարտ հավաքածուն բավարար կլինի.

• ip.dst - փաթեթի նպատակակետ ip հասցե;
• ip.src - ուղարկողի հասցեն;
• ip.addr - պարզապես ցանկացած ip;
• ip.proto - արձանագրություն:

Օգտագործելով ֆիլտրեր WireShark-ում - հրահանգներ

Փորձելու համար, թե ինչպես է ծրագիրը աշխատում ֆիլտրերի հետ, դուք պետք է մուտքագրեք հատուկ հրաման: Օրինակ, նման հավաքածուն՝ ip.dst == 172.217.23.131, ցույց կտա բոլոր թռչող փաթեթները Google-ի կայք: Ամբողջ տրաֆիկը դիտելու համար՝ և՛ մուտքային, և՛ ելքային, կարող եք համատեղել երկու բանաձև՝ ip.dst == 172.217.23.131 || ip.src == 172.217.23.131. Այսպիսով, պարզվեց, որ մեկ տողում միանգամից երկու պայման է օգտագործվում.

Դուք կարող եք օգտագործել այլ պայմաններ, օրինակ՝ ip.ttl< 10. Այս հրամանը 10-ից պակաս ժամկետով բոլոր փաթեթները կարտադրվեն: Տվյալներն ըստ չափի ընտրելու համար կարող եք օգտագործել այս մոտեցումը՝ http.content_length > 5000:

Լրացուցիչ հնարավորություններ

Հարմարության համար WireShark-ն ունի փաթեթի պարամետրերը որպես վերլուծված դաշտ արագ ընտրելու միջոց: Օրինակ, տեխնիկական տվյալներ ունեցող դաշտում կարող եք աջ սեղմել ցանկալի օբյեկտի վրա և ընտրել «Դիմել որպես սյունակ»: Ի՞նչ է նշանակում դրա տեղափոխումը դաշտի տարածք որպես սյունակ։

Նմանապես, դուք կարող եք ընտրել ցանկացած պարամետր որպես զտիչ: Դա անելու համար համատեքստի ընտրացանկը ունի «Դիմել որպես զտիչ» տարրը:

Առանձին նիստ

Դուք կարող եք օգտագործել WireShark-ը որպես մոնիտոր երկու ցանցային հանգույցների միջև, օրինակ՝ օգտագործողի և սերվերի: Դա անելու համար ընտրեք հետաքրքրության փաթեթը, զանգահարեք համատեքստի ընտրացանկը և սեղմեք Հետևեք TCP հոսքին: Նոր պատուհանում կցուցադրվի երկու հանգույցների միջև փոխանակման ամբողջ մատյանը:

Ախտորոշում

WireShark-ն ունի ցանցային խնդիրների վերլուծության առանձին գործիք: Այն կոչվում է Փորձագիտական ​​գործիքներ: Այն կարող եք գտնել ներքևի ձախ անկյունում, կլոր պատկերակի տեսքով: Սեղմելով դրա վրա՝ կբացվի նոր պատուհան մի քանի ներդիրներով՝ Սխալներ, Զգուշացումներ և այլն: Նրանց օգնությամբ դուք կարող եք վերլուծել, թե որ հանգույցներն են ձախողվում, փաթեթները չեն հասնում և հայտնաբերել ցանցի հետ կապված այլ խնդիրներ:

Ձայնային երթեւեկություն

Ինչպես արդեն նշվեց, WireShark-ը կարող է ընդհատել և ձայնային տրաֆիկ. Դրան նվիրված կա մի ամբողջ Հեռախոսային մենյու: Սա կարող է օգտագործվել VoIP-ում խնդիրներ գտնելու և դրանք արագ լուծելու համար:

Հեռախոսային ընտրացանկի VoIP զանգեր տարրը թույլ կտա դիտել կատարված զանգերը և լսել դրանք:

Արտահանել օբյեկտներ

Սա, հավանաբար, ծրագրի ամենահետաքրքիր առանձնահատկությունն է: Այն թույլ է տալիս օգտագործել WireShark-ը որպես ցանցի միջոցով փոխանցվող ֆայլերի խափանման միջոց: Դա անելու համար դուք պետք է դադարեցնեք գաղտնալսման գործընթացը և արտահանեք HTTP օբյեկտներ File ընտրացանկում: Բացվող պատուհանում կներկայացվի նիստի ընթացքում փոխանցված բոլոր ֆայլերի ցանկը, որը կարող է պահպանվել հարմար վայրում:

Վերջապես

Ցավոք, ընթացիկ տարբերակըՑանցում ռուսերեն WireShark-ը դժվար կլինի գտնել։ Առավել մատչելի և հաճախ օգտագործվողը անգլերենն է:

Այդպես է նաև մանրամասն հրահանգներ WireShark-ի կողմից ռուսերեն: Պաշտոնական մշակողի կողմից ներկայացված է անգլերեն: Համացանցում սկսնակների համար կան բազմաթիվ փոքր և հակիրճ ձեռնարկներ WireShark-ում:

Սակայն նրանց համար, ովքեր երկար ժամանակ աշխատում են ՏՏ ոլորտում, ծրագրի հետ առնչվելը առանձնակի դժվարություններ չի առաջացնի։ Ա մեծ հնարավորություններև հարուստ ֆունկցիոնալությունը կլուսավորի սովորելու բոլոր դժվարությունները:

Հարկ է նշել, որ որոշ երկրներում sniffer-ի օգտագործումը, որը հանդիսանում է WireShark-ը, կարող է անօրինական լինել: