Sniffing Mode || Cara memonitoring Jaringan menggunakan Sistem Operasi Linux Console

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 ():

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

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 ().

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

Read More