contrib/hostapd/src/crypto/crypto_internal-cipher.c

   1 /*
   2  * Crypto wrapper for internal crypto implementation - Cipher wrappers
   3  * Copyright (c) 2006-2009, Jouni Malinen <j@w1.fi>
   4  *
   5  * This software may be distributed under the terms of the BSD license.
   6  * See README for more details.
   7  */
   8
   9 #include "includes.h"
  10
  11 #include "common.h"
  12 #include "crypto.h"
  13 #include "aes.h"
  14 #include "des_i.h"
  15
  16
  17 struct crypto_cipher {
  18         enum crypto_cipher_alg alg;
  19         union {
  20                 struct {
  21                         size_t used_bytes;
  22                         u8 key[16];
  23                         size_t keylen;
  24                 } rc4;
  25                 struct {
  26                         u8 cbc[32];
  27                         void *ctx_enc;
  28                         void *ctx_dec;
  29                 } aes;
  30                 struct {
  31                         struct des3_key_s key;
  32                         u8 cbc[8];
  33                 } des3;
  34                 struct {
  35                         u32 ek[32];
  36                         u32 dk[32];
  37                         u8 cbc[8];
  38                 } des;
  39         } u;
  40 };
  41
  42
  43 struct crypto_cipher * crypto_cipher_init(enum crypto_cipher_alg alg,
  44                                           const u8 *iv, const u8 *key,
  45                                           size_t key_len)
  46 {
  47         struct crypto_cipher *ctx;
  48
  49         ctx = os_zalloc(sizeof(*ctx));
  50         if (ctx == NULL)
  51                 return NULL;
  52
  53         ctx->alg = alg;
  54
  55         switch (alg) {
  56         case CRYPTO_CIPHER_ALG_RC4:
  57                 if (key_len > sizeof(ctx->u.rc4.key)) {
  58                         os_free(ctx);
  59                         return NULL;
  60                 }
  61                 ctx->u.rc4.keylen = key_len;
  62                 os_memcpy(ctx->u.rc4.key, key, key_len);
  63                 break;
  64         case CRYPTO_CIPHER_ALG_AES:
  65                 ctx->u.aes.ctx_enc = aes_encrypt_init(key, key_len);
  66                 if (ctx->u.aes.ctx_enc == NULL) {
  67                         os_free(ctx);
  68                         return NULL;
  69                 }
  70                 ctx->u.aes.ctx_dec = aes_decrypt_init(key, key_len);
  71                 if (ctx->u.aes.ctx_dec == NULL) {
  72                         aes_encrypt_deinit(ctx->u.aes.ctx_enc);
  73                         os_free(ctx);
  74                         return NULL;
  75                 }
  76                 os_memcpy(ctx->u.aes.cbc, iv, AES_BLOCK_SIZE);
  77                 break;
  78         case CRYPTO_CIPHER_ALG_3DES:
  79                 if (key_len != 24) {
  80                         os_free(ctx);
  81                         return NULL;
  82                 }
  83                 des3_key_setup(key, &ctx->u.des3.key);
  84                 os_memcpy(ctx->u.des3.cbc, iv, 8);
  85                 break;
  86         case CRYPTO_CIPHER_ALG_DES:
  87                 if (key_len != 8) {
  88                         os_free(ctx);
  89                         return NULL;
  90                 }
  91                 des_key_setup(key, ctx->u.des.ek, ctx->u.des.dk);
  92                 os_memcpy(ctx->u.des.cbc, iv, 8);
  93                 break;
  94         default:
  95                 os_free(ctx);
  96                 return NULL;
  97         }
  98
  99         return ctx;
 100 }
 101
 102
 103 int crypto_cipher_encrypt(struct crypto_cipher *ctx, const u8 *plain,
 104                           u8 *crypt, size_t len)
 105 {
 106         size_t i, j, blocks;
 107
 108         switch (ctx->alg) {
 109         case CRYPTO_CIPHER_ALG_RC4:
 110                 if (plain != crypt)
 111                         os_memcpy(crypt, plain, len);
 112                 rc4_skip(ctx->u.rc4.key, ctx->u.rc4.keylen,
 113                          ctx->u.rc4.used_bytes, crypt, len);
 114                 ctx->u.rc4.used_bytes += len;
 115                 break;
 116         case CRYPTO_CIPHER_ALG_AES:
 117                 if (len % AES_BLOCK_SIZE)
 118                         return -1;
 119                 blocks = len / AES_BLOCK_SIZE;
 120                 for (i = 0; i < blocks; i++) {
 121                         for (j = 0; j < AES_BLOCK_SIZE; j++)
 122                                 ctx->u.aes.cbc[j] ^= plain[j];
 123                         aes_encrypt(ctx->u.aes.ctx_enc, ctx->u.aes.cbc,
 124                                     ctx->u.aes.cbc);
 125                         os_memcpy(crypt, ctx->u.aes.cbc, AES_BLOCK_SIZE);
 126                         plain += AES_BLOCK_SIZE;
 127                         crypt += AES_BLOCK_SIZE;
 128                 }
 129                 break;
 130         case CRYPTO_CIPHER_ALG_3DES:
 131                 if (len % 8)
 132                         return -1;
 133                 blocks = len / 8;
 134                 for (i = 0; i < blocks; i++) {
 135                         for (j = 0; j < 8; j++)
 136                                 ctx->u.des3.cbc[j] ^= plain[j];
 137                         des3_encrypt(ctx->u.des3.cbc, &ctx->u.des3.key,
 138                                      ctx->u.des3.cbc);
 139                         os_memcpy(crypt, ctx->u.des3.cbc, 8);
 140                         plain += 8;
 141                         crypt += 8;
 142                 }
 143                 break;
 144         case CRYPTO_CIPHER_ALG_DES:
 145                 if (len % 8)
 146                         return -1;
 147                 blocks = len / 8;
 148                 for (i = 0; i < blocks; i++) {
 149                         for (j = 0; j < 8; j++)
 150                                 ctx->u.des3.cbc[j] ^= plain[j];
 151                         des_block_encrypt(ctx->u.des.cbc, ctx->u.des.ek,
 152                                           ctx->u.des.cbc);
 153                         os_memcpy(crypt, ctx->u.des.cbc, 8);
 154                         plain += 8;
 155                         crypt += 8;
 156                 }
 157                 break;
 158         default:
 159                 return -1;
 160         }
 161
 162         return 0;
 163 }
 164
 165
 166 int crypto_cipher_decrypt(struct crypto_cipher *ctx, const u8 *crypt,
 167                           u8 *plain, size_t len)
 168 {
 169         size_t i, j, blocks;
 170         u8 tmp[32];
 171
 172         switch (ctx->alg) {
 173         case CRYPTO_CIPHER_ALG_RC4:
 174                 if (plain != crypt)
 175                         os_memcpy(plain, crypt, len);
 176                 rc4_skip(ctx->u.rc4.key, ctx->u.rc4.keylen,
 177                          ctx->u.rc4.used_bytes, plain, len);
 178                 ctx->u.rc4.used_bytes += len;
 179                 break;
 180         case CRYPTO_CIPHER_ALG_AES:
 181                 if (len % AES_BLOCK_SIZE)
 182                         return -1;
 183                 blocks = len / AES_BLOCK_SIZE;
 184                 for (i = 0; i < blocks; i++) {
 185                         os_memcpy(tmp, crypt, AES_BLOCK_SIZE);
 186                         aes_decrypt(ctx->u.aes.ctx_dec, crypt, plain);
 187                         for (j = 0; j < AES_BLOCK_SIZE; j++)
 188                                 plain[j] ^= ctx->u.aes.cbc[j];
 189                         os_memcpy(ctx->u.aes.cbc, tmp, AES_BLOCK_SIZE);
 190                         plain += AES_BLOCK_SIZE;
 191                         crypt += AES_BLOCK_SIZE;
 192                 }
 193                 break;
 194         case CRYPTO_CIPHER_ALG_3DES:
 195                 if (len % 8)
 196                         return -1;
 197                 blocks = len / 8;
 198                 for (i = 0; i < blocks; i++) {
 199                         os_memcpy(tmp, crypt, 8);
 200                         des3_decrypt(crypt, &ctx->u.des3.key, plain);
 201                         for (j = 0; j < 8; j++)
 202                                 plain[j] ^= ctx->u.des3.cbc[j];
 203                         os_memcpy(ctx->u.des3.cbc, tmp, 8);
 204                         plain += 8;
 205                         crypt += 8;
 206                 }
 207                 break;
 208         case CRYPTO_CIPHER_ALG_DES:
 209                 if (len % 8)
 210                         return -1;
 211                 blocks = len / 8;
 212                 for (i = 0; i < blocks; i++) {
 213                         os_memcpy(tmp, crypt, 8);
 214                         des_block_decrypt(crypt, ctx->u.des.dk, plain);
 215                         for (j = 0; j < 8; j++)
 216                                 plain[j] ^= ctx->u.des.cbc[j];
 217                         os_memcpy(ctx->u.des.cbc, tmp, 8);
 218                         plain += 8;
 219                         crypt += 8;
 220                 }
 221                 break;
 222         default:
 223                 return -1;
 224         }
 225
 226         return 0;
 227 }
 228
 229
 230 void crypto_cipher_deinit(struct crypto_cipher *ctx)
 231 {
 232         switch (ctx->alg) {
 233         case CRYPTO_CIPHER_ALG_AES:
 234                 aes_encrypt_deinit(ctx->u.aes.ctx_enc);
 235                 aes_decrypt_deinit(ctx->u.aes.ctx_dec);
 236                 break;
 237         case CRYPTO_CIPHER_ALG_3DES:
 238                 break;
 239         default:
 240                 break;
 241         }
 242         os_free(ctx);
 243 }