Šifrování v Arduinu

anebo obecně v 8bitových AVR.

Někdy během minulého roku jsem se poprvé zabýval šifrováním dat v AVR. Potřeboval jsem šifrovat data odesílaná ze základen Energomonitoru, které obsahují 8bitový AVR mikrokontrolér. Pro šifrování se použila symetrická šifra AES, která, jak se nakonec ukázalo, jde jednoduše implementovat i na 8 MHz mikrokontroléru s minimem paměti. Tehdy jsem si vyzkoušel AES i na Arduinu a našel jsem dvě implementace v jazyce C, které se dají jednoduše použít. V následujícím textu ukážu jak na tomto slabém hardware šifrovat a co je k tomu všechno potřeba.

K tomuto článku mě inspiroval Adentův tweet o šifrování na Arduinu.

Právě jsme se se @stepanb pustili do zkoumání možností šifrování na Arduinu. Mýtus o tom, že IoT nemá na to být bezpečný, se pomalu drolí…

— ADent Retročipující (@retrocip) October 3, 2015

V tu chvíli mě napadlo, že spousta profesionálů považuje Arduino za hračku pro děti, která se nehodí ani pro studenty. O nějakém IoT a bezpečnosti přece nemůže být ani řeč! No… takové lidi neposlouchejte :) pokud k tomu ještě poznamenají něco o příšerném IDE a vlastním programovacím jazyku, pak je jasné, že tématu vůbec nerozumí.

Teď si bez dalšího zdržování představíme šifru AES, vysvětlíme si, co to je režim CBC a nakonec si ukážeme funkční kód pro Arduino Uno.

Bloková symetrická šifra AES

Naším cílem je přenést data mezi dvěma body takovým způsobem, aby jim nedokázal porozumět nikdo kromě odesílatele a oprávněného příjemce. K tomu potřebujeme na obou stranách tajný klíč. Pokud je tento klíč na obou stranách stejný, mluvíme o symetrických šifrách. Pokud má každá strana svůj vlastní klíč (jeden se používá k zašifrování dat, ten je většinou veřejně známý a druhý se používá k rozšifrování, ten je tajný a zná ho pouze oprávněný příjemce), pak mluvíme o asymetrických šifrách.

Šifra známá pod zkratkou AES (Advanced Encryption Standard), nebo také pod jménem Rijndael (spojení jmen obou tvůrců Daemen a Rijmen) patří do kategorie symetrických šifer. K tomu, abychom mohli zašifrovat a rozšifrovat zprávu, nám stačí jeden klíč o délce 128, 192 nebo 256 bitů (tady pozor, mluvíme o bitech, nikoliv bajtech).

A nakonec ještě zbývá vysvětlit poslední slovíčko: bloková. Blokové šifry nejdříve rozdělí vstupní data na bloky o předem dané velikosti a ty pak šifrují samostatně jeden po druhém. V případě AES mají bloky velikost 128 bitů. Pokud poslední blok nemá po rozdělení dat velikost přesně 128 bitů, je potřeba data doplnit například o nuly nebo náhodnými čísly.

Režim CBC

V předchozím odstavci si prosím všimněte slovíčka samostatně. Každý blok lze zašifrovat i rozšifrovat zvlášť bez nutnosti znát (nebo mít přijatý) předchozí či následující blok. To nám dává výhodu paralelizace – pokud máte k dispozici více výpočetních jader, můžete data šifrovat/rozšifrovat po několika blocích ve více vláknech. Tato výhoda je ale zároveň velká nevýhoda – stejné bloky vstupních dat budou po zašifrování vypadat stejně. To nám může i nemusí vadit, záleží na povaze dat. Tento problém je u všech blokových šifer, nejenom u AES.

U blokových šifer proto používáme různé módy. Nebudu zabíhat do detailů, zběžně vysvětlím pouze dva: ECB a CBC.

ECB (Electronic Codebook) je již zmiňovaný režim, kdy se jednotlivé bloky šifrují samostatně. Na vstupu je pouze blok dat a tajný klíč, na výstupu pak zašifrovaný blok dat. Jeho výhody i nevýhody jsme si již uvedli.

CBC (Cipher Block Chaining) je režim, ve kterém se vezme zašifrovaný předchozí blok a nezašifrovaná data bloku následujícího, tyto data se XORují a teprve výsledek této operace se zašifruje. Pro XORování prvního bloku se použije tzv. inicializační vektor (IV), který má velikost právě jednoho bloku. V případě AES je to 128 bitů.

Na následujícím obrázku je bitmapový obrázek tučňáka Tuxe (vlevo) zašifrován blokovou šifrou v módu ECB (uprostřed) a v módu CBC (vpravo). Jak je vidět, původní obsah dat lze v případě režimu ECB odhadnout pouhým okem.

Ukázka módů EBC a CBC u blokových šifer. Zdroj Wikipedia

Další detaily a informace o módech blokových šifer najdete na Wikipedii v článku Block cipher mode of operation.

Implemetace vhodné pro Arduino

Mám vyzkoušené dvě knihovny AVR-Crypto-Lib a Tiny-AES128-C. První zmiňovaná knihovna implementuje několik různých šifer, je psaná v jazyce C i v assembleru a je optimalizovaná pro 8 bitové mikrokontroléry. V případě AES implementuje všechny tři délky klíčů. Druhá knihovna je psaná v jazyce C, implementuje pouze AES s délkou klíče 128 a režimy ECB a CBC.

Obě se dají použít v AVR, resp. Arduinu. Knihovna Tiny-AES128-C si své jméno opravdu zaslouží. Po kompilaci zabírá cca 2,5 kB paměti flash. Můj test pro ATMega1284P používající oba režimy ECB a CBC zabíral 4570 bajtů paměti flash a 1258 paměti RAM. Když jsem použil pouze šifrování v režimu CBC, pak kód zabíral 2534 B flash a 1044 B RAM (z toho 160 bajtů pro klíč, inicializační vektor a data).

Tiny-AES128-C a Arduino

Následující kód vypíše na Serial tajný klíč, inicializační vektor, data před zašifrováním a data po zašifrování. K šifrování se používá funkce AES128_CBC_encrypt_buffer() z knihovny Tiny-AES128-C.

Kód jsem odzkoušel pro Arduino Uno a po překladu zabírá 5498 bajtů flash a 1097 bajtů RAM.

#include <stdio.h>
#include <string.h>
#include <stdint.h>

#include &quot;aes.h&quot;

// Tajný klíč o délce 16 bajtů (128 bitů).
static uint8_t key[] = {
    0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
    0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c
};

// Inicializační vektor o délce 16 bajtů.
static uint8_t iv[]  = {
    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
    0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f
};

// Vstupní data o délce 64 bajtů, tedy 4x16 bajtů.
static uint8_t in[]  = {
    // Blok 1
    0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
    0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a,
    // Blok 2
    0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
    0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51,
    // Blok 3
    0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11,
    0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef,
    // Blok 4
    0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
    0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10
};

static uint8_t buffer[64];

/**
 * Očekáváný výstup po zašifrování.
 *   0x76, 0x49, 0xab, 0xac, 0x81, 0x19, 0xb2, 0x46,
 *   0xce, 0xe9, 0x8e, 0x9b, 0x12, 0xe9, 0x19, 0x7d,
 *   0x50, 0x86, 0xcb, 0x9b, 0x50, 0x72, 0x19, 0xee,
 *   0x95, 0xdb, 0x11, 0x3a, 0x91, 0x76, 0x78, 0xb2,
 *   0x73, 0xbe, 0xd6, 0xb8, 0xe3, 0xc1, 0x74, 0x3b,
 *   0x71, 0x16, 0xe6, 0x9e, 0x22, 0x22, 0x95, 0x16, 
 *   0x3f, 0xf1, 0xca, 0xa1, 0x68, 0x1f, 0xac, 0x09,
 *   0x12, 0x0e, 0xca, 0x30, 0x75, 0x86, 0xe1, 0xa7
 */

// Funkce, která vytiskne binární data jako řetězec.
static void print_hex(uint8_t *str) {
    char tmp[4];
    for(uint8_t i = 0; i &lt; 16; ++i) {
        sprintf(tmp, "%02X:", str[i]);
        Serial1.print(tmp);
    }

    Serial1.println();
}

void setup(void) {
    Serial1.begin(57600);
    Serial1.println("Up and running");

    Serial1.println("Key:");
    print_hex(key);

    Serial1.println("IV:");
    print_hex(iv);

    Serial1.println("Data:");
    print_hex(in+0);
    print_hex(in+16);
    print_hex(in+32);
    print_hex(in+48);

    // Zde je nejdůležitější část. Funkce, která zašifruje
    // data v poli `in` a výsledek uloží do `buffer`.
    // Inicializační vektor pro CBC mód je v poli `iv` a
    // tajný klíč v poli `key`.
    AES128_CBC_encrypt_buffer(buffer, in, 64, key, iv);

    Serial1.println("CBC encrypt:");
    print_hex(buffer+0);
    print_hex(buffer+16);
    print_hex(buffer+32);
    print_hex(buffer+48);
}

void loop(void) {}

Zde je ke stažení celý kód včetně knihovny a Makefile.

Závěr

Šifrujte.

Je jedno, jestli děláte hobby projekt nebo profesionální IoT platformu. Na internetu nikdy nevíte, kdo poslouchá a k čemu mohou být vaše data zneužita. Argument „je to zbytečné“ nebo „naše data nejsou tajná“ prostě neobstojí :) zvlášť když je použití šifry AES tak jednoduché – většinu práce už za vás udělali jiní a v případě Arduina stačí vzít knihovnu a tu použít.

A ještě pár poznámek:

AES nijak neřeší výměnu tajných klíčů. K tomu jsou jiné mechanismy. Nejjedodušší je nahrát tajný klíč do paměti zařízení a tuto paměť pak ochránit proti přečtení. Složitější způsob je například Diffieho-Hellmanova výměna klíčů.
AES128 je méně náročnější na výpočet než AES256. AES128 i AES256 je z pohledu dnešních a pravděpodobně i budoucích počítačů nemožné prolomit hrubou silou. Pokud řešíte rychlost šifrování, zvolte AES128.
Funkce rand() ani knihovna TrueRandom nejsou dostatečně kvalitní zdroje náhodných čísel. Nepoužívejte je pro generování tajných klíčů ani IV.