Add bulk OCB for Twofish AMD64 implementation
[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 ( ((uintptr_t)h & 0x0f) )
485             {
486               /* The malloced block is not aligned on a 16 byte
487                  boundary.  Correct for this.  */
488               off = 16 - ((uintptr_t)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               h->bulk.ocb_crypt = _gcry_aes_ocb_crypt;
514               h->bulk.ocb_auth  = _gcry_aes_ocb_auth;
515               break;
516 #endif /*USE_AES*/
517 #ifdef USE_BLOWFISH
518             case GCRY_CIPHER_BLOWFISH:
519               h->bulk.cfb_dec = _gcry_blowfish_cfb_dec;
520               h->bulk.cbc_dec = _gcry_blowfish_cbc_dec;
521               h->bulk.ctr_enc = _gcry_blowfish_ctr_enc;
522               break;
523 #endif /*USE_BLOWFISH*/
524 #ifdef USE_CAST5
525             case GCRY_CIPHER_CAST5:
526               h->bulk.cfb_dec = _gcry_cast5_cfb_dec;
527               h->bulk.cbc_dec = _gcry_cast5_cbc_dec;
528               h->bulk.ctr_enc = _gcry_cast5_ctr_enc;
529               break;
530 #endif /*USE_CAMELLIA*/
531 #ifdef USE_CAMELLIA
532             case GCRY_CIPHER_CAMELLIA128:
533             case GCRY_CIPHER_CAMELLIA192:
534             case GCRY_CIPHER_CAMELLIA256:
535               h->bulk.cbc_dec = _gcry_camellia_cbc_dec;
536               h->bulk.cfb_dec = _gcry_camellia_cfb_dec;
537               h->bulk.ctr_enc = _gcry_camellia_ctr_enc;
538               h->bulk.ocb_crypt = _gcry_camellia_ocb_crypt;
539               h->bulk.ocb_auth  = _gcry_camellia_ocb_auth;
540               break;
541 #endif /*USE_CAMELLIA*/
542 #ifdef USE_DES
543             case GCRY_CIPHER_3DES:
544               h->bulk.cbc_dec =  _gcry_3des_cbc_dec;
545               h->bulk.cfb_dec =  _gcry_3des_cfb_dec;
546               h->bulk.ctr_enc =  _gcry_3des_ctr_enc;
547               break;
548 #endif /*USE_DES*/
549 #ifdef USE_SERPENT
550             case GCRY_CIPHER_SERPENT128:
551             case GCRY_CIPHER_SERPENT192:
552             case GCRY_CIPHER_SERPENT256:
553               h->bulk.cbc_dec = _gcry_serpent_cbc_dec;
554               h->bulk.cfb_dec = _gcry_serpent_cfb_dec;
555               h->bulk.ctr_enc = _gcry_serpent_ctr_enc;
556               break;
557 #endif /*USE_SERPENT*/
558 #ifdef USE_TWOFISH
559             case GCRY_CIPHER_TWOFISH:
560             case GCRY_CIPHER_TWOFISH128:
561               h->bulk.cbc_dec = _gcry_twofish_cbc_dec;
562               h->bulk.cfb_dec = _gcry_twofish_cfb_dec;
563               h->bulk.ctr_enc = _gcry_twofish_ctr_enc;
564               h->bulk.ocb_crypt = _gcry_twofish_ocb_crypt;
565               h->bulk.ocb_auth  = _gcry_twofish_ocb_auth;
566               break;
567 #endif /*USE_TWOFISH*/
568
569             default:
570               break;
571             }
572
573           /* Setup defaults depending on the mode.  */
574           switch (mode)
575             {
576             case GCRY_CIPHER_MODE_OCB:
577               h->u_mode.ocb.taglen = 16; /* Bytes.  */
578               break;
579
580             default:
581               break;
582             }
583
584         }
585     }
586
587   /* Done.  */
588
589   *handle = err ? NULL : h;
590
591   return gcry_error (err);
592 }
593
594
595 /* Release all resources associated with the cipher handle H. H may be
596    NULL in which case this is a no-operation. */
597 void
598 _gcry_cipher_close (gcry_cipher_hd_t h)
599 {
600   size_t off;
601
602   if (!h)
603     return;
604
605   if ((h->magic != CTX_MAGIC_SECURE)
606       && (h->magic != CTX_MAGIC_NORMAL))
607     _gcry_fatal_error(GPG_ERR_INTERNAL,
608                       "gcry_cipher_close: already closed/invalid handle");
609   else
610     h->magic = 0;
611
612   /* We always want to wipe out the memory even when the context has
613      been allocated in secure memory.  The user might have disabled
614      secure memory or is using his own implementation which does not
615      do the wiping.  To accomplish this we need to keep track of the
616      actual size of this structure because we have no way to known
617      how large the allocated area was when using a standard malloc. */
618   off = h->handle_offset;
619   wipememory (h, h->actual_handle_size);
620
621   xfree ((char*)h - off);
622 }
623
624
625 /* Set the key to be used for the encryption context C to KEY with
626    length KEYLEN.  The length should match the required length. */
627 static gcry_err_code_t
628 cipher_setkey (gcry_cipher_hd_t c, byte *key, size_t keylen)
629 {
630   gcry_err_code_t rc;
631
632   rc = c->spec->setkey (&c->context.c, key, keylen);
633   if (!rc)
634     {
635       /* Duplicate initial context.  */
636       memcpy ((void *) ((char *) &c->context.c + c->spec->contextsize),
637               (void *) &c->context.c,
638               c->spec->contextsize);
639       c->marks.key = 1;
640
641       switch (c->mode)
642         {
643         case GCRY_CIPHER_MODE_CMAC:
644           _gcry_cipher_cmac_set_subkeys (c);
645           break;
646
647         case GCRY_CIPHER_MODE_GCM:
648           _gcry_cipher_gcm_setkey (c);
649           break;
650
651         case GCRY_CIPHER_MODE_POLY1305:
652           _gcry_cipher_poly1305_setkey (c);
653           break;
654
655         default:
656           break;
657         };
658     }
659   else
660     c->marks.key = 0;
661
662   return rc;
663 }
664
665
666 /* Set the IV to be used for the encryption context C to IV with
667    length IVLEN.  The length should match the required length. */
668 static gcry_err_code_t
669 cipher_setiv (gcry_cipher_hd_t c, const byte *iv, size_t ivlen)
670 {
671   /* If the cipher has its own IV handler, we use only this one.  This
672      is currently used for stream ciphers requiring a nonce.  */
673   if (c->spec->setiv)
674     {
675       c->spec->setiv (&c->context.c, iv, ivlen);
676       return 0;
677     }
678
679   memset (c->u_iv.iv, 0, c->spec->blocksize);
680   if (iv)
681     {
682       if (ivlen != c->spec->blocksize)
683         {
684           log_info ("WARNING: cipher_setiv: ivlen=%u blklen=%u\n",
685                     (unsigned int)ivlen, (unsigned int)c->spec->blocksize);
686           fips_signal_error ("IV length does not match blocklength");
687         }
688       if (ivlen > c->spec->blocksize)
689         ivlen = c->spec->blocksize;
690       memcpy (c->u_iv.iv, iv, ivlen);
691       c->marks.iv = 1;
692     }
693   else
694       c->marks.iv = 0;
695   c->unused = 0;
696
697   return 0;
698 }
699
700
701 /* Reset the cipher context to the initial context.  This is basically
702    the same as an release followed by a new. */
703 static void
704 cipher_reset (gcry_cipher_hd_t c)
705 {
706   unsigned int marks_key;
707
708   marks_key = c->marks.key;
709
710   memcpy (&c->context.c,
711           (char *) &c->context.c + c->spec->contextsize,
712           c->spec->contextsize);
713   memset (&c->marks, 0, sizeof c->marks);
714   memset (c->u_iv.iv, 0, c->spec->blocksize);
715   memset (c->lastiv, 0, c->spec->blocksize);
716   memset (c->u_ctr.ctr, 0, c->spec->blocksize);
717   c->unused = 0;
718
719   c->marks.key = marks_key;
720
721   switch (c->mode)
722     {
723     case GCRY_CIPHER_MODE_CMAC:
724       /* Only clear 'tag' for cmac, keep subkeys. */
725       c->u_mode.cmac.tag = 0;
726       break;
727
728     case GCRY_CIPHER_MODE_GCM:
729       /* Only clear head of u_mode, keep ghash_key and gcm_table. */
730       {
731         byte *u_mode_pos = (void *)&c->u_mode;
732         byte *ghash_key_pos = c->u_mode.gcm.u_ghash_key.key;
733         size_t u_mode_head_length = ghash_key_pos - u_mode_pos;
734
735         memset (&c->u_mode, 0, u_mode_head_length);
736       }
737       break;
738
739     case GCRY_CIPHER_MODE_POLY1305:
740       memset (&c->u_mode.poly1305, 0, sizeof c->u_mode.poly1305);
741       break;
742
743 #ifdef HAVE_U64_TYPEDEF
744     case GCRY_CIPHER_MODE_CCM:
745       memset (&c->u_mode.ccm, 0, sizeof c->u_mode.ccm);
746       break;
747 #endif
748
749     case GCRY_CIPHER_MODE_OCB:
750       memset (&c->u_mode.ocb, 0, sizeof c->u_mode.ocb);
751       /* Setup default taglen.  */
752       c->u_mode.ocb.taglen = 16;
753       break;
754
755     default:
756       break; /* u_mode unused by other modes. */
757     }
758 }
759
760
761 \f
762 static gcry_err_code_t
763 do_ecb_crypt (gcry_cipher_hd_t c,
764               unsigned char *outbuf, size_t outbuflen,
765               const unsigned char *inbuf, size_t inbuflen,
766               gcry_cipher_encrypt_t crypt_fn)
767 {
768   unsigned int blocksize = c->spec->blocksize;
769   size_t n, nblocks;
770   unsigned int burn, nburn;
771
772   if (outbuflen < inbuflen)
773     return GPG_ERR_BUFFER_TOO_SHORT;
774   if ((inbuflen % blocksize))
775     return GPG_ERR_INV_LENGTH;
776
777   nblocks = inbuflen / blocksize;
778   burn = 0;
779
780   for (n=0; n < nblocks; n++ )
781     {
782       nburn = crypt_fn (&c->context.c, outbuf, inbuf);
783       burn = nburn > burn ? nburn : burn;
784       inbuf  += blocksize;
785       outbuf += blocksize;
786     }
787
788   if (burn > 0)
789     _gcry_burn_stack (burn + 4 * sizeof(void *));
790
791   return 0;
792 }
793
794 static gcry_err_code_t
795 do_ecb_encrypt (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->encrypt);
800 }
801
802 static gcry_err_code_t
803 do_ecb_decrypt (gcry_cipher_hd_t c,
804                 unsigned char *outbuf, size_t outbuflen,
805                 const unsigned char *inbuf, size_t inbuflen)
806 {
807   return do_ecb_crypt (c, outbuf, outbuflen, inbuf, inbuflen, c->spec->decrypt);
808 }
809
810
811 /****************
812  * Encrypt INBUF to OUTBUF with the mode selected at open.
813  * inbuf and outbuf may overlap or be the same.
814  * Depending on the mode some constraints apply to INBUFLEN.
815  */
816 static gcry_err_code_t
817 cipher_encrypt (gcry_cipher_hd_t c, byte *outbuf, size_t outbuflen,
818                 const byte *inbuf, size_t inbuflen)
819 {
820   gcry_err_code_t rc;
821
822   switch (c->mode)
823     {
824     case GCRY_CIPHER_MODE_ECB:
825       rc = do_ecb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
826       break;
827
828     case GCRY_CIPHER_MODE_CBC:
829       rc = _gcry_cipher_cbc_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
830       break;
831
832     case GCRY_CIPHER_MODE_CFB:
833       rc = _gcry_cipher_cfb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
834       break;
835
836     case GCRY_CIPHER_MODE_OFB:
837       rc = _gcry_cipher_ofb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
838       break;
839
840     case GCRY_CIPHER_MODE_CTR:
841       rc = _gcry_cipher_ctr_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
842       break;
843
844     case GCRY_CIPHER_MODE_AESWRAP:
845       rc = _gcry_cipher_aeswrap_encrypt (c, outbuf, outbuflen,
846                                          inbuf, inbuflen);
847       break;
848
849     case GCRY_CIPHER_MODE_CCM:
850       rc = _gcry_cipher_ccm_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
851       break;
852
853     case GCRY_CIPHER_MODE_CMAC:
854       rc = GPG_ERR_INV_CIPHER_MODE;
855       break;
856
857     case GCRY_CIPHER_MODE_GCM:
858       rc = _gcry_cipher_gcm_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
859       break;
860
861     case GCRY_CIPHER_MODE_POLY1305:
862       rc = _gcry_cipher_poly1305_encrypt (c, outbuf, outbuflen,
863                                           inbuf, inbuflen);
864       break;
865
866     case GCRY_CIPHER_MODE_OCB:
867       rc = _gcry_cipher_ocb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
868       break;
869
870     case GCRY_CIPHER_MODE_STREAM:
871       c->spec->stencrypt (&c->context.c,
872                           outbuf, (byte*)/*arggg*/inbuf, inbuflen);
873       rc = 0;
874       break;
875
876     case GCRY_CIPHER_MODE_NONE:
877       if (fips_mode () || !_gcry_get_debug_flag (0))
878         {
879           fips_signal_error ("cipher mode NONE used");
880           rc = GPG_ERR_INV_CIPHER_MODE;
881         }
882       else
883         {
884           if (inbuf != outbuf)
885             memmove (outbuf, inbuf, inbuflen);
886           rc = 0;
887         }
888       break;
889
890     default:
891       log_fatal ("cipher_encrypt: invalid mode %d\n", c->mode );
892       rc = GPG_ERR_INV_CIPHER_MODE;
893       break;
894     }
895
896   return rc;
897 }
898
899
900 /****************
901  * Encrypt IN and write it to OUT.  If IN is NULL, in-place encryption has
902  * been requested.
903  */
904 gcry_err_code_t
905 _gcry_cipher_encrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
906                       const void *in, size_t inlen)
907 {
908   gcry_err_code_t rc;
909
910   if (!in)  /* Caller requested in-place encryption.  */
911     {
912       in = out;
913       inlen = outsize;
914     }
915
916   rc = cipher_encrypt (h, out, outsize, in, inlen);
917
918   /* Failsafe: Make sure that the plaintext will never make it into
919      OUT if the encryption returned an error.  */
920   if (rc && out)
921     memset (out, 0x42, outsize);
922
923   return rc;
924 }
925
926
927
928 /****************
929  * Decrypt INBUF to OUTBUF with the mode selected at open.
930  * inbuf and outbuf may overlap or be the same.
931  * Depending on the mode some some contraints apply to INBUFLEN.
932  */
933 static gcry_err_code_t
934 cipher_decrypt (gcry_cipher_hd_t c, byte *outbuf, size_t outbuflen,
935                 const byte *inbuf, size_t inbuflen)
936 {
937   gcry_err_code_t rc;
938
939   switch (c->mode)
940     {
941     case GCRY_CIPHER_MODE_ECB:
942       rc = do_ecb_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
943       break;
944
945     case GCRY_CIPHER_MODE_CBC:
946       rc = _gcry_cipher_cbc_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
947       break;
948
949     case GCRY_CIPHER_MODE_CFB:
950       rc = _gcry_cipher_cfb_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
951       break;
952
953     case GCRY_CIPHER_MODE_OFB:
954       rc = _gcry_cipher_ofb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
955       break;
956
957     case GCRY_CIPHER_MODE_CTR:
958       rc = _gcry_cipher_ctr_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
959       break;
960
961     case GCRY_CIPHER_MODE_AESWRAP:
962       rc = _gcry_cipher_aeswrap_decrypt (c, outbuf, outbuflen,
963                                          inbuf, inbuflen);
964       break;
965
966     case GCRY_CIPHER_MODE_CCM:
967       rc = _gcry_cipher_ccm_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
968       break;
969
970     case GCRY_CIPHER_MODE_CMAC:
971       rc = GPG_ERR_INV_CIPHER_MODE;
972       break;
973
974     case GCRY_CIPHER_MODE_GCM:
975       rc = _gcry_cipher_gcm_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
976       break;
977
978     case GCRY_CIPHER_MODE_POLY1305:
979       rc = _gcry_cipher_poly1305_decrypt (c, outbuf, outbuflen,
980                                           inbuf, inbuflen);
981       break;
982
983     case GCRY_CIPHER_MODE_OCB:
984       rc = _gcry_cipher_ocb_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
985       break;
986
987     case GCRY_CIPHER_MODE_STREAM:
988       c->spec->stdecrypt (&c->context.c,
989                           outbuf, (byte*)/*arggg*/inbuf, inbuflen);
990       rc = 0;
991       break;
992
993     case GCRY_CIPHER_MODE_NONE:
994       if (fips_mode () || !_gcry_get_debug_flag (0))
995         {
996           fips_signal_error ("cipher mode NONE used");
997           rc = GPG_ERR_INV_CIPHER_MODE;
998         }
999       else
1000         {
1001           if (inbuf != outbuf)
1002             memmove (outbuf, inbuf, inbuflen);
1003           rc = 0;
1004         }
1005       break;
1006
1007     default:
1008       log_fatal ("cipher_decrypt: invalid mode %d\n", c->mode );
1009       rc = GPG_ERR_INV_CIPHER_MODE;
1010       break;
1011     }
1012
1013   return rc;
1014 }
1015
1016
1017 gcry_err_code_t
1018 _gcry_cipher_decrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
1019                       const void *in, size_t inlen)
1020 {
1021   if (!in) /* Caller requested in-place encryption. */
1022     {
1023       in = out;
1024       inlen = outsize;
1025     }
1026
1027   return cipher_decrypt (h, out, outsize, in, inlen);
1028 }
1029
1030
1031
1032 /****************
1033  * Used for PGP's somewhat strange CFB mode. Only works if
1034  * the corresponding flag is set.
1035  */
1036 static void
1037 cipher_sync (gcry_cipher_hd_t c)
1038 {
1039   if ((c->flags & GCRY_CIPHER_ENABLE_SYNC) && c->unused)
1040     {
1041       memmove (c->u_iv.iv + c->unused,
1042                c->u_iv.iv, c->spec->blocksize - c->unused);
1043       memcpy (c->u_iv.iv,
1044               c->lastiv + c->spec->blocksize - c->unused, c->unused);
1045       c->unused = 0;
1046     }
1047 }
1048
1049
1050 gcry_err_code_t
1051 _gcry_cipher_setkey (gcry_cipher_hd_t hd, const void *key, size_t keylen)
1052 {
1053   return cipher_setkey (hd, (void*)key, keylen);
1054 }
1055
1056
1057 gcry_err_code_t
1058 _gcry_cipher_setiv (gcry_cipher_hd_t hd, const void *iv, size_t ivlen)
1059 {
1060   gcry_err_code_t rc = 0;
1061
1062   switch (hd->mode)
1063     {
1064       case GCRY_CIPHER_MODE_CCM:
1065         rc = _gcry_cipher_ccm_set_nonce (hd, iv, ivlen);
1066         break;
1067
1068       case GCRY_CIPHER_MODE_GCM:
1069         rc =  _gcry_cipher_gcm_setiv (hd, iv, ivlen);
1070         break;
1071
1072       case GCRY_CIPHER_MODE_POLY1305:
1073         rc =  _gcry_cipher_poly1305_setiv (hd, iv, ivlen);
1074         break;
1075
1076       case GCRY_CIPHER_MODE_OCB:
1077         rc = _gcry_cipher_ocb_set_nonce (hd, iv, ivlen);
1078         break;
1079
1080       default:
1081         rc = cipher_setiv (hd, iv, ivlen);
1082         break;
1083     }
1084   return rc;
1085 }
1086
1087 /* Set counter for CTR mode.  (CTR,CTRLEN) must denote a buffer of
1088    block size length, or (NULL,0) to set the CTR to the all-zero
1089    block. */
1090 gpg_err_code_t
1091 _gcry_cipher_setctr (gcry_cipher_hd_t hd, const void *ctr, size_t ctrlen)
1092 {
1093   if (ctr && ctrlen == hd->spec->blocksize)
1094     {
1095       memcpy (hd->u_ctr.ctr, ctr, hd->spec->blocksize);
1096       hd->unused = 0;
1097     }
1098   else if (!ctr || !ctrlen)
1099     {
1100       memset (hd->u_ctr.ctr, 0, hd->spec->blocksize);
1101       hd->unused = 0;
1102     }
1103   else
1104     return GPG_ERR_INV_ARG;
1105
1106   return 0;
1107 }
1108
1109
1110 gcry_err_code_t
1111 _gcry_cipher_authenticate (gcry_cipher_hd_t hd, const void *abuf,
1112                            size_t abuflen)
1113 {
1114   gcry_err_code_t rc;
1115
1116   switch (hd->mode)
1117     {
1118     case GCRY_CIPHER_MODE_CCM:
1119       rc = _gcry_cipher_ccm_authenticate (hd, abuf, abuflen);
1120       break;
1121
1122     case GCRY_CIPHER_MODE_CMAC:
1123       rc = _gcry_cipher_cmac_authenticate (hd, abuf, abuflen);
1124       break;
1125
1126     case GCRY_CIPHER_MODE_GCM:
1127       rc = _gcry_cipher_gcm_authenticate (hd, abuf, abuflen);
1128       break;
1129
1130     case GCRY_CIPHER_MODE_POLY1305:
1131       rc = _gcry_cipher_poly1305_authenticate (hd, abuf, abuflen);
1132       break;
1133
1134     case GCRY_CIPHER_MODE_OCB:
1135       rc = _gcry_cipher_ocb_authenticate (hd, abuf, abuflen);
1136       break;
1137
1138     default:
1139       log_error ("gcry_cipher_authenticate: invalid mode %d\n", hd->mode);
1140       rc = GPG_ERR_INV_CIPHER_MODE;
1141       break;
1142     }
1143
1144   return rc;
1145 }
1146
1147
1148 gcry_err_code_t
1149 _gcry_cipher_gettag (gcry_cipher_hd_t hd, void *outtag, size_t taglen)
1150 {
1151   gcry_err_code_t rc;
1152
1153   switch (hd->mode)
1154     {
1155     case GCRY_CIPHER_MODE_CCM:
1156       rc = _gcry_cipher_ccm_get_tag (hd, outtag, taglen);
1157       break;
1158
1159     case GCRY_CIPHER_MODE_CMAC:
1160       rc = _gcry_cipher_cmac_get_tag (hd, outtag, taglen);
1161       break;
1162
1163     case GCRY_CIPHER_MODE_GCM:
1164       rc = _gcry_cipher_gcm_get_tag (hd, outtag, taglen);
1165       break;
1166
1167     case GCRY_CIPHER_MODE_POLY1305:
1168       rc = _gcry_cipher_poly1305_get_tag (hd, outtag, taglen);
1169       break;
1170
1171     case GCRY_CIPHER_MODE_OCB:
1172       rc = _gcry_cipher_ocb_get_tag (hd, outtag, taglen);
1173       break;
1174
1175     default:
1176       log_error ("gcry_cipher_gettag: invalid mode %d\n", hd->mode);
1177       rc = GPG_ERR_INV_CIPHER_MODE;
1178       break;
1179     }
1180
1181   return rc;
1182 }
1183
1184
1185 gcry_err_code_t
1186 _gcry_cipher_checktag (gcry_cipher_hd_t hd, const void *intag, size_t taglen)
1187 {
1188   gcry_err_code_t rc;
1189
1190   switch (hd->mode)
1191     {
1192     case GCRY_CIPHER_MODE_CCM:
1193       rc = _gcry_cipher_ccm_check_tag (hd, intag, taglen);
1194       break;
1195
1196     case GCRY_CIPHER_MODE_CMAC:
1197       rc = _gcry_cipher_cmac_check_tag (hd, intag, taglen);
1198       break;
1199
1200     case GCRY_CIPHER_MODE_GCM:
1201       rc = _gcry_cipher_gcm_check_tag (hd, intag, taglen);
1202       break;
1203
1204     case GCRY_CIPHER_MODE_POLY1305:
1205       rc = _gcry_cipher_poly1305_check_tag (hd, intag, taglen);
1206       break;
1207
1208     case GCRY_CIPHER_MODE_OCB:
1209       rc = _gcry_cipher_ocb_check_tag (hd, intag, taglen);
1210       break;
1211
1212     default:
1213       log_error ("gcry_cipher_checktag: invalid mode %d\n", hd->mode);
1214       rc = GPG_ERR_INV_CIPHER_MODE;
1215       break;
1216     }
1217
1218   return rc;
1219 }
1220
1221
1222 gcry_err_code_t
1223 _gcry_cipher_ctl (gcry_cipher_hd_t h, int cmd, void *buffer, size_t buflen)
1224 {
1225   gcry_err_code_t rc = 0;
1226
1227   switch (cmd)
1228     {
1229     case GCRYCTL_RESET:
1230       cipher_reset (h);
1231       break;
1232
1233     case GCRYCTL_FINALIZE:
1234       if (!h || buffer || buflen)
1235         return GPG_ERR_INV_ARG;
1236       h->marks.finalize = 1;
1237       break;
1238
1239     case GCRYCTL_CFB_SYNC:
1240       cipher_sync( h );
1241       break;
1242
1243     case GCRYCTL_SET_CBC_CTS:
1244       if (buflen)
1245         if (h->flags & GCRY_CIPHER_CBC_MAC)
1246           rc = GPG_ERR_INV_FLAG;
1247         else
1248           h->flags |= GCRY_CIPHER_CBC_CTS;
1249       else
1250         h->flags &= ~GCRY_CIPHER_CBC_CTS;
1251       break;
1252
1253     case GCRYCTL_SET_CBC_MAC:
1254       if (buflen)
1255         if (h->flags & GCRY_CIPHER_CBC_CTS)
1256           rc = GPG_ERR_INV_FLAG;
1257         else
1258           h->flags |= GCRY_CIPHER_CBC_MAC;
1259       else
1260         h->flags &= ~GCRY_CIPHER_CBC_MAC;
1261       break;
1262
1263     case GCRYCTL_SET_CCM_LENGTHS:
1264 #ifdef HAVE_U64_TYPEDEF
1265       {
1266         u64 params[3];
1267         size_t encryptedlen;
1268         size_t aadlen;
1269         size_t authtaglen;
1270
1271         if (h->mode != GCRY_CIPHER_MODE_CCM)
1272           return gcry_error (GPG_ERR_INV_CIPHER_MODE);
1273
1274         if (!buffer || buflen != 3 * sizeof(u64))
1275           return gcry_error (GPG_ERR_INV_ARG);
1276
1277         /* This command is used to pass additional length parameters needed
1278            by CCM mode to initialize CBC-MAC.  */
1279         memcpy (params, buffer, sizeof(params));
1280         encryptedlen = params[0];
1281         aadlen = params[1];
1282         authtaglen = params[2];
1283
1284         rc = _gcry_cipher_ccm_set_lengths (h, encryptedlen, aadlen, authtaglen);
1285       }
1286 #else
1287       rc = GPG_ERR_NOT_SUPPORTED;
1288 #endif
1289       break;
1290
1291     case GCRYCTL_SET_TAGLEN:
1292       if (!h || !buffer || buflen != sizeof(int) )
1293         return GPG_ERR_INV_ARG;
1294       switch (h->mode)
1295         {
1296         case GCRY_CIPHER_MODE_OCB:
1297           switch (*(int*)buffer)
1298             {
1299             case 8: case 12: case 16:
1300               h->u_mode.ocb.taglen = *(int*)buffer;
1301               break;
1302             default:
1303               rc = GPG_ERR_INV_LENGTH; /* Invalid tag length. */
1304               break;
1305             }
1306           break;
1307
1308         default:
1309           rc =GPG_ERR_INV_CIPHER_MODE;
1310           break;
1311         }
1312       break;
1313
1314     case GCRYCTL_DISABLE_ALGO:
1315       /* This command expects NULL for H and BUFFER to point to an
1316          integer with the algo number.  */
1317       if( h || !buffer || buflen != sizeof(int) )
1318         return gcry_error (GPG_ERR_CIPHER_ALGO);
1319       disable_cipher_algo( *(int*)buffer );
1320       break;
1321
1322     case 61:  /* Disable weak key detection (private).  */
1323       if (h->spec->set_extra_info)
1324         rc = h->spec->set_extra_info
1325           (&h->context.c, CIPHER_INFO_NO_WEAK_KEY, NULL, 0);
1326       else
1327         rc = GPG_ERR_NOT_SUPPORTED;
1328       break;
1329
1330     case 62: /* Return current input vector (private).  */
1331       /* This is the input block as used in CFB and OFB mode which has
1332          initially been set as IV.  The returned format is:
1333            1 byte  Actual length of the block in bytes.
1334            n byte  The block.
1335          If the provided buffer is too short, an error is returned. */
1336       if (buflen < (1 + h->spec->blocksize))
1337         rc = GPG_ERR_TOO_SHORT;
1338       else
1339         {
1340           unsigned char *ivp;
1341           unsigned char *dst = buffer;
1342           int n = h->unused;
1343
1344           if (!n)
1345             n = h->spec->blocksize;
1346           gcry_assert (n <= h->spec->blocksize);
1347           *dst++ = n;
1348           ivp = h->u_iv.iv + h->spec->blocksize - n;
1349           while (n--)
1350             *dst++ = *ivp++;
1351         }
1352       break;
1353
1354     case GCRYCTL_SET_SBOX:
1355       if (h->spec->set_extra_info)
1356         rc = h->spec->set_extra_info
1357           (&h->context.c, GCRYCTL_SET_SBOX, buffer, buflen);
1358       else
1359         rc = GPG_ERR_NOT_SUPPORTED;
1360
1361     default:
1362       rc = GPG_ERR_INV_OP;
1363     }
1364
1365   return rc;
1366 }
1367
1368
1369 /* Return information about the cipher handle H.  CMD is the kind of
1370    information requested.  BUFFER and NBYTES are reserved for now.
1371
1372    There are no values for CMD yet defined.
1373
1374    The function always returns GPG_ERR_INV_OP.
1375
1376  */
1377 gcry_err_code_t
1378 _gcry_cipher_info (gcry_cipher_hd_t h, int cmd, void *buffer, size_t *nbytes)
1379 {
1380   gcry_err_code_t rc = 0;
1381
1382   (void)h;
1383   (void)buffer;
1384   (void)nbytes;
1385
1386   switch (cmd)
1387     {
1388     default:
1389       rc = GPG_ERR_INV_OP;
1390     }
1391
1392   return rc;
1393 }
1394
1395 /* Return information about the given cipher algorithm ALGO.
1396
1397    WHAT select the kind of information returned:
1398
1399     GCRYCTL_GET_KEYLEN:
1400         Return the length of the key.  If the algorithm ALGO
1401         supports multiple key lengths, the maximum supported key length
1402         is returned.  The key length is returned as number of octets.
1403         BUFFER and NBYTES must be zero.
1404
1405     GCRYCTL_GET_BLKLEN:
1406         Return the blocklength of the algorithm ALGO counted in octets.
1407         BUFFER and NBYTES must be zero.
1408
1409     GCRYCTL_TEST_ALGO:
1410         Returns 0 if the specified algorithm ALGO is available for use.
1411         BUFFER and NBYTES must be zero.
1412
1413    Note: Because this function is in most cases used to return an
1414    integer value, we can make it easier for the caller to just look at
1415    the return value.  The caller will in all cases consult the value
1416    and thereby detecting whether a error occurred or not (i.e. while
1417    checking the block size)
1418  */
1419 gcry_err_code_t
1420 _gcry_cipher_algo_info (int algo, int what, void *buffer, size_t *nbytes)
1421 {
1422   gcry_err_code_t rc = 0;
1423   unsigned int ui;
1424
1425   switch (what)
1426     {
1427     case GCRYCTL_GET_KEYLEN:
1428       if (buffer || (! nbytes))
1429         rc = GPG_ERR_CIPHER_ALGO;
1430       else
1431         {
1432           ui = cipher_get_keylen (algo);
1433           if ((ui > 0) && (ui <= 512))
1434             *nbytes = (size_t) ui / 8;
1435           else
1436             /* The only reason for an error is an invalid algo.  */
1437             rc = GPG_ERR_CIPHER_ALGO;
1438         }
1439       break;
1440
1441     case GCRYCTL_GET_BLKLEN:
1442       if (buffer || (! nbytes))
1443         rc = GPG_ERR_CIPHER_ALGO;
1444       else
1445         {
1446           ui = cipher_get_blocksize (algo);
1447           if ((ui > 0) && (ui < 10000))
1448             *nbytes = ui;
1449           else
1450             {
1451               /* The only reason is an invalid algo or a strange
1452                  blocksize.  */
1453               rc = GPG_ERR_CIPHER_ALGO;
1454             }
1455         }
1456       break;
1457
1458     case GCRYCTL_TEST_ALGO:
1459       if (buffer || nbytes)
1460         rc = GPG_ERR_INV_ARG;
1461       else
1462         rc = check_cipher_algo (algo);
1463       break;
1464
1465       default:
1466         rc = GPG_ERR_INV_OP;
1467     }
1468
1469   return rc;
1470 }
1471
1472
1473 /* This function returns length of the key for algorithm ALGO.  If the
1474    algorithm supports multiple key lengths, the maximum supported key
1475    length is returned.  On error 0 is returned.  The key length is
1476    returned as number of octets.
1477
1478    This is a convenience functions which should be preferred over
1479    gcry_cipher_algo_info because it allows for proper type
1480    checking.  */
1481 size_t
1482 _gcry_cipher_get_algo_keylen (int algo)
1483 {
1484   size_t n;
1485
1486   if (_gcry_cipher_algo_info (algo, GCRYCTL_GET_KEYLEN, NULL, &n))
1487     n = 0;
1488   return n;
1489 }
1490
1491
1492 /* This functions returns the blocklength of the algorithm ALGO
1493    counted in octets.  On error 0 is returned.
1494
1495    This is a convenience functions which should be preferred over
1496    gcry_cipher_algo_info because it allows for proper type
1497    checking.  */
1498 size_t
1499 _gcry_cipher_get_algo_blklen (int algo)
1500 {
1501   size_t n;
1502
1503   if (_gcry_cipher_algo_info( algo, GCRYCTL_GET_BLKLEN, NULL, &n))
1504     n = 0;
1505   return n;
1506 }
1507
1508
1509 /* Explicitly initialize this module.  */
1510 gcry_err_code_t
1511 _gcry_cipher_init (void)
1512 {
1513   return 0;
1514 }
1515
1516
1517 /* Run the selftests for cipher algorithm ALGO with optional reporting
1518    function REPORT.  */
1519 gpg_error_t
1520 _gcry_cipher_selftest (int algo, int extended, selftest_report_func_t report)
1521 {
1522   gcry_err_code_t ec = 0;
1523   gcry_cipher_spec_t *spec;
1524
1525   spec = spec_from_algo (algo);
1526   if (spec && !spec->flags.disabled && spec->selftest)
1527     ec = spec->selftest (algo, extended, report);
1528   else
1529     {
1530       ec = GPG_ERR_CIPHER_ALGO;
1531       if (report)
1532         report ("cipher", algo, "module",
1533                 (spec && !spec->flags.disabled)?
1534                 "no selftest available" :
1535                 spec? "algorithm disabled" : "algorithm not found");
1536     }
1537
1538   return gpg_error (ec);
1539 }