La più piccola implementazione AES per i microcontrollori?

Qualcuno può raccomandare una piccola implementazione gratuita di AES-128 Rijndael per i microcontrollori. Idealmente, per PIC18, anche se un'implementazione generale in C sarebbe utile.

La compilazione dell'implementazione axTLS per PIC18 e la crittografia / decrittografia di un blocco richiedono 6 KB di ROM e 750 b di RAM.

La compilazione di rijndael-alg-fst.c per PIC18 e la crittografia / decrittografia di un blocco richiedono 28 KB di ROM e 0,5 KB di RAM.

La compilazione dell'AES di Brian Gladman a 8 bit per PIC18 e la crittografia / decrittografia di un blocco richiedono 19 KB di ROM e 190 byte di RAM.

Sono disponibili varianti specifiche PIC ottimizzate meglio?

(requisiti RAM aggiornati per la versione axTLS)

Mi chiedo come hai ottenuto 7,5 kB di utilizzo della RAM con axTLS. Guardando il codice, tutto il contesto è memorizzato in questa struttura:

typedef struct aes_key_st 
{
    uint16_t rounds;
    uint16_t key_size;
    uint32_t ks[(AES_MAXROUNDS+1)*8];
    uint8_t iv[AES_IV_SIZE];
} AES_CTX;

La dimensione di questa struttura è 2 + 2 + 4 * 15 * 8 + 16 = 504. Non vedo variabili globali in aes.c, le variabili automatiche sono tutte piccole, quindi anche l'uso dello stack è ragionevole. Quindi dove vanno i 7,5 kB? Forse stai cercando di utilizzare l'intera libreria invece di estrarre l'implementazione AES da essa?

Ad ogni modo, questa implementazione sembra piuttosto semplice, preferirei attenermi a questo codice e provare a ottimizzarlo. So che può essere complicato, ma l'apprendimento dei dettagli AES può aiutarti almeno a stimare l'utilizzo minimo assoluto di RAM.

Aggiornamento: ho appena provato a compilare questa libreria su IA-32 Linux e scrivere un semplice test di crittografia CBC AES-128. Ha ottenuto i seguenti risultati (il primo numero è l'esagono di lunghezza della sezione):

 22 .data         00000028  0804a010  0804a010  00001010  2**2
                  CONTENTS, ALLOC, LOAD, DATA
 23 .bss          00000294  0804a040  0804a040  00001038  2**5
                  ALLOC

Sono solo 660 byte di .bss (ho dichiarato AES_CTX come variabile globale). La maggior parte dei .data è occupata da IV e chiave. Non includo .text qui, poiché otterrai risultati totalmente diversi su PIC (le sezioni dei dati dovrebbero avere quasi le stesse dimensioni su entrambe le architetture).

So che questa domanda è un po 'vecchia, ma di recente ho dovuto ricercarla da sola mentre sto implementando AES128 su un PIC16 e un 8051, e quindi ero curioso anche di questa domanda.

Ho usato qualcosa del genere: http://cs.ucsb.edu/~koc/cs178/projects/JT/aes.c e il mio utilizzo di RAM è di circa duecento byte e la dimensione binaria è inferiore a 3kb ROM.

Il mio miglior consiglio è di leggere sulla pagina di Wikipedia http://it.wikipedia.org/wiki/Block_cipher_modes_of_operation e comprendere le diverse modalità, ad esempio il modo in cui AES in modalità OFB utilizza la modalità ECB come elemento base. Anche l'XOR (in modalità OFB) lo rende un'operazione simmetrica, quindi crittografare / decodificare è la stessa funzione che consente anche di risparmiare spazio.

Quando ho capito come funzionava davvero AES, potevo implementarlo in C e quindi testarlo contro le specifiche NIST ** (fai questo! Molto codice trovato online è difettoso) e implementavo solo ciò di cui avevo assolutamente bisogno.

Sono stato in grado di adattare AES128 su un 8051 insieme ad altri firmware RF facendo questa personalizzazione e ottimizzazione. L'utilizzo della RAM (per l'intero sistema) è passato da ~ 2.5kb a poco meno di 2kb, il che significa che non abbiamo dovuto eseguire l'aggiornamento a un 8051 con SRAM da 4kb, ma potevamo continuare a utilizzare la versione SRAM da 2kb più economica.

** I vettori di prova si trovano nell'appendice F in: http://csrc.nist.gov/publications/nistpubs/800-38a/addendum-to-nist_sp800-38A.pdf

MODIFICARE:

Finalmente ottenuto il codice su Github: https://github.com/kokke/tiny-AES-c

Ho ottimizzato un po 'le dimensioni. Output delle dimensioni GCC quando compilato per ARM:

$ arm-none-eabi-gcc -O2 -c aes.c -o aes.o
$ size aes.o
   text    data     bss     dec     hex filename
   1024       0     204    1228     4cc aes.o

Quindi l'utilizzo delle risorse è ora di 1 KB di codice, 204 byte di RAM.

Non ricordo come costruire per il PIC, ma se l'ATR Atmel Mega16 a 8 bit è qualcosa di simile al PIC, l'utilizzo delle risorse è:

$ avr-gcc -Wall -Wextra -mmcu=atmega16 -O2 -c aes.c -o aes.o
$ avr-size aes.o
   text    data     bss     dec     hex filename
   1553       0     198    1751     6d7 aes.o

Quindi 1,5 K di codice e 198 byte di RAM.

Di recente ho preso l'implementazione di axTLS e ho lavorato per ridurlo il più possibile. Puoi facilmente generare da solo le S-box e risparmiare qualche centinaio di byte.

static uint8_t aes_sbox[256];   /** AES S-box  */
static uint8_t aes_isbox[256];  /** AES iS-box */
void AES_generateSBox(void)
{
    uint32_t t[256], i;
    uint32_t x;
    for (i = 0, x = 1; i < 256; i ++)
    {
        t[i] = x;
        x ^= (x << 1) ^ ((x >> 7) * 0x11B);
    }

    aes_sbox[0] = 0x63;
    for (i = 0; i < 255; i ++)
    {
        x = t[255 - i];
        x |= x << 8;
        x ^= (x >> 4) ^ (x >> 5) ^ (x >> 6) ^ (x >> 7);
        aes_sbox[t[i]] = (x ^ 0x63) & 0xFF;
    }
    for (i = 0; i < 256;i++)
    {
         aes_isbox[aes_sbox[i]]=i;
    }
}

Puoi ottenere la fonte completa su: http://ccodeblog.wordpress.com/2012/05/25/aes-implementation-in-300-lines-of-code/

Ho fatto un'implementazione in C, solo AES-128, chiamata aes-min , con licenza MIT. Si rivolge a piccoli microprocessori (ad es. 8 bit) con poca RAM / ROM.

Ha un calcolo opzionale della pianificazione delle chiavi al volo per ridurre i requisiti di memoria (evitando la necessità di una pianificazione completa delle chiavi espansa nella RAM).

È possibile che questa implementazione sia interessante. È da un cripto-libario AVR open source.

Puoi trovare alcune informazioni e statistiche generali (obsolete) sulla dimensione del codice e le prestazioni qui .

AES:

Ho giocato solo con la fonte SHA-1 da quella lib, quindi non posso commentare AES.

Sto usando l'implementazione del Texas per msp430 in un microcontrollore Freescale S08SH8 con 512 RAM e 8k di flash e anche in Arduino senza alcuna rielaborazione.

http://www.ti.com/lit/an/slaa547a/slaa547a.pdf

http://www.ti.com/tool/AES-128

Il più piccolo AES128 che ho scritto per la serie PIC può funzionare con 900 istruzioni e 42 byte di RAM. Lo uso da solo sulla serie PIC12 ma PIC10F206 è anche possibile :-).

Non posso rivelare il codice dal momento che è stato dalla mia azienda, ma l'ho scritto in asm per la serie PIC10-12-16. La crittografia richiede 444 byte di codice inclusa la tabella di ricerca di 256 byte, questo codice includeva anche la funzione di caricamento della chiave che è di circa 25 byte.

Consiglio a tutti di verificare il documento AES e di implementarlo da soli! La maggior parte delle implementazioni sono pessime e usano molti ram e rom.

Ho anche implementato AES128 per dsPIC e PIC24 e uso circa il 70% di spazio in meno del codice rispetto alla lib del microchip e anche il mio codice è un po 'più veloce. Numeri di implementazione dsPIC e PIC24:

"La crittografia richiede circa 2995 cicli. 79.10uS @ 40 MIPS, 197.75uS @ 16 MIPS"

"DecKeySetup richiede circa 567 cicli. 14.20uS @ 40 MIPS, 35.43uS @ 16 MIPS"

"La decodifica richiede circa 3886 cicli. 97.15uS @ 40 MIPS, 242.88uS @ 16 MIPS"

"La dimensione totale del codice è 1050 parole incl tabelle."

Il bello del core PIC24 è che alcune istruzioni sono a 32 bit e questo rende la vita molto più semplice per la costruzione di una piccola implementazione AES128, il mio codice utilizza tutte le istruzioni a 32 bit disponibili ed è completamente a 32 bit in funzione, quindi posso portarlo rapidamente su PIC32 o altri CPU a 32 bit.

AES è molto semplice da implementare solo la maggior parte delle persone non ci prova nemmeno!

Guarda il link: http://www.cs.bc.edu/~straubin/cs381-05/blockciphers/rijndael_ingles2004.swf