b12c3be7e3d5b37c1cab34fb8dd0f2bea7c8c814
[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 bulk operations.  Due to
144      limitations of the module system (we don't want to change the
145      API) we need to keep these function pointers here.  The cipher
146      open function initializes them and the actual encryption routines
147      use them if they are not NULL.  */
148   struct {
149     void (*cfb_enc)(void *context, unsigned char *iv,
150                     void *outbuf_arg, const void *inbuf_arg,
151                     size_t nblocks);
152     void (*cfb_dec)(void *context, unsigned char *iv,
153                     void *outbuf_arg, const void *inbuf_arg,
154                     size_t nblocks);
155     void (*cbc_enc)(void *context, unsigned char *iv,
156                     void *outbuf_arg, const void *inbuf_arg,
157                     size_t nblocks, int cbc_mac);
158     void (*cbc_dec)(void *context, unsigned char *iv,
159                     void *outbuf_arg, const void *inbuf_arg,
160                     size_t nblocks);
161     void (*ctr_enc)(void *context, unsigned char *iv,
162                     void *outbuf_arg, const void *inbuf_arg,
163                     size_t nblocks);
164     size_t (*ocb_crypt)(gcry_cipher_hd_t c, void *outbuf_arg,
165                         const void *inbuf_arg, size_t nblocks, int encrypt);
166     size_t (*ocb_auth)(gcry_cipher_hd_t c, const void *abuf_arg,
167                        size_t nblocks);
168     void (*xts_crypt)(void *context, unsigned char *tweak,
169                       void *outbuf_arg, const void *inbuf_arg,
170                       size_t nblocks, int encrypt);
171   } bulk;
172
173
174   int mode;
175   unsigned int flags;
176
177   struct {
178     unsigned int key:1; /* Set to 1 if a key has been set.  */
179     unsigned int iv:1;  /* Set to 1 if a IV has been set.  */
180     unsigned int tag:1; /* Set to 1 if a tag is finalized. */
181     unsigned int finalize:1; /* Next encrypt/decrypt has the final data.  */
182   } marks;
183
184   /* The initialization vector.  For best performance we make sure
185      that it is properly aligned.  In particular some implementations
186      of bulk operations expect an 16 byte aligned IV.  IV is also used
187      to store CBC-MAC in CCM mode; counter IV is stored in U_CTR.  For
188      OCB mode it is used for the offset value.  */
189   union {
190     cipher_context_alignment_t iv_align;
191     unsigned char iv[MAX_BLOCKSIZE];
192   } u_iv;
193
194   /* The counter for CTR mode.  This field is also used by AESWRAP and
195      thus we can't use the U_IV union.  For OCB mode it is used for
196      the checksum.  */
197   union {
198     cipher_context_alignment_t iv_align;
199     unsigned char ctr[MAX_BLOCKSIZE];
200   } u_ctr;
201
202   /* Space to save an IV or CTR for chaining operations.  */
203   unsigned char lastiv[MAX_BLOCKSIZE];
204   int unused;  /* Number of unused bytes in LASTIV. */
205
206   union {
207     /* Mode specific storage for CCM mode. */
208     struct {
209       u64 encryptlen;
210       u64 aadlen;
211       unsigned int authlen;
212
213       /* Space to save partial input lengths for MAC. */
214       unsigned char macbuf[GCRY_CCM_BLOCK_LEN];
215       int mac_unused;  /* Number of unprocessed bytes in MACBUF. */
216
217       unsigned char s0[GCRY_CCM_BLOCK_LEN];
218
219       unsigned int nonce:1; /* Set to 1 if nonce has been set.  */
220       unsigned int lengths:1; /* Set to 1 if CCM length parameters has been
221                                  processed.  */
222     } ccm;
223
224     /* Mode specific storage for Poly1305 mode. */
225     struct {
226       /* byte counter for AAD. */
227       u32 aadcount[2];
228
229       /* byte counter for data. */
230       u32 datacount[2];
231
232       unsigned int aad_finalized:1;
233       unsigned int bytecount_over_limits:1;
234
235       poly1305_context_t ctx;
236     } poly1305;
237
238     /* Mode specific storage for CMAC mode. */
239     gcry_cmac_context_t cmac;
240
241     /* Mode specific storage for EAX mode. */
242     struct {
243       /* CMAC for header (AAD). */
244       gcry_cmac_context_t cmac_header;
245
246       /* CMAC for ciphertext. */
247       gcry_cmac_context_t cmac_ciphertext;
248     } eax;
249
250     /* Mode specific storage for GCM mode. */
251     struct {
252       /* The interim tag for GCM mode.  */
253       union {
254         cipher_context_alignment_t iv_align;
255         unsigned char tag[MAX_BLOCKSIZE];
256       } u_tag;
257
258       /* Space to save partial input lengths for MAC. */
259       unsigned char macbuf[GCRY_CCM_BLOCK_LEN];
260       int mac_unused;  /* Number of unprocessed bytes in MACBUF. */
261
262       /* byte counters for GCM */
263       u32 aadlen[2];
264       u32 datalen[2];
265
266       /* encrypted tag counter */
267       unsigned char tagiv[MAX_BLOCKSIZE];
268
269       unsigned int ghash_data_finalized:1;
270       unsigned int ghash_aad_finalized:1;
271
272       unsigned int datalen_over_limits:1;
273       unsigned int disallow_encryption_because_of_setiv_in_fips_mode:1;
274
275       /* --- Following members are not cleared in gcry_cipher_reset --- */
276
277       /* GHASH multiplier from key.  */
278       union {
279         cipher_context_alignment_t iv_align;
280         unsigned char key[MAX_BLOCKSIZE];
281       } u_ghash_key;
282
283       /* GHASH implementation in use. */
284       ghash_fn_t ghash_fn;
285
286       /* Pre-calculated table for GCM. */
287 #ifdef GCM_USE_TABLES
288  #if (SIZEOF_UNSIGNED_LONG == 8 || defined(__x86_64__))
289       #define GCM_TABLES_USE_U64 1
290       u64 gcm_table[2 * 16];
291  #else
292       #undef GCM_TABLES_USE_U64
293       u32 gcm_table[4 * 16];
294  #endif
295 #endif
296     } gcm;
297
298     /* Mode specific storage for OCB mode. */
299     struct {
300       /* Helper variables and pre-computed table of L values.  */
301       unsigned char L_star[OCB_BLOCK_LEN];
302       unsigned char L_dollar[OCB_BLOCK_LEN];
303       unsigned char L[OCB_BLOCK_LEN][OCB_L_TABLE_SIZE];
304
305       /* The tag is valid if marks.tag has been set.  */
306       unsigned char tag[OCB_BLOCK_LEN];
307
308       /* A buffer to hold the offset for the AAD processing.  */
309       unsigned char aad_offset[OCB_BLOCK_LEN];
310
311       /* A buffer to hold the current sum of AAD processing.  We can't
312          use tag here because tag may already hold the preprocessed
313          checksum of the data.  */
314       unsigned char aad_sum[OCB_BLOCK_LEN];
315
316       /* A buffer to store AAD data not yet processed.  */
317       unsigned char aad_leftover[OCB_BLOCK_LEN];
318
319       /* Number of data/aad blocks processed so far.  */
320       u64 data_nblocks;
321       u64 aad_nblocks;
322
323       /* Number of valid bytes in AAD_LEFTOVER.  */
324       unsigned char aad_nleftover;
325
326       /* Length of the tag.  Fixed for now but may eventually be
327          specified using a set of gcry_cipher_flags.  */
328       unsigned char taglen;
329
330       /* Flags indicating that the final data/aad block has been
331          processed.  */
332       unsigned int data_finalized:1;
333       unsigned int aad_finalized:1;
334     } ocb;
335
336     /* Mode specific storage for XTS mode. */
337     struct {
338       /* Pointer to tweak cipher context, allocated after actual
339        * cipher context. */
340       char *tweak_context;
341     } xts;
342   } u_mode;
343
344   /* What follows are two contexts of the cipher in use.  The first
345      one needs to be aligned well enough for the cipher operation
346      whereas the second one is a copy created by cipher_setkey and
347      used by cipher_reset.  That second copy has no need for proper
348      aligment because it is only accessed by memcpy.  */
349   cipher_context_alignment_t context;
350 };
351
352
353 /*-- cipher-cbc.c --*/
354 gcry_err_code_t _gcry_cipher_cbc_encrypt
355 /*           */ (gcry_cipher_hd_t c,
356                  unsigned char *outbuf, size_t outbuflen,
357                  const unsigned char *inbuf, size_t inbuflen);
358 gcry_err_code_t _gcry_cipher_cbc_decrypt
359 /*           */ (gcry_cipher_hd_t c,
360                  unsigned char *outbuf, size_t outbuflen,
361                  const unsigned char *inbuf, size_t inbuflen);
362 gcry_err_code_t _gcry_cipher_cbc_cts_encrypt
363 /*           */ (gcry_cipher_hd_t c,
364                  unsigned char *outbuf, size_t outbuflen,
365                  const unsigned char *inbuf, size_t inbuflen);
366 gcry_err_code_t _gcry_cipher_cbc_cts_decrypt
367 /*           */ (gcry_cipher_hd_t c,
368                  unsigned char *outbuf, size_t outbuflen,
369                  const unsigned char *inbuf, size_t inbuflen);
370
371 /*-- cipher-cfb.c --*/
372 gcry_err_code_t _gcry_cipher_cfb_encrypt
373 /*           */ (gcry_cipher_hd_t c,
374                  unsigned char *outbuf, size_t outbuflen,
375                  const unsigned char *inbuf, size_t inbuflen);
376 gcry_err_code_t _gcry_cipher_cfb_decrypt
377 /*           */ (gcry_cipher_hd_t c,
378                  unsigned char *outbuf, size_t outbuflen,
379                  const unsigned char *inbuf, size_t inbuflen);
380 gcry_err_code_t _gcry_cipher_cfb8_encrypt
381 /*           */ (gcry_cipher_hd_t c,
382                  unsigned char *outbuf, size_t outbuflen,
383                  const unsigned char *inbuf, size_t inbuflen);
384 gcry_err_code_t _gcry_cipher_cfb8_decrypt
385 /*           */ (gcry_cipher_hd_t c,
386                  unsigned char *outbuf, size_t outbuflen,
387                  const unsigned char *inbuf, size_t inbuflen);
388
389
390 /*-- cipher-ofb.c --*/
391 gcry_err_code_t _gcry_cipher_ofb_encrypt
392 /*           */ (gcry_cipher_hd_t c,
393                  unsigned char *outbuf, size_t outbuflen,
394                  const unsigned char *inbuf, size_t inbuflen);
395
396 /*-- cipher-ctr.c --*/
397 gcry_err_code_t _gcry_cipher_ctr_encrypt
398 /*           */ (gcry_cipher_hd_t c,
399                  unsigned char *outbuf, size_t outbuflen,
400                  const unsigned char *inbuf, size_t inbuflen);
401
402
403 /*-- cipher-aeswrap.c --*/
404 gcry_err_code_t _gcry_cipher_aeswrap_encrypt
405 /*           */   (gcry_cipher_hd_t c,
406                    byte *outbuf, size_t outbuflen,
407                    const byte *inbuf, size_t inbuflen);
408 gcry_err_code_t _gcry_cipher_aeswrap_decrypt
409 /*           */   (gcry_cipher_hd_t c,
410                    byte *outbuf, size_t outbuflen,
411                    const byte *inbuf, size_t inbuflen);
412
413
414 /*-- cipher-ccm.c --*/
415 gcry_err_code_t _gcry_cipher_ccm_encrypt
416 /*           */ (gcry_cipher_hd_t c,
417                  unsigned char *outbuf, size_t outbuflen,
418                  const unsigned char *inbuf, size_t inbuflen);
419 gcry_err_code_t _gcry_cipher_ccm_decrypt
420 /*           */ (gcry_cipher_hd_t c,
421                  unsigned char *outbuf, size_t outbuflen,
422                  const unsigned char *inbuf, size_t inbuflen);
423 gcry_err_code_t _gcry_cipher_ccm_set_nonce
424 /*           */ (gcry_cipher_hd_t c, const unsigned char *nonce,
425                  size_t noncelen);
426 gcry_err_code_t _gcry_cipher_ccm_authenticate
427 /*           */ (gcry_cipher_hd_t c, const unsigned char *abuf, size_t abuflen);
428 gcry_err_code_t _gcry_cipher_ccm_set_lengths
429 /*           */ (gcry_cipher_hd_t c, u64 encryptedlen, u64 aadlen, u64 taglen);
430 gcry_err_code_t _gcry_cipher_ccm_get_tag
431 /*           */ (gcry_cipher_hd_t c,
432                  unsigned char *outtag, size_t taglen);
433 gcry_err_code_t _gcry_cipher_ccm_check_tag
434 /*           */ (gcry_cipher_hd_t c,
435                  const unsigned char *intag, size_t taglen);
436
437
438 /*-- cipher-cmac.c --*/
439 gcry_err_code_t _gcry_cmac_generate_subkeys
440 /*           */ (gcry_cipher_hd_t c, gcry_cmac_context_t *ctx);
441 gcry_err_code_t _gcry_cmac_write
442 /*           */ (gcry_cipher_hd_t c, gcry_cmac_context_t *ctx,
443                  const byte * inbuf, size_t inlen);
444 gcry_err_code_t _gcry_cmac_final
445 /*           */ (gcry_cipher_hd_t c, gcry_cmac_context_t *ctx);
446 void _gcry_cmac_reset (gcry_cmac_context_t *ctx);
447
448
449 /*-- cipher-eax.c --*/
450 gcry_err_code_t _gcry_cipher_eax_encrypt
451 /*           */   (gcry_cipher_hd_t c,
452                    unsigned char *outbuf, size_t outbuflen,
453                    const unsigned char *inbuf, size_t inbuflen);
454 gcry_err_code_t _gcry_cipher_eax_decrypt
455 /*           */   (gcry_cipher_hd_t c,
456                    unsigned char *outbuf, size_t outbuflen,
457                    const unsigned char *inbuf, size_t inbuflen);
458 gcry_err_code_t _gcry_cipher_eax_set_nonce
459 /*           */   (gcry_cipher_hd_t c,
460                    const unsigned char *nonce, size_t noncelen);
461 gcry_err_code_t _gcry_cipher_eax_authenticate
462 /*           */   (gcry_cipher_hd_t c,
463                    const unsigned char *aadbuf, size_t aadbuflen);
464 gcry_err_code_t _gcry_cipher_eax_get_tag
465 /*           */   (gcry_cipher_hd_t c,
466                    unsigned char *outtag, size_t taglen);
467 gcry_err_code_t _gcry_cipher_eax_check_tag
468 /*           */   (gcry_cipher_hd_t c,
469                    const unsigned char *intag, size_t taglen);
470 gcry_err_code_t _gcry_cipher_eax_setkey
471 /*           */   (gcry_cipher_hd_t c);
472
473
474 /*-- cipher-gcm.c --*/
475 gcry_err_code_t _gcry_cipher_gcm_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_gcm_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_gcm_setiv
484 /*           */   (gcry_cipher_hd_t c,
485                    const unsigned char *iv, size_t ivlen);
486 gcry_err_code_t _gcry_cipher_gcm_authenticate
487 /*           */   (gcry_cipher_hd_t c,
488                    const unsigned char *aadbuf, size_t aadbuflen);
489 gcry_err_code_t _gcry_cipher_gcm_get_tag
490 /*           */   (gcry_cipher_hd_t c,
491                    unsigned char *outtag, size_t taglen);
492 gcry_err_code_t _gcry_cipher_gcm_check_tag
493 /*           */   (gcry_cipher_hd_t c,
494                    const unsigned char *intag, size_t taglen);
495 void _gcry_cipher_gcm_setkey
496 /*           */   (gcry_cipher_hd_t c);
497
498
499 /*-- cipher-poly1305.c --*/
500 gcry_err_code_t _gcry_cipher_poly1305_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_poly1305_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_poly1305_setiv
509 /*           */   (gcry_cipher_hd_t c,
510                    const unsigned char *iv, size_t ivlen);
511 gcry_err_code_t _gcry_cipher_poly1305_authenticate
512 /*           */   (gcry_cipher_hd_t c,
513                    const unsigned char *aadbuf, size_t aadbuflen);
514 gcry_err_code_t _gcry_cipher_poly1305_get_tag
515 /*           */   (gcry_cipher_hd_t c,
516                    unsigned char *outtag, size_t taglen);
517 gcry_err_code_t _gcry_cipher_poly1305_check_tag
518 /*           */   (gcry_cipher_hd_t c,
519                    const unsigned char *intag, size_t taglen);
520 void _gcry_cipher_poly1305_setkey
521 /*           */   (gcry_cipher_hd_t c);
522
523
524 /*-- cipher-ocb.c --*/
525 gcry_err_code_t _gcry_cipher_ocb_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_ocb_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_ocb_set_nonce
534 /*           */ (gcry_cipher_hd_t c, const unsigned char *nonce,
535                  size_t noncelen);
536 gcry_err_code_t _gcry_cipher_ocb_authenticate
537 /*           */ (gcry_cipher_hd_t c, const unsigned char *abuf, size_t abuflen);
538 gcry_err_code_t _gcry_cipher_ocb_get_tag
539 /*           */ (gcry_cipher_hd_t c,
540                  unsigned char *outtag, size_t taglen);
541 gcry_err_code_t _gcry_cipher_ocb_check_tag
542 /*           */ (gcry_cipher_hd_t c,
543                  const unsigned char *intag, size_t taglen);
544
545
546 /*-- cipher-xts.c --*/
547 gcry_err_code_t _gcry_cipher_xts_crypt
548 /*           */ (gcry_cipher_hd_t c, unsigned char *outbuf, size_t outbuflen,
549                  const unsigned char *inbuf, size_t inbuflen, int encrypt);
550
551
552 /* Return the L-value for block N.  Note: 'cipher_ocb.c' ensures that N
553  * will never be multiple of 65536 (1 << OCB_L_TABLE_SIZE), thus N can
554  * be directly passed to _gcry_ctz() function and resulting index will
555  * never overflow the table.  */
556 static inline const unsigned char *
557 ocb_get_l (gcry_cipher_hd_t c, u64 n)
558 {
559   unsigned long ntz;
560
561 #if ((defined(__i386__) || defined(__x86_64__)) && __GNUC__ >= 4)
562   /* Assumes that N != 0. */
563   asm ("rep;bsfl %k[low], %k[ntz]\n\t"
564         : [ntz] "=r" (ntz)
565         : [low] "r" ((unsigned long)n)
566         : "cc");
567 #else
568   ntz = _gcry_ctz (n);
569 #endif
570
571   return c->u_mode.ocb.L[ntz];
572 }
573
574
575 /* Return bit-shift of blocksize. */
576 static inline unsigned int _gcry_blocksize_shift(gcry_cipher_hd_t c)
577 {
578   /* Only blocksizes 8 and 16 are used. Return value in such way
579    * that compiler can optimize calling functions based on this.  */
580   return c->spec->blocksize == 8 ? 3 : 4;
581 }
582
583
584 #endif /*G10_CIPHER_INTERNAL_H*/