Calculate OCB L-tables when setting key instead of when setting nonce
[libgcrypt.git] / cipher / cipher-internal.h
1 /* cipher-internal.h  - Internal defs for cipher.c
2  * Copyright (C) 2011 Free Software Foundation, Inc.
3  *
4  * This file is part of Libgcrypt.
5  *
6  * Libgcrypt is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU Lesser general Public License as
8  * published by the Free Software Foundation; either version 2.1 of
9  * the License, or (at your option) any later version.
10  *
11  * Libgcrypt is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20 #ifndef G10_CIPHER_INTERNAL_H
21 #define G10_CIPHER_INTERNAL_H
22
23 #include "./poly1305-internal.h"
24
25
26 /* The maximum supported size of a block in bytes.  */
27 #define MAX_BLOCKSIZE 16
28
29 /* The length for an OCB block.  Although OCB supports any block
30    length it does not make sense to use a 64 bit blocklen (and cipher)
31    because this reduces the security margin to an unacceptable state.
32    Thus we require a cipher with 128 bit blocklength.  */
33 #define OCB_BLOCK_LEN  (128/8)
34
35 /* The size of the pre-computed L table for OCB.  This takes the same
36    size as the table used for GCM and thus we don't save anything by
37    not using such a table.  */
38 #define OCB_L_TABLE_SIZE 16
39
40
41 /* Check the above constants.  */
42 #if OCB_BLOCK_LEN > MAX_BLOCKSIZE
43 # error OCB_BLOCKLEN > MAX_BLOCKSIZE
44 #endif
45
46
47
48 /* Magic values for the context structure.  */
49 #define CTX_MAGIC_NORMAL 0x24091964
50 #define CTX_MAGIC_SECURE 0x46919042
51
52 /* Try to use 16 byte aligned cipher context for better performance.
53    We use the aligned attribute, thus it is only possible to implement
54    this with gcc.  */
55 #undef NEED_16BYTE_ALIGNED_CONTEXT
56 #ifdef HAVE_GCC_ATTRIBUTE_ALIGNED
57 # define NEED_16BYTE_ALIGNED_CONTEXT 1
58 #endif
59
60 /* Undef this symbol to trade GCM speed for 256 bytes of memory per context */
61 #define GCM_USE_TABLES 1
62
63
64 /* GCM_USE_INTEL_PCLMUL indicates whether to compile GCM with Intel PCLMUL
65    code.  */
66 #undef GCM_USE_INTEL_PCLMUL
67 #if defined(ENABLE_PCLMUL_SUPPORT) && defined(GCM_USE_TABLES)
68 # if ((defined(__i386__) && SIZEOF_UNSIGNED_LONG == 4) || defined(__x86_64__))
69 #  if __GNUC__ >= 4
70 #   define GCM_USE_INTEL_PCLMUL 1
71 #  endif
72 # endif
73 #endif /* GCM_USE_INTEL_PCLMUL */
74
75 /* GCM_USE_ARM_PMULL indicates whether to compile GCM with ARMv8 PMULL code. */
76 #undef GCM_USE_ARM_PMULL
77 #if defined(ENABLE_ARM_CRYPTO_SUPPORT) && defined(GCM_USE_TABLES)
78 # if defined(HAVE_ARM_ARCH_V6) && defined(__ARMEL__) \
79      && defined(HAVE_COMPATIBLE_GCC_ARM_PLATFORM_AS) \
80      && defined(HAVE_GCC_INLINE_ASM_AARCH32_CRYPTO)
81 #  define GCM_USE_ARM_PMULL 1
82 # elif defined(__AARCH64EL__) && \
83     defined(HAVE_COMPATIBLE_GCC_AARCH64_PLATFORM_AS) && \
84     defined(HAVE_GCC_INLINE_ASM_AARCH64_CRYPTO)
85 #  define GCM_USE_ARM_PMULL 1
86 # endif
87 #endif /* GCM_USE_ARM_PMULL */
88
89
90 typedef unsigned int (*ghash_fn_t) (gcry_cipher_hd_t c, byte *result,
91                                     const byte *buf, size_t nblocks);
92
93
94 /* A VIA processor with the Padlock engine as well as the Intel AES_NI
95    instructions require an alignment of most data on a 16 byte
96    boundary.  Because we trick out the compiler while allocating the
97    context, the align attribute as used in rijndael.c does not work on
98    its own.  Thus we need to make sure that the entire context
99    structure is a aligned on that boundary.  We achieve this by
100    defining a new type and use that instead of our usual alignment
101    type.  */
102 typedef union
103 {
104   PROPERLY_ALIGNED_TYPE foo;
105 #ifdef NEED_16BYTE_ALIGNED_CONTEXT
106   char bar[16] __attribute__ ((aligned (16)));
107 #endif
108   char c[1];
109 } cipher_context_alignment_t;
110
111
112 /* Storage structure for CMAC, for CMAC and EAX modes. */
113 typedef struct {
114   /* The initialization vector. Also contains tag after finalization. */
115   union {
116     cipher_context_alignment_t iv_align;
117     unsigned char iv[MAX_BLOCKSIZE];
118   } u_iv;
119
120   /* Subkeys for tag creation, not cleared by gcry_cipher_reset. */
121   unsigned char subkeys[2][MAX_BLOCKSIZE];
122
123   /* Space to save partial input lengths for MAC. */
124   unsigned char macbuf[MAX_BLOCKSIZE];
125
126   int mac_unused;  /* Number of unprocessed bytes in MACBUF. */
127   unsigned int tag:1; /* Set to 1 if tag has been finalized.  */
128 } gcry_cmac_context_t;
129
130
131 /* The handle structure.  */
132 struct gcry_cipher_handle
133 {
134   int magic;
135   size_t actual_handle_size;     /* Allocated size of this handle. */
136   size_t handle_offset;          /* Offset to the malloced block.  */
137   gcry_cipher_spec_t *spec;
138
139   /* The algorithm id.  This is a hack required because the module
140      interface does not easily allow to retrieve this value. */
141   int algo;
142
143   /* A structure with function pointers for mode operations. */
144   struct {
145     gcry_err_code_t (*encrypt)(gcry_cipher_hd_t c,
146                                unsigned char *outbuf, size_t outbuflen,
147                                const unsigned char *inbuf, size_t inbuflen);
148     gcry_err_code_t (*decrypt)(gcry_cipher_hd_t c,
149                                unsigned char *outbuf, size_t outbuflen,
150                                const unsigned char *inbuf, size_t inbuflen);
151     gcry_err_code_t (*setiv)(gcry_cipher_hd_t c, const unsigned char *iv,
152                              size_t ivlen);
153
154     gcry_err_code_t (*authenticate)(gcry_cipher_hd_t c,
155                                     const unsigned char *abuf, size_t abuflen);
156     gcry_err_code_t (*get_tag)(gcry_cipher_hd_t c, unsigned char *outtag,
157                                size_t taglen);
158     gcry_err_code_t (*check_tag)(gcry_cipher_hd_t c, const unsigned char *intag,
159                                  size_t taglen);
160   } mode_ops;
161
162   /* A structure with function pointers for bulk operations.  Due to
163      limitations of the module system (we don't want to change the
164      API) we need to keep these function pointers here.  The cipher
165      open function initializes them and the actual encryption routines
166      use them if they are not NULL.  */
167   struct {
168     void (*cfb_enc)(void *context, unsigned char *iv,
169                     void *outbuf_arg, const void *inbuf_arg,
170                     size_t nblocks);
171     void (*cfb_dec)(void *context, unsigned char *iv,
172                     void *outbuf_arg, const void *inbuf_arg,
173                     size_t nblocks);
174     void (*cbc_enc)(void *context, unsigned char *iv,
175                     void *outbuf_arg, const void *inbuf_arg,
176                     size_t nblocks, int cbc_mac);
177     void (*cbc_dec)(void *context, unsigned char *iv,
178                     void *outbuf_arg, const void *inbuf_arg,
179                     size_t nblocks);
180     void (*ctr_enc)(void *context, unsigned char *iv,
181                     void *outbuf_arg, const void *inbuf_arg,
182                     size_t nblocks);
183     size_t (*ocb_crypt)(gcry_cipher_hd_t c, void *outbuf_arg,
184                         const void *inbuf_arg, size_t nblocks, int encrypt);
185     size_t (*ocb_auth)(gcry_cipher_hd_t c, const void *abuf_arg,
186                        size_t nblocks);
187     void (*xts_crypt)(void *context, unsigned char *tweak,
188                       void *outbuf_arg, const void *inbuf_arg,
189                       size_t nblocks, int encrypt);
190   } bulk;
191
192
193   int mode;
194   unsigned int flags;
195
196   struct {
197     unsigned int key:1; /* Set to 1 if a key has been set.  */
198     unsigned int iv:1;  /* Set to 1 if a IV has been set.  */
199     unsigned int tag:1; /* Set to 1 if a tag is finalized. */
200     unsigned int finalize:1; /* Next encrypt/decrypt has the final data.  */
201   } marks;
202
203   /* The initialization vector.  For best performance we make sure
204      that it is properly aligned.  In particular some implementations
205      of bulk operations expect an 16 byte aligned IV.  IV is also used
206      to store CBC-MAC in CCM mode; counter IV is stored in U_CTR.  For
207      OCB mode it is used for the offset value.  */
208   union {
209     cipher_context_alignment_t iv_align;
210     unsigned char iv[MAX_BLOCKSIZE];
211   } u_iv;
212
213   /* The counter for CTR mode.  This field is also used by AESWRAP and
214      thus we can't use the U_IV union.  For OCB mode it is used for
215      the checksum.  */
216   union {
217     cipher_context_alignment_t iv_align;
218     unsigned char ctr[MAX_BLOCKSIZE];
219   } u_ctr;
220
221   /* Space to save an IV or CTR for chaining operations.  */
222   unsigned char lastiv[MAX_BLOCKSIZE];
223   int unused;  /* Number of unused bytes in LASTIV. */
224
225   union {
226     /* Mode specific storage for CCM mode. */
227     struct {
228       u64 encryptlen;
229       u64 aadlen;
230       unsigned int authlen;
231
232       /* Space to save partial input lengths for MAC. */
233       unsigned char macbuf[GCRY_CCM_BLOCK_LEN];
234       int mac_unused;  /* Number of unprocessed bytes in MACBUF. */
235
236       unsigned char s0[GCRY_CCM_BLOCK_LEN];
237
238       unsigned int nonce:1; /* Set to 1 if nonce has been set.  */
239       unsigned int lengths:1; /* Set to 1 if CCM length parameters has been
240                                  processed.  */
241     } ccm;
242
243     /* Mode specific storage for Poly1305 mode. */
244     struct {
245       /* byte counter for AAD. */
246       u32 aadcount[2];
247
248       /* byte counter for data. */
249       u32 datacount[2];
250
251       unsigned int aad_finalized:1;
252       unsigned int bytecount_over_limits:1;
253
254       poly1305_context_t ctx;
255     } poly1305;
256
257     /* Mode specific storage for CMAC mode. */
258     gcry_cmac_context_t cmac;
259
260     /* Mode specific storage for EAX mode. */
261     struct {
262       /* CMAC for header (AAD). */
263       gcry_cmac_context_t cmac_header;
264
265       /* CMAC for ciphertext. */
266       gcry_cmac_context_t cmac_ciphertext;
267     } eax;
268
269     /* Mode specific storage for GCM mode. */
270     struct {
271       /* The interim tag for GCM mode.  */
272       union {
273         cipher_context_alignment_t iv_align;
274         unsigned char tag[MAX_BLOCKSIZE];
275       } u_tag;
276
277       /* Space to save partial input lengths for MAC. */
278       unsigned char macbuf[GCRY_CCM_BLOCK_LEN];
279       int mac_unused;  /* Number of unprocessed bytes in MACBUF. */
280
281       /* byte counters for GCM */
282       u32 aadlen[2];
283       u32 datalen[2];
284
285       /* encrypted tag counter */
286       unsigned char tagiv[MAX_BLOCKSIZE];
287
288       unsigned int ghash_data_finalized:1;
289       unsigned int ghash_aad_finalized:1;
290
291       unsigned int datalen_over_limits:1;
292       unsigned int disallow_encryption_because_of_setiv_in_fips_mode:1;
293
294       /* --- Following members are not cleared in gcry_cipher_reset --- */
295
296       /* GHASH multiplier from key.  */
297       union {
298         cipher_context_alignment_t iv_align;
299         unsigned char key[MAX_BLOCKSIZE];
300       } u_ghash_key;
301
302       /* GHASH implementation in use. */
303       ghash_fn_t ghash_fn;
304
305       /* Pre-calculated table for GCM. */
306 #ifdef GCM_USE_TABLES
307  #if (SIZEOF_UNSIGNED_LONG == 8 || defined(__x86_64__))
308       #define GCM_TABLES_USE_U64 1
309       u64 gcm_table[2 * 16];
310  #else
311       #undef GCM_TABLES_USE_U64
312       u32 gcm_table[4 * 16];
313  #endif
314 #endif
315     } gcm;
316
317     /* Mode specific storage for OCB mode. */
318     struct {
319       /* --- Following members are not cleared in gcry_cipher_reset --- */
320
321       /* Helper variables and pre-computed table of L values.  */
322       unsigned char L_star[OCB_BLOCK_LEN];
323       unsigned char L_dollar[OCB_BLOCK_LEN];
324       unsigned char L0L1[OCB_BLOCK_LEN];
325       unsigned char L0L1L0[OCB_BLOCK_LEN];
326       unsigned char L[OCB_L_TABLE_SIZE][OCB_BLOCK_LEN];
327
328       /* --- Following members are cleared in gcry_cipher_reset --- */
329
330       /* The tag is valid if marks.tag has been set.  */
331       unsigned char tag[OCB_BLOCK_LEN];
332
333       /* A buffer to hold the offset for the AAD processing.  */
334       unsigned char aad_offset[OCB_BLOCK_LEN];
335
336       /* A buffer to hold the current sum of AAD processing.  We can't
337          use tag here because tag may already hold the preprocessed
338          checksum of the data.  */
339       unsigned char aad_sum[OCB_BLOCK_LEN];
340
341       /* A buffer to store AAD data not yet processed.  */
342       unsigned char aad_leftover[OCB_BLOCK_LEN];
343
344       /* Number of data/aad blocks processed so far.  */
345       u64 data_nblocks;
346       u64 aad_nblocks;
347
348       /* Number of valid bytes in AAD_LEFTOVER.  */
349       unsigned char aad_nleftover;
350
351       /* Length of the tag.  Fixed for now but may eventually be
352          specified using a set of gcry_cipher_flags.  */
353       unsigned char taglen;
354
355       /* Flags indicating that the final data/aad block has been
356          processed.  */
357       unsigned int data_finalized:1;
358       unsigned int aad_finalized:1;
359     } ocb;
360
361     /* Mode specific storage for XTS mode. */
362     struct {
363       /* Pointer to tweak cipher context, allocated after actual
364        * cipher context. */
365       char *tweak_context;
366     } xts;
367   } u_mode;
368
369   /* What follows are two contexts of the cipher in use.  The first
370      one needs to be aligned well enough for the cipher operation
371      whereas the second one is a copy created by cipher_setkey and
372      used by cipher_reset.  That second copy has no need for proper
373      aligment because it is only accessed by memcpy.  */
374   cipher_context_alignment_t context;
375 };
376
377
378 /*-- cipher-cbc.c --*/
379 gcry_err_code_t _gcry_cipher_cbc_encrypt
380 /*           */ (gcry_cipher_hd_t c,
381                  unsigned char *outbuf, size_t outbuflen,
382                  const unsigned char *inbuf, size_t inbuflen);
383 gcry_err_code_t _gcry_cipher_cbc_decrypt
384 /*           */ (gcry_cipher_hd_t c,
385                  unsigned char *outbuf, size_t outbuflen,
386                  const unsigned char *inbuf, size_t inbuflen);
387 gcry_err_code_t _gcry_cipher_cbc_cts_encrypt
388 /*           */ (gcry_cipher_hd_t c,
389                  unsigned char *outbuf, size_t outbuflen,
390                  const unsigned char *inbuf, size_t inbuflen);
391 gcry_err_code_t _gcry_cipher_cbc_cts_decrypt
392 /*           */ (gcry_cipher_hd_t c,
393                  unsigned char *outbuf, size_t outbuflen,
394                  const unsigned char *inbuf, size_t inbuflen);
395
396 /*-- cipher-cfb.c --*/
397 gcry_err_code_t _gcry_cipher_cfb_encrypt
398 /*           */ (gcry_cipher_hd_t c,
399                  unsigned char *outbuf, size_t outbuflen,
400                  const unsigned char *inbuf, size_t inbuflen);
401 gcry_err_code_t _gcry_cipher_cfb_decrypt
402 /*           */ (gcry_cipher_hd_t c,
403                  unsigned char *outbuf, size_t outbuflen,
404                  const unsigned char *inbuf, size_t inbuflen);
405 gcry_err_code_t _gcry_cipher_cfb8_encrypt
406 /*           */ (gcry_cipher_hd_t c,
407                  unsigned char *outbuf, size_t outbuflen,
408                  const unsigned char *inbuf, size_t inbuflen);
409 gcry_err_code_t _gcry_cipher_cfb8_decrypt
410 /*           */ (gcry_cipher_hd_t c,
411                  unsigned char *outbuf, size_t outbuflen,
412                  const unsigned char *inbuf, size_t inbuflen);
413
414
415 /*-- cipher-ofb.c --*/
416 gcry_err_code_t _gcry_cipher_ofb_encrypt
417 /*           */ (gcry_cipher_hd_t c,
418                  unsigned char *outbuf, size_t outbuflen,
419                  const unsigned char *inbuf, size_t inbuflen);
420
421 /*-- cipher-ctr.c --*/
422 gcry_err_code_t _gcry_cipher_ctr_encrypt
423 /*           */ (gcry_cipher_hd_t c,
424                  unsigned char *outbuf, size_t outbuflen,
425                  const unsigned char *inbuf, size_t inbuflen);
426
427
428 /*-- cipher-aeswrap.c --*/
429 gcry_err_code_t _gcry_cipher_aeswrap_encrypt
430 /*           */   (gcry_cipher_hd_t c,
431                    byte *outbuf, size_t outbuflen,
432                    const byte *inbuf, size_t inbuflen);
433 gcry_err_code_t _gcry_cipher_aeswrap_decrypt
434 /*           */   (gcry_cipher_hd_t c,
435                    byte *outbuf, size_t outbuflen,
436                    const byte *inbuf, size_t inbuflen);
437
438
439 /*-- cipher-ccm.c --*/
440 gcry_err_code_t _gcry_cipher_ccm_encrypt
441 /*           */ (gcry_cipher_hd_t c,
442                  unsigned char *outbuf, size_t outbuflen,
443                  const unsigned char *inbuf, size_t inbuflen);
444 gcry_err_code_t _gcry_cipher_ccm_decrypt
445 /*           */ (gcry_cipher_hd_t c,
446                  unsigned char *outbuf, size_t outbuflen,
447                  const unsigned char *inbuf, size_t inbuflen);
448 gcry_err_code_t _gcry_cipher_ccm_set_nonce
449 /*           */ (gcry_cipher_hd_t c, const unsigned char *nonce,
450                  size_t noncelen);
451 gcry_err_code_t _gcry_cipher_ccm_authenticate
452 /*           */ (gcry_cipher_hd_t c, const unsigned char *abuf, size_t abuflen);
453 gcry_err_code_t _gcry_cipher_ccm_set_lengths
454 /*           */ (gcry_cipher_hd_t c, u64 encryptedlen, u64 aadlen, u64 taglen);
455 gcry_err_code_t _gcry_cipher_ccm_get_tag
456 /*           */ (gcry_cipher_hd_t c,
457                  unsigned char *outtag, size_t taglen);
458 gcry_err_code_t _gcry_cipher_ccm_check_tag
459 /*           */ (gcry_cipher_hd_t c,
460                  const unsigned char *intag, size_t taglen);
461
462
463 /*-- cipher-cmac.c --*/
464 gcry_err_code_t _gcry_cmac_generate_subkeys
465 /*           */ (gcry_cipher_hd_t c, gcry_cmac_context_t *ctx);
466 gcry_err_code_t _gcry_cmac_write
467 /*           */ (gcry_cipher_hd_t c, gcry_cmac_context_t *ctx,
468                  const byte * inbuf, size_t inlen);
469 gcry_err_code_t _gcry_cmac_final
470 /*           */ (gcry_cipher_hd_t c, gcry_cmac_context_t *ctx);
471 void _gcry_cmac_reset (gcry_cmac_context_t *ctx);
472
473
474 /*-- cipher-eax.c --*/
475 gcry_err_code_t _gcry_cipher_eax_encrypt
476 /*           */   (gcry_cipher_hd_t c,
477                    unsigned char *outbuf, size_t outbuflen,
478                    const unsigned char *inbuf, size_t inbuflen);
479 gcry_err_code_t _gcry_cipher_eax_decrypt
480 /*           */   (gcry_cipher_hd_t c,
481                    unsigned char *outbuf, size_t outbuflen,
482                    const unsigned char *inbuf, size_t inbuflen);
483 gcry_err_code_t _gcry_cipher_eax_set_nonce
484 /*           */   (gcry_cipher_hd_t c,
485                    const unsigned char *nonce, size_t noncelen);
486 gcry_err_code_t _gcry_cipher_eax_authenticate
487 /*           */   (gcry_cipher_hd_t c,
488                    const unsigned char *aadbuf, size_t aadbuflen);
489 gcry_err_code_t _gcry_cipher_eax_get_tag
490 /*           */   (gcry_cipher_hd_t c,
491                    unsigned char *outtag, size_t taglen);
492 gcry_err_code_t _gcry_cipher_eax_check_tag
493 /*           */   (gcry_cipher_hd_t c,
494                    const unsigned char *intag, size_t taglen);
495 gcry_err_code_t _gcry_cipher_eax_setkey
496 /*           */   (gcry_cipher_hd_t c);
497
498
499 /*-- cipher-gcm.c --*/
500 gcry_err_code_t _gcry_cipher_gcm_encrypt
501 /*           */   (gcry_cipher_hd_t c,
502                    unsigned char *outbuf, size_t outbuflen,
503                    const unsigned char *inbuf, size_t inbuflen);
504 gcry_err_code_t _gcry_cipher_gcm_decrypt
505 /*           */   (gcry_cipher_hd_t c,
506                    unsigned char *outbuf, size_t outbuflen,
507                    const unsigned char *inbuf, size_t inbuflen);
508 gcry_err_code_t _gcry_cipher_gcm_setiv
509 /*           */   (gcry_cipher_hd_t c,
510                    const unsigned char *iv, size_t ivlen);
511 gcry_err_code_t _gcry_cipher_gcm_authenticate
512 /*           */   (gcry_cipher_hd_t c,
513                    const unsigned char *aadbuf, size_t aadbuflen);
514 gcry_err_code_t _gcry_cipher_gcm_get_tag
515 /*           */   (gcry_cipher_hd_t c,
516                    unsigned char *outtag, size_t taglen);
517 gcry_err_code_t _gcry_cipher_gcm_check_tag
518 /*           */   (gcry_cipher_hd_t c,
519                    const unsigned char *intag, size_t taglen);
520 void _gcry_cipher_gcm_setkey
521 /*           */   (gcry_cipher_hd_t c);
522
523
524 /*-- cipher-poly1305.c --*/
525 gcry_err_code_t _gcry_cipher_poly1305_encrypt
526 /*           */   (gcry_cipher_hd_t c,
527                    unsigned char *outbuf, size_t outbuflen,
528                    const unsigned char *inbuf, size_t inbuflen);
529 gcry_err_code_t _gcry_cipher_poly1305_decrypt
530 /*           */   (gcry_cipher_hd_t c,
531                    unsigned char *outbuf, size_t outbuflen,
532                    const unsigned char *inbuf, size_t inbuflen);
533 gcry_err_code_t _gcry_cipher_poly1305_setiv
534 /*           */   (gcry_cipher_hd_t c,
535                    const unsigned char *iv, size_t ivlen);
536 gcry_err_code_t _gcry_cipher_poly1305_authenticate
537 /*           */   (gcry_cipher_hd_t c,
538                    const unsigned char *aadbuf, size_t aadbuflen);
539 gcry_err_code_t _gcry_cipher_poly1305_get_tag
540 /*           */   (gcry_cipher_hd_t c,
541                    unsigned char *outtag, size_t taglen);
542 gcry_err_code_t _gcry_cipher_poly1305_check_tag
543 /*           */   (gcry_cipher_hd_t c,
544                    const unsigned char *intag, size_t taglen);
545 void _gcry_cipher_poly1305_setkey
546 /*           */   (gcry_cipher_hd_t c);
547
548
549 /*-- chacha20.c --*/
550 gcry_err_code_t _gcry_chacha20_poly1305_encrypt
551 /*           */   (gcry_cipher_hd_t c, byte *outbuf, const byte *inbuf,
552                    size_t length);
553 gcry_err_code_t _gcry_chacha20_poly1305_decrypt
554 /*           */   (gcry_cipher_hd_t c, byte *outbuf, const byte *inbuf,
555                    size_t length);
556
557
558 /*-- cipher-ocb.c --*/
559 gcry_err_code_t _gcry_cipher_ocb_encrypt
560 /*           */ (gcry_cipher_hd_t c,
561                  unsigned char *outbuf, size_t outbuflen,
562                  const unsigned char *inbuf, size_t inbuflen);
563 gcry_err_code_t _gcry_cipher_ocb_decrypt
564 /*           */ (gcry_cipher_hd_t c,
565                  unsigned char *outbuf, size_t outbuflen,
566                  const unsigned char *inbuf, size_t inbuflen);
567 gcry_err_code_t _gcry_cipher_ocb_set_nonce
568 /*           */ (gcry_cipher_hd_t c, const unsigned char *nonce,
569                  size_t noncelen);
570 gcry_err_code_t _gcry_cipher_ocb_authenticate
571 /*           */ (gcry_cipher_hd_t c, const unsigned char *abuf, size_t abuflen);
572 gcry_err_code_t _gcry_cipher_ocb_get_tag
573 /*           */ (gcry_cipher_hd_t c,
574                  unsigned char *outtag, size_t taglen);
575 gcry_err_code_t _gcry_cipher_ocb_check_tag
576 /*           */ (gcry_cipher_hd_t c,
577                  const unsigned char *intag, size_t taglen);
578 void _gcry_cipher_ocb_setkey
579 /*           */ (gcry_cipher_hd_t c);
580
581
582 /*-- cipher-xts.c --*/
583 gcry_err_code_t _gcry_cipher_xts_encrypt
584 /*           */ (gcry_cipher_hd_t c, unsigned char *outbuf, size_t outbuflen,
585                  const unsigned char *inbuf, size_t inbuflen);
586 gcry_err_code_t _gcry_cipher_xts_decrypt
587 /*           */ (gcry_cipher_hd_t c, unsigned char *outbuf, size_t outbuflen,
588                  const unsigned char *inbuf, size_t inbuflen);
589
590
591 /* Return the L-value for block N.  Note: 'cipher_ocb.c' ensures that N
592  * will never be multiple of 65536 (1 << OCB_L_TABLE_SIZE), thus N can
593  * be directly passed to _gcry_ctz() function and resulting index will
594  * never overflow the table.  */
595 static inline const unsigned char *
596 ocb_get_l (gcry_cipher_hd_t c, u64 n)
597 {
598   unsigned long ntz;
599
600 #if ((defined(__i386__) || defined(__x86_64__)) && __GNUC__ >= 4)
601   /* Assumes that N != 0. */
602   asm ("rep;bsfl %k[low], %k[ntz]\n\t"
603         : [ntz] "=r" (ntz)
604         : [low] "r" ((unsigned long)n)
605         : "cc");
606 #else
607   ntz = _gcry_ctz (n);
608 #endif
609
610   return c->u_mode.ocb.L[ntz];
611 }
612
613
614 /* Return bit-shift of blocksize. */
615 static inline unsigned int _gcry_blocksize_shift(gcry_cipher_hd_t c)
616 {
617   /* Only blocksizes 8 and 16 are used. Return value in such way
618    * that compiler can optimize calling functions based on this.  */
619   return c->spec->blocksize == 8 ? 3 : 4;
620 }
621
622
623 /* Optimized function for cipher block copying */
624 static inline void
625 cipher_block_cpy(void *_dst, const void *_src, size_t blocksize)
626 {
627   byte *dst = _dst;
628   const byte *src = _src;
629   u64 s[2];
630
631   if (blocksize == 8)
632     {
633       buf_put_he64(dst + 0, buf_get_he64(src + 0));
634     }
635   else /* blocksize == 16 */
636     {
637       s[0] = buf_get_he64(src + 0);
638       s[1] = buf_get_he64(src + 8);
639       buf_put_he64(dst + 0, s[0]);
640       buf_put_he64(dst + 8, s[1]);
641     }
642 }
643
644
645 /* Optimized function for cipher block xoring */
646 static inline void
647 cipher_block_xor(void *_dst, const void *_src1, const void *_src2,
648                  size_t blocksize)
649 {
650   byte *dst = _dst;
651   const byte *src1 = _src1;
652   const byte *src2 = _src2;
653   u64 s1[2];
654   u64 s2[2];
655
656   if (blocksize == 8)
657     {
658       buf_put_he64(dst + 0, buf_get_he64(src1 + 0) ^ buf_get_he64(src2 + 0));
659     }
660   else /* blocksize == 16 */
661     {
662       s1[0] = buf_get_he64(src1 + 0);
663       s1[1] = buf_get_he64(src1 + 8);
664       s2[0] = buf_get_he64(src2 + 0);
665       s2[1] = buf_get_he64(src2 + 8);
666       buf_put_he64(dst + 0, s1[0] ^ s2[0]);
667       buf_put_he64(dst + 8, s1[1] ^ s2[1]);
668     }
669 }
670
671
672 /* Optimized function for in-place cipher block xoring */
673 static inline void
674 cipher_block_xor_1(void *_dst, const void *_src, size_t blocksize)
675 {
676   cipher_block_xor (_dst, _dst, _src, blocksize);
677 }
678
679
680 /* Optimized function for cipher block xoring with two destination cipher
681    blocks.  Used mainly by CFB mode encryption.  */
682 static inline void
683 cipher_block_xor_2dst(void *_dst1, void *_dst2, const void *_src,
684                       size_t blocksize)
685 {
686   byte *dst1 = _dst1;
687   byte *dst2 = _dst2;
688   const byte *src = _src;
689   u64 d2[2];
690   u64 s[2];
691
692   if (blocksize == 8)
693     {
694       d2[0] = buf_get_he64(dst2 + 0) ^ buf_get_he64(src + 0);
695       buf_put_he64(dst2 + 0, d2[0]);
696       buf_put_he64(dst1 + 0, d2[0]);
697     }
698   else /* blocksize == 16 */
699     {
700       s[0] = buf_get_he64(src + 0);
701       s[1] = buf_get_he64(src + 8);
702       d2[0] = buf_get_he64(dst2 + 0);
703       d2[1] = buf_get_he64(dst2 + 8);
704       d2[0] = d2[0] ^ s[0];
705       d2[1] = d2[1] ^ s[1];
706       buf_put_he64(dst2 + 0, d2[0]);
707       buf_put_he64(dst2 + 8, d2[1]);
708       buf_put_he64(dst1 + 0, d2[0]);
709       buf_put_he64(dst1 + 8, d2[1]);
710     }
711 }
712
713
714 /* Optimized function for combined cipher block xoring and copying.
715    Used by mainly CBC mode decryption.  */
716 static inline void
717 cipher_block_xor_n_copy_2(void *_dst_xor, const void *_src_xor,
718                           void *_srcdst_cpy, const void *_src_cpy,
719                           size_t blocksize)
720 {
721   byte *dst_xor = _dst_xor;
722   byte *srcdst_cpy = _srcdst_cpy;
723   const byte *src_xor = _src_xor;
724   const byte *src_cpy = _src_cpy;
725   u64 sc[2];
726   u64 sx[2];
727   u64 sdc[2];
728
729   if (blocksize == 8)
730     {
731       sc[0] = buf_get_he64(src_cpy + 0);
732       buf_put_he64(dst_xor + 0,
733                    buf_get_he64(srcdst_cpy + 0) ^ buf_get_he64(src_xor + 0));
734       buf_put_he64(srcdst_cpy + 0, sc[0]);
735     }
736   else /* blocksize == 16 */
737     {
738       sc[0] = buf_get_he64(src_cpy + 0);
739       sc[1] = buf_get_he64(src_cpy + 8);
740       sx[0] = buf_get_he64(src_xor + 0);
741       sx[1] = buf_get_he64(src_xor + 8);
742       sdc[0] = buf_get_he64(srcdst_cpy + 0);
743       sdc[1] = buf_get_he64(srcdst_cpy + 8);
744       sx[0] ^= sdc[0];
745       sx[1] ^= sdc[1];
746       buf_put_he64(dst_xor + 0, sx[0]);
747       buf_put_he64(dst_xor + 8, sx[1]);
748       buf_put_he64(srcdst_cpy + 0, sc[0]);
749       buf_put_he64(srcdst_cpy + 8, sc[1]);
750     }
751 }
752
753
754 /* Optimized function for combined cipher block xoring and copying.
755    Used by mainly CFB mode decryption.  */
756 static inline void
757 cipher_block_xor_n_copy(void *_dst_xor, void *_srcdst_cpy, const void *_src,
758                         size_t blocksize)
759 {
760   cipher_block_xor_n_copy_2(_dst_xor, _src, _srcdst_cpy, _src, blocksize);
761 }
762
763
764 #endif /*G10_CIPHER_INTERNAL_H*/