committing page revision 1

1 files changed, 352 insertions, 0 deletions

diff --git a/pages/hackabike.md b/pages/hackabike.md
new file mode 100644
index 00000000..47036744
--- /dev/null
+++ b/pages/hackabike.md
@@ -0,0 +1,352 @@
+title: hackabike
+date: 2009-11-02 01:04:00 
+updated: 2009-11-02 01:10:40 
+author: admin
+tags: 
+
+Schon immer mal nachts ohne Transportmöglichkeit in einem fremden Bezirk aufgewacht? "Mal schnell" ein Fahrrad benötigt? In Berlin und anderen Großstädten Deutschlands bietet Die Deutsche Bahn mit dem Call-A-Bike Service Abhilfe.
+
+<!-- TEASER_END -->
+
+**Kurzeinführung in das CallABike System**Als Kunde ruft man die
+CallABike-Zentrale und gibt per DTMF-Wahl die vierstellige Radnummer
+durch. Von der Zentrale erhält man dann den vierstelligen Code, mit dem
+man das CallABike-Fahrad öffnen kann. Zur Sicherheit wird man nach dem
+Anruf von der Zentrale zurückgerufen. Die letzten vier Ziffern des
+Rückrufes enthalten nochmal den Code - annehmen muss man den Anruf
+deswegen nicht.\
+\
+Jetzt läuft die Uhr und der Kunde muss pro Minute 6 Cent bezahlen (mit
+Bahncard nur 4 Cent). Wenn der Kunde das CallABike einfach mal schnell
+abstellen will (z.B. für einen kurzen Einkauf), kann man das CallABike
+abschließen und im Display auf ‘Nicht Abgeben’ tippen. Es ist sozusagen
+kurz geparkt. Danach kann man das CallABike mit dem gleichen Code wie
+beim ersten Mal öffnen. Das kann man so oft wiederholen, wie man möchte.
+Die Zeit, die man bezahlen muss, läuft natürlich weiter.\
+\
+Wenn der Kunde das CallABike dann endgültig abgeben will, muss er beim
+Schließen auf ‘Abgeben’ tippen; das CallABike gibt einem dann den
+Rückgabecode. Mit diesem Code kann man gegenüber der Zentrale
+‘beweisen’, dass man das CallABike wirklich wieder abgeschlossen hat.
+Man ruft jetzt einfach wieder die Zentrale an und gibt den Rückgabecode
+durch. Danach muss man noch die Straßenecke auf Band sprechen, an der
+man das CallABike abgestellt hat. Die Mietzeit wird damit dann auch
+beendet.\
+\
+Es ist auch möglich, zwei Räder mit einem Anruf auszuleihen oder
+abzugeben. Wenn der Kunde in seiner Nähe kein CallABike-Rad findet, kann
+er auch die Zentrale anrufen und fragen, wo das nächste CallABike- Rad
+steht. Ein Servicemitarbeiter der Bahn schaut dann in der Datenbank nach
+und gibt den Standort des nächstgelegenen CallABike-Rads durch.\
+[Offizielle CallABike Webseite](http://www.callabike.de/i_fahrrad.html)\
+\
+..."Es gibt natürlich auch andere Zeitgenossen, die haben, schon aus
+sportiven Gründen, allerlei versucht, um die Standfestigkeit der
+Hardware oder das elektronische Prinzip der eingebauten Mikrochips und
+Prozessoren zu ergründen. Sie rückten dem Schloss mit Schraubenziehern
+und gängigen Imbusschlüsseln zu Leibe. Sie versuchten ihr Glück mit
+Brechstange, Vorschlaghammer, sogar mit der Motorflex. Oder, ganz Smart,
+mit Laptop, mit Dechiffrierprogrammen, auch mit Fangfragen an das
+Wartungspersonal. Doch vergebens! Wieder lächelt Reth, der einst erste
+Ausflüge auf einem grünen Puky-Rad unternahm, sich heutzutage aber als
+“postmoderner Urbaniker”, denn als “Fahrradfreak” versteht. Er lächelt
+und sagt: “Erst diese Technik macht uns zum weltweit einzigen
+stationsunabhängigen Stadtradsystem. Der Code ist nicht zu knacken und
+darauf sind wir richtig stolz.”... Kurzer Auszug eines Interviews mit
+einem Call A Bike Techniker im Magazin Mobil der Deutschen Bahn
+
+## Artikel:
+
+Im November 2003 wurde uns ein CallABike ‘zugetragen’, das nicht richtig
+abgeschlossen wurde. Dieses musste erstmal als Testobjekt herhalten. Die
+meisten dachten, dass in dem Schlosskasten GPS oder sonstiger Funk
+enthalten sei, nach dem öffnen war hiervon jedoch nix zu sehen. Um die
+Schrauben der Schlosskästen zu öffnen, benötigt man nur ein Torx TR
+(Tamper Resistant). In dem Kasten ohne Display ist die Stromversorgung
+durch Batterien sichergestellt (3x 1.5V Mono). Die beiden Kästen sind
+durch eine Art Bügel miteinander verbunden. In diesem Bügel befindet
+sich ein sechspoliges Kabel für den Strom und zwei Spulen. Damit kann
+geprüft werden, ob das Schloss wirklich geschlossen ist, oder einfach
+kein oder nur irgendein anderer Bolzen zum Verschließen genommen wurde.\
+\
+Der Kasten mit dem Display enthält den Exzentermotor zum öffnen des
+Schlosses, zwei Taster (Mikroschalter) und ein kapazitives 5x2-Touchpad.
+Die Hauptlogik sitzt unter dem Display. Sie ist nochmal durch eine
+Metallplatte abgesichert, welche nur die Kabel zum Display/Touchpad
+durchlässt. Damit wird der Motor und der Verschlussmechanismus vor einer
+Attacke durchs Display geschützt.\
+\
+Die gesamte Platine ist mit schwarzem Silikon übergossen, das man
+erstmal runterkratzen muss. Das geht prima mit einer Mess-Spitze. Außer
+einer streichholzschachtelgroßen Platine (Rückseite Datenschleuder 82),
+auf der ein [Atmel
+AT90S8535](http://www.atmel.com/dyn/products/product_card.asp?family_id=607&family_name=AVR+8%2DBit+RISC+&part_id=2000)
+(8-Bit-Risc-Prozessor, 4x8-IO-Pins, 8KB Flash, 512-Bytes-EEProm und
+512-Bytes-RAM) \[1\], ein paar LEDs (rot, grün und IR) und IR-Receiver
+aufgebracht sind, enthält der Kasten noch ein paar andere elektrische
+Bauteile (Motor, Schalter und ein Beeper). Es ist auch ein
+Neigungssensor vorhanden, aber im Code wird er nicht benutzt. Daher
+bestand keine Gefahr, uns zu orten. Es wurden ein paar Bilder von der
+Aktion gemacht, aber dann lag die Technik erstmal zwei Monate einsam in
+einer Kiste, weil wir es nicht geschafft haben, das CallABike zu booten.
+Es dauerte eine Weile, bis wir merkten, dass das System nach dem Booten
+durch ein Infrarot-Signal aktiviert werden muss. Das war mehr oder
+weniger Zufall.\
+\
+Wenn man eine normale Glühlampe benutzt, um besser sehen zu koennen,
+piepte die Elektronik gelegentlich scheinbar unmotiviert. Wie sich
+später herausstellte, reichte der durch die Glühlampe emittierte
+IR-Anteil aus, um den IR-Receiver zu triggern und den Bootvorgang
+fortzusetzen. Beim Booten testet sich das System selbst, und der Empfang
+eines Infrarot Signals gehört eben dazu. Im Zuge fortschreitender
+Professionalisierung™ wurde in der Folgezeit die Glühlampe durch ein
+Infrarot-Photon-Micro-Light ersetzt. Bei unserer weiteren Analyse des
+Systems begannen wir damit, alle Anschlüsse des Atmel durchzumessen, um
+uns einen ungefähren Schaltplan zu erstellen (siehe Bild). Die
+Datenblätter für den Atmel und das verwendete Display haben wir uns aus
+dem Web besorgt.\
+\
+Im Januar hatte einer der Beteiligten dann endlich eine Idee, wie weiter
+vorzugehen sei. Auf der Platine war uns eine unbenutzte 6-polige
+Steckerleiste aufgefallen, und wie sich herausstellte, handelt es sich
+dabei um den ISP-Connector (In System Programming) des Atmel. Daran
+schlossen wir dann ein Atmel-Developer-Board
+[STK500](http://www.atmel.com/dyn/products/tools_card.asp?tool_id=2735)
+an. Zum Auslesen wurde hauptsächlich das freie
+[UISP](http://savannah.nongnu.org/projects/uisp/) (“Uisp is a tool for
+AVR microcontrollers which can interface to many hardware in-system
+programmers”) benutzt. Die auf dem Atmel vorhandenen
+„Intellectual-Property“-Bits waren in einem undefinierten Zustand,
+deswegen konnten wir das Flash des Atmels mit der 8KB großen Firmware
+auslesen.\
+\
+In den nächsten Wochen waren mehrere Hacker damit beschäftigt, den
+ausgelesenen Assemblercode zu verstehen und zu dokumentieren. Dazu
+verwendeten wir AVR-Studio und [Ida
+Pro](http://www.datarescue.com/idabase/). Den Scramble Code (zum
+berechnen der Ausleih- und Abgabecodes) fanden wir relativ schnell, da
+sich dort eine Menge rotate-und-shift-Befehle befanden. Den
+Initialisierungscode erkannten wir wieder, da wir wussten, dass der
+Motor sich beim Einschalten zweimal herumdreht. So konnten wir das
+gelernte immer wieder an unserem Prototyp auf Richtigkeit überprüfen.\
+\
+Die Ausleih- und Abgabecodes werden durch einen Scrambler generiert, der
+mit einem 16Bit-Counter des CallABikes und einem Zustandswert aufgerufen
+wird. Ein gerader Counterwert erzeugt Ausleihcodes und ein ungerader
+erzeugt die Abgabecodes. Der Scrambler nutzt den Counter und das
+Zustandsbyte, um ein Offset auf ein 1024 Bit großes Feld zu errechnen.
+Dieses Feld ist ein für jedes CallABike eindeutiger binärer String, der
+als der (wahrscheinlich) eindeutige Key des CallABikes bezeichnet werden
+könnte. Von diesem Offset aus werden dann 4x4 Bit genutzt, die die vier
+Ziffern für die Ausleih- und Abgabecodes repräsentieren. Die 16 Bit des
+Counters werden aber schlecht genutzt, denn schon nach 1024 Iterationen
+wiederholen sich die Ausleih- und Abgabecodes. Das bedeutet auch, dass
+es nur 512 Ausleihcodes je CallABike gibt, da es nur 512 gerade Offsets
+gibt die auf den Key (1024 Bit) zeigen können. CallABikes, die wir
+geöffnet haben und die wir wegen der Lockbits nicht auslesen konnten,
+haben wir mit einem Script 511 mal resetten lassen (bei einem Reset
+erhöht sich der Counter immer um zwei). Damit haben wir den
+ursprünglichen Zustand wiederhergestellt, und das CallABike war wieder
+‘in sync’ mit der Zentrale.\
+\
+Wer sich das Display mal genauer angeschaut hat, wird festgestellt
+haben, dass der Zeichensatz ein proportionaler ist. Dazu gibt es im Code
+eine Tabelle, in der die Länge des Zeichens und die Position im Flash
+gespeichert sind. Ein ‘i’ und ein ‘!’ belegen nur ein Byte, wogegen z.B.
+ein ‘w’ sieben Bytes belegt. Die großen Logos und das Zahleneingabefeld
+liegen als 400 Byte große Bitmaps vor. Die lange schwarze Linie im
+CallABike-Logo zeigt die Stärke der Spule im Schloss an. Das haben wir
+nur durch das Code-Auditing herausgefunden.\
+\
+Unser erstes Ziel war es, den aus unserem Disassembler erhaltenen
+Sourcecode so anzupassen, dass nach dem Assemblieren mit dem Commandline
+Tool [Avra](http://avra.sourceforge.net/) (“Assembler for the Atmel AVR
+microcontrollers”) ein EXAKT identisches Binary herauskam. Auf der
+Grundlage dieses Referenzcodes konnten wir dann endlich änderungen
+vornehmen.\
+\
+Nachdem wir uns diese Grundlage geschaffen hatten, konnten wir das
+CallABike mit unserem eigenen Code flashen. Da wir keine Vulnerabilities
+oder Backdoors fanden (jedes CallABike hat einen eigenen Key, der im
+EEPROM gespeichert ist), mit denen man ein CallABike exploiten könnte,
+ohne es aufzuschrauben, kamen wir auf die Idee, uns eine eigene Backdoor
+in den Code zu programmieren. Hört sich eigentlich ganz leicht an, ist
+es aber nicht. Erstmal mussten wir den Code der BAHN optimieren, um uns
+den entsprechenden Platz zu schaffen. Schließlich sollte ja auch noch
+ein Logo mit 400 Bytes von uns in das 8KB große Flash. Den Datenmüll,
+den man über unserem HackABike Logo sehen kann, ist der Backdoor Code.
+Das sparte nochmal ca. 150 Bytes. Außerdem wollten wir nicht, dass man
+mit dem Backdoor Code normalen Kunden, die das Rad nur geparkt
+(verschlossen, aber nicht abgegeben) haben, das ausgeliehene HackABike
+wegschnappen konnte. Das erforderte noch ein paar Zeilen mehr im Code.
+Auch kann man mit unserem Backdoor Code das HackABike nicht ‘parken’, da
+ja der öffner nichts bezahlen muss und deswegen nicht motiviert ist,
+sich weiter um das Rad zu kümmern, und es aber auch niemand anders
+aufmachen könnte. Um das HackABike auch auf größere Entfernung noch von
+seinen unbehandelten Verwandten unterscheiden zu können, haben wir ihm
+eine leicht veränderte Blink-Sequenz beigebracht.\
+\
+Im Verlauf der weiteren Analyse des Codes ist uns aufgefallen, dass das
+CallABike im Abgabecode integriert Statusinformationen an die Zentrale
+durchgeben kann. Je nachdem, in welchem technischen Zustand sich das
+CallABike befindet, kann es unterschiedliche Rückgabecodes - abhängig
+vom bereits erwähnten Zustandsbyte - angeben. Das CallABike kann z.B.
+melden, dass die Batterie nicht mehr lange hält, oder der Motor für das
+Schloss nicht mehr in der richtigen Stellung ist. Wenn man z.B. den
+Schließknopf sieben mal ohne eingeführten Bolzen drückt, liefert der
+Scrambler einen entsprechenden Rückgabecode, der gültig ist, diesen
+Zustand aber für die Zentrale erkennbar anzeigt. Von diesen Codes gibt
+es 52 (eine Matrix aus 4x13).\
+\
+Die Backdoor erlaubt, das HackABike mit einem von uns festgelegten
+Ausleihcode einfach zu öffnen. Wenn man das HackABike dann wieder
+abgibt, ist es ganz normal wieder ausleihbar. Es steht auch wieder der
+Ausleihcode des vorherigen Kunden im Display. Die Zentrale merkt von
+diesem eingeschobenen Ausleihvorgang nichts - außer, dass es an einem
+anderem Ort steht, als es in der Datenbank vermerkt ist. Wenn es dann
+aber wieder normal ausgeliehen und abgestellt wird, ist auch in der
+Zentrale alles wieder in Ordnung.\
+\
+Um ein CallABike in ein HackABike zu verwandeln, mussten wir sechs
+Schrauben auf der Innenseite des Schlosskastens mit dem Display öffnen
+und das Kabel des STK500 an den ISP-Anschluss der Platine stecken.
+Danach haben wir ein Script gestartet, dass das Flash und den EEPROM
+Bereich ausliest. Das EEPROM wird danach mit zurückgesetztem Counter und
+dem Flash mit unserer Backdoor wieder zurückgeschrieben. Damit niemand
+unsere Backdoor auslesen kann, haben wir natürlich noch die Lockbits
+gesetzt. Ein geschulter Hacker brauchte ca. 12 Minuten, um zwei
+CallABikes parallel in HackABikes zu verwandeln. Insgesamt wurden knappe
+10% der in Berlin verteilten CallABikes in ein HackABike umgebaut indem
+ihnen eine neue firmware verpasst wurde. Da UISP das Setzen der Lockbits
+nicht korrekt unterstützte, mussten wir das erstmal einbauen. Dazu haben
+wir den Output von AVR-Studio mit einem serial sniffer mitgelesen und
+uns die entsprechenden Kommandos für das STK500 rausgesucht und in UISP
+eingebaut.\
+\
+Abschließend ist festzustellen, dass das technische Design des CallABike
+in unseren Augen sehr gut ist. Jedes CallABike hat vermutlich einen
+eigenen 1024 Bit Key, der benötigt wird, um die Abgabe- und Ausleihcodes
+berechnen zu können. Dazu muss vermutlich das CallABike geöffnet und
+ausgelesen werden. Es wurde nur versäumt, die Lockbits zu setzen, um die
+Firmware vor dem Auslesen zu schützen. Unsere Attacke ist von den
+verbrauchten Mannstunden wohl mehr Wert als ein paar Dutzend CallABikes.
+
+    EEPROM Content:
+
+    0x0000 - 0x0001 unused
+    0x0002          lock_sensor_calibration
+    0x0003 - 0x0019 unused
+    0x001A - 0x001B 16bit counter (scrambler)
+    0x001C          unused
+    0x001D - 0x001F CallABike Number
+    0x0020 - 0x009F 128 Byte Random (Key)
+    0x00A0 - 0x00A2 first three bytes of key again
+    0x00A3 - 0x00AF unused
+    0x00B0 - 0x01FF textmessages for display
+                    
+
+    bikecounter: 0x015E
+    EEPROM belongs to bike 3856
+
+    Counter 0x0162:  3042 9843 5360      <-- rentcode
+
+        -00- -01- -02- -03- -04- -05- -06- -07- -08- -09- -10- -11- -12- -13-
+    00: 8584 7572 6970 4597 9119 4285 2144 0277 3197 0072 5545 6487 6341 9664
+    01: 5244 2345 5463 6065 9493 2971 9352 5402 5519 4579 8355 9533 9245 4926
+    10: 6615 7508 8159 7355 8125 3632 2920 4348 0484 7784 0084 6154 8905 6742
+    11: 6234 7953 4741 7386 8181 2930 6280 8658 6805 5432 4092 7161 2070 8554
+
+    Counter 0x0164:  7240 7043 9766      <-- rentcode
+
+        -00- -01- -02- -03- -04- -05- -06- -07- -08- -09- -10- -11- -12- -13-
+    00: 1542 5463 4821 7206 8181 5293 5100 8370 7662 7831 6561 1071 9350 7554
+    01: 8480 7640 5094 4420 7470 5025 6472 0596 9260 5499 4274 0341 7092 7363
+    10: 6369 3545 6991 9042 0121 7702 7931 5600 6755 8264 9063 9596 6918 8761
+    11: 4254 0960 8294 7529 9793 4954 5455 9345 0183 3995 4992 5949 4392 9538
+
+    Here you see the open and close pins of the bike 3856 with
+    the counter at 0x0162
+    At first the Customer gets the open pin 3042. When the customer
+    closes the lock and everything is ok he gets the return code 8584.
+    When for example the battery (-01-) is exhausted he gets the return code
+    7572.
+                    
+
+    The following commands are possible via infrared:
+    0x5B read bikenumber
+    0xCE calibrate coil
+    0xC5 read RAM from 0x00AD
+
+    after transmit of the first 32 bytes of the key
+    0xCA enable watchdog (reboot)
+    0xC8 write and read the key of the EEPROM
+    0xCD write and read other parts of the EEPROM
+                    
+
+    //Code zum Generieren der Abgabe/Ausleihcodes bei gegebenem Key aus dem eeprom
+
+    unsigned char g_key[4];
+
+    void scrambler(uchar param, long counter)
+    {
+         long bitoffset;
+         uchar r21 = param, r28 = 1;
+         short r27_26 = counter, short r31_30;
+         r28 <<= r27_26 & 7;
+         r27_26 += r21;
+         r27_26 &= 0x3ff;
+         r31_30 = r27_26;
+         r27_26 <<= 5;
+         r27_26 -= r31_30;
+         r27_26 &= 0x3ff;
+         r27_26 += r28;
+         r27_26 &= 0x3ff;
+         bitoffset = r27_26 & 7;
+         r27_26 >>= 3;
+         r27_26 += 0x20;
+         r27_26 &= 0xff;
+         fillkey(r27_26,bitoffset);
+    }
+
+    void fillkey(long address, long bitoffset)
+    {
+         uchar r16;
+         long fullkey;
+         fullkey = eeprom[address++] << 16;
+         fullkey += eeprom[address++] << 8;
+         fullkey += eeprom[address++];
+         fullkey >>= bitoffset;
+         r16 = fullkey          & 0xf;
+         if(r16 >= 10) r16 -= 10;
+         g_key[3] = r16;
+         r16 = (fullkey >> 4 ) & 0xf;
+         if(r16 >= 10) r16 -= 6;
+         g_key[2] = r16;
+         r16 = (fullkey >> 8 ) & 0xf;
+         if(r16 >= 10) r16 -= 10;
+         g_key[1] = r16;
+         r16 = (fullkey >> 12) & 0xf;
+         if(r16 >= 10) r16 -= 6;
+         g_key[0] = r16;
+    }
+
+    //Fürs CallABike mit der Nummer 2883 z.B.:
+    unsigned char eeprom[ ] =
+    {
+        0x5A,0xD5,0xAD,0x6B,0xFD,0xD7,0x34,0x78,
+        0xB3,0x03,0x22,0x13,0x61,0x23,0xAD,0xFE,
+        0x51,0x6E,0xAA,0xA2,0xD4,0xB7,0xBA,0xC0,
+        0x78,0x9A,0x84,0x55,0x2A,0xB9,0x6E,0xBC,
+        0x33,0x15,0x2C,0x97,0x33,0x98,0x4B,0x78,
+        0x43,0xE5,0x20,0xD5,0x1C,0x1C,0x75,0x12,
+        0x2A,0x91,0x17,0xFC,0x0C,0x61,0x31,0x31,
+        0x50,0x6D,0xFD,0x5C,0xC5,0x60,0x8D,0xE0,
+        0x0A,0xF2,0x85,0xF1,0x3B,0xA3,0xBD,0x74,
+        0xF3,0xD4,0x9E,0xBB,0x45,0x95,0x69,0x24,
+        0x79,0x36,0x9A,0xA6,0x66,0x96,0xFB,0xE8,
+        0x5D,0x38,0x34,0x28,0xC0,0x51,0x3B,0x18,
+        0x46,0xCA,0xD9,0xE3,0xD7,0xC8,0x86,0x01,
+        0x11,0x60,0xF2,0xF0,0xA4,0xA4,0xEF,0x16,
+        0x3E,0xBE,0xB9,0x1F,0xA8,0xF9,0x61,0x0B,
+        0xD6,0x7F,0x75,0xE7,0xF4,0x31,0x3F,0x6B
+    };