Agustus 05, 2019
Untuk Praktik kali ini menggunakan Linux sebagai OS nya..
Untuk Codingnya langsung aja lihat dibawah ini :
Pengaturan Perangkat
Ini sangat sederhana. Ada dua teknik untuk mengatur perangkat yang ingin
kita hirup.
Yang pertama adalah kita hanya bisa memberi tahu pengguna. Pertimbangkan
program berikut:
#include
<stdio.h>
#include
<pcap.h>
int
main(int argc, char *argv[])
{
char *dev = argv[1];
printf("Device: %s\n", dev);
return(0);
}
Pengguna menentukan
perangkat dengan memberikan nama itu sebagai argumen pertama ke program.
Sekarang string "dev" memiliki nama antarmuka yang akan kita hirup
dalam format yang dapat dipahami pcap (dengan asumsi, tentu saja, pengguna
memberi kita antarmuka nyata).
Teknik lainnya sama-sama
sederhana. Lihatlah program ini:
#include <stdio.h>
#include
<pcap.h>
int
main(int argc, char *argv[])
{
char
*dev, errbuf[PCAP_ERRBUF_SIZE];
dev
= pcap_lookupdev(errbuf);
if
(dev == NULL) {
fprintf(stderr,
"Couldn't find default device: %s\n", errbuf);
return(2);
}
printf("Device:
%s\n", dev);
return(0);
}
Dalam hal ini, pcap
hanya mengatur perangkat sendiri. "Tapi tunggu, Tim," katamu.
"Apa masalahnya dengan string errbuf?" Sebagian besar perintah pcap
memungkinkan kita meneruskannya sebagai argumen. Tujuan dari string ini? Jika
perintah gagal, itu akan mengisi string dengan deskripsi kesalahan. Dalam hal
ini, jika pcap_lookupdev () gagal, itu akan menyimpan pesan kesalahan di errbuf.
Bagus, bukan? Dan itulah cara kami mengatur perangkat kami
Membuka
perangkat untuk Sniffing
Tugas membuat sesi sniffing sangat sederhana. Untuk ini,
kami menggunakan pcap_open_live (). Prototipe fungsi ini (dari halaman manual
pcap) adalah sebagai berikut:
pcap_t *pcap_open_live(char *device, int snaplen, int promisc, int to_ms,
char *ebuf)
Argumen pertama adalah perangkat yang kami tentukan di
bagian sebelumnya. snaplen adalah bilangan bulat yang menentukan jumlah byte
maksimum yang akan ditangkap oleh pcap. promisc, ketika disetel ke true,
membawa antarmuka ke mode promiscuous (namun, meskipun disetel ke false,
dimungkinkan dalam kasus-kasus tertentu untuk antarmuka berada dalam mode
promiscuous). to_ms adalah waktu habis baca dalam milidetik (nilai 0 berarti
tidak ada waktu habis; pada setidaknya beberapa platform, ini berarti Anda
dapat menunggu hingga cukup banyak paket sebelum melihat paket apa pun, jadi
Anda harus menggunakan bukan-nol waktu habis). Terakhir, ebuf adalah string
yang dapat kita simpan pesan kesalahan apa pun di dalamnya (seperti yang kita
lakukan di atas dengan errbuf). Fungsi mengembalikan pengendali sesi kami.
Untuk demonstrasinya:
#include <pcap.h>
...
pcap_t *handle;
handle = pcap_open_live(dev, BUFSIZ, 1, 1000, errbuf);
if (handle == NULL) {
fprintf(stderr, "Couldn't open device %s: %s\n", dev, errbuf);
return(2);
}
Jika Program tidak suport terhadap Link-layer yang
diseiakan oleh perangkat, maka code yang digunakan sbb:
if (pcap_datalink(handle) != DLT_EN10MB) {
fprintf(stderr, "Device %s doesn't provide Ethernet headers - not supported\n", dev);
return(2);
}
Filtering traffic
Seringkali sniffer kami hanya tertarik pada lalu lintas
tertentu. Misalnya, mungkin ada saat-saat yang kita inginkan adalah mengendus
port 23 (telnet) untuk mencari kata sandi. Atau mungkin kami ingin melakukan
highjack file yang dikirim melalui port 21 (FTP). Mungkin kita hanya
menginginkan traffic DNS (port 53 UDP). Apa pun masalahnya, jarang sekali kita
hanya ingin mengendus semua lalu lintas jaringan secara membabi buta. Masukkan
pcap_compile () dan pcap_setfilter ().
Prosesnya cukup sederhana. Setelah kita memanggil
pcap_open_live () dan memiliki sesi sniffing yang berfungsi, kita dapat
menerapkan filter kita. Mengapa tidak menggunakan pernyataan if / else if kita
sendiri? Dua alasan. Pertama, filter pcap jauh lebih efisien, karena melakukannya
langsung dengan filter BPF; kami menghilangkan banyak langkah dengan meminta
pengemudi BPF melakukannya secara langsung. Kedua, ini jauh lebih mudah :)
Sebelum menerapkan filter kami, kami harus
"mengompilasinya". Ekspresi filter disimpan dalam string biasa (char
array). Sintaksnya didokumentasikan dengan cukup baik di halaman manual untuk
tcpdump; Saya meninggalkan Anda untuk membacanya sendiri. Namun, kami akan
menggunakan ekspresi tes sederhana, jadi mungkin Anda cukup tajam untuk
mengetahuinya dari contoh saya.
Untuk mengkompilasi program, kami memanggil pcap_compile
(). Prototipe mendefinisikannya sebagai:
int pcap_compile(pcap_t *p, struct bpf_program *fp, char *str, int optimize,
bpf_u_int32 netmask)
Argumen pertama adalah pegangan sesi kami (pegangan
pcap_t * dalam contoh kami sebelumnya). Berikut ini adalah referensi ke tempat
kami akan menyimpan versi kompilasi dari filter kami. Kemudian muncul ekspresi
itu sendiri, dalam format string biasa. Berikutnya adalah bilangan bulat yang memutuskan
apakah ekspresi harus "dioptimalkan" atau tidak (0 salah, 1 benar.
Hal-hal standar.) Akhirnya, kita harus menentukan topeng jaringan dari jaringan
yang diterapkan oleh filter. Fungsi mengembalikan -1 pada kegagalan; semua
nilai lain menyiratkan kesuksesan.
Setelah ekspresi dikompilasi, sekarang saatnya untuk
menerapkannya. Masukkan pcap_setfilter (). Mengikuti format penjelasan pcap
kami, kami akan melihat prototipe pcap_setfilter ():
Ini sangat mudah. Argumen pertama adalah pengendali sesi
kami, yang kedua adalah referensi ke versi ekspresi yang dikompilasi (mungkin
variabel yang sama dengan argumen kedua ke pcap_compile ()).
Mungkin contoh kode lain akan membantu untuk lebih
memahami:
#include <pcap.h>
...
pcap_t *handle; /* Session handle */
char dev[] = "rl0"; /* Device to sniff on */
char errbuf[PCAP_ERRBUF_SIZE]; /* Error string */
struct bpf_program fp; /* The compiled filter expression */
char filter_exp[] = "port 23"; /* The filter expression */
bpf_u_int32 mask; /* The netmask of our sniffing device */
bpf_u_int32 net; /* The IP of our sniffing device */
if (pcap_lookupnet(dev, &net, &mask, errbuf) == -1) {
fprintf(stderr, "Can't get netmask for device %s\n", dev);
net = 0;
mask = 0;
}
handle = pcap_open_live(dev, BUFSIZ, 1, 1000, errbuf);
if (handle == NULL) {
fprintf(stderr, "Couldn't open device %s: %s\n", dev, errbuf);
return(2);
}
if (pcap_compile(handle, &fp, filter_exp, 0, net) == -1) {
fprintf(stderr, "Couldn't parse filter %s: %s\n", filter_exp, pcap_geterr(handle));
return(2);
}
if (pcap_setfilter(handle, &fp) == -1) {
fprintf(stderr, "Couldn't install filter %s: %s\n", filter_exp, pcap_geterr(handle));
return(2);
}
Program ini menyiapkan sniffer untuk mengendus semua lalu
lintas yang datang dari atau pergi ke port 23, dalam mode promiscuous, pada
perangkat rl0.
Anda mungkin memperhatikan bahwa contoh sebelumnya berisi
fungsi yang belum kita diskusikan. pcap_lookupnet () adalah fungsi yang, diberi
nama perangkat, mengembalikan salah satu nomor jaringan IPv4-nya dan mask
jaringan yang sesuai (nomor jaringan adalah alamat IPv4 ANDed dengan mask
jaringan, sehingga hanya berisi bagian jaringan dari alamat tersebut ). Ini
penting karena kami perlu mengetahui topeng jaringan untuk menerapkan filter.
Fungsi ini dijelaskan di bagian Lain-lain di akhir dokumen.
Sudah pengalaman saya bahwa filter ini tidak berfungsi di
semua sistem operasi. Dalam lingkungan pengujian saya, saya menemukan bahwa
OpenBSD 2.9 dengan kernel default memang mendukung jenis filter ini, tetapi
FreeBSD 4.3 dengan kernel default tidak. Jarak tempuh Anda mungkin beragam.
Sniffing
yang Sebenarnya
Pada titik ini kita telah belajar bagaimana
mendefinisikan suatu perangkat, menyiapkannya untuk mengendus, dan menerapkan
filter tentang apa yang seharusnya dan tidak seharusnya kita ketahui. Sekarang
saatnya untuk benar-benar menangkap beberapa paket.
Ada dua teknik utama untuk menangkap paket. Kita dapat
menangkap satu paket pada satu waktu, atau kita dapat memasukkan satu loop yang
menunggu sejumlah paket untuk diendus sebelum dilakukan. Kita akan mulai dengan
melihat bagaimana cara menangkap satu paket, kemudian melihat metode
menggunakan loop. Untuk ini, kami menggunakan pcap_next ().
Argumen pertama adalah pengendali sesi kami. Argumen kedua adalah penunjuk ke struktur yang menyimpan informasi umum tentang paket, khususnya waktu di mana ia diendus, panjang paket ini, dan panjang bagian spesifiknya (jika itu terfragmentasi, misalnya.) Pcap_next () mengembalikan pointer u_char ke paket yang dijelaskan oleh struktur ini. Kami akan membahas teknik untuk benar-benar membaca paket itu sendiri nanti.
Berikut ini adalah demonstrasi sederhana menggunakan pcap_next () untuk mengendus suatu paket.
u_char *pcap_next(pcap_t *p, struct pcap_pkthdr *h)
Argumen pertama adalah pengendali sesi kami. Argumen kedua adalah penunjuk ke struktur yang menyimpan informasi umum tentang paket, khususnya waktu di mana ia diendus, panjang paket ini, dan panjang bagian spesifiknya (jika itu terfragmentasi, misalnya.) Pcap_next () mengembalikan pointer u_char ke paket yang dijelaskan oleh struktur ini. Kami akan membahas teknik untuk benar-benar membaca paket itu sendiri nanti.
Berikut ini adalah demonstrasi sederhana menggunakan pcap_next () untuk mengendus suatu paket.
#include <pcap.h>
#include <stdio.h>
int main(int argc, char *argv[])
{
pcap_t *handle; /* Session handle */
char *dev; /* The device to sniff on */
char errbuf[PCAP_ERRBUF_SIZE]; /* Error string */
struct bpf_program fp; /* The compiled filter */
char filter_exp[] = "port 23"; /* The filter expression */
bpf_u_int32 mask; /* Our netmask */
bpf_u_int32 net; /* Our IP */
struct pcap_pkthdr header; /* The header that pcap gives us */
const u_char *packet; /* The actual packet */
/* Define the device */
dev = pcap_lookupdev(errbuf);
if (dev == NULL) {
fprintf(stderr, "Couldn't find default device: %s\n", errbuf);
return(2);
}
/* Find the properties for the device */
if (pcap_lookupnet(dev, &net, &mask, errbuf) == -1) {
fprintf(stderr, "Couldn't get netmask for device %s: %s\n", dev, errbuf);
net = 0;
mask = 0;
}
/* Open the session in promiscuous mode */
handle = pcap_open_live(dev, BUFSIZ, 1, 1000, errbuf);
if (handle == NULL) {
fprintf(stderr, "Couldn't open device %s: %s\n", dev, errbuf);
return(2);
}
/* Compile and apply the filter */
if (pcap_compile(handle, &fp, filter_exp, 0, net) == -1) {
fprintf(stderr, "Couldn't parse filter %s: %s\n", filter_exp, pcap_geterr(handle));
return(2);
}
if (pcap_setfilter(handle, &fp) == -1) {
fprintf(stderr, "Couldn't install filter %s: %s\n", filter_exp, pcap_geterr(handle));
return(2);
}
/* Grab a packet */
packet = pcap_next(handle, &header);
/* Print its length */
printf("Jacked a packet with length of [%d]\n", header.len);
/* And close the session */
pcap_close(handle);
return(0);
}
Sumber : https://www.tcpdump.org/pcap.html
