Flipper Zero NFC Hacking – Kanonenfutter

In einem früheren Beitrag haben wir gesehen, wie man mit dem Flipper Zero einen transparenten Leser implementiert. Was wäre, wenn wir das gleiche Konzept verfolgen, dieses Mal jedoch einen transparenten Kartenemulator implementieren? Wir könnten unseren Flipper Zero wie eine Kanone einsetzen, um digitale Festungen wie Lesegeräte oder Smartphones anzugreifen, indem wir fehlerhafte Anfragen senden. Fehlerhafte Befehle, im Lebenszyklus nicht erwartete Befehle, Fuzzing, Pufferüberlauf – es gibt keine Grenzen!

1 - Kontext

Genau wie beim transparenten Kartenleser möchte ich mit dem Flipper über seine serielle CLI von meinem Computer aus kommunizieren. Der Computer übernimmt die gesamte Logik, d. h. er entscheidet abhängig vom Befehl, welche Antwort gegeben werden soll, beispielsweise mithilfe eines Python-Skripts.

Was nun die Implementierung der Kartenemulatorbefehle betrifft, handelt es sich im Wesentlichen um eine Art Spiegelmodus im Vergleich zum Lesegerät:

• Wir müssen erkennen, wann das RF-Feld vom Terminal aktiviert wird.
• Wir müssen erkennen, wann das RF-Feld vom Terminal deaktiviert wird.
• Wir müssen in der Lage sein, Bits an das Terminal zu empfangen/senden.
• Wir müssen in der Lage sein, Bytes an das Terminal zu empfangen/senden.

Außer es gibt ein kleines Detail, das die Sache verkompliziert. Denken Sie daran, dass bei der Kommunikation zwischen Karte und Lesegerät das Lesegerät als Master fungiert, das heißt, es ist derjenige, der die Kommunikation initiiert und Befehle sendet.

Wenn wir also einen Kartenemulator erstellen, muss dieser auf Ereignisse vom Lesegerät warten. Man kann es sich wie einen Server vorstellen, bei dem der Leser als Client fungiert. Wir müssen dies in den Flipper Zero codieren.

Okay, lassen Sie uns zunächst einen kurzen Rückblick auf den Kommunikationsaustausch zwischen einem Lesegerät und einer Karte unter Verwendung von ISO 14443-A geben.

2 – Kommunikationsaustausch zwischen einem Lesegerät und einer Karte unter Verwendung von ISO 14443-A

Hier ist ein Diagramm, das die wichtigsten Austauschvorgänge zwischen einem Lesegerät und einer Karte zusammenfasst, die über ISO 14443-A kommunizieren.

+----------------+                                  +----------------+
|   Reader       |                                  |   Card         |
+----------------+                                  +----------------+
        |                                                  |
    Field activation                                       |
        |                                                  |
        | --- REQA (Request Command Type A) -------------> |
        |                   26                             |
        |                                                  |
        | |
        |                                                  |
        | |
        |                                                  |
        | |
        | E0 50 BC A5                                      |
        |                                                  |
        | |    
        | D0 73 87                                         |
        |                                                  |
        | |
        | 0200A404000E325041592E5359532E444446303100E042   |
        |                                                  |
        | 



<p>Jetzt stellt sich die Frage: „Wie setzen wir das alles auf dem Flipper um?“</p>

<h2>
  
  
  4 – Flipper Zero-Implementierung
</h2>

<p>Wie in meinem vorherigen Artikel werde ich die Datei „applications/main/nfc/nfc_cli.c“ weiter erweitern (siehe die Datei in meinem Zweig).</p>

<p>Zunächst ein kurzer Hardware-Punkt. Für die NFC-Verwaltung nutzt der Flipper Zero den ST25R3916-Chip. Das ist großartig, denn es ermöglicht uns, sowohl ein kontaktloses Lesegerät als auch einen Kartenemulator zu entwickeln. Der Chip übernimmt automatisch die Übertragung der beteiligten Befehle von der Feldaktivierung bis zur Antikollision. Wir müssen lediglich die ATQA, SAK, UID und deren Länge angeben, die wir zurücksenden möchten.</p>

<p>Der Flipper stellt die Funktion furi_hal_nfc_iso14443a_listener_set_col_res_data zur Verfügung, um all dies zu bewältigen.</p>

<p>Deshalb habe ich der NFC-CLI des Flippers drei Befehle hinzugefügt, um diese Elemente zu konfigurieren:</p>

• set_atqa
• set_sak
• set_uid

Und kurz bevor wir mit der Emulation beginnen, rufen wir furi_hal_nfc_iso14443a_listener_set_col_res_data mit diesen Parametern auf.

+----------------+                                  +----------------+
|   Reader       |                                  |   Card         |
+----------------+                                  +----------------+
        |                                                  |
    Field activation                                       |
        |                                                  |
        | --- REQA (Request Command Type A) -------------> |
        |                   26                             |
        |                                                  |
        | |
        |                                                  |
        | |
        |                                                  |
        | |
        | E0 50 BC A5                                      |
        |                                                  |
        | |    
        | D0 73 87                                         |
        |                                                  |
        | |
        | 0200A404000E325041592E5359532E444446303100E042   |
        |                                                  |
        | 



<p>Als nächstes wird der Flipper Zero mit der Funktion furi_hal_nfc_set_mode in den Kartenemulatormodus versetzt. Dieses Mal geben wir den Modus FuriHalNfcModeListener an und für die Technologien verwenden wir die Standardwerte: FuriHalNfcTechIso14443a, FuriHalNfcTechIso14443b und FuriHalNfcTechIso15693.</p>

<p>Um die Emulation zu starten, habe ich schließlich den Befehl run_emu implementiert, der eine Endlosschleife initiiert, die auf einen Leser in der Nähe wartet. Die Ereignisüberwachung erfolgt durch die Funktion furi_hal_nfc_listener_wait_event.<br>
</p>

<pre class="brush:php;toolbar:false">    if(g_NfcTech == FuriHalNfcTechIso14443a) {
        furi_hal_nfc_iso14443a_listener_set_col_res_data(g_uid, g_uid_len, g_atqa, g_sak);
        fdt = ISO14443_3A_FDT_LISTEN_FC;
    }

Als nächstes kann das Ereignis mehrere Werte annehmen, je nachdem, was erkannt wurde:

• FuriHalNfcEventFieldOn zeigt an, dass eine Feldaktivierung erkannt wurde.
• FuriHalNfcEventFieldOff zeigt an, dass das Feld ausgeschaltet wurde.
• Das wichtigste Ereignis ist FuriHalNfcEventRxEnd, das anzeigt, dass ein Befehl vom Terminal empfangen wurde. An dieser Stelle müssen wir unsere Antwort senden. Auch hier ist es wichtig zu beachten, dass die gesamte Abwicklung der Befehlsübermittlung bis hin zur Antikollision automatisch erfolgt. Wir können also grundsätzlich mit der Verarbeitung eines Befehls wie zum Beispiel „select“ beginnen.

FuriHalNfcEvent event = furi_hal_nfc_listener_wait_event(100);

5 – Abwicklung des Befehlsempfangs und Senden der Antwort

Jetzt wollen wir sehen, wie wir mit dem Empfang des Befehls und dem Senden der Antwort umgehen.

    while(true) {
        FuriHalNfcEvent event = furi_hal_nfc_listener_wait_event(100);
        if(event == FuriHalNfcEventTimeout) {
            if(cli_cmd_interrupt_received(cli)) {
                break;
            }
        }
        if(event & FuriHalNfcEventAbortRequest) {
            break;
        }
        if(event & FuriHalNfcEventFieldOn) {
            printf("on\r\n");
        }
        if(event & FuriHalNfcEventFieldOff) {
            furi_hal_nfc_listener_idle();
            printf("off\r\n");
        }
        if(event & FuriHalNfcEventListenerActive) {
            // Nothing
        }
        if(event & FuriHalNfcEventRxEnd) {

• Der Datenempfang wird über furi_hal_nfc_listener_rx(rx_data, rx_data_size, &rx_bits); abgewickelt. Wir zeigen die empfangenen Daten mit einem printf an, der die Antwort an das mit dem Flipper verbundene Terminal sendet. Es ist wichtig zu verstehen, dass wir sehr schnell reagieren müssen, sobald wir den Befehl erhalten. Das bedeutet, dass wir die Antwort nicht manuell in die Shell schreiben können – es wäre zu spät. Aus diesem Grund besteht die einzige Möglichkeit zur Kommunikation mit dem Flipper darin, ein Python-Skript mit einem Dispatcher zu verwenden, der angibt, welche Antwort auf jeden empfangenen Befehl gegeben werden soll.

• Dann sendet das Terminal eine Antwort, die wir mit der Funktion nfc_emu_get_resp(cli, rx_cmd) abrufen. Dieser Teil ist etwas knifflig, da es bei einem Shell-Befehl normalerweise nicht zu einem Hin- und Her-Austausch kommt. Also verwende ich die Funktion cli_getc(cli), um ein Zeichen zu lesen.

  • Manchmal erhalte ich das unerwünschte Zeichen 0xA. Wenn es das erste empfangene Zeichen ist, überspringe ich es, da ich Zeichen für Zeichen lese.
  • Das erste Zeichen gibt an, ob der Flipper Zero den CRC berechnen und zum Befehl selbst hinzufügen soll (0x31 bedeutet ja, andernfalls nein).
  • Dann lese ich die Zeichen der Antwort im hexadezimalen String-Format. Wenn wir das Zeichen 0xA empfangen, bedeutet dies, dass der Empfang abgeschlossen ist.

• Schließlich konvertieren wir die hexadezimale Zeichenfolge mit unhexify(tmp, (uint8_t*)bit_buffer_get_data(rx_data), len); in ein uint8_t-Array.

• Bei Bedarf fügen wir einen CRC mit add_crc hinzu.

• Zuletzt können wir die Antwort an den Leser senden mit:
  
  FuriHalNfcError r = furi_hal_nfc_listener_tx(rx_data, bit_buffer_get_size(rx_cmd));.

Und wie können wir das alles nun validieren?

6 – Validierung der Kartenemulation

6.1 – Wie es begann ... (Hydra NFC v2)

Nun, wir könnten unseren transparenten Reader aus dem vorherigen Beitrag verwenden, um unseren Emulator zu validieren. Wir bräuchten also zwei Flipper Zeros ... die ich nicht habe. Allerdings habe ich einen Hydra NFC v2, der eine transparente Leseeinrichtung ermöglicht.

Ich muss nur ein Skript von pynfc verwenden.

+----------------+                                  +----------------+
|   Reader       |                                  |   Card         |
+----------------+                                  +----------------+
        |                                                  |
    Field activation                                       |
        |                                                  |
        | --- REQA (Request Command Type A) -------------> |
        |                   26                             |
        |                                                  |
        | |
        |                                                  |
        | |
        |                                                  |
        | |
        | E0 50 BC A5                                      |
        |                                                  |
        | |    
        | D0 73 87                                         |
        |                                                  |
        | |
        | 0200A404000E325041592E5359532E444446303100E042   |
        |                                                  |
        | 



<p>Es ist sehr praktisch, weil es uns ermöglicht, Befehle einzeln zu senden, um alles zu validieren:</p>

• Senden des REQA
• Antikollision
• Auswählen
• PPS
• Senden einer TPDU

6.2 - So endete es... (PC/SC-Reader).

In Wirklichkeit ist die Kommunikation jedoch etwas komplizierter. Deshalb habe ich einen PC/SC-Leser, den ACR122U, zum Senden/Empfangen eines vollständigen APDU-Befehls in Kombination mit einem Python-Skript (unter Verwendung von pyscard ) verwendet, um einen Test in der realen Welt durchzuführen.

In meinem Fall wähle ich einfach die PPSE-Anwendung aus.

    if(g_NfcTech == FuriHalNfcTechIso14443a) {
        furi_hal_nfc_iso14443a_listener_set_col_res_data(g_uid, g_uid_len, g_atqa, g_sak);
        fdt = ISO14443_3A_FDT_LISTEN_FC;
    }

Jetzt muss der Kartenemulator also noch viel mehr Ereignisse verarbeiten. Daher habe ich unten ein Python-Skript erstellt, um diesen Fall zu verwalten. Es gibt viel zu erklären, beispielsweise die verschiedenen Arten von TPDU (i-Block, R-Block, S-Block), aber das wird in einem zukünftigen Blog-Beitrag behandelt.

FuriHalNfcEvent event = furi_hal_nfc_listener_wait_event(100);

Damit funktioniert es sehr gut und die Emulation ist äußerst stabil. Ich kann den Flipper am Lesegerät platzieren oder daraus entfernen und die Befehle mehrmals senden, und es funktioniert jedes Mal. Auch hier verfügt der Flipper über eine hervorragende Implementierung seiner NFC-Schicht und seine API ermöglicht viele Funktionen mit minimalem Implementierungsaufwand.

Unten finden Sie ein Beispiel der Ausgabe des Python-Skripts.

+----------------+                                  +----------------+
|   Reader       |                                  |   Card         |
+----------------+                                  +----------------+
        |                                                  |
    Field activation                                       |
        |                                                  |
        | --- REQA (Request Command Type A) -------------> |
        |                   26                             |
        |                                                  |
        | |
        |                                                  |
        | |
        |                                                  |
        | |
        | E0 50 BC A5                                      |
        |                                                  |
        | |    
        | D0 73 87                                         |
        |                                                  |
        | |
        | 0200A404000E325041592E5359532E444446303100E042   |
        |                                                  |
        | 



<h3>
  
  
  6.3 Ein bisschen Proxmark auch
</h3>

<p><img src="/static/imghwm/default1.png" data-src="https://img.php.cn/upload/article/000/000/000/172964254814325.jpg?x-oss-process=image/resize,p_40" class="lazy" alt="Flipper Zero NFC Hacking - cannon fooder"></p>

<p>Die Verwendung des Proxmark 3 erwies sich als nützlich für das Debuggen der Kommunikation im Sniffing-Modus: Ich platzierte ihn zwischen dem Lesegerät und der Karte (bei der es sich um eine echte Karte oder den Flipper handeln konnte) und konnte den Datenaustausch überprüfen.<br>
</p>

<pre class="brush:php;toolbar:false">    if(g_NfcTech == FuriHalNfcTechIso14443a) {
        furi_hal_nfc_iso14443a_listener_set_col_res_data(g_uid, g_uid_len, g_atqa, g_sak);
        fdt = ISO14443_3A_FDT_LISTEN_FC;
    }

Was kommt als nächstes?

Gut, was kommt als nächstes?

• Zunächst könnte ich weitere Erläuterungen zum Kartenemulations-Python-Skript geben.
• Außerdem sollte ich eine Möglichkeit implementieren, die Kartenemulation zu stoppen, wenn eine Taste gedrückt wird, da die Ereignis-Warteschleife derzeit nie endet. Die einzige Möglichkeit zum Verlassen besteht darin, den Flipper neu zu starten.
• Außerdem könnten wir einige lustige Dinge tun, indem wir gleichzeitig ein transparentes Lesegerät und einen Kartenemulator verwenden, um beispielsweise einen Man-in-the-Middle-Angriff durchzuführen und die Kommunikation live zu ändern!

Das obige ist der detaillierte Inhalt vonFlipper Zero NFC Hacking – Kanonenfutter. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!