networking/tls_aes.c

   1 /*
   2  * Copyright (C) 2017 Denys Vlasenko
   3  *
   4  * Licensed under GPLv2, see file LICENSE in this source tree.
   5  */
   6
   7 /* This AES implementation is derived from tiny-AES128-C code,
   8  * which was put by its author into public domain:
   9  *
  10  * tiny-AES128-C/unlicense.txt, Dec 8, 2014
  11  * """
  12  * This is free and unencumbered software released into the public domain.
  13  *
  14  * Anyone is free to copy, modify, publish, use, compile, sell, or
  15  * distribute this software, either in source code form or as a compiled
  16  * binary, for any purpose, commercial or non-commercial, and by any
  17  * means.
  18  *
  19  * In jurisdictions that recognize copyright laws, the author or authors
  20  * of this software dedicate any and all copyright interest in the
  21  * software to the public domain. We make this dedication for the benefit
  22  * of the public at large and to the detriment of our heirs and
  23  * successors. We intend this dedication to be an overt act of
  24  * relinquishment in perpetuity of all present and future rights to this
  25  * software under copyright law.
  26  *
  27  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  28  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  29  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  30  * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  31  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  32  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  33  * OTHER DEALINGS IN THE SOFTWARE.
  34  * """
  35  */
  36 /* Note that only original tiny-AES128-C code is public domain.
  37  * The derived code in this file has been expanded to also implement aes192
  38  * and aes256 and use more efficient word-sized operations in many places,
  39  * and put under GPLv2 license.
  40  */
  41 #include "tls.h"
  42
  43 // The lookup-tables are marked const so they can be placed in read-only storage instead of RAM
  44 // The numbers below can be computed dynamically trading ROM for RAM -
  45 // This can be useful in (embedded) bootloader applications, where ROM is often limited.
  46 static const uint8_t sbox[] = {
  47         0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5,
  48         0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
  49         0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0,
  50         0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
  51         0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc,
  52         0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
  53         0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a,
  54         0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
  55         0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0,
  56         0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
  57         0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b,
  58         0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
  59         0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85,
  60         0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
  61         0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5,
  62         0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
  63         0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17,
  64         0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
  65         0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88,
  66         0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
  67         0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c,
  68         0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
  69         0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9,
  70         0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
  71         0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6,
  72         0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
  73         0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e,
  74         0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
  75         0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94,
  76         0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
  77         0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68,
  78         0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16,
  79 };
  80
  81 static const uint8_t rsbox[] = {
  82         0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38,
  83         0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb,
  84         0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87,
  85         0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb,
  86         0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d,
  87         0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,
  88         0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2,
  89         0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25,
  90         0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16,
  91         0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92,
  92         0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda,
  93         0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84,
  94         0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a,
  95         0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06,
  96         0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02,
  97         0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b,
  98         0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea,
  99         0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73,
 100         0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85,
 101         0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e,
 102         0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89,
 103         0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b,
 104         0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20,
 105         0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4,
 106         0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31,
 107         0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f,
 108         0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d,
 109         0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef,
 110         0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0,
 111         0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,
 112         0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26,
 113         0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d,
 114 };
 115
 116 // SubWord() is a function that takes a four-byte input word and
 117 // applies the S-box to each of the four bytes to produce an output word.
 118 static uint32_t Subword(uint32_t x)
 119 {
 120         return (sbox[(x >> 24)      ] << 24)
 121         |      (sbox[(x >> 16) & 255] << 16)
 122         |      (sbox[(x >> 8 ) & 255] << 8 )
 123         |      (sbox[(x      ) & 255]      );
 124 }
 125
 126 // This function produces Nb(Nr+1) round keys.
 127 // The round keys are used in each round to decrypt the states.
 128 static int KeyExpansion(uint32_t *RoundKey, const void *key, unsigned key_len)
 129 {
 130         // The round constant word array, Rcon[i], contains the values given by
 131         // x to th e power (i-1) being powers of x (x is denoted as {02}) in the field GF(2^8).
 132         // Note that i starts at 2, not 0.
 133         static const uint8_t Rcon[] = {
 134                 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36
 135         //..... 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6,...
 136         // but aes256 only uses values up to 0x36
 137         };
 138         int rounds, words_key, words_RoundKey;
 139         int i, j, k;
 140
 141         // key_len 16: aes128, rounds 10, words_key 4, words_RoundKey 44
 142         // key_len 24: aes192, rounds 12, words_key 6, words_RoundKey 52
 143         // key_len 32: aes256, rounds 14, words_key 8, words_RoundKey 60
 144         words_key = key_len / 4;
 145         rounds = 6 + (key_len / 4);
 146         words_RoundKey = 28 + key_len;
 147
 148         // The first round key is the key itself.
 149         for (i = 0; i < words_key; i++)
 150                 RoundKey[i] = get_unaligned_be32((uint32_t*)key + i);
 151         // i == words_key now
 152
 153         // All other round keys are found from the previous round keys.
 154         j = k = 0;
 155         for (; i < words_RoundKey; i++) {
 156                 uint32_t tempa;
 157
 158                 tempa = RoundKey[i - 1];
 159                 if (j == 0) {
 160                         // RotWord(): rotates the 4 bytes in a word to the left once.
 161                         tempa = (tempa << 8) | (tempa >> 24);
 162                         tempa = Subword(tempa);
 163                         tempa ^= (uint32_t)Rcon[k] << 24;
 164                 } else if (words_key > 6 && j == 4) {
 165                         tempa = Subword(tempa);
 166                 }
 167                 RoundKey[i] = RoundKey[i - words_key] ^ tempa;
 168                 j++;
 169                 if (j == words_key) {
 170                         j = 0;
 171                         k++;
 172                 }
 173         }
 174         return rounds;
 175 }
 176
 177 // This function adds the round key to state.
 178 // The round key is added to the state by an XOR function.
 179 static void AddRoundKey(unsigned astate[16], const uint32_t *RoundKeys)
 180 {
 181         int i;
 182
 183         for (i = 0; i < 16; i += 4) {
 184                 uint32_t n = *RoundKeys++;
 185                 astate[i + 0] ^= (n >> 24);
 186                 astate[i + 1] ^= (n >> 16) & 255;
 187                 astate[i + 2] ^= (n >> 8) & 255;
 188                 astate[i + 3] ^= n & 255;
 189         }
 190 }
 191
 192 // The SubBytes Function Substitutes the values in the
 193 // state matrix with values in an S-box.
 194 static void SubBytes(unsigned astate[16])
 195 {
 196         int i;
 197
 198         for (i = 0; i < 16; i++)
 199                 astate[i] = sbox[astate[i]];
 200 }
 201
 202 // Our code actually stores "columns" (in aes encryption terminology)
 203 // of state in rows: first 4 elements are "row 0, col 0", "row 1, col 0".
 204 // "row 2, col 0", "row 3, col 0". The fifth element is "row 0, col 1",
 205 // and so on.
 206 #define ASTATE(col,row) astate[(col)*4 + (row)]
 207
 208 // The ShiftRows() function shifts the rows in the state to the left.
 209 // Each row is shifted with different offset.
 210 // Offset = Row number. So the first row is not shifted.
 211 static void ShiftRows(unsigned astate[16])
 212 {
 213         unsigned v;
 214
 215         // Rotate first row 1 columns to left
 216         v = ASTATE(0,1);
 217         ASTATE(0,1) = ASTATE(1,1);
 218         ASTATE(1,1) = ASTATE(2,1);
 219         ASTATE(2,1) = ASTATE(3,1);
 220         ASTATE(3,1) = v;
 221
 222         // Rotate second row 2 columns to left
 223         v = ASTATE(0,2); ASTATE(0,2) = ASTATE(2,2); ASTATE(2,2) = v;
 224         v = ASTATE(1,2); ASTATE(1,2) = ASTATE(3,2); ASTATE(3,2) = v;
 225
 226         // Rotate third row 3 columns to left
 227         v = ASTATE(3,3);
 228         ASTATE(3,3) = ASTATE(2,3);
 229         ASTATE(2,3) = ASTATE(1,3);
 230         ASTATE(1,3) = ASTATE(0,3);
 231         ASTATE(0,3) = v;
 232 }
 233
 234 // MixColumns function mixes the columns of the state matrix
 235 static void MixColumns(unsigned astate[16])
 236 {
 237         int i;
 238
 239         for (i = 0; i < 16; i += 4) {
 240                 unsigned a, b, c, d;
 241                 unsigned x, y, z, t;
 242
 243                 a = astate[i + 0];
 244                 b = astate[i + 1];
 245                 c = astate[i + 2];
 246                 d = astate[i + 3];
 247                 x = (a << 1) ^ b ^ (b << 1) ^ c ^ d;
 248                 y = a ^ (b << 1) ^ c ^ (c << 1) ^ d;
 249                 z = a ^ b ^ (c << 1) ^ d ^ (d << 1);
 250                 t = a ^ (a << 1) ^ b ^ c ^ (d << 1);
 251                 astate[i + 0] = x ^ ((-(int)(x >> 8)) & 0x11b);
 252                 astate[i + 1] = y ^ ((-(int)(y >> 8)) & 0x11b);
 253                 astate[i + 2] = z ^ ((-(int)(z >> 8)) & 0x11b);
 254                 astate[i + 3] = t ^ ((-(int)(t >> 8)) & 0x11b);
 255         }
 256 }
 257
 258 // The SubBytes Function Substitutes the values in the
 259 // state matrix with values in an S-box.
 260 static void InvSubBytes(unsigned astate[16])
 261 {
 262         int i;
 263
 264         for (i = 0; i < 16; i++)
 265                 astate[i] = rsbox[astate[i]];
 266 }
 267
 268 static void InvShiftRows(unsigned astate[16])
 269 {
 270         unsigned v;
 271
 272         // Rotate first row 1 columns to right
 273         v = ASTATE(3,1);
 274         ASTATE(3,1) = ASTATE(2,1);
 275         ASTATE(2,1) = ASTATE(1,1);
 276         ASTATE(1,1) = ASTATE(0,1);
 277         ASTATE(0,1) = v;
 278
 279         // Rotate second row 2 columns to right
 280         v = ASTATE(0,2); ASTATE(0,2) = ASTATE(2,2); ASTATE(2,2) = v;
 281         v = ASTATE(1,2); ASTATE(1,2) = ASTATE(3,2); ASTATE(3,2) = v;
 282
 283         // Rotate third row 3 columns to right
 284         v = ASTATE(0,3);
 285         ASTATE(0,3) = ASTATE(1,3);
 286         ASTATE(1,3) = ASTATE(2,3);
 287         ASTATE(2,3) = ASTATE(3,3);
 288         ASTATE(3,3) = v;
 289 }
 290
 291 static ALWAYS_INLINE unsigned Multiply(unsigned x)
 292 {
 293         unsigned y;
 294
 295         y = x >> 8;
 296         return (x ^ y ^ (y << 1) ^ (y << 3) ^ (y << 4)) & 255;
 297 }
 298
 299 // MixColumns function mixes the columns of the state matrix.
 300 // The method used to multiply may be difficult to understand for the inexperienced.
 301 // Please use the references to gain more information.
 302 static void InvMixColumns(unsigned astate[16])
 303 {
 304         int i;
 305
 306         for (i = 0; i < 16; i += 4) {
 307                 unsigned a, b, c, d;
 308                 unsigned x, y, z, t;
 309
 310                 a = astate[i + 0];
 311                 b = astate[i + 1];
 312                 c = astate[i + 2];
 313                 d = astate[i + 3];
 314                 x = (a << 1) ^ (a << 2) ^ (a << 3) ^ b ^ (b << 1) ^ (b << 3)
 315                 /***/ ^ c ^ (c << 2) ^ (c << 3) ^ d ^ (d << 3);
 316                 y = a ^ (a << 3) ^ (b << 1) ^ (b << 2) ^ (b << 3)
 317                 /***/ ^ c ^ (c << 1) ^ (c << 3) ^ d ^ (d << 2) ^ (d << 3);
 318                 z = a ^ (a << 2) ^ (a << 3) ^ b ^ (b << 3)
 319                 /***/ ^ (c << 1) ^ (c << 2) ^ (c << 3) ^ d ^ (d << 1) ^ (d << 3);
 320                 t = a ^ (a << 1) ^ (a << 3) ^ b ^ (b << 2) ^ (b << 3)
 321                 /***/ ^ c ^ (c << 3) ^ (d << 1) ^ (d << 2) ^ (d << 3);
 322                 astate[i + 0] = Multiply(x);
 323                 astate[i + 1] = Multiply(y);
 324                 astate[i + 2] = Multiply(z);
 325                 astate[i + 3] = Multiply(t);
 326         }
 327 }
 328
 329 static void aes_encrypt_1(unsigned astate[16], unsigned rounds, const uint32_t *RoundKey)
 330 {
 331         for (;;) {
 332                 AddRoundKey(astate, RoundKey);
 333                 RoundKey += 4;
 334                 SubBytes(astate);
 335                 ShiftRows(astate);
 336                 if (--rounds == 0)
 337                         break;
 338                 MixColumns(astate);
 339         }
 340         AddRoundKey(astate, RoundKey);
 341 }
 342
 343 #if 0 // UNUSED
 344 static void aes_encrypt_one_block(unsigned rounds, const uint32_t *RoundKey, const void *data, void *dst)
 345 {
 346         unsigned astate[16];
 347         unsigned i;
 348
 349         const uint8_t *pt = data;
 350         uint8_t *ct = dst;
 351
 352         for (i = 0; i < 16; i++)
 353                 astate[i] = pt[i];
 354         aes_encrypt_1(astate, rounds, RoundKey);
 355         for (i = 0; i < 16; i++)
 356                 ct[i] = astate[i];
 357 }
 358 #endif
 359
 360 void aes_cbc_encrypt(const void *key, int klen, void *iv, const void *data, size_t len, void *dst)
 361 {
 362         uint32_t RoundKey[60];
 363         uint8_t iv2[16];
 364         unsigned rounds;
 365
 366         const uint8_t *pt = data;
 367         uint8_t *ct = dst;
 368
 369         memcpy(iv2, iv, 16);
 370         rounds = KeyExpansion(RoundKey, key, klen);
 371         while (len > 0) {
 372                 {
 373                         /* almost aes_encrypt_one_block(rounds, RoundKey, pt, ct);
 374                          * but xor'ing of IV with plaintext[] is combined
 375                          * with plaintext[] -> astate[]
 376                          */
 377                         int i;
 378                         unsigned astate[16];
 379                         for (i = 0; i < 16; i++)
 380                                 astate[i] = pt[i] ^ iv2[i];
 381                         aes_encrypt_1(astate, rounds, RoundKey);
 382                         for (i = 0; i < 16; i++)
 383                                 iv2[i] = ct[i] = astate[i];
 384                 }
 385                 ct += 16;
 386                 pt += 16;
 387                 len -= 16;
 388         }
 389 }
 390
 391 static void aes_decrypt_1(unsigned astate[16], unsigned rounds, const uint32_t *RoundKey)
 392 {
 393         RoundKey += rounds * 4;
 394         AddRoundKey(astate, RoundKey);
 395         for (;;) {
 396                 InvShiftRows(astate);
 397                 InvSubBytes(astate);
 398                 RoundKey -= 4;
 399                 AddRoundKey(astate, RoundKey);
 400                 if (--rounds == 0)
 401                         break;
 402                 InvMixColumns(astate);
 403         }
 404 }
 405
 406 #if 0 //UNUSED
 407 static void aes_decrypt_one_block(unsigned rounds, const uint32_t *RoundKey, const void *data, void *dst)
 408 {
 409         unsigned astate[16];
 410         unsigned i;
 411
 412         const uint8_t *ct = data;
 413         uint8_t *pt = dst;
 414
 415         for (i = 0; i < 16; i++)
 416                 astate[i] = ct[i];
 417         aes_decrypt_1(astate, rounds, RoundKey);
 418         for (i = 0; i < 16; i++)
 419                 pt[i] = astate[i];
 420 }
 421 #endif
 422
 423 void aes_cbc_decrypt(const void *key, int klen, void *iv, const void *data, size_t len, void *dst)
 424 {
 425         uint32_t RoundKey[60];
 426         uint8_t iv2[16];
 427         uint8_t iv3[16];
 428         unsigned rounds;
 429         uint8_t *ivbuf;
 430         uint8_t *ivnext;
 431
 432         const uint8_t *ct = data;
 433         uint8_t *pt = dst;
 434
 435         rounds = KeyExpansion(RoundKey, key, klen);
 436         ivbuf = memcpy(iv2, iv, 16);
 437         while (len) {
 438                 ivnext = (ivbuf==iv2) ? iv3 : iv2;
 439                 {
 440                         /* almost aes_decrypt_one_block(rounds, RoundKey, ct, pt)
 441                          * but xor'ing of ivbuf is combined with astate[] -> plaintext[]
 442                          */
 443                         int i;
 444                         unsigned astate[16];
 445                         for (i = 0; i < 16; i++)
 446                                 ivnext[i] = astate[i] = ct[i];
 447                         aes_decrypt_1(astate, rounds, RoundKey);
 448                         for (i = 0; i < 16; i++)
 449                                 pt[i] = astate[i] ^ ivbuf[i];
 450                 }
 451                 ivbuf = ivnext;
 452                 ct += 16;
 453                 pt += 16;
 454                 len -= 16;
 455         }
 456 }