contrib/wpa_supplicant/crypto.c

   1 /*
   2  * WPA Supplicant / wrapper functions for libcrypto
   3  * Copyright (c) 2004-2005, Jouni Malinen <jkmaline@cc.hut.fi>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2 as
   7  * published by the Free Software Foundation.
   8  *
   9  * Alternatively, this software may be distributed under the terms of BSD
  10  * license.
  11  *
  12  * See README and COPYING for more details.
  13  */
  14
  15 #include <string.h>
  16 #include <sys/types.h>
  17
  18 #include <openssl/md4.h>
  19 #include <openssl/md5.h>
  20 #include <openssl/sha.h>
  21 #include <openssl/des.h>
  22 #include <openssl/aes.h>
  23
  24 #include "common.h"
  25 #include "crypto.h"
  26
  27 #if OPENSSL_VERSION_NUMBER < 0x00907000
  28 #define DES_key_schedule des_key_schedule
  29 #define DES_cblock des_cblock
  30 #define DES_set_key(key, schedule) des_set_key((key), *(schedule))
  31 #define DES_ecb_encrypt(input, output, ks, enc) \
  32         des_ecb_encrypt((input), (output), *(ks), (enc))
  33 #endif /* openssl < 0.9.7 */
  34
  35
  36 void md4_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac)
  37 {
  38         MD4_CTX ctx;
  39         int i;
  40
  41         MD4_Init(&ctx);
  42         for (i = 0; i < num_elem; i++)
  43                 MD4_Update(&ctx, addr[i], len[i]);
  44         MD4_Final(mac, &ctx);
  45 }
  46
  47
  48 void des_encrypt(const u8 *clear, const u8 *key, u8 *cypher)
  49 {
  50         u8 pkey[8], next, tmp;
  51         int i;
  52         DES_key_schedule ks;
  53
  54         /* Add parity bits to the key */
  55         next = 0;
  56         for (i = 0; i < 7; i++) {
  57                 tmp = key[i];
  58                 pkey[i] = (tmp >> i) | next | 1;
  59                 next = tmp << (7 - i);
  60         }
  61         pkey[i] = next | 1;
  62
  63         DES_set_key(&pkey, &ks);
  64         DES_ecb_encrypt((DES_cblock *) clear, (DES_cblock *) cypher, &ks,
  65                         DES_ENCRYPT);
  66 }
  67
  68
  69 #ifdef EAP_TLS_FUNCS
  70 void md5_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac)
  71 {
  72         MD5_CTX ctx;
  73         int i;
  74
  75         MD5_Init(&ctx);
  76         for (i = 0; i < num_elem; i++)
  77                 MD5_Update(&ctx, addr[i], len[i]);
  78         MD5_Final(mac, &ctx);
  79 }
  80
  81
  82 void sha1_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac)
  83 {
  84         SHA_CTX ctx;
  85         int i;
  86
  87         SHA1_Init(&ctx);
  88         for (i = 0; i < num_elem; i++)
  89                 SHA1_Update(&ctx, addr[i], len[i]);
  90         SHA1_Final(mac, &ctx);
  91 }
  92
  93
  94 void sha1_transform(u8 *state, const u8 data[64])
  95 {
  96         SHA_CTX context;
  97         memset(&context, 0, sizeof(context));
  98         memcpy(&context.h0, state, 5 * 4);
  99         SHA1_Transform(&context, data);
 100         memcpy(state, &context.h0, 5 * 4);
 101 }
 102
 103
 104 void * aes_encrypt_init(const u8 *key, size_t len)
 105 {
 106         AES_KEY *ak;
 107         ak = malloc(sizeof(*ak));
 108         if (ak == NULL)
 109                 return NULL;
 110         if (AES_set_encrypt_key(key, 8 * len, ak) < 0) {
 111                 free(ak);
 112                 return NULL;
 113         }
 114         return ak;
 115 }
 116
 117
 118 void aes_encrypt(void *ctx, const u8 *plain, u8 *crypt)
 119 {
 120         AES_encrypt(plain, crypt, ctx);
 121 }
 122
 123
 124 void aes_encrypt_deinit(void *ctx)
 125 {
 126         free(ctx);
 127 }
 128
 129
 130 void * aes_decrypt_init(const u8 *key, size_t len)
 131 {
 132         AES_KEY *ak;
 133         ak = malloc(sizeof(*ak));
 134         if (ak == NULL)
 135                 return NULL;
 136         if (AES_set_decrypt_key(key, 8 * len, ak) < 0) {
 137                 free(ak);
 138                 return NULL;
 139         }
 140         return ak;
 141 }
 142
 143
 144 void aes_decrypt(void *ctx, const u8 *crypt, u8 *plain)
 145 {
 146         AES_decrypt(crypt, plain, ctx);
 147 }
 148
 149
 150 void aes_decrypt_deinit(void *ctx)
 151 {
 152         free(ctx);
 153 }
 154 #endif /* EAP_TLS_FUNCS */