git.sesse.net Git - wardrive/blob - bt-remote.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <unistd.h>
   4 #include <sys/types.h>
   5 #include <sys/socket.h>
   6 #include <bluetooth/bluetooth.h>
   7 #include <bluetooth/rfcomm.h>
   8 #include <sys/ioctl.h>
   9 #include <netinet/in.h>
  10 #include <arpa/inet.h>
  11
  12 int parse_packet(unsigned char *buf, unsigned bytes, int sock)
  13 {
  14         char *ptr;
  15         int ret = 0;
  16         buf[bytes + 1] = 0;
  17
  18         ptr = strtok((char *)buf, "\n");
  19         while (ptr) {
  20                 if (strncmp(ptr, "*NETWORK: ", 10) == 0) {
  21                         char bssid[32];
  22                         int crypted, weak, signal, noise;
  23                         if (sscanf(ptr, "*NETWORK: %s %d %d %d %d", bssid, &crypted, &weak, &signal, &noise) != 5) {
  24                                 printf("Couldn't parse NETWORK packet\n");
  25                         } else {
  26                                 if (strcmp(bssid, "00:0D:54:A0:27:7F") == 0) {
  27                                         static int last_crypted = 0;
  28                                         char str1[64], str2[64], str3[64], str4[64];
  29                                         short len;
  30                                         sprintf(str1, "Crypted: %d", crypted);
  31                                         sprintf(str2, "Weak IVs: %d", weak);
  32                                         sprintf(str3, "Signal level: %d dB", signal);
  33                                         sprintf(str4, "Noise level: %d dB", noise);
  34
  35                                         write(sock, "\000\001", 2);
  36                                         len = htons(2 * 4 + strlen(str1) + strlen(str2) + strlen(str3) + strlen(str4));
  37                                         write(sock, (char*)&len, 2);
  38
  39                                         len = htons(strlen(str1));
  40                                         write(sock, (char*)&len, 2);
  41                                         write(sock, str1, strlen(str1));
  42
  43                                         len = htons(strlen(str2));
  44                                         write(sock, (char*)&len, 2);
  45                                         write(sock, str2, strlen(str2));
  46
  47                                         len = htons(strlen(str3));
  48                                         write(sock, (char*)&len, 2);
  49                                         write(sock, str3, strlen(str3));
  50
  51                                         len = htons(strlen(str4));
  52                                         write(sock, (char*)&len, 2);
  53                                         write(sock, str4, strlen(str4));
  54
  55                                         // vibrate 250ms for every 10k packets
  56                                         if (crypted/10000 != last_crypted/10000) {
  57                                                 write(sock, "\000\016\000\002\000\372", 6);
  58                                         }
  59
  60                                         // vibrate 1750ms extra for every 100k packets
  61                                         if (crypted/100000 != last_crypted/100000) {
  62                                                 write(sock, "\000\016\000\002\006\326", 6);
  63                                         }
  64
  65                                         last_crypted = crypted;
  66
  67                                         ret = 1;
  68                                 }
  69                         }
  70                 }
  71                 ptr = strtok(NULL, "\n");
  72         }
  73
  74         return ret;
  75 }
  76
  77 int main(int argc, char **argv)
  78 {
  79         struct sockaddr_rc loc_addr = { 0 }, rem_addr = { 0 };
  80         struct sockaddr_in addr;
  81         unsigned char buf[1024] = { 0 };
  82         char initstr[] = "!1 ENABLE NETWORK bssid,cryptpackets,weakpackets,signal,noise\n";
  83         int s, client, kismet, bytes_read;
  84         size_t opt = sizeof(rem_addr);
  85         unsigned one = 1;
  86
  87         // allocate socket
  88         s = socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
  89
  90         // bind socket to port 1 of the first available
  91         // local bluetooth adapter
  92         loc_addr.rc_family = AF_BLUETOOTH;
  93         loc_addr.rc_bdaddr = *BDADDR_ANY;
  94         loc_addr.rc_channel = (uint8_t) 1;
  95         bind(s, (struct sockaddr *)&loc_addr, sizeof(loc_addr));
  96
  97         // put socket into listening mode
  98         listen(s, 1);
  99
 100         // accept one connection
 101         client = accept(s, (struct sockaddr *)&rem_addr, &opt);
 102
 103         ba2str( &rem_addr.rc_bdaddr, buf );
 104         fprintf(stderr, "accepted connection from %s\n", buf);
 105         memset(buf, 0, sizeof(buf));
 106
 107         ioctl(client, FIONBIO, &one);
 108
 109         // connect to kismet
 110         kismet = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
 111         addr.sin_family = AF_INET;
 112         addr.sin_addr.s_addr = inet_addr("127.0.0.1");
 113         addr.sin_port = htons(2501);
 114
 115         if (connect(kismet, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
 116                 perror("connect()");
 117                 exit(1);
 118         }
 119         ioctl(kismet, FIONBIO, &one);
 120         write(kismet, initstr, strlen(initstr));
 121
 122         printf("Connected to Kismet.\n");
 123
 124         // read data from the client
 125         for ( ;; ) {
 126                 int flag = 1;
 127
 128                 // gobble up data from the phone
 129                 bytes_read = read(client, buf, sizeof(buf) - 1);
 130                 if( bytes_read > 0 ) {
 131                         unsigned i;
 132                         printf("received [");
 133                         for (i = 0; i < bytes_read; ++i)
 134                                 printf("0x%02x ", buf[i]);
 135                         printf("]\n");
 136                 }
 137
 138                 // read from kismet
 139                 bytes_read = read(kismet, buf, sizeof(buf));
 140                 if( bytes_read > 0 ) {
 141                         unsigned i;
 142                         for (i = 0; i < bytes_read; ++i)
 143                                 printf("%c", buf[i]);
 144
 145                         flag = parse_packet(buf, bytes_read, client);
 146                 }
 147
 148                 if (flag) {
 149                         // alive?
 150                         write(client, "\000\012\000\000", 4);
 151                         sleep(1);
 152                 }
 153         }
 154
 155         // close connection
 156         close(client);
 157         close(s);
 158         return 0;
 159 }
 160