aes_keyschedule.c

   1 /* aes_keyschedule.c */
   2 /*
   3     This file is part of the Crypto-avr-lib/microcrypt-lib.
   4     Copyright (C) 2008  Daniel Otte (daniel.otte@rub.de)
   5
   6     This program is free software: you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation, either version 3 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18 */
  19 /**
  20  * \file     aes_keyschedule.c
  21  * \email    daniel.otte@rub.de
  22  * \author   Daniel Otte
  23  * \date     2008-12-30
  24  * \license  GPLv3 or later
  25  *
  26  */
  27
  28 #include <stdint.h>
  29 #include "gf256mul.h"
  30 #include "aes.h"
  31 #include "aes_keyschedule.h"
  32 #include "aes_sbox.h"
  33 #include <string.h>
  34 #include <avr/pgmspace.h>
  35
  36 static
  37 void aes_rotword(void* a){
  38         uint8_t t;
  39         t=((uint8_t*)a)[0];
  40         ((uint8_t*)a)[0] = ((uint8_t*)a)[1];
  41         ((uint8_t*)a)[1] = ((uint8_t*)a)[2];
  42         ((uint8_t*)a)[2] = ((uint8_t*)a)[3];
  43         ((uint8_t*)a)[3] = t;
  44 }
  45
  46 #include "uart.h"
  47
  48 void aes_init(const void* key, uint16_t keysize_b, aes_genctx_t* ctx){
  49         uint8_t hi,i,nk;
  50         uint8_t rc=1;
  51         uint8_t tmp[4];
  52         nk=keysize_b/32;
  53         hi=4*(nk+6+1);
  54         memcpy(ctx, key, keysize_b/8);
  55         i=keysize_b/32;
  56         for(i=nk;i<hi;++i){
  57                 *((uint32_t*)tmp) = ((uint32_t*)(ctx->key[0].ks))[i-1];
  58         //      uart_putstr_P(PSTR("\r\nDBG: tmp = "));
  59         //      uart_hexdump(tmp, 4);
  60                 if(i%nk){
  61                         if(nk>6 && i%nk==4){
  62                                 tmp[0] = pgm_read_byte(aes_sbox+tmp[0]);
  63                                 tmp[1] = pgm_read_byte(aes_sbox+tmp[1]);
  64                                 tmp[2] = pgm_read_byte(aes_sbox+tmp[2]);
  65                                 tmp[3] = pgm_read_byte(aes_sbox+tmp[3]);
  66         //                      uart_putstr_P(PSTR("\r\nDBG: after sub = "));
  67         //                      uart_hexdump(tmp, 4);
  68                         }
  69                 } else {
  70                         aes_rotword(tmp);
  71         //              uart_putstr_P(PSTR("\r\nDBG: after rot = "));
  72         //              uart_hexdump(tmp, 4);
  73                         tmp[0] = pgm_read_byte(aes_sbox+tmp[0]);
  74                         tmp[1] = pgm_read_byte(aes_sbox+tmp[1]);
  75                         tmp[2] = pgm_read_byte(aes_sbox+tmp[2]);
  76                         tmp[3] = pgm_read_byte(aes_sbox+tmp[3]);
  77         //              uart_putstr_P(PSTR("\r\nDBG: after sub = "));
  78         //              uart_hexdump(tmp, 4);
  79                         tmp[0] ^= rc;
  80         //              uart_putstr_P(PSTR("\r\nDBG: after xor RC = "));
  81         //              uart_hexdump(tmp, 4);
  82                         rc = gf256mul(2,rc,0x1b);
  83                 }
  84                 ((uint32_t*)(ctx->key[0].ks))[i] = ((uint32_t*)(ctx->key[0].ks))[i-nk]
  85                                                    ^ *((uint32_t*)tmp);
  86         }
  87
  88         uint8_t buffer[16];
  89         for(i=0; i<nk+7; ++i){
  90                 memcpy(buffer, ctx->key[i].ks, 16);
  91                 aes_buffer2state(ctx->key[i].ks, buffer);
  92         }
  93 }
  94
  95 void aes128_init(const void* key, aes128_ctx_t* ctx){
  96         aes_init(key, 128, (aes_genctx_t*)ctx);
  97 }
  98
  99 void aes192_init(const void* key, aes192_ctx_t* ctx){
 100         aes_init(key, 192, (aes_genctx_t*)ctx);
 101 }
 102
 103 void aes256_init(const void* key, aes256_ctx_t* ctx){
 104         aes_init(key, 256, (aes_genctx_t*)ctx);
 105 }