xref: /freebsd/contrib/wpa/src/crypto/crypto_nettle.c (revision d0b2dbfa0ecf2bbc9709efc5e20baf8e4b44bbbf) 
1 /*
2  * Wrapper functions for libnettle and libgmp
3  * Copyright (c) 2017, 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 #include <nettle/nettle-meta.h>
11 #include <nettle/des.h>
12 #undef des_encrypt
13 #include <nettle/hmac.h>
14 #include <nettle/aes.h>
15 #undef aes_encrypt
16 #undef aes_decrypt
17 #include <nettle/arcfour.h>
18 #include <nettle/bignum.h>
19 
20 #include "common.h"
21 #include "md5.h"
22 #include "sha1.h"
23 #include "sha256.h"
24 #include "sha384.h"
25 #include "sha512.h"
26 #include "crypto.h"
27 
28 
29 int des_encrypt(const u8 *clear, const u8 *key, u8 *cypher)
30 {
31 	struct des_ctx ctx;
32 	u8 pkey[8], next, tmp;
33 	int i;
34 
35 	/* Add parity bits to the key */
36 	next = 0;
37 	for (i = 0; i < 7; i++) {
38 		tmp = key[i];
39 		pkey[i] = (tmp >> i) | next | 1;
40 		next = tmp << (7 - i);
41 	}
42 	pkey[i] = next | 1;
43 
44 	nettle_des_set_key(&ctx, pkey);
45 	nettle_des_encrypt(&ctx, DES_BLOCK_SIZE, cypher, clear);
46 	os_memset(&ctx, 0, sizeof(ctx));
47 	return 0;
48 }
49 
50 
51 static int nettle_digest_vector(const struct nettle_hash *alg, size_t num_elem,
52 				const u8 *addr[], const size_t *len, u8 *mac)
53 {
54 	void *ctx;
55 	size_t i;
56 
57 	if (TEST_FAIL())
58 		return -1;
59 
60 	ctx = os_malloc(alg->context_size);
61 	if (!ctx)
62 		return -1;
63 	alg->init(ctx);
64 	for (i = 0; i < num_elem; i++)
65 		alg->update(ctx, len[i], addr[i]);
66 	alg->digest(ctx, alg->digest_size, mac);
67 	bin_clear_free(ctx, alg->context_size);
68 	return 0;
69 }
70 
71 
72 int md4_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac)
73 {
74 	return nettle_digest_vector(&nettle_md4, num_elem, addr, len, mac);
75 }
76 
77 
78 int md5_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac)
79 {
80 	return nettle_digest_vector(&nettle_md5, num_elem, addr, len, mac);
81 }
82 
83 
84 int sha1_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac)
85 {
86 	return nettle_digest_vector(&nettle_sha1, num_elem, addr, len, mac);
87 }
88 
89 
90 int sha256_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac)
91 {
92 	return nettle_digest_vector(&nettle_sha256, num_elem, addr, len, mac);
93 }
94 
95 
96 int sha384_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac)
97 {
98 	return nettle_digest_vector(&nettle_sha384, num_elem, addr, len, mac);
99 }
100 
101 
102 int sha512_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac)
103 {
104 	return nettle_digest_vector(&nettle_sha512, num_elem, addr, len, mac);
105 }
106 
107 
108 int hmac_md5_vector(const u8 *key, size_t key_len, size_t num_elem,
109 		    const u8 *addr[], const size_t *len, u8 *mac)
110 {
111 	struct hmac_md5_ctx ctx;
112 	size_t i;
113 
114 	if (TEST_FAIL())
115 		return -1;
116 
117 	hmac_md5_set_key(&ctx, key_len, key);
118 	for (i = 0; i < num_elem; i++)
119 		hmac_md5_update(&ctx, len[i], addr[i]);
120 	hmac_md5_digest(&ctx, MD5_DIGEST_SIZE, mac);
121 	os_memset(&ctx, 0, sizeof(ctx));
122 	return 0;
123 }
124 
125 
126 int hmac_md5(const u8 *key, size_t key_len, const u8 *data, size_t data_len,
127 	     u8 *mac)
128 {
129 	return hmac_md5_vector(key, key_len, 1, &data, &data_len, mac);
130 }
131 
132 
133 int hmac_sha1_vector(const u8 *key, size_t key_len, size_t num_elem,
134 		     const u8 *addr[], const size_t *len, u8 *mac)
135 {
136 	struct hmac_sha1_ctx ctx;
137 	size_t i;
138 
139 	if (TEST_FAIL())
140 		return -1;
141 
142 	hmac_sha1_set_key(&ctx, key_len, key);
143 	for (i = 0; i < num_elem; i++)
144 		hmac_sha1_update(&ctx, len[i], addr[i]);
145 	hmac_sha1_digest(&ctx, SHA1_DIGEST_SIZE, mac);
146 	os_memset(&ctx, 0, sizeof(ctx));
147 	return 0;
148 }
149 
150 
151 int hmac_sha1(const u8 *key, size_t key_len, const u8 *data, size_t data_len,
152 	       u8 *mac)
153 {
154 	return hmac_sha1_vector(key, key_len, 1, &data, &data_len, mac);
155 }
156 
157 
158 #ifdef CONFIG_SHA256
159 
160 int hmac_sha256_vector(const u8 *key, size_t key_len, size_t num_elem,
161 		       const u8 *addr[], const size_t *len, u8 *mac)
162 {
163 	struct hmac_sha256_ctx ctx;
164 	size_t i;
165 
166 	if (TEST_FAIL())
167 		return -1;
168 
169 	hmac_sha256_set_key(&ctx, key_len, key);
170 	for (i = 0; i < num_elem; i++)
171 		hmac_sha256_update(&ctx, len[i], addr[i]);
172 	hmac_sha256_digest(&ctx, SHA256_DIGEST_SIZE, mac);
173 	os_memset(&ctx, 0, sizeof(ctx));
174 	return 0;
175 }
176 
177 
178 int hmac_sha256(const u8 *key, size_t key_len, const u8 *data,
179 		size_t data_len, u8 *mac)
180 {
181 	return hmac_sha256_vector(key, key_len, 1, &data, &data_len, mac);
182 }
183 
184 #endif /* CONFIG_SHA256 */
185 
186 
187 #ifdef CONFIG_SHA384
188 
189 int hmac_sha384_vector(const u8 *key, size_t key_len, size_t num_elem,
190 		       const u8 *addr[], const size_t *len, u8 *mac)
191 {
192 	struct hmac_sha384_ctx ctx;
193 	size_t i;
194 
195 	if (TEST_FAIL())
196 		return -1;
197 
198 	hmac_sha384_set_key(&ctx, key_len, key);
199 	for (i = 0; i < num_elem; i++)
200 		hmac_sha384_update(&ctx, len[i], addr[i]);
201 	hmac_sha384_digest(&ctx, SHA384_DIGEST_SIZE, mac);
202 	os_memset(&ctx, 0, sizeof(ctx));
203 	return 0;
204 }
205 
206 
207 int hmac_sha384(const u8 *key, size_t key_len, const u8 *data,
208 		size_t data_len, u8 *mac)
209 {
210 	return hmac_sha384_vector(key, key_len, 1, &data, &data_len, mac);
211 }
212 
213 #endif /* CONFIG_SHA384 */
214 
215 
216 #ifdef CONFIG_SHA512
217 
218 int hmac_sha512_vector(const u8 *key, size_t key_len, size_t num_elem,
219 		       const u8 *addr[], const size_t *len, u8 *mac)
220 {
221 	struct hmac_sha512_ctx ctx;
222 	size_t i;
223 
224 	if (TEST_FAIL())
225 		return -1;
226 
227 	hmac_sha512_set_key(&ctx, key_len, key);
228 	for (i = 0; i < num_elem; i++)
229 		hmac_sha512_update(&ctx, len[i], addr[i]);
230 	hmac_sha512_digest(&ctx, SHA512_DIGEST_SIZE, mac);
231 	os_memset(&ctx, 0, sizeof(ctx));
232 	return 0;
233 }
234 
235 
236 int hmac_sha512(const u8 *key, size_t key_len, const u8 *data,
237 		size_t data_len, u8 *mac)
238 {
239 	return hmac_sha512_vector(key, key_len, 1, &data, &data_len, mac);
240 }
241 
242 #endif /* CONFIG_SHA512 */
243 
244 
245 void * aes_encrypt_init(const u8 *key, size_t len)
246 {
247 	struct aes_ctx *ctx;
248 
249 	if (TEST_FAIL())
250 		return NULL;
251 	ctx = os_malloc(sizeof(*ctx));
252 	if (!ctx)
253 		return NULL;
254 
255 	nettle_aes_set_encrypt_key(ctx, len, key);
256 
257 	return ctx;
258 }
259 
260 
261 int aes_encrypt(void *ctx, const u8 *plain, u8 *crypt)
262 {
263 	struct aes_ctx *actx = ctx;
264 	nettle_aes_encrypt(actx, AES_BLOCK_SIZE, crypt, plain);
265 	return 0;
266 }
267 
268 
269 void aes_encrypt_deinit(void *ctx)
270 {
271 	struct aes_ctx *actx = ctx;
272 	bin_clear_free(actx, sizeof(*actx));
273 }
274 
275 
276 void * aes_decrypt_init(const u8 *key, size_t len)
277 {
278 	struct aes_ctx *ctx;
279 
280 	if (TEST_FAIL())
281 		return NULL;
282 	ctx = os_malloc(sizeof(*ctx));
283 	if (!ctx)
284 		return NULL;
285 
286 	nettle_aes_set_decrypt_key(ctx, len, key);
287 
288 	return ctx;
289 }
290 
291 
292 int aes_decrypt(void *ctx, const u8 *crypt, u8 *plain)
293 {
294 	struct aes_ctx *actx = ctx;
295 	nettle_aes_decrypt(actx, AES_BLOCK_SIZE, plain, crypt);
296 	return 0;
297 }
298 
299 
300 void aes_decrypt_deinit(void *ctx)
301 {
302 	struct aes_ctx *actx = ctx;
303 	bin_clear_free(actx, sizeof(*actx));
304 }
305 
306 
307 int crypto_dh_init(u8 generator, const u8 *prime, size_t prime_len, u8 *privkey,
308 		   u8 *pubkey)
309 {
310 	size_t pubkey_len, pad;
311 
312 	if (os_get_random(privkey, prime_len) < 0)
313 		return -1;
314 	if (os_memcmp(privkey, prime, prime_len) > 0) {
315 		/* Make sure private value is smaller than prime */
316 		privkey[0] = 0;
317 	}
318 
319 	pubkey_len = prime_len;
320 	if (crypto_mod_exp(&generator, 1, privkey, prime_len, prime, prime_len,
321 			   pubkey, &pubkey_len) < 0)
322 		return -1;
323 	if (pubkey_len < prime_len) {
324 		pad = prime_len - pubkey_len;
325 		os_memmove(pubkey + pad, pubkey, pubkey_len);
326 		os_memset(pubkey, 0, pad);
327 	}
328 
329 	return 0;
330 }
331 
332 
333 int crypto_dh_derive_secret(u8 generator, const u8 *prime, size_t prime_len,
334 			    const u8 *order, size_t order_len,
335 			    const u8 *privkey, size_t privkey_len,
336 			    const u8 *pubkey, size_t pubkey_len,
337 			    u8 *secret, size_t *len)
338 {
339 	mpz_t pub;
340 	int res = -1;
341 
342 	if (pubkey_len > prime_len ||
343 	    (pubkey_len == prime_len &&
344 	     os_memcmp(pubkey, prime, prime_len) >= 0))
345 		return -1;
346 
347 	mpz_init(pub);
348 	mpz_import(pub, pubkey_len, 1, 1, 1, 0, pubkey);
349 	if (mpz_cmp_d(pub, 1) <= 0)
350 		goto fail;
351 
352 	if (order) {
353 		mpz_t p, q, tmp;
354 		int failed;
355 
356 		/* verify: pubkey^q == 1 mod p */
357 		mpz_inits(p, q, tmp, NULL);
358 		mpz_import(p, prime_len, 1, 1, 1, 0, prime);
359 		mpz_import(q, order_len, 1, 1, 1, 0, order);
360 		mpz_powm(tmp, pub, q, p);
361 		failed = mpz_cmp_d(tmp, 1) != 0;
362 		mpz_clears(p, q, tmp, NULL);
363 		if (failed)
364 			goto fail;
365 	}
366 
367 	res = crypto_mod_exp(pubkey, pubkey_len, privkey, privkey_len,
368 			     prime, prime_len, secret, len);
369 fail:
370 	mpz_clear(pub);
371 	return res;
372 }
373 
374 
375 int crypto_mod_exp(const u8 *base, size_t base_len,
376 		   const u8 *power, size_t power_len,
377 		   const u8 *modulus, size_t modulus_len,
378 		   u8 *result, size_t *result_len)
379 {
380 	mpz_t bn_base, bn_exp, bn_modulus, bn_result;
381 	int ret = -1;
382 	size_t len;
383 
384 	mpz_inits(bn_base, bn_exp, bn_modulus, bn_result, NULL);
385 	mpz_import(bn_base, base_len, 1, 1, 1, 0, base);
386 	mpz_import(bn_exp, power_len, 1, 1, 1, 0, power);
387 	mpz_import(bn_modulus, modulus_len, 1, 1, 1, 0, modulus);
388 
389 	mpz_powm(bn_result, bn_base, bn_exp, bn_modulus);
390 	len = mpz_sizeinbase(bn_result, 2);
391 	len = (len + 7) / 8;
392 	if (*result_len < len)
393 		goto error;
394 	mpz_export(result, result_len, 1, 1, 1, 0, bn_result);
395 	ret = 0;
396 
397 error:
398 	mpz_clears(bn_base, bn_exp, bn_modulus, bn_result, NULL);
399 	return ret;
400 }
401 
402 
403 struct crypto_cipher {
404 	enum crypto_cipher_alg alg;
405 	union {
406 		struct arcfour_ctx arcfour_ctx;
407 	} u;
408 };
409 
410 
411 struct crypto_cipher * crypto_cipher_init(enum crypto_cipher_alg alg,
412 					  const u8 *iv, const u8 *key,
413 					  size_t key_len)
414 {
415 	struct crypto_cipher *ctx;
416 
417 	ctx = os_zalloc(sizeof(*ctx));
418 	if (!ctx)
419 		return NULL;
420 
421 	ctx->alg = alg;
422 
423 	switch (alg) {
424 	case CRYPTO_CIPHER_ALG_RC4:
425 		nettle_arcfour_set_key(&ctx->u.arcfour_ctx, key_len, key);
426 		break;
427 	default:
428 		os_free(ctx);
429 		return NULL;
430 	}
431 
432 	return ctx;
433 }
434 
435 
436 int crypto_cipher_encrypt(struct crypto_cipher *ctx, const u8 *plain,
437 			  u8 *crypt, size_t len)
438 {
439 	switch (ctx->alg) {
440 	case CRYPTO_CIPHER_ALG_RC4:
441 		nettle_arcfour_crypt(&ctx->u.arcfour_ctx, len, crypt, plain);
442 		break;
443 	default:
444 		return -1;
445 	}
446 
447 	return 0;
448 }
449 
450 
451 int crypto_cipher_decrypt(struct crypto_cipher *ctx, const u8 *crypt,
452 			  u8 *plain, size_t len)
453 {
454 	switch (ctx->alg) {
455 	case CRYPTO_CIPHER_ALG_RC4:
456 		nettle_arcfour_crypt(&ctx->u.arcfour_ctx, len, plain, crypt);
457 		break;
458 	default:
459 		return -1;
460 	}
461 
462 	return 0;
463 }
464 
465 
466 void crypto_cipher_deinit(struct crypto_cipher *ctx)
467 {
468 	bin_clear_free(ctx, sizeof(*ctx));
469 }
470