git.zerfleddert.de Git - proxmark3-svn/blob - client/aes.c

   1 /*
   2  *  FIPS-197 compliant AES implementation
   3  *
   4  *  Copyright (C) 2006-2014, Brainspark B.V.
   5  *
   6  *  This file is part of PolarSSL (http://www.polarssl.org)
   7  *  Lead Maintainer: Paul Bakker <polarssl_maintainer at polarssl.org>
   8  *
   9  *  All rights reserved.
  10  *
  11  *  This program is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License as published by
  13  *  the Free Software Foundation; either version 2 of the License, or
  14  *  (at your option) any later version.
  15  *
  16  *  This program is distributed in the hope that it will be useful,
  17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  *  GNU General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License along
  22  *  with this program; if not, write to the Free Software Foundation, Inc.,
  23  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  24  */
  25 /*
  26  *  The AES block cipher was designed by Vincent Rijmen and Joan Daemen.
  27  *
  28  *  http://csrc.nist.gov/encryption/aes/rijndael/Rijndael.pdf
  29  *  http://csrc.nist.gov/publications/fips/fips197/fips-197.pdf
  30  */
  31
  32 #if !defined(POLARSSL_CONFIG_FILE)
  33 #include "polarssl_config.h"
  34 #else
  35 #include POLARSSL_CONFIG_FILE
  36 #endif
  37
  38 #if defined(POLARSSL_AES_C)
  39
  40 #include "aes.h"
  41 #if defined(POLARSSL_PADLOCK_C)
  42 #include "polarssl/padlock.h"
  43 #endif
  44 #if defined(POLARSSL_AESNI_C)
  45 #include "polarssl/aesni.h"
  46 #endif
  47
  48 #if defined(POLARSSL_PLATFORM_C)
  49 #include "polarssl/platform.h"
  50 #else
  51 #define polarssl_printf printf
  52 #endif
  53
  54 #if !defined(POLARSSL_AES_ALT)
  55
  56 /* Implementation that should never be optimized out by the compiler */
  57 static void polarssl_zeroize( void *v, size_t n ) {
  58     volatile unsigned char *p = v; while( n-- ) *p++ = 0;
  59 }
  60
  61 /*
  62  * 32-bit integer manipulation macros (little endian)
  63  */
  64 #ifndef GET_UINT32_LE
  65 #define GET_UINT32_LE(n,b,i)                            \
  66 {                                                       \
  67     (n) = ( (uint32_t) (b)[(i)    ]       )             \
  68         | ( (uint32_t) (b)[(i) + 1] <<  8 )             \
  69         | ( (uint32_t) (b)[(i) + 2] << 16 )             \
  70         | ( (uint32_t) (b)[(i) + 3] << 24 );            \
  71 }
  72 #endif
  73
  74 #ifndef PUT_UINT32_LE
  75 #define PUT_UINT32_LE(n,b,i)                            \
  76 {                                                       \
  77     (b)[(i)    ] = (unsigned char) ( (n)       );       \
  78     (b)[(i) + 1] = (unsigned char) ( (n) >>  8 );       \
  79     (b)[(i) + 2] = (unsigned char) ( (n) >> 16 );       \
  80     (b)[(i) + 3] = (unsigned char) ( (n) >> 24 );       \
  81 }
  82 #endif
  83
  84 #if defined(POLARSSL_PADLOCK_C) &&                      \
  85     ( defined(POLARSSL_HAVE_X86) || defined(PADLOCK_ALIGN16) )
  86 static int aes_padlock_ace = -1;
  87 #endif
  88
  89 #if defined(POLARSSL_AES_ROM_TABLES)
  90 /*
  91  * Forward S-box
  92  */
  93 static const unsigned char FSb[256] =
  94 {
  95     0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5,
  96     0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,
  97     0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0,
  98     0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,
  99     0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC,
 100     0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
 101     0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A,
 102     0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,
 103     0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0,
 104     0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,
 105     0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B,
 106     0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
 107     0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85,
 108     0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,
 109     0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5,
 110     0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,
 111     0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17,
 112     0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
 113     0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88,
 114     0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,
 115     0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C,
 116     0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,
 117     0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9,
 118     0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
 119     0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6,
 120     0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,
 121     0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E,
 122     0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,
 123     0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94,
 124     0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
 125     0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68,
 126     0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16
 127 };
 128
 129 /*
 130  * Forward tables
 131  */
 132 #define FT \
 133 \
 134     V(A5,63,63,C6), V(84,7C,7C,F8), V(99,77,77,EE), V(8D,7B,7B,F6), \
 135     V(0D,F2,F2,FF), V(BD,6B,6B,D6), V(B1,6F,6F,DE), V(54,C5,C5,91), \
 136     V(50,30,30,60), V(03,01,01,02), V(A9,67,67,CE), V(7D,2B,2B,56), \
 137     V(19,FE,FE,E7), V(62,D7,D7,B5), V(E6,AB,AB,4D), V(9A,76,76,EC), \
 138     V(45,CA,CA,8F), V(9D,82,82,1F), V(40,C9,C9,89), V(87,7D,7D,FA), \
 139     V(15,FA,FA,EF), V(EB,59,59,B2), V(C9,47,47,8E), V(0B,F0,F0,FB), \
 140     V(EC,AD,AD,41), V(67,D4,D4,B3), V(FD,A2,A2,5F), V(EA,AF,AF,45), \
 141     V(BF,9C,9C,23), V(F7,A4,A4,53), V(96,72,72,E4), V(5B,C0,C0,9B), \
 142     V(C2,B7,B7,75), V(1C,FD,FD,E1), V(AE,93,93,3D), V(6A,26,26,4C), \
 143     V(5A,36,36,6C), V(41,3F,3F,7E), V(02,F7,F7,F5), V(4F,CC,CC,83), \
 144     V(5C,34,34,68), V(F4,A5,A5,51), V(34,E5,E5,D1), V(08,F1,F1,F9), \
 145     V(93,71,71,E2), V(73,D8,D8,AB), V(53,31,31,62), V(3F,15,15,2A), \
 146     V(0C,04,04,08), V(52,C7,C7,95), V(65,23,23,46), V(5E,C3,C3,9D), \
 147     V(28,18,18,30), V(A1,96,96,37), V(0F,05,05,0A), V(B5,9A,9A,2F), \
 148     V(09,07,07,0E), V(36,12,12,24), V(9B,80,80,1B), V(3D,E2,E2,DF), \
 149     V(26,EB,EB,CD), V(69,27,27,4E), V(CD,B2,B2,7F), V(9F,75,75,EA), \
 150     V(1B,09,09,12), V(9E,83,83,1D), V(74,2C,2C,58), V(2E,1A,1A,34), \
 151     V(2D,1B,1B,36), V(B2,6E,6E,DC), V(EE,5A,5A,B4), V(FB,A0,A0,5B), \
 152     V(F6,52,52,A4), V(4D,3B,3B,76), V(61,D6,D6,B7), V(CE,B3,B3,7D), \
 153     V(7B,29,29,52), V(3E,E3,E3,DD), V(71,2F,2F,5E), V(97,84,84,13), \
 154     V(F5,53,53,A6), V(68,D1,D1,B9), V(00,00,00,00), V(2C,ED,ED,C1), \
 155     V(60,20,20,40), V(1F,FC,FC,E3), V(C8,B1,B1,79), V(ED,5B,5B,B6), \
 156     V(BE,6A,6A,D4), V(46,CB,CB,8D), V(D9,BE,BE,67), V(4B,39,39,72), \
 157     V(DE,4A,4A,94), V(D4,4C,4C,98), V(E8,58,58,B0), V(4A,CF,CF,85), \
 158     V(6B,D0,D0,BB), V(2A,EF,EF,C5), V(E5,AA,AA,4F), V(16,FB,FB,ED), \
 159     V(C5,43,43,86), V(D7,4D,4D,9A), V(55,33,33,66), V(94,85,85,11), \
 160     V(CF,45,45,8A), V(10,F9,F9,E9), V(06,02,02,04), V(81,7F,7F,FE), \
 161     V(F0,50,50,A0), V(44,3C,3C,78), V(BA,9F,9F,25), V(E3,A8,A8,4B), \
 162     V(F3,51,51,A2), V(FE,A3,A3,5D), V(C0,40,40,80), V(8A,8F,8F,05), \
 163     V(AD,92,92,3F), V(BC,9D,9D,21), V(48,38,38,70), V(04,F5,F5,F1), \
 164     V(DF,BC,BC,63), V(C1,B6,B6,77), V(75,DA,DA,AF), V(63,21,21,42), \
 165     V(30,10,10,20), V(1A,FF,FF,E5), V(0E,F3,F3,FD), V(6D,D2,D2,BF), \
 166     V(4C,CD,CD,81), V(14,0C,0C,18), V(35,13,13,26), V(2F,EC,EC,C3), \
 167     V(E1,5F,5F,BE), V(A2,97,97,35), V(CC,44,44,88), V(39,17,17,2E), \
 168     V(57,C4,C4,93), V(F2,A7,A7,55), V(82,7E,7E,FC), V(47,3D,3D,7A), \
 169     V(AC,64,64,C8), V(E7,5D,5D,BA), V(2B,19,19,32), V(95,73,73,E6), \
 170     V(A0,60,60,C0), V(98,81,81,19), V(D1,4F,4F,9E), V(7F,DC,DC,A3), \
 171     V(66,22,22,44), V(7E,2A,2A,54), V(AB,90,90,3B), V(83,88,88,0B), \
 172     V(CA,46,46,8C), V(29,EE,EE,C7), V(D3,B8,B8,6B), V(3C,14,14,28), \
 173     V(79,DE,DE,A7), V(E2,5E,5E,BC), V(1D,0B,0B,16), V(76,DB,DB,AD), \
 174     V(3B,E0,E0,DB), V(56,32,32,64), V(4E,3A,3A,74), V(1E,0A,0A,14), \
 175     V(DB,49,49,92), V(0A,06,06,0C), V(6C,24,24,48), V(E4,5C,5C,B8), \
 176     V(5D,C2,C2,9F), V(6E,D3,D3,BD), V(EF,AC,AC,43), V(A6,62,62,C4), \
 177     V(A8,91,91,39), V(A4,95,95,31), V(37,E4,E4,D3), V(8B,79,79,F2), \
 178     V(32,E7,E7,D5), V(43,C8,C8,8B), V(59,37,37,6E), V(B7,6D,6D,DA), \
 179     V(8C,8D,8D,01), V(64,D5,D5,B1), V(D2,4E,4E,9C), V(E0,A9,A9,49), \
 180     V(B4,6C,6C,D8), V(FA,56,56,AC), V(07,F4,F4,F3), V(25,EA,EA,CF), \
 181     V(AF,65,65,CA), V(8E,7A,7A,F4), V(E9,AE,AE,47), V(18,08,08,10), \
 182     V(D5,BA,BA,6F), V(88,78,78,F0), V(6F,25,25,4A), V(72,2E,2E,5C), \
 183     V(24,1C,1C,38), V(F1,A6,A6,57), V(C7,B4,B4,73), V(51,C6,C6,97), \
 184     V(23,E8,E8,CB), V(7C,DD,DD,A1), V(9C,74,74,E8), V(21,1F,1F,3E), \
 185     V(DD,4B,4B,96), V(DC,BD,BD,61), V(86,8B,8B,0D), V(85,8A,8A,0F), \
 186     V(90,70,70,E0), V(42,3E,3E,7C), V(C4,B5,B5,71), V(AA,66,66,CC), \
 187     V(D8,48,48,90), V(05,03,03,06), V(01,F6,F6,F7), V(12,0E,0E,1C), \
 188     V(A3,61,61,C2), V(5F,35,35,6A), V(F9,57,57,AE), V(D0,B9,B9,69), \
 189     V(91,86,86,17), V(58,C1,C1,99), V(27,1D,1D,3A), V(B9,9E,9E,27), \
 190     V(38,E1,E1,D9), V(13,F8,F8,EB), V(B3,98,98,2B), V(33,11,11,22), \
 191     V(BB,69,69,D2), V(70,D9,D9,A9), V(89,8E,8E,07), V(A7,94,94,33), \
 192     V(B6,9B,9B,2D), V(22,1E,1E,3C), V(92,87,87,15), V(20,E9,E9,C9), \
 193     V(49,CE,CE,87), V(FF,55,55,AA), V(78,28,28,50), V(7A,DF,DF,A5), \
 194     V(8F,8C,8C,03), V(F8,A1,A1,59), V(80,89,89,09), V(17,0D,0D,1A), \
 195     V(DA,BF,BF,65), V(31,E6,E6,D7), V(C6,42,42,84), V(B8,68,68,D0), \
 196     V(C3,41,41,82), V(B0,99,99,29), V(77,2D,2D,5A), V(11,0F,0F,1E), \
 197     V(CB,B0,B0,7B), V(FC,54,54,A8), V(D6,BB,BB,6D), V(3A,16,16,2C)
 198
 199 #define V(a,b,c,d) 0x##a##b##c##d
 200 static const uint32_t FT0[256] = { FT };
 201 #undef V
 202
 203 #define V(a,b,c,d) 0x##b##c##d##a
 204 static const uint32_t FT1[256] = { FT };
 205 #undef V
 206
 207 #define V(a,b,c,d) 0x##c##d##a##b
 208 static const uint32_t FT2[256] = { FT };
 209 #undef V
 210
 211 #define V(a,b,c,d) 0x##d##a##b##c
 212 static const uint32_t FT3[256] = { FT };
 213 #undef V
 214
 215 #undef FT
 216
 217 /*
 218  * Reverse S-box
 219  */
 220 static const unsigned char RSb[256] =
 221 {
 222     0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38,
 223     0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,
 224     0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87,
 225     0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,
 226     0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D,
 227     0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
 228     0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2,
 229     0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,
 230     0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16,
 231     0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,
 232     0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA,
 233     0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,
 234     0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A,
 235     0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,
 236     0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02,
 237     0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,
 238     0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA,
 239     0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
 240     0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85,
 241     0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,
 242     0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89,
 243     0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,
 244     0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20,
 245     0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
 246     0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31,
 247     0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,
 248     0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D,
 249     0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,
 250     0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0,
 251     0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
 252     0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26,
 253     0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D
 254 };
 255
 256 /*
 257  * Reverse tables
 258  */
 259 #define RT \
 260 \
 261     V(50,A7,F4,51), V(53,65,41,7E), V(C3,A4,17,1A), V(96,5E,27,3A), \
 262     V(CB,6B,AB,3B), V(F1,45,9D,1F), V(AB,58,FA,AC), V(93,03,E3,4B), \
 263     V(55,FA,30,20), V(F6,6D,76,AD), V(91,76,CC,88), V(25,4C,02,F5), \
 264     V(FC,D7,E5,4F), V(D7,CB,2A,C5), V(80,44,35,26), V(8F,A3,62,B5), \
 265     V(49,5A,B1,DE), V(67,1B,BA,25), V(98,0E,EA,45), V(E1,C0,FE,5D), \
 266     V(02,75,2F,C3), V(12,F0,4C,81), V(A3,97,46,8D), V(C6,F9,D3,6B), \
 267     V(E7,5F,8F,03), V(95,9C,92,15), V(EB,7A,6D,BF), V(DA,59,52,95), \
 268     V(2D,83,BE,D4), V(D3,21,74,58), V(29,69,E0,49), V(44,C8,C9,8E), \
 269     V(6A,89,C2,75), V(78,79,8E,F4), V(6B,3E,58,99), V(DD,71,B9,27), \
 270     V(B6,4F,E1,BE), V(17,AD,88,F0), V(66,AC,20,C9), V(B4,3A,CE,7D), \
 271     V(18,4A,DF,63), V(82,31,1A,E5), V(60,33,51,97), V(45,7F,53,62), \
 272     V(E0,77,64,B1), V(84,AE,6B,BB), V(1C,A0,81,FE), V(94,2B,08,F9), \
 273     V(58,68,48,70), V(19,FD,45,8F), V(87,6C,DE,94), V(B7,F8,7B,52), \
 274     V(23,D3,73,AB), V(E2,02,4B,72), V(57,8F,1F,E3), V(2A,AB,55,66), \
 275     V(07,28,EB,B2), V(03,C2,B5,2F), V(9A,7B,C5,86), V(A5,08,37,D3), \
 276     V(F2,87,28,30), V(B2,A5,BF,23), V(BA,6A,03,02), V(5C,82,16,ED), \
 277     V(2B,1C,CF,8A), V(92,B4,79,A7), V(F0,F2,07,F3), V(A1,E2,69,4E), \
 278     V(CD,F4,DA,65), V(D5,BE,05,06), V(1F,62,34,D1), V(8A,FE,A6,C4), \
 279     V(9D,53,2E,34), V(A0,55,F3,A2), V(32,E1,8A,05), V(75,EB,F6,A4), \
 280     V(39,EC,83,0B), V(AA,EF,60,40), V(06,9F,71,5E), V(51,10,6E,BD), \
 281     V(F9,8A,21,3E), V(3D,06,DD,96), V(AE,05,3E,DD), V(46,BD,E6,4D), \
 282     V(B5,8D,54,91), V(05,5D,C4,71), V(6F,D4,06,04), V(FF,15,50,60), \
 283     V(24,FB,98,19), V(97,E9,BD,D6), V(CC,43,40,89), V(77,9E,D9,67), \
 284     V(BD,42,E8,B0), V(88,8B,89,07), V(38,5B,19,E7), V(DB,EE,C8,79), \
 285     V(47,0A,7C,A1), V(E9,0F,42,7C), V(C9,1E,84,F8), V(00,00,00,00), \
 286     V(83,86,80,09), V(48,ED,2B,32), V(AC,70,11,1E), V(4E,72,5A,6C), \
 287     V(FB,FF,0E,FD), V(56,38,85,0F), V(1E,D5,AE,3D), V(27,39,2D,36), \
 288     V(64,D9,0F,0A), V(21,A6,5C,68), V(D1,54,5B,9B), V(3A,2E,36,24), \
 289     V(B1,67,0A,0C), V(0F,E7,57,93), V(D2,96,EE,B4), V(9E,91,9B,1B), \
 290     V(4F,C5,C0,80), V(A2,20,DC,61), V(69,4B,77,5A), V(16,1A,12,1C), \
 291     V(0A,BA,93,E2), V(E5,2A,A0,C0), V(43,E0,22,3C), V(1D,17,1B,12), \
 292     V(0B,0D,09,0E), V(AD,C7,8B,F2), V(B9,A8,B6,2D), V(C8,A9,1E,14), \
 293     V(85,19,F1,57), V(4C,07,75,AF), V(BB,DD,99,EE), V(FD,60,7F,A3), \
 294     V(9F,26,01,F7), V(BC,F5,72,5C), V(C5,3B,66,44), V(34,7E,FB,5B), \
 295     V(76,29,43,8B), V(DC,C6,23,CB), V(68,FC,ED,B6), V(63,F1,E4,B8), \
 296     V(CA,DC,31,D7), V(10,85,63,42), V(40,22,97,13), V(20,11,C6,84), \
 297     V(7D,24,4A,85), V(F8,3D,BB,D2), V(11,32,F9,AE), V(6D,A1,29,C7), \
 298     V(4B,2F,9E,1D), V(F3,30,B2,DC), V(EC,52,86,0D), V(D0,E3,C1,77), \
 299     V(6C,16,B3,2B), V(99,B9,70,A9), V(FA,48,94,11), V(22,64,E9,47), \
 300     V(C4,8C,FC,A8), V(1A,3F,F0,A0), V(D8,2C,7D,56), V(EF,90,33,22), \
 301     V(C7,4E,49,87), V(C1,D1,38,D9), V(FE,A2,CA,8C), V(36,0B,D4,98), \
 302     V(CF,81,F5,A6), V(28,DE,7A,A5), V(26,8E,B7,DA), V(A4,BF,AD,3F), \
 303     V(E4,9D,3A,2C), V(0D,92,78,50), V(9B,CC,5F,6A), V(62,46,7E,54), \
 304     V(C2,13,8D,F6), V(E8,B8,D8,90), V(5E,F7,39,2E), V(F5,AF,C3,82), \
 305     V(BE,80,5D,9F), V(7C,93,D0,69), V(A9,2D,D5,6F), V(B3,12,25,CF), \
 306     V(3B,99,AC,C8), V(A7,7D,18,10), V(6E,63,9C,E8), V(7B,BB,3B,DB), \
 307     V(09,78,26,CD), V(F4,18,59,6E), V(01,B7,9A,EC), V(A8,9A,4F,83), \
 308     V(65,6E,95,E6), V(7E,E6,FF,AA), V(08,CF,BC,21), V(E6,E8,15,EF), \
 309     V(D9,9B,E7,BA), V(CE,36,6F,4A), V(D4,09,9F,EA), V(D6,7C,B0,29), \
 310     V(AF,B2,A4,31), V(31,23,3F,2A), V(30,94,A5,C6), V(C0,66,A2,35), \
 311     V(37,BC,4E,74), V(A6,CA,82,FC), V(B0,D0,90,E0), V(15,D8,A7,33), \
 312     V(4A,98,04,F1), V(F7,DA,EC,41), V(0E,50,CD,7F), V(2F,F6,91,17), \
 313     V(8D,D6,4D,76), V(4D,B0,EF,43), V(54,4D,AA,CC), V(DF,04,96,E4), \
 314     V(E3,B5,D1,9E), V(1B,88,6A,4C), V(B8,1F,2C,C1), V(7F,51,65,46), \
 315     V(04,EA,5E,9D), V(5D,35,8C,01), V(73,74,87,FA), V(2E,41,0B,FB), \
 316     V(5A,1D,67,B3), V(52,D2,DB,92), V(33,56,10,E9), V(13,47,D6,6D), \
 317     V(8C,61,D7,9A), V(7A,0C,A1,37), V(8E,14,F8,59), V(89,3C,13,EB), \
 318     V(EE,27,A9,CE), V(35,C9,61,B7), V(ED,E5,1C,E1), V(3C,B1,47,7A), \
 319     V(59,DF,D2,9C), V(3F,73,F2,55), V(79,CE,14,18), V(BF,37,C7,73), \
 320     V(EA,CD,F7,53), V(5B,AA,FD,5F), V(14,6F,3D,DF), V(86,DB,44,78), \
 321     V(81,F3,AF,CA), V(3E,C4,68,B9), V(2C,34,24,38), V(5F,40,A3,C2), \
 322     V(72,C3,1D,16), V(0C,25,E2,BC), V(8B,49,3C,28), V(41,95,0D,FF), \
 323     V(71,01,A8,39), V(DE,B3,0C,08), V(9C,E4,B4,D8), V(90,C1,56,64), \
 324     V(61,84,CB,7B), V(70,B6,32,D5), V(74,5C,6C,48), V(42,57,B8,D0)
 325
 326 #define V(a,b,c,d) 0x##a##b##c##d
 327 static const uint32_t RT0[256] = { RT };
 328 #undef V
 329
 330 #define V(a,b,c,d) 0x##b##c##d##a
 331 static const uint32_t RT1[256] = { RT };
 332 #undef V
 333
 334 #define V(a,b,c,d) 0x##c##d##a##b
 335 static const uint32_t RT2[256] = { RT };
 336 #undef V
 337
 338 #define V(a,b,c,d) 0x##d##a##b##c
 339 static const uint32_t RT3[256] = { RT };
 340 #undef V
 341
 342 #undef RT
 343
 344 /*
 345  * Round constants
 346  */
 347 static const uint32_t RCON[10] =
 348 {
 349     0x00000001, 0x00000002, 0x00000004, 0x00000008,
 350     0x00000010, 0x00000020, 0x00000040, 0x00000080,
 351     0x0000001B, 0x00000036
 352 };
 353
 354 #else /* POLARSSL_AES_ROM_TABLES */
 355
 356 /*
 357  * Forward S-box & tables
 358  */
 359 static unsigned char FSb[256];
 360 static uint32_t FT0[256];
 361 static uint32_t FT1[256];
 362 static uint32_t FT2[256];
 363 static uint32_t FT3[256];
 364
 365 /*
 366  * Reverse S-box & tables
 367  */
 368 static unsigned char RSb[256];
 369 static uint32_t RT0[256];
 370 static uint32_t RT1[256];
 371 static uint32_t RT2[256];
 372 static uint32_t RT3[256];
 373
 374 /*
 375  * Round constants
 376  */
 377 static uint32_t RCON[10];
 378
 379 /*
 380  * Tables generation code
 381  */
 382 #define ROTL8(x) ( ( x << 8 ) & 0xFFFFFFFF ) | ( x >> 24 )
 383 #define XTIME(x) ( ( x << 1 ) ^ ( ( x & 0x80 ) ? 0x1B : 0x00 ) )
 384 #define MUL(x,y) ( ( x && y ) ? pow[(log[x]+log[y]) % 255] : 0 )
 385
 386 static int aes_init_done = 0;
 387
 388 static void aes_gen_tables( void )
 389 {
 390     int i, x, y, z;
 391     int pow[256];
 392     int log[256];
 393
 394     /*
 395      * compute pow and log tables over GF(2^8)
 396      */
 397     for( i = 0, x = 1; i < 256; i++ )
 398     {
 399         pow[i] = x;
 400         log[x] = i;
 401         x = ( x ^ XTIME( x ) ) & 0xFF;
 402     }
 403
 404     /*
 405      * calculate the round constants
 406      */
 407     for( i = 0, x = 1; i < 10; i++ )
 408     {
 409         RCON[i] = (uint32_t) x;
 410         x = XTIME( x ) & 0xFF;
 411     }
 412
 413     /*
 414      * generate the forward and reverse S-boxes
 415      */
 416     FSb[0x00] = 0x63;
 417     RSb[0x63] = 0x00;
 418
 419     for( i = 1; i < 256; i++ )
 420     {
 421         x = pow[255 - log[i]];
 422
 423         y  = x; y = ( ( y << 1 ) | ( y >> 7 ) ) & 0xFF;
 424         x ^= y; y = ( ( y << 1 ) | ( y >> 7 ) ) & 0xFF;
 425         x ^= y; y = ( ( y << 1 ) | ( y >> 7 ) ) & 0xFF;
 426         x ^= y; y = ( ( y << 1 ) | ( y >> 7 ) ) & 0xFF;
 427         x ^= y ^ 0x63;
 428
 429         FSb[i] = (unsigned char) x;
 430         RSb[x] = (unsigned char) i;
 431     }
 432
 433     /*
 434      * generate the forward and reverse tables
 435      */
 436     for( i = 0; i < 256; i++ )
 437     {
 438         x = FSb[i];
 439         y = XTIME( x ) & 0xFF;
 440         z =  ( y ^ x ) & 0xFF;
 441
 442         FT0[i] = ( (uint32_t) y       ) ^
 443                  ( (uint32_t) x <<  8 ) ^
 444                  ( (uint32_t) x << 16 ) ^
 445                  ( (uint32_t) z << 24 );
 446
 447         FT1[i] = ROTL8( FT0[i] );
 448         FT2[i] = ROTL8( FT1[i] );
 449         FT3[i] = ROTL8( FT2[i] );
 450
 451         x = RSb[i];
 452
 453         RT0[i] = ( (uint32_t) MUL( 0x0E, x )       ) ^
 454                  ( (uint32_t) MUL( 0x09, x ) <<  8 ) ^
 455                  ( (uint32_t) MUL( 0x0D, x ) << 16 ) ^
 456                  ( (uint32_t) MUL( 0x0B, x ) << 24 );
 457
 458         RT1[i] = ROTL8( RT0[i] );
 459         RT2[i] = ROTL8( RT1[i] );
 460         RT3[i] = ROTL8( RT2[i] );
 461     }
 462 }
 463
 464 #endif /* POLARSSL_AES_ROM_TABLES */
 465
 466 void aes_init( aes_context *ctx )
 467 {
 468     memset( ctx, 0, sizeof( aes_context ) );
 469 }
 470
 471 void aes_free( aes_context *ctx )
 472 {
 473     if( ctx == NULL )
 474         return;
 475
 476     polarssl_zeroize( ctx, sizeof( aes_context ) );
 477 }
 478
 479 /*
 480  * AES key schedule (encryption)
 481  */
 482 int aes_setkey_enc( aes_context *ctx, const unsigned char *key,
 483                     unsigned int keysize )
 484 {
 485     unsigned int i;
 486     uint32_t *RK;
 487
 488 #if !defined(POLARSSL_AES_ROM_TABLES)
 489     if( aes_init_done == 0 )
 490     {
 491         aes_gen_tables();
 492         aes_init_done = 1;
 493
 494     }
 495 #endif
 496
 497     switch( keysize )
 498     {
 499         case 128: ctx->nr = 10; break;
 500         case 192: ctx->nr = 12; break;
 501         case 256: ctx->nr = 14; break;
 502         default : return( POLARSSL_ERR_AES_INVALID_KEY_LENGTH );
 503     }
 504
 505 #if defined(POLARSSL_PADLOCK_C) && defined(PADLOCK_ALIGN16)
 506     if( aes_padlock_ace == -1 )
 507         aes_padlock_ace = padlock_supports( PADLOCK_ACE );
 508
 509     if( aes_padlock_ace )
 510         ctx->rk = RK = PADLOCK_ALIGN16( ctx->buf );
 511     else
 512 #endif
 513     ctx->rk = RK = ctx->buf;
 514
 515 #if defined(POLARSSL_AESNI_C) && defined(POLARSSL_HAVE_X86_64)
 516     if( aesni_supports( POLARSSL_AESNI_AES ) )
 517         return( aesni_setkey_enc( (unsigned char *) ctx->rk, key, keysize ) );
 518 #endif
 519
 520     for( i = 0; i < ( keysize >> 5 ); i++ )
 521     {
 522         GET_UINT32_LE( RK[i], key, i << 2 );
 523     }
 524
 525     switch( ctx->nr )
 526     {
 527         case 10:
 528
 529             for( i = 0; i < 10; i++, RK += 4 )
 530             {
 531                 RK[4]  = RK[0] ^ RCON[i] ^
 532                 ( (uint32_t) FSb[ ( RK[3] >>  8 ) & 0xFF ]       ) ^
 533                 ( (uint32_t) FSb[ ( RK[3] >> 16 ) & 0xFF ] <<  8 ) ^
 534                 ( (uint32_t) FSb[ ( RK[3] >> 24 ) & 0xFF ] << 16 ) ^
 535                 ( (uint32_t) FSb[ ( RK[3]       ) & 0xFF ] << 24 );
 536
 537                 RK[5]  = RK[1] ^ RK[4];
 538                 RK[6]  = RK[2] ^ RK[5];
 539                 RK[7]  = RK[3] ^ RK[6];
 540             }
 541             break;
 542
 543         case 12:
 544
 545             for( i = 0; i < 8; i++, RK += 6 )
 546             {
 547                 RK[6]  = RK[0] ^ RCON[i] ^
 548                 ( (uint32_t) FSb[ ( RK[5] >>  8 ) & 0xFF ]       ) ^
 549                 ( (uint32_t) FSb[ ( RK[5] >> 16 ) & 0xFF ] <<  8 ) ^
 550                 ( (uint32_t) FSb[ ( RK[5] >> 24 ) & 0xFF ] << 16 ) ^
 551                 ( (uint32_t) FSb[ ( RK[5]       ) & 0xFF ] << 24 );
 552
 553                 RK[7]  = RK[1] ^ RK[6];
 554                 RK[8]  = RK[2] ^ RK[7];
 555                 RK[9]  = RK[3] ^ RK[8];
 556                 RK[10] = RK[4] ^ RK[9];
 557                 RK[11] = RK[5] ^ RK[10];
 558             }
 559             break;
 560
 561         case 14:
 562
 563             for( i = 0; i < 7; i++, RK += 8 )
 564             {
 565                 RK[8]  = RK[0] ^ RCON[i] ^
 566                 ( (uint32_t) FSb[ ( RK[7] >>  8 ) & 0xFF ]       ) ^
 567                 ( (uint32_t) FSb[ ( RK[7] >> 16 ) & 0xFF ] <<  8 ) ^
 568                 ( (uint32_t) FSb[ ( RK[7] >> 24 ) & 0xFF ] << 16 ) ^
 569                 ( (uint32_t) FSb[ ( RK[7]       ) & 0xFF ] << 24 );
 570
 571                 RK[9]  = RK[1] ^ RK[8];
 572                 RK[10] = RK[2] ^ RK[9];
 573                 RK[11] = RK[3] ^ RK[10];
 574
 575                 RK[12] = RK[4] ^
 576                 ( (uint32_t) FSb[ ( RK[11]       ) & 0xFF ]       ) ^
 577                 ( (uint32_t) FSb[ ( RK[11] >>  8 ) & 0xFF ] <<  8 ) ^
 578                 ( (uint32_t) FSb[ ( RK[11] >> 16 ) & 0xFF ] << 16 ) ^
 579                 ( (uint32_t) FSb[ ( RK[11] >> 24 ) & 0xFF ] << 24 );
 580
 581                 RK[13] = RK[5] ^ RK[12];
 582                 RK[14] = RK[6] ^ RK[13];
 583                 RK[15] = RK[7] ^ RK[14];
 584             }
 585             break;
 586     }
 587
 588     return( 0 );
 589 }
 590
 591 /*
 592  * AES key schedule (decryption)
 593  */
 594 int aes_setkey_dec( aes_context *ctx, const unsigned char *key,
 595                     unsigned int keysize )
 596 {
 597     int i, j, ret;
 598     aes_context cty;
 599     uint32_t *RK;
 600     uint32_t *SK;
 601
 602     aes_init( &cty );
 603
 604 #if defined(POLARSSL_PADLOCK_C) && defined(PADLOCK_ALIGN16)
 605     if( aes_padlock_ace == -1 )
 606         aes_padlock_ace = padlock_supports( PADLOCK_ACE );
 607
 608     if( aes_padlock_ace )
 609         ctx->rk = RK = PADLOCK_ALIGN16( ctx->buf );
 610     else
 611 #endif
 612     ctx->rk = RK = ctx->buf;
 613
 614     /* Also checks keysize */
 615     if( ( ret = aes_setkey_enc( &cty, key, keysize ) ) != 0 )
 616         goto exit;
 617
 618     ctx->nr = cty.nr;
 619
 620 #if defined(POLARSSL_AESNI_C) && defined(POLARSSL_HAVE_X86_64)
 621     if( aesni_supports( POLARSSL_AESNI_AES ) )
 622     {
 623         aesni_inverse_key( (unsigned char *) ctx->rk,
 624                            (const unsigned char *) cty.rk, ctx->nr );
 625         goto exit;
 626     }
 627 #endif
 628
 629     SK = cty.rk + cty.nr * 4;
 630
 631     *RK++ = *SK++;
 632     *RK++ = *SK++;
 633     *RK++ = *SK++;
 634     *RK++ = *SK++;
 635
 636     for( i = ctx->nr - 1, SK -= 8; i > 0; i--, SK -= 8 )
 637     {
 638         for( j = 0; j < 4; j++, SK++ )
 639         {
 640             *RK++ = RT0[ FSb[ ( *SK       ) & 0xFF ] ] ^
 641                     RT1[ FSb[ ( *SK >>  8 ) & 0xFF ] ] ^
 642                     RT2[ FSb[ ( *SK >> 16 ) & 0xFF ] ] ^
 643                     RT3[ FSb[ ( *SK >> 24 ) & 0xFF ] ];
 644         }
 645     }
 646
 647     *RK++ = *SK++;
 648     *RK++ = *SK++;
 649     *RK++ = *SK++;
 650     *RK++ = *SK++;
 651
 652 exit:
 653     aes_free( &cty );
 654
 655     return( ret );
 656 }
 657
 658 #define AES_FROUND(X0,X1,X2,X3,Y0,Y1,Y2,Y3)     \
 659 {                                               \
 660     X0 = *RK++ ^ FT0[ ( Y0       ) & 0xFF ] ^   \
 661                  FT1[ ( Y1 >>  8 ) & 0xFF ] ^   \
 662                  FT2[ ( Y2 >> 16 ) & 0xFF ] ^   \
 663                  FT3[ ( Y3 >> 24 ) & 0xFF ];    \
 664                                                 \
 665     X1 = *RK++ ^ FT0[ ( Y1       ) & 0xFF ] ^   \
 666                  FT1[ ( Y2 >>  8 ) & 0xFF ] ^   \
 667                  FT2[ ( Y3 >> 16 ) & 0xFF ] ^   \
 668                  FT3[ ( Y0 >> 24 ) & 0xFF ];    \
 669                                                 \
 670     X2 = *RK++ ^ FT0[ ( Y2       ) & 0xFF ] ^   \
 671                  FT1[ ( Y3 >>  8 ) & 0xFF ] ^   \
 672                  FT2[ ( Y0 >> 16 ) & 0xFF ] ^   \
 673                  FT3[ ( Y1 >> 24 ) & 0xFF ];    \
 674                                                 \
 675     X3 = *RK++ ^ FT0[ ( Y3       ) & 0xFF ] ^   \
 676                  FT1[ ( Y0 >>  8 ) & 0xFF ] ^   \
 677                  FT2[ ( Y1 >> 16 ) & 0xFF ] ^   \
 678                  FT3[ ( Y2 >> 24 ) & 0xFF ];    \
 679 }
 680
 681 #define AES_RROUND(X0,X1,X2,X3,Y0,Y1,Y2,Y3)     \
 682 {                                               \
 683     X0 = *RK++ ^ RT0[ ( Y0       ) & 0xFF ] ^   \
 684                  RT1[ ( Y3 >>  8 ) & 0xFF ] ^   \
 685                  RT2[ ( Y2 >> 16 ) & 0xFF ] ^   \
 686                  RT3[ ( Y1 >> 24 ) & 0xFF ];    \
 687                                                 \
 688     X1 = *RK++ ^ RT0[ ( Y1       ) & 0xFF ] ^   \
 689                  RT1[ ( Y0 >>  8 ) & 0xFF ] ^   \
 690                  RT2[ ( Y3 >> 16 ) & 0xFF ] ^   \
 691                  RT3[ ( Y2 >> 24 ) & 0xFF ];    \
 692                                                 \
 693     X2 = *RK++ ^ RT0[ ( Y2       ) & 0xFF ] ^   \
 694                  RT1[ ( Y1 >>  8 ) & 0xFF ] ^   \
 695                  RT2[ ( Y0 >> 16 ) & 0xFF ] ^   \
 696                  RT3[ ( Y3 >> 24 ) & 0xFF ];    \
 697                                                 \
 698     X3 = *RK++ ^ RT0[ ( Y3       ) & 0xFF ] ^   \
 699                  RT1[ ( Y2 >>  8 ) & 0xFF ] ^   \
 700                  RT2[ ( Y1 >> 16 ) & 0xFF ] ^   \
 701                  RT3[ ( Y0 >> 24 ) & 0xFF ];    \
 702 }
 703
 704 /*
 705  * AES-ECB block encryption/decryption
 706  */
 707 int aes_crypt_ecb( aes_context *ctx,
 708                     int mode,
 709                     const unsigned char input[16],
 710                     unsigned char output[16] )
 711 {
 712     int i;
 713     uint32_t *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3;
 714
 715 #if defined(POLARSSL_AESNI_C) && defined(POLARSSL_HAVE_X86_64)
 716     if( aesni_supports( POLARSSL_AESNI_AES ) )
 717         return( aesni_crypt_ecb( ctx, mode, input, output ) );
 718 #endif
 719
 720 #if defined(POLARSSL_PADLOCK_C) && defined(POLARSSL_HAVE_X86)
 721     if( aes_padlock_ace )
 722     {
 723         if( padlock_xcryptecb( ctx, mode, input, output ) == 0 )
 724             return( 0 );
 725
 726         // If padlock data misaligned, we just fall back to
 727         // unaccelerated mode
 728         //
 729     }
 730 #endif
 731
 732     RK = ctx->rk;
 733
 734     GET_UINT32_LE( X0, input,  0 ); X0 ^= *RK++;
 735     GET_UINT32_LE( X1, input,  4 ); X1 ^= *RK++;
 736     GET_UINT32_LE( X2, input,  8 ); X2 ^= *RK++;
 737     GET_UINT32_LE( X3, input, 12 ); X3 ^= *RK++;
 738
 739     if( mode == AES_DECRYPT )
 740     {
 741         for( i = ( ctx->nr >> 1 ) - 1; i > 0; i-- )
 742         {
 743             AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
 744             AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
 745         }
 746
 747         AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
 748
 749         X0 = *RK++ ^ \
 750                 ( (uint32_t) RSb[ ( Y0       ) & 0xFF ]       ) ^
 751                 ( (uint32_t) RSb[ ( Y3 >>  8 ) & 0xFF ] <<  8 ) ^
 752                 ( (uint32_t) RSb[ ( Y2 >> 16 ) & 0xFF ] << 16 ) ^
 753                 ( (uint32_t) RSb[ ( Y1 >> 24 ) & 0xFF ] << 24 );
 754
 755         X1 = *RK++ ^ \
 756                 ( (uint32_t) RSb[ ( Y1       ) & 0xFF ]       ) ^
 757                 ( (uint32_t) RSb[ ( Y0 >>  8 ) & 0xFF ] <<  8 ) ^
 758                 ( (uint32_t) RSb[ ( Y3 >> 16 ) & 0xFF ] << 16 ) ^
 759                 ( (uint32_t) RSb[ ( Y2 >> 24 ) & 0xFF ] << 24 );
 760
 761         X2 = *RK++ ^ \
 762                 ( (uint32_t) RSb[ ( Y2       ) & 0xFF ]       ) ^
 763                 ( (uint32_t) RSb[ ( Y1 >>  8 ) & 0xFF ] <<  8 ) ^
 764                 ( (uint32_t) RSb[ ( Y0 >> 16 ) & 0xFF ] << 16 ) ^
 765                 ( (uint32_t) RSb[ ( Y3 >> 24 ) & 0xFF ] << 24 );
 766
 767         X3 = *RK++ ^ \
 768                 ( (uint32_t) RSb[ ( Y3       ) & 0xFF ]       ) ^
 769                 ( (uint32_t) RSb[ ( Y2 >>  8 ) & 0xFF ] <<  8 ) ^
 770                 ( (uint32_t) RSb[ ( Y1 >> 16 ) & 0xFF ] << 16 ) ^
 771                 ( (uint32_t) RSb[ ( Y0 >> 24 ) & 0xFF ] << 24 );
 772     }
 773     else /* AES_ENCRYPT */
 774     {
 775         for( i = ( ctx->nr >> 1 ) - 1; i > 0; i-- )
 776         {
 777             AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
 778             AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
 779         }
 780
 781         AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
 782
 783         X0 = *RK++ ^ \
 784                 ( (uint32_t) FSb[ ( Y0       ) & 0xFF ]       ) ^
 785                 ( (uint32_t) FSb[ ( Y1 >>  8 ) & 0xFF ] <<  8 ) ^
 786                 ( (uint32_t) FSb[ ( Y2 >> 16 ) & 0xFF ] << 16 ) ^
 787                 ( (uint32_t) FSb[ ( Y3 >> 24 ) & 0xFF ] << 24 );
 788
 789         X1 = *RK++ ^ \
 790                 ( (uint32_t) FSb[ ( Y1       ) & 0xFF ]       ) ^
 791                 ( (uint32_t) FSb[ ( Y2 >>  8 ) & 0xFF ] <<  8 ) ^
 792                 ( (uint32_t) FSb[ ( Y3 >> 16 ) & 0xFF ] << 16 ) ^
 793                 ( (uint32_t) FSb[ ( Y0 >> 24 ) & 0xFF ] << 24 );
 794
 795         X2 = *RK++ ^ \
 796                 ( (uint32_t) FSb[ ( Y2       ) & 0xFF ]       ) ^
 797                 ( (uint32_t) FSb[ ( Y3 >>  8 ) & 0xFF ] <<  8 ) ^
 798                 ( (uint32_t) FSb[ ( Y0 >> 16 ) & 0xFF ] << 16 ) ^
 799                 ( (uint32_t) FSb[ ( Y1 >> 24 ) & 0xFF ] << 24 );
 800
 801         X3 = *RK++ ^ \
 802                 ( (uint32_t) FSb[ ( Y3       ) & 0xFF ]       ) ^
 803                 ( (uint32_t) FSb[ ( Y0 >>  8 ) & 0xFF ] <<  8 ) ^
 804                 ( (uint32_t) FSb[ ( Y1 >> 16 ) & 0xFF ] << 16 ) ^
 805                 ( (uint32_t) FSb[ ( Y2 >> 24 ) & 0xFF ] << 24 );
 806     }
 807
 808     PUT_UINT32_LE( X0, output,  0 );
 809     PUT_UINT32_LE( X1, output,  4 );
 810     PUT_UINT32_LE( X2, output,  8 );
 811     PUT_UINT32_LE( X3, output, 12 );
 812
 813     return( 0 );
 814 }
 815
 816 #if defined(POLARSSL_CIPHER_MODE_CBC)
 817 /*
 818  * AES-CBC buffer encryption/decryption
 819  */
 820 int aes_crypt_cbc( aes_context *ctx,
 821                     int mode,
 822                     size_t length,
 823                     unsigned char iv[16],
 824                     const unsigned char *input,
 825                     unsigned char *output )
 826 {
 827     int i;
 828     unsigned char temp[16];
 829
 830     if( length % 16 )
 831         return( POLARSSL_ERR_AES_INVALID_INPUT_LENGTH );
 832
 833 #if defined(POLARSSL_PADLOCK_C) && defined(POLARSSL_HAVE_X86)
 834     if( aes_padlock_ace )
 835     {
 836         if( padlock_xcryptcbc( ctx, mode, length, iv, input, output ) == 0 )
 837             return( 0 );
 838
 839         // If padlock data misaligned, we just fall back to
 840         // unaccelerated mode
 841         //
 842     }
 843 #endif
 844
 845     if( mode == AES_DECRYPT )
 846     {
 847         while( length > 0 )
 848         {
 849             memcpy( temp, input, 16 );
 850             aes_crypt_ecb( ctx, mode, input, output );
 851
 852             for( i = 0; i < 16; i++ )
 853                 output[i] = (unsigned char)( output[i] ^ iv[i] );
 854
 855             memcpy( iv, temp, 16 );
 856
 857             input  += 16;
 858             output += 16;
 859             length -= 16;
 860         }
 861     }
 862     else
 863     {
 864         while( length > 0 )
 865         {
 866             for( i = 0; i < 16; i++ )
 867                 output[i] = (unsigned char)( input[i] ^ iv[i] );
 868
 869             aes_crypt_ecb( ctx, mode, output, output );
 870             memcpy( iv, output, 16 );
 871
 872             input  += 16;
 873             output += 16;
 874             length -= 16;
 875         }
 876     }
 877
 878     return( 0 );
 879 }
 880 #endif /* POLARSSL_CIPHER_MODE_CBC */
 881
 882 #if defined(POLARSSL_CIPHER_MODE_CFB)
 883 /*
 884  * AES-CFB128 buffer encryption/decryption
 885  */
 886 int aes_crypt_cfb128( aes_context *ctx,
 887                        int mode,
 888                        size_t length,
 889                        size_t *iv_off,
 890                        unsigned char iv[16],
 891                        const unsigned char *input,
 892                        unsigned char *output )
 893 {
 894     int c;
 895     size_t n = *iv_off;
 896
 897     if( mode == AES_DECRYPT )
 898     {
 899         while( length-- )
 900         {
 901             if( n == 0 )
 902                 aes_crypt_ecb( ctx, AES_ENCRYPT, iv, iv );
 903
 904             c = *input++;
 905             *output++ = (unsigned char)( c ^ iv[n] );
 906             iv[n] = (unsigned char) c;
 907
 908             n = ( n + 1 ) & 0x0F;
 909         }
 910     }
 911     else
 912     {
 913         while( length-- )
 914         {
 915             if( n == 0 )
 916                 aes_crypt_ecb( ctx, AES_ENCRYPT, iv, iv );
 917
 918             iv[n] = *output++ = (unsigned char)( iv[n] ^ *input++ );
 919
 920             n = ( n + 1 ) & 0x0F;
 921         }
 922     }
 923
 924     *iv_off = n;
 925
 926     return( 0 );
 927 }
 928
 929 /*
 930  * AES-CFB8 buffer encryption/decryption
 931  */
 932 #include <stdio.h>
 933 int aes_crypt_cfb8( aes_context *ctx,
 934                        int mode,
 935                        size_t length,
 936                        unsigned char iv[16],
 937                        const unsigned char *input,
 938                        unsigned char *output )
 939 {
 940     unsigned char c;
 941     unsigned char ov[17];
 942
 943     while( length-- )
 944     {
 945         memcpy( ov, iv, 16 );
 946         aes_crypt_ecb( ctx, AES_ENCRYPT, iv, iv );
 947
 948         if( mode == AES_DECRYPT )
 949             ov[16] = *input;
 950
 951         c = *output++ = (unsigned char)( iv[0] ^ *input++ );
 952
 953         if( mode == AES_ENCRYPT )
 954             ov[16] = c;
 955
 956         memcpy( iv, ov + 1, 16 );
 957     }
 958
 959     return( 0 );
 960 }
 961 #endif /*POLARSSL_CIPHER_MODE_CFB */
 962
 963 #if defined(POLARSSL_CIPHER_MODE_CTR)
 964 /*
 965  * AES-CTR buffer encryption/decryption
 966  */
 967 int aes_crypt_ctr( aes_context *ctx,
 968                        size_t length,
 969                        size_t *nc_off,
 970                        unsigned char nonce_counter[16],
 971                        unsigned char stream_block[16],
 972                        const unsigned char *input,
 973                        unsigned char *output )
 974 {
 975     int c, i;
 976     size_t n = *nc_off;
 977
 978     while( length-- )
 979     {
 980         if( n == 0 ) {
 981             aes_crypt_ecb( ctx, AES_ENCRYPT, nonce_counter, stream_block );
 982
 983             for( i = 16; i > 0; i-- )
 984                 if( ++nonce_counter[i - 1] != 0 )
 985                     break;
 986         }
 987         c = *input++;
 988         *output++ = (unsigned char)( c ^ stream_block[n] );
 989
 990         n = ( n + 1 ) & 0x0F;
 991     }
 992
 993     *nc_off = n;
 994
 995     return( 0 );
 996 }
 997 #endif /* POLARSSL_CIPHER_MODE_CTR */
 998
 999 #endif /* !POLARSSL_AES_ALT */
1000
1001 #if defined(POLARSSL_SELF_TEST)
1002
1003 #include <stdio.h>
1004
1005 /*
1006  * AES test vectors from:
1007  *
1008  * http://csrc.nist.gov/archive/aes/rijndael/rijndael-vals.zip
1009  */
1010 static const unsigned char aes_test_ecb_dec[3][16] =
1011 {
1012     { 0x44, 0x41, 0x6A, 0xC2, 0xD1, 0xF5, 0x3C, 0x58,
1013       0x33, 0x03, 0x91, 0x7E, 0x6B, 0xE9, 0xEB, 0xE0 },
1014     { 0x48, 0xE3, 0x1E, 0x9E, 0x25, 0x67, 0x18, 0xF2,
1015       0x92, 0x29, 0x31, 0x9C, 0x19, 0xF1, 0x5B, 0xA4 },
1016     { 0x05, 0x8C, 0xCF, 0xFD, 0xBB, 0xCB, 0x38, 0x2D,
1017       0x1F, 0x6F, 0x56, 0x58, 0x5D, 0x8A, 0x4A, 0xDE }
1018 };
1019
1020 static const unsigned char aes_test_ecb_enc[3][16] =
1021 {
1022     { 0xC3, 0x4C, 0x05, 0x2C, 0xC0, 0xDA, 0x8D, 0x73,
1023       0x45, 0x1A, 0xFE, 0x5F, 0x03, 0xBE, 0x29, 0x7F },
1024     { 0xF3, 0xF6, 0x75, 0x2A, 0xE8, 0xD7, 0x83, 0x11,
1025       0x38, 0xF0, 0x41, 0x56, 0x06, 0x31, 0xB1, 0x14 },
1026     { 0x8B, 0x79, 0xEE, 0xCC, 0x93, 0xA0, 0xEE, 0x5D,
1027       0xFF, 0x30, 0xB4, 0xEA, 0x21, 0x63, 0x6D, 0xA4 }
1028 };
1029
1030 #if defined(POLARSSL_CIPHER_MODE_CBC)
1031 static const unsigned char aes_test_cbc_dec[3][16] =
1032 {
1033     { 0xFA, 0xCA, 0x37, 0xE0, 0xB0, 0xC8, 0x53, 0x73,
1034       0xDF, 0x70, 0x6E, 0x73, 0xF7, 0xC9, 0xAF, 0x86 },
1035     { 0x5D, 0xF6, 0x78, 0xDD, 0x17, 0xBA, 0x4E, 0x75,
1036       0xB6, 0x17, 0x68, 0xC6, 0xAD, 0xEF, 0x7C, 0x7B },
1037     { 0x48, 0x04, 0xE1, 0x81, 0x8F, 0xE6, 0x29, 0x75,
1038       0x19, 0xA3, 0xE8, 0x8C, 0x57, 0x31, 0x04, 0x13 }
1039 };
1040
1041 static const unsigned char aes_test_cbc_enc[3][16] =
1042 {
1043     { 0x8A, 0x05, 0xFC, 0x5E, 0x09, 0x5A, 0xF4, 0x84,
1044       0x8A, 0x08, 0xD3, 0x28, 0xD3, 0x68, 0x8E, 0x3D },
1045     { 0x7B, 0xD9, 0x66, 0xD5, 0x3A, 0xD8, 0xC1, 0xBB,
1046       0x85, 0xD2, 0xAD, 0xFA, 0xE8, 0x7B, 0xB1, 0x04 },
1047     { 0xFE, 0x3C, 0x53, 0x65, 0x3E, 0x2F, 0x45, 0xB5,
1048       0x6F, 0xCD, 0x88, 0xB2, 0xCC, 0x89, 0x8F, 0xF0 }
1049 };
1050 #endif /* POLARSSL_CIPHER_MODE_CBC */
1051
1052 #if defined(POLARSSL_CIPHER_MODE_CFB)
1053 /*
1054  * AES-CFB128 test vectors from:
1055  *
1056  * http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
1057  */
1058 static const unsigned char aes_test_cfb128_key[3][32] =
1059 {
1060     { 0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6,
1061       0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C },
1062     { 0x8E, 0x73, 0xB0, 0xF7, 0xDA, 0x0E, 0x64, 0x52,
1063       0xC8, 0x10, 0xF3, 0x2B, 0x80, 0x90, 0x79, 0xE5,
1064       0x62, 0xF8, 0xEA, 0xD2, 0x52, 0x2C, 0x6B, 0x7B },
1065     { 0x60, 0x3D, 0xEB, 0x10, 0x15, 0xCA, 0x71, 0xBE,
1066       0x2B, 0x73, 0xAE, 0xF0, 0x85, 0x7D, 0x77, 0x81,
1067       0x1F, 0x35, 0x2C, 0x07, 0x3B, 0x61, 0x08, 0xD7,
1068       0x2D, 0x98, 0x10, 0xA3, 0x09, 0x14, 0xDF, 0xF4 }
1069 };
1070
1071 static const unsigned char aes_test_cfb128_iv[16] =
1072 {
1073     0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1074     0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
1075 };
1076
1077 static const unsigned char aes_test_cfb128_pt[64] =
1078 {
1079     0x6B, 0xC1, 0xBE, 0xE2, 0x2E, 0x40, 0x9F, 0x96,
1080     0xE9, 0x3D, 0x7E, 0x11, 0x73, 0x93, 0x17, 0x2A,
1081     0xAE, 0x2D, 0x8A, 0x57, 0x1E, 0x03, 0xAC, 0x9C,
1082     0x9E, 0xB7, 0x6F, 0xAC, 0x45, 0xAF, 0x8E, 0x51,
1083     0x30, 0xC8, 0x1C, 0x46, 0xA3, 0x5C, 0xE4, 0x11,
1084     0xE5, 0xFB, 0xC1, 0x19, 0x1A, 0x0A, 0x52, 0xEF,
1085     0xF6, 0x9F, 0x24, 0x45, 0xDF, 0x4F, 0x9B, 0x17,
1086     0xAD, 0x2B, 0x41, 0x7B, 0xE6, 0x6C, 0x37, 0x10
1087 };
1088
1089 static const unsigned char aes_test_cfb128_ct[3][64] =
1090 {
1091     { 0x3B, 0x3F, 0xD9, 0x2E, 0xB7, 0x2D, 0xAD, 0x20,
1092       0x33, 0x34, 0x49, 0xF8, 0xE8, 0x3C, 0xFB, 0x4A,
1093       0xC8, 0xA6, 0x45, 0x37, 0xA0, 0xB3, 0xA9, 0x3F,
1094       0xCD, 0xE3, 0xCD, 0xAD, 0x9F, 0x1C, 0xE5, 0x8B,
1095       0x26, 0x75, 0x1F, 0x67, 0xA3, 0xCB, 0xB1, 0x40,
1096       0xB1, 0x80, 0x8C, 0xF1, 0x87, 0xA4, 0xF4, 0xDF,
1097       0xC0, 0x4B, 0x05, 0x35, 0x7C, 0x5D, 0x1C, 0x0E,
1098       0xEA, 0xC4, 0xC6, 0x6F, 0x9F, 0xF7, 0xF2, 0xE6 },
1099     { 0xCD, 0xC8, 0x0D, 0x6F, 0xDD, 0xF1, 0x8C, 0xAB,
1100       0x34, 0xC2, 0x59, 0x09, 0xC9, 0x9A, 0x41, 0x74,
1101       0x67, 0xCE, 0x7F, 0x7F, 0x81, 0x17, 0x36, 0x21,
1102       0x96, 0x1A, 0x2B, 0x70, 0x17, 0x1D, 0x3D, 0x7A,
1103       0x2E, 0x1E, 0x8A, 0x1D, 0xD5, 0x9B, 0x88, 0xB1,
1104       0xC8, 0xE6, 0x0F, 0xED, 0x1E, 0xFA, 0xC4, 0xC9,
1105       0xC0, 0x5F, 0x9F, 0x9C, 0xA9, 0x83, 0x4F, 0xA0,
1106       0x42, 0xAE, 0x8F, 0xBA, 0x58, 0x4B, 0x09, 0xFF },
1107     { 0xDC, 0x7E, 0x84, 0xBF, 0xDA, 0x79, 0x16, 0x4B,
1108       0x7E, 0xCD, 0x84, 0x86, 0x98, 0x5D, 0x38, 0x60,
1109       0x39, 0xFF, 0xED, 0x14, 0x3B, 0x28, 0xB1, 0xC8,
1110       0x32, 0x11, 0x3C, 0x63, 0x31, 0xE5, 0x40, 0x7B,
1111       0xDF, 0x10, 0x13, 0x24, 0x15, 0xE5, 0x4B, 0x92,
1112       0xA1, 0x3E, 0xD0, 0xA8, 0x26, 0x7A, 0xE2, 0xF9,
1113       0x75, 0xA3, 0x85, 0x74, 0x1A, 0xB9, 0xCE, 0xF8,
1114       0x20, 0x31, 0x62, 0x3D, 0x55, 0xB1, 0xE4, 0x71 }
1115 };
1116 #endif /* POLARSSL_CIPHER_MODE_CFB */
1117
1118 #if defined(POLARSSL_CIPHER_MODE_CTR)
1119 /*
1120  * AES-CTR test vectors from:
1121  *
1122  * http://www.faqs.org/rfcs/rfc3686.html
1123  */
1124
1125 static const unsigned char aes_test_ctr_key[3][16] =
1126 {
1127     { 0xAE, 0x68, 0x52, 0xF8, 0x12, 0x10, 0x67, 0xCC,
1128       0x4B, 0xF7, 0xA5, 0x76, 0x55, 0x77, 0xF3, 0x9E },
1129     { 0x7E, 0x24, 0x06, 0x78, 0x17, 0xFA, 0xE0, 0xD7,
1130       0x43, 0xD6, 0xCE, 0x1F, 0x32, 0x53, 0x91, 0x63 },
1131     { 0x76, 0x91, 0xBE, 0x03, 0x5E, 0x50, 0x20, 0xA8,
1132       0xAC, 0x6E, 0x61, 0x85, 0x29, 0xF9, 0xA0, 0xDC }
1133 };
1134
1135 static const unsigned char aes_test_ctr_nonce_counter[3][16] =
1136 {
1137     { 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00,
1138       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 },
1139     { 0x00, 0x6C, 0xB6, 0xDB, 0xC0, 0x54, 0x3B, 0x59,
1140       0xDA, 0x48, 0xD9, 0x0B, 0x00, 0x00, 0x00, 0x01 },
1141     { 0x00, 0xE0, 0x01, 0x7B, 0x27, 0x77, 0x7F, 0x3F,
1142       0x4A, 0x17, 0x86, 0xF0, 0x00, 0x00, 0x00, 0x01 }
1143 };
1144
1145 static const unsigned char aes_test_ctr_pt[3][48] =
1146 {
1147     { 0x53, 0x69, 0x6E, 0x67, 0x6C, 0x65, 0x20, 0x62,
1148       0x6C, 0x6F, 0x63, 0x6B, 0x20, 0x6D, 0x73, 0x67 },
1149
1150     { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1151       0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
1152       0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
1153       0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F },
1154
1155     { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1156       0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
1157       0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
1158       0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
1159       0x20, 0x21, 0x22, 0x23 }
1160 };
1161
1162 static const unsigned char aes_test_ctr_ct[3][48] =
1163 {
1164     { 0xE4, 0x09, 0x5D, 0x4F, 0xB7, 0xA7, 0xB3, 0x79,
1165       0x2D, 0x61, 0x75, 0xA3, 0x26, 0x13, 0x11, 0xB8 },
1166     { 0x51, 0x04, 0xA1, 0x06, 0x16, 0x8A, 0x72, 0xD9,
1167       0x79, 0x0D, 0x41, 0xEE, 0x8E, 0xDA, 0xD3, 0x88,
1168       0xEB, 0x2E, 0x1E, 0xFC, 0x46, 0xDA, 0x57, 0xC8,
1169       0xFC, 0xE6, 0x30, 0xDF, 0x91, 0x41, 0xBE, 0x28 },
1170     { 0xC1, 0xCF, 0x48, 0xA8, 0x9F, 0x2F, 0xFD, 0xD9,
1171       0xCF, 0x46, 0x52, 0xE9, 0xEF, 0xDB, 0x72, 0xD7,
1172       0x45, 0x40, 0xA4, 0x2B, 0xDE, 0x6D, 0x78, 0x36,
1173       0xD5, 0x9A, 0x5C, 0xEA, 0xAE, 0xF3, 0x10, 0x53,
1174       0x25, 0xB2, 0x07, 0x2F }
1175 };
1176
1177 static const int aes_test_ctr_len[3] =
1178     { 16, 32, 36 };
1179 #endif /* POLARSSL_CIPHER_MODE_CTR */
1180
1181 /*
1182  * Checkup routine
1183  */
1184 int aes_self_test( int verbose )
1185 {
1186     int ret = 0, i, j, u, v;
1187     unsigned char key[32];
1188     unsigned char buf[64];
1189     unsigned char iv[16];
1190 #if defined(POLARSSL_CIPHER_MODE_CBC)
1191     unsigned char prv[16];
1192 #endif
1193 #if defined(POLARSSL_CIPHER_MODE_CTR) || defined(POLARSSL_CIPHER_MODE_CFB)
1194     size_t offset;
1195 #endif
1196 #if defined(POLARSSL_CIPHER_MODE_CTR)
1197     int len;
1198     unsigned char nonce_counter[16];
1199     unsigned char stream_block[16];
1200 #endif
1201     aes_context ctx;
1202
1203     memset( key, 0, 32 );
1204     aes_init( &ctx );
1205
1206     /*
1207      * ECB mode
1208      */
1209     for( i = 0; i < 6; i++ )
1210     {
1211         u = i >> 1;
1212         v = i  & 1;
1213
1214         if( verbose != 0 )
1215             polarssl_printf( "  AES-ECB-%3d (%s): ", 128 + u * 64,
1216                              ( v == AES_DECRYPT ) ? "dec" : "enc" );
1217
1218         memset( buf, 0, 16 );
1219
1220         if( v == AES_DECRYPT )
1221         {
1222             aes_setkey_dec( &ctx, key, 128 + u * 64 );
1223
1224             for( j = 0; j < 10000; j++ )
1225                 aes_crypt_ecb( &ctx, v, buf, buf );
1226
1227             if( memcmp( buf, aes_test_ecb_dec[u], 16 ) != 0 )
1228             {
1229                 if( verbose != 0 )
1230                     polarssl_printf( "failed\n" );
1231
1232                 ret = 1;
1233                 goto exit;
1234             }
1235         }
1236         else
1237         {
1238             aes_setkey_enc( &ctx, key, 128 + u * 64 );
1239
1240             for( j = 0; j < 10000; j++ )
1241                 aes_crypt_ecb( &ctx, v, buf, buf );
1242
1243             if( memcmp( buf, aes_test_ecb_enc[u], 16 ) != 0 )
1244             {
1245                 if( verbose != 0 )
1246                     polarssl_printf( "failed\n" );
1247
1248                 ret = 1;
1249                 goto exit;
1250             }
1251         }
1252
1253         if( verbose != 0 )
1254             polarssl_printf( "passed\n" );
1255     }
1256
1257     if( verbose != 0 )
1258         polarssl_printf( "\n" );
1259
1260 #if defined(POLARSSL_CIPHER_MODE_CBC)
1261     /*
1262      * CBC mode
1263      */
1264     for( i = 0; i < 6; i++ )
1265     {
1266         u = i >> 1;
1267         v = i  & 1;
1268
1269         if( verbose != 0 )
1270             polarssl_printf( "  AES-CBC-%3d (%s): ", 128 + u * 64,
1271                              ( v == AES_DECRYPT ) ? "dec" : "enc" );
1272
1273         memset( iv , 0, 16 );
1274         memset( prv, 0, 16 );
1275         memset( buf, 0, 16 );
1276
1277         if( v == AES_DECRYPT )
1278         {
1279             aes_setkey_dec( &ctx, key, 128 + u * 64 );
1280
1281             for( j = 0; j < 10000; j++ )
1282                 aes_crypt_cbc( &ctx, v, 16, iv, buf, buf );
1283
1284             if( memcmp( buf, aes_test_cbc_dec[u], 16 ) != 0 )
1285             {
1286                 if( verbose != 0 )
1287                     polarssl_printf( "failed\n" );
1288
1289                 ret = 1;
1290                 goto exit;
1291             }
1292         }
1293         else
1294         {
1295             aes_setkey_enc( &ctx, key, 128 + u * 64 );
1296
1297             for( j = 0; j < 10000; j++ )
1298             {
1299                 unsigned char tmp[16];
1300
1301                 aes_crypt_cbc( &ctx, v, 16, iv, buf, buf );
1302
1303                 memcpy( tmp, prv, 16 );
1304                 memcpy( prv, buf, 16 );
1305                 memcpy( buf, tmp, 16 );
1306             }
1307
1308             if( memcmp( prv, aes_test_cbc_enc[u], 16 ) != 0 )
1309             {
1310                 if( verbose != 0 )
1311                     polarssl_printf( "failed\n" );
1312
1313                 ret = 1;
1314                 goto exit;
1315             }
1316         }
1317
1318         if( verbose != 0 )
1319             polarssl_printf( "passed\n" );
1320     }
1321
1322     if( verbose != 0 )
1323         polarssl_printf( "\n" );
1324 #endif /* POLARSSL_CIPHER_MODE_CBC */
1325
1326 #if defined(POLARSSL_CIPHER_MODE_CFB)
1327     /*
1328      * CFB128 mode
1329      */
1330     for( i = 0; i < 6; i++ )
1331     {
1332         u = i >> 1;
1333         v = i  & 1;
1334
1335         if( verbose != 0 )
1336             polarssl_printf( "  AES-CFB128-%3d (%s): ", 128 + u * 64,
1337                              ( v == AES_DECRYPT ) ? "dec" : "enc" );
1338
1339         memcpy( iv,  aes_test_cfb128_iv, 16 );
1340         memcpy( key, aes_test_cfb128_key[u], 16 + u * 8 );
1341
1342         offset = 0;
1343         aes_setkey_enc( &ctx, key, 128 + u * 64 );
1344
1345         if( v == AES_DECRYPT )
1346         {
1347             memcpy( buf, aes_test_cfb128_ct[u], 64 );
1348             aes_crypt_cfb128( &ctx, v, 64, &offset, iv, buf, buf );
1349
1350             if( memcmp( buf, aes_test_cfb128_pt, 64 ) != 0 )
1351             {
1352                 if( verbose != 0 )
1353                     polarssl_printf( "failed\n" );
1354
1355                 ret = 1;
1356                 goto exit;
1357             }
1358         }
1359         else
1360         {
1361             memcpy( buf, aes_test_cfb128_pt, 64 );
1362             aes_crypt_cfb128( &ctx, v, 64, &offset, iv, buf, buf );
1363
1364             if( memcmp( buf, aes_test_cfb128_ct[u], 64 ) != 0 )
1365             {
1366                 if( verbose != 0 )
1367                     polarssl_printf( "failed\n" );
1368
1369                 ret = 1;
1370                 goto exit;
1371             }
1372         }
1373
1374         if( verbose != 0 )
1375             polarssl_printf( "passed\n" );
1376     }
1377
1378     if( verbose != 0 )
1379         polarssl_printf( "\n" );
1380 #endif /* POLARSSL_CIPHER_MODE_CFB */
1381
1382 #if defined(POLARSSL_CIPHER_MODE_CTR)
1383     /*
1384      * CTR mode
1385      */
1386     for( i = 0; i < 6; i++ )
1387     {
1388         u = i >> 1;
1389         v = i  & 1;
1390
1391         if( verbose != 0 )
1392             polarssl_printf( "  AES-CTR-128 (%s): ",
1393                              ( v == AES_DECRYPT ) ? "dec" : "enc" );
1394
1395         memcpy( nonce_counter, aes_test_ctr_nonce_counter[u], 16 );
1396         memcpy( key, aes_test_ctr_key[u], 16 );
1397
1398         offset = 0;
1399         aes_setkey_enc( &ctx, key, 128 );
1400
1401         if( v == AES_DECRYPT )
1402         {
1403             len = aes_test_ctr_len[u];
1404             memcpy( buf, aes_test_ctr_ct[u], len );
1405
1406             aes_crypt_ctr( &ctx, len, &offset, nonce_counter, stream_block,
1407                            buf, buf );
1408
1409             if( memcmp( buf, aes_test_ctr_pt[u], len ) != 0 )
1410             {
1411                 if( verbose != 0 )
1412                     polarssl_printf( "failed\n" );
1413
1414                 ret = 1;
1415                 goto exit;
1416             }
1417         }
1418         else
1419         {
1420             len = aes_test_ctr_len[u];
1421             memcpy( buf, aes_test_ctr_pt[u], len );
1422
1423             aes_crypt_ctr( &ctx, len, &offset, nonce_counter, stream_block,
1424                            buf, buf );
1425
1426             if( memcmp( buf, aes_test_ctr_ct[u], len ) != 0 )
1427             {
1428                 if( verbose != 0 )
1429                     polarssl_printf( "failed\n" );
1430
1431                 ret = 1;
1432                 goto exit;
1433             }
1434         }
1435
1436         if( verbose != 0 )
1437             polarssl_printf( "passed\n" );
1438     }
1439
1440     if( verbose != 0 )
1441         polarssl_printf( "\n" );
1442 #endif /* POLARSSL_CIPHER_MODE_CTR */
1443
1444     ret = 0;
1445
1446 exit:
1447     aes_free( &ctx );
1448
1449     return( ret );
1450 }
1451
1452 #endif /* POLARSSL_SELF_TEST */
1453
1454 #endif /* POLARSSL_AES_C */