¿La implementación de AES más pequeña para microcontroladores?

Me pregunto cómo obtuvo 7.5kB de uso de RAM con axTLS. Mirando el código, todo el contexto se almacena en esta estructura:

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;

El tamaño de esta estructura es 2 + 2 + 4 * 15 * 8 + 16 = 504. No veo variables globales en aes.c, las variables automáticas son todas pequeñas, por lo que el uso de la pila también es razonable. Entonces, ¿a dónde va 7.5kB? ¿Quizás intenta utilizar toda la biblioteca en lugar de simplemente extraer la implementación de AES de ella?

De todos modos, esta implementación parece bastante simple, prefiero seguir este código y tratar de optimizarlo. Sé que puede ser complicado, pero conocer los detalles de AES puede ayudarlo a estimar el uso mínimo absoluto de RAM.

Actualización: Acabo de intentar compilar esta biblioteca en IA-32 Linux y escribir una simple prueba de cifrado CBC AES-128. Obtuvo los siguientes resultados (el primer número es el hex de longitud de la sección):

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

Eso es solo 660 bytes de .bss (he declarado AES_CTX como una variable global). La mayor parte de .data está ocupada por IV y clave. No incluyo .text aquí, ya que obtendrás un resultado totalmente diferente en PIC (las secciones de datos deben ser casi del mismo tamaño en ambas arquitecturas).

Sé que esta pregunta es un poco antigua, pero recientemente tuve que investigarla yo mismo, ya que estoy implementando AES128 en un PIC16 y un 8051, así que también sentía curiosidad por esta pregunta.

He usado algo como esto: enlace y mi uso de RAM es de un par de cientos de bytes y el tamaño binario es inferior a 3kb ROM.

Mi mejor consejo es leer en la página de Wikipedia enlace y entienda los diferentes modos, por ejemplo, cómo AES en modo OFB utiliza el modo ECB como un componente básico. Además, el XOR'ing (en modo OFB) lo convierte en una operación simétrica, por lo que cifrar / descifrar es la misma función que también ahorra espacio.

Cuando entendí cómo funcionaba realmente AES, pude implementarlo en C personalizando un fragmento de código encontrado en la web y luego probarlo según la especificación NIST ** (haga esto; mucho código encontrado en línea es defectuoso) y solo Implementar lo que absolutamente necesité.

Pude ajustar AES128 en un 8051 junto con algún otro firmware de RF al hacer esta personalización y optimización. El uso de RAM (para todo el sistema) se redujo de ~ 2.5kb a solo 2kb, lo que significa que no tuvimos que actualizar a un 8051 con SRAM de 4kb, pero podríamos seguir usando la versión más barata de SRAM de 2kb.

** Los Vectores de prueba se encuentran en el Apéndice F en: enlace

EDIT:

Finalmente obtuve el código en Github: enlace

He optimizado un poco para el tamaño. Salida de tamaño GCC cuando se compila para 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

Por lo tanto, el uso de recursos ahora es de 1 KB de código, 204 bytes de RAM.

No recuerdo cómo compilar para el PIC, pero si el 8bit AVR Atmel Mega16 es similar al PIC, el uso de recursos es:

$ 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

Así que el código 1.5K y 198bytes RAM.

Recientemente tomé la implementación de axTLS y trabajé en reducirla tanto como pude. Puede generar fácilmente las cajas S y ahorrarse unos cientos de bytes.

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;
    }
}

Puede obtener el código fuente completo en: enlace

He estado haciendo una implementación solo en C, AES-128, llamada aes-min , con licencia MIT . Se dirige a pequeños microprocesadores (por ejemplo, 8 bits) con poca RAM / ROM.

Tiene un cálculo de programación de teclas sobre la marcha opcional para reducir los requisitos de memoria (evitando la necesidad de una programación de teclas expandida completa en la RAM).

Puede encontrar implementación interesante. Es de un código abierto AVR crypto-libary.

Puede encontrar información y estadísticas generales (obsoletas) sobre el tamaño y el rendimiento del código aquí .

AES:

Solo jugué con la fuente SHA-1 de esa biblioteca, así que no puedo comentar sobre AES.

Estoy usando la implementación de Texas para msp430 en un microcontrolador Freescale S08SH8 con 512 RAM y 8k de flash y también en Arduino sin ningún trabajo adicional.

enlace

enlace

El AES128 más pequeño que escribí para la serie PIC puede ejecutarse en 900 instrucciones y 42 bytes de RAM. Lo uso yo mismo en la serie PIC12, pero PIC10F206 también es posible :-).

No puedo revelar el código desde mi compañía, pero lo escribí en asm para la serie PIC10-12-16. El cifrado toma 444 bytes de código, incluida una tabla de búsqueda de 256 bytes, este código también incluye la función de carga de claves, que es de unos 25 bytes.

¡Todos los consejos para revisar el documento de AES e implementarlo usted mismo! La mayoría de las implementaciones son muy malas y usan mucho ram y rom.

También implementé AES128 para dsPIC y PIC24 y uso un 70% menos de espacio de código en comparación con la lib del microchip y mi código también es un poco más rápido. Números de implementación de dsPIC y PIC24:

"El cifrado lleva aproximadamente 2995 ciclos. 79.10uS @ 40 MIPS, 197.75uS @ 16 MIPS"

"DecKeySetup toma aproximadamente 567 ciclos. 14.20uS @ 40 MIPS, 35.43uS @ 16 MIPS"

"El descifrado lleva aproximadamente 3886 ciclos. 97.15uS @ 40 MIPS, 242.88uS @ 16 MIPS"

"El tamaño total del código es de 1050 palabras, incluidas las tablas".

La belleza del núcleo de PIC24 es que algunas instrucciones son de 32 bits y esto hace que la vida sea mucho más fácil para construir una pequeña implementación de AES128. Mi código usa todas las instrucciones de 32 bits disponibles y está completamente en funcionamiento a 32 bits, por lo que puedo transferir el codifique rápidamente a PIC32 u otro cpu de 32 bits.

AES es muy simple de implementar, solo la mayoría de las personas no lo intentan.

Mire el enlace: enlace