Š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.

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.

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.