BA / SerialCom

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Fork of OmniWheels by Gustav Atmel

mbed-os/features/mbedtls/src/aes.c@2:798925c9e4a8, 2018-05-01 (annotated)

Committer:
gustavatmel
Date:
Tue May 01 15:55:34 2018 +0000
Revision:
2:798925c9e4a8
Parent:
1:9c5af431a1f1 
bluetooth

Who changed what in which revision?

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