Branch data Line data Source code
1 : : /* gc-libgcrypt.c --- Crypto wrappers around Libgcrypt for GC.
2 : : * Copyright (C) 2002-2012 Free Software Foundation, Inc.
3 : : *
4 : : * This file is free software; you can redistribute it and/or modify
5 : : * it under the terms of the GNU Lesser General Public License as published
6 : : * by the Free Software Foundation; either version 2.1, or (at your
7 : : * option) any later version.
8 : : *
9 : : * This file is distributed in the hope that it will be useful, but
10 : : * WITHOUT ANY WARRANTY; without even the implied warranty of
11 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 : : * Lesser General Public License for more details.
13 : : *
14 : : * You should have received a copy of the GNU Lesser General Public License
15 : : * along with this file; if not, see <http://www.gnu.org/licenses/>.
16 : : *
17 : : */
18 : :
19 : : /* Note: This file is only built if GC uses Libgcrypt. */
20 : :
21 : : #include <config.h>
22 : :
23 : : /* Get prototype. */
24 : : #include "gc.h"
25 : :
26 : : #include <stdlib.h>
27 : : #include <string.h>
28 : :
29 : : /* Get libgcrypt API. */
30 : : #include <gcrypt.h>
31 : : #ifdef GNULIB_GC_MD2
32 : : # include "md2.h"
33 : : #endif
34 : :
35 : : #include <assert.h>
36 : :
37 : : #ifndef MIN_GCRYPT_VERSION
38 : : # define MIN_GCRYPT_VERSION "1.4.4"
39 : : #endif
40 : :
41 : : /* Initialization. */
42 : :
43 : : Gc_rc
44 : 24 : gc_init (void)
45 : : {
46 : : gcry_error_t err;
47 : :
48 : 24 : err = gcry_control (GCRYCTL_ANY_INITIALIZATION_P);
49 [ + + ]: 24 : if (err == GPG_ERR_NO_ERROR)
50 : : {
51 [ - + ]: 21 : if (gcry_control (GCRYCTL_DISABLE_SECMEM, NULL, 0))
52 : 0 : return GC_INIT_ERROR;
53 : :
54 [ - + ]: 21 : if (gcry_check_version (MIN_GCRYPT_VERSION) == NULL)
55 : 0 : return GC_INIT_ERROR;
56 : :
57 : 21 : err = gcry_control (GCRYCTL_INITIALIZATION_FINISHED, NULL, 0);
58 [ - + ]: 21 : if (err != GPG_ERR_NO_ERROR)
59 : 0 : return GC_INIT_ERROR;
60 : : }
61 : :
62 : 24 : return GC_OK;
63 : : }
64 : :
65 : : void
66 : 5 : gc_done (void)
67 : : {
68 : 5 : return;
69 : : }
70 : :
71 : : #ifdef GNULIB_GC_RANDOM
72 : :
73 : : /* Randomness. */
74 : :
75 : : Gc_rc
76 : 231 : gc_nonce (char *data, size_t datalen)
77 : : {
78 : 231 : gcry_create_nonce ((unsigned char *) data, datalen);
79 : 231 : return GC_OK;
80 : : }
81 : :
82 : : Gc_rc
83 : 0 : gc_pseudo_random (char *data, size_t datalen)
84 : : {
85 : 0 : gcry_randomize ((unsigned char *) data, datalen, GCRY_STRONG_RANDOM);
86 : 0 : return GC_OK;
87 : : }
88 : :
89 : : Gc_rc
90 : 0 : gc_random (char *data, size_t datalen)
91 : : {
92 : 0 : gcry_randomize ((unsigned char *) data, datalen, GCRY_VERY_STRONG_RANDOM);
93 : 0 : return GC_OK;
94 : : }
95 : :
96 : : #endif
97 : :
98 : : /* Memory allocation. */
99 : :
100 : : void
101 : 0 : gc_set_allocators (gc_malloc_t func_malloc,
102 : : gc_malloc_t secure_malloc,
103 : : gc_secure_check_t secure_check,
104 : : gc_realloc_t func_realloc, gc_free_t func_free)
105 : : {
106 : 0 : gcry_set_allocation_handler (func_malloc, secure_malloc, secure_check,
107 : : func_realloc, func_free);
108 : 0 : }
109 : :
110 : : /* Ciphers. */
111 : :
112 : : Gc_rc
113 : 0 : gc_cipher_open (Gc_cipher alg, Gc_cipher_mode mode,
114 : : gc_cipher_handle * outhandle)
115 : : {
116 : : int gcryalg, gcrymode;
117 : : gcry_error_t err;
118 : :
119 [ # # # # : 0 : switch (alg)
# # # # ]
120 : : {
121 : : case GC_AES128:
122 : 0 : gcryalg = GCRY_CIPHER_RIJNDAEL;
123 : 0 : break;
124 : :
125 : : case GC_AES192:
126 : 0 : gcryalg = GCRY_CIPHER_RIJNDAEL;
127 : 0 : break;
128 : :
129 : : case GC_AES256:
130 : 0 : gcryalg = GCRY_CIPHER_RIJNDAEL256;
131 : 0 : break;
132 : :
133 : : case GC_3DES:
134 : 0 : gcryalg = GCRY_CIPHER_3DES;
135 : 0 : break;
136 : :
137 : : case GC_DES:
138 : 0 : gcryalg = GCRY_CIPHER_DES;
139 : 0 : break;
140 : :
141 : : case GC_ARCFOUR128:
142 : : case GC_ARCFOUR40:
143 : 0 : gcryalg = GCRY_CIPHER_ARCFOUR;
144 : 0 : break;
145 : :
146 : : case GC_ARCTWO40:
147 : 0 : gcryalg = GCRY_CIPHER_RFC2268_40;
148 : 0 : break;
149 : :
150 : : #ifdef HAVE_CAMELLIA
151 : : case GC_CAMELLIA128:
152 : : gcryalg = GCRY_CIPHER_CAMELLIA128;
153 : : break;
154 : :
155 : : case GC_CAMELLIA256:
156 : : gcryalg = GCRY_CIPHER_CAMELLIA256;
157 : : break;
158 : : #endif
159 : :
160 : : default:
161 : 0 : return GC_INVALID_CIPHER;
162 : : }
163 : :
164 [ # # # # ]: 0 : switch (mode)
165 : : {
166 : : case GC_ECB:
167 : 0 : gcrymode = GCRY_CIPHER_MODE_ECB;
168 : 0 : break;
169 : :
170 : : case GC_CBC:
171 : 0 : gcrymode = GCRY_CIPHER_MODE_CBC;
172 : 0 : break;
173 : :
174 : : case GC_STREAM:
175 : 0 : gcrymode = GCRY_CIPHER_MODE_STREAM;
176 : 0 : break;
177 : :
178 : : default:
179 : 0 : return GC_INVALID_CIPHER;
180 : : }
181 : :
182 : 0 : err = gcry_cipher_open ((gcry_cipher_hd_t *) outhandle,
183 : : gcryalg, gcrymode, 0);
184 [ # # ]: 0 : if (gcry_err_code (err))
185 : 0 : return GC_INVALID_CIPHER;
186 : :
187 : 0 : return GC_OK;
188 : : }
189 : :
190 : : Gc_rc
191 : 0 : gc_cipher_setkey (gc_cipher_handle handle, size_t keylen, const char *key)
192 : : {
193 : : gcry_error_t err;
194 : :
195 : 0 : err = gcry_cipher_setkey ((gcry_cipher_hd_t) handle, key, keylen);
196 [ # # ]: 0 : if (gcry_err_code (err))
197 : 0 : return GC_INVALID_CIPHER;
198 : :
199 : 0 : return GC_OK;
200 : : }
201 : :
202 : : Gc_rc
203 : 0 : gc_cipher_setiv (gc_cipher_handle handle, size_t ivlen, const char *iv)
204 : : {
205 : : gcry_error_t err;
206 : :
207 : 0 : err = gcry_cipher_setiv ((gcry_cipher_hd_t) handle, iv, ivlen);
208 [ # # ]: 0 : if (gcry_err_code (err))
209 : 0 : return GC_INVALID_CIPHER;
210 : :
211 : 0 : return GC_OK;
212 : : }
213 : :
214 : : Gc_rc
215 : 0 : gc_cipher_encrypt_inline (gc_cipher_handle handle, size_t len, char *data)
216 : : {
217 [ # # ]: 0 : if (gcry_cipher_encrypt ((gcry_cipher_hd_t) handle,
218 : : data, len, NULL, len) != 0)
219 : 0 : return GC_INVALID_CIPHER;
220 : :
221 : 0 : return GC_OK;
222 : : }
223 : :
224 : : Gc_rc
225 : 0 : gc_cipher_decrypt_inline (gc_cipher_handle handle, size_t len, char *data)
226 : : {
227 [ # # ]: 0 : if (gcry_cipher_decrypt ((gcry_cipher_hd_t) handle,
228 : : data, len, NULL, len) != 0)
229 : 0 : return GC_INVALID_CIPHER;
230 : :
231 : 0 : return GC_OK;
232 : : }
233 : :
234 : : Gc_rc
235 : 0 : gc_cipher_close (gc_cipher_handle handle)
236 : : {
237 : 0 : gcry_cipher_close (handle);
238 : :
239 : 0 : return GC_OK;
240 : : }
241 : :
242 : : /* Hashes. */
243 : :
244 : : typedef struct _gc_hash_ctx {
245 : : Gc_hash alg;
246 : : Gc_hash_mode mode;
247 : : gcry_md_hd_t gch;
248 : : #ifdef GNULIB_GC_MD2
249 : : char hash[GC_MD2_DIGEST_SIZE];
250 : : struct md2_ctx md2Context;
251 : : #endif
252 : : } _gc_hash_ctx;
253 : :
254 : : Gc_rc
255 : 2 : gc_hash_open (Gc_hash hash, Gc_hash_mode mode, gc_hash_handle * outhandle)
256 : : {
257 : : _gc_hash_ctx *ctx;
258 : 2 : int gcryalg = 0, gcrymode = 0;
259 : : gcry_error_t err;
260 : 2 : Gc_rc rc = GC_OK;
261 : :
262 : 2 : ctx = calloc (sizeof (*ctx), 1);
263 [ - + ]: 2 : if (!ctx)
264 : 0 : return GC_MALLOC_ERROR;
265 : :
266 : 2 : ctx->alg = hash;
267 : 2 : ctx->mode = mode;
268 : :
269 [ - - + + : 2 : switch (hash)
- - - - -
- ]
270 : : {
271 : : case GC_MD2:
272 : 0 : gcryalg = GCRY_MD_NONE;
273 : 0 : break;
274 : :
275 : : case GC_MD4:
276 : 0 : gcryalg = GCRY_MD_MD4;
277 : 0 : break;
278 : :
279 : : case GC_MD5:
280 : 1 : gcryalg = GCRY_MD_MD5;
281 : 1 : break;
282 : :
283 : : case GC_SHA1:
284 : 1 : gcryalg = GCRY_MD_SHA1;
285 : 1 : break;
286 : :
287 : : case GC_SHA256:
288 : 0 : gcryalg = GCRY_MD_SHA256;
289 : 0 : break;
290 : :
291 : : case GC_SHA384:
292 : 0 : gcryalg = GCRY_MD_SHA384;
293 : 0 : break;
294 : :
295 : : case GC_SHA512:
296 : 0 : gcryalg = GCRY_MD_SHA512;
297 : 0 : break;
298 : :
299 : : case GC_SHA224:
300 : 0 : gcryalg = GCRY_MD_SHA224;
301 : 0 : break;
302 : :
303 : : case GC_RMD160:
304 : 0 : gcryalg = GCRY_MD_RMD160;
305 : 0 : break;
306 : :
307 : : default:
308 : 0 : rc = GC_INVALID_HASH;
309 : : }
310 : :
311 [ + - - ]: 2 : switch (mode)
312 : : {
313 : : case 0:
314 : 2 : gcrymode = 0;
315 : 2 : break;
316 : :
317 : : case GC_HMAC:
318 : 0 : gcrymode = GCRY_MD_FLAG_HMAC;
319 : 0 : break;
320 : :
321 : : default:
322 : 0 : rc = GC_INVALID_HASH;
323 : : }
324 : :
325 [ + - ][ + - ]: 2 : if (rc == GC_OK && gcryalg != GCRY_MD_NONE)
326 : : {
327 : 2 : err = gcry_md_open (&ctx->gch, gcryalg, gcrymode);
328 [ - + ]: 2 : if (gcry_err_code (err))
329 : 0 : rc = GC_INVALID_HASH;
330 : : }
331 : :
332 [ + - ]: 2 : if (rc == GC_OK)
333 : 2 : *outhandle = ctx;
334 : : else
335 : 0 : free (ctx);
336 : :
337 : 2 : return rc;
338 : : }
339 : :
340 : : Gc_rc
341 : 0 : gc_hash_clone (gc_hash_handle handle, gc_hash_handle * outhandle)
342 : : {
343 : 0 : _gc_hash_ctx *in = handle;
344 : : _gc_hash_ctx *out;
345 : : int err;
346 : :
347 : 0 : *outhandle = out = calloc (sizeof (*out), 1);
348 [ # # ]: 0 : if (!out)
349 : 0 : return GC_MALLOC_ERROR;
350 : :
351 : 0 : memcpy (out, in, sizeof (*out));
352 : :
353 : 0 : err = gcry_md_copy (&out->gch, in->gch);
354 [ # # ]: 0 : if (err)
355 : : {
356 : 0 : free (out);
357 : 0 : return GC_INVALID_HASH;
358 : : }
359 : :
360 : 0 : return GC_OK;
361 : : }
362 : :
363 : : size_t
364 : 2 : gc_hash_digest_length (Gc_hash hash)
365 : : {
366 : : size_t len;
367 : :
368 [ - - + - : 2 : switch (hash)
+ - - - -
- ]
369 : : {
370 : : case GC_MD2:
371 : 0 : len = GC_MD2_DIGEST_SIZE;
372 : 0 : break;
373 : :
374 : : case GC_MD4:
375 : 0 : len = GC_MD4_DIGEST_SIZE;
376 : 0 : break;
377 : :
378 : : case GC_MD5:
379 : 1 : len = GC_MD5_DIGEST_SIZE;
380 : 1 : break;
381 : :
382 : : case GC_RMD160:
383 : 0 : len = GC_RMD160_DIGEST_SIZE;
384 : 0 : break;
385 : :
386 : : case GC_SHA1:
387 : 1 : len = GC_SHA1_DIGEST_SIZE;
388 : 1 : break;
389 : :
390 : : case GC_SHA256:
391 : 0 : len = GC_SHA256_DIGEST_SIZE;
392 : 0 : break;
393 : :
394 : : case GC_SHA384:
395 : 0 : len = GC_SHA384_DIGEST_SIZE;
396 : 0 : break;
397 : :
398 : : case GC_SHA512:
399 : 0 : len = GC_SHA512_DIGEST_SIZE;
400 : 0 : break;
401 : :
402 : : case GC_SHA224:
403 : 0 : len = GC_SHA224_DIGEST_SIZE;
404 : 0 : break;
405 : :
406 : : default:
407 : 0 : return 0;
408 : : }
409 : :
410 : 2 : return len;
411 : : }
412 : :
413 : : void
414 : 0 : gc_hash_hmac_setkey (gc_hash_handle handle, size_t len, const char *key)
415 : : {
416 : 0 : _gc_hash_ctx *ctx = handle;
417 : : #ifdef GNULIB_GC_MD2
418 : : if (ctx->alg != GC_MD2)
419 : : #endif
420 : 0 : gcry_md_setkey (ctx->gch, key, len);
421 : 0 : }
422 : :
423 : : void
424 : 2 : gc_hash_write (gc_hash_handle handle, size_t len, const char *data)
425 : : {
426 : 2 : _gc_hash_ctx *ctx = handle;
427 : :
428 : : #ifdef GNULIB_GC_MD2
429 : : if (ctx->alg == GC_MD2)
430 : : md2_process_bytes (data, len, &ctx->md2Context);
431 : : else
432 : : #endif
433 : 2 : gcry_md_write (ctx->gch, data, len);
434 : 2 : }
435 : :
436 : : const char *
437 : 2 : gc_hash_read (gc_hash_handle handle)
438 : : {
439 : 2 : _gc_hash_ctx *ctx = handle;
440 : : const char *digest;
441 : :
442 : : #ifdef GNULIB_GC_MD2
443 : : if (ctx->alg == GC_MD2)
444 : : {
445 : : md2_finish_ctx (&ctx->md2Context, ctx->hash);
446 : : digest = ctx->hash;
447 : : }
448 : : else
449 : : #endif
450 : : {
451 : 2 : gcry_md_final (ctx->gch);
452 : 2 : digest = gcry_md_read (ctx->gch, 0);
453 : : }
454 : :
455 : 2 : return digest;
456 : : }
457 : :
458 : : void
459 : 2 : gc_hash_close (gc_hash_handle handle)
460 : : {
461 : 2 : _gc_hash_ctx *ctx = handle;
462 : :
463 : : #ifdef GNULIB_GC_MD2
464 : : if (ctx->alg != GC_MD2)
465 : : #endif
466 : 2 : gcry_md_close (ctx->gch);
467 : :
468 : 2 : free (ctx);
469 : 2 : }
470 : :
471 : : Gc_rc
472 : 2 : gc_hash_buffer (Gc_hash hash, const void *in, size_t inlen, char *resbuf)
473 : : {
474 : : int gcryalg;
475 : :
476 [ + + - ]: 2 : switch (hash)
477 : : {
478 : : #ifdef GNULIB_GC_MD2
479 : : case GC_MD2:
480 : : md2_buffer (in, inlen, resbuf);
481 : : return GC_OK;
482 : : break;
483 : : #endif
484 : :
485 : : #ifdef GNULIB_GC_MD4
486 : : case GC_MD4:
487 : : gcryalg = GCRY_MD_MD4;
488 : : break;
489 : : #endif
490 : :
491 : : #ifdef GNULIB_GC_MD5
492 : : case GC_MD5:
493 : 1 : gcryalg = GCRY_MD_MD5;
494 : 1 : break;
495 : : #endif
496 : :
497 : : #ifdef GNULIB_GC_SHA1
498 : : case GC_SHA1:
499 : 1 : gcryalg = GCRY_MD_SHA1;
500 : 1 : break;
501 : : #endif
502 : :
503 : : #ifdef GNULIB_GC_SHA256
504 : : case GC_SHA256:
505 : : gcryalg = GCRY_MD_SHA256;
506 : : break;
507 : : #endif
508 : :
509 : : #ifdef GNULIB_GC_SHA384
510 : : case GC_SHA384:
511 : : gcryalg = GCRY_MD_SHA384;
512 : : break;
513 : : #endif
514 : :
515 : : #ifdef GNULIB_GC_SHA512
516 : : case GC_SHA512:
517 : : gcryalg = GCRY_MD_SHA512;
518 : : break;
519 : : #endif
520 : :
521 : : #ifdef GNULIB_GC_SHA224
522 : : case GC_SHA224:
523 : : gcryalg = GCRY_MD_SHA224;
524 : : break;
525 : : #endif
526 : :
527 : : #ifdef GNULIB_GC_RMD160
528 : : case GC_RMD160:
529 : : gcryalg = GCRY_MD_RMD160;
530 : : break;
531 : : #endif
532 : :
533 : : default:
534 : 0 : return GC_INVALID_HASH;
535 : : }
536 : :
537 : 2 : gcry_md_hash_buffer (gcryalg, resbuf, in, inlen);
538 : :
539 : 2 : return GC_OK;
540 : : }
541 : :
542 : : /* One-call interface. */
543 : :
544 : : #ifdef GNULIB_GC_MD2
545 : : Gc_rc
546 : : gc_md2 (const void *in, size_t inlen, void *resbuf)
547 : : {
548 : : md2_buffer (in, inlen, resbuf);
549 : : return GC_OK;
550 : : }
551 : : #endif
552 : :
553 : : #ifdef GNULIB_GC_MD4
554 : : Gc_rc
555 : : gc_md4 (const void *in, size_t inlen, void *resbuf)
556 : : {
557 : : size_t outlen = gcry_md_get_algo_dlen (GCRY_MD_MD4);
558 : : gcry_md_hd_t hd;
559 : : gpg_error_t err;
560 : : unsigned char *p;
561 : :
562 : : assert (outlen == GC_MD4_DIGEST_SIZE);
563 : :
564 : : err = gcry_md_open (&hd, GCRY_MD_MD4, 0);
565 : : if (err != GPG_ERR_NO_ERROR)
566 : : return GC_INVALID_HASH;
567 : :
568 : : gcry_md_write (hd, in, inlen);
569 : :
570 : : p = gcry_md_read (hd, GCRY_MD_MD4);
571 : : if (p == NULL)
572 : : {
573 : : gcry_md_close (hd);
574 : : return GC_INVALID_HASH;
575 : : }
576 : :
577 : : memcpy (resbuf, p, outlen);
578 : :
579 : : gcry_md_close (hd);
580 : :
581 : : return GC_OK;
582 : : }
583 : : #endif
584 : :
585 : : #ifdef GNULIB_GC_MD5
586 : : Gc_rc
587 : 338 : gc_md5 (const void *in, size_t inlen, void *resbuf)
588 : : {
589 : 338 : size_t outlen = gcry_md_get_algo_dlen (GCRY_MD_MD5);
590 : : gcry_md_hd_t hd;
591 : : gpg_error_t err;
592 : : unsigned char *p;
593 : :
594 [ - + ]: 338 : assert (outlen == GC_MD5_DIGEST_SIZE);
595 : :
596 : 338 : err = gcry_md_open (&hd, GCRY_MD_MD5, 0);
597 [ - + ]: 338 : if (err != GPG_ERR_NO_ERROR)
598 : 0 : return GC_INVALID_HASH;
599 : :
600 : 338 : gcry_md_write (hd, in, inlen);
601 : :
602 : 338 : p = gcry_md_read (hd, GCRY_MD_MD5);
603 [ - + ]: 338 : if (p == NULL)
604 : : {
605 : 0 : gcry_md_close (hd);
606 : 0 : return GC_INVALID_HASH;
607 : : }
608 : :
609 : 338 : memcpy (resbuf, p, outlen);
610 : :
611 : 338 : gcry_md_close (hd);
612 : :
613 : 338 : return GC_OK;
614 : : }
615 : : #endif
616 : :
617 : : #ifdef GNULIB_GC_SHA1
618 : : Gc_rc
619 : 126 : gc_sha1 (const void *in, size_t inlen, void *resbuf)
620 : : {
621 : 126 : size_t outlen = gcry_md_get_algo_dlen (GCRY_MD_SHA1);
622 : : gcry_md_hd_t hd;
623 : : gpg_error_t err;
624 : : unsigned char *p;
625 : :
626 [ - + ]: 126 : assert (outlen == GC_SHA1_DIGEST_SIZE);
627 : :
628 : 126 : err = gcry_md_open (&hd, GCRY_MD_SHA1, 0);
629 [ - + ]: 126 : if (err != GPG_ERR_NO_ERROR)
630 : 0 : return GC_INVALID_HASH;
631 : :
632 : 126 : gcry_md_write (hd, in, inlen);
633 : :
634 : 126 : p = gcry_md_read (hd, GCRY_MD_SHA1);
635 [ - + ]: 126 : if (p == NULL)
636 : : {
637 : 0 : gcry_md_close (hd);
638 : 0 : return GC_INVALID_HASH;
639 : : }
640 : :
641 : 126 : memcpy (resbuf, p, outlen);
642 : :
643 : 126 : gcry_md_close (hd);
644 : :
645 : 126 : return GC_OK;
646 : : }
647 : : #endif
648 : :
649 : : #ifdef GNULIB_GC_HMAC_MD5
650 : : Gc_rc
651 : 28 : gc_hmac_md5 (const void *key, size_t keylen,
652 : : const void *in, size_t inlen, char *resbuf)
653 : : {
654 : 28 : size_t hlen = gcry_md_get_algo_dlen (GCRY_MD_MD5);
655 : : gcry_md_hd_t mdh;
656 : : unsigned char *hash;
657 : : gpg_error_t err;
658 : :
659 [ - + ]: 28 : assert (hlen == 16);
660 : :
661 : 28 : err = gcry_md_open (&mdh, GCRY_MD_MD5, GCRY_MD_FLAG_HMAC);
662 [ - + ]: 28 : if (err != GPG_ERR_NO_ERROR)
663 : 0 : return GC_INVALID_HASH;
664 : :
665 : 28 : err = gcry_md_setkey (mdh, key, keylen);
666 [ - + ]: 28 : if (err != GPG_ERR_NO_ERROR)
667 : : {
668 : 0 : gcry_md_close (mdh);
669 : 0 : return GC_INVALID_HASH;
670 : : }
671 : :
672 : 28 : gcry_md_write (mdh, in, inlen);
673 : :
674 : 28 : hash = gcry_md_read (mdh, GCRY_MD_MD5);
675 [ - + ]: 28 : if (hash == NULL)
676 : : {
677 : 0 : gcry_md_close (mdh);
678 : 0 : return GC_INVALID_HASH;
679 : : }
680 : :
681 : 28 : memcpy (resbuf, hash, hlen);
682 : :
683 : 28 : gcry_md_close (mdh);
684 : :
685 : 28 : return GC_OK;
686 : : }
687 : : #endif
688 : :
689 : : #ifdef GNULIB_GC_HMAC_SHA1
690 : : Gc_rc
691 : 225793 : gc_hmac_sha1 (const void *key, size_t keylen,
692 : : const void *in, size_t inlen, char *resbuf)
693 : : {
694 : 225793 : size_t hlen = gcry_md_get_algo_dlen (GCRY_MD_SHA1);
695 : : gcry_md_hd_t mdh;
696 : : unsigned char *hash;
697 : : gpg_error_t err;
698 : :
699 [ - + ]: 225793 : assert (hlen == GC_SHA1_DIGEST_SIZE);
700 : :
701 : 225793 : err = gcry_md_open (&mdh, GCRY_MD_SHA1, GCRY_MD_FLAG_HMAC);
702 [ - + ]: 225793 : if (err != GPG_ERR_NO_ERROR)
703 : 0 : return GC_INVALID_HASH;
704 : :
705 : 225793 : err = gcry_md_setkey (mdh, key, keylen);
706 [ - + ]: 225793 : if (err != GPG_ERR_NO_ERROR)
707 : : {
708 : 0 : gcry_md_close (mdh);
709 : 0 : return GC_INVALID_HASH;
710 : : }
711 : :
712 : 225793 : gcry_md_write (mdh, in, inlen);
713 : :
714 : 225793 : hash = gcry_md_read (mdh, GCRY_MD_SHA1);
715 [ - + ]: 225793 : if (hash == NULL)
716 : : {
717 : 0 : gcry_md_close (mdh);
718 : 0 : return GC_INVALID_HASH;
719 : : }
720 : :
721 : 225793 : memcpy (resbuf, hash, hlen);
722 : :
723 : 225793 : gcry_md_close (mdh);
724 : :
725 : 225793 : return GC_OK;
726 : : }
727 : : #endif
|
