/* * EAP server/peer: EAP-pwd shared routines * Copyright (c) 2010, Dan Harkins * * This software may be distributed under the terms of the BSD license. * See README for more details. */ #include "includes.h" #include "common.h" #include "utils/const_time.h" #include "common/dragonfly.h" #include "crypto/sha256.h" #include "crypto/crypto.h" #include "eap_defs.h" #include "eap_pwd_common.h" #define MAX_ECC_PRIME_LEN 66 /* The random function H(x) = HMAC-SHA256(0^32, x) */ struct crypto_hash * eap_pwd_h_init(void) { u8 allzero[SHA256_MAC_LEN]; os_memset(allzero, 0, SHA256_MAC_LEN); return crypto_hash_init(CRYPTO_HASH_ALG_HMAC_SHA256, allzero, SHA256_MAC_LEN); } void eap_pwd_h_update(struct crypto_hash *hash, const u8 *data, size_t len) { crypto_hash_update(hash, data, len); } void eap_pwd_h_final(struct crypto_hash *hash, u8 *digest) { size_t len = SHA256_MAC_LEN; crypto_hash_finish(hash, digest, &len); } /* a counter-based KDF based on NIST SP800-108 */ static int eap_pwd_kdf(const u8 *key, size_t keylen, const u8 *label, size_t labellen, u8 *result, size_t resultbitlen) { struct crypto_hash *hash; u8 digest[SHA256_MAC_LEN]; u16 i, ctr, L; size_t resultbytelen, len = 0, mdlen; resultbytelen = (resultbitlen + 7) / 8; ctr = 0; L = htons(resultbitlen); while (len < resultbytelen) { ctr++; i = htons(ctr); hash = crypto_hash_init(CRYPTO_HASH_ALG_HMAC_SHA256, key, keylen); if (hash == NULL) return -1; if (ctr > 1) crypto_hash_update(hash, digest, SHA256_MAC_LEN); crypto_hash_update(hash, (u8 *) &i, sizeof(u16)); crypto_hash_update(hash, label, labellen); crypto_hash_update(hash, (u8 *) &L, sizeof(u16)); mdlen = SHA256_MAC_LEN; if (crypto_hash_finish(hash, digest, &mdlen) < 0) return -1; if ((len + mdlen) > resultbytelen) os_memcpy(result + len, digest, resultbytelen - len); else os_memcpy(result + len, digest, mdlen); len += mdlen; } /* since we're expanding to a bit length, mask off the excess */ if (resultbitlen % 8) { u8 mask = 0xff; mask <<= (8 - (resultbitlen % 8)); result[resultbytelen - 1] &= mask; } return 0; } EAP_PWD_group * get_eap_pwd_group(u16 num) { EAP_PWD_group *grp; if (!dragonfly_suitable_group(num, 1)) { wpa_printf(MSG_INFO, "EAP-pwd: unsuitable group %u", num); return NULL; } grp = os_zalloc(sizeof(EAP_PWD_group)); if (!grp) return NULL; grp->group = crypto_ec_init(num); if (!grp->group) { wpa_printf(MSG_INFO, "EAP-pwd: unable to create EC group"); os_free(grp); return NULL; } grp->group_num = num; wpa_printf(MSG_INFO, "EAP-pwd: provisioned group %d", num); return grp; } /* * compute a "random" secret point on an elliptic curve based * on the password and identities. */ int compute_password_element(EAP_PWD_group *grp, u16 num, const u8 *password, size_t password_len, const u8 *id_server, size_t id_server_len, const u8 *id_peer, size_t id_peer_len, const u8 *token) { struct crypto_bignum *qr = NULL, *qnr = NULL; u8 qr_bin[MAX_ECC_PRIME_LEN]; u8 qnr_bin[MAX_ECC_PRIME_LEN]; u8 qr_or_qnr_bin[MAX_ECC_PRIME_LEN]; u8 x_bin[MAX_ECC_PRIME_LEN]; u8 prime_bin[MAX_ECC_PRIME_LEN]; struct crypto_bignum *tmp2 = NULL; struct crypto_hash *hash; unsigned char pwe_digest[SHA256_MAC_LEN], *prfbuf = NULL, ctr; int ret = 0, res; u8 found = 0; /* 0 (false) or 0xff (true) to be used as const_time_* * mask */ size_t primebytelen = 0, primebitlen; struct crypto_bignum *x_candidate = NULL; const struct crypto_bignum *prime; u8 found_ctr = 0, is_odd = 0; int cmp_prime; unsigned int in_range; if (grp->pwe) return -1; os_memset(x_bin, 0, sizeof(x_bin)); prime = crypto_ec_get_prime(grp->group); primebitlen = crypto_ec_prime_len_bits(grp->group); primebytelen = crypto_ec_prime_len(grp->group); if (crypto_bignum_to_bin(prime, prime_bin, sizeof(prime_bin), primebytelen) < 0) return -1; grp->pwe = crypto_ec_point_init(grp->group); if (!grp->pwe) { wpa_printf(MSG_INFO, "EAP-pwd: unable to create bignums"); goto fail; } if ((prfbuf = os_malloc(primebytelen)) == NULL) { wpa_printf(MSG_INFO, "EAP-pwd: unable to malloc space for prf " "buffer"); goto fail; } /* get a random quadratic residue and nonresidue */ if (dragonfly_get_random_qr_qnr(prime, &qr, &qnr) < 0 || crypto_bignum_to_bin(qr, qr_bin, sizeof(qr_bin), primebytelen) < 0 || crypto_bignum_to_bin(qnr, qnr_bin, sizeof(qnr_bin), primebytelen) < 0) goto fail; os_memset(prfbuf, 0, primebytelen); ctr = 0; /* * Run through the hunting-and-pecking loop 40 times to mask the time * necessary to find PWE. The odds of PWE not being found in 40 loops is * roughly 1 in 1 trillion. */ while (ctr < 40) { ctr++; /* * compute counter-mode password value and stretch to prime * pwd-seed = H(token | peer-id | server-id | password | * counter) */ hash = eap_pwd_h_init(); if (hash == NULL) goto fail; eap_pwd_h_update(hash, token, sizeof(u32)); eap_pwd_h_update(hash, id_peer, id_peer_len); eap_pwd_h_update(hash, id_server, id_server_len); eap_pwd_h_update(hash, password, password_len); eap_pwd_h_update(hash, &ctr, sizeof(ctr)); eap_pwd_h_final(hash, pwe_digest); is_odd = const_time_select_u8( found, is_odd, pwe_digest[SHA256_MAC_LEN - 1] & 0x01); if (eap_pwd_kdf(pwe_digest, SHA256_MAC_LEN, (u8 *) "EAP-pwd Hunting And Pecking", os_strlen("EAP-pwd Hunting And Pecking"), prfbuf, primebitlen) < 0) goto fail; if (primebitlen % 8) buf_shift_right(prfbuf, primebytelen, 8 - primebitlen % 8); cmp_prime = const_time_memcmp(prfbuf, prime_bin, primebytelen); /* Create a const_time mask for selection based on prf result * being smaller than prime. */ in_range = const_time_fill_msb((unsigned int) cmp_prime); /* The algorithm description would skip the next steps if * cmp_prime >= 0, but go through them regardless to minimize * externally observable differences in behavior. */ crypto_bignum_deinit(x_candidate, 1); x_candidate = crypto_bignum_init_set(prfbuf, primebytelen); if (!x_candidate) { wpa_printf(MSG_INFO, "EAP-pwd: unable to create x_candidate"); goto fail; } wpa_hexdump_key(MSG_DEBUG, "EAP-pwd: x_candidate", prfbuf, primebytelen); const_time_select_bin(found, x_bin, prfbuf, primebytelen, x_bin); /* * compute y^2 using the equation of the curve * * y^2 = x^3 + ax + b */ crypto_bignum_deinit(tmp2, 1); tmp2 = crypto_ec_point_compute_y_sqr(grp->group, x_candidate); if (!tmp2) goto fail; res = dragonfly_is_quadratic_residue_blind(grp->group, qr_bin, qnr_bin, tmp2); if (res < 0) goto fail; found_ctr = const_time_select_u8(found, found_ctr, ctr); /* found is 0 or 0xff here and res is 0 or 1. Bitwise OR of them * (with res converted to 0/0xff and masked with prf being below * prime) handles this in constant time. */ found |= (res & in_range) * 0xff; } if (found == 0) { wpa_printf(MSG_INFO, "EAP-pwd: unable to find random point on curve for group %d, something's fishy", num); goto fail; } /* * We know x_candidate is a quadratic residue so set it here. */ crypto_bignum_deinit(x_candidate, 1); x_candidate = crypto_bignum_init_set(x_bin, primebytelen); if (!x_candidate || crypto_ec_point_solve_y_coord(grp->group, grp->pwe, x_candidate, is_odd) != 0) { wpa_printf(MSG_INFO, "EAP-pwd: Could not solve for y"); goto fail; } /* * If there's a solution to the equation then the point must be on the * curve so why check again explicitly? OpenSSL code says this is * required by X9.62. We're not X9.62 but it can't hurt just to be sure. */ if (!crypto_ec_point_is_on_curve(grp->group, grp->pwe)) { wpa_printf(MSG_INFO, "EAP-pwd: point is not on curve"); goto fail; } wpa_printf(MSG_DEBUG, "EAP-pwd: found a PWE in %02d tries", found_ctr); if (0) { fail: crypto_ec_point_deinit(grp->pwe, 1); grp->pwe = NULL; ret = 1; } /* cleanliness and order.... */ crypto_bignum_deinit(x_candidate, 1); crypto_bignum_deinit(tmp2, 1); crypto_bignum_deinit(qr, 1); crypto_bignum_deinit(qnr, 1); bin_clear_free(prfbuf, primebytelen); os_memset(qr_bin, 0, sizeof(qr_bin)); os_memset(qnr_bin, 0, sizeof(qnr_bin)); os_memset(qr_or_qnr_bin, 0, sizeof(qr_or_qnr_bin)); os_memset(pwe_digest, 0, sizeof(pwe_digest)); return ret; } int compute_keys(EAP_PWD_group *grp, const struct crypto_bignum *k, const struct crypto_bignum *peer_scalar, const struct crypto_bignum *server_scalar, const u8 *confirm_peer, const u8 *confirm_server, const u32 *ciphersuite, u8 *msk, u8 *emsk, u8 *session_id) { struct crypto_hash *hash; u8 mk[SHA256_MAC_LEN], *cruft; u8 msk_emsk[EAP_MSK_LEN + EAP_EMSK_LEN]; size_t prime_len, order_len; prime_len = crypto_ec_prime_len(grp->group); order_len = crypto_ec_order_len(grp->group); cruft = os_malloc(prime_len); if (!cruft) return -1; /* * first compute the session-id = TypeCode | H(ciphersuite | scal_p | * scal_s) */ session_id[0] = EAP_TYPE_PWD; hash = eap_pwd_h_init(); if (hash == NULL) { os_free(cruft); return -1; } eap_pwd_h_update(hash, (const u8 *) ciphersuite, sizeof(u32)); crypto_bignum_to_bin(peer_scalar, cruft, order_len, order_len); eap_pwd_h_update(hash, cruft, order_len); crypto_bignum_to_bin(server_scalar, cruft, order_len, order_len); eap_pwd_h_update(hash, cruft, order_len); eap_pwd_h_final(hash, &session_id[1]); /* then compute MK = H(k | confirm-peer | confirm-server) */ hash = eap_pwd_h_init(); if (hash == NULL) { os_free(cruft); return -1; } crypto_bignum_to_bin(k, cruft, prime_len, prime_len); eap_pwd_h_update(hash, cruft, prime_len); os_free(cruft); eap_pwd_h_update(hash, confirm_peer, SHA256_MAC_LEN); eap_pwd_h_update(hash, confirm_server, SHA256_MAC_LEN); eap_pwd_h_final(hash, mk); /* stretch the mk with the session-id to get MSK | EMSK */ if (eap_pwd_kdf(mk, SHA256_MAC_LEN, session_id, SHA256_MAC_LEN + 1, msk_emsk, (EAP_MSK_LEN + EAP_EMSK_LEN) * 8) < 0) { return -1; } os_memcpy(msk, msk_emsk, EAP_MSK_LEN); os_memcpy(emsk, msk_emsk + EAP_MSK_LEN, EAP_EMSK_LEN); return 1; } static int eap_pwd_element_coord_ok(const struct crypto_bignum *prime, const u8 *buf, size_t len) { struct crypto_bignum *val; int ok = 1; val = crypto_bignum_init_set(buf, len); if (!val || crypto_bignum_is_zero(val) || crypto_bignum_cmp(val, prime) >= 0) ok = 0; crypto_bignum_deinit(val, 0); return ok; } struct crypto_ec_point * eap_pwd_get_element(EAP_PWD_group *group, const u8 *buf) { struct crypto_ec_point *element; const struct crypto_bignum *prime; size_t prime_len; prime = crypto_ec_get_prime(group->group); prime_len = crypto_ec_prime_len(group->group); /* RFC 5931, 2.8.5.2.2: 0 < x,y < p */ if (!eap_pwd_element_coord_ok(prime, buf, prime_len) || !eap_pwd_element_coord_ok(prime, buf + prime_len, prime_len)) { wpa_printf(MSG_INFO, "EAP-pwd: Invalid coordinate in element"); return NULL; } element = crypto_ec_point_from_bin(group->group, buf); if (!element) { wpa_printf(MSG_INFO, "EAP-pwd: EC point from element failed"); return NULL; } /* RFC 5931, 2.8.5.2.2: on curve and not the point at infinity */ if (!crypto_ec_point_is_on_curve(group->group, element) || crypto_ec_point_is_at_infinity(group->group, element)) { wpa_printf(MSG_INFO, "EAP-pwd: Invalid element"); goto fail; } out: return element; fail: crypto_ec_point_deinit(element, 0); element = NULL; goto out; } struct crypto_bignum * eap_pwd_get_scalar(EAP_PWD_group *group, const u8 *buf) { struct crypto_bignum *scalar; const struct crypto_bignum *order; size_t order_len; order = crypto_ec_get_order(group->group); order_len = crypto_ec_order_len(group->group); /* RFC 5931, 2.8.5.2: 1 < scalar < r */ scalar = crypto_bignum_init_set(buf, order_len); if (!scalar || crypto_bignum_is_zero(scalar) || crypto_bignum_is_one(scalar) || crypto_bignum_cmp(scalar, order) >= 0) { wpa_printf(MSG_INFO, "EAP-pwd: received scalar is invalid"); crypto_bignum_deinit(scalar, 0); scalar = NULL; } return scalar; } int eap_pwd_get_rand_mask(EAP_PWD_group *group, struct crypto_bignum *_rand, struct crypto_bignum *_mask, struct crypto_bignum *scalar) { return dragonfly_generate_scalar(crypto_ec_get_order(group->group), _rand, _mask, scalar); }