mirror of
https://github.com/espressif/esp-idf.git
synced 2025-11-10 12:02:05 +01:00
ad7cb5f5c1
This commit add following crypto changes 1. Update current crypto code with upstream supplicant code 2. Add a proper porting layer to use mbedtls APIs for all the crypto operations used by supplicant. Internal crypto will be used when USE_MBEDLTS flag is disabled in supplicant's menuconfig. This commit also removes the clutter in crypto files due to partial porting of some APIs to mbedtls, all the code from those files have been removed and rewritten in a generic way, this is inspired from current upstream code. This also reduces the lib size significantly, supplicant's lib size reduces around ~567kb after this change(NB: lib size doesn't indicate reduction in final bin size).
327 lines
6.8 KiB
C
327 lines
6.8 KiB
C
/*
|
|
* Crypto wrapper for internal crypto implementation
|
|
* Copyright (c) 2006-2011, Jouni Malinen <j@w1.fi>
|
|
*
|
|
* This software may be distributed under the terms of the BSD license.
|
|
* See README for more details.
|
|
*/
|
|
|
|
#include "includes.h"
|
|
|
|
#include "common.h"
|
|
#include "crypto.h"
|
|
#include "sha256_i.h"
|
|
#include "sha1_i.h"
|
|
#include "md5_i.h"
|
|
|
|
struct crypto_hash {
|
|
enum crypto_hash_alg alg;
|
|
union {
|
|
struct MD5Context md5;
|
|
struct SHA1Context sha1;
|
|
#ifdef CONFIG_SHA256
|
|
struct sha256_state sha256;
|
|
#endif /* CONFIG_SHA256 */
|
|
#ifdef CONFIG_INTERNAL_SHA384
|
|
struct sha384_state sha384;
|
|
#endif /* CONFIG_INTERNAL_SHA384 */
|
|
#ifdef CONFIG_INTERNAL_SHA512
|
|
struct sha512_state sha512;
|
|
#endif /* CONFIG_INTERNAL_SHA512 */
|
|
} u;
|
|
u8 key[64];
|
|
size_t key_len;
|
|
};
|
|
|
|
|
|
struct crypto_hash * crypto_hash_init(enum crypto_hash_alg alg, const u8 *key,
|
|
size_t key_len)
|
|
{
|
|
struct crypto_hash *ctx;
|
|
u8 k_pad[64];
|
|
u8 tk[32];
|
|
size_t i;
|
|
|
|
ctx = os_zalloc(sizeof(*ctx));
|
|
if (ctx == NULL)
|
|
return NULL;
|
|
|
|
ctx->alg = alg;
|
|
|
|
switch (alg) {
|
|
case CRYPTO_HASH_ALG_MD5:
|
|
MD5Init(&ctx->u.md5);
|
|
break;
|
|
case CRYPTO_HASH_ALG_SHA1:
|
|
SHA1Init(&ctx->u.sha1);
|
|
break;
|
|
#ifdef CONFIG_SHA256
|
|
case CRYPTO_HASH_ALG_SHA256:
|
|
sha256_init(&ctx->u.sha256);
|
|
break;
|
|
#endif /* CONFIG_SHA256 */
|
|
#ifdef CONFIG_INTERNAL_SHA384
|
|
case CRYPTO_HASH_ALG_SHA384:
|
|
sha384_init(&ctx->u.sha384);
|
|
break;
|
|
#endif /* CONFIG_INTERNAL_SHA384 */
|
|
#ifdef CONFIG_INTERNAL_SHA512
|
|
case CRYPTO_HASH_ALG_SHA512:
|
|
sha512_init(&ctx->u.sha512);
|
|
break;
|
|
#endif /* CONFIG_INTERNAL_SHA512 */
|
|
case CRYPTO_HASH_ALG_HMAC_MD5:
|
|
if (key_len > sizeof(k_pad)) {
|
|
MD5Init(&ctx->u.md5);
|
|
MD5Update(&ctx->u.md5, key, key_len);
|
|
MD5Final(tk, &ctx->u.md5);
|
|
key = tk;
|
|
key_len = 16;
|
|
}
|
|
os_memcpy(ctx->key, key, key_len);
|
|
ctx->key_len = key_len;
|
|
|
|
os_memcpy(k_pad, key, key_len);
|
|
if (key_len < sizeof(k_pad))
|
|
os_memset(k_pad + key_len, 0, sizeof(k_pad) - key_len);
|
|
for (i = 0; i < sizeof(k_pad); i++)
|
|
k_pad[i] ^= 0x36;
|
|
MD5Init(&ctx->u.md5);
|
|
MD5Update(&ctx->u.md5, k_pad, sizeof(k_pad));
|
|
break;
|
|
case CRYPTO_HASH_ALG_HMAC_SHA1:
|
|
if (key_len > sizeof(k_pad)) {
|
|
SHA1Init(&ctx->u.sha1);
|
|
SHA1Update(&ctx->u.sha1, key, key_len);
|
|
SHA1Final(tk, &ctx->u.sha1);
|
|
key = tk;
|
|
key_len = 20;
|
|
}
|
|
os_memcpy(ctx->key, key, key_len);
|
|
ctx->key_len = key_len;
|
|
|
|
os_memcpy(k_pad, key, key_len);
|
|
if (key_len < sizeof(k_pad))
|
|
os_memset(k_pad + key_len, 0, sizeof(k_pad) - key_len);
|
|
for (i = 0; i < sizeof(k_pad); i++)
|
|
k_pad[i] ^= 0x36;
|
|
SHA1Init(&ctx->u.sha1);
|
|
SHA1Update(&ctx->u.sha1, k_pad, sizeof(k_pad));
|
|
break;
|
|
#ifdef CONFIG_SHA256
|
|
case CRYPTO_HASH_ALG_HMAC_SHA256:
|
|
if (key_len > sizeof(k_pad)) {
|
|
sha256_init(&ctx->u.sha256);
|
|
sha256_process(&ctx->u.sha256, key, key_len);
|
|
sha256_done(&ctx->u.sha256, tk);
|
|
key = tk;
|
|
key_len = 32;
|
|
}
|
|
os_memcpy(ctx->key, key, key_len);
|
|
ctx->key_len = key_len;
|
|
|
|
os_memcpy(k_pad, key, key_len);
|
|
if (key_len < sizeof(k_pad))
|
|
os_memset(k_pad + key_len, 0, sizeof(k_pad) - key_len);
|
|
for (i = 0; i < sizeof(k_pad); i++)
|
|
k_pad[i] ^= 0x36;
|
|
sha256_init(&ctx->u.sha256);
|
|
sha256_process(&ctx->u.sha256, k_pad, sizeof(k_pad));
|
|
break;
|
|
#endif /* CONFIG_SHA256 */
|
|
default:
|
|
os_free(ctx);
|
|
return NULL;
|
|
}
|
|
|
|
return ctx;
|
|
}
|
|
|
|
|
|
void crypto_hash_update(struct crypto_hash *ctx, const u8 *data, size_t len)
|
|
{
|
|
if (ctx == NULL)
|
|
return;
|
|
|
|
switch (ctx->alg) {
|
|
case CRYPTO_HASH_ALG_MD5:
|
|
case CRYPTO_HASH_ALG_HMAC_MD5:
|
|
MD5Update(&ctx->u.md5, data, len);
|
|
break;
|
|
case CRYPTO_HASH_ALG_SHA1:
|
|
case CRYPTO_HASH_ALG_HMAC_SHA1:
|
|
SHA1Update(&ctx->u.sha1, data, len);
|
|
break;
|
|
#ifdef CONFIG_SHA256
|
|
case CRYPTO_HASH_ALG_SHA256:
|
|
case CRYPTO_HASH_ALG_HMAC_SHA256:
|
|
sha256_process(&ctx->u.sha256, data, len);
|
|
break;
|
|
#endif /* CONFIG_SHA256 */
|
|
#ifdef CONFIG_INTERNAL_SHA384
|
|
case CRYPTO_HASH_ALG_SHA384:
|
|
sha384_process(&ctx->u.sha384, data, len);
|
|
break;
|
|
#endif /* CONFIG_INTERNAL_SHA384 */
|
|
#ifdef CONFIG_INTERNAL_SHA512
|
|
case CRYPTO_HASH_ALG_SHA512:
|
|
sha512_process(&ctx->u.sha512, data, len);
|
|
break;
|
|
#endif /* CONFIG_INTERNAL_SHA512 */
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
int crypto_hash_finish(struct crypto_hash *ctx, u8 *mac, size_t *len)
|
|
{
|
|
u8 k_pad[64];
|
|
size_t i;
|
|
|
|
if (ctx == NULL)
|
|
return -2;
|
|
|
|
if (mac == NULL || len == NULL) {
|
|
os_free(ctx);
|
|
return 0;
|
|
}
|
|
|
|
switch (ctx->alg) {
|
|
case CRYPTO_HASH_ALG_MD5:
|
|
if (*len < 16) {
|
|
*len = 16;
|
|
os_free(ctx);
|
|
return -1;
|
|
}
|
|
*len = 16;
|
|
MD5Final(mac, &ctx->u.md5);
|
|
break;
|
|
case CRYPTO_HASH_ALG_SHA1:
|
|
if (*len < 20) {
|
|
*len = 20;
|
|
os_free(ctx);
|
|
return -1;
|
|
}
|
|
*len = 20;
|
|
SHA1Final(mac, &ctx->u.sha1);
|
|
break;
|
|
#ifdef CONFIG_SHA256
|
|
case CRYPTO_HASH_ALG_SHA256:
|
|
if (*len < 32) {
|
|
*len = 32;
|
|
os_free(ctx);
|
|
return -1;
|
|
}
|
|
*len = 32;
|
|
sha256_done(&ctx->u.sha256, mac);
|
|
break;
|
|
#endif /* CONFIG_SHA256 */
|
|
#ifdef CONFIG_INTERNAL_SHA384
|
|
case CRYPTO_HASH_ALG_SHA384:
|
|
if (*len < 48) {
|
|
*len = 48;
|
|
os_free(ctx);
|
|
return -1;
|
|
}
|
|
*len = 48;
|
|
sha384_done(&ctx->u.sha384, mac);
|
|
break;
|
|
#endif /* CONFIG_INTERNAL_SHA384 */
|
|
#ifdef CONFIG_INTERNAL_SHA512
|
|
case CRYPTO_HASH_ALG_SHA512:
|
|
if (*len < 64) {
|
|
*len = 64;
|
|
os_free(ctx);
|
|
return -1;
|
|
}
|
|
*len = 64;
|
|
sha512_done(&ctx->u.sha512, mac);
|
|
break;
|
|
#endif /* CONFIG_INTERNAL_SHA512 */
|
|
case CRYPTO_HASH_ALG_HMAC_MD5:
|
|
if (*len < 16) {
|
|
*len = 16;
|
|
os_free(ctx);
|
|
return -1;
|
|
}
|
|
*len = 16;
|
|
|
|
MD5Final(mac, &ctx->u.md5);
|
|
|
|
os_memcpy(k_pad, ctx->key, ctx->key_len);
|
|
os_memset(k_pad + ctx->key_len, 0,
|
|
sizeof(k_pad) - ctx->key_len);
|
|
for (i = 0; i < sizeof(k_pad); i++)
|
|
k_pad[i] ^= 0x5c;
|
|
MD5Init(&ctx->u.md5);
|
|
MD5Update(&ctx->u.md5, k_pad, sizeof(k_pad));
|
|
MD5Update(&ctx->u.md5, mac, 16);
|
|
MD5Final(mac, &ctx->u.md5);
|
|
break;
|
|
case CRYPTO_HASH_ALG_HMAC_SHA1:
|
|
if (*len < 20) {
|
|
*len = 20;
|
|
os_free(ctx);
|
|
return -1;
|
|
}
|
|
*len = 20;
|
|
|
|
SHA1Final(mac, &ctx->u.sha1);
|
|
|
|
os_memcpy(k_pad, ctx->key, ctx->key_len);
|
|
os_memset(k_pad + ctx->key_len, 0,
|
|
sizeof(k_pad) - ctx->key_len);
|
|
for (i = 0; i < sizeof(k_pad); i++)
|
|
k_pad[i] ^= 0x5c;
|
|
SHA1Init(&ctx->u.sha1);
|
|
SHA1Update(&ctx->u.sha1, k_pad, sizeof(k_pad));
|
|
SHA1Update(&ctx->u.sha1, mac, 20);
|
|
SHA1Final(mac, &ctx->u.sha1);
|
|
break;
|
|
#ifdef CONFIG_SHA256
|
|
case CRYPTO_HASH_ALG_HMAC_SHA256:
|
|
if (*len < 32) {
|
|
*len = 32;
|
|
os_free(ctx);
|
|
return -1;
|
|
}
|
|
*len = 32;
|
|
|
|
sha256_done(&ctx->u.sha256, mac);
|
|
|
|
os_memcpy(k_pad, ctx->key, ctx->key_len);
|
|
os_memset(k_pad + ctx->key_len, 0,
|
|
sizeof(k_pad) - ctx->key_len);
|
|
for (i = 0; i < sizeof(k_pad); i++)
|
|
k_pad[i] ^= 0x5c;
|
|
sha256_init(&ctx->u.sha256);
|
|
sha256_process(&ctx->u.sha256, k_pad, sizeof(k_pad));
|
|
sha256_process(&ctx->u.sha256, mac, 32);
|
|
sha256_done(&ctx->u.sha256, mac);
|
|
break;
|
|
#endif /* CONFIG_SHA256 */
|
|
default:
|
|
os_free(ctx);
|
|
return -1;
|
|
}
|
|
|
|
os_free(ctx);
|
|
|
|
if (TEST_FAIL())
|
|
return -1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int crypto_global_init(void)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
|
|
void crypto_global_deinit(void)
|
|
{
|
|
}
|