bufhelp: use one-byte aligned type for unaligned memory accesses
[libgcrypt.git] / cipher / cipher.c
1 /* cipher.c  -  cipher dispatcher
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003
3  *               2005, 2007, 2008, 2009, 2011 Free Software Foundation, Inc.
4  * Copyright (C) 2013 g10 Code GmbH
5  *
6  * This file is part of Libgcrypt.
7  *
8  * Libgcrypt is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU Lesser general Public License as
10  * published by the Free Software Foundation; either version 2.1 of
11  * the License, or (at your option) any later version.
12  *
13  * Libgcrypt is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <errno.h>
27
28 #include "g10lib.h"
29 #include "cipher.h"
30 #include "./cipher-internal.h"
31
32
33 /* This is the list of the default ciphers, which are included in
34    libgcrypt.  */
35 static gcry_cipher_spec_t *cipher_list[] =
36   {
37 #if USE_BLOWFISH
38      &_gcry_cipher_spec_blowfish,
39 #endif
40 #if USE_DES
41      &_gcry_cipher_spec_des,
42      &_gcry_cipher_spec_tripledes,
43 #endif
44 #if USE_ARCFOUR
45      &_gcry_cipher_spec_arcfour,
46 #endif
47 #if USE_CAST5
48      &_gcry_cipher_spec_cast5,
49 #endif
50 #if USE_AES
51      &_gcry_cipher_spec_aes,
52      &_gcry_cipher_spec_aes192,
53      &_gcry_cipher_spec_aes256,
54 #endif
55 #if USE_TWOFISH
56      &_gcry_cipher_spec_twofish,
57      &_gcry_cipher_spec_twofish128,
58 #endif
59 #if USE_SERPENT
60      &_gcry_cipher_spec_serpent128,
61      &_gcry_cipher_spec_serpent192,
62      &_gcry_cipher_spec_serpent256,
63 #endif
64 #if USE_RFC2268
65      &_gcry_cipher_spec_rfc2268_40,
66      &_gcry_cipher_spec_rfc2268_128,
67 #endif
68 #if USE_SEED
69      &_gcry_cipher_spec_seed,
70 #endif
71 #if USE_CAMELLIA
72      &_gcry_cipher_spec_camellia128,
73      &_gcry_cipher_spec_camellia192,
74      &_gcry_cipher_spec_camellia256,
75 #endif
76 #ifdef USE_IDEA
77      &_gcry_cipher_spec_idea,
78 #endif
79 #if USE_SALSA20
80      &_gcry_cipher_spec_salsa20,
81      &_gcry_cipher_spec_salsa20r12,
82 #endif
83 #if USE_GOST28147
84      &_gcry_cipher_spec_gost28147,
85 #endif
86 #if USE_CHACHA20
87      &_gcry_cipher_spec_chacha20,
88 #endif
89     NULL
90   };
91
92
93
94 \f
95 static int
96 map_algo (int algo)
97 {
98   return algo;
99 }
100
101
102 /* Return the spec structure for the cipher algorithm ALGO.  For
103    an unknown algorithm NULL is returned.  */
104 static gcry_cipher_spec_t *
105 spec_from_algo (int algo)
106 {
107   int idx;
108   gcry_cipher_spec_t *spec;
109
110   algo = map_algo (algo);
111
112   for (idx = 0; (spec = cipher_list[idx]); idx++)
113     if (algo == spec->algo)
114       return spec;
115   return NULL;
116 }
117
118
119 /* Lookup a cipher's spec by its name.  */
120 static gcry_cipher_spec_t *
121 spec_from_name (const char *name)
122 {
123   gcry_cipher_spec_t *spec;
124   int idx;
125   const char **aliases;
126
127   for (idx=0; (spec = cipher_list[idx]); idx++)
128     {
129       if (!stricmp (name, spec->name))
130         return spec;
131       if (spec->aliases)
132         {
133           for (aliases = spec->aliases; *aliases; aliases++)
134             if (!stricmp (name, *aliases))
135               return spec;
136         }
137     }
138
139   return NULL;
140 }
141
142
143 /* Lookup a cipher's spec by its OID.  */
144 static gcry_cipher_spec_t *
145 spec_from_oid (const char *oid)
146 {
147   gcry_cipher_spec_t *spec;
148   gcry_cipher_oid_spec_t *oid_specs;
149   int idx, j;
150
151   for (idx=0; (spec = cipher_list[idx]); idx++)
152     {
153       oid_specs = spec->oids;
154       if (oid_specs)
155         {
156           for (j = 0; oid_specs[j].oid; j++)
157             if (!stricmp (oid, oid_specs[j].oid))
158               return spec;
159         }
160     }
161
162   return NULL;
163 }
164
165
166 /* Locate the OID in the oid table and return the spec or NULL if not
167    found.  An optional "oid." or "OID." prefix in OID is ignored, the
168    OID is expected to be in standard IETF dotted notation.  A pointer
169    to the OID specification of the module implementing this algorithm
170    is return in OID_SPEC unless passed as NULL.*/
171 static gcry_cipher_spec_t *
172 search_oid (const char *oid, gcry_cipher_oid_spec_t *oid_spec)
173 {
174   gcry_cipher_spec_t *spec;
175   int i;
176
177   if (oid && ((! strncmp (oid, "oid.", 4))
178               || (! strncmp (oid, "OID.", 4))))
179     oid += 4;
180
181   spec = spec_from_oid (oid);
182   if (spec && spec->oids)
183     {
184       for (i = 0; spec->oids[i].oid; i++)
185         if (!stricmp (oid, spec->oids[i].oid))
186           {
187             if (oid_spec)
188               *oid_spec = spec->oids[i];
189             return spec;
190           }
191     }
192
193   return NULL;
194 }
195
196
197 /* Map STRING to the cipher algorithm identifier.  Returns the
198    algorithm ID of the cipher for the given name or 0 if the name is
199    not known.  It is valid to pass NULL for STRING which results in a
200    return value of 0. */
201 int
202 _gcry_cipher_map_name (const char *string)
203 {
204   gcry_cipher_spec_t *spec;
205
206   if (!string)
207     return 0;
208
209   /* If the string starts with a digit (optionally prefixed with
210      either "OID." or "oid."), we first look into our table of ASN.1
211      object identifiers to figure out the algorithm */
212
213   spec = search_oid (string, NULL);
214   if (spec)
215     return spec->algo;
216
217   spec = spec_from_name (string);
218   if (spec)
219     return spec->algo;
220
221   return 0;
222 }
223
224
225 /* Given a STRING with an OID in dotted decimal notation, this
226    function returns the cipher mode (GCRY_CIPHER_MODE_*) associated
227    with that OID or 0 if no mode is known.  Passing NULL for string
228    yields a return value of 0. */
229 int
230 _gcry_cipher_mode_from_oid (const char *string)
231 {
232   gcry_cipher_spec_t *spec;
233   gcry_cipher_oid_spec_t oid_spec;
234
235   if (!string)
236     return 0;
237
238   spec = search_oid (string, &oid_spec);
239   if (spec)
240     return oid_spec.mode;
241
242   return 0;
243 }
244
245
246 /* Map the cipher algorithm identifier ALGORITHM to a string
247    representing this algorithm.  This string is the default name as
248    used by Libgcrypt.  A "?" is returned for an unknown algorithm.
249    NULL is never returned. */
250 const char *
251 _gcry_cipher_algo_name (int algorithm)
252 {
253   gcry_cipher_spec_t *spec;
254
255   spec = spec_from_algo (algorithm);
256   return spec? spec->name : "?";
257 }
258
259
260 /* Flag the cipher algorithm with the identifier ALGORITHM as
261    disabled.  There is no error return, the function does nothing for
262    unknown algorithms.  Disabled algorithms are virtually not
263    available in Libgcrypt.  This is not thread safe and should thus be
264    called early. */
265 static void
266 disable_cipher_algo (int algo)
267 {
268   gcry_cipher_spec_t *spec = spec_from_algo (algo);
269
270   if (spec)
271     spec->flags.disabled = 1;
272 }
273
274
275 /* Return 0 if the cipher algorithm with identifier ALGORITHM is
276    available. Returns a basic error code value if it is not
277    available.  */
278 static gcry_err_code_t
279 check_cipher_algo (int algorithm)
280 {
281   gcry_cipher_spec_t *spec;
282
283   spec = spec_from_algo (algorithm);
284   if (spec && !spec->flags.disabled)
285     return 0;
286
287   return GPG_ERR_CIPHER_ALGO;
288 }
289
290
291 /* Return the standard length in bits of the key for the cipher
292    algorithm with the identifier ALGORITHM.  */
293 static unsigned int
294 cipher_get_keylen (int algorithm)
295 {
296   gcry_cipher_spec_t *spec;
297   unsigned len = 0;
298
299   spec = spec_from_algo (algorithm);
300   if (spec)
301     {
302       len = spec->keylen;
303       if (!len)
304         log_bug ("cipher %d w/o key length\n", algorithm);
305     }
306
307   return len;
308 }
309
310
311 /* Return the block length of the cipher algorithm with the identifier
312    ALGORITHM.  This function return 0 for an invalid algorithm.  */
313 static unsigned int
314 cipher_get_blocksize (int algorithm)
315 {
316   gcry_cipher_spec_t *spec;
317   unsigned len = 0;
318
319   spec = spec_from_algo (algorithm);
320   if (spec)
321     {
322       len = spec->blocksize;
323       if (!len)
324         log_bug ("cipher %d w/o blocksize\n", algorithm);
325     }
326
327   return len;
328 }
329
330
331 /*
332    Open a cipher handle for use with cipher algorithm ALGORITHM, using
333    the cipher mode MODE (one of the GCRY_CIPHER_MODE_*) and return a
334    handle in HANDLE.  Put NULL into HANDLE and return an error code if
335    something goes wrong.  FLAGS may be used to modify the
336    operation.  The defined flags are:
337
338    GCRY_CIPHER_SECURE:  allocate all internal buffers in secure memory.
339    GCRY_CIPHER_ENABLE_SYNC:  Enable the sync operation as used in OpenPGP.
340    GCRY_CIPHER_CBC_CTS:  Enable CTS mode.
341    GCRY_CIPHER_CBC_MAC:  Enable MAC mode.
342
343    Values for these flags may be combined using OR.
344  */
345 gcry_err_code_t
346 _gcry_cipher_open (gcry_cipher_hd_t *handle,
347                    int algo, int mode, unsigned int flags)
348 {
349   gcry_err_code_t rc;
350   gcry_cipher_hd_t h = NULL;
351
352   if (mode >= GCRY_CIPHER_MODE_INTERNAL)
353     rc = GPG_ERR_INV_CIPHER_MODE;
354   else
355     rc = _gcry_cipher_open_internal (&h, algo, mode, flags);
356
357   *handle = rc ? NULL : h;
358
359   return rc;
360 }
361
362
363 gcry_err_code_t
364 _gcry_cipher_open_internal (gcry_cipher_hd_t *handle,
365                             int algo, int mode, unsigned int flags)
366 {
367   int secure = (flags & GCRY_CIPHER_SECURE);
368   gcry_cipher_spec_t *spec;
369   gcry_cipher_hd_t h = NULL;
370   gcry_err_code_t err;
371
372   /* If the application missed to call the random poll function, we do
373      it here to ensure that it is used once in a while. */
374   _gcry_fast_random_poll ();
375
376   spec = spec_from_algo (algo);
377   if (!spec)
378     err = GPG_ERR_CIPHER_ALGO;
379   else if (spec->flags.disabled)
380     err = GPG_ERR_CIPHER_ALGO;
381   else
382     err = 0;
383
384   /* check flags */
385   if ((! err)
386       && ((flags & ~(0
387                      | GCRY_CIPHER_SECURE
388                      | GCRY_CIPHER_ENABLE_SYNC
389                      | GCRY_CIPHER_CBC_CTS
390                      | GCRY_CIPHER_CBC_MAC))
391           || (flags & GCRY_CIPHER_CBC_CTS & GCRY_CIPHER_CBC_MAC)))
392     err = GPG_ERR_CIPHER_ALGO;
393
394   /* check that a valid mode has been requested */
395   if (! err)
396     switch (mode)
397       {
398       case GCRY_CIPHER_MODE_CCM:
399 #ifdef HAVE_U64_TYPEDEF
400         if (spec->blocksize != GCRY_CCM_BLOCK_LEN)
401           err = GPG_ERR_INV_CIPHER_MODE;
402         if (!spec->encrypt || !spec->decrypt)
403           err = GPG_ERR_INV_CIPHER_MODE;
404         break;
405 #else
406         err = GPG_ERR_NOT_SUPPORTED;
407 #endif
408
409       case GCRY_CIPHER_MODE_ECB:
410       case GCRY_CIPHER_MODE_CBC:
411       case GCRY_CIPHER_MODE_CFB:
412       case GCRY_CIPHER_MODE_OFB:
413       case GCRY_CIPHER_MODE_CTR:
414       case GCRY_CIPHER_MODE_AESWRAP:
415       case GCRY_CIPHER_MODE_CMAC:
416       case GCRY_CIPHER_MODE_GCM:
417         if (!spec->encrypt || !spec->decrypt)
418           err = GPG_ERR_INV_CIPHER_MODE;
419         break;
420
421       case GCRY_CIPHER_MODE_POLY1305:
422         if (!spec->stencrypt || !spec->stdecrypt || !spec->setiv)
423           err = GPG_ERR_INV_CIPHER_MODE;
424         else if (spec->algo != GCRY_CIPHER_CHACHA20)
425           err = GPG_ERR_INV_CIPHER_MODE;
426         break;
427
428       case GCRY_CIPHER_MODE_OCB:
429         /* Note that our implementation allows only for 128 bit block
430            length algorithms.  Lower block lengths would be possible
431            but we do not implement them because they limit the
432            security too much.  */
433         if (!spec->encrypt || !spec->decrypt)
434           err = GPG_ERR_INV_CIPHER_MODE;
435         else if (spec->blocksize != (128/8))
436           err = GPG_ERR_INV_CIPHER_MODE;
437         break;
438
439       case GCRY_CIPHER_MODE_STREAM:
440         if (!spec->stencrypt || !spec->stdecrypt)
441           err = GPG_ERR_INV_CIPHER_MODE;
442         break;
443
444       case GCRY_CIPHER_MODE_NONE:
445         /* This mode may be used for debugging.  It copies the main
446            text verbatim to the ciphertext.  We do not allow this in
447            fips mode or if no debug flag has been set.  */
448         if (fips_mode () || !_gcry_get_debug_flag (0))
449           err = GPG_ERR_INV_CIPHER_MODE;
450         break;
451
452       default:
453         err = GPG_ERR_INV_CIPHER_MODE;
454       }
455
456   /* Perform selftest here and mark this with a flag in cipher_table?
457      No, we should not do this as it takes too long.  Further it does
458      not make sense to exclude algorithms with failing selftests at
459      runtime: If a selftest fails there is something seriously wrong
460      with the system and thus we better die immediately. */
461
462   if (! err)
463     {
464       size_t size = (sizeof (*h)
465                      + 2 * spec->contextsize
466                      - sizeof (cipher_context_alignment_t)
467 #ifdef NEED_16BYTE_ALIGNED_CONTEXT
468                      + 15  /* Space for leading alignment gap.  */
469 #endif /*NEED_16BYTE_ALIGNED_CONTEXT*/
470                      );
471
472       if (secure)
473         h = xtrycalloc_secure (1, size);
474       else
475         h = xtrycalloc (1, size);
476
477       if (! h)
478         err = gpg_err_code_from_syserror ();
479       else
480         {
481           size_t off = 0;
482
483 #ifdef NEED_16BYTE_ALIGNED_CONTEXT
484           if ( ((unsigned long)h & 0x0f) )
485             {
486               /* The malloced block is not aligned on a 16 byte
487                  boundary.  Correct for this.  */
488               off = 16 - ((unsigned long)h & 0x0f);
489               h = (void*)((char*)h + off);
490             }
491 #endif /*NEED_16BYTE_ALIGNED_CONTEXT*/
492
493           h->magic = secure ? CTX_MAGIC_SECURE : CTX_MAGIC_NORMAL;
494           h->actual_handle_size = size - off;
495           h->handle_offset = off;
496           h->spec = spec;
497           h->algo = algo;
498           h->mode = mode;
499           h->flags = flags;
500
501           /* Setup bulk encryption routines.  */
502           switch (algo)
503             {
504 #ifdef USE_AES
505             case GCRY_CIPHER_AES128:
506             case GCRY_CIPHER_AES192:
507             case GCRY_CIPHER_AES256:
508               h->bulk.cfb_enc = _gcry_aes_cfb_enc;
509               h->bulk.cfb_dec = _gcry_aes_cfb_dec;
510               h->bulk.cbc_enc = _gcry_aes_cbc_enc;
511               h->bulk.cbc_dec = _gcry_aes_cbc_dec;
512               h->bulk.ctr_enc = _gcry_aes_ctr_enc;
513               break;
514 #endif /*USE_AES*/
515 #ifdef USE_BLOWFISH
516             case GCRY_CIPHER_BLOWFISH:
517               h->bulk.cfb_dec = _gcry_blowfish_cfb_dec;
518               h->bulk.cbc_dec = _gcry_blowfish_cbc_dec;
519               h->bulk.ctr_enc = _gcry_blowfish_ctr_enc;
520               break;
521 #endif /*USE_BLOWFISH*/
522 #ifdef USE_CAST5
523             case GCRY_CIPHER_CAST5:
524               h->bulk.cfb_dec = _gcry_cast5_cfb_dec;
525               h->bulk.cbc_dec = _gcry_cast5_cbc_dec;
526               h->bulk.ctr_enc = _gcry_cast5_ctr_enc;
527               break;
528 #endif /*USE_CAMELLIA*/
529 #ifdef USE_CAMELLIA
530             case GCRY_CIPHER_CAMELLIA128:
531             case GCRY_CIPHER_CAMELLIA192:
532             case GCRY_CIPHER_CAMELLIA256:
533               h->bulk.cbc_dec = _gcry_camellia_cbc_dec;
534               h->bulk.cfb_dec = _gcry_camellia_cfb_dec;
535               h->bulk.ctr_enc = _gcry_camellia_ctr_enc;
536               break;
537 #endif /*USE_CAMELLIA*/
538 #ifdef USE_DES
539             case GCRY_CIPHER_3DES:
540               h->bulk.cbc_dec =  _gcry_3des_cbc_dec;
541               h->bulk.cfb_dec =  _gcry_3des_cfb_dec;
542               h->bulk.ctr_enc =  _gcry_3des_ctr_enc;
543               break;
544 #endif /*USE_DES*/
545 #ifdef USE_SERPENT
546             case GCRY_CIPHER_SERPENT128:
547             case GCRY_CIPHER_SERPENT192:
548             case GCRY_CIPHER_SERPENT256:
549               h->bulk.cbc_dec = _gcry_serpent_cbc_dec;
550               h->bulk.cfb_dec = _gcry_serpent_cfb_dec;
551               h->bulk.ctr_enc = _gcry_serpent_ctr_enc;
552               break;
553 #endif /*USE_SERPENT*/
554 #ifdef USE_TWOFISH
555             case GCRY_CIPHER_TWOFISH:
556             case GCRY_CIPHER_TWOFISH128:
557               h->bulk.cbc_dec = _gcry_twofish_cbc_dec;
558               h->bulk.cfb_dec = _gcry_twofish_cfb_dec;
559               h->bulk.ctr_enc = _gcry_twofish_ctr_enc;
560               break;
561 #endif /*USE_TWOFISH*/
562
563             default:
564               break;
565             }
566
567           /* Setup defaults depending on the mode.  */
568           switch (mode)
569             {
570             case GCRY_CIPHER_MODE_OCB:
571               h->u_mode.ocb.taglen = 16; /* Bytes.  */
572               break;
573
574             default:
575               break;
576             }
577
578         }
579     }
580
581   /* Done.  */
582
583   *handle = err ? NULL : h;
584
585   return gcry_error (err);
586 }
587
588
589 /* Release all resources associated with the cipher handle H. H may be
590    NULL in which case this is a no-operation. */
591 void
592 _gcry_cipher_close (gcry_cipher_hd_t h)
593 {
594   size_t off;
595
596   if (!h)
597     return;
598
599   if ((h->magic != CTX_MAGIC_SECURE)
600       && (h->magic != CTX_MAGIC_NORMAL))
601     _gcry_fatal_error(GPG_ERR_INTERNAL,
602                       "gcry_cipher_close: already closed/invalid handle");
603   else
604     h->magic = 0;
605
606   /* We always want to wipe out the memory even when the context has
607      been allocated in secure memory.  The user might have disabled
608      secure memory or is using his own implementation which does not
609      do the wiping.  To accomplish this we need to keep track of the
610      actual size of this structure because we have no way to known
611      how large the allocated area was when using a standard malloc. */
612   off = h->handle_offset;
613   wipememory (h, h->actual_handle_size);
614
615   xfree ((char*)h - off);
616 }
617
618
619 /* Set the key to be used for the encryption context C to KEY with
620    length KEYLEN.  The length should match the required length. */
621 static gcry_err_code_t
622 cipher_setkey (gcry_cipher_hd_t c, byte *key, size_t keylen)
623 {
624   gcry_err_code_t rc;
625
626   rc = c->spec->setkey (&c->context.c, key, keylen);
627   if (!rc)
628     {
629       /* Duplicate initial context.  */
630       memcpy ((void *) ((char *) &c->context.c + c->spec->contextsize),
631               (void *) &c->context.c,
632               c->spec->contextsize);
633       c->marks.key = 1;
634
635       switch (c->mode)
636         {
637         case GCRY_CIPHER_MODE_CMAC:
638           _gcry_cipher_cmac_set_subkeys (c);
639           break;
640
641         case GCRY_CIPHER_MODE_GCM:
642           _gcry_cipher_gcm_setkey (c);
643           break;
644
645         case GCRY_CIPHER_MODE_POLY1305:
646           _gcry_cipher_poly1305_setkey (c);
647           break;
648
649         default:
650           break;
651         };
652     }
653   else
654     c->marks.key = 0;
655
656   return rc;
657 }
658
659
660 /* Set the IV to be used for the encryption context C to IV with
661    length IVLEN.  The length should match the required length. */
662 static gcry_err_code_t
663 cipher_setiv (gcry_cipher_hd_t c, const byte *iv, size_t ivlen)
664 {
665   /* If the cipher has its own IV handler, we use only this one.  This
666      is currently used for stream ciphers requiring a nonce.  */
667   if (c->spec->setiv)
668     {
669       c->spec->setiv (&c->context.c, iv, ivlen);
670       return 0;
671     }
672
673   memset (c->u_iv.iv, 0, c->spec->blocksize);
674   if (iv)
675     {
676       if (ivlen != c->spec->blocksize)
677         {
678           log_info ("WARNING: cipher_setiv: ivlen=%u blklen=%u\n",
679                     (unsigned int)ivlen, (unsigned int)c->spec->blocksize);
680           fips_signal_error ("IV length does not match blocklength");
681         }
682       if (ivlen > c->spec->blocksize)
683         ivlen = c->spec->blocksize;
684       memcpy (c->u_iv.iv, iv, ivlen);
685       c->marks.iv = 1;
686     }
687   else
688       c->marks.iv = 0;
689   c->unused = 0;
690
691   return 0;
692 }
693
694
695 /* Reset the cipher context to the initial context.  This is basically
696    the same as an release followed by a new. */
697 static void
698 cipher_reset (gcry_cipher_hd_t c)
699 {
700   unsigned int marks_key;
701
702   marks_key = c->marks.key;
703
704   memcpy (&c->context.c,
705           (char *) &c->context.c + c->spec->contextsize,
706           c->spec->contextsize);
707   memset (&c->marks, 0, sizeof c->marks);
708   memset (c->u_iv.iv, 0, c->spec->blocksize);
709   memset (c->lastiv, 0, c->spec->blocksize);
710   memset (c->u_ctr.ctr, 0, c->spec->blocksize);
711   c->unused = 0;
712
713   c->marks.key = marks_key;
714
715   switch (c->mode)
716     {
717     case GCRY_CIPHER_MODE_CMAC:
718       /* Only clear 'tag' for cmac, keep subkeys. */
719       c->u_mode.cmac.tag = 0;
720       break;
721
722     case GCRY_CIPHER_MODE_GCM:
723       /* Only clear head of u_mode, keep ghash_key and gcm_table. */
724       {
725         byte *u_mode_pos = (void *)&c->u_mode;
726         byte *ghash_key_pos = c->u_mode.gcm.u_ghash_key.key;
727         size_t u_mode_head_length = ghash_key_pos - u_mode_pos;
728
729         memset (&c->u_mode, 0, u_mode_head_length);
730       }
731       break;
732
733     case GCRY_CIPHER_MODE_POLY1305:
734       memset (&c->u_mode.poly1305, 0, sizeof c->u_mode.poly1305);
735       break;
736
737 #ifdef HAVE_U64_TYPEDEF
738     case GCRY_CIPHER_MODE_CCM:
739       memset (&c->u_mode.ccm, 0, sizeof c->u_mode.ccm);
740       break;
741 #endif
742
743     case GCRY_CIPHER_MODE_OCB:
744       memset (&c->u_mode.ocb, 0, sizeof c->u_mode.ocb);
745       break;
746
747     default:
748       break; /* u_mode unused by other modes. */
749     }
750 }
751
752
753 \f
754 static gcry_err_code_t
755 do_ecb_crypt (gcry_cipher_hd_t c,
756               unsigned char *outbuf, size_t outbuflen,
757               const unsigned char *inbuf, size_t inbuflen,
758               gcry_cipher_encrypt_t crypt_fn)
759 {
760   unsigned int blocksize = c->spec->blocksize;
761   size_t n, nblocks;
762   unsigned int burn, nburn;
763
764   if (outbuflen < inbuflen)
765     return GPG_ERR_BUFFER_TOO_SHORT;
766   if ((inbuflen % blocksize))
767     return GPG_ERR_INV_LENGTH;
768
769   nblocks = inbuflen / blocksize;
770   burn = 0;
771
772   for (n=0; n < nblocks; n++ )
773     {
774       nburn = crypt_fn (&c->context.c, outbuf, inbuf);
775       burn = nburn > burn ? nburn : burn;
776       inbuf  += blocksize;
777       outbuf += blocksize;
778     }
779
780   if (burn > 0)
781     _gcry_burn_stack (burn + 4 * sizeof(void *));
782
783   return 0;
784 }
785
786 static gcry_err_code_t
787 do_ecb_encrypt (gcry_cipher_hd_t c,
788                 unsigned char *outbuf, size_t outbuflen,
789                 const unsigned char *inbuf, size_t inbuflen)
790 {
791   return do_ecb_crypt (c, outbuf, outbuflen, inbuf, inbuflen, c->spec->encrypt);
792 }
793
794 static gcry_err_code_t
795 do_ecb_decrypt (gcry_cipher_hd_t c,
796                 unsigned char *outbuf, size_t outbuflen,
797                 const unsigned char *inbuf, size_t inbuflen)
798 {
799   return do_ecb_crypt (c, outbuf, outbuflen, inbuf, inbuflen, c->spec->decrypt);
800 }
801
802
803 /****************
804  * Encrypt INBUF to OUTBUF with the mode selected at open.
805  * inbuf and outbuf may overlap or be the same.
806  * Depending on the mode some constraints apply to INBUFLEN.
807  */
808 static gcry_err_code_t
809 cipher_encrypt (gcry_cipher_hd_t c, byte *outbuf, size_t outbuflen,
810                 const byte *inbuf, size_t inbuflen)
811 {
812   gcry_err_code_t rc;
813
814   switch (c->mode)
815     {
816     case GCRY_CIPHER_MODE_ECB:
817       rc = do_ecb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
818       break;
819
820     case GCRY_CIPHER_MODE_CBC:
821       rc = _gcry_cipher_cbc_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
822       break;
823
824     case GCRY_CIPHER_MODE_CFB:
825       rc = _gcry_cipher_cfb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
826       break;
827
828     case GCRY_CIPHER_MODE_OFB:
829       rc = _gcry_cipher_ofb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
830       break;
831
832     case GCRY_CIPHER_MODE_CTR:
833       rc = _gcry_cipher_ctr_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
834       break;
835
836     case GCRY_CIPHER_MODE_AESWRAP:
837       rc = _gcry_cipher_aeswrap_encrypt (c, outbuf, outbuflen,
838                                          inbuf, inbuflen);
839       break;
840
841     case GCRY_CIPHER_MODE_CCM:
842       rc = _gcry_cipher_ccm_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
843       break;
844
845     case GCRY_CIPHER_MODE_CMAC:
846       rc = GPG_ERR_INV_CIPHER_MODE;
847       break;
848
849     case GCRY_CIPHER_MODE_GCM:
850       rc = _gcry_cipher_gcm_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
851       break;
852
853     case GCRY_CIPHER_MODE_POLY1305:
854       rc = _gcry_cipher_poly1305_encrypt (c, outbuf, outbuflen,
855                                           inbuf, inbuflen);
856       break;
857
858     case GCRY_CIPHER_MODE_OCB:
859       rc = _gcry_cipher_ocb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
860       break;
861
862     case GCRY_CIPHER_MODE_STREAM:
863       c->spec->stencrypt (&c->context.c,
864                           outbuf, (byte*)/*arggg*/inbuf, inbuflen);
865       rc = 0;
866       break;
867
868     case GCRY_CIPHER_MODE_NONE:
869       if (fips_mode () || !_gcry_get_debug_flag (0))
870         {
871           fips_signal_error ("cipher mode NONE used");
872           rc = GPG_ERR_INV_CIPHER_MODE;
873         }
874       else
875         {
876           if (inbuf != outbuf)
877             memmove (outbuf, inbuf, inbuflen);
878           rc = 0;
879         }
880       break;
881
882     default:
883       log_fatal ("cipher_encrypt: invalid mode %d\n", c->mode );
884       rc = GPG_ERR_INV_CIPHER_MODE;
885       break;
886     }
887
888   return rc;
889 }
890
891
892 /****************
893  * Encrypt IN and write it to OUT.  If IN is NULL, in-place encryption has
894  * been requested.
895  */
896 gcry_err_code_t
897 _gcry_cipher_encrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
898                       const void *in, size_t inlen)
899 {
900   gcry_err_code_t rc;
901
902   if (!in)  /* Caller requested in-place encryption.  */
903     {
904       in = out;
905       inlen = outsize;
906     }
907
908   rc = cipher_encrypt (h, out, outsize, in, inlen);
909
910   /* Failsafe: Make sure that the plaintext will never make it into
911      OUT if the encryption returned an error.  */
912   if (rc && out)
913     memset (out, 0x42, outsize);
914
915   return rc;
916 }
917
918
919
920 /****************
921  * Decrypt INBUF to OUTBUF with the mode selected at open.
922  * inbuf and outbuf may overlap or be the same.
923  * Depending on the mode some some contraints apply to INBUFLEN.
924  */
925 static gcry_err_code_t
926 cipher_decrypt (gcry_cipher_hd_t c, byte *outbuf, size_t outbuflen,
927                 const byte *inbuf, size_t inbuflen)
928 {
929   gcry_err_code_t rc;
930
931   switch (c->mode)
932     {
933     case GCRY_CIPHER_MODE_ECB:
934       rc = do_ecb_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
935       break;
936
937     case GCRY_CIPHER_MODE_CBC:
938       rc = _gcry_cipher_cbc_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
939       break;
940
941     case GCRY_CIPHER_MODE_CFB:
942       rc = _gcry_cipher_cfb_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
943       break;
944
945     case GCRY_CIPHER_MODE_OFB:
946       rc = _gcry_cipher_ofb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
947       break;
948
949     case GCRY_CIPHER_MODE_CTR:
950       rc = _gcry_cipher_ctr_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
951       break;
952
953     case GCRY_CIPHER_MODE_AESWRAP:
954       rc = _gcry_cipher_aeswrap_decrypt (c, outbuf, outbuflen,
955                                          inbuf, inbuflen);
956       break;
957
958     case GCRY_CIPHER_MODE_CCM:
959       rc = _gcry_cipher_ccm_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
960       break;
961
962     case GCRY_CIPHER_MODE_CMAC:
963       rc = GPG_ERR_INV_CIPHER_MODE;
964       break;
965
966     case GCRY_CIPHER_MODE_GCM:
967       rc = _gcry_cipher_gcm_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
968       break;
969
970     case GCRY_CIPHER_MODE_POLY1305:
971       rc = _gcry_cipher_poly1305_decrypt (c, outbuf, outbuflen,
972                                           inbuf, inbuflen);
973       break;
974
975     case GCRY_CIPHER_MODE_OCB:
976       rc = _gcry_cipher_ocb_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
977       break;
978
979     case GCRY_CIPHER_MODE_STREAM:
980       c->spec->stdecrypt (&c->context.c,
981                           outbuf, (byte*)/*arggg*/inbuf, inbuflen);
982       rc = 0;
983       break;
984
985     case GCRY_CIPHER_MODE_NONE:
986       if (fips_mode () || !_gcry_get_debug_flag (0))
987         {
988           fips_signal_error ("cipher mode NONE used");
989           rc = GPG_ERR_INV_CIPHER_MODE;
990         }
991       else
992         {
993           if (inbuf != outbuf)
994             memmove (outbuf, inbuf, inbuflen);
995           rc = 0;
996         }
997       break;
998
999     default:
1000       log_fatal ("cipher_decrypt: invalid mode %d\n", c->mode );
1001       rc = GPG_ERR_INV_CIPHER_MODE;
1002       break;
1003     }
1004
1005   return rc;
1006 }
1007
1008
1009 gcry_err_code_t
1010 _gcry_cipher_decrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
1011                       const void *in, size_t inlen)
1012 {
1013   if (!in) /* Caller requested in-place encryption. */
1014     {
1015       in = out;
1016       inlen = outsize;
1017     }
1018
1019   return cipher_decrypt (h, out, outsize, in, inlen);
1020 }
1021
1022
1023
1024 /****************
1025  * Used for PGP's somewhat strange CFB mode. Only works if
1026  * the corresponding flag is set.
1027  */
1028 static void
1029 cipher_sync (gcry_cipher_hd_t c)
1030 {
1031   if ((c->flags & GCRY_CIPHER_ENABLE_SYNC) && c->unused)
1032     {
1033       memmove (c->u_iv.iv + c->unused,
1034                c->u_iv.iv, c->spec->blocksize - c->unused);
1035       memcpy (c->u_iv.iv,
1036               c->lastiv + c->spec->blocksize - c->unused, c->unused);
1037       c->unused = 0;
1038     }
1039 }
1040
1041
1042 gcry_err_code_t
1043 _gcry_cipher_setkey (gcry_cipher_hd_t hd, const void *key, size_t keylen)
1044 {
1045   return cipher_setkey (hd, (void*)key, keylen);
1046 }
1047
1048
1049 gcry_err_code_t
1050 _gcry_cipher_setiv (gcry_cipher_hd_t hd, const void *iv, size_t ivlen)
1051 {
1052   gcry_err_code_t rc = 0;
1053
1054   switch (hd->mode)
1055     {
1056       case GCRY_CIPHER_MODE_CCM:
1057         rc = _gcry_cipher_ccm_set_nonce (hd, iv, ivlen);
1058         break;
1059
1060       case GCRY_CIPHER_MODE_GCM:
1061         rc =  _gcry_cipher_gcm_setiv (hd, iv, ivlen);
1062         break;
1063
1064       case GCRY_CIPHER_MODE_POLY1305:
1065         rc =  _gcry_cipher_poly1305_setiv (hd, iv, ivlen);
1066         break;
1067
1068       case GCRY_CIPHER_MODE_OCB:
1069         rc = _gcry_cipher_ocb_set_nonce (hd, iv, ivlen);
1070         break;
1071
1072       default:
1073         rc = cipher_setiv (hd, iv, ivlen);
1074         break;
1075     }
1076   return rc;
1077 }
1078
1079 /* Set counter for CTR mode.  (CTR,CTRLEN) must denote a buffer of
1080    block size length, or (NULL,0) to set the CTR to the all-zero
1081    block. */
1082 gpg_err_code_t
1083 _gcry_cipher_setctr (gcry_cipher_hd_t hd, const void *ctr, size_t ctrlen)
1084 {
1085   if (ctr && ctrlen == hd->spec->blocksize)
1086     {
1087       memcpy (hd->u_ctr.ctr, ctr, hd->spec->blocksize);
1088       hd->unused = 0;
1089     }
1090   else if (!ctr || !ctrlen)
1091     {
1092       memset (hd->u_ctr.ctr, 0, hd->spec->blocksize);
1093       hd->unused = 0;
1094     }
1095   else
1096     return GPG_ERR_INV_ARG;
1097
1098   return 0;
1099 }
1100
1101
1102 gcry_err_code_t
1103 _gcry_cipher_authenticate (gcry_cipher_hd_t hd, const void *abuf,
1104                            size_t abuflen)
1105 {
1106   gcry_err_code_t rc;
1107
1108   switch (hd->mode)
1109     {
1110     case GCRY_CIPHER_MODE_CCM:
1111       rc = _gcry_cipher_ccm_authenticate (hd, abuf, abuflen);
1112       break;
1113
1114     case GCRY_CIPHER_MODE_CMAC:
1115       rc = _gcry_cipher_cmac_authenticate (hd, abuf, abuflen);
1116       break;
1117
1118     case GCRY_CIPHER_MODE_GCM:
1119       rc = _gcry_cipher_gcm_authenticate (hd, abuf, abuflen);
1120       break;
1121
1122     case GCRY_CIPHER_MODE_POLY1305:
1123       rc = _gcry_cipher_poly1305_authenticate (hd, abuf, abuflen);
1124       break;
1125
1126     case GCRY_CIPHER_MODE_OCB:
1127       rc = _gcry_cipher_ocb_authenticate (hd, abuf, abuflen);
1128       break;
1129
1130     default:
1131       log_error ("gcry_cipher_authenticate: invalid mode %d\n", hd->mode);
1132       rc = GPG_ERR_INV_CIPHER_MODE;
1133       break;
1134     }
1135
1136   return rc;
1137 }
1138
1139
1140 gcry_err_code_t
1141 _gcry_cipher_gettag (gcry_cipher_hd_t hd, void *outtag, size_t taglen)
1142 {
1143   gcry_err_code_t rc;
1144
1145   switch (hd->mode)
1146     {
1147     case GCRY_CIPHER_MODE_CCM:
1148       rc = _gcry_cipher_ccm_get_tag (hd, outtag, taglen);
1149       break;
1150
1151     case GCRY_CIPHER_MODE_CMAC:
1152       rc = _gcry_cipher_cmac_get_tag (hd, outtag, taglen);
1153       break;
1154
1155     case GCRY_CIPHER_MODE_GCM:
1156       rc = _gcry_cipher_gcm_get_tag (hd, outtag, taglen);
1157       break;
1158
1159     case GCRY_CIPHER_MODE_POLY1305:
1160       rc = _gcry_cipher_poly1305_get_tag (hd, outtag, taglen);
1161       break;
1162
1163     case GCRY_CIPHER_MODE_OCB:
1164       rc = _gcry_cipher_ocb_get_tag (hd, outtag, taglen);
1165       break;
1166
1167     default:
1168       log_error ("gcry_cipher_gettag: invalid mode %d\n", hd->mode);
1169       rc = GPG_ERR_INV_CIPHER_MODE;
1170       break;
1171     }
1172
1173   return rc;
1174 }
1175
1176
1177 gcry_err_code_t
1178 _gcry_cipher_checktag (gcry_cipher_hd_t hd, const void *intag, size_t taglen)
1179 {
1180   gcry_err_code_t rc;
1181
1182   switch (hd->mode)
1183     {
1184     case GCRY_CIPHER_MODE_CCM:
1185       rc = _gcry_cipher_ccm_check_tag (hd, intag, taglen);
1186       break;
1187
1188     case GCRY_CIPHER_MODE_CMAC:
1189       rc = _gcry_cipher_cmac_check_tag (hd, intag, taglen);
1190       break;
1191
1192     case GCRY_CIPHER_MODE_GCM:
1193       rc = _gcry_cipher_gcm_check_tag (hd, intag, taglen);
1194       break;
1195
1196     case GCRY_CIPHER_MODE_POLY1305:
1197       rc = _gcry_cipher_poly1305_check_tag (hd, intag, taglen);
1198       break;
1199
1200     case GCRY_CIPHER_MODE_OCB:
1201       rc = _gcry_cipher_ocb_check_tag (hd, intag, taglen);
1202       break;
1203
1204     default:
1205       log_error ("gcry_cipher_checktag: invalid mode %d\n", hd->mode);
1206       rc = GPG_ERR_INV_CIPHER_MODE;
1207       break;
1208     }
1209
1210   return rc;
1211 }
1212
1213
1214 gcry_err_code_t
1215 _gcry_cipher_ctl (gcry_cipher_hd_t h, int cmd, void *buffer, size_t buflen)
1216 {
1217   gcry_err_code_t rc = 0;
1218
1219   switch (cmd)
1220     {
1221     case GCRYCTL_RESET:
1222       cipher_reset (h);
1223       break;
1224
1225     case GCRYCTL_FINALIZE:
1226       if (!h || buffer || buflen)
1227         return GPG_ERR_INV_ARG;
1228       h->marks.finalize = 1;
1229       break;
1230
1231     case GCRYCTL_CFB_SYNC:
1232       cipher_sync( h );
1233       break;
1234
1235     case GCRYCTL_SET_CBC_CTS:
1236       if (buflen)
1237         if (h->flags & GCRY_CIPHER_CBC_MAC)
1238           rc = GPG_ERR_INV_FLAG;
1239         else
1240           h->flags |= GCRY_CIPHER_CBC_CTS;
1241       else
1242         h->flags &= ~GCRY_CIPHER_CBC_CTS;
1243       break;
1244
1245     case GCRYCTL_SET_CBC_MAC:
1246       if (buflen)
1247         if (h->flags & GCRY_CIPHER_CBC_CTS)
1248           rc = GPG_ERR_INV_FLAG;
1249         else
1250           h->flags |= GCRY_CIPHER_CBC_MAC;
1251       else
1252         h->flags &= ~GCRY_CIPHER_CBC_MAC;
1253       break;
1254
1255     case GCRYCTL_SET_CCM_LENGTHS:
1256 #ifdef HAVE_U64_TYPEDEF
1257       {
1258         u64 params[3];
1259         size_t encryptedlen;
1260         size_t aadlen;
1261         size_t authtaglen;
1262
1263         if (h->mode != GCRY_CIPHER_MODE_CCM)
1264           return gcry_error (GPG_ERR_INV_CIPHER_MODE);
1265
1266         if (!buffer || buflen != 3 * sizeof(u64))
1267           return gcry_error (GPG_ERR_INV_ARG);
1268
1269         /* This command is used to pass additional length parameters needed
1270            by CCM mode to initialize CBC-MAC.  */
1271         memcpy (params, buffer, sizeof(params));
1272         encryptedlen = params[0];
1273         aadlen = params[1];
1274         authtaglen = params[2];
1275
1276         rc = _gcry_cipher_ccm_set_lengths (h, encryptedlen, aadlen, authtaglen);
1277       }
1278 #else
1279       rc = GPG_ERR_NOT_SUPPORTED;
1280 #endif
1281       break;
1282
1283     case GCRYCTL_SET_TAGLEN:
1284       if (!h || !buffer || buflen != sizeof(int) )
1285         return GPG_ERR_INV_ARG;
1286       switch (h->mode)
1287         {
1288         case GCRY_CIPHER_MODE_OCB:
1289           switch (*(int*)buffer)
1290             {
1291             case 8: case 12: case 16:
1292               h->u_mode.ocb.taglen = *(int*)buffer;
1293               break;
1294             default:
1295               rc = GPG_ERR_INV_LENGTH; /* Invalid tag length. */
1296               break;
1297             }
1298           break;
1299
1300         default:
1301           rc =GPG_ERR_INV_CIPHER_MODE;
1302           break;
1303         }
1304       break;
1305
1306     case GCRYCTL_DISABLE_ALGO:
1307       /* This command expects NULL for H and BUFFER to point to an
1308          integer with the algo number.  */
1309       if( h || !buffer || buflen != sizeof(int) )
1310         return gcry_error (GPG_ERR_CIPHER_ALGO);
1311       disable_cipher_algo( *(int*)buffer );
1312       break;
1313
1314     case 61:  /* Disable weak key detection (private).  */
1315       if (h->spec->set_extra_info)
1316         rc = h->spec->set_extra_info
1317           (&h->context.c, CIPHER_INFO_NO_WEAK_KEY, NULL, 0);
1318       else
1319         rc = GPG_ERR_NOT_SUPPORTED;
1320       break;
1321
1322     case 62: /* Return current input vector (private).  */
1323       /* This is the input block as used in CFB and OFB mode which has
1324          initially been set as IV.  The returned format is:
1325            1 byte  Actual length of the block in bytes.
1326            n byte  The block.
1327          If the provided buffer is too short, an error is returned. */
1328       if (buflen < (1 + h->spec->blocksize))
1329         rc = GPG_ERR_TOO_SHORT;
1330       else
1331         {
1332           unsigned char *ivp;
1333           unsigned char *dst = buffer;
1334           int n = h->unused;
1335
1336           if (!n)
1337             n = h->spec->blocksize;
1338           gcry_assert (n <= h->spec->blocksize);
1339           *dst++ = n;
1340           ivp = h->u_iv.iv + h->spec->blocksize - n;
1341           while (n--)
1342             *dst++ = *ivp++;
1343         }
1344       break;
1345
1346     case GCRYCTL_SET_SBOX:
1347       if (h->spec->set_extra_info)
1348         rc = h->spec->set_extra_info
1349           (&h->context.c, GCRYCTL_SET_SBOX, buffer, buflen);
1350       else
1351         rc = GPG_ERR_NOT_SUPPORTED;
1352
1353     default:
1354       rc = GPG_ERR_INV_OP;
1355     }
1356
1357   return rc;
1358 }
1359
1360
1361 /* Return information about the cipher handle H.  CMD is the kind of
1362    information requested.  BUFFER and NBYTES are reserved for now.
1363
1364    There are no values for CMD yet defined.
1365
1366    The function always returns GPG_ERR_INV_OP.
1367
1368  */
1369 gcry_err_code_t
1370 _gcry_cipher_info (gcry_cipher_hd_t h, int cmd, void *buffer, size_t *nbytes)
1371 {
1372   gcry_err_code_t rc = 0;
1373
1374   (void)h;
1375   (void)buffer;
1376   (void)nbytes;
1377
1378   switch (cmd)
1379     {
1380     default:
1381       rc = GPG_ERR_INV_OP;
1382     }
1383
1384   return rc;
1385 }
1386
1387 /* Return information about the given cipher algorithm ALGO.
1388
1389    WHAT select the kind of information returned:
1390
1391     GCRYCTL_GET_KEYLEN:
1392         Return the length of the key.  If the algorithm ALGO
1393         supports multiple key lengths, the maximum supported key length
1394         is returned.  The key length is returned as number of octets.
1395         BUFFER and NBYTES must be zero.
1396
1397     GCRYCTL_GET_BLKLEN:
1398         Return the blocklength of the algorithm ALGO counted in octets.
1399         BUFFER and NBYTES must be zero.
1400
1401     GCRYCTL_TEST_ALGO:
1402         Returns 0 if the specified algorithm ALGO is available for use.
1403         BUFFER and NBYTES must be zero.
1404
1405    Note: Because this function is in most cases used to return an
1406    integer value, we can make it easier for the caller to just look at
1407    the return value.  The caller will in all cases consult the value
1408    and thereby detecting whether a error occurred or not (i.e. while
1409    checking the block size)
1410  */
1411 gcry_err_code_t
1412 _gcry_cipher_algo_info (int algo, int what, void *buffer, size_t *nbytes)
1413 {
1414   gcry_err_code_t rc = 0;
1415   unsigned int ui;
1416
1417   switch (what)
1418     {
1419     case GCRYCTL_GET_KEYLEN:
1420       if (buffer || (! nbytes))
1421         rc = GPG_ERR_CIPHER_ALGO;
1422       else
1423         {
1424           ui = cipher_get_keylen (algo);
1425           if ((ui > 0) && (ui <= 512))
1426             *nbytes = (size_t) ui / 8;
1427           else
1428             /* The only reason for an error is an invalid algo.  */
1429             rc = GPG_ERR_CIPHER_ALGO;
1430         }
1431       break;
1432
1433     case GCRYCTL_GET_BLKLEN:
1434       if (buffer || (! nbytes))
1435         rc = GPG_ERR_CIPHER_ALGO;
1436       else
1437         {
1438           ui = cipher_get_blocksize (algo);
1439           if ((ui > 0) && (ui < 10000))
1440             *nbytes = ui;
1441           else
1442             {
1443               /* The only reason is an invalid algo or a strange
1444                  blocksize.  */
1445               rc = GPG_ERR_CIPHER_ALGO;
1446             }
1447         }
1448       break;
1449
1450     case GCRYCTL_TEST_ALGO:
1451       if (buffer || nbytes)
1452         rc = GPG_ERR_INV_ARG;
1453       else
1454         rc = check_cipher_algo (algo);
1455       break;
1456
1457       default:
1458         rc = GPG_ERR_INV_OP;
1459     }
1460
1461   return rc;
1462 }
1463
1464
1465 /* This function returns length of the key for algorithm ALGO.  If the
1466    algorithm supports multiple key lengths, the maximum supported key
1467    length is returned.  On error 0 is returned.  The key length is
1468    returned as number of octets.
1469
1470    This is a convenience functions which should be preferred over
1471    gcry_cipher_algo_info because it allows for proper type
1472    checking.  */
1473 size_t
1474 _gcry_cipher_get_algo_keylen (int algo)
1475 {
1476   size_t n;
1477
1478   if (_gcry_cipher_algo_info (algo, GCRYCTL_GET_KEYLEN, NULL, &n))
1479     n = 0;
1480   return n;
1481 }
1482
1483
1484 /* This functions returns the blocklength of the algorithm ALGO
1485    counted in octets.  On error 0 is returned.
1486
1487    This is a convenience functions which should be preferred over
1488    gcry_cipher_algo_info because it allows for proper type
1489    checking.  */
1490 size_t
1491 _gcry_cipher_get_algo_blklen (int algo)
1492 {
1493   size_t n;
1494
1495   if (_gcry_cipher_algo_info( algo, GCRYCTL_GET_BLKLEN, NULL, &n))
1496     n = 0;
1497   return n;
1498 }
1499
1500
1501 /* Explicitly initialize this module.  */
1502 gcry_err_code_t
1503 _gcry_cipher_init (void)
1504 {
1505   return 0;
1506 }
1507
1508
1509 /* Run the selftests for cipher algorithm ALGO with optional reporting
1510    function REPORT.  */
1511 gpg_error_t
1512 _gcry_cipher_selftest (int algo, int extended, selftest_report_func_t report)
1513 {
1514   gcry_err_code_t ec = 0;
1515   gcry_cipher_spec_t *spec;
1516
1517   spec = spec_from_algo (algo);
1518   if (spec && !spec->flags.disabled && spec->selftest)
1519     ec = spec->selftest (algo, extended, report);
1520   else
1521     {
1522       ec = GPG_ERR_CIPHER_ALGO;
1523       if (report)
1524         report ("cipher", algo, "module",
1525                 (spec && !spec->flags.disabled)?
1526                 "no selftest available" :
1527                 spec? "algorithm disabled" : "algorithm not found");
1528     }
1529
1530   return gpg_error (ec);
1531 }