git.sur5r.net Git - freertos/blob - FreeRTOS-Labs/Source/mbedtls/library/aes.c

   1 /*\r
   2  *  FIPS-197 compliant AES implementation\r
   3  *\r
   4  *  Copyright (C) 2006-2015, ARM Limited, All Rights Reserved\r
   5  *  SPDX-License-Identifier: Apache-2.0\r
   6  *\r
   7  *  Licensed under the Apache License, Version 2.0 (the "License"); you may\r
   8  *  not use this file except in compliance with the License.\r
   9  *  You may obtain a copy of the License at\r
  10  *\r
  11  *  http://www.apache.org/licenses/LICENSE-2.0\r
  12  *\r
  13  *  Unless required by applicable law or agreed to in writing, software\r
  14  *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT\r
  15  *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  16  *  See the License for the specific language governing permissions and\r
  17  *  limitations under the License.\r
  18  *\r
  19  *  This file is part of mbed TLS (https://tls.mbed.org)\r
  20  */\r
  21 /*\r
  22  *  The AES block cipher was designed by Vincent Rijmen and Joan Daemen.\r
  23  *\r
  24  *  http://csrc.nist.gov/encryption/aes/rijndael/Rijndael.pdf\r
  25  *  http://csrc.nist.gov/publications/fips/fips197/fips-197.pdf\r
  26  */\r
  27 \r
  28 #if !defined(MBEDTLS_CONFIG_FILE)\r
  29 #include "mbedtls/config.h"\r
  30 #else\r
  31 #include MBEDTLS_CONFIG_FILE\r
  32 #endif\r
  33 \r
  34 #if defined(MBEDTLS_AES_C)\r
  35 \r
  36 #include <string.h>\r
  37 \r
  38 #include "mbedtls/aes.h"\r
  39 #include "mbedtls/platform.h"\r
  40 #include "mbedtls/platform_util.h"\r
  41 #if defined(MBEDTLS_PADLOCK_C)\r
  42 #include "mbedtls/padlock.h"\r
  43 #endif\r
  44 #if defined(MBEDTLS_AESNI_C)\r
  45 #include "mbedtls/aesni.h"\r
  46 #endif\r
  47 \r
  48 #if defined(MBEDTLS_SELF_TEST)\r
  49 #if defined(MBEDTLS_PLATFORM_C)\r
  50 #include "mbedtls/platform.h"\r
  51 #else\r
  52 #include <stdio.h>\r
  53 #define mbedtls_printf printf\r
  54 #endif /* MBEDTLS_PLATFORM_C */\r
  55 #endif /* MBEDTLS_SELF_TEST */\r
  56 \r
  57 #if !defined(MBEDTLS_AES_ALT)\r
  58 \r
  59 /* Parameter validation macros based on platform_util.h */\r
  60 #define AES_VALIDATE_RET( cond )    \\r
  61     MBEDTLS_INTERNAL_VALIDATE_RET( cond, MBEDTLS_ERR_AES_BAD_INPUT_DATA )\r
  62 #define AES_VALIDATE( cond )        \\r
  63     MBEDTLS_INTERNAL_VALIDATE( cond )\r
  64 \r
  65 /*\r
  66  * 32-bit integer manipulation macros (little endian)\r
  67  */\r
  68 #ifndef GET_UINT32_LE\r
  69 #define GET_UINT32_LE(n,b,i)                            \\r
  70 {                                                       \\r
  71     (n) = ( (uint32_t) (b)[(i)    ]       )             \\r
  72         | ( (uint32_t) (b)[(i) + 1] <<  8 )             \\r
  73         | ( (uint32_t) (b)[(i) + 2] << 16 )             \\r
  74         | ( (uint32_t) (b)[(i) + 3] << 24 );            \\r
  75 }\r
  76 #endif\r
  77 \r
  78 #ifndef PUT_UINT32_LE\r
  79 #define PUT_UINT32_LE(n,b,i)                                    \\r
  80 {                                                               \\r
  81     (b)[(i)    ] = (unsigned char) ( ( (n)       ) & 0xFF );    \\r
  82     (b)[(i) + 1] = (unsigned char) ( ( (n) >>  8 ) & 0xFF );    \\r
  83     (b)[(i) + 2] = (unsigned char) ( ( (n) >> 16 ) & 0xFF );    \\r
  84     (b)[(i) + 3] = (unsigned char) ( ( (n) >> 24 ) & 0xFF );    \\r
  85 }\r
  86 #endif\r
  87 \r
  88 #if defined(MBEDTLS_PADLOCK_C) &&                      \\r
  89     ( defined(MBEDTLS_HAVE_X86) || defined(MBEDTLS_PADLOCK_ALIGN16) )\r
  90 static int aes_padlock_ace = -1;\r
  91 #endif\r
  92 \r
  93 #if defined(MBEDTLS_AES_ROM_TABLES)\r
  94 /*\r
  95  * Forward S-box\r
  96  */\r
  97 static const unsigned char FSb[256] =\r
  98 {\r
  99     0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5,\r
 100     0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,\r
 101     0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0,\r
 102     0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,\r
 103     0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC,\r
 104     0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,\r
 105     0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A,\r
 106     0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,\r
 107     0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0,\r
 108     0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,\r
 109     0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B,\r
 110     0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,\r
 111     0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85,\r
 112     0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,\r
 113     0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5,\r
 114     0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,\r
 115     0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17,\r
 116     0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,\r
 117     0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88,\r
 118     0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,\r
 119     0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C,\r
 120     0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,\r
 121     0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9,\r
 122     0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,\r
 123     0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6,\r
 124     0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,\r
 125     0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E,\r
 126     0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,\r
 127     0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94,\r
 128     0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,\r
 129     0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68,\r
 130     0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16\r
 131 };\r
 132 \r
 133 /*\r
 134  * Forward tables\r
 135  */\r
 136 #define FT \\r
 137 \\r
 138     V(A5,63,63,C6), V(84,7C,7C,F8), V(99,77,77,EE), V(8D,7B,7B,F6), \\r
 139     V(0D,F2,F2,FF), V(BD,6B,6B,D6), V(B1,6F,6F,DE), V(54,C5,C5,91), \\r
 140     V(50,30,30,60), V(03,01,01,02), V(A9,67,67,CE), V(7D,2B,2B,56), \\r
 141     V(19,FE,FE,E7), V(62,D7,D7,B5), V(E6,AB,AB,4D), V(9A,76,76,EC), \\r
 142     V(45,CA,CA,8F), V(9D,82,82,1F), V(40,C9,C9,89), V(87,7D,7D,FA), \\r
 143     V(15,FA,FA,EF), V(EB,59,59,B2), V(C9,47,47,8E), V(0B,F0,F0,FB), \\r
 144     V(EC,AD,AD,41), V(67,D4,D4,B3), V(FD,A2,A2,5F), V(EA,AF,AF,45), \\r
 145     V(BF,9C,9C,23), V(F7,A4,A4,53), V(96,72,72,E4), V(5B,C0,C0,9B), \\r
 146     V(C2,B7,B7,75), V(1C,FD,FD,E1), V(AE,93,93,3D), V(6A,26,26,4C), \\r
 147     V(5A,36,36,6C), V(41,3F,3F,7E), V(02,F7,F7,F5), V(4F,CC,CC,83), \\r
 148     V(5C,34,34,68), V(F4,A5,A5,51), V(34,E5,E5,D1), V(08,F1,F1,F9), \\r
 149     V(93,71,71,E2), V(73,D8,D8,AB), V(53,31,31,62), V(3F,15,15,2A), \\r
 150     V(0C,04,04,08), V(52,C7,C7,95), V(65,23,23,46), V(5E,C3,C3,9D), \\r
 151     V(28,18,18,30), V(A1,96,96,37), V(0F,05,05,0A), V(B5,9A,9A,2F), \\r
 152     V(09,07,07,0E), V(36,12,12,24), V(9B,80,80,1B), V(3D,E2,E2,DF), \\r
 153     V(26,EB,EB,CD), V(69,27,27,4E), V(CD,B2,B2,7F), V(9F,75,75,EA), \\r
 154     V(1B,09,09,12), V(9E,83,83,1D), V(74,2C,2C,58), V(2E,1A,1A,34), \\r
 155     V(2D,1B,1B,36), V(B2,6E,6E,DC), V(EE,5A,5A,B4), V(FB,A0,A0,5B), \\r
 156     V(F6,52,52,A4), V(4D,3B,3B,76), V(61,D6,D6,B7), V(CE,B3,B3,7D), \\r
 157     V(7B,29,29,52), V(3E,E3,E3,DD), V(71,2F,2F,5E), V(97,84,84,13), \\r
 158     V(F5,53,53,A6), V(68,D1,D1,B9), V(00,00,00,00), V(2C,ED,ED,C1), \\r
 159     V(60,20,20,40), V(1F,FC,FC,E3), V(C8,B1,B1,79), V(ED,5B,5B,B6), \\r
 160     V(BE,6A,6A,D4), V(46,CB,CB,8D), V(D9,BE,BE,67), V(4B,39,39,72), \\r
 161     V(DE,4A,4A,94), V(D4,4C,4C,98), V(E8,58,58,B0), V(4A,CF,CF,85), \\r
 162     V(6B,D0,D0,BB), V(2A,EF,EF,C5), V(E5,AA,AA,4F), V(16,FB,FB,ED), \\r
 163     V(C5,43,43,86), V(D7,4D,4D,9A), V(55,33,33,66), V(94,85,85,11), \\r
 164     V(CF,45,45,8A), V(10,F9,F9,E9), V(06,02,02,04), V(81,7F,7F,FE), \\r
 165     V(F0,50,50,A0), V(44,3C,3C,78), V(BA,9F,9F,25), V(E3,A8,A8,4B), \\r
 166     V(F3,51,51,A2), V(FE,A3,A3,5D), V(C0,40,40,80), V(8A,8F,8F,05), \\r
 167     V(AD,92,92,3F), V(BC,9D,9D,21), V(48,38,38,70), V(04,F5,F5,F1), \\r
 168     V(DF,BC,BC,63), V(C1,B6,B6,77), V(75,DA,DA,AF), V(63,21,21,42), \\r
 169     V(30,10,10,20), V(1A,FF,FF,E5), V(0E,F3,F3,FD), V(6D,D2,D2,BF), \\r
 170     V(4C,CD,CD,81), V(14,0C,0C,18), V(35,13,13,26), V(2F,EC,EC,C3), \\r
 171     V(E1,5F,5F,BE), V(A2,97,97,35), V(CC,44,44,88), V(39,17,17,2E), \\r
 172     V(57,C4,C4,93), V(F2,A7,A7,55), V(82,7E,7E,FC), V(47,3D,3D,7A), \\r
 173     V(AC,64,64,C8), V(E7,5D,5D,BA), V(2B,19,19,32), V(95,73,73,E6), \\r
 174     V(A0,60,60,C0), V(98,81,81,19), V(D1,4F,4F,9E), V(7F,DC,DC,A3), \\r
 175     V(66,22,22,44), V(7E,2A,2A,54), V(AB,90,90,3B), V(83,88,88,0B), \\r
 176     V(CA,46,46,8C), V(29,EE,EE,C7), V(D3,B8,B8,6B), V(3C,14,14,28), \\r
 177     V(79,DE,DE,A7), V(E2,5E,5E,BC), V(1D,0B,0B,16), V(76,DB,DB,AD), \\r
 178     V(3B,E0,E0,DB), V(56,32,32,64), V(4E,3A,3A,74), V(1E,0A,0A,14), \\r
 179     V(DB,49,49,92), V(0A,06,06,0C), V(6C,24,24,48), V(E4,5C,5C,B8), \\r
 180     V(5D,C2,C2,9F), V(6E,D3,D3,BD), V(EF,AC,AC,43), V(A6,62,62,C4), \\r
 181     V(A8,91,91,39), V(A4,95,95,31), V(37,E4,E4,D3), V(8B,79,79,F2), \\r
 182     V(32,E7,E7,D5), V(43,C8,C8,8B), V(59,37,37,6E), V(B7,6D,6D,DA), \\r
 183     V(8C,8D,8D,01), V(64,D5,D5,B1), V(D2,4E,4E,9C), V(E0,A9,A9,49), \\r
 184     V(B4,6C,6C,D8), V(FA,56,56,AC), V(07,F4,F4,F3), V(25,EA,EA,CF), \\r
 185     V(AF,65,65,CA), V(8E,7A,7A,F4), V(E9,AE,AE,47), V(18,08,08,10), \\r
 186     V(D5,BA,BA,6F), V(88,78,78,F0), V(6F,25,25,4A), V(72,2E,2E,5C), \\r
 187     V(24,1C,1C,38), V(F1,A6,A6,57), V(C7,B4,B4,73), V(51,C6,C6,97), \\r
 188     V(23,E8,E8,CB), V(7C,DD,DD,A1), V(9C,74,74,E8), V(21,1F,1F,3E), \\r
 189     V(DD,4B,4B,96), V(DC,BD,BD,61), V(86,8B,8B,0D), V(85,8A,8A,0F), \\r
 190     V(90,70,70,E0), V(42,3E,3E,7C), V(C4,B5,B5,71), V(AA,66,66,CC), \\r
 191     V(D8,48,48,90), V(05,03,03,06), V(01,F6,F6,F7), V(12,0E,0E,1C), \\r
 192     V(A3,61,61,C2), V(5F,35,35,6A), V(F9,57,57,AE), V(D0,B9,B9,69), \\r
 193     V(91,86,86,17), V(58,C1,C1,99), V(27,1D,1D,3A), V(B9,9E,9E,27), \\r
 194     V(38,E1,E1,D9), V(13,F8,F8,EB), V(B3,98,98,2B), V(33,11,11,22), \\r
 195     V(BB,69,69,D2), V(70,D9,D9,A9), V(89,8E,8E,07), V(A7,94,94,33), \\r
 196     V(B6,9B,9B,2D), V(22,1E,1E,3C), V(92,87,87,15), V(20,E9,E9,C9), \\r
 197     V(49,CE,CE,87), V(FF,55,55,AA), V(78,28,28,50), V(7A,DF,DF,A5), \\r
 198     V(8F,8C,8C,03), V(F8,A1,A1,59), V(80,89,89,09), V(17,0D,0D,1A), \\r
 199     V(DA,BF,BF,65), V(31,E6,E6,D7), V(C6,42,42,84), V(B8,68,68,D0), \\r
 200     V(C3,41,41,82), V(B0,99,99,29), V(77,2D,2D,5A), V(11,0F,0F,1E), \\r
 201     V(CB,B0,B0,7B), V(FC,54,54,A8), V(D6,BB,BB,6D), V(3A,16,16,2C)\r
 202 \r
 203 #define V(a,b,c,d) 0x##a##b##c##d\r
 204 static const uint32_t FT0[256] = { FT };\r
 205 #undef V\r
 206 \r
 207 #if !defined(MBEDTLS_AES_FEWER_TABLES)\r
 208 \r
 209 #define V(a,b,c,d) 0x##b##c##d##a\r
 210 static const uint32_t FT1[256] = { FT };\r
 211 #undef V\r
 212 \r
 213 #define V(a,b,c,d) 0x##c##d##a##b\r
 214 static const uint32_t FT2[256] = { FT };\r
 215 #undef V\r
 216 \r
 217 #define V(a,b,c,d) 0x##d##a##b##c\r
 218 static const uint32_t FT3[256] = { FT };\r
 219 #undef V\r
 220 \r
 221 #endif /* !MBEDTLS_AES_FEWER_TABLES */\r
 222 \r
 223 #undef FT\r
 224 \r
 225 /*\r
 226  * Reverse S-box\r
 227  */\r
 228 static const unsigned char RSb[256] =\r
 229 {\r
 230     0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38,\r
 231     0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,\r
 232     0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87,\r
 233     0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,\r
 234     0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D,\r
 235     0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,\r
 236     0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2,\r
 237     0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,\r
 238     0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16,\r
 239     0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,\r
 240     0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA,\r
 241     0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,\r
 242     0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A,\r
 243     0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,\r
 244     0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02,\r
 245     0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,\r
 246     0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA,\r
 247     0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,\r
 248     0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85,\r
 249     0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,\r
 250     0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89,\r
 251     0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,\r
 252     0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20,\r
 253     0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,\r
 254     0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31,\r
 255     0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,\r
 256     0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D,\r
 257     0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,\r
 258     0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0,\r
 259     0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,\r
 260     0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26,\r
 261     0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D\r
 262 };\r
 263 \r
 264 /*\r
 265  * Reverse tables\r
 266  */\r
 267 #define RT \\r
 268 \\r
 269     V(50,A7,F4,51), V(53,65,41,7E), V(C3,A4,17,1A), V(96,5E,27,3A), \\r
 270     V(CB,6B,AB,3B), V(F1,45,9D,1F), V(AB,58,FA,AC), V(93,03,E3,4B), \\r
 271     V(55,FA,30,20), V(F6,6D,76,AD), V(91,76,CC,88), V(25,4C,02,F5), \\r
 272     V(FC,D7,E5,4F), V(D7,CB,2A,C5), V(80,44,35,26), V(8F,A3,62,B5), \\r
 273     V(49,5A,B1,DE), V(67,1B,BA,25), V(98,0E,EA,45), V(E1,C0,FE,5D), \\r
 274     V(02,75,2F,C3), V(12,F0,4C,81), V(A3,97,46,8D), V(C6,F9,D3,6B), \\r
 275     V(E7,5F,8F,03), V(95,9C,92,15), V(EB,7A,6D,BF), V(DA,59,52,95), \\r
 276     V(2D,83,BE,D4), V(D3,21,74,58), V(29,69,E0,49), V(44,C8,C9,8E), \\r
 277     V(6A,89,C2,75), V(78,79,8E,F4), V(6B,3E,58,99), V(DD,71,B9,27), \\r
 278     V(B6,4F,E1,BE), V(17,AD,88,F0), V(66,AC,20,C9), V(B4,3A,CE,7D), \\r
 279     V(18,4A,DF,63), V(82,31,1A,E5), V(60,33,51,97), V(45,7F,53,62), \\r
 280     V(E0,77,64,B1), V(84,AE,6B,BB), V(1C,A0,81,FE), V(94,2B,08,F9), \\r
 281     V(58,68,48,70), V(19,FD,45,8F), V(87,6C,DE,94), V(B7,F8,7B,52), \\r
 282     V(23,D3,73,AB), V(E2,02,4B,72), V(57,8F,1F,E3), V(2A,AB,55,66), \\r
 283     V(07,28,EB,B2), V(03,C2,B5,2F), V(9A,7B,C5,86), V(A5,08,37,D3), \\r
 284     V(F2,87,28,30), V(B2,A5,BF,23), V(BA,6A,03,02), V(5C,82,16,ED), \\r
 285     V(2B,1C,CF,8A), V(92,B4,79,A7), V(F0,F2,07,F3), V(A1,E2,69,4E), \\r
 286     V(CD,F4,DA,65), V(D5,BE,05,06), V(1F,62,34,D1), V(8A,FE,A6,C4), \\r
 287     V(9D,53,2E,34), V(A0,55,F3,A2), V(32,E1,8A,05), V(75,EB,F6,A4), \\r
 288     V(39,EC,83,0B), V(AA,EF,60,40), V(06,9F,71,5E), V(51,10,6E,BD), \\r
 289     V(F9,8A,21,3E), V(3D,06,DD,96), V(AE,05,3E,DD), V(46,BD,E6,4D), \\r
 290     V(B5,8D,54,91), V(05,5D,C4,71), V(6F,D4,06,04), V(FF,15,50,60), \\r
 291     V(24,FB,98,19), V(97,E9,BD,D6), V(CC,43,40,89), V(77,9E,D9,67), \\r
 292     V(BD,42,E8,B0), V(88,8B,89,07), V(38,5B,19,E7), V(DB,EE,C8,79), \\r
 293     V(47,0A,7C,A1), V(E9,0F,42,7C), V(C9,1E,84,F8), V(00,00,00,00), \\r
 294     V(83,86,80,09), V(48,ED,2B,32), V(AC,70,11,1E), V(4E,72,5A,6C), \\r
 295     V(FB,FF,0E,FD), V(56,38,85,0F), V(1E,D5,AE,3D), V(27,39,2D,36), \\r
 296     V(64,D9,0F,0A), V(21,A6,5C,68), V(D1,54,5B,9B), V(3A,2E,36,24), \\r
 297     V(B1,67,0A,0C), V(0F,E7,57,93), V(D2,96,EE,B4), V(9E,91,9B,1B), \\r
 298     V(4F,C5,C0,80), V(A2,20,DC,61), V(69,4B,77,5A), V(16,1A,12,1C), \\r
 299     V(0A,BA,93,E2), V(E5,2A,A0,C0), V(43,E0,22,3C), V(1D,17,1B,12), \\r
 300     V(0B,0D,09,0E), V(AD,C7,8B,F2), V(B9,A8,B6,2D), V(C8,A9,1E,14), \\r
 301     V(85,19,F1,57), V(4C,07,75,AF), V(BB,DD,99,EE), V(FD,60,7F,A3), \\r
 302     V(9F,26,01,F7), V(BC,F5,72,5C), V(C5,3B,66,44), V(34,7E,FB,5B), \\r
 303     V(76,29,43,8B), V(DC,C6,23,CB), V(68,FC,ED,B6), V(63,F1,E4,B8), \\r
 304     V(CA,DC,31,D7), V(10,85,63,42), V(40,22,97,13), V(20,11,C6,84), \\r
 305     V(7D,24,4A,85), V(F8,3D,BB,D2), V(11,32,F9,AE), V(6D,A1,29,C7), \\r
 306     V(4B,2F,9E,1D), V(F3,30,B2,DC), V(EC,52,86,0D), V(D0,E3,C1,77), \\r
 307     V(6C,16,B3,2B), V(99,B9,70,A9), V(FA,48,94,11), V(22,64,E9,47), \\r
 308     V(C4,8C,FC,A8), V(1A,3F,F0,A0), V(D8,2C,7D,56), V(EF,90,33,22), \\r
 309     V(C7,4E,49,87), V(C1,D1,38,D9), V(FE,A2,CA,8C), V(36,0B,D4,98), \\r
 310     V(CF,81,F5,A6), V(28,DE,7A,A5), V(26,8E,B7,DA), V(A4,BF,AD,3F), \\r
 311     V(E4,9D,3A,2C), V(0D,92,78,50), V(9B,CC,5F,6A), V(62,46,7E,54), \\r
 312     V(C2,13,8D,F6), V(E8,B8,D8,90), V(5E,F7,39,2E), V(F5,AF,C3,82), \\r
 313     V(BE,80,5D,9F), V(7C,93,D0,69), V(A9,2D,D5,6F), V(B3,12,25,CF), \\r
 314     V(3B,99,AC,C8), V(A7,7D,18,10), V(6E,63,9C,E8), V(7B,BB,3B,DB), \\r
 315     V(09,78,26,CD), V(F4,18,59,6E), V(01,B7,9A,EC), V(A8,9A,4F,83), \\r
 316     V(65,6E,95,E6), V(7E,E6,FF,AA), V(08,CF,BC,21), V(E6,E8,15,EF), \\r
 317     V(D9,9B,E7,BA), V(CE,36,6F,4A), V(D4,09,9F,EA), V(D6,7C,B0,29), \\r
 318     V(AF,B2,A4,31), V(31,23,3F,2A), V(30,94,A5,C6), V(C0,66,A2,35), \\r
 319     V(37,BC,4E,74), V(A6,CA,82,FC), V(B0,D0,90,E0), V(15,D8,A7,33), \\r
 320     V(4A,98,04,F1), V(F7,DA,EC,41), V(0E,50,CD,7F), V(2F,F6,91,17), \\r
 321     V(8D,D6,4D,76), V(4D,B0,EF,43), V(54,4D,AA,CC), V(DF,04,96,E4), \\r
 322     V(E3,B5,D1,9E), V(1B,88,6A,4C), V(B8,1F,2C,C1), V(7F,51,65,46), \\r
 323     V(04,EA,5E,9D), V(5D,35,8C,01), V(73,74,87,FA), V(2E,41,0B,FB), \\r
 324     V(5A,1D,67,B3), V(52,D2,DB,92), V(33,56,10,E9), V(13,47,D6,6D), \\r
 325     V(8C,61,D7,9A), V(7A,0C,A1,37), V(8E,14,F8,59), V(89,3C,13,EB), \\r
 326     V(EE,27,A9,CE), V(35,C9,61,B7), V(ED,E5,1C,E1), V(3C,B1,47,7A), \\r
 327     V(59,DF,D2,9C), V(3F,73,F2,55), V(79,CE,14,18), V(BF,37,C7,73), \\r
 328     V(EA,CD,F7,53), V(5B,AA,FD,5F), V(14,6F,3D,DF), V(86,DB,44,78), \\r
 329     V(81,F3,AF,CA), V(3E,C4,68,B9), V(2C,34,24,38), V(5F,40,A3,C2), \\r
 330     V(72,C3,1D,16), V(0C,25,E2,BC), V(8B,49,3C,28), V(41,95,0D,FF), \\r
 331     V(71,01,A8,39), V(DE,B3,0C,08), V(9C,E4,B4,D8), V(90,C1,56,64), \\r
 332     V(61,84,CB,7B), V(70,B6,32,D5), V(74,5C,6C,48), V(42,57,B8,D0)\r
 333 \r
 334 #define V(a,b,c,d) 0x##a##b##c##d\r
 335 static const uint32_t RT0[256] = { RT };\r
 336 #undef V\r
 337 \r
 338 #if !defined(MBEDTLS_AES_FEWER_TABLES)\r
 339 \r
 340 #define V(a,b,c,d) 0x##b##c##d##a\r
 341 static const uint32_t RT1[256] = { RT };\r
 342 #undef V\r
 343 \r
 344 #define V(a,b,c,d) 0x##c##d##a##b\r
 345 static const uint32_t RT2[256] = { RT };\r
 346 #undef V\r
 347 \r
 348 #define V(a,b,c,d) 0x##d##a##b##c\r
 349 static const uint32_t RT3[256] = { RT };\r
 350 #undef V\r
 351 \r
 352 #endif /* !MBEDTLS_AES_FEWER_TABLES */\r
 353 \r
 354 #undef RT\r
 355 \r
 356 /*\r
 357  * Round constants\r
 358  */\r
 359 static const uint32_t RCON[10] =\r
 360 {\r
 361     0x00000001, 0x00000002, 0x00000004, 0x00000008,\r
 362     0x00000010, 0x00000020, 0x00000040, 0x00000080,\r
 363     0x0000001B, 0x00000036\r
 364 };\r
 365 \r
 366 #else /* MBEDTLS_AES_ROM_TABLES */\r
 367 \r
 368 /*\r
 369  * Forward S-box & tables\r
 370  */\r
 371 static unsigned char FSb[256];\r
 372 static uint32_t FT0[256];\r
 373 #if !defined(MBEDTLS_AES_FEWER_TABLES)\r
 374 static uint32_t FT1[256];\r
 375 static uint32_t FT2[256];\r
 376 static uint32_t FT3[256];\r
 377 #endif /* !MBEDTLS_AES_FEWER_TABLES */\r
 378 \r
 379 /*\r
 380  * Reverse S-box & tables\r
 381  */\r
 382 static unsigned char RSb[256];\r
 383 static uint32_t RT0[256];\r
 384 #if !defined(MBEDTLS_AES_FEWER_TABLES)\r
 385 static uint32_t RT1[256];\r
 386 static uint32_t RT2[256];\r
 387 static uint32_t RT3[256];\r
 388 #endif /* !MBEDTLS_AES_FEWER_TABLES */\r
 389 \r
 390 /*\r
 391  * Round constants\r
 392  */\r
 393 static uint32_t RCON[10];\r
 394 \r
 395 /*\r
 396  * Tables generation code\r
 397  */\r
 398 #define ROTL8(x) ( ( (x) << 8 ) & 0xFFFFFFFF ) | ( (x) >> 24 )\r
 399 #define XTIME(x) ( ( (x) << 1 ) ^ ( ( (x) & 0x80 ) ? 0x1B : 0x00 ) )\r
 400 #define MUL(x,y) ( ( (x) && (y) ) ? pow[(log[(x)]+log[(y)]) % 255] : 0 )\r
 401 \r
 402 static int aes_init_done = 0;\r
 403 \r
 404 static void aes_gen_tables( void )\r
 405 {\r
 406     int i, x, y, z;\r
 407     int pow[256];\r
 408     int log[256];\r
 409 \r
 410     /*\r
 411      * compute pow and log tables over GF(2^8)\r
 412      */\r
 413     for( i = 0, x = 1; i < 256; i++ )\r
 414     {\r
 415         pow[i] = x;\r
 416         log[x] = i;\r
 417         x = ( x ^ XTIME( x ) ) & 0xFF;\r
 418     }\r
 419 \r
 420     /*\r
 421      * calculate the round constants\r
 422      */\r
 423     for( i = 0, x = 1; i < 10; i++ )\r
 424     {\r
 425         RCON[i] = (uint32_t) x;\r
 426         x = XTIME( x ) & 0xFF;\r
 427     }\r
 428 \r
 429     /*\r
 430      * generate the forward and reverse S-boxes\r
 431      */\r
 432     FSb[0x00] = 0x63;\r
 433     RSb[0x63] = 0x00;\r
 434 \r
 435     for( i = 1; i < 256; i++ )\r
 436     {\r
 437         x = pow[255 - log[i]];\r
 438 \r
 439         y  = x; y = ( ( y << 1 ) | ( y >> 7 ) ) & 0xFF;\r
 440         x ^= y; y = ( ( y << 1 ) | ( y >> 7 ) ) & 0xFF;\r
 441         x ^= y; y = ( ( y << 1 ) | ( y >> 7 ) ) & 0xFF;\r
 442         x ^= y; y = ( ( y << 1 ) | ( y >> 7 ) ) & 0xFF;\r
 443         x ^= y ^ 0x63;\r
 444 \r
 445         FSb[i] = (unsigned char) x;\r
 446         RSb[x] = (unsigned char) i;\r
 447     }\r
 448 \r
 449     /*\r
 450      * generate the forward and reverse tables\r
 451      */\r
 452     for( i = 0; i < 256; i++ )\r
 453     {\r
 454         x = FSb[i];\r
 455         y = XTIME( x ) & 0xFF;\r
 456         z =  ( y ^ x ) & 0xFF;\r
 457 \r
 458         FT0[i] = ( (uint32_t) y       ) ^\r
 459                  ( (uint32_t) x <<  8 ) ^\r
 460                  ( (uint32_t) x << 16 ) ^\r
 461                  ( (uint32_t) z << 24 );\r
 462 \r
 463 #if !defined(MBEDTLS_AES_FEWER_TABLES)\r
 464         FT1[i] = ROTL8( FT0[i] );\r
 465         FT2[i] = ROTL8( FT1[i] );\r
 466         FT3[i] = ROTL8( FT2[i] );\r
 467 #endif /* !MBEDTLS_AES_FEWER_TABLES */\r
 468 \r
 469         x = RSb[i];\r
 470 \r
 471         RT0[i] = ( (uint32_t) MUL( 0x0E, x )       ) ^\r
 472                  ( (uint32_t) MUL( 0x09, x ) <<  8 ) ^\r
 473                  ( (uint32_t) MUL( 0x0D, x ) << 16 ) ^\r
 474                  ( (uint32_t) MUL( 0x0B, x ) << 24 );\r
 475 \r
 476 #if !defined(MBEDTLS_AES_FEWER_TABLES)\r
 477         RT1[i] = ROTL8( RT0[i] );\r
 478         RT2[i] = ROTL8( RT1[i] );\r
 479         RT3[i] = ROTL8( RT2[i] );\r
 480 #endif /* !MBEDTLS_AES_FEWER_TABLES */\r
 481     }\r
 482 }\r
 483 \r
 484 #undef ROTL8\r
 485 \r
 486 #endif /* MBEDTLS_AES_ROM_TABLES */\r
 487 \r
 488 #if defined(MBEDTLS_AES_FEWER_TABLES)\r
 489 \r
 490 #define ROTL8(x)  ( (uint32_t)( ( x ) <<  8 ) + (uint32_t)( ( x ) >> 24 ) )\r
 491 #define ROTL16(x) ( (uint32_t)( ( x ) << 16 ) + (uint32_t)( ( x ) >> 16 ) )\r
 492 #define ROTL24(x) ( (uint32_t)( ( x ) << 24 ) + (uint32_t)( ( x ) >>  8 ) )\r
 493 \r
 494 #define AES_RT0(idx) RT0[idx]\r
 495 #define AES_RT1(idx) ROTL8(  RT0[idx] )\r
 496 #define AES_RT2(idx) ROTL16( RT0[idx] )\r
 497 #define AES_RT3(idx) ROTL24( RT0[idx] )\r
 498 \r
 499 #define AES_FT0(idx) FT0[idx]\r
 500 #define AES_FT1(idx) ROTL8(  FT0[idx] )\r
 501 #define AES_FT2(idx) ROTL16( FT0[idx] )\r
 502 #define AES_FT3(idx) ROTL24( FT0[idx] )\r
 503 \r
 504 #else /* MBEDTLS_AES_FEWER_TABLES */\r
 505 \r
 506 #define AES_RT0(idx) RT0[idx]\r
 507 #define AES_RT1(idx) RT1[idx]\r
 508 #define AES_RT2(idx) RT2[idx]\r
 509 #define AES_RT3(idx) RT3[idx]\r
 510 \r
 511 #define AES_FT0(idx) FT0[idx]\r
 512 #define AES_FT1(idx) FT1[idx]\r
 513 #define AES_FT2(idx) FT2[idx]\r
 514 #define AES_FT3(idx) FT3[idx]\r
 515 \r
 516 #endif /* MBEDTLS_AES_FEWER_TABLES */\r
 517 \r
 518 void mbedtls_aes_init( mbedtls_aes_context *ctx )\r
 519 {\r
 520     AES_VALIDATE( ctx != NULL );\r
 521 \r
 522     memset( ctx, 0, sizeof( mbedtls_aes_context ) );\r
 523 }\r
 524 \r
 525 void mbedtls_aes_free( mbedtls_aes_context *ctx )\r
 526 {\r
 527     if( ctx == NULL )\r
 528         return;\r
 529 \r
 530     mbedtls_platform_zeroize( ctx, sizeof( mbedtls_aes_context ) );\r
 531 }\r
 532 \r
 533 #if defined(MBEDTLS_CIPHER_MODE_XTS)\r
 534 void mbedtls_aes_xts_init( mbedtls_aes_xts_context *ctx )\r
 535 {\r
 536     AES_VALIDATE( ctx != NULL );\r
 537 \r
 538     mbedtls_aes_init( &ctx->crypt );\r
 539     mbedtls_aes_init( &ctx->tweak );\r
 540 }\r
 541 \r
 542 void mbedtls_aes_xts_free( mbedtls_aes_xts_context *ctx )\r
 543 {\r
 544     if( ctx == NULL )\r
 545         return;\r
 546 \r
 547     mbedtls_aes_free( &ctx->crypt );\r
 548     mbedtls_aes_free( &ctx->tweak );\r
 549 }\r
 550 #endif /* MBEDTLS_CIPHER_MODE_XTS */\r
 551 \r
 552 /*\r
 553  * AES key schedule (encryption)\r
 554  */\r
 555 #if !defined(MBEDTLS_AES_SETKEY_ENC_ALT)\r
 556 int mbedtls_aes_setkey_enc( mbedtls_aes_context *ctx, const unsigned char *key,\r
 557                     unsigned int keybits )\r
 558 {\r
 559     unsigned int i;\r
 560     uint32_t *RK;\r
 561 \r
 562     AES_VALIDATE_RET( ctx != NULL );\r
 563     AES_VALIDATE_RET( key != NULL );\r
 564 \r
 565     switch( keybits )\r
 566     {\r
 567         case 128: ctx->nr = 10; break;\r
 568         case 192: ctx->nr = 12; break;\r
 569         case 256: ctx->nr = 14; break;\r
 570         default : return( MBEDTLS_ERR_AES_INVALID_KEY_LENGTH );\r
 571     }\r
 572 \r
 573 #if !defined(MBEDTLS_AES_ROM_TABLES)\r
 574     if( aes_init_done == 0 )\r
 575     {\r
 576         aes_gen_tables();\r
 577         aes_init_done = 1;\r
 578     }\r
 579 #endif\r
 580 \r
 581 #if defined(MBEDTLS_PADLOCK_C) && defined(MBEDTLS_PADLOCK_ALIGN16)\r
 582     if( aes_padlock_ace == -1 )\r
 583         aes_padlock_ace = mbedtls_padlock_has_support( MBEDTLS_PADLOCK_ACE );\r
 584 \r
 585     if( aes_padlock_ace )\r
 586         ctx->rk = RK = MBEDTLS_PADLOCK_ALIGN16( ctx->buf );\r
 587     else\r
 588 #endif\r
 589     ctx->rk = RK = ctx->buf;\r
 590 \r
 591 #if defined(MBEDTLS_AESNI_C) && defined(MBEDTLS_HAVE_X86_64)\r
 592     if( mbedtls_aesni_has_support( MBEDTLS_AESNI_AES ) )\r
 593         return( mbedtls_aesni_setkey_enc( (unsigned char *) ctx->rk, key, keybits ) );\r
 594 #endif\r
 595 \r
 596     for( i = 0; i < ( keybits >> 5 ); i++ )\r
 597     {\r
 598         GET_UINT32_LE( RK[i], key, i << 2 );\r
 599     }\r
 600 \r
 601     switch( ctx->nr )\r
 602     {\r
 603         case 10:\r
 604 \r
 605             for( i = 0; i < 10; i++, RK += 4 )\r
 606             {\r
 607                 RK[4]  = RK[0] ^ RCON[i] ^\r
 608                 ( (uint32_t) FSb[ ( RK[3] >>  8 ) & 0xFF ]       ) ^\r
 609                 ( (uint32_t) FSb[ ( RK[3] >> 16 ) & 0xFF ] <<  8 ) ^\r
 610                 ( (uint32_t) FSb[ ( RK[3] >> 24 ) & 0xFF ] << 16 ) ^\r
 611                 ( (uint32_t) FSb[ ( RK[3]       ) & 0xFF ] << 24 );\r
 612 \r
 613                 RK[5]  = RK[1] ^ RK[4];\r
 614                 RK[6]  = RK[2] ^ RK[5];\r
 615                 RK[7]  = RK[3] ^ RK[6];\r
 616             }\r
 617             break;\r
 618 \r
 619         case 12:\r
 620 \r
 621             for( i = 0; i < 8; i++, RK += 6 )\r
 622             {\r
 623                 RK[6]  = RK[0] ^ RCON[i] ^\r
 624                 ( (uint32_t) FSb[ ( RK[5] >>  8 ) & 0xFF ]       ) ^\r
 625                 ( (uint32_t) FSb[ ( RK[5] >> 16 ) & 0xFF ] <<  8 ) ^\r
 626                 ( (uint32_t) FSb[ ( RK[5] >> 24 ) & 0xFF ] << 16 ) ^\r
 627                 ( (uint32_t) FSb[ ( RK[5]       ) & 0xFF ] << 24 );\r
 628 \r
 629                 RK[7]  = RK[1] ^ RK[6];\r
 630                 RK[8]  = RK[2] ^ RK[7];\r
 631                 RK[9]  = RK[3] ^ RK[8];\r
 632                 RK[10] = RK[4] ^ RK[9];\r
 633                 RK[11] = RK[5] ^ RK[10];\r
 634             }\r
 635             break;\r
 636 \r
 637         case 14:\r
 638 \r
 639             for( i = 0; i < 7; i++, RK += 8 )\r
 640             {\r
 641                 RK[8]  = RK[0] ^ RCON[i] ^\r
 642                 ( (uint32_t) FSb[ ( RK[7] >>  8 ) & 0xFF ]       ) ^\r
 643                 ( (uint32_t) FSb[ ( RK[7] >> 16 ) & 0xFF ] <<  8 ) ^\r
 644                 ( (uint32_t) FSb[ ( RK[7] >> 24 ) & 0xFF ] << 16 ) ^\r
 645                 ( (uint32_t) FSb[ ( RK[7]       ) & 0xFF ] << 24 );\r
 646 \r
 647                 RK[9]  = RK[1] ^ RK[8];\r
 648                 RK[10] = RK[2] ^ RK[9];\r
 649                 RK[11] = RK[3] ^ RK[10];\r
 650 \r
 651                 RK[12] = RK[4] ^\r
 652                 ( (uint32_t) FSb[ ( RK[11]       ) & 0xFF ]       ) ^\r
 653                 ( (uint32_t) FSb[ ( RK[11] >>  8 ) & 0xFF ] <<  8 ) ^\r
 654                 ( (uint32_t) FSb[ ( RK[11] >> 16 ) & 0xFF ] << 16 ) ^\r
 655                 ( (uint32_t) FSb[ ( RK[11] >> 24 ) & 0xFF ] << 24 );\r
 656 \r
 657                 RK[13] = RK[5] ^ RK[12];\r
 658                 RK[14] = RK[6] ^ RK[13];\r
 659                 RK[15] = RK[7] ^ RK[14];\r
 660             }\r
 661             break;\r
 662     }\r
 663 \r
 664     return( 0 );\r
 665 }\r
 666 #endif /* !MBEDTLS_AES_SETKEY_ENC_ALT */\r
 667 \r
 668 /*\r
 669  * AES key schedule (decryption)\r
 670  */\r
 671 #if !defined(MBEDTLS_AES_SETKEY_DEC_ALT)\r
 672 int mbedtls_aes_setkey_dec( mbedtls_aes_context *ctx, const unsigned char *key,\r
 673                     unsigned int keybits )\r
 674 {\r
 675     int i, j, ret;\r
 676     mbedtls_aes_context cty;\r
 677     uint32_t *RK;\r
 678     uint32_t *SK;\r
 679 \r
 680     AES_VALIDATE_RET( ctx != NULL );\r
 681     AES_VALIDATE_RET( key != NULL );\r
 682 \r
 683     mbedtls_aes_init( &cty );\r
 684 \r
 685 #if defined(MBEDTLS_PADLOCK_C) && defined(MBEDTLS_PADLOCK_ALIGN16)\r
 686     if( aes_padlock_ace == -1 )\r
 687         aes_padlock_ace = mbedtls_padlock_has_support( MBEDTLS_PADLOCK_ACE );\r
 688 \r
 689     if( aes_padlock_ace )\r
 690         ctx->rk = RK = MBEDTLS_PADLOCK_ALIGN16( ctx->buf );\r
 691     else\r
 692 #endif\r
 693     ctx->rk = RK = ctx->buf;\r
 694 \r
 695     /* Also checks keybits */\r
 696     if( ( ret = mbedtls_aes_setkey_enc( &cty, key, keybits ) ) != 0 )\r
 697         goto exit;\r
 698 \r
 699     ctx->nr = cty.nr;\r
 700 \r
 701 #if defined(MBEDTLS_AESNI_C) && defined(MBEDTLS_HAVE_X86_64)\r
 702     if( mbedtls_aesni_has_support( MBEDTLS_AESNI_AES ) )\r
 703     {\r
 704         mbedtls_aesni_inverse_key( (unsigned char *) ctx->rk,\r
 705                            (const unsigned char *) cty.rk, ctx->nr );\r
 706         goto exit;\r
 707     }\r
 708 #endif\r
 709 \r
 710     SK = cty.rk + cty.nr * 4;\r
 711 \r
 712     *RK++ = *SK++;\r
 713     *RK++ = *SK++;\r
 714     *RK++ = *SK++;\r
 715     *RK++ = *SK++;\r
 716 \r
 717     for( i = ctx->nr - 1, SK -= 8; i > 0; i--, SK -= 8 )\r
 718     {\r
 719         for( j = 0; j < 4; j++, SK++ )\r
 720         {\r
 721             *RK++ = AES_RT0( FSb[ ( *SK       ) & 0xFF ] ) ^\r
 722                     AES_RT1( FSb[ ( *SK >>  8 ) & 0xFF ] ) ^\r
 723                     AES_RT2( FSb[ ( *SK >> 16 ) & 0xFF ] ) ^\r
 724                     AES_RT3( FSb[ ( *SK >> 24 ) & 0xFF ] );\r
 725         }\r
 726     }\r
 727 \r
 728     *RK++ = *SK++;\r
 729     *RK++ = *SK++;\r
 730     *RK++ = *SK++;\r
 731     *RK++ = *SK++;\r
 732 \r
 733 exit:\r
 734     mbedtls_aes_free( &cty );\r
 735 \r
 736     return( ret );\r
 737 }\r
 738 \r
 739 #if defined(MBEDTLS_CIPHER_MODE_XTS)\r
 740 static int mbedtls_aes_xts_decode_keys( const unsigned char *key,\r
 741                                         unsigned int keybits,\r
 742                                         const unsigned char **key1,\r
 743                                         unsigned int *key1bits,\r
 744                                         const unsigned char **key2,\r
 745                                         unsigned int *key2bits )\r
 746 {\r
 747     const unsigned int half_keybits = keybits / 2;\r
 748     const unsigned int half_keybytes = half_keybits / 8;\r
 749 \r
 750     switch( keybits )\r
 751     {\r
 752         case 256: break;\r
 753         case 512: break;\r
 754         default : return( MBEDTLS_ERR_AES_INVALID_KEY_LENGTH );\r
 755     }\r
 756 \r
 757     *key1bits = half_keybits;\r
 758     *key2bits = half_keybits;\r
 759     *key1 = &key[0];\r
 760     *key2 = &key[half_keybytes];\r
 761 \r
 762     return 0;\r
 763 }\r
 764 \r
 765 int mbedtls_aes_xts_setkey_enc( mbedtls_aes_xts_context *ctx,\r
 766                                 const unsigned char *key,\r
 767                                 unsigned int keybits)\r
 768 {\r
 769     int ret;\r
 770     const unsigned char *key1, *key2;\r
 771     unsigned int key1bits, key2bits;\r
 772 \r
 773     AES_VALIDATE_RET( ctx != NULL );\r
 774     AES_VALIDATE_RET( key != NULL );\r
 775 \r
 776     ret = mbedtls_aes_xts_decode_keys( key, keybits, &key1, &key1bits,\r
 777                                        &key2, &key2bits );\r
 778     if( ret != 0 )\r
 779         return( ret );\r
 780 \r
 781     /* Set the tweak key. Always set tweak key for the encryption mode. */\r
 782     ret = mbedtls_aes_setkey_enc( &ctx->tweak, key2, key2bits );\r
 783     if( ret != 0 )\r
 784         return( ret );\r
 785 \r
 786     /* Set crypt key for encryption. */\r
 787     return mbedtls_aes_setkey_enc( &ctx->crypt, key1, key1bits );\r
 788 }\r
 789 \r
 790 int mbedtls_aes_xts_setkey_dec( mbedtls_aes_xts_context *ctx,\r
 791                                 const unsigned char *key,\r
 792                                 unsigned int keybits)\r
 793 {\r
 794     int ret;\r
 795     const unsigned char *key1, *key2;\r
 796     unsigned int key1bits, key2bits;\r
 797 \r
 798     AES_VALIDATE_RET( ctx != NULL );\r
 799     AES_VALIDATE_RET( key != NULL );\r
 800 \r
 801     ret = mbedtls_aes_xts_decode_keys( key, keybits, &key1, &key1bits,\r
 802                                        &key2, &key2bits );\r
 803     if( ret != 0 )\r
 804         return( ret );\r
 805 \r
 806     /* Set the tweak key. Always set tweak key for encryption. */\r
 807     ret = mbedtls_aes_setkey_enc( &ctx->tweak, key2, key2bits );\r
 808     if( ret != 0 )\r
 809         return( ret );\r
 810 \r
 811     /* Set crypt key for decryption. */\r
 812     return mbedtls_aes_setkey_dec( &ctx->crypt, key1, key1bits );\r
 813 }\r
 814 #endif /* MBEDTLS_CIPHER_MODE_XTS */\r
 815 \r
 816 #endif /* !MBEDTLS_AES_SETKEY_DEC_ALT */\r
 817 \r
 818 #define AES_FROUND(X0,X1,X2,X3,Y0,Y1,Y2,Y3)                     \\r
 819     do                                                          \\r
 820     {                                                           \\r
 821         (X0) = *RK++ ^ AES_FT0( ( (Y0)       ) & 0xFF ) ^       \\r
 822                        AES_FT1( ( (Y1) >>  8 ) & 0xFF ) ^       \\r
 823                        AES_FT2( ( (Y2) >> 16 ) & 0xFF ) ^       \\r
 824                        AES_FT3( ( (Y3) >> 24 ) & 0xFF );        \\r
 825                                                                 \\r
 826         (X1) = *RK++ ^ AES_FT0( ( (Y1)       ) & 0xFF ) ^       \\r
 827                        AES_FT1( ( (Y2) >>  8 ) & 0xFF ) ^       \\r
 828                        AES_FT2( ( (Y3) >> 16 ) & 0xFF ) ^       \\r
 829                        AES_FT3( ( (Y0) >> 24 ) & 0xFF );        \\r
 830                                                                 \\r
 831         (X2) = *RK++ ^ AES_FT0( ( (Y2)       ) & 0xFF ) ^       \\r
 832                        AES_FT1( ( (Y3) >>  8 ) & 0xFF ) ^       \\r
 833                        AES_FT2( ( (Y0) >> 16 ) & 0xFF ) ^       \\r
 834                        AES_FT3( ( (Y1) >> 24 ) & 0xFF );        \\r
 835                                                                 \\r
 836         (X3) = *RK++ ^ AES_FT0( ( (Y3)       ) & 0xFF ) ^       \\r
 837                        AES_FT1( ( (Y0) >>  8 ) & 0xFF ) ^       \\r
 838                        AES_FT2( ( (Y1) >> 16 ) & 0xFF ) ^       \\r
 839                        AES_FT3( ( (Y2) >> 24 ) & 0xFF );        \\r
 840     } while( 0 )\r
 841 \r
 842 #define AES_RROUND(X0,X1,X2,X3,Y0,Y1,Y2,Y3)                 \\r
 843     do                                                      \\r
 844     {                                                       \\r
 845         (X0) = *RK++ ^ AES_RT0( ( (Y0)       ) & 0xFF ) ^   \\r
 846                        AES_RT1( ( (Y3) >>  8 ) & 0xFF ) ^   \\r
 847                        AES_RT2( ( (Y2) >> 16 ) & 0xFF ) ^   \\r
 848                        AES_RT3( ( (Y1) >> 24 ) & 0xFF );    \\r
 849                                                             \\r
 850         (X1) = *RK++ ^ AES_RT0( ( (Y1)       ) & 0xFF ) ^   \\r
 851                        AES_RT1( ( (Y0) >>  8 ) & 0xFF ) ^   \\r
 852                        AES_RT2( ( (Y3) >> 16 ) & 0xFF ) ^   \\r
 853                        AES_RT3( ( (Y2) >> 24 ) & 0xFF );    \\r
 854                                                             \\r
 855         (X2) = *RK++ ^ AES_RT0( ( (Y2)       ) & 0xFF ) ^   \\r
 856                        AES_RT1( ( (Y1) >>  8 ) & 0xFF ) ^   \\r
 857                        AES_RT2( ( (Y0) >> 16 ) & 0xFF ) ^   \\r
 858                        AES_RT3( ( (Y3) >> 24 ) & 0xFF );    \\r
 859                                                             \\r
 860         (X3) = *RK++ ^ AES_RT0( ( (Y3)       ) & 0xFF ) ^   \\r
 861                        AES_RT1( ( (Y2) >>  8 ) & 0xFF ) ^   \\r
 862                        AES_RT2( ( (Y1) >> 16 ) & 0xFF ) ^   \\r
 863                        AES_RT3( ( (Y0) >> 24 ) & 0xFF );    \\r
 864     } while( 0 )\r
 865 \r
 866 /*\r
 867  * AES-ECB block encryption\r
 868  */\r
 869 #if !defined(MBEDTLS_AES_ENCRYPT_ALT)\r
 870 int mbedtls_internal_aes_encrypt( mbedtls_aes_context *ctx,\r
 871                                   const unsigned char input[16],\r
 872                                   unsigned char output[16] )\r
 873 {\r
 874     int i;\r
 875     uint32_t *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3;\r
 876 \r
 877     RK = ctx->rk;\r
 878 \r
 879     GET_UINT32_LE( X0, input,  0 ); X0 ^= *RK++;\r
 880     GET_UINT32_LE( X1, input,  4 ); X1 ^= *RK++;\r
 881     GET_UINT32_LE( X2, input,  8 ); X2 ^= *RK++;\r
 882     GET_UINT32_LE( X3, input, 12 ); X3 ^= *RK++;\r
 883 \r
 884     for( i = ( ctx->nr >> 1 ) - 1; i > 0; i-- )\r
 885     {\r
 886         AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );\r
 887         AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );\r
 888     }\r
 889 \r
 890     AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );\r
 891 \r
 892     X0 = *RK++ ^ \\r
 893             ( (uint32_t) FSb[ ( Y0       ) & 0xFF ]       ) ^\r
 894             ( (uint32_t) FSb[ ( Y1 >>  8 ) & 0xFF ] <<  8 ) ^\r
 895             ( (uint32_t) FSb[ ( Y2 >> 16 ) & 0xFF ] << 16 ) ^\r
 896             ( (uint32_t) FSb[ ( Y3 >> 24 ) & 0xFF ] << 24 );\r
 897 \r
 898     X1 = *RK++ ^ \\r
 899             ( (uint32_t) FSb[ ( Y1       ) & 0xFF ]       ) ^\r
 900             ( (uint32_t) FSb[ ( Y2 >>  8 ) & 0xFF ] <<  8 ) ^\r
 901             ( (uint32_t) FSb[ ( Y3 >> 16 ) & 0xFF ] << 16 ) ^\r
 902             ( (uint32_t) FSb[ ( Y0 >> 24 ) & 0xFF ] << 24 );\r
 903 \r
 904     X2 = *RK++ ^ \\r
 905             ( (uint32_t) FSb[ ( Y2       ) & 0xFF ]       ) ^\r
 906             ( (uint32_t) FSb[ ( Y3 >>  8 ) & 0xFF ] <<  8 ) ^\r
 907             ( (uint32_t) FSb[ ( Y0 >> 16 ) & 0xFF ] << 16 ) ^\r
 908             ( (uint32_t) FSb[ ( Y1 >> 24 ) & 0xFF ] << 24 );\r
 909 \r
 910     X3 = *RK++ ^ \\r
 911             ( (uint32_t) FSb[ ( Y3       ) & 0xFF ]       ) ^\r
 912             ( (uint32_t) FSb[ ( Y0 >>  8 ) & 0xFF ] <<  8 ) ^\r
 913             ( (uint32_t) FSb[ ( Y1 >> 16 ) & 0xFF ] << 16 ) ^\r
 914             ( (uint32_t) FSb[ ( Y2 >> 24 ) & 0xFF ] << 24 );\r
 915 \r
 916     PUT_UINT32_LE( X0, output,  0 );\r
 917     PUT_UINT32_LE( X1, output,  4 );\r
 918     PUT_UINT32_LE( X2, output,  8 );\r
 919     PUT_UINT32_LE( X3, output, 12 );\r
 920 \r
 921     return( 0 );\r
 922 }\r
 923 #endif /* !MBEDTLS_AES_ENCRYPT_ALT */\r
 924 \r
 925 #if !defined(MBEDTLS_DEPRECATED_REMOVED)\r
 926 void mbedtls_aes_encrypt( mbedtls_aes_context *ctx,\r
 927                           const unsigned char input[16],\r
 928                           unsigned char output[16] )\r
 929 {\r
 930     mbedtls_internal_aes_encrypt( ctx, input, output );\r
 931 }\r
 932 #endif /* !MBEDTLS_DEPRECATED_REMOVED */\r
 933 \r
 934 /*\r
 935  * AES-ECB block decryption\r
 936  */\r
 937 #if !defined(MBEDTLS_AES_DECRYPT_ALT)\r
 938 int mbedtls_internal_aes_decrypt( mbedtls_aes_context *ctx,\r
 939                                   const unsigned char input[16],\r
 940                                   unsigned char output[16] )\r
 941 {\r
 942     int i;\r
 943     uint32_t *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3;\r
 944 \r
 945     RK = ctx->rk;\r
 946 \r
 947     GET_UINT32_LE( X0, input,  0 ); X0 ^= *RK++;\r
 948     GET_UINT32_LE( X1, input,  4 ); X1 ^= *RK++;\r
 949     GET_UINT32_LE( X2, input,  8 ); X2 ^= *RK++;\r
 950     GET_UINT32_LE( X3, input, 12 ); X3 ^= *RK++;\r
 951 \r
 952     for( i = ( ctx->nr >> 1 ) - 1; i > 0; i-- )\r
 953     {\r
 954         AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );\r
 955         AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );\r
 956     }\r
 957 \r
 958     AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );\r
 959 \r
 960     X0 = *RK++ ^ \\r
 961             ( (uint32_t) RSb[ ( Y0       ) & 0xFF ]       ) ^\r
 962             ( (uint32_t) RSb[ ( Y3 >>  8 ) & 0xFF ] <<  8 ) ^\r
 963             ( (uint32_t) RSb[ ( Y2 >> 16 ) & 0xFF ] << 16 ) ^\r
 964             ( (uint32_t) RSb[ ( Y1 >> 24 ) & 0xFF ] << 24 );\r
 965 \r
 966     X1 = *RK++ ^ \\r
 967             ( (uint32_t) RSb[ ( Y1       ) & 0xFF ]       ) ^\r
 968             ( (uint32_t) RSb[ ( Y0 >>  8 ) & 0xFF ] <<  8 ) ^\r
 969             ( (uint32_t) RSb[ ( Y3 >> 16 ) & 0xFF ] << 16 ) ^\r
 970             ( (uint32_t) RSb[ ( Y2 >> 24 ) & 0xFF ] << 24 );\r
 971 \r
 972     X2 = *RK++ ^ \\r
 973             ( (uint32_t) RSb[ ( Y2       ) & 0xFF ]       ) ^\r
 974             ( (uint32_t) RSb[ ( Y1 >>  8 ) & 0xFF ] <<  8 ) ^\r
 975             ( (uint32_t) RSb[ ( Y0 >> 16 ) & 0xFF ] << 16 ) ^\r
 976             ( (uint32_t) RSb[ ( Y3 >> 24 ) & 0xFF ] << 24 );\r
 977 \r
 978     X3 = *RK++ ^ \\r
 979             ( (uint32_t) RSb[ ( Y3       ) & 0xFF ]       ) ^\r
 980             ( (uint32_t) RSb[ ( Y2 >>  8 ) & 0xFF ] <<  8 ) ^\r
 981             ( (uint32_t) RSb[ ( Y1 >> 16 ) & 0xFF ] << 16 ) ^\r
 982             ( (uint32_t) RSb[ ( Y0 >> 24 ) & 0xFF ] << 24 );\r
 983 \r
 984     PUT_UINT32_LE( X0, output,  0 );\r
 985     PUT_UINT32_LE( X1, output,  4 );\r
 986     PUT_UINT32_LE( X2, output,  8 );\r
 987     PUT_UINT32_LE( X3, output, 12 );\r
 988 \r
 989     return( 0 );\r
 990 }\r
 991 #endif /* !MBEDTLS_AES_DECRYPT_ALT */\r
 992 \r
 993 #if !defined(MBEDTLS_DEPRECATED_REMOVED)\r
 994 void mbedtls_aes_decrypt( mbedtls_aes_context *ctx,\r
 995                           const unsigned char input[16],\r
 996                           unsigned char output[16] )\r
 997 {\r
 998     mbedtls_internal_aes_decrypt( ctx, input, output );\r
 999 }\r
1000 #endif /* !MBEDTLS_DEPRECATED_REMOVED */\r
1001 \r
1002 /*\r
1003  * AES-ECB block encryption/decryption\r
1004  */\r
1005 int mbedtls_aes_crypt_ecb( mbedtls_aes_context *ctx,\r
1006                            int mode,\r
1007                            const unsigned char input[16],\r
1008                            unsigned char output[16] )\r
1009 {\r
1010     AES_VALIDATE_RET( ctx != NULL );\r
1011     AES_VALIDATE_RET( input != NULL );\r
1012     AES_VALIDATE_RET( output != NULL );\r
1013     AES_VALIDATE_RET( mode == MBEDTLS_AES_ENCRYPT ||\r
1014                       mode == MBEDTLS_AES_DECRYPT );\r
1015 \r
1016 #if defined(MBEDTLS_AESNI_C) && defined(MBEDTLS_HAVE_X86_64)\r
1017     if( mbedtls_aesni_has_support( MBEDTLS_AESNI_AES ) )\r
1018         return( mbedtls_aesni_crypt_ecb( ctx, mode, input, output ) );\r
1019 #endif\r
1020 \r
1021 #if defined(MBEDTLS_PADLOCK_C) && defined(MBEDTLS_HAVE_X86)\r
1022     if( aes_padlock_ace )\r
1023     {\r
1024         if( mbedtls_padlock_xcryptecb( ctx, mode, input, output ) == 0 )\r
1025             return( 0 );\r
1026 \r
1027         // If padlock data misaligned, we just fall back to\r
1028         // unaccelerated mode\r
1029         //\r
1030     }\r
1031 #endif\r
1032 \r
1033     if( mode == MBEDTLS_AES_ENCRYPT )\r
1034         return( mbedtls_internal_aes_encrypt( ctx, input, output ) );\r
1035     else\r
1036         return( mbedtls_internal_aes_decrypt( ctx, input, output ) );\r
1037 }\r
1038 \r
1039 #if defined(MBEDTLS_CIPHER_MODE_CBC)\r
1040 /*\r
1041  * AES-CBC buffer encryption/decryption\r
1042  */\r
1043 int mbedtls_aes_crypt_cbc( mbedtls_aes_context *ctx,\r
1044                     int mode,\r
1045                     size_t length,\r
1046                     unsigned char iv[16],\r
1047                     const unsigned char *input,\r
1048                     unsigned char *output )\r
1049 {\r
1050     int i;\r
1051     unsigned char temp[16];\r
1052 \r
1053     AES_VALIDATE_RET( ctx != NULL );\r
1054     AES_VALIDATE_RET( mode == MBEDTLS_AES_ENCRYPT ||\r
1055                       mode == MBEDTLS_AES_DECRYPT );\r
1056     AES_VALIDATE_RET( iv != NULL );\r
1057     AES_VALIDATE_RET( input != NULL );\r
1058     AES_VALIDATE_RET( output != NULL );\r
1059 \r
1060     if( length % 16 )\r
1061         return( MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH );\r
1062 \r
1063 #if defined(MBEDTLS_PADLOCK_C) && defined(MBEDTLS_HAVE_X86)\r
1064     if( aes_padlock_ace )\r
1065     {\r
1066         if( mbedtls_padlock_xcryptcbc( ctx, mode, length, iv, input, output ) == 0 )\r
1067             return( 0 );\r
1068 \r
1069         // If padlock data misaligned, we just fall back to\r
1070         // unaccelerated mode\r
1071         //\r
1072     }\r
1073 #endif\r
1074 \r
1075     if( mode == MBEDTLS_AES_DECRYPT )\r
1076     {\r
1077         while( length > 0 )\r
1078         {\r
1079             memcpy( temp, input, 16 );\r
1080             mbedtls_aes_crypt_ecb( ctx, mode, input, output );\r
1081 \r
1082             for( i = 0; i < 16; i++ )\r
1083                 output[i] = (unsigned char)( output[i] ^ iv[i] );\r
1084 \r
1085             memcpy( iv, temp, 16 );\r
1086 \r
1087             input  += 16;\r
1088             output += 16;\r
1089             length -= 16;\r
1090         }\r
1091     }\r
1092     else\r
1093     {\r
1094         while( length > 0 )\r
1095         {\r
1096             for( i = 0; i < 16; i++ )\r
1097                 output[i] = (unsigned char)( input[i] ^ iv[i] );\r
1098 \r
1099             mbedtls_aes_crypt_ecb( ctx, mode, output, output );\r
1100             memcpy( iv, output, 16 );\r
1101 \r
1102             input  += 16;\r
1103             output += 16;\r
1104             length -= 16;\r
1105         }\r
1106     }\r
1107 \r
1108     return( 0 );\r
1109 }\r
1110 #endif /* MBEDTLS_CIPHER_MODE_CBC */\r
1111 \r
1112 #if defined(MBEDTLS_CIPHER_MODE_XTS)\r
1113 \r
1114 /* Endianess with 64 bits values */\r
1115 #ifndef GET_UINT64_LE\r
1116 #define GET_UINT64_LE(n,b,i)                            \\r
1117 {                                                       \\r
1118     (n) = ( (uint64_t) (b)[(i) + 7] << 56 )             \\r
1119         | ( (uint64_t) (b)[(i) + 6] << 48 )             \\r
1120         | ( (uint64_t) (b)[(i) + 5] << 40 )             \\r
1121         | ( (uint64_t) (b)[(i) + 4] << 32 )             \\r
1122         | ( (uint64_t) (b)[(i) + 3] << 24 )             \\r
1123         | ( (uint64_t) (b)[(i) + 2] << 16 )             \\r
1124         | ( (uint64_t) (b)[(i) + 1] <<  8 )             \\r
1125         | ( (uint64_t) (b)[(i)    ]       );            \\r
1126 }\r
1127 #endif\r
1128 \r
1129 #ifndef PUT_UINT64_LE\r
1130 #define PUT_UINT64_LE(n,b,i)                            \\r
1131 {                                                       \\r
1132     (b)[(i) + 7] = (unsigned char) ( (n) >> 56 );       \\r
1133     (b)[(i) + 6] = (unsigned char) ( (n) >> 48 );       \\r
1134     (b)[(i) + 5] = (unsigned char) ( (n) >> 40 );       \\r
1135     (b)[(i) + 4] = (unsigned char) ( (n) >> 32 );       \\r
1136     (b)[(i) + 3] = (unsigned char) ( (n) >> 24 );       \\r
1137     (b)[(i) + 2] = (unsigned char) ( (n) >> 16 );       \\r
1138     (b)[(i) + 1] = (unsigned char) ( (n) >>  8 );       \\r
1139     (b)[(i)    ] = (unsigned char) ( (n)       );       \\r
1140 }\r
1141 #endif\r
1142 \r
1143 typedef unsigned char mbedtls_be128[16];\r
1144 \r
1145 /*\r
1146  * GF(2^128) multiplication function\r
1147  *\r
1148  * This function multiplies a field element by x in the polynomial field\r
1149  * representation. It uses 64-bit word operations to gain speed but compensates\r
1150  * for machine endianess and hence works correctly on both big and little\r
1151  * endian machines.\r
1152  */\r
1153 static void mbedtls_gf128mul_x_ble( unsigned char r[16],\r
1154                                     const unsigned char x[16] )\r
1155 {\r
1156     uint64_t a, b, ra, rb;\r
1157 \r
1158     GET_UINT64_LE( a, x, 0 );\r
1159     GET_UINT64_LE( b, x, 8 );\r
1160 \r
1161     ra = ( a << 1 )  ^ 0x0087 >> ( 8 - ( ( b >> 63 ) << 3 ) );\r
1162     rb = ( a >> 63 ) | ( b << 1 );\r
1163 \r
1164     PUT_UINT64_LE( ra, r, 0 );\r
1165     PUT_UINT64_LE( rb, r, 8 );\r
1166 }\r
1167 \r
1168 /*\r
1169  * AES-XTS buffer encryption/decryption\r
1170  */\r
1171 int mbedtls_aes_crypt_xts( mbedtls_aes_xts_context *ctx,\r
1172                            int mode,\r
1173                            size_t length,\r
1174                            const unsigned char data_unit[16],\r
1175                            const unsigned char *input,\r
1176                            unsigned char *output )\r
1177 {\r
1178     int ret;\r
1179     size_t blocks = length / 16;\r
1180     size_t leftover = length % 16;\r
1181     unsigned char tweak[16];\r
1182     unsigned char prev_tweak[16];\r
1183     unsigned char tmp[16];\r
1184 \r
1185     AES_VALIDATE_RET( ctx != NULL );\r
1186     AES_VALIDATE_RET( mode == MBEDTLS_AES_ENCRYPT ||\r
1187                       mode == MBEDTLS_AES_DECRYPT );\r
1188     AES_VALIDATE_RET( data_unit != NULL );\r
1189     AES_VALIDATE_RET( input != NULL );\r
1190     AES_VALIDATE_RET( output != NULL );\r
1191 \r
1192     /* Data units must be at least 16 bytes long. */\r
1193     if( length < 16 )\r
1194         return MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH;\r
1195 \r
1196     /* NIST SP 800-38E disallows data units larger than 2**20 blocks. */\r
1197     if( length > ( 1 << 20 ) * 16 )\r
1198         return MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH;\r
1199 \r
1200     /* Compute the tweak. */\r
1201     ret = mbedtls_aes_crypt_ecb( &ctx->tweak, MBEDTLS_AES_ENCRYPT,\r
1202                                  data_unit, tweak );\r
1203     if( ret != 0 )\r
1204         return( ret );\r
1205 \r
1206     while( blocks-- )\r
1207     {\r
1208         size_t i;\r
1209 \r
1210         if( leftover && ( mode == MBEDTLS_AES_DECRYPT ) && blocks == 0 )\r
1211         {\r
1212             /* We are on the last block in a decrypt operation that has\r
1213              * leftover bytes, so we need to use the next tweak for this block,\r
1214              * and this tweak for the lefover bytes. Save the current tweak for\r
1215              * the leftovers and then update the current tweak for use on this,\r
1216              * the last full block. */\r
1217             memcpy( prev_tweak, tweak, sizeof( tweak ) );\r
1218             mbedtls_gf128mul_x_ble( tweak, tweak );\r
1219         }\r
1220 \r
1221         for( i = 0; i < 16; i++ )\r
1222             tmp[i] = input[i] ^ tweak[i];\r
1223 \r
1224         ret = mbedtls_aes_crypt_ecb( &ctx->crypt, mode, tmp, tmp );\r
1225         if( ret != 0 )\r
1226             return( ret );\r
1227 \r
1228         for( i = 0; i < 16; i++ )\r
1229             output[i] = tmp[i] ^ tweak[i];\r
1230 \r
1231         /* Update the tweak for the next block. */\r
1232         mbedtls_gf128mul_x_ble( tweak, tweak );\r
1233 \r
1234         output += 16;\r
1235         input += 16;\r
1236     }\r
1237 \r
1238     if( leftover )\r
1239     {\r
1240         /* If we are on the leftover bytes in a decrypt operation, we need to\r
1241          * use the previous tweak for these bytes (as saved in prev_tweak). */\r
1242         unsigned char *t = mode == MBEDTLS_AES_DECRYPT ? prev_tweak : tweak;\r
1243 \r
1244         /* We are now on the final part of the data unit, which doesn't divide\r
1245          * evenly by 16. It's time for ciphertext stealing. */\r
1246         size_t i;\r
1247         unsigned char *prev_output = output - 16;\r
1248 \r
1249         /* Copy ciphertext bytes from the previous block to our output for each\r
1250          * byte of cyphertext we won't steal. At the same time, copy the\r
1251          * remainder of the input for this final round (since the loop bounds\r
1252          * are the same). */\r
1253         for( i = 0; i < leftover; i++ )\r
1254         {\r
1255             output[i] = prev_output[i];\r
1256             tmp[i] = input[i] ^ t[i];\r
1257         }\r
1258 \r
1259         /* Copy ciphertext bytes from the previous block for input in this\r
1260          * round. */\r
1261         for( ; i < 16; i++ )\r
1262             tmp[i] = prev_output[i] ^ t[i];\r
1263 \r
1264         ret = mbedtls_aes_crypt_ecb( &ctx->crypt, mode, tmp, tmp );\r
1265         if( ret != 0 )\r
1266             return ret;\r
1267 \r
1268         /* Write the result back to the previous block, overriding the previous\r
1269          * output we copied. */\r
1270         for( i = 0; i < 16; i++ )\r
1271             prev_output[i] = tmp[i] ^ t[i];\r
1272     }\r
1273 \r
1274     return( 0 );\r
1275 }\r
1276 #endif /* MBEDTLS_CIPHER_MODE_XTS */\r
1277 \r
1278 #if defined(MBEDTLS_CIPHER_MODE_CFB)\r
1279 /*\r
1280  * AES-CFB128 buffer encryption/decryption\r
1281  */\r
1282 int mbedtls_aes_crypt_cfb128( mbedtls_aes_context *ctx,\r
1283                        int mode,\r
1284                        size_t length,\r
1285                        size_t *iv_off,\r
1286                        unsigned char iv[16],\r
1287                        const unsigned char *input,\r
1288                        unsigned char *output )\r
1289 {\r
1290     int c;\r
1291     size_t n;\r
1292 \r
1293     AES_VALIDATE_RET( ctx != NULL );\r
1294     AES_VALIDATE_RET( mode == MBEDTLS_AES_ENCRYPT ||\r
1295                       mode == MBEDTLS_AES_DECRYPT );\r
1296     AES_VALIDATE_RET( iv_off != NULL );\r
1297     AES_VALIDATE_RET( iv != NULL );\r
1298     AES_VALIDATE_RET( input != NULL );\r
1299     AES_VALIDATE_RET( output != NULL );\r
1300 \r
1301     n = *iv_off;\r
1302 \r
1303     if( n > 15 )\r
1304         return( MBEDTLS_ERR_AES_BAD_INPUT_DATA );\r
1305 \r
1306     if( mode == MBEDTLS_AES_DECRYPT )\r
1307     {\r
1308         while( length-- )\r
1309         {\r
1310             if( n == 0 )\r
1311                 mbedtls_aes_crypt_ecb( ctx, MBEDTLS_AES_ENCRYPT, iv, iv );\r
1312 \r
1313             c = *input++;\r
1314             *output++ = (unsigned char)( c ^ iv[n] );\r
1315             iv[n] = (unsigned char) c;\r
1316 \r
1317             n = ( n + 1 ) & 0x0F;\r
1318         }\r
1319     }\r
1320     else\r
1321     {\r
1322         while( length-- )\r
1323         {\r
1324             if( n == 0 )\r
1325                 mbedtls_aes_crypt_ecb( ctx, MBEDTLS_AES_ENCRYPT, iv, iv );\r
1326 \r
1327             iv[n] = *output++ = (unsigned char)( iv[n] ^ *input++ );\r
1328 \r
1329             n = ( n + 1 ) & 0x0F;\r
1330         }\r
1331     }\r
1332 \r
1333     *iv_off = n;\r
1334 \r
1335     return( 0 );\r
1336 }\r
1337 \r
1338 /*\r
1339  * AES-CFB8 buffer encryption/decryption\r
1340  */\r
1341 int mbedtls_aes_crypt_cfb8( mbedtls_aes_context *ctx,\r
1342                             int mode,\r
1343                             size_t length,\r
1344                             unsigned char iv[16],\r
1345                             const unsigned char *input,\r
1346                             unsigned char *output )\r
1347 {\r
1348     unsigned char c;\r
1349     unsigned char ov[17];\r
1350 \r
1351     AES_VALIDATE_RET( ctx != NULL );\r
1352     AES_VALIDATE_RET( mode == MBEDTLS_AES_ENCRYPT ||\r
1353                       mode == MBEDTLS_AES_DECRYPT );\r
1354     AES_VALIDATE_RET( iv != NULL );\r
1355     AES_VALIDATE_RET( input != NULL );\r
1356     AES_VALIDATE_RET( output != NULL );\r
1357     while( length-- )\r
1358     {\r
1359         memcpy( ov, iv, 16 );\r
1360         mbedtls_aes_crypt_ecb( ctx, MBEDTLS_AES_ENCRYPT, iv, iv );\r
1361 \r
1362         if( mode == MBEDTLS_AES_DECRYPT )\r
1363             ov[16] = *input;\r
1364 \r
1365         c = *output++ = (unsigned char)( iv[0] ^ *input++ );\r
1366 \r
1367         if( mode == MBEDTLS_AES_ENCRYPT )\r
1368             ov[16] = c;\r
1369 \r
1370         memcpy( iv, ov + 1, 16 );\r
1371     }\r
1372 \r
1373     return( 0 );\r
1374 }\r
1375 #endif /* MBEDTLS_CIPHER_MODE_CFB */\r
1376 \r
1377 #if defined(MBEDTLS_CIPHER_MODE_OFB)\r
1378 /*\r
1379  * AES-OFB (Output Feedback Mode) buffer encryption/decryption\r
1380  */\r
1381 int mbedtls_aes_crypt_ofb( mbedtls_aes_context *ctx,\r
1382                            size_t length,\r
1383                            size_t *iv_off,\r
1384                            unsigned char iv[16],\r
1385                            const unsigned char *input,\r
1386                            unsigned char *output )\r
1387 {\r
1388     int ret = 0;\r
1389     size_t n;\r
1390 \r
1391     AES_VALIDATE_RET( ctx != NULL );\r
1392     AES_VALIDATE_RET( iv_off != NULL );\r
1393     AES_VALIDATE_RET( iv != NULL );\r
1394     AES_VALIDATE_RET( input != NULL );\r
1395     AES_VALIDATE_RET( output != NULL );\r
1396 \r
1397     n = *iv_off;\r
1398 \r
1399     if( n > 15 )\r
1400         return( MBEDTLS_ERR_AES_BAD_INPUT_DATA );\r
1401 \r
1402     while( length-- )\r
1403     {\r
1404         if( n == 0 )\r
1405         {\r
1406             ret = mbedtls_aes_crypt_ecb( ctx, MBEDTLS_AES_ENCRYPT, iv, iv );\r
1407             if( ret != 0 )\r
1408                 goto exit;\r
1409         }\r
1410         *output++ =  *input++ ^ iv[n];\r
1411 \r
1412         n = ( n + 1 ) & 0x0F;\r
1413     }\r
1414 \r
1415     *iv_off = n;\r
1416 \r
1417 exit:\r
1418     return( ret );\r
1419 }\r
1420 #endif /* MBEDTLS_CIPHER_MODE_OFB */\r
1421 \r
1422 #if defined(MBEDTLS_CIPHER_MODE_CTR)\r
1423 /*\r
1424  * AES-CTR buffer encryption/decryption\r
1425  */\r
1426 int mbedtls_aes_crypt_ctr( mbedtls_aes_context *ctx,\r
1427                        size_t length,\r
1428                        size_t *nc_off,\r
1429                        unsigned char nonce_counter[16],\r
1430                        unsigned char stream_block[16],\r
1431                        const unsigned char *input,\r
1432                        unsigned char *output )\r
1433 {\r
1434     int c, i;\r
1435     size_t n;\r
1436 \r
1437     AES_VALIDATE_RET( ctx != NULL );\r
1438     AES_VALIDATE_RET( nc_off != NULL );\r
1439     AES_VALIDATE_RET( nonce_counter != NULL );\r
1440     AES_VALIDATE_RET( stream_block != NULL );\r
1441     AES_VALIDATE_RET( input != NULL );\r
1442     AES_VALIDATE_RET( output != NULL );\r
1443 \r
1444     n = *nc_off;\r
1445 \r
1446     if ( n > 0x0F )\r
1447         return( MBEDTLS_ERR_AES_BAD_INPUT_DATA );\r
1448 \r
1449     while( length-- )\r
1450     {\r
1451         if( n == 0 ) {\r
1452             mbedtls_aes_crypt_ecb( ctx, MBEDTLS_AES_ENCRYPT, nonce_counter, stream_block );\r
1453 \r
1454             for( i = 16; i > 0; i-- )\r
1455                 if( ++nonce_counter[i - 1] != 0 )\r
1456                     break;\r
1457         }\r
1458         c = *input++;\r
1459         *output++ = (unsigned char)( c ^ stream_block[n] );\r
1460 \r
1461         n = ( n + 1 ) & 0x0F;\r
1462     }\r
1463 \r
1464     *nc_off = n;\r
1465 \r
1466     return( 0 );\r
1467 }\r
1468 #endif /* MBEDTLS_CIPHER_MODE_CTR */\r
1469 \r
1470 #endif /* !MBEDTLS_AES_ALT */\r
1471 \r
1472 #if defined(MBEDTLS_SELF_TEST)\r
1473 /*\r
1474  * AES test vectors from:\r
1475  *\r
1476  * http://csrc.nist.gov/archive/aes/rijndael/rijndael-vals.zip\r
1477  */\r
1478 static const unsigned char aes_test_ecb_dec[3][16] =\r
1479 {\r
1480     { 0x44, 0x41, 0x6A, 0xC2, 0xD1, 0xF5, 0x3C, 0x58,\r
1481       0x33, 0x03, 0x91, 0x7E, 0x6B, 0xE9, 0xEB, 0xE0 },\r
1482     { 0x48, 0xE3, 0x1E, 0x9E, 0x25, 0x67, 0x18, 0xF2,\r
1483       0x92, 0x29, 0x31, 0x9C, 0x19, 0xF1, 0x5B, 0xA4 },\r
1484     { 0x05, 0x8C, 0xCF, 0xFD, 0xBB, 0xCB, 0x38, 0x2D,\r
1485       0x1F, 0x6F, 0x56, 0x58, 0x5D, 0x8A, 0x4A, 0xDE }\r
1486 };\r
1487 \r
1488 static const unsigned char aes_test_ecb_enc[3][16] =\r
1489 {\r
1490     { 0xC3, 0x4C, 0x05, 0x2C, 0xC0, 0xDA, 0x8D, 0x73,\r
1491       0x45, 0x1A, 0xFE, 0x5F, 0x03, 0xBE, 0x29, 0x7F },\r
1492     { 0xF3, 0xF6, 0x75, 0x2A, 0xE8, 0xD7, 0x83, 0x11,\r
1493       0x38, 0xF0, 0x41, 0x56, 0x06, 0x31, 0xB1, 0x14 },\r
1494     { 0x8B, 0x79, 0xEE, 0xCC, 0x93, 0xA0, 0xEE, 0x5D,\r
1495       0xFF, 0x30, 0xB4, 0xEA, 0x21, 0x63, 0x6D, 0xA4 }\r
1496 };\r
1497 \r
1498 #if defined(MBEDTLS_CIPHER_MODE_CBC)\r
1499 static const unsigned char aes_test_cbc_dec[3][16] =\r
1500 {\r
1501     { 0xFA, 0xCA, 0x37, 0xE0, 0xB0, 0xC8, 0x53, 0x73,\r
1502       0xDF, 0x70, 0x6E, 0x73, 0xF7, 0xC9, 0xAF, 0x86 },\r
1503     { 0x5D, 0xF6, 0x78, 0xDD, 0x17, 0xBA, 0x4E, 0x75,\r
1504       0xB6, 0x17, 0x68, 0xC6, 0xAD, 0xEF, 0x7C, 0x7B },\r
1505     { 0x48, 0x04, 0xE1, 0x81, 0x8F, 0xE6, 0x29, 0x75,\r
1506       0x19, 0xA3, 0xE8, 0x8C, 0x57, 0x31, 0x04, 0x13 }\r
1507 };\r
1508 \r
1509 static const unsigned char aes_test_cbc_enc[3][16] =\r
1510 {\r
1511     { 0x8A, 0x05, 0xFC, 0x5E, 0x09, 0x5A, 0xF4, 0x84,\r
1512       0x8A, 0x08, 0xD3, 0x28, 0xD3, 0x68, 0x8E, 0x3D },\r
1513     { 0x7B, 0xD9, 0x66, 0xD5, 0x3A, 0xD8, 0xC1, 0xBB,\r
1514       0x85, 0xD2, 0xAD, 0xFA, 0xE8, 0x7B, 0xB1, 0x04 },\r
1515     { 0xFE, 0x3C, 0x53, 0x65, 0x3E, 0x2F, 0x45, 0xB5,\r
1516       0x6F, 0xCD, 0x88, 0xB2, 0xCC, 0x89, 0x8F, 0xF0 }\r
1517 };\r
1518 #endif /* MBEDTLS_CIPHER_MODE_CBC */\r
1519 \r
1520 #if defined(MBEDTLS_CIPHER_MODE_CFB)\r
1521 /*\r
1522  * AES-CFB128 test vectors from:\r
1523  *\r
1524  * http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf\r
1525  */\r
1526 static const unsigned char aes_test_cfb128_key[3][32] =\r
1527 {\r
1528     { 0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6,\r
1529       0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C },\r
1530     { 0x8E, 0x73, 0xB0, 0xF7, 0xDA, 0x0E, 0x64, 0x52,\r
1531       0xC8, 0x10, 0xF3, 0x2B, 0x80, 0x90, 0x79, 0xE5,\r
1532       0x62, 0xF8, 0xEA, 0xD2, 0x52, 0x2C, 0x6B, 0x7B },\r
1533     { 0x60, 0x3D, 0xEB, 0x10, 0x15, 0xCA, 0x71, 0xBE,\r
1534       0x2B, 0x73, 0xAE, 0xF0, 0x85, 0x7D, 0x77, 0x81,\r
1535       0x1F, 0x35, 0x2C, 0x07, 0x3B, 0x61, 0x08, 0xD7,\r
1536       0x2D, 0x98, 0x10, 0xA3, 0x09, 0x14, 0xDF, 0xF4 }\r
1537 };\r
1538 \r
1539 static const unsigned char aes_test_cfb128_iv[16] =\r
1540 {\r
1541     0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,\r
1542     0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F\r
1543 };\r
1544 \r
1545 static const unsigned char aes_test_cfb128_pt[64] =\r
1546 {\r
1547     0x6B, 0xC1, 0xBE, 0xE2, 0x2E, 0x40, 0x9F, 0x96,\r
1548     0xE9, 0x3D, 0x7E, 0x11, 0x73, 0x93, 0x17, 0x2A,\r
1549     0xAE, 0x2D, 0x8A, 0x57, 0x1E, 0x03, 0xAC, 0x9C,\r
1550     0x9E, 0xB7, 0x6F, 0xAC, 0x45, 0xAF, 0x8E, 0x51,\r
1551     0x30, 0xC8, 0x1C, 0x46, 0xA3, 0x5C, 0xE4, 0x11,\r
1552     0xE5, 0xFB, 0xC1, 0x19, 0x1A, 0x0A, 0x52, 0xEF,\r
1553     0xF6, 0x9F, 0x24, 0x45, 0xDF, 0x4F, 0x9B, 0x17,\r
1554     0xAD, 0x2B, 0x41, 0x7B, 0xE6, 0x6C, 0x37, 0x10\r
1555 };\r
1556 \r
1557 static const unsigned char aes_test_cfb128_ct[3][64] =\r
1558 {\r
1559     { 0x3B, 0x3F, 0xD9, 0x2E, 0xB7, 0x2D, 0xAD, 0x20,\r
1560       0x33, 0x34, 0x49, 0xF8, 0xE8, 0x3C, 0xFB, 0x4A,\r
1561       0xC8, 0xA6, 0x45, 0x37, 0xA0, 0xB3, 0xA9, 0x3F,\r
1562       0xCD, 0xE3, 0xCD, 0xAD, 0x9F, 0x1C, 0xE5, 0x8B,\r
1563       0x26, 0x75, 0x1F, 0x67, 0xA3, 0xCB, 0xB1, 0x40,\r
1564       0xB1, 0x80, 0x8C, 0xF1, 0x87, 0xA4, 0xF4, 0xDF,\r
1565       0xC0, 0x4B, 0x05, 0x35, 0x7C, 0x5D, 0x1C, 0x0E,\r
1566       0xEA, 0xC4, 0xC6, 0x6F, 0x9F, 0xF7, 0xF2, 0xE6 },\r
1567     { 0xCD, 0xC8, 0x0D, 0x6F, 0xDD, 0xF1, 0x8C, 0xAB,\r
1568       0x34, 0xC2, 0x59, 0x09, 0xC9, 0x9A, 0x41, 0x74,\r
1569       0x67, 0xCE, 0x7F, 0x7F, 0x81, 0x17, 0x36, 0x21,\r
1570       0x96, 0x1A, 0x2B, 0x70, 0x17, 0x1D, 0x3D, 0x7A,\r
1571       0x2E, 0x1E, 0x8A, 0x1D, 0xD5, 0x9B, 0x88, 0xB1,\r
1572       0xC8, 0xE6, 0x0F, 0xED, 0x1E, 0xFA, 0xC4, 0xC9,\r
1573       0xC0, 0x5F, 0x9F, 0x9C, 0xA9, 0x83, 0x4F, 0xA0,\r
1574       0x42, 0xAE, 0x8F, 0xBA, 0x58, 0x4B, 0x09, 0xFF },\r
1575     { 0xDC, 0x7E, 0x84, 0xBF, 0xDA, 0x79, 0x16, 0x4B,\r
1576       0x7E, 0xCD, 0x84, 0x86, 0x98, 0x5D, 0x38, 0x60,\r
1577       0x39, 0xFF, 0xED, 0x14, 0x3B, 0x28, 0xB1, 0xC8,\r
1578       0x32, 0x11, 0x3C, 0x63, 0x31, 0xE5, 0x40, 0x7B,\r
1579       0xDF, 0x10, 0x13, 0x24, 0x15, 0xE5, 0x4B, 0x92,\r
1580       0xA1, 0x3E, 0xD0, 0xA8, 0x26, 0x7A, 0xE2, 0xF9,\r
1581       0x75, 0xA3, 0x85, 0x74, 0x1A, 0xB9, 0xCE, 0xF8,\r
1582       0x20, 0x31, 0x62, 0x3D, 0x55, 0xB1, 0xE4, 0x71 }\r
1583 };\r
1584 #endif /* MBEDTLS_CIPHER_MODE_CFB */\r
1585 \r
1586 #if defined(MBEDTLS_CIPHER_MODE_OFB)\r
1587 /*\r
1588  * AES-OFB test vectors from:\r
1589  *\r
1590  * https://csrc.nist.gov/publications/detail/sp/800-38a/final\r
1591  */\r
1592 static const unsigned char aes_test_ofb_key[3][32] =\r
1593 {\r
1594     { 0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6,\r
1595       0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C },\r
1596     { 0x8E, 0x73, 0xB0, 0xF7, 0xDA, 0x0E, 0x64, 0x52,\r
1597       0xC8, 0x10, 0xF3, 0x2B, 0x80, 0x90, 0x79, 0xE5,\r
1598       0x62, 0xF8, 0xEA, 0xD2, 0x52, 0x2C, 0x6B, 0x7B },\r
1599     { 0x60, 0x3D, 0xEB, 0x10, 0x15, 0xCA, 0x71, 0xBE,\r
1600       0x2B, 0x73, 0xAE, 0xF0, 0x85, 0x7D, 0x77, 0x81,\r
1601       0x1F, 0x35, 0x2C, 0x07, 0x3B, 0x61, 0x08, 0xD7,\r
1602       0x2D, 0x98, 0x10, 0xA3, 0x09, 0x14, 0xDF, 0xF4 }\r
1603 };\r
1604 \r
1605 static const unsigned char aes_test_ofb_iv[16] =\r
1606 {\r
1607     0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,\r
1608     0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F\r
1609 };\r
1610 \r
1611 static const unsigned char aes_test_ofb_pt[64] =\r
1612 {\r
1613     0x6B, 0xC1, 0xBE, 0xE2, 0x2E, 0x40, 0x9F, 0x96,\r
1614     0xE9, 0x3D, 0x7E, 0x11, 0x73, 0x93, 0x17, 0x2A,\r
1615     0xAE, 0x2D, 0x8A, 0x57, 0x1E, 0x03, 0xAC, 0x9C,\r
1616     0x9E, 0xB7, 0x6F, 0xAC, 0x45, 0xAF, 0x8E, 0x51,\r
1617     0x30, 0xC8, 0x1C, 0x46, 0xA3, 0x5C, 0xE4, 0x11,\r
1618     0xE5, 0xFB, 0xC1, 0x19, 0x1A, 0x0A, 0x52, 0xEF,\r
1619     0xF6, 0x9F, 0x24, 0x45, 0xDF, 0x4F, 0x9B, 0x17,\r
1620     0xAD, 0x2B, 0x41, 0x7B, 0xE6, 0x6C, 0x37, 0x10\r
1621 };\r
1622 \r
1623 static const unsigned char aes_test_ofb_ct[3][64] =\r
1624 {\r
1625     { 0x3B, 0x3F, 0xD9, 0x2E, 0xB7, 0x2D, 0xAD, 0x20,\r
1626       0x33, 0x34, 0x49, 0xF8, 0xE8, 0x3C, 0xFB, 0x4A,\r
1627       0x77, 0x89, 0x50, 0x8d, 0x16, 0x91, 0x8f, 0x03,\r
1628       0xf5, 0x3c, 0x52, 0xda, 0xc5, 0x4e, 0xd8, 0x25,\r
1629       0x97, 0x40, 0x05, 0x1e, 0x9c, 0x5f, 0xec, 0xf6,\r
1630       0x43, 0x44, 0xf7, 0xa8, 0x22, 0x60, 0xed, 0xcc,\r
1631       0x30, 0x4c, 0x65, 0x28, 0xf6, 0x59, 0xc7, 0x78,\r
1632       0x66, 0xa5, 0x10, 0xd9, 0xc1, 0xd6, 0xae, 0x5e },\r
1633     { 0xCD, 0xC8, 0x0D, 0x6F, 0xDD, 0xF1, 0x8C, 0xAB,\r
1634       0x34, 0xC2, 0x59, 0x09, 0xC9, 0x9A, 0x41, 0x74,\r
1635       0xfc, 0xc2, 0x8b, 0x8d, 0x4c, 0x63, 0x83, 0x7c,\r
1636       0x09, 0xe8, 0x17, 0x00, 0xc1, 0x10, 0x04, 0x01,\r
1637       0x8d, 0x9a, 0x9a, 0xea, 0xc0, 0xf6, 0x59, 0x6f,\r
1638       0x55, 0x9c, 0x6d, 0x4d, 0xaf, 0x59, 0xa5, 0xf2,\r
1639       0x6d, 0x9f, 0x20, 0x08, 0x57, 0xca, 0x6c, 0x3e,\r
1640       0x9c, 0xac, 0x52, 0x4b, 0xd9, 0xac, 0xc9, 0x2a },\r
1641     { 0xDC, 0x7E, 0x84, 0xBF, 0xDA, 0x79, 0x16, 0x4B,\r
1642       0x7E, 0xCD, 0x84, 0x86, 0x98, 0x5D, 0x38, 0x60,\r
1643       0x4f, 0xeb, 0xdc, 0x67, 0x40, 0xd2, 0x0b, 0x3a,\r
1644       0xc8, 0x8f, 0x6a, 0xd8, 0x2a, 0x4f, 0xb0, 0x8d,\r
1645       0x71, 0xab, 0x47, 0xa0, 0x86, 0xe8, 0x6e, 0xed,\r
1646       0xf3, 0x9d, 0x1c, 0x5b, 0xba, 0x97, 0xc4, 0x08,\r
1647       0x01, 0x26, 0x14, 0x1d, 0x67, 0xf3, 0x7b, 0xe8,\r
1648       0x53, 0x8f, 0x5a, 0x8b, 0xe7, 0x40, 0xe4, 0x84 }\r
1649 };\r
1650 #endif /* MBEDTLS_CIPHER_MODE_OFB */\r
1651 \r
1652 #if defined(MBEDTLS_CIPHER_MODE_CTR)\r
1653 /*\r
1654  * AES-CTR test vectors from:\r
1655  *\r
1656  * http://www.faqs.org/rfcs/rfc3686.html\r
1657  */\r
1658 \r
1659 static const unsigned char aes_test_ctr_key[3][16] =\r
1660 {\r
1661     { 0xAE, 0x68, 0x52, 0xF8, 0x12, 0x10, 0x67, 0xCC,\r
1662       0x4B, 0xF7, 0xA5, 0x76, 0x55, 0x77, 0xF3, 0x9E },\r
1663     { 0x7E, 0x24, 0x06, 0x78, 0x17, 0xFA, 0xE0, 0xD7,\r
1664       0x43, 0xD6, 0xCE, 0x1F, 0x32, 0x53, 0x91, 0x63 },\r
1665     { 0x76, 0x91, 0xBE, 0x03, 0x5E, 0x50, 0x20, 0xA8,\r
1666       0xAC, 0x6E, 0x61, 0x85, 0x29, 0xF9, 0xA0, 0xDC }\r
1667 };\r
1668 \r
1669 static const unsigned char aes_test_ctr_nonce_counter[3][16] =\r
1670 {\r
1671     { 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00,\r
1672       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 },\r
1673     { 0x00, 0x6C, 0xB6, 0xDB, 0xC0, 0x54, 0x3B, 0x59,\r
1674       0xDA, 0x48, 0xD9, 0x0B, 0x00, 0x00, 0x00, 0x01 },\r
1675     { 0x00, 0xE0, 0x01, 0x7B, 0x27, 0x77, 0x7F, 0x3F,\r
1676       0x4A, 0x17, 0x86, 0xF0, 0x00, 0x00, 0x00, 0x01 }\r
1677 };\r
1678 \r
1679 static const unsigned char aes_test_ctr_pt[3][48] =\r
1680 {\r
1681     { 0x53, 0x69, 0x6E, 0x67, 0x6C, 0x65, 0x20, 0x62,\r
1682       0x6C, 0x6F, 0x63, 0x6B, 0x20, 0x6D, 0x73, 0x67 },\r
1683 \r
1684     { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,\r
1685       0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,\r
1686       0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,\r
1687       0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F },\r
1688 \r
1689     { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,\r
1690       0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,\r
1691       0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,\r
1692       0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,\r
1693       0x20, 0x21, 0x22, 0x23 }\r
1694 };\r
1695 \r
1696 static const unsigned char aes_test_ctr_ct[3][48] =\r
1697 {\r
1698     { 0xE4, 0x09, 0x5D, 0x4F, 0xB7, 0xA7, 0xB3, 0x79,\r
1699       0x2D, 0x61, 0x75, 0xA3, 0x26, 0x13, 0x11, 0xB8 },\r
1700     { 0x51, 0x04, 0xA1, 0x06, 0x16, 0x8A, 0x72, 0xD9,\r
1701       0x79, 0x0D, 0x41, 0xEE, 0x8E, 0xDA, 0xD3, 0x88,\r
1702       0xEB, 0x2E, 0x1E, 0xFC, 0x46, 0xDA, 0x57, 0xC8,\r
1703       0xFC, 0xE6, 0x30, 0xDF, 0x91, 0x41, 0xBE, 0x28 },\r
1704     { 0xC1, 0xCF, 0x48, 0xA8, 0x9F, 0x2F, 0xFD, 0xD9,\r
1705       0xCF, 0x46, 0x52, 0xE9, 0xEF, 0xDB, 0x72, 0xD7,\r
1706       0x45, 0x40, 0xA4, 0x2B, 0xDE, 0x6D, 0x78, 0x36,\r
1707       0xD5, 0x9A, 0x5C, 0xEA, 0xAE, 0xF3, 0x10, 0x53,\r
1708       0x25, 0xB2, 0x07, 0x2F }\r
1709 };\r
1710 \r
1711 static const int aes_test_ctr_len[3] =\r
1712     { 16, 32, 36 };\r
1713 #endif /* MBEDTLS_CIPHER_MODE_CTR */\r
1714 \r
1715 #if defined(MBEDTLS_CIPHER_MODE_XTS)\r
1716 /*\r
1717  * AES-XTS test vectors from:\r
1718  *\r
1719  * IEEE P1619/D16 Annex B\r
1720  * https://web.archive.org/web/20150629024421/http://grouper.ieee.org/groups/1619/email/pdf00086.pdf\r
1721  * (Archived from original at http://grouper.ieee.org/groups/1619/email/pdf00086.pdf)\r
1722  */\r
1723 static const unsigned char aes_test_xts_key[][32] =\r
1724 {\r
1725     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\r
1726       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\r
1727       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\r
1728       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },\r
1729     { 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,\r
1730       0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,\r
1731       0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,\r
1732       0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22 },\r
1733     { 0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8,\r
1734       0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1, 0xf0,\r
1735       0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,\r
1736       0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22 },\r
1737 };\r
1738 \r
1739 static const unsigned char aes_test_xts_pt32[][32] =\r
1740 {\r
1741     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\r
1742       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\r
1743       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\r
1744       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },\r
1745     { 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,\r
1746       0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,\r
1747       0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,\r
1748       0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44 },\r
1749     { 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,\r
1750       0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,\r
1751       0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,\r
1752       0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44 },\r
1753 };\r
1754 \r
1755 static const unsigned char aes_test_xts_ct32[][32] =\r
1756 {\r
1757     { 0x91, 0x7c, 0xf6, 0x9e, 0xbd, 0x68, 0xb2, 0xec,\r
1758       0x9b, 0x9f, 0xe9, 0xa3, 0xea, 0xdd, 0xa6, 0x92,\r
1759       0xcd, 0x43, 0xd2, 0xf5, 0x95, 0x98, 0xed, 0x85,\r
1760       0x8c, 0x02, 0xc2, 0x65, 0x2f, 0xbf, 0x92, 0x2e },\r
1761     { 0xc4, 0x54, 0x18, 0x5e, 0x6a, 0x16, 0x93, 0x6e,\r
1762       0x39, 0x33, 0x40, 0x38, 0xac, 0xef, 0x83, 0x8b,\r
1763       0xfb, 0x18, 0x6f, 0xff, 0x74, 0x80, 0xad, 0xc4,\r
1764       0x28, 0x93, 0x82, 0xec, 0xd6, 0xd3, 0x94, 0xf0 },\r
1765     { 0xaf, 0x85, 0x33, 0x6b, 0x59, 0x7a, 0xfc, 0x1a,\r
1766       0x90, 0x0b, 0x2e, 0xb2, 0x1e, 0xc9, 0x49, 0xd2,\r
1767       0x92, 0xdf, 0x4c, 0x04, 0x7e, 0x0b, 0x21, 0x53,\r
1768       0x21, 0x86, 0xa5, 0x97, 0x1a, 0x22, 0x7a, 0x89 },\r
1769 };\r
1770 \r
1771 static const unsigned char aes_test_xts_data_unit[][16] =\r
1772 {\r
1773    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\r
1774      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },\r
1775    { 0x33, 0x33, 0x33, 0x33, 0x33, 0x00, 0x00, 0x00,\r
1776      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },\r
1777    { 0x33, 0x33, 0x33, 0x33, 0x33, 0x00, 0x00, 0x00,\r
1778      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },\r
1779 };\r
1780 \r
1781 #endif /* MBEDTLS_CIPHER_MODE_XTS */\r
1782 \r
1783 /*\r
1784  * Checkup routine\r
1785  */\r
1786 int mbedtls_aes_self_test( int verbose )\r
1787 {\r
1788     int ret = 0, i, j, u, mode;\r
1789     unsigned int keybits;\r
1790     unsigned char key[32];\r
1791     unsigned char buf[64];\r
1792     const unsigned char *aes_tests;\r
1793 #if defined(MBEDTLS_CIPHER_MODE_CBC) || defined(MBEDTLS_CIPHER_MODE_CFB)\r
1794     unsigned char iv[16];\r
1795 #endif\r
1796 #if defined(MBEDTLS_CIPHER_MODE_CBC)\r
1797     unsigned char prv[16];\r
1798 #endif\r
1799 #if defined(MBEDTLS_CIPHER_MODE_CTR) || defined(MBEDTLS_CIPHER_MODE_CFB) || \\r
1800     defined(MBEDTLS_CIPHER_MODE_OFB)\r
1801     size_t offset;\r
1802 #endif\r
1803 #if defined(MBEDTLS_CIPHER_MODE_CTR) || defined(MBEDTLS_CIPHER_MODE_XTS)\r
1804     int len;\r
1805 #endif\r
1806 #if defined(MBEDTLS_CIPHER_MODE_CTR)\r
1807     unsigned char nonce_counter[16];\r
1808     unsigned char stream_block[16];\r
1809 #endif\r
1810     mbedtls_aes_context ctx;\r
1811 \r
1812     memset( key, 0, 32 );\r
1813     mbedtls_aes_init( &ctx );\r
1814 \r
1815     /*\r
1816      * ECB mode\r
1817      */\r
1818     for( i = 0; i < 6; i++ )\r
1819     {\r
1820         u = i >> 1;\r
1821         keybits = 128 + u * 64;\r
1822         mode = i & 1;\r
1823 \r
1824         if( verbose != 0 )\r
1825             mbedtls_printf( "  AES-ECB-%3d (%s): ", keybits,\r
1826                             ( mode == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );\r
1827 \r
1828         memset( buf, 0, 16 );\r
1829 \r
1830         if( mode == MBEDTLS_AES_DECRYPT )\r
1831         {\r
1832             ret = mbedtls_aes_setkey_dec( &ctx, key, keybits );\r
1833             aes_tests = aes_test_ecb_dec[u];\r
1834         }\r
1835         else\r
1836         {\r
1837             ret = mbedtls_aes_setkey_enc( &ctx, key, keybits );\r
1838             aes_tests = aes_test_ecb_enc[u];\r
1839         }\r
1840 \r
1841         /*\r
1842          * AES-192 is an optional feature that may be unavailable when\r
1843          * there is an alternative underlying implementation i.e. when\r
1844          * MBEDTLS_AES_ALT is defined.\r
1845          */\r
1846         if( ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED && keybits == 192 )\r
1847         {\r
1848             mbedtls_printf( "skipped\n" );\r
1849             continue;\r
1850         }\r
1851         else if( ret != 0 )\r
1852         {\r
1853             goto exit;\r
1854         }\r
1855 \r
1856         for( j = 0; j < 10000; j++ )\r
1857         {\r
1858             ret = mbedtls_aes_crypt_ecb( &ctx, mode, buf, buf );\r
1859             if( ret != 0 )\r
1860                 goto exit;\r
1861         }\r
1862 \r
1863         if( memcmp( buf, aes_tests, 16 ) != 0 )\r
1864         {\r
1865             ret = 1;\r
1866             goto exit;\r
1867         }\r
1868 \r
1869         if( verbose != 0 )\r
1870             mbedtls_printf( "passed\n" );\r
1871     }\r
1872 \r
1873     if( verbose != 0 )\r
1874         mbedtls_printf( "\n" );\r
1875 \r
1876 #if defined(MBEDTLS_CIPHER_MODE_CBC)\r
1877     /*\r
1878      * CBC mode\r
1879      */\r
1880     for( i = 0; i < 6; i++ )\r
1881     {\r
1882         u = i >> 1;\r
1883         keybits = 128 + u * 64;\r
1884         mode = i & 1;\r
1885 \r
1886         if( verbose != 0 )\r
1887             mbedtls_printf( "  AES-CBC-%3d (%s): ", keybits,\r
1888                             ( mode == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );\r
1889 \r
1890         memset( iv , 0, 16 );\r
1891         memset( prv, 0, 16 );\r
1892         memset( buf, 0, 16 );\r
1893 \r
1894         if( mode == MBEDTLS_AES_DECRYPT )\r
1895         {\r
1896             ret = mbedtls_aes_setkey_dec( &ctx, key, keybits );\r
1897             aes_tests = aes_test_cbc_dec[u];\r
1898         }\r
1899         else\r
1900         {\r
1901             ret = mbedtls_aes_setkey_enc( &ctx, key, keybits );\r
1902             aes_tests = aes_test_cbc_enc[u];\r
1903         }\r
1904 \r
1905         /*\r
1906          * AES-192 is an optional feature that may be unavailable when\r
1907          * there is an alternative underlying implementation i.e. when\r
1908          * MBEDTLS_AES_ALT is defined.\r
1909          */\r
1910         if( ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED && keybits == 192 )\r
1911         {\r
1912             mbedtls_printf( "skipped\n" );\r
1913             continue;\r
1914         }\r
1915         else if( ret != 0 )\r
1916         {\r
1917             goto exit;\r
1918         }\r
1919 \r
1920         for( j = 0; j < 10000; j++ )\r
1921         {\r
1922             if( mode == MBEDTLS_AES_ENCRYPT )\r
1923             {\r
1924                 unsigned char tmp[16];\r
1925 \r
1926                 memcpy( tmp, prv, 16 );\r
1927                 memcpy( prv, buf, 16 );\r
1928                 memcpy( buf, tmp, 16 );\r
1929             }\r
1930 \r
1931             ret = mbedtls_aes_crypt_cbc( &ctx, mode, 16, iv, buf, buf );\r
1932             if( ret != 0 )\r
1933                 goto exit;\r
1934 \r
1935         }\r
1936 \r
1937         if( memcmp( buf, aes_tests, 16 ) != 0 )\r
1938         {\r
1939             ret = 1;\r
1940             goto exit;\r
1941         }\r
1942 \r
1943         if( verbose != 0 )\r
1944             mbedtls_printf( "passed\n" );\r
1945     }\r
1946 \r
1947     if( verbose != 0 )\r
1948         mbedtls_printf( "\n" );\r
1949 #endif /* MBEDTLS_CIPHER_MODE_CBC */\r
1950 \r
1951 #if defined(MBEDTLS_CIPHER_MODE_CFB)\r
1952     /*\r
1953      * CFB128 mode\r
1954      */\r
1955     for( i = 0; i < 6; i++ )\r
1956     {\r
1957         u = i >> 1;\r
1958         keybits = 128 + u * 64;\r
1959         mode = i & 1;\r
1960 \r
1961         if( verbose != 0 )\r
1962             mbedtls_printf( "  AES-CFB128-%3d (%s): ", keybits,\r
1963                             ( mode == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );\r
1964 \r
1965         memcpy( iv,  aes_test_cfb128_iv, 16 );\r
1966         memcpy( key, aes_test_cfb128_key[u], keybits / 8 );\r
1967 \r
1968         offset = 0;\r
1969         ret = mbedtls_aes_setkey_enc( &ctx, key, keybits );\r
1970         /*\r
1971          * AES-192 is an optional feature that may be unavailable when\r
1972          * there is an alternative underlying implementation i.e. when\r
1973          * MBEDTLS_AES_ALT is defined.\r
1974          */\r
1975         if( ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED && keybits == 192 )\r
1976         {\r
1977             mbedtls_printf( "skipped\n" );\r
1978             continue;\r
1979         }\r
1980         else if( ret != 0 )\r
1981         {\r
1982             goto exit;\r
1983         }\r
1984 \r
1985         if( mode == MBEDTLS_AES_DECRYPT )\r
1986         {\r
1987             memcpy( buf, aes_test_cfb128_ct[u], 64 );\r
1988             aes_tests = aes_test_cfb128_pt;\r
1989         }\r
1990         else\r
1991         {\r
1992             memcpy( buf, aes_test_cfb128_pt, 64 );\r
1993             aes_tests = aes_test_cfb128_ct[u];\r
1994         }\r
1995 \r
1996         ret = mbedtls_aes_crypt_cfb128( &ctx, mode, 64, &offset, iv, buf, buf );\r
1997         if( ret != 0 )\r
1998             goto exit;\r
1999 \r
2000         if( memcmp( buf, aes_tests, 64 ) != 0 )\r
2001         {\r
2002             ret = 1;\r
2003             goto exit;\r
2004         }\r
2005 \r
2006         if( verbose != 0 )\r
2007             mbedtls_printf( "passed\n" );\r
2008     }\r
2009 \r
2010     if( verbose != 0 )\r
2011         mbedtls_printf( "\n" );\r
2012 #endif /* MBEDTLS_CIPHER_MODE_CFB */\r
2013 \r
2014 #if defined(MBEDTLS_CIPHER_MODE_OFB)\r
2015     /*\r
2016      * OFB mode\r
2017      */\r
2018     for( i = 0; i < 6; i++ )\r
2019     {\r
2020         u = i >> 1;\r
2021         keybits = 128 + u * 64;\r
2022         mode = i & 1;\r
2023 \r
2024         if( verbose != 0 )\r
2025             mbedtls_printf( "  AES-OFB-%3d (%s): ", keybits,\r
2026                             ( mode == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );\r
2027 \r
2028         memcpy( iv,  aes_test_ofb_iv, 16 );\r
2029         memcpy( key, aes_test_ofb_key[u], keybits / 8 );\r
2030 \r
2031         offset = 0;\r
2032         ret = mbedtls_aes_setkey_enc( &ctx, key, keybits );\r
2033         /*\r
2034          * AES-192 is an optional feature that may be unavailable when\r
2035          * there is an alternative underlying implementation i.e. when\r
2036          * MBEDTLS_AES_ALT is defined.\r
2037          */\r
2038         if( ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED && keybits == 192 )\r
2039         {\r
2040             mbedtls_printf( "skipped\n" );\r
2041             continue;\r
2042         }\r
2043         else if( ret != 0 )\r
2044         {\r
2045             goto exit;\r
2046         }\r
2047 \r
2048         if( mode == MBEDTLS_AES_DECRYPT )\r
2049         {\r
2050             memcpy( buf, aes_test_ofb_ct[u], 64 );\r
2051             aes_tests = aes_test_ofb_pt;\r
2052         }\r
2053         else\r
2054         {\r
2055             memcpy( buf, aes_test_ofb_pt, 64 );\r
2056             aes_tests = aes_test_ofb_ct[u];\r
2057         }\r
2058 \r
2059         ret = mbedtls_aes_crypt_ofb( &ctx, 64, &offset, iv, buf, buf );\r
2060         if( ret != 0 )\r
2061             goto exit;\r
2062 \r
2063         if( memcmp( buf, aes_tests, 64 ) != 0 )\r
2064         {\r
2065             ret = 1;\r
2066             goto exit;\r
2067         }\r
2068 \r
2069         if( verbose != 0 )\r
2070             mbedtls_printf( "passed\n" );\r
2071     }\r
2072 \r
2073     if( verbose != 0 )\r
2074         mbedtls_printf( "\n" );\r
2075 #endif /* MBEDTLS_CIPHER_MODE_OFB */\r
2076 \r
2077 #if defined(MBEDTLS_CIPHER_MODE_CTR)\r
2078     /*\r
2079      * CTR mode\r
2080      */\r
2081     for( i = 0; i < 6; i++ )\r
2082     {\r
2083         u = i >> 1;\r
2084         mode = i & 1;\r
2085 \r
2086         if( verbose != 0 )\r
2087             mbedtls_printf( "  AES-CTR-128 (%s): ",\r
2088                             ( mode == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );\r
2089 \r
2090         memcpy( nonce_counter, aes_test_ctr_nonce_counter[u], 16 );\r
2091         memcpy( key, aes_test_ctr_key[u], 16 );\r
2092 \r
2093         offset = 0;\r
2094         if( ( ret = mbedtls_aes_setkey_enc( &ctx, key, 128 ) ) != 0 )\r
2095             goto exit;\r
2096 \r
2097         len = aes_test_ctr_len[u];\r
2098 \r
2099         if( mode == MBEDTLS_AES_DECRYPT )\r
2100         {\r
2101             memcpy( buf, aes_test_ctr_ct[u], len );\r
2102             aes_tests = aes_test_ctr_pt[u];\r
2103         }\r
2104         else\r
2105         {\r
2106             memcpy( buf, aes_test_ctr_pt[u], len );\r
2107             aes_tests = aes_test_ctr_ct[u];\r
2108         }\r
2109 \r
2110         ret = mbedtls_aes_crypt_ctr( &ctx, len, &offset, nonce_counter,\r
2111                                      stream_block, buf, buf );\r
2112         if( ret != 0 )\r
2113             goto exit;\r
2114 \r
2115         if( memcmp( buf, aes_tests, len ) != 0 )\r
2116         {\r
2117             ret = 1;\r
2118             goto exit;\r
2119         }\r
2120 \r
2121         if( verbose != 0 )\r
2122             mbedtls_printf( "passed\n" );\r
2123     }\r
2124 \r
2125     if( verbose != 0 )\r
2126         mbedtls_printf( "\n" );\r
2127 #endif /* MBEDTLS_CIPHER_MODE_CTR */\r
2128 \r
2129 #if defined(MBEDTLS_CIPHER_MODE_XTS)\r
2130     {\r
2131     static const int num_tests =\r
2132         sizeof(aes_test_xts_key) / sizeof(*aes_test_xts_key);\r
2133     mbedtls_aes_xts_context ctx_xts;\r
2134 \r
2135     /*\r
2136      * XTS mode\r
2137      */\r
2138     mbedtls_aes_xts_init( &ctx_xts );\r
2139 \r
2140     for( i = 0; i < num_tests << 1; i++ )\r
2141     {\r
2142         const unsigned char *data_unit;\r
2143         u = i >> 1;\r
2144         mode = i & 1;\r
2145 \r
2146         if( verbose != 0 )\r
2147             mbedtls_printf( "  AES-XTS-128 (%s): ",\r
2148                             ( mode == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );\r
2149 \r
2150         memset( key, 0, sizeof( key ) );\r
2151         memcpy( key, aes_test_xts_key[u], 32 );\r
2152         data_unit = aes_test_xts_data_unit[u];\r
2153 \r
2154         len = sizeof( *aes_test_xts_ct32 );\r
2155 \r
2156         if( mode == MBEDTLS_AES_DECRYPT )\r
2157         {\r
2158             ret = mbedtls_aes_xts_setkey_dec( &ctx_xts, key, 256 );\r
2159             if( ret != 0)\r
2160                 goto exit;\r
2161             memcpy( buf, aes_test_xts_ct32[u], len );\r
2162             aes_tests = aes_test_xts_pt32[u];\r
2163         }\r
2164         else\r
2165         {\r
2166             ret = mbedtls_aes_xts_setkey_enc( &ctx_xts, key, 256 );\r
2167             if( ret != 0)\r
2168                 goto exit;\r
2169             memcpy( buf, aes_test_xts_pt32[u], len );\r
2170             aes_tests = aes_test_xts_ct32[u];\r
2171         }\r
2172 \r
2173 \r
2174         ret = mbedtls_aes_crypt_xts( &ctx_xts, mode, len, data_unit,\r
2175                                      buf, buf );\r
2176         if( ret != 0 )\r
2177             goto exit;\r
2178 \r
2179         if( memcmp( buf, aes_tests, len ) != 0 )\r
2180         {\r
2181             ret = 1;\r
2182             goto exit;\r
2183         }\r
2184 \r
2185         if( verbose != 0 )\r
2186             mbedtls_printf( "passed\n" );\r
2187     }\r
2188 \r
2189     if( verbose != 0 )\r
2190         mbedtls_printf( "\n" );\r
2191 \r
2192     mbedtls_aes_xts_free( &ctx_xts );\r
2193     }\r
2194 #endif /* MBEDTLS_CIPHER_MODE_XTS */\r
2195 \r
2196     ret = 0;\r
2197 \r
2198 exit:\r
2199     if( ret != 0 && verbose != 0 )\r
2200         mbedtls_printf( "failed\n" );\r
2201 \r
2202     mbedtls_aes_free( &ctx );\r
2203 \r
2204     return( ret );\r
2205 }\r
2206 \r
2207 #endif /* MBEDTLS_SELF_TEST */\r
2208 \r
2209 #endif /* MBEDTLS_AES_C */\r