Skip to content

Wardriving z Raspberry Pi 4

Przenośny zestaw wardrivera. Doskonały do plecaka lub sakwy rowerowej.

Technologia 5G powoli rusza produkcyjnie w sieciach komórkowych, a blady strach pada na znaczną część społeczeństwa. Tworzą się grupy i organizacje, które tą nowość w eterze chcą aktywnie zwalczać. Z drugiej strony, straszą i kpią z nich oświeceni zwolennicy postępu, ustawiając w swoich domowych ruterach nazwy sieci WiFi takie jak 'Testowy nadajnik 5G'. Póki co krowy, zupełnie obojętne na te ludzkie fanaberie, dają mleko jak dawniej, a niebo nie spadło nam na głowy. Jednocześnie nie w pełni poznaliśmy, jak na ludzi i inne organizmy żywe, wpływa długofalowa ekspozycja na promieniowanie elektromagnetyczne emitowane w zakresach radiowych. Ale jak można wywnioskować po tytule, to nie fale radiowe nadajników 5G są sednem tego wpisu, będzie on o innych sieciach, o wypełniających naszą przestrzeń bezprzewodowych sieciach komputerowych oraz o ich nasłuchu.

Zaciekawiony po lekturze książki „Pamięć nieulotna” Edwarda Snowdena, zrobiłem sobie i potem tu opisałem, jak na bazie Raspberry Pi 4 wykonać sprzęt do tak zwanego wardriving’u, czyli wykrywania i pasywnego nasłuchiwania okolicznych sieci WiFi. Te powszechnie używane sieci, wykorzystują pasmo radiowe 2,4 i 5 Ghz, a ich domowe nadajniki mają ograniczoną prawnie moc do odpowiednio 100mW i 200mW.

Do zestawu takiego jak mój potrzebne będą:

  • Raspberry Pi 4 model B rev. 1.2 – 4GB RAM
  • Karta WiFi Alfa – 0bda:8812 Realtek Semiconductor Corp. RTL8812AU 802.11a/b/g/n/ac 2T2R DB WLAN Adapter
  • POWERBANK XIAOMI MI 3 PRO 20000mAh PD QC3.0 45W
  • Smartphone z Andoidem, GPS i Bluetooth

Raspbian i ustawienie WiFi

Zaczynamy od pobrania i dekompresji najnowszej instalacji raspbiana w wersji minimalnej:

$ wget https://downloads.raspberrypi.org/raspbian_lite_latest
$ unzip raspbian_lite_latest

Korzystam z systemu Linux, dlatego te i wszystkie kolejne przykładowe polecenia są poleceniami konsoli tego systemu wydawanymi z poziomem uprawnień superuser’a.

Kopiujemy pobrany obraz na nośnik, czyli najczęściej na kartę SD.

$ dd bs=4M if=2020-02-13-raspbian-buster-lite.img of=/dev/mmcblk0 conv=fsync

Nazwę urządzenia karty SD możemy po jej włożeniu do czytnika sprawdzić poleceniami:

$ dmesg  | tail -10 
$ fdisk -l

Montujemy system plików z przygotowanej karty,

$ mkdir pi_disk
$ mount /dev/mmcblk0p2 pi_disk/

i dopisujemy własną sieć WiFi i hasło do konfiguracji wpa_supplicant’a. Dzięki temu nasz system będzie mógł się połączyć do sieci WiFi już przy pierwszym uruchomieniu. Możemy tu wpisać sieć AP udostępnianą z naszego telefonu. Korzystanie z sieci wystawianej przez telefon przyda nam się potem jak będziemy z całym zestawem „na mieście”.

$ cd pi_root/etc/wpa_supplicant/
$ echo -e "country=PL\n" >> wpa_supplicant.conf
$ wpa_passphrase mojehiperwifi "***************" >> wpa_supplicant.conf
$ umount /dev/mmcblk0p2

W dalszej kolejności montujemy partycje boot i tworzymy na niej pusty plik ssh, co powoduje start sshd przy uruchomieniu systemu.

$ mount /dev/mmcblk0p2 pipi_disk/
$ > pi_disk/ssh
$ umount /dev/mmcblk0p2

Przekładamy kartę do Raspberry Pi i podłączamy zasilanie. Jeżeli wszystko poszło dobrze, to po sprawdzeniu jakie IP przydzielił przez dhcp nasz telefon, możemy zalogować do systemu przez ssh. Nie musimy podłączać klawiatury i monitora.
Standardowo po zalogowaniu, wykonujemy aktualizację systemu do najnowszej wersji i doinstalowujemy pakiety, które będą potrzebne nam za chwilę:

$ apt-get update
$ apt-get upgrade
$ apt-get install lshw git

Wpinamy w port USB kartę Alfa przygotowaną dla naszego zestawu. Od razu widać sprzęt na porcie USB,

$ dmesg | tail -3
 [ 3175.537454] usb 1-1.1.2: Product: 802.11n NIC
 [ 3175.537463] usb 1-1.1.2: Manufacturer: Realtek
 [ 3175.537472] usb 1-1.1.2: SerialNumber: 123456
$ sudo lsusb | grep Realtek
 Bus 001 Device 003: ID 0bda:8812 Realtek Semiconductor Corp. RTL8812AU 802.11a/b/g/n/ac 2T2R DB WLAN Adapter

widać urządzenie USB ale nie widać nowej karty sieciowej w systemie:

$ ip link 
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN mode DEFAULT group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
2: eth0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc mq state DOWN mode DEFAULT group default qlen 1000
    link/ether dc:a6:32:*:*:* brd ff:ff:ff:ff:ff:ff
3: wlan0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP mode DORMANT group default qlen 1000
    link/ether dc:a6:32:*:*:* brd ff:ff:ff:ff:ff:ff

Oczywiście brakuje nam sterownika dla karty, który musimy zainstalować z dodatkowych źródeł, np. z aircrack-ng, którego też będziemy później używać:

$ sudo git clone https://github.com/aircrack-ng/rtl8812au
$ cd rtl8812au
$ more README.md

Dalej zgodnie z sekcją Raspberry Pi w README.md, doinstalowujemy kolejne pakiety i ustawiamy architekturę dla której będziemy kompilować sterownik:

$ apt-get install bc raspberrypi-kernel-headers dkms 
$ sed -i 's/CONFIG_PLATFORM_I386_PC = y/CONFIG_PLATFORM_I386_PC = n/g' Makefile 
$ sed -i 's/CONFIG_PLATFORM_ARM64_RPI = n/CONFIG_PLATFORM_ARM64_RPI = y/g'

I instalujemy sterownik (moduł kernela):

$ ./dkms-install.sh

Jeżeli przy kompilacji wystąpił opisany błąd:

Makefile In addition, if you receive an error message about unrecognized command line option ‘-mgeneral-regs-only’ (i.e., Raspbian Buster)

to dodatkowo należy wykonać zmianę:

$ sed -i 's/^dkms build/ARCH=arm dkms build/' dkms-install.sh 
$ sed -i 's/^MAKE="/MAKE="ARCH=arm\ /' dkms.conf

Teraz nasz system widzi już nowe urządzenie sieciowe:

$ ip link show wlan1
 4: wlan1:  mtu 2312 qdisc mq state UP mode DORMANT group default qlen 1000
     link/ether 00:c0:ca:*:*:* brd ff:ff:ff:ff:ff:ff

Sprawdzimy jeszcze szybko czy urządzenie i sterownik obsługują „monitor mode”, który to tryb będzie konieczny do prowadzenia nasłuchu:

$ ip link set wlan1 down && iw dev wlan1  set type monitor && ip link set wlan1 up
$ iwconfig wlan1
 wlan1     unassociated  Nickname:""
           Mode:Monitor  Frequency=2.447 GHz  Access Point: Not-Associated   
           Sensitivity:0/0  
           Retry:off   RTS thr:off   Fragment thr:off
           Encryption key:off
           Power Management:off
           Link Quality:0  Signal level:0  Noise level:0
           Rx invalid nwid:0  Rx invalid crypt:0  Rx invalid frag:0
           Tx excessive retries:0  Invalid misc:0   Missed beacon:0

Instalujemy wspomnianego aircrack-ng, ale nie z repozytorium systemowego tylko najbardziej aktualną wersję ze źródeł na GitHubie. Pobieramy źródła:

$ git clone https://github.com/aircrack-ng/aircrack-ng

Instalujemy kolejne pakiety potrzebne do kompilacji źródeł aircrack-ng oraz inne do dalszych czynności.

$ apt-get install build-essential autoconf automake libtool pkg-config libnl-3-dev libnl-genl-3-dev libssl-dev ethtool shtool rfkill zlib1g-dev libpcap-dev libsqlite3-dev libpcre3-dev libhwloc-dev libcmocka-dev hostapd wpasupplicant tcpdump screen iw usbutils

Prosta kompilacja aircrack-ng:

$ cd aircrack-ng
$ autoreconf -i
$ ./configure
$ make
$ make install

ale testowe uruchomienie airodump-ng kończy się błędem:

$ airodump-ng wlan1
 airodump-ng: error while loading shared libraries: libaircrack-osdep-1.6.0.so: cannot open shared object file: No such file or directory

Jeszcze musimy zrobić dowiązania do nowych bibliotek współdzielonych i wszystko działa już prawidłowo:

$ ldconfig 
$ airodump-ng wlan1

Mam sprzęt gotowy ale możemy jeszcze go trochę usprawnić. Włączając Pi z wpiętą w port USB kartą „alfa” może nam się przytrafić, że otrzyma ona alias wlan0 a kolejny wlan1 przypadnie karcie wbudowanej. My jednak chcemy, żeby wbudowana karta zawsze służyła do łączności a zewnętrzna, podpięta przez USB, do nasłuchu. Dlatego powiążemy na stałe karty z aliasami, tworząc plik /etc/udev/rules.d/70-persistent-net.rules z zawartością:

$ cat /etc/udev/rules.d/70-persistent-net.rules
 SUBSYSTEM=="net", ACTION=="add", DRIVERS=="?", ATTR{address}=="dc:a6:32:*:*:*" , ATTR{dev_id}=="0x0", ATTR{type}=="1", KERNEL=="wlan", NAME="wlan0"
 SUBSYSTEM=="net", ACTION=="add", DRIVERS=="?", ATTR{address}=="00:c0:ca:*:*:*" , ATTR{dev_id}=="0x0", ATTR{type}=="1", KERNEL=="wlan", NAME="alfa"

Od teraz nasza karta zewnętrzna będzie się nazywała alfa, a wbudowana będzie miała alias wlan0. Oczywiście w pliku należy wpisać prawidłowe maki swoich kart.

Ustawiamy wpa_supplicant’a tak, żeby system łączył się z siecią WiFi naszego telefonu jedynie przez interfejs wlan0.

$ mv /etc/wpa_supplicant/wpa_supplicant.conf /etc/wpa_supplicant/wpa_supplicant-wlan0.conf

Po reboot mamy już wymaganą konfigurację:

$ ip link
 3: wlan0:  mtu 1500 qdisc pfifo_fast state UP mode DORMANT group default qlen 1000
     link/ether dc:a6:32:*:*:* brd ff:ff:ff:ff:ff:ff
 4: alfa:  mtu 2312 qdisc mq state UP mode DEFAULT group default qlen 1000
     link/ether 00:c0:ca:*:*:* brd ff:ff:ff:ff:ff:ff

Na koniec wyłączamy dhcp na interfejsie alfa:

$ echo "denyinterfaces alfa" >> /etc/dhcpcd.conf

GPS ze smartfona via bluetooth

Do wardrivingu potrzebny będzie nam jeszcze GPS. Można dokupić specjalny moduł GPS do Raspberry ale nawet u chińczyka kosztuje on więcej niż kilka dolarów. Lepiej użyć GPS z telefonu przez który będziemy kontrolować nasz zestaw. Przy użyciu jednej z darmowych aplikacji z Google store, lokalizację z GPS możemy udostępniać ze smartfona do innych urządzeń z wykorzystaniem bluetooth. Ja wybrałem aplikacje o bardzo enigmatycznej nazwie „GPS 2 Bluetooth”.

Wcześniej wypada jednak zparować Raspberry Pi z naszym telefonem. Proces z użyciem bluetoothctl wygląda jak poniżej:

$ bluetoothctl 
 Agent registered
 [bluetooth]# show
 Controller DC:A6:32:*:*:* (public)
         Name: raspberrypi
         Alias: raspberrypi
         Class: 0x00000000
         Powered: yes
         Discoverable: no
         Pairable: yes
         UUID: Generic Attribute Profile (00001801-0000-1000-8000-00805f9b34fb)
         UUID: A/V Remote Control        (0000110e-0000-1000-8000-00805f9b34fb)
         UUID: PnP Information           (00001200-0000-1000-8000-00805f9b34fb)
         UUID: A/V Remote Control Target (0000110c-0000-1000-8000-00805f9b34fb)
         UUID: Generic Access Profile    (00001800-0000-1000-8000-00805f9b34fb)
         Modalias: usb:v1D6Bp0246d0532
         Discovering: no
 [bluetooth]# scan
 Missing on/off argument
 [bluetooth]# scan on
 Discovery started
 [CHG] Controller DC:A6:32:*:*:* Discovering: yes
 [NEW] Device A4:50:46:*:*:* qwerty
 [bluetooth]# pair  A4:50:46:*:*:*
 Attempting to pair with A4:50:46:*:*:*
 [CHG] Device A4:50:46:*:*:* Connected: yes
 Request confirmation
 [agent] Confirm passkey 530418 (yes/no): yes
 [CHG] Device A4:50:46:*:*:* Modalias: bluetooth:v038Fp1200d1436
 [CHG] Device A4:50:46:*:*:* UUIDs: 00001105-0000-1000-8000-00805f9b34fb
 [CHG] Device A4:50:46:*:*:* UUIDs: 0000110a-0000-1000-8000-00805f9b34fb
 [CHG] Device A4:50:46:*:*:* UUIDs: 00001132-0000-1000-8000-00805f9b34fb
 [CHG] Device A4:50:46:*:*:* ServicesResolved: yes
 [CHG] Device A4:50:46:*:*:* Paired: yes
 Pairing successful
 [CHG] Device A4:50:46:*:*:* ServicesResolved: no
 [CHG] Device A4:50:46:*:*:* Connected: no
 [bluetooth]# connect A4:50:46:*:*:*
 Attempting to connect to A4:50:46:*:*:*
 Failed to connect: org.bluez.Error.Failed

Zostawiam tu ten powyższy błąd i jego rozwiązanie bo kosztował on mnie kilka wieczorów. Być może oszczędzę komuś trochę czasu. Po zaglądnięciu do /var/log/daemon.log mamy:

May  3 19:53:02 raspberrypi bluetoothd[487]: a2dp-source profile connect failed for A4:50:46:*:*:*: Protocol not available

Raspbian łącząc się po bluetooth do telefonu, słusznie traktuje go jako urządzenie dźwiękowe, a do tego połączenia potrzebuje serwera dźwięku pulseaudio. Wystarczy go zainstalować, uruchomić i załadować moduł module-bluetooth-discover, żeby połączenie BT poszło bez błędów.

$ apt-get install pulseaudio
$ apt-get install pulseaudio-module-bluetooth
$ pulseaudio --start
$ pactl load-module module-bluetooth-discover
$ bluetoothctl 
 Agent registered
 [bluetooth]# paired-devices 
 Device A4:50:46:*:*:* qwerty
 [bluetooth]# connect A4:50:46:*:*:*
 Attempting to connect to A4:50:46:*:*:*
 [CHG] Device A4:50:46:*:*:* Connected: yes
 Connection successful

Uruchamiamy aplikację na telefonie. Narzędziem sdptool możemy zobaczyć co telefon wystawia za pośrednictwem BT. Gdzieś w długiej liście serwisów powinniśmy znaleźć ten o nazwie GPS2BT2, a przy nim taką informację jak channle. W moim wypadku jest to numer 4.

$ sdptool browse A4:50:46:*:*:*
 Browsing A4:50:46:*:*:* …
 Service Name: GPS2BT2
 Service RecHandle: 0x1000c
 Service Class ID List:
   "Serial Port" (0x1101)
 Protocol Descriptor List:
   "L2CAP" (0x0100)
   "RFCOMM" (0x0003)
     Channel: 4
 Profile Descriptor List:
   "Serial Port" (0x1101)
     Version: 0x0102

Tworzymy nowy port serial RS-232 dla połączenia radiowego bluetooth. 4 na końcu polecenia oznacza numer kanału, ten który sprawdzaliśmy w poprzednim kroku.

$ rfcomm connect /dev/rfcomm0 A4:50:46:*:*:* 4 

Potrzebny nam będzie jeszcze daemon dla GPS. Instalujemy kolejne dwa pakiety.

$ apt-get install gpsd gpsd-clients

Sprawdzamy czy na serial porcie możemy odczytać pozycję GPS podawaną z telefonu.

$ gpsmon /dev/rfcomm0

Zatrzymujemy domyślną instancję gpsd i uruchamiamy własną korzystającą z danych czytanych z portu /dev/rfcomm0

$ systemctl stop gpsd.socket && gpsd -b /dev/rfcomm0
Sprawdzamy czy wszystko działa jak powinno.
$ netstat -plan | grep gpsd
 tcp        0      0 127.0.0.1:2947          0.0.0.0:*               LISTEN      4007/gpsd           
 tcp6       0      0 ::1:2947                :::*                    LISTEN      4007/gpsd           
 unix  3      [ ]         STREAM     CONNECTED     27506    4007/gpsd  
$ gpsmon 127.0.0.1:2947

Przełączamy kartę alfa w tryb monitor i uruchamiamy airodump-ng, który będzie prowadził nasłuch i zapisywał złapane pakiety do plików. Nazwa plików będzie zawierała czas uruchomienia programu. Najbardzie przydatne informację znajdziemy potem w formacie kismet.

$ ip link set alfa down && iw dev alfa  set type monitor && ip link set alfa up
$ airodump-ng --gpsd -i -o gps -o csv -o kismet -w `date '+%Y.%m.%d-%H:%M'` alfa

Całość możemy uruchamiać np. takim skryptem /etc/init.d/sniff_wifi.sh automatycznie po starcie systemu po wykonaniu:

$ update-rc.d sniff_wifi.sh default


Facebook Comments

Dodaj komentarz

Twój adres email nie zostanie opublikowany. Wymagane pola są oznaczone *