ChipcardLab

Aus Chaos Computer Club Berlin
Wechseln zu:Navigation, Suche

ChipcardLab

chipcardhackers playground.jpg

Das ChipcardLab ist ein modulares Entwicklungs und Analyseset für ISO und kompatible Chipkarten. Es ist modular erweiterbar und kann vielseitig eingesetzt werden. Eigene Ideen können mit minimalem Aufwand schnell ausprobiert werden. Das Projekt wendet sich in erster Linie an Einsteiger ohne Vorerfahrung. Das offene Konzept soll dazu einladen sich auf die Thematik Chipkarten aktiv einzulassen. Die Vorgefertigte Software und die bereits erstellte und getestete Platine sorgen für einen sicheren Start in die Welt der Chipkarten.

Die Hardware:

ChipcardLabSet.jpg

  • Das Cardboard:

Die Basis bildet das Cardboard, auf welchem sich eine ISO/Anfor Kontaktiereinheit und ein 25 Pol Sub-D Stecker befindet. Sowol die ISO, als auch die Anfor Kontakte sind auf Steckleisten an der Seite geführt und normgerecht beschriftet. Bei dem Sub-D Stecker wurden alle Parallelport relevanten Pins ebenfalls auf die Steckleisten geführt und normgerecht beschriftet. So hält man bereits mit der Cardboard Platine ein Werkzeug in der Hand um z.B.: mit ein par Drähten eine Chipkarte am Parallelport eines PCs anzuschließen und zu lesesn bzw. zu beschreiben. Die Stiftleisten sind weiterhin dazu geeignet Module aufzunehmen.

  • Die Kartenimitation:

Die Kartenimitation dient dazu das ChipcardLab direkt mit einem Cipkartenterminal zu verbinden um z.B.: eine Chipkarte zu emulieren bzw. den Datenverkehr zwischen Chipkartenterminal und Karte zu debugzwecken aufzuzeichnen. Es existiert eine Imitation für ISO-Karten (Überlänge) und SIM-Karten.

  • Die SIM-Kartenkontaktiereinrichtung.

Da SIM-Karten nicht in die normale Kontaktiereinrichtung passen gibt es eine Kontaktiereinrichtung die an die Kartenimitation angeschlossen werden kann. Auf diese Weise wird die Sim-Karte adaptiert. Diese Komponente ist nicht zwingend nötig da eine SIM-Karte auch mit einer im Handel erhältlichen Adapterkarte adaptiert werden kann.

  • Der Adapter:

Der Adapter (rechts oben im Bild) dient dazu die Kartenimitation direkt an das Cardboard anzuschließen um die entsprechenden Kontakte auf den Steckleisten des Cardboards zur Verfügung zu stellen. Das Cardboard ist schon entsprechend beschriftet. Der Adapter ist mit dem ChipcardController Board nicht kompatiebel, dort wird die Kartenimitation direkt an den dafür vorgesehenen Stecker angschlossen.

  • Das BSCRDW Modul:

BSCDRW steht für »Billigster SmartCard Reader Der Welt« und geht auf gsho.de zurück. Mit dem BSCRDW von Gsho habe ich meine ersten Chipkartenexperimente gemacht. Da für selbiges Konzept auf Gsho.de auch C++ Quelltexte zur Verfügung stehen ist der BSCRDW eine gute Fingerübung für alle die in die Thematik einsteigen wollen. Das Modul besitzt leider nur Lesefähigkeiten.

  • Das Smartlab Modul:

Das Smartlab ist ein ebenfalls auf Gsho herunterladbares Programm (leider nur für Windows) mit dem sich die Inhalte von Telefonkarten lesen und bearbeiten lassen. Im Gegensatz zum BSCRDW besitzt das Smartlab Modul Schreibfähigkeiten und eine Status LED.

  • Der ChipcardController:

ChipcardlabSchaltplan.png

Der Chipcard Controller macht das Chipcarlab zu einem mächtigen Universalgerät. Auf der Platine befindet sich ein Atmega16 als Hauptprozessor, eine Serielle und eine Parallele Schnittstelle (Hinweis: Es hat sich gezeigt das der Parallelport nicht nötig ist, er wird in zukünftigen Versionen abgeschafft), eine Schnittstelle zum Anschluss der Kartenimitation. 4 Status LEDs. Die Anschlüsse für die LEDs, die Kartenimitation und die ISO Kontakte der Kontaktiereinrichtung sind zusammen mit GND und 5V auf eine Steckleiste geführt um kleine Erweiterungsmodule (zum Beispiel das SmartcardClock oder das Sniffer-Modul) aufstecken zu können. Programmiert wird über eine ISP Schnittstelle, welche natürlich entsprechend herausgeführt ist. Sowol beim Anschluss für die Kartenimitation, als auch bei der Kontaktiereinrichtung sind alle 8 ISO Pins erreichbar und können mit beliebigen Pegeln versorgt werden. Der Takt wird von einem externen 16Mhz oszillator gewonnen, so läuft die CPU mit maximaler Geschwindigkeit.

  • Der Sniffer Adapter:

SnifferAdaptor-module.jpg

Es existiert desweiteren noch ein Sniffer Adapter welcher in den Erweiterungsslot des ChipcardController gesteckt wird. Diese Verbindungen können auch schnell mit ein par Kabel hergestellt werden wenn sie gebraucht werden.

  • Die SmartcardClock:

SmartcardClock-module.jpg

Smartcards benötigen anders als syncrone Speicherkarten eine stabile Taktversorgung. Dieser Takt wird mit dem SmartcardClock Modul gewonnen auf dem sich ein 3,579Mhz Quarz befindet. Es können natürlich auch andere Quarzoszillatoren aufgesteckt werden, falls die Situation es erfordert. Der Ausgang des Quarzoszillators ist mit einem Widerstand (unkritisch, etwa 300 Ohm) versehen. So kann man den Takt im Betrieb abschalten in dem man den Clock-Pin des Cardslots auf masse zieht.

Die Software:

Die Software wurde komplett neu geschrieben und unterstützt nun eine viel Zahl von alltäglichen Dingen die man in einem Chipkartenhaushalt so braucht. Das Konzept hat sich gegenüber der alten Software gravierend gändert. Es ist nicht mehr die komplette Software im ChipcardLab sondern nur noch eine Firmware die mit einer Software (Linux) fernbedient wird.

Wer das ChipcardLab nachbaut findet im Paket vorkompilierte Binarys der kompletten Software. Was den Controller anbelangt können diese Binaries sogar so wie sie sind verwendet, sprich in den Controller geflasht werden. Bei der PC-Software ist es nicht garantiert das die Binaries funktioniern. Man sollte deshalb die PC-Software selber neu kompilieren. Hierzu muss zuerst die libCodeBananas installiert werden. Erst dann kann man die PC-Software kompilieren. Wenn die Software startet und die Verbindung mit dem ChipcardLab klappt ist der Rest ein Kinderspiel. Die Menüführung der Software ist diesmal mit sehr reichaltigen Hinweisen und Tips ausgeschmückt so das man sich schnell zurechtfindet. Im folgenden werden einige "Übungen" vorgestellt die man mit dem ChipcardLab machen kann - viel Spaß!

1. Übung: Telefonkarte auslesen

Der Klassiker unter den Chipkartenexperimenten ist das Auslesen von Telefonkarten. Es gibt quasi nichts einfacheres und wenn man sich gerade neu mit dem Thema befasst auch nichts motivierenderes.

Man drückt also L um sich zu verbinden, dann 3 um in das Menü für three-wire Karten zu kommen, und dann A um die Telefonkarte auszulesen und gleich zu analysieren. Das Ergebnis sollte ungefähr so aussehen:

This function does a phonecard analysis. It reads the content of a typical SLExx36
card and parses its information.

Insert card and press enter when ready!

   Power on card...
   Resetting card...
   Reading card...
   Power down card...

The result is:

   dd 2f ff ca   11011101 00101111 11111111 11001010   . / . .
   a9 5f 32 88   10101001 01011111 00110010 10001000   . _ 2 .
   00 01 03 00   00000000 00000001 00000011 00000000   . . . .
   00 fe 00 07   00000000 11111110 00000000 00000111   . . . .
   ff ff ff ff   11111111 11111111 11111111 11111111   . . . .
   ff ff ff ff   11111111 11111111 11111111 11111111   . . . .
   ff ff ff ff   11111111 11111111 11111111 11111111   . . . .
   ff ff ff ff   11111111 11111111 11111111 11111111   . . . .
   ff ff ff ff   11111111 11111111 11111111 11111111   . . . .
   ff ff ff ff   11111111 11111111 11111111 11111111   . . . .
   ff ff ff ff   11111111 11111111 11111111 11111111   . . . .
   ff ff ff ff   11111111 11111111 11111111 11111111   . . . .
   ff ff ff ff   11111111 11111111 11111111 11111111   . . . .
   ff ff ff ff   11111111 11111111 11111111 11111111   . . . .
   ff ff ff ff   11111111 11111111 11111111 11111111   . . . .
   ff ff ff      11111111 11111111 11111111            . . .

   Byte 1: dd
   Chip type: Eurochip

   Byte 2: 2f
   Country: Germany

   Byte 3: ff
   First nibble is F ==> Old card with missing 10th serial number digit

   Byte 4: ca
   Chip fabricator: Unknown

   Byte 5: a9
   Nominal Value: 12 DM
   Invalid last digit of deployment year: 10

   Byte 6: 5f
   Month of deployment: OKT
   9th digit of serial number: 15

   Byte 7: 32
   8th digit of serial number: 12
   7th digit of serial number: 4

   Byte 8: 88
   6th digit of serial number: 1
   5th digit of serial number: 1

   Byte 9-13: 00 01 03 00 00
   Units: 6.40
   Note units are computed as follows: NumberOfBitsInByte9*4096 +
                                       NumberOfBitsInByte10*512 +
                                       NumberOfBitsInByte11*64 +
                                       NumberOfBitsInByte12*8 +
                                       NumberOfBitsInByte13*1 = Units

Analysis done!

2. Übung: Wert der Telefonkarte ändern

Man kann den Wert der Karte auch verändern, natürlich nur in Richtung weniger. Wir tun einfach das was ein Telefon tun würde wenn es Einheiten von der Karte bucht. Ännliches macht man übrigens wenn man alte, abgelaufene Telefonkarten im Laden umbuchen lässt. Hier wird einfach geschaut wie viele Einheiten noch auf der alten, abgelaufenen Karte sind und dann einfach eine neue, volle genommen und dann einfach so viele Einheiten abgebucht bis der Wert der abgelaufenen Karte entspricht - so einfach ist das.

phonecard.jpg

Mit ? kann man sich das Auswahlmenü wieder heranholen und nach dem Menüpunkt "Modify phonecard units" suchen. Dann gibt man den entsprechenden Buchstaben ein. Um den Prozess zu starten drückt man nochmal Enter. Das ChipcardLab liest jetzt ersteinmal die Karte ein und stellt den aktuellen Wert fest. Der Bildschirm sollte nun so aussehen:

Byte:       9         10         11        12          13
         n*4096  +  n*512   +   n*64   +   n*8    +    n*1
        00000000   00000001   00000011   00000000   00000000

Note: n is the number of the bits in every byte
The courrent value is: 6.40

The counter is modified by deleting (writing) bits of the five bytes
listed above. Note: The bits are enumered from right to left (8..1)!
                                           

Hier sieht man sehr schön wie der Zähler in der Karte aufgebaut ist. Der Wert der Karte ist 6,40 Geldeinheiten. Der Zähler hat im wesentlichen zwei Befehle. Zum einen wird immer wenn ein Bit in einem Byte gelöscht wird das davorliegende Byte wieder mit einsen gefüllt. Das verändert den Wert der Karte zwar nicht, aber schafft zusätzliche Bits zum löschen. Genau dies werden wir bei dieser Karte jetzt tun. Wir werden dafür sorgen das Byte 12 und Byte 13 wieder reichlich mit Nullen gefüllt sind.

Zuerst füllen 12, dafür müssen wir das letze Bit von Byte Nr. 11 löschen. Also wählen wir dieses Byte zum schreiben aus und danach wählen danach das erste Bit aus.

Select byte (9-13) you want to write ==> 11
Select bit (1-8) you want to write ==>1

Nach bestätigung der Frage ob wir diese Operation auch wirklich ausführen wollen sieht der Zähler so aus:

Byte:       9         10         11        12          13
         n*4096  +  n*512   +   n*64   +   n*8    +    n*1
        00000000   00000001   00000010   11111111   00000000

Note: n is the number of the bits in every byte
The courrent value is: 6.40

Am Wert hat sich nichts gändert. Jetzt machen wir das gleiche noch einmal mit dem letzen Bit in Byte 13. Das Ergebnis ist:

Byte:       9         10         11        12          13
         n*4096  +  n*512   +   n*64   +   n*8    +    n*1
        00000000   00000001   00000010   11111110   11111111

Note: n is the number of the bits in every byte
The courrent value is: 6.40

So jetzt haben wir genug bits zum Löschen verfügbar und wollen mal versuchen eine Einheit von der Karte zu buchen. Man bucht immer vom letzen Byte ab. Wenn es leer wird können wir es ja wieder füllen in dem wir das letzte Bit aus dem Byte davor löschen. Wie auch immer. Wir wählen Byte 13, Bit 1 zum löschen aus und erhalten:

Byte:       9         10         11        12          13
         n*4096  +  n*512   +   n*64   +   n*8    +    n*1
        00000000   00000001   00000010   11111110   11111110

Note: n is the number of the bits in every byte
The courrent value is: 6.39

Wir haben es also geschafft der Karte eine Einheit zu mopsen. Aus 6,40 Geldeinheiten ist 6,39 Geldeinheiten. Das Komma ist hier auch nur virtuell um sowas wie Mark und Pfennig bzw. Euro und Cent dastellen zu können. Eigentlich sind es 639 Einheiten.

Jetzt könnte man natürlich auf die Idee kommen sich mit einem Mikrocontroller eine eigene Telefonkarte zu basteln. Warum das nicht (so einfach) geht lernen wir in der nächsten Übung.

3. Übung: Challenge Response Anfrage stellen

In den späten 90er Jahren waren gefäschte Telefonkarten ganz groß in Mode. Eine dünne Platine, ein Controller und etwas technisches Verständnis - fertig war die eigene Telefonkarte die nie leer wurde. Da musste man natürlich reagieren: Ab sofort bekam jede Karte ein Geheimnis mit auf den Weg. Mit dem Wissen um dieses Geheimnis konnten die Karten aus zufälligen Zahlen andere Zahlen berechnen die das Telefon, welches ebenfalls das Geheimnis kannte durch nachrechnen überprüfen konnte. Soetwas nennt man Challenge-Response. Im folgenden werden wir genau dies tun. Wir denken uns eine Zahl aus: z.B. 23 und schauen was die Karte daraus macht. Überprüfen können wir das natürlich nicht da wir das Geheimnis nicht kennen - das macht die Sache aber nicht weniger spannend.

This function performs a challenge response request. to an SLExx36 ponecard.
A chellenge is a random number that is sent to the card. Then the card computes
another number, the response, which is sent back. The response is computed using
a secret key with a secret algorithm. The telephone that sends the chellenge also
knows the secret key and the secret algorithm so it is able to verify the response
if the verification is ok the telephone knows that the card is a genuie one.

Note: Phonecards use a 6 byte long chellenge with 2 byte long responses. There are
      two verfication keys available per card. This program is only able to use the
      first one because i actually do not know how to select the second key.

Enter chellenge (hex) ==> 00 00 00 00 00 23

The following chellange will be sent:
   00 00 00 00   00000000 00000000 00000000 00000000   . . . .
   00 23         00000000 00100011                     . #

Insert card and press enter when ready!

   Power on card...
   Resetting card...
   Phase 1: Performing 110 clock pulses...
   Phase 2: Activating challenge-response by writing bit 111...
   Phase 3: Performing 177 clock pulses...
   Phase 4: Writing challenge...
               Byte 1: 00...
               Byte 2: 00...
               Byte 3: 00...
               Byte 4: 00...
               Byte 5: 00...
               Byte 6: 23...
   Phase 5: Reading challenge...
               Performing 160 clock pulses...
               Reading challenge bit 1...
               Result: 0
               Performing 160 clock pulses...
               Reading challenge bit 2...
               Result: 1
               Performing 160 clock pulses...
               Reading challenge bit 3...
               Result: 1
               Performing 160 clock pulses...
               Reading challenge bit 4...
               Result: 1
               Performing 160 clock pulses...
               Reading challenge bit 5...
               Result: 0
               Performing 160 clock pulses...
               Reading challenge bit 6...
               Result: 0
               Performing 160 clock pulses...
               Reading challenge bit 7...
               Result: 1
               Performing 160 clock pulses...
               Reading challenge bit 8...
               Result: 0
               Performing 160 clock pulses...
               Reading challenge bit 9...
               Result: 1
               Performing 160 clock pulses...
               Reading challenge bit 10...
               Result: 1
               Performing 160 clock pulses...
               Reading challenge bit 11...
               Result: 0
               Performing 160 clock pulses...
               Reading challenge bit 12...
               Result: 0
               Performing 160 clock pulses...
               Reading challenge bit 13...
               Result: 0
               Performing 160 clock pulses...
               Reading challenge bit 14...
               Result: 1
               Performing 160 clock pulses...
               Reading challenge bit 15...
               Result: 1
               Performing 160 clock pulses...
               Reading challenge bit 16...
               Result: 1

The result is:
   72 01110010   c7 11000111

Power down card...

Fertig! Die Antwort auf die Zahl 23 ist also 72C7. Was wohl die Antwort auf die Zahl 42 ist?

4. Übung: Krankenkassenkarte auslesen

Als Kassenpatient hat man in Deutschland so ein kleines Krankenversichertenkärtchen. Diese Karte ist im wahrsten Sinne des Wortes ein Kärtchen. Es handelt sich nämlich um eine einfache i2c Speicherkarte. i2c ist ein Industriestandart der für die Kommunikation zwischen Mikrochips entworfen wurde, also wie geschaffen für einfache Speicherkarten. Wir gehen also in das Menü für i2c Speicherkarten und suchen die Lesefunktion.

insurance card.jpg

Da es bei i2c karten solche und solche gibt sind einige Einstellungen erforderlich. Für die Krankenkassenkarte reicht einfach die bestätigung der Standarteinstellungen. Da wo [...] stehen dann die Personenbezogenen Daten diese sind hier natürlich weggelassen.

Now performing i2c memorycard dump...

   Power on card...
   Resetting card...

Most i2c memorycards feature an syncronous ATR (answer to reset). This
ATR is nothing more than a short peace of memory that is readable with
the 3W protocol. After reading the atr of the card the card beacomes
ready for i2c commands. If you do not know if your card features an ATR
you should take a look at it with the 3W terminal. If you see only FFs
your card has no syncrnous ATR. if you see 4 bytes of data trailed by
FFs the 4 bytes might be a syncrnous ATR.

Does your card feature an ATR? [Y/N] y

   Reading ATR...
   45 c8 08 89   01000101 11001000 00001000 10001001   E . . .

   Performing 32 additional clock pulses to bring card into ready state...

Number of bytes ==> 300


There exist various types of i2c chipcards and every card has a slightly
different command set. The command set normaly consists of 3 bytes of data.
The first byte specifies what to do, the next one is the memory adress where
the desired operation shall take place and the last one is a data field which
is only sometimes used. You must look up the command sequence in the datasheet
of the card and enter it here.

Note: German insurance cards use 00110000 00000000 00000000 for reading from
      adress 0x00!

Do you whish to customize the read command? [Y/N] n
Using default read command (SLE4442):

   30 00 00      00110000 00000000 00000000            0 . .

   Performing i2c start condition...
   Sending i2c command header...
   Performing i2c stop condition...
   Reading data...
   Power down card...

The result is:

   a2 13 10 91   10100010 00010011 00010000 10010001   . . . .

[...]

   80 06 42 41   10000000 00000110 01000010 01000001   . . B A
   52 4d 45 52   01010010 01001101 01000101 01010010   R M E R
 
[...]

   20 20 20 20   00100000 00100000 00100000 00100000   . . . .
   20 20 20 20   00100000 00100000 00100000 00100000   . . . .
   20 20 20 20   00100000 00100000 00100000 00100000   . . . .
   20 20 20 20   00100000 00100000 00100000 00100000   . . . .
   20 20 20 20   00100000 00100000 00100000 00100000   . . . .
   20 20 20 20   00100000 00100000 00100000 00100000   . . . .
   20 20 20 20   00100000 00100000 00100000 00100000   . . . .
   20 20 20 20   00100000 00100000 00100000 00100000   . . . .
   20 20 20 20   00100000 00100000 00100000 00100000   . . . .
   20 20 20 20   00100000 00100000 00100000 00100000   . . . .
   20 20 20 20   00100000 00100000 00100000 00100000   . . . .
   20 20 20 20   00100000 00100000 00100000 00100000   . . . .
   20 20 20 20   00100000 00100000 00100000 00100000   . . . .
   20 20 20 20   00100000 00100000 00100000 00100000   . . . .
   20 20 20 20   00100000 00100000 00100000 00100000   . . . .
   20 20 20 20   00100000 00100000 00100000 00100000   . . . .
   20 20 20 20   00100000 00100000 00100000 00100000   . . . .
   20 20 20 20   00100000 00100000 00100000 00100000   . . . .
   20 20 20 20   00100000 00100000 00100000 00100000   . . . .
   20 20 20 20   00100000 00100000 00100000 00100000   . . . .
   20 20 20 20   00100000 00100000 00100000 00100000   . . . .
   20 20 20 20   00100000 00100000 00100000 00100000   . . . .
   20 20 20 20   00100000 00100000 00100000 00100000   . . . .
   20 20 20 20   00100000 00100000 00100000 00100000   . . . .
   20 20 20 00   00100000 00100000 00100000 00000000   . . . .
   ff ff ff ff   11111111 11111111 11111111 11111111   . . . .
   ff ff ff ff   11111111 11111111 11111111 11111111   . . . .
   ff ff ff ff   11111111 11111111 11111111 11111111   . . . .
   ff ff ff ff   11111111 11111111 11111111 11111111   . . . .
   ff ff ff ff   11111111 11111111 11111111 11111111   . . . .
   ff ff ff ff   11111111 11111111 11111111 11111111   . . . .
   ff ff ff ff   11111111 11111111 11111111 11111111   . . . .
   ff ff ff ff   11111111 11111111 11111111 11111111   . . . .
   ff ff ff ff   11111111 11111111 11111111 11111111   . . . .
   ff ff ff ff   11111111 11111111 11111111 11111111   . . . .
   ff ff ff ff   11111111 11111111 11111111 11111111   . . . .


>>>                                                    

5. Übung: Krankenkassenkarte verändern

Die Krankenversichertenkarte ist ohne jeden Schutz, sie kann völlig frei gelesen und geschrieben werden. Das macht sie zum optimalen Übungsobjekt, denn wenn was nicht klappt weis man das es nicht an irgendeiner Sicherheitslogik lag sondern an einem selbst. Einen kleinen Schutz gibt es übrigens doch: Die Karte hat eine kryptische Checksumme, wenn man also seinen Namen ändert stimmt danach die Checksumme nicht mehr. Wir wollen nun das Wort "BARMER" in "FARMER" ändern. Das Tool kann nur einzelne Bytes verändern. Es ist auch nur für Experimente gedacht, für alles andere nimmt man besser einen kommerziellen Reader.

Das "B" das in "F" geändert werden soll befindet sich an Adresse 34 (Das ist in Hex 22). Der HEX-Ascii Code für "F" ist 46.

Und los gehts:

Now performing i2c memorycard write access...

   Power on card...
   Resetting card...

Most i2c memorycards feature an syncronous ATR (answer to reset). This
ATR is nothing more than a short peace of memory that is readable with
the 3W protocol. After reading the atr of the card the card beacomes
ready for i2c commands. If you do not know if your card features an ATR
you should take a look at it with the 3W terminal. If you see only FFs
your card has no syncrnous ATR. if you see 4 bytes of data trailed by
FFs the 4 bytes might be a syncrnous ATR.

Does your card feature an ATR? [Y/N] y

   Reading ATR...
   45 c8 08 89   01000101 11001000 00001000 10001001   E . . .

   Performing 32 additional clock pulses to bring card into ready state...


There exist various types of i2c chipcards and every card has a slightly
different command set. The command set normaly consists of 3 bytes of data.
The first byte specifies what to do, the next one is the memory adress where
the desired operation shall take place and the last one is a data field which
is only sometimes used. You must look up the command sequence in the datasheet
of the card and enter it here.

Note: German insurance cards use 00111000 10000010 00100011 for writing the number
      0x23 at adress 0x42!

Do you whish to customize the write command? [Y/N] n
Adress (HEX) ==> 22
Data (HEX) ==> 46
The following commandstring will be sent to the card:
   38 22 46      00111000 00100010 01000110            8 " F

Is this correct? [Y/N] y
Using default write command (SLE4442):

   38 22 46      00111000 00100010 01000110            8 " F

   Performing i2c start condition...
   Sending i2c command...
   Performing i2c stop condition...
   Card is processing... done!
   Power down card...

Wenn man sich den Inhalt der Karte jetzt noch einmal anzeigen lässt sieht man das dort jetzt tatsächlich "FARMER" steht.


   80 06 46 41   10000000 00000110 01000110 01000001   . . F A
   52 4d 45 52   01010010 01001101 01000101 01010010   R M E R

Man sollte dieses Experiment allerdings vor dem nächsten Arztbesuch wieder rückgängig machen, ansonsten gibt es wahrscheinlich dumme Fragen.

6. Übung: Kommunikation von synchronen Karten abhören

Wenn man mit Chipkarten arbeitet ist die Fähigkeit Datenverkehr abzuhören nahezu unerlässlich denn wie kann man sicher sein das Daten die man auf den Weg geschickt hat überhaupt auf der Leitungsebene ankommen und wenn ob sie auch nicht verstümmelt oder sonstwie beschädigt sind. Bei synchronen Karten verwendet man für diesen Zweck einen Logikanalyser - ein teures Gerät. Weil ein Logikanalyser eben nicht überall zur Hand ist habe ich dem ChipcardLab einen kleinen Logikanalyser mit auf den Weg gegeben. Immer wenn sich die Pegel von RESET, CLOCK, I/O und VCC ändern wird der neue Pegel auf dem Bildschirm ausgegeben. Das ganze ist da es in einem 16Mhz Controller läuft natürlich nicht besonders schnell - aber vielleicht manchmal doch hilfreich.

Sniffing phonecard.jpg

Zuerst müssen wir das ChipcardLab in einen Sniffer verwandeln, dazu wird das Sniffer-Modul huckepack aufgesteckt und die Kartenimitation angeschlossen. Wir wollen nun die Kommunikation zwischen einem Telefonkartentester und einer Telefonkarte mitschneiden:


==LOGIC ANALYSER==
The integrated logic analyser provides a logic diagramm of VCC, CLK, RST
and I/O. The diagram is updated whenever the state of one of the four lines
changes its state.

          +----------------------------------+
 .--------|                                  |
 |        |                                  |
 | Chip-  |    Plug sniffer module           |
 | card   |           here                   |
 |        |          |   |                   |
 |        |         \|   |/                  |  /
 |        |          \   /                   | /----- Connect
 |        |   ooooooooooooooooooooo          | \----- Card imitation
 ´--------|                                  |  \     here.
          +----------------------------------+

Note: Do not expect too much performance, if your appliance runs on very high
      speed the logic diagramm will look garbeled.

Sample #0
 I/O:_---_-------_--------__---____---_------------------------------____--_-
 CLK:___-___-_-_--_-_-_-_--__-__-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_--_-_-_-_
 RST:__----__________________________________________________________________
 VCC:------------------------------------------------------------------------


Sample #1
 I/O:--_---_---__--____---_---_-----------___-----___---_----______--________
 CLK:-_-_-_-_-_-__--_-__-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_--_-_-_-_-_-_-_-_
 RST:________________________________________________________________________
 VCC:------------------------------------------------------------------------


Sample #2
 I/O:____________________________---___________---__---------------__--------
 CLK:-_-_-_-_-_-_-_-_-_-_-_-_-_-__-__-_-_-_-_-__-__-_-_-_-_-_-_-_-_-_-_-_-_-_
 RST:________________________________________________________________________
 VCC:------------------------------------------------------------------------


Sample #3
 I/O:------__---------------____________________________-------__
 CLK:-_-_-_-__-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-__-_-_-___
 RST:____________________________________________________________
 VCC:-----------------------------------------------------------_    

Wichtig zu beachten: Das ChipcardLab muss resettet werden (Stromzufuhr kurz unterbrechen) und die Software neu gestartet werden bevor man wieder etwas anderes machen kann.

Hinweis: Ob die gesnifften Daten sinnvoll sind habe ich nie verifiziert, es währe möglich das der Telefonkartentester schon zu schnell für den Logiganalyser ist. Wenn es aber um das debuggen eines eigenen Readers geht kann man die Taktfrequenz ja testweise herunterfahren.

7. Übung: Abhören von Smartcards

Smartcards kommunizieren über mit einer RS232 ähnlichen Verbindung mit dem Lesegerät. Nur ist RX und TX auf einer Leitung zusammengefasst. Es ist also nur Halbduplex Datenverkehr möglich, was auch völlig ausreichend ist da keine großen Datenmengen bewegt werden müssen. Da diese Verbindung, vom Pegel einmal abgesehen, der Seriellen schnittstelle so ähnlich ist liegt es nahe die Verbindung mit einem PC und einem Pegelwandler dazwischen mitzuhören. Hardware dafür kann man in vielen Satshops (Wieso eigentlich Satshops, die verkaufen doch nur Fernsehzeug?!) kaufen. Diese Hardware hat allerdings einen gravierenden Mangel, sie funktioniert nur wenn die Baudrate mit der die Karte funktioniert in das Raster der PC-Baudraten passt. Vor allem Mobiltelefone kommunizieren mit Vorliebe auf Baudraten die alles andere als PC-Ähnlich sind. Diesen Mangel gleicht das ChipcardLab aus, hier können beliebige Baudraten gewählt werden. Alles was man tun muss ist die Baudrate (Meist 9600) vorher, z.B.: mit einem Oszilloskop, zu bestimmen oder durch probieren zu ermitteln.

sniffing smartcard.jpg

Im folgenden wird der Verkehr zwischen einer XCOS-Karte und dem Lesegerät mitgeschnitten und auch gleich analysiert. Die Karte wird hierbei nach ihrem Typ gefragt. Dabei werden zwei T=0 Pakete mit je 8 byte übertragen. Das zweite Paket enthält keine Daten da das Wort "Funcard" nichtmal das erste Paket ganz füllt. Die XCOS-Utils fragen allerdings immer die volle länge ab.

Es wäre auch möglich gewesen die Daten nicht zu analysieren sondern nur als Hexdump ausgeben zu lassen. Man sollte die T=0 Protokoll-Analyse nur auswählen wenn man sich schon sicher ist das es sich auch um eine T=0 Karte handelt.

==T=x-SNIFF==
This is the integrated T=x sniffer tool, to return back to main menue end the
program by pressing STRG+C and restart it. You also need to powercycle the your
ChipcardLab. Now plug the components like this:

          +----------------------------------+
 .--------|                                  |
 |        |                                  |
 | Chip-  |    Plug sniffer module           |
 | card   |           here                   |
 |        |          |   |                   |
 |        |         \|   |/                  |  /
 |        |          \   /                   | /----- Connect
 |        |   ooooooooooooooooooooo          | \----- Card imitation
 ´--------|                                  |  \     here.
          +----------------------------------+

You have to specify the baudrate. Chipcards typically use 9600 Baud
(when running at 3,579545 Mhz).

Note: Here are some baudrates of devices i worked with:
      Towitoko Chipdrive: 9600 Baud
      Siemens P1 (early mobile phone): 11904 Baud
      Siemens S25 (mobile phone): 8695 Baud, no pullup

Baudrate (e.g. 9600) ==> 9600

Sometimes a pullup resistor may help to avoid noise that might be misinterpedted as
a start bit. The hardware has internal pullup resistors that can be switched on and off.

Do wish to have a pullup resistor activated on the I/O Port? [Y/N] n


Note: The ChipcardLab is now in serial sniffer mode, if you wish to analyse
      the incoming data stream with another program, just exit here by pressing
      STRG+C and reopen /dev/ttyUSB1 with another program. The data tastes like data that
      is captured with a season logger.

This software can do a simple realtime analyis oft the data. Please select
one of the following anylysis types:

     N..............................Do no analyis, just dump the data
     1..............................Do T=0 analyis (e.g. for SIM-Cards)


>>>1

T=0 Protocol analysis is selected.

The analysis must begin from where the first TPDU is transmiited to
determine this point you can set an offset and a trigger. The trigger
is the first byte from wehre the offset begins to count. Here is an
illustration for a better understanding:

Imaginge: Offset = 5 Triger = 0x3B
00 00 00 00 3B F8 ... 23 8A 08 00 00 05 ...
            A   5 ... 1  A
            |      A     |
         Trigger   |     |
                   |     |
               Overriden |
                 Bytes   |
                       Offset

NOTE: In the very most cases the trigger is 3b (beginning from an ATR) and
      the offset is the length of the ATR

NOTE: The offset is the byte from where the analysis should start, not the
      number of bytes that should be overridden. If you want to override 24
      bytes the offset is 25!

Do wish to set offset and trigger? [Y/N] n

Now listening for incoming data...


   8a 08 00 00   10001010 00001000 00000000 00000000   . . . .
   08            00001000                              .
   ==> Header: Class Byte (CLA)       = 8a
               Instruction Byte (INS) = 08
               Parameter (P1)         = 00
               Parameter (P2)         = 00
               Parameter (P3/LE)      = 08

   08            00001000                              .
   ==> ACK (should be lways the same as the INS byte!)

   46 75 6e 63   01000110 01110101 01101110 01100011   F u n c
   61 72 64 ff   01100001 01110010 01100100 11111111   a r d .
   ==> Body (Contains the transmitted data)


   90 00         10010000 00000000                     . .
   ==> Status: status word 1 = (SW1) 90
               status word 2 = (SW2) 00
               ==> Normal processing.

==> TRANSMISSION COMPLETE!



   8a 08 00 08   10001010 00001000 00000000 00001000   . . . .
   07            00000111                              .
   ==> Header: Class Byte (CLA)       = 8a
               Instruction Byte (INS) = 08
               Parameter (P1)         = 00
               Parameter (P2)         = 08
               Parameter (P3/LE)      = 07

   08            00001000                              .
   ==> ACK (should be lways the same as the INS byte!)

   ff ff ff ff   11111111 11111111 11111111 11111111   . . . .
   ff ff ff      11111111 11111111 11111111            . . .
   ==> Body (Contains the transmitted data)

   90 00         10010000 00000000                     . .
   ==> Status: status word 1 = (SW1) 90
               status word 2 = (SW2) 00
               ==> Normal processing.

==> TRANSMISSION COMPLETE!

Nicht immer ist die Situation so einfach wie im oben gezeigten Fall. Hier wird nämlich davon ausgegangen das die Karte ihren ATR schon gesendet wird hat und zum Startzeitpunkt der Analyse gerade keine Kommunikation zwischen Lesegerät und Karte stattfindet. Wenn man in der Situation ist das man die Kommunikation nicht stillegen kann wann man will z.B.: Bei der Fehlersuche einer SIM-GSMChip Kommunikation wo man eben keinen direkten Einfluss darauf nehmen kann wann kommuniziert wird. Dann hat man die Möglichkeit einen ein Byte langen Trigger und einen Offset festzulegen.

Man geht also wie folgt vor: Man startet die Analyse bei ausgeschalteten Device. Also Trigger wählt man das erste Zeichen des ATR, das ist eigentlich immer 3B. Der Offset ist das erste Byte eines gültigen T=0 Paketes. Wenn alles stimmt beginnt die Protokollanalyse dann nach dem Einschalten direkt beim ersten sinnvollen Paket.

Um den Offset herauszufinden muss man die Kommunikation vorher eine Weile ohne Protokollanalyse anschauen und Offset und Trigger durch scharfes hinsehen ermitteln.

Wichtig zu beachten: Das ChipcardLab muss resettet werden (Stromzufuhr kurz unterbrechen) und die Software neu gestartet werden bevor man wieder etwas anderes machen kann.


Übrigens: Man kann auch einen SeasonLogger mit der ChipcardLab Software verwenden. Allerdings hat man dann keine variablen Baudraten

8. Übung: Sprechen mit Smartcards

In der Regel ist ein kommerzielles Lesegerät komfortabler um ein Gespräch mit einer Smartcard zu führen. Aber auch das ChipcardLab kann dazu benutzt werden um ein kurzes Gespräch mit einer Karte zu führen. Das praktische hierbei ist wieder die variable Baudrate und das man hier selbst entscheiden kann wie viele Bytes man an die Karte sendet. Man kann also auch testen wie die Karte mit fehlerhaften Eingaben klarkommt.

talking to smartcard.jpg

Da das ChipcardLab den erforderlichen Takt nicht selbst generieren kann brauchen wir das SmartcardClock Modul. Auf diesem Modul befindet sich idealerweise ein Quarzoszillator mit 3,579545 Mhz. Dann entspricht die Baudrate nämlich genau 9600 Baud. Bei anderen Quarzen müssen andere Baudraten gewählt werden.

Im folgenden werden wir eine XCOS-Karte fragen von welchem Typ sie ist:

==T=X Terminal==
Note: This is the integrated chipcard terminal tool of the chipcardlab software.
      To return back to main menue end the program by pressing STRG+C and restart
      it. You also will have to powercycle your chipcardLab!

          +----------------------------------+
 .--------|                                  |
 |        |                                  |
 | Chip-  |    Plug smartcard clock          |
 | card   |        module here               |
 |        |          |   |                   |
 |        |         \|   |/                  |
 |        |          \   /                   |
 |        |   ooooooooooooooooooooo          |
 ´--------|                                  |
          +----------------------------------+

You have to specify the baudrate. Chipcards typically use 9600 Baud
(when running at 3,579545 Mhz)

NOTE: If you have problems to communicate with the card (e.g. says 6D 00
      to all requests) try a slightly different baudrate to fix an eventually
      anounced timing problem.

Baudrate (e.g. 9600) ==> 9600

Reading ATR:
   3b 7f 01 00   00111011 01111111 00000001 00000000   ;   . .
   fe 58 43 4f   11111110 01000101 01000011 01001111   . X C O
   53 76 32 30   01010011 01110110 00110010 00110000   S v 2 0
   30 28 63 29   00110000 00101000 01100011 00101001   0 ( c )
   50 46 42 4d   01010000 01000110 01000010 01001101   P F B M

   ATR length: 20 byte

Note: The ChipcardLab is now in terminal mode, if you wish to handle the communication
      with another program, exit by pressing STRG+C and reopen /dev/ttyUSB1 with another program.
      The communication feels like a direct serial communication to the card, just talk
      the card protocol (T=0, T=1, T=14 or whatever) as usual.


data string ==> 8A 08 00 00 0F

   8a 08 00 00   10001010 00001000 00000000 00000000   . . . .
   0f            00001111                              .

   Is this correct? [Y/N] y
   Data sent!

   Received:
   08 4d 65 67   00001000 01001101 01100101 01100111   . M e g
   61 46 75 6e   01100001 01000110 01110101 01101110   a F u n
   63 61 72 64   01100011 01100001 01110010 01100100   c a r d
   ff ff ff ff   11111111 11111111 11111111 11111111   . . . .
   90 00         10010000 00000000                     . .


data string ==>    


Wichtig zu beachten: Das ChipcardLab muss resettet werden (Stromzufuhr kurz unterbrechen) und die Software neu gestartet werden bevor man wieder etwas anderes machen kann.

Übrigens: Die ChipcardLab Software unterstützt auch den seinerzeit von Tron entwickelten Serprog. Schließt man anstatt des ChipcardLab einen Serprog an kann man damit genauso mit der Karte reden, allerdings nicht mit variablen Baudraten. Infos zum Serprog findet man unter: ftp://ftp.ccc.de/serprog/

Tipps & Tricks

  • Speicherkarten:

Normale Speicherkarten (z.B.: Telefonkarten) haben eine 3 Drahtschnittstelle. Das sind Takt, Reset und I/O. Mit jedem Taktpuls wird der Adresszähler erhöht und mit Reset kann er wieder auf 0 gesetzt werden. An I/O liegt der jeweilige Status der Speicherzelle an, sollte man meinen. Tatsächlich ist es so das im Falle einer logischen 0 I/O auf Masse zieht und im Falle einer logischen 1 einen undefinierten Pegel annimmt. Deshalb muss I/O auf alle Fälle mit einem Pullup Widerstand an VCC gelegt werden.

  • Abtelefonierte Telefonkarten:

Abtelefonierte Telefonkarten kann man zwar nicht wieder aufladen aber man kann sie als ID-Karten weiterverwenden: Telefonkarten sind durch ein Challenge/Response Verfahren geschützt. Die Challange ist 48 Bit lang und die Response 16 Bit. Man könnte sich nun eine Anzahl Responses von der Karte berechnen lassen und diese dann zur Validierung verwenden. Telefonkarten haben aber noch ein anderes Chic: Hält man sie unter schwarzlicht wird die Seriennummer sichtbar.

  • Von der Bitlänge zur Baudrate:

An vielen Stellen muss, falls man sie nicht weis, die Baudrate bestimmt werden. Im einfachsten Fall macht man das mit einem Speicheroszilloskop. Man greift sich willkürlich ein Stück der Kommunikation herraus und sucht sich das kleinst mögliche stetige Intervall, also eine Stelle wo man sicher ist das es sich um ein einzelnes Bit handelt heraus und misst den Abstand zwischen Anfang und Ende. Nehmen wir mal an wir messen hier einen Abstand von DeltaT=104us. Daraus kann man jetzt sehr einfach die Baudrate berechnen, denn die Baudrate ist genau der Kehrwert von DeltaT. Man muss das ganze nur richtig in den Taschenrechner eingeben, also die us bzw. das *10^-6 nicht vergessen. Effektiv rechnet man also 1/(104*10^-6). Heraus kommt 9615,384615385 was ungefähr 9600 Baud ist.

Weiteres:

Die Platinenlayouts und Schaltpläne stehen im PostScript (Ätzen) und im HPGL (Isolationsfräse) unter der Creative Commons Licence zur Verfügung. Die zugehörigen Quelltexte stehen unter der GNU-GPL V.2.0 zur Verfügung.

Alle zum Projekt zugehörigen Dateien können auf meiner Webseite heruntergeladen werden: http://www.runningserver.com/?page=runningserver.content.thelab.chipcardlab

Hinweis: Das Paket mit der neuen Software ist noch nicht hochgeladen, allerdings wird es in den nächsten Tagen folgen.

Interessierte können sich bei mir unter zero-kelvin@gmx.de melden oder mich Donnerstags im ClubDiscordia ansprechen. Ich bin auch gerne bereit beim Zusammenbauen zu helfen.

Im übrigen gibt es von mir auch ein freies Chipkartenbetriebsystem, welches auch auf dem ChipcardLab direkt läuft: XCOS_2.0 Hier kann man sogar (Sofern das Lesgerät mit der standartfrequenz von 3,579545 arbeitet) ein serielles Kabel anschließen und Debug-Messages anzeigen lassen.

120808 Philipp Fabian Benedikt Maier