main/aeskey.c

   1 /*
   2  ---------------------------------------------------------------------------
   3  Copyright (c) 2003, Dr Brian Gladman <brg@gladman.me.uk>, Worcester, UK.
   4  All rights reserved.
   5
   6  LICENSE TERMS
   7
   8  The free distribution and use of this software in both source and binary
   9  form is allowed (with or without changes) provided that:
  10
  11    1. distributions of this source code include the above copyright
  12       notice, this list of conditions and the following disclaimer;
  13
  14    2. distributions in binary form include the above copyright
  15       notice, this list of conditions and the following disclaimer
  16       in the documentation and/or other associated materials;
  17
  18    3. the copyright holder's name is not used to endorse products
  19       built using this software without specific written permission.
  20
  21  ALTERNATIVELY, provided that this notice is retained in full, this product
  22  may be distributed under the terms of the GNU General Public License (GPL),
  23  in which case the provisions of the GPL apply INSTEAD OF those given above.
  24
  25  DISCLAIMER
  26
  27  This software is provided 'as is' with no explicit or implied warranties
  28  in respect of its properties, including, but not limited to, correctness
  29  and/or fitness for purpose.
  30  ---------------------------------------------------------------------------
  31  Issue Date: 26/08/2003
  32
  33 */
  34
  35 /*! \file
  36  *
  37  *  \brief  This file contains the code for implementing the key schedule for AES
  38  *  (Rijndael) for block and key sizes of 16, 24, and 32 bytes. See aesopt.h
  39  *  for further details including optimisation.
  40  *
  41  * \author Dr Brian Gladman <brg@gladman.me.uk>
  42  */
  43
  44 #if defined(__cplusplus)
  45 extern "C"
  46 {
  47 #endif
  48
  49 #ifndef HAVE_CRYPTO
  50
  51 #include "aesopt.h"
  52
  53 /* Initialise the key schedule from the user supplied key. The key
  54    length can be specified in bytes, with legal values of 16, 24
  55    and 32, or in bits, with legal values of 128, 192 and 256. These
  56    values correspond with Nk values of 4, 6 and 8 respectively.
  57
  58    The following macros implement a single cycle in the key
  59    schedule generation process. The number of cycles needed
  60    for each cx->n_col and nk value is:
  61
  62     nk =             4  5  6  7  8
  63     ------------------------------
  64     cx->n_col = 4   10  9  8  7  7
  65     cx->n_col = 5   14 11 10  9  9
  66     cx->n_col = 6   19 15 12 11 11
  67     cx->n_col = 7   21 19 16 13 14
  68     cx->n_col = 8   29 23 19 17 14
  69 */
  70
  71 #define ke4(k,i) \
  72 {   k[4*(i)+4] = ss[0] ^= ls_box(ss[3],3) ^ t_use(r,c)[i]; k[4*(i)+5] = ss[1] ^= ss[0]; \
  73     k[4*(i)+6] = ss[2] ^= ss[1]; k[4*(i)+7] = ss[3] ^= ss[2]; \
  74 }
  75 #define kel4(k,i) \
  76 {   k[4*(i)+4] = ss[0] ^= ls_box(ss[3],3) ^ t_use(r,c)[i]; k[4*(i)+5] = ss[1] ^= ss[0]; \
  77     k[4*(i)+6] = ss[2] ^= ss[1]; k[4*(i)+7] = ss[3] ^= ss[2]; \
  78 }
  79
  80 #define ke6(k,i) \
  81 {   k[6*(i)+ 6] = ss[0] ^= ls_box(ss[5],3) ^ t_use(r,c)[i]; k[6*(i)+ 7] = ss[1] ^= ss[0]; \
  82     k[6*(i)+ 8] = ss[2] ^= ss[1]; k[6*(i)+ 9] = ss[3] ^= ss[2]; \
  83     k[6*(i)+10] = ss[4] ^= ss[3]; k[6*(i)+11] = ss[5] ^= ss[4]; \
  84 }
  85 #define kel6(k,i) \
  86 {   k[6*(i)+ 6] = ss[0] ^= ls_box(ss[5],3) ^ t_use(r,c)[i]; k[6*(i)+ 7] = ss[1] ^= ss[0]; \
  87     k[6*(i)+ 8] = ss[2] ^= ss[1]; k[6*(i)+ 9] = ss[3] ^= ss[2]; \
  88 }
  89
  90 #define ke8(k,i) \
  91 {   k[8*(i)+ 8] = ss[0] ^= ls_box(ss[7],3) ^ t_use(r,c)[i]; k[8*(i)+ 9] = ss[1] ^= ss[0]; \
  92     k[8*(i)+10] = ss[2] ^= ss[1]; k[8*(i)+11] = ss[3] ^= ss[2]; \
  93     k[8*(i)+12] = ss[4] ^= ls_box(ss[3],0); k[8*(i)+13] = ss[5] ^= ss[4]; \
  94     k[8*(i)+14] = ss[6] ^= ss[5]; k[8*(i)+15] = ss[7] ^= ss[6]; \
  95 }
  96 #define kel8(k,i) \
  97 {   k[8*(i)+ 8] = ss[0] ^= ls_box(ss[7],3) ^ t_use(r,c)[i]; k[8*(i)+ 9] = ss[1] ^= ss[0]; \
  98     k[8*(i)+10] = ss[2] ^= ss[1]; k[8*(i)+11] = ss[3] ^= ss[2]; \
  99 }
 100
 101 #if defined(ENCRYPTION_KEY_SCHEDULE)
 102
 103 #if defined(AES_128) || defined(AES_VAR)
 104
 105 aes_rval aes_encrypt_key128(const void *in_key, aes_encrypt_ctx cx[1])
 106 {   aes_32t    ss[4];
 107
 108     cx->ks[0] = ss[0] = word_in(in_key, 0);
 109     cx->ks[1] = ss[1] = word_in(in_key, 1);
 110     cx->ks[2] = ss[2] = word_in(in_key, 2);
 111     cx->ks[3] = ss[3] = word_in(in_key, 3);
 112
 113 #if ENC_UNROLL == NONE
 114     {   aes_32t i;
 115
 116         for(i = 0; i < ((11 * N_COLS - 1) / 4); ++i)
 117             ke4(cx->ks, i);
 118     }
 119 #else
 120     ke4(cx->ks, 0);  ke4(cx->ks, 1);
 121     ke4(cx->ks, 2);  ke4(cx->ks, 3);
 122     ke4(cx->ks, 4);  ke4(cx->ks, 5);
 123     ke4(cx->ks, 6);  ke4(cx->ks, 7);
 124     ke4(cx->ks, 8); kel4(cx->ks, 9);
 125 #endif
 126
 127     /* cx->ks[45] ^ cx->ks[52] ^ cx->ks[53] is zero for a 256 bit       */
 128     /* key and must be non-zero for 128 and 192 bits keys   */
 129     cx->ks[53] = cx->ks[45] = 0;
 130     cx->ks[52] = 10;
 131 #ifdef AES_ERR_CHK
 132     return aes_good;
 133 #endif
 134 }
 135
 136 #endif
 137
 138 #if defined(AES_192) || defined(AES_VAR)
 139
 140 aes_rval aes_encrypt_key192(const void *in_key, aes_encrypt_ctx cx[1])
 141 {   aes_32t    ss[6];
 142
 143     cx->ks[0] = ss[0] = word_in(in_key, 0);
 144     cx->ks[1] = ss[1] = word_in(in_key, 1);
 145     cx->ks[2] = ss[2] = word_in(in_key, 2);
 146     cx->ks[3] = ss[3] = word_in(in_key, 3);
 147     cx->ks[4] = ss[4] = word_in(in_key, 4);
 148     cx->ks[5] = ss[5] = word_in(in_key, 5);
 149
 150 #if ENC_UNROLL == NONE
 151     {   aes_32t i;
 152
 153         for(i = 0; i < (13 * N_COLS - 1) / 6; ++i)
 154             ke6(cx->ks, i);
 155     }
 156 #else
 157     ke6(cx->ks, 0);  ke6(cx->ks, 1);
 158     ke6(cx->ks, 2);  ke6(cx->ks, 3);
 159     ke6(cx->ks, 4);  ke6(cx->ks, 5);
 160     ke6(cx->ks, 6); kel6(cx->ks, 7);
 161 #endif
 162
 163     /* cx->ks[45] ^ cx->ks[52] ^ cx->ks[53] is zero for a 256 bit       */
 164     /* key and must be non-zero for 128 and 192 bits keys   */
 165     cx->ks[53] = cx->ks[45];
 166     cx->ks[52] = 12;
 167 #ifdef AES_ERR_CHK
 168     return aes_good;
 169 #endif
 170 }
 171
 172 #endif
 173
 174 #if defined(AES_256) || defined(AES_VAR)
 175
 176 aes_rval aes_encrypt_key256(const void *in_key, aes_encrypt_ctx cx[1])
 177 {   aes_32t    ss[8];
 178
 179     cx->ks[0] = ss[0] = word_in(in_key, 0);
 180     cx->ks[1] = ss[1] = word_in(in_key, 1);
 181     cx->ks[2] = ss[2] = word_in(in_key, 2);
 182     cx->ks[3] = ss[3] = word_in(in_key, 3);
 183     cx->ks[4] = ss[4] = word_in(in_key, 4);
 184     cx->ks[5] = ss[5] = word_in(in_key, 5);
 185     cx->ks[6] = ss[6] = word_in(in_key, 6);
 186     cx->ks[7] = ss[7] = word_in(in_key, 7);
 187
 188 #if ENC_UNROLL == NONE
 189     {   aes_32t i;
 190
 191         for(i = 0; i < (15 * N_COLS - 1) / 8; ++i)
 192             ke8(cx->ks,  i);
 193     }
 194 #else
 195     ke8(cx->ks, 0); ke8(cx->ks, 1);
 196     ke8(cx->ks, 2); ke8(cx->ks, 3);
 197     ke8(cx->ks, 4); ke8(cx->ks, 5);
 198     kel8(cx->ks, 6);
 199 #endif
 200 #ifdef AES_ERR_CHK
 201     return aes_good;
 202 #endif
 203 }
 204
 205 #endif
 206
 207 #if defined(AES_VAR)
 208
 209 aes_rval aes_encrypt_key(const void *in_key, int key_len, aes_encrypt_ctx cx[1])
 210 {
 211     switch(key_len)
 212     {
 213 #ifdef AES_ERR_CHK
 214     case 16: case 128: return aes_encrypt_key128(in_key, cx);
 215     case 24: case 192: return aes_encrypt_key192(in_key, cx);
 216     case 32: case 256: return aes_encrypt_key256(in_key, cx);
 217     default: return aes_error;
 218 #else
 219     case 16: case 128: aes_encrypt_key128(in_key, cx); return;
 220     case 24: case 192: aes_encrypt_key192(in_key, cx); return;
 221     case 32: case 256: aes_encrypt_key256(in_key, cx); return;
 222 #endif
 223     }
 224 }
 225
 226 #endif
 227
 228 #endif
 229
 230 #if defined(DECRYPTION_KEY_SCHEDULE)
 231
 232 #if DEC_ROUND == NO_TABLES
 233 #define ff(x)   (x)
 234 #else
 235 #define ff(x)   inv_mcol(x)
 236 #ifdef  dec_imvars
 237 #define d_vars  dec_imvars
 238 #endif
 239 #endif
 240
 241 #if 1
 242 #define kdf4(k,i) \
 243 {   ss[0] = ss[0] ^ ss[2] ^ ss[1] ^ ss[3]; ss[1] = ss[1] ^ ss[3]; ss[2] = ss[2] ^ ss[3]; ss[3] = ss[3]; \
 244     ss[4] = ls_box(ss[(i+3) % 4], 3) ^ t_use(r,c)[i]; ss[i % 4] ^= ss[4]; \
 245     ss[4] ^= k[4*(i)];   k[4*(i)+4] = ff(ss[4]); ss[4] ^= k[4*(i)+1]; k[4*(i)+5] = ff(ss[4]); \
 246     ss[4] ^= k[4*(i)+2]; k[4*(i)+6] = ff(ss[4]); ss[4] ^= k[4*(i)+3]; k[4*(i)+7] = ff(ss[4]); \
 247 }
 248 #define kd4(k,i) \
 249 {   ss[4] = ls_box(ss[(i+3) % 4], 3) ^ t_use(r,c)[i]; ss[i % 4] ^= ss[4]; ss[4] = ff(ss[4]); \
 250     k[4*(i)+4] = ss[4] ^= k[4*(i)]; k[4*(i)+5] = ss[4] ^= k[4*(i)+1]; \
 251     k[4*(i)+6] = ss[4] ^= k[4*(i)+2]; k[4*(i)+7] = ss[4] ^= k[4*(i)+3]; \
 252 }
 253 #define kdl4(k,i) \
 254 {   ss[4] = ls_box(ss[(i+3) % 4], 3) ^ t_use(r,c)[i]; ss[i % 4] ^= ss[4]; \
 255     k[4*(i)+4] = (ss[0] ^= ss[1]) ^ ss[2] ^ ss[3]; k[4*(i)+5] = ss[1] ^ ss[3]; \
 256     k[4*(i)+6] = ss[0]; k[4*(i)+7] = ss[1]; \
 257 }
 258 #else
 259 #define kdf4(k,i) \
 260 {   ss[0] ^= ls_box(ss[3],3) ^ t_use(r,c)[i]; k[4*(i)+ 4] = ff(ss[0]); ss[1] ^= ss[0]; k[4*(i)+ 5] = ff(ss[1]); \
 261     ss[2] ^= ss[1]; k[4*(i)+ 6] = ff(ss[2]); ss[3] ^= ss[2]; k[4*(i)+ 7] = ff(ss[3]); \
 262 }
 263 #define kd4(k,i) \
 264 {   ss[4] = ls_box(ss[3],3) ^ t_use(r,c)[i]; \
 265     ss[0] ^= ss[4]; ss[4] = ff(ss[4]); k[4*(i)+ 4] = ss[4] ^= k[4*(i)]; \
 266     ss[1] ^= ss[0]; k[4*(i)+ 5] = ss[4] ^= k[4*(i)+ 1]; \
 267     ss[2] ^= ss[1]; k[4*(i)+ 6] = ss[4] ^= k[4*(i)+ 2]; \
 268     ss[3] ^= ss[2]; k[4*(i)+ 7] = ss[4] ^= k[4*(i)+ 3]; \
 269 }
 270 #define kdl4(k,i) \
 271 {   ss[0] ^= ls_box(ss[3],3) ^ t_use(r,c)[i]; k[4*(i)+ 4] = ss[0]; ss[1] ^= ss[0]; k[4*(i)+ 5] = ss[1]; \
 272     ss[2] ^= ss[1]; k[4*(i)+ 6] = ss[2]; ss[3] ^= ss[2]; k[4*(i)+ 7] = ss[3]; \
 273 }
 274 #endif
 275
 276 #define kdf6(k,i) \
 277 {   ss[0] ^= ls_box(ss[5],3) ^ t_use(r,c)[i]; k[6*(i)+ 6] = ff(ss[0]); ss[1] ^= ss[0]; k[6*(i)+ 7] = ff(ss[1]); \
 278     ss[2] ^= ss[1]; k[6*(i)+ 8] = ff(ss[2]); ss[3] ^= ss[2]; k[6*(i)+ 9] = ff(ss[3]); \
 279     ss[4] ^= ss[3]; k[6*(i)+10] = ff(ss[4]); ss[5] ^= ss[4]; k[6*(i)+11] = ff(ss[5]); \
 280 }
 281 #define kd6(k,i) \
 282 {   ss[6] = ls_box(ss[5],3) ^ t_use(r,c)[i]; \
 283     ss[0] ^= ss[6]; ss[6] = ff(ss[6]); k[6*(i)+ 6] = ss[6] ^= k[6*(i)]; \
 284     ss[1] ^= ss[0]; k[6*(i)+ 7] = ss[6] ^= k[6*(i)+ 1]; \
 285     ss[2] ^= ss[1]; k[6*(i)+ 8] = ss[6] ^= k[6*(i)+ 2]; \
 286     ss[3] ^= ss[2]; k[6*(i)+ 9] = ss[6] ^= k[6*(i)+ 3]; \
 287     ss[4] ^= ss[3]; k[6*(i)+10] = ss[6] ^= k[6*(i)+ 4]; \
 288     ss[5] ^= ss[4]; k[6*(i)+11] = ss[6] ^= k[6*(i)+ 5]; \
 289 }
 290 #define kdl6(k,i) \
 291 {   ss[0] ^= ls_box(ss[5],3) ^ t_use(r,c)[i]; k[6*(i)+ 6] = ss[0]; ss[1] ^= ss[0]; k[6*(i)+ 7] = ss[1]; \
 292     ss[2] ^= ss[1]; k[6*(i)+ 8] = ss[2]; ss[3] ^= ss[2]; k[6*(i)+ 9] = ss[3]; \
 293 }
 294
 295 #define kdf8(k,i) \
 296 {   ss[0] ^= ls_box(ss[7],3) ^ t_use(r,c)[i]; k[8*(i)+ 8] = ff(ss[0]); ss[1] ^= ss[0]; k[8*(i)+ 9] = ff(ss[1]); \
 297     ss[2] ^= ss[1]; k[8*(i)+10] = ff(ss[2]); ss[3] ^= ss[2]; k[8*(i)+11] = ff(ss[3]); \
 298     ss[4] ^= ls_box(ss[3],0); k[8*(i)+12] = ff(ss[4]); ss[5] ^= ss[4]; k[8*(i)+13] = ff(ss[5]); \
 299     ss[6] ^= ss[5]; k[8*(i)+14] = ff(ss[6]); ss[7] ^= ss[6]; k[8*(i)+15] = ff(ss[7]); \
 300 }
 301 #define kd8(k,i) \
 302 {   aes_32t g = ls_box(ss[7],3) ^ t_use(r,c)[i]; \
 303     ss[0] ^= g; g = ff(g); k[8*(i)+ 8] = g ^= k[8*(i)]; \
 304     ss[1] ^= ss[0]; k[8*(i)+ 9] = g ^= k[8*(i)+ 1]; \
 305     ss[2] ^= ss[1]; k[8*(i)+10] = g ^= k[8*(i)+ 2]; \
 306     ss[3] ^= ss[2]; k[8*(i)+11] = g ^= k[8*(i)+ 3]; \
 307     g = ls_box(ss[3],0); \
 308     ss[4] ^= g; g = ff(g); k[8*(i)+12] = g ^= k[8*(i)+ 4]; \
 309     ss[5] ^= ss[4]; k[8*(i)+13] = g ^= k[8*(i)+ 5]; \
 310     ss[6] ^= ss[5]; k[8*(i)+14] = g ^= k[8*(i)+ 6]; \
 311     ss[7] ^= ss[6]; k[8*(i)+15] = g ^= k[8*(i)+ 7]; \
 312 }
 313 #define kdl8(k,i) \
 314 {   ss[0] ^= ls_box(ss[7],3) ^ t_use(r,c)[i]; k[8*(i)+ 8] = ss[0]; ss[1] ^= ss[0]; k[8*(i)+ 9] = ss[1]; \
 315     ss[2] ^= ss[1]; k[8*(i)+10] = ss[2]; ss[3] ^= ss[2]; k[8*(i)+11] = ss[3]; \
 316 }
 317
 318 #if defined(AES_128) || defined(AES_VAR)
 319
 320 aes_rval aes_decrypt_key128(const void *in_key, aes_decrypt_ctx cx[1])
 321 {   aes_32t    ss[5];
 322 #ifdef  d_vars
 323         d_vars;
 324 #endif
 325     cx->ks[0] = ss[0] = word_in(in_key, 0);
 326     cx->ks[1] = ss[1] = word_in(in_key, 1);
 327     cx->ks[2] = ss[2] = word_in(in_key, 2);
 328     cx->ks[3] = ss[3] = word_in(in_key, 3);
 329
 330 #if DEC_UNROLL == NONE
 331     {   aes_32t i;
 332
 333         for(i = 0; i < (11 * N_COLS - 1) / 4; ++i)
 334             ke4(cx->ks, i);
 335 #if !(DEC_ROUND == NO_TABLES)
 336         for(i = N_COLS; i < 10 * N_COLS; ++i)
 337             cx->ks[i] = inv_mcol(cx->ks[i]);
 338 #endif
 339     }
 340 #else
 341     kdf4(cx->ks, 0);  kd4(cx->ks, 1);
 342      kd4(cx->ks, 2);  kd4(cx->ks, 3);
 343      kd4(cx->ks, 4);  kd4(cx->ks, 5);
 344      kd4(cx->ks, 6);  kd4(cx->ks, 7);
 345      kd4(cx->ks, 8); kdl4(cx->ks, 9);
 346 #endif
 347
 348     /* cx->ks[45] ^ cx->ks[52] ^ cx->ks[53] is zero for a 256 bit       */
 349     /* key and must be non-zero for 128 and 192 bits keys   */
 350     cx->ks[53] = cx->ks[45] = 0;
 351     cx->ks[52] = 10;
 352 #ifdef AES_ERR_CHK
 353     return aes_good;
 354 #endif
 355 }
 356
 357 #endif
 358
 359 #if defined(AES_192) || defined(AES_VAR)
 360
 361 aes_rval aes_decrypt_key192(const void *in_key, aes_decrypt_ctx cx[1])
 362 {   aes_32t    ss[7];
 363 #ifdef  d_vars
 364         d_vars;
 365 #endif
 366     cx->ks[0] = ss[0] = word_in(in_key, 0);
 367     cx->ks[1] = ss[1] = word_in(in_key, 1);
 368     cx->ks[2] = ss[2] = word_in(in_key, 2);
 369     cx->ks[3] = ss[3] = word_in(in_key, 3);
 370
 371 #if DEC_UNROLL == NONE
 372     cx->ks[4] = ss[4] = word_in(in_key, 4);
 373     cx->ks[5] = ss[5] = word_in(in_key, 5);
 374     {   aes_32t i;
 375
 376         for(i = 0; i < (13 * N_COLS - 1) / 6; ++i)
 377             ke6(cx->ks, i);
 378 #if !(DEC_ROUND == NO_TABLES)
 379         for(i = N_COLS; i < 12 * N_COLS; ++i)
 380             cx->ks[i] = inv_mcol(cx->ks[i]);
 381 #endif
 382     }
 383 #else
 384     cx->ks[4] = ff(ss[4] = word_in(in_key, 4));
 385     cx->ks[5] = ff(ss[5] = word_in(in_key, 5));
 386     kdf6(cx->ks, 0); kd6(cx->ks, 1);
 387     kd6(cx->ks, 2);  kd6(cx->ks, 3);
 388     kd6(cx->ks, 4);  kd6(cx->ks, 5);
 389     kd6(cx->ks, 6); kdl6(cx->ks, 7);
 390 #endif
 391
 392     /* cx->ks[45] ^ cx->ks[52] ^ cx->ks[53] is zero for a 256 bit       */
 393     /* key and must be non-zero for 128 and 192 bits keys   */
 394     cx->ks[53] = cx->ks[45];
 395     cx->ks[52] = 12;
 396 #ifdef AES_ERR_CHK
 397     return aes_good;
 398 #endif
 399 }
 400
 401 #endif
 402
 403 #if defined(AES_256) || defined(AES_VAR)
 404
 405 aes_rval aes_decrypt_key256(const void *in_key, aes_decrypt_ctx cx[1])
 406 {   aes_32t    ss[8];
 407 #ifdef  d_vars
 408         d_vars;
 409 #endif
 410     cx->ks[0] = ss[0] = word_in(in_key, 0);
 411     cx->ks[1] = ss[1] = word_in(in_key, 1);
 412     cx->ks[2] = ss[2] = word_in(in_key, 2);
 413     cx->ks[3] = ss[3] = word_in(in_key, 3);
 414
 415 #if DEC_UNROLL == NONE
 416     cx->ks[4] = ss[4] = word_in(in_key, 4);
 417     cx->ks[5] = ss[5] = word_in(in_key, 5);
 418     cx->ks[6] = ss[6] = word_in(in_key, 6);
 419     cx->ks[7] = ss[7] = word_in(in_key, 7);
 420     {   aes_32t i;
 421
 422         for(i = 0; i < (15 * N_COLS - 1) / 8; ++i)
 423             ke8(cx->ks,  i);
 424 #if !(DEC_ROUND == NO_TABLES)
 425         for(i = N_COLS; i < 14 * N_COLS; ++i)
 426             cx->ks[i] = inv_mcol(cx->ks[i]);
 427 #endif
 428     }
 429 #else
 430     cx->ks[4] = ff(ss[4] = word_in(in_key, 4));
 431     cx->ks[5] = ff(ss[5] = word_in(in_key, 5));
 432     cx->ks[6] = ff(ss[6] = word_in(in_key, 6));
 433     cx->ks[7] = ff(ss[7] = word_in(in_key, 7));
 434     kdf8(cx->ks, 0); kd8(cx->ks, 1);
 435     kd8(cx->ks, 2);  kd8(cx->ks, 3);
 436     kd8(cx->ks, 4);  kd8(cx->ks, 5);
 437     kdl8(cx->ks, 6);
 438 #endif
 439 #ifdef AES_ERR_CHK
 440     return aes_good;
 441 #endif
 442 }
 443
 444 #endif
 445
 446 #if defined(AES_VAR)
 447
 448 aes_rval aes_decrypt_key(const void *in_key, int key_len, aes_decrypt_ctx cx[1])
 449 {
 450     switch(key_len)
 451     {
 452 #ifdef AES_ERR_CHK
 453     case 16: case 128: return aes_decrypt_key128(in_key, cx);
 454     case 24: case 192: return aes_decrypt_key192(in_key, cx);
 455     case 32: case 256: return aes_decrypt_key256(in_key, cx);
 456     default: return aes_error;
 457 #else
 458     case 16: case 128: aes_decrypt_key128(in_key, cx); return;
 459     case 24: case 192: aes_decrypt_key192(in_key, cx); return;
 460     case 32: case 256: aes_decrypt_key256(in_key, cx); return;
 461 #endif
 462     }
 463 }
 464
 465 #endif
 466
 467 #endif
 468
 469 #endif /* !HAVE_CRYPTO */
 470
 471 #if defined(__cplusplus)
 472 }
 473 #endif