Disconnect hostapd from building in base
[dragonfly.git] / contrib / hostapd / src / eap_common / eap_pwd_common.c
CommitLineData
4781064b
JM
1/*
2 * EAP server/peer: EAP-pwd shared routines
3 * Copyright (c) 2010, Dan Harkins <dharkins@lounge.org>
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#include "common.h"
11#include "crypto/sha256.h"
12#include "crypto/crypto.h"
13#include "eap_defs.h"
14#include "eap_pwd_common.h"
15
16/* The random function H(x) = HMAC-SHA256(0^32, x) */
17struct crypto_hash * eap_pwd_h_init(void)
18{
19 u8 allzero[SHA256_MAC_LEN];
20 os_memset(allzero, 0, SHA256_MAC_LEN);
21 return crypto_hash_init(CRYPTO_HASH_ALG_HMAC_SHA256, allzero,
22 SHA256_MAC_LEN);
23}
24
25
26void eap_pwd_h_update(struct crypto_hash *hash, const u8 *data, size_t len)
27{
28 crypto_hash_update(hash, data, len);
29}
30
31
32void eap_pwd_h_final(struct crypto_hash *hash, u8 *digest)
33{
34 size_t len = SHA256_MAC_LEN;
35 crypto_hash_finish(hash, digest, &len);
36}
37
38
39/* a counter-based KDF based on NIST SP800-108 */
40static int eap_pwd_kdf(const u8 *key, size_t keylen, const u8 *label,
41 size_t labellen, u8 *result, size_t resultbitlen)
42{
43 struct crypto_hash *hash;
44 u8 digest[SHA256_MAC_LEN];
45 u16 i, ctr, L;
46 size_t resultbytelen, len = 0, mdlen;
47
48 resultbytelen = (resultbitlen + 7) / 8;
49 ctr = 0;
50 L = htons(resultbitlen);
51 while (len < resultbytelen) {
52 ctr++;
53 i = htons(ctr);
54 hash = crypto_hash_init(CRYPTO_HASH_ALG_HMAC_SHA256,
55 key, keylen);
56 if (hash == NULL)
57 return -1;
58 if (ctr > 1)
59 crypto_hash_update(hash, digest, SHA256_MAC_LEN);
60 crypto_hash_update(hash, (u8 *) &i, sizeof(u16));
61 crypto_hash_update(hash, label, labellen);
62 crypto_hash_update(hash, (u8 *) &L, sizeof(u16));
63 mdlen = SHA256_MAC_LEN;
64 if (crypto_hash_finish(hash, digest, &mdlen) < 0)
65 return -1;
66 if ((len + mdlen) > resultbytelen)
67 os_memcpy(result + len, digest, resultbytelen - len);
68 else
69 os_memcpy(result + len, digest, mdlen);
70 len += mdlen;
71 }
72
73 /* since we're expanding to a bit length, mask off the excess */
74 if (resultbitlen % 8) {
75 u8 mask = 0xff;
76 mask <<= (8 - (resultbitlen % 8));
77 result[resultbytelen - 1] &= mask;
78 }
79
80 return 0;
81}
82
83
84/*
85 * compute a "random" secret point on an elliptic curve based
86 * on the password and identities.
87 */
88int compute_password_element(EAP_PWD_group *grp, u16 num,
89 u8 *password, int password_len,
90 u8 *id_server, int id_server_len,
91 u8 *id_peer, int id_peer_len, u8 *token)
92{
93 BIGNUM *x_candidate = NULL, *rnd = NULL, *cofactor = NULL;
94 struct crypto_hash *hash;
95 unsigned char pwe_digest[SHA256_MAC_LEN], *prfbuf = NULL, ctr;
96 int nid, is_odd, ret = 0;
97 size_t primebytelen, primebitlen;
98
99 switch (num) { /* from IANA registry for IKE D-H groups */
100 case 19:
101 nid = NID_X9_62_prime256v1;
102 break;
103 case 20:
104 nid = NID_secp384r1;
105 break;
106 case 21:
107 nid = NID_secp521r1;
108 break;
109 case 25:
110 nid = NID_X9_62_prime192v1;
111 break;
112 case 26:
113 nid = NID_secp224r1;
114 break;
115 default:
116 wpa_printf(MSG_INFO, "EAP-pwd: unsupported group %d", num);
117 return -1;
118 }
119
120 grp->pwe = NULL;
121 grp->order = NULL;
122 grp->prime = NULL;
123
124 if ((grp->group = EC_GROUP_new_by_curve_name(nid)) == NULL) {
125 wpa_printf(MSG_INFO, "EAP-pwd: unable to create EC_GROUP");
126 goto fail;
127 }
128
129 if (((rnd = BN_new()) == NULL) ||
130 ((cofactor = BN_new()) == NULL) ||
131 ((grp->pwe = EC_POINT_new(grp->group)) == NULL) ||
132 ((grp->order = BN_new()) == NULL) ||
133 ((grp->prime = BN_new()) == NULL) ||
134 ((x_candidate = BN_new()) == NULL)) {
135 wpa_printf(MSG_INFO, "EAP-pwd: unable to create bignums");
136 goto fail;
137 }
138
139 if (!EC_GROUP_get_curve_GFp(grp->group, grp->prime, NULL, NULL, NULL))
140 {
141 wpa_printf(MSG_INFO, "EAP-pwd: unable to get prime for GFp "
142 "curve");
143 goto fail;
144 }
145 if (!EC_GROUP_get_order(grp->group, grp->order, NULL)) {
146 wpa_printf(MSG_INFO, "EAP-pwd: unable to get order for curve");
147 goto fail;
148 }
149 if (!EC_GROUP_get_cofactor(grp->group, cofactor, NULL)) {
150 wpa_printf(MSG_INFO, "EAP-pwd: unable to get cofactor for "
151 "curve");
152 goto fail;
153 }
154 primebitlen = BN_num_bits(grp->prime);
155 primebytelen = BN_num_bytes(grp->prime);
156 if ((prfbuf = os_malloc(primebytelen)) == NULL) {
157 wpa_printf(MSG_INFO, "EAP-pwd: unable to malloc space for prf "
158 "buffer");
159 goto fail;
160 }
161 os_memset(prfbuf, 0, primebytelen);
162 ctr = 0;
163 while (1) {
164 if (ctr > 30) {
165 wpa_printf(MSG_INFO, "EAP-pwd: unable to find random "
166 "point on curve for group %d, something's "
167 "fishy", num);
168 goto fail;
169 }
170 ctr++;
171
172 /*
173 * compute counter-mode password value and stretch to prime
174 * pwd-seed = H(token | peer-id | server-id | password |
175 * counter)
176 */
177 hash = eap_pwd_h_init();
178 if (hash == NULL)
179 goto fail;
180 eap_pwd_h_update(hash, token, sizeof(u32));
181 eap_pwd_h_update(hash, id_peer, id_peer_len);
182 eap_pwd_h_update(hash, id_server, id_server_len);
183 eap_pwd_h_update(hash, password, password_len);
184 eap_pwd_h_update(hash, &ctr, sizeof(ctr));
185 eap_pwd_h_final(hash, pwe_digest);
186
187 BN_bin2bn(pwe_digest, SHA256_MAC_LEN, rnd);
188
189 if (eap_pwd_kdf(pwe_digest, SHA256_MAC_LEN,
190 (u8 *) "EAP-pwd Hunting And Pecking",
191 os_strlen("EAP-pwd Hunting And Pecking"),
192 prfbuf, primebitlen) < 0)
193 goto fail;
194
195 BN_bin2bn(prfbuf, primebytelen, x_candidate);
196
197 /*
198 * eap_pwd_kdf() returns a string of bits 0..primebitlen but
199 * BN_bin2bn will treat that string of bits as a big endian
200 * number. If the primebitlen is not an even multiple of 8
201 * then excessive bits-- those _after_ primebitlen-- so now
202 * we have to shift right the amount we masked off.
203 */
204 if (primebitlen % 8)
205 BN_rshift(x_candidate, x_candidate,
206 (8 - (primebitlen % 8)));
207
208 if (BN_ucmp(x_candidate, grp->prime) >= 0)
209 continue;
210
211 wpa_hexdump(MSG_DEBUG, "EAP-pwd: x_candidate",
212 prfbuf, primebytelen);
213
214 /*
215 * need to unambiguously identify the solution, if there is
216 * one...
217 */
218 if (BN_is_odd(rnd))
219 is_odd = 1;
220 else
221 is_odd = 0;
222
223 /*
224 * solve the quadratic equation, if it's not solvable then we
225 * don't have a point
226 */
227 if (!EC_POINT_set_compressed_coordinates_GFp(grp->group,
228 grp->pwe,
229 x_candidate,
230 is_odd, NULL))
231 continue;
232 /*
233 * If there's a solution to the equation then the point must be
234 * on the curve so why check again explicitly? OpenSSL code
235 * says this is required by X9.62. We're not X9.62 but it can't
236 * hurt just to be sure.
237 */
238 if (!EC_POINT_is_on_curve(grp->group, grp->pwe, NULL)) {
239 wpa_printf(MSG_INFO, "EAP-pwd: point is not on curve");
240 continue;
241 }
242
243 if (BN_cmp(cofactor, BN_value_one())) {
244 /* make sure the point is not in a small sub-group */
245 if (!EC_POINT_mul(grp->group, grp->pwe, NULL, grp->pwe,
246 cofactor, NULL)) {
247 wpa_printf(MSG_INFO, "EAP-pwd: cannot "
248 "multiply generator by order");
249 continue;
250 }
251 if (EC_POINT_is_at_infinity(grp->group, grp->pwe)) {
252 wpa_printf(MSG_INFO, "EAP-pwd: point is at "
253 "infinity");
254 continue;
255 }
256 }
257 /* if we got here then we have a new generator. */
258 break;
259 }
260 wpa_printf(MSG_DEBUG, "EAP-pwd: found a PWE in %d tries", ctr);
261 grp->group_num = num;
262 if (0) {
263 fail:
264 EC_GROUP_free(grp->group);
265 grp->group = NULL;
266 EC_POINT_free(grp->pwe);
267 grp->pwe = NULL;
268 BN_free(grp->order);
269 grp->order = NULL;
270 BN_free(grp->prime);
271 grp->prime = NULL;
272 ret = 1;
273 }
274 /* cleanliness and order.... */
275 BN_free(cofactor);
276 BN_free(x_candidate);
277 BN_free(rnd);
278 os_free(prfbuf);
279
280 return ret;
281}
282
283
284int compute_keys(EAP_PWD_group *grp, BN_CTX *bnctx, BIGNUM *k,
285 BIGNUM *peer_scalar, BIGNUM *server_scalar,
286 u8 *confirm_peer, u8 *confirm_server,
287 u32 *ciphersuite, u8 *msk, u8 *emsk)
288{
289 struct crypto_hash *hash;
290 u8 mk[SHA256_MAC_LEN], *cruft;
291 u8 session_id[SHA256_MAC_LEN + 1];
292 u8 msk_emsk[EAP_MSK_LEN + EAP_EMSK_LEN];
293 int offset;
294
295 if ((cruft = os_malloc(BN_num_bytes(grp->prime))) == NULL)
296 return -1;
297
298 /*
299 * first compute the session-id = TypeCode | H(ciphersuite | scal_p |
300 * scal_s)
301 */
302 session_id[0] = EAP_TYPE_PWD;
303 hash = eap_pwd_h_init();
304 if (hash == NULL) {
305 os_free(cruft);
306 return -1;
307 }
308 eap_pwd_h_update(hash, (u8 *) ciphersuite, sizeof(u32));
309 offset = BN_num_bytes(grp->order) - BN_num_bytes(peer_scalar);
310 os_memset(cruft, 0, BN_num_bytes(grp->prime));
311 BN_bn2bin(peer_scalar, cruft + offset);
312 eap_pwd_h_update(hash, cruft, BN_num_bytes(grp->order));
313 offset = BN_num_bytes(grp->order) - BN_num_bytes(server_scalar);
314 os_memset(cruft, 0, BN_num_bytes(grp->prime));
315 BN_bn2bin(server_scalar, cruft + offset);
316 eap_pwd_h_update(hash, cruft, BN_num_bytes(grp->order));
317 eap_pwd_h_final(hash, &session_id[1]);
318
319 /* then compute MK = H(k | confirm-peer | confirm-server) */
320 hash = eap_pwd_h_init();
321 if (hash == NULL) {
322 os_free(cruft);
323 return -1;
324 }
325 offset = BN_num_bytes(grp->prime) - BN_num_bytes(k);
326 os_memset(cruft, 0, BN_num_bytes(grp->prime));
327 BN_bn2bin(k, cruft + offset);
328 eap_pwd_h_update(hash, cruft, BN_num_bytes(grp->prime));
329 os_free(cruft);
330 eap_pwd_h_update(hash, confirm_peer, SHA256_MAC_LEN);
331 eap_pwd_h_update(hash, confirm_server, SHA256_MAC_LEN);
332 eap_pwd_h_final(hash, mk);
333
334 /* stretch the mk with the session-id to get MSK | EMSK */
335 if (eap_pwd_kdf(mk, SHA256_MAC_LEN,
336 session_id, SHA256_MAC_LEN + 1,
337 msk_emsk, (EAP_MSK_LEN + EAP_EMSK_LEN) * 8) < 0) {
338 return -1;
339 }
340
341 os_memcpy(msk, msk_emsk, EAP_MSK_LEN);
342 os_memcpy(emsk, msk_emsk + EAP_MSK_LEN, EAP_EMSK_LEN);
343
344 return 1;
345}