Access cipher mode routines through routine pointers
[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       /* Helper variables and pre-computed table of L values.  */
320       unsigned char L_star[OCB_BLOCK_LEN];
321       unsigned char L_dollar[OCB_BLOCK_LEN];
322       unsigned char L[OCB_BLOCK_LEN][OCB_L_TABLE_SIZE];
323
324       /* The tag is valid if marks.tag has been set.  */
325       unsigned char tag[OCB_BLOCK_LEN];
326
327       /* A buffer to hold the offset for the AAD processing.  */
328       unsigned char aad_offset[OCB_BLOCK_LEN];
329
330       /* A buffer to hold the current sum of AAD processing.  We can't
331          use tag here because tag may already hold the preprocessed
332          checksum of the data.  */
333       unsigned char aad_sum[OCB_BLOCK_LEN];
334
335       /* A buffer to store AAD data not yet processed.  */
336       unsigned char aad_leftover[OCB_BLOCK_LEN];
337
338       /* Number of data/aad blocks processed so far.  */
339       u64 data_nblocks;
340       u64 aad_nblocks;
341
342       /* Number of valid bytes in AAD_LEFTOVER.  */
343       unsigned char aad_nleftover;
344
345       /* Length of the tag.  Fixed for now but may eventually be
346          specified using a set of gcry_cipher_flags.  */
347       unsigned char taglen;
348
349       /* Flags indicating that the final data/aad block has been
350          processed.  */
351       unsigned int data_finalized:1;
352       unsigned int aad_finalized:1;
353     } ocb;
354
355     /* Mode specific storage for XTS mode. */
356     struct {
357       /* Pointer to tweak cipher context, allocated after actual
358        * cipher context. */
359       char *tweak_context;
360     } xts;
361   } u_mode;
362
363   /* What follows are two contexts of the cipher in use.  The first
364      one needs to be aligned well enough for the cipher operation
365      whereas the second one is a copy created by cipher_setkey and
366      used by cipher_reset.  That second copy has no need for proper
367      aligment because it is only accessed by memcpy.  */
368   cipher_context_alignment_t context;
369 };
370
371
372 /*-- cipher-cbc.c --*/
373 gcry_err_code_t _gcry_cipher_cbc_encrypt
374 /*           */ (gcry_cipher_hd_t c,
375                  unsigned char *outbuf, size_t outbuflen,
376                  const unsigned char *inbuf, size_t inbuflen);
377 gcry_err_code_t _gcry_cipher_cbc_decrypt
378 /*           */ (gcry_cipher_hd_t c,
379                  unsigned char *outbuf, size_t outbuflen,
380                  const unsigned char *inbuf, size_t inbuflen);
381 gcry_err_code_t _gcry_cipher_cbc_cts_encrypt
382 /*           */ (gcry_cipher_hd_t c,
383                  unsigned char *outbuf, size_t outbuflen,
384                  const unsigned char *inbuf, size_t inbuflen);
385 gcry_err_code_t _gcry_cipher_cbc_cts_decrypt
386 /*           */ (gcry_cipher_hd_t c,
387                  unsigned char *outbuf, size_t outbuflen,
388                  const unsigned char *inbuf, size_t inbuflen);
389
390 /*-- cipher-cfb.c --*/
391 gcry_err_code_t _gcry_cipher_cfb_encrypt
392 /*           */ (gcry_cipher_hd_t c,
393                  unsigned char *outbuf, size_t outbuflen,
394                  const unsigned char *inbuf, size_t inbuflen);
395 gcry_err_code_t _gcry_cipher_cfb_decrypt
396 /*           */ (gcry_cipher_hd_t c,
397                  unsigned char *outbuf, size_t outbuflen,
398                  const unsigned char *inbuf, size_t inbuflen);
399 gcry_err_code_t _gcry_cipher_cfb8_encrypt
400 /*           */ (gcry_cipher_hd_t c,
401                  unsigned char *outbuf, size_t outbuflen,
402                  const unsigned char *inbuf, size_t inbuflen);
403 gcry_err_code_t _gcry_cipher_cfb8_decrypt
404 /*           */ (gcry_cipher_hd_t c,
405                  unsigned char *outbuf, size_t outbuflen,
406                  const unsigned char *inbuf, size_t inbuflen);
407
408
409 /*-- cipher-ofb.c --*/
410 gcry_err_code_t _gcry_cipher_ofb_encrypt
411 /*           */ (gcry_cipher_hd_t c,
412                  unsigned char *outbuf, size_t outbuflen,
413                  const unsigned char *inbuf, size_t inbuflen);
414
415 /*-- cipher-ctr.c --*/
416 gcry_err_code_t _gcry_cipher_ctr_encrypt
417 /*           */ (gcry_cipher_hd_t c,
418                  unsigned char *outbuf, size_t outbuflen,
419                  const unsigned char *inbuf, size_t inbuflen);
420
421
422 /*-- cipher-aeswrap.c --*/
423 gcry_err_code_t _gcry_cipher_aeswrap_encrypt
424 /*           */   (gcry_cipher_hd_t c,
425                    byte *outbuf, size_t outbuflen,
426                    const byte *inbuf, size_t inbuflen);
427 gcry_err_code_t _gcry_cipher_aeswrap_decrypt
428 /*           */   (gcry_cipher_hd_t c,
429                    byte *outbuf, size_t outbuflen,
430                    const byte *inbuf, size_t inbuflen);
431
432
433 /*-- cipher-ccm.c --*/
434 gcry_err_code_t _gcry_cipher_ccm_encrypt
435 /*           */ (gcry_cipher_hd_t c,
436                  unsigned char *outbuf, size_t outbuflen,
437                  const unsigned char *inbuf, size_t inbuflen);
438 gcry_err_code_t _gcry_cipher_ccm_decrypt
439 /*           */ (gcry_cipher_hd_t c,
440                  unsigned char *outbuf, size_t outbuflen,
441                  const unsigned char *inbuf, size_t inbuflen);
442 gcry_err_code_t _gcry_cipher_ccm_set_nonce
443 /*           */ (gcry_cipher_hd_t c, const unsigned char *nonce,
444                  size_t noncelen);
445 gcry_err_code_t _gcry_cipher_ccm_authenticate
446 /*           */ (gcry_cipher_hd_t c, const unsigned char *abuf, size_t abuflen);
447 gcry_err_code_t _gcry_cipher_ccm_set_lengths
448 /*           */ (gcry_cipher_hd_t c, u64 encryptedlen, u64 aadlen, u64 taglen);
449 gcry_err_code_t _gcry_cipher_ccm_get_tag
450 /*           */ (gcry_cipher_hd_t c,
451                  unsigned char *outtag, size_t taglen);
452 gcry_err_code_t _gcry_cipher_ccm_check_tag
453 /*           */ (gcry_cipher_hd_t c,
454                  const unsigned char *intag, size_t taglen);
455
456
457 /*-- cipher-cmac.c --*/
458 gcry_err_code_t _gcry_cmac_generate_subkeys
459 /*           */ (gcry_cipher_hd_t c, gcry_cmac_context_t *ctx);
460 gcry_err_code_t _gcry_cmac_write
461 /*           */ (gcry_cipher_hd_t c, gcry_cmac_context_t *ctx,
462                  const byte * inbuf, size_t inlen);
463 gcry_err_code_t _gcry_cmac_final
464 /*           */ (gcry_cipher_hd_t c, gcry_cmac_context_t *ctx);
465 void _gcry_cmac_reset (gcry_cmac_context_t *ctx);
466
467
468 /*-- cipher-eax.c --*/
469 gcry_err_code_t _gcry_cipher_eax_encrypt
470 /*           */   (gcry_cipher_hd_t c,
471                    unsigned char *outbuf, size_t outbuflen,
472                    const unsigned char *inbuf, size_t inbuflen);
473 gcry_err_code_t _gcry_cipher_eax_decrypt
474 /*           */   (gcry_cipher_hd_t c,
475                    unsigned char *outbuf, size_t outbuflen,
476                    const unsigned char *inbuf, size_t inbuflen);
477 gcry_err_code_t _gcry_cipher_eax_set_nonce
478 /*           */   (gcry_cipher_hd_t c,
479                    const unsigned char *nonce, size_t noncelen);
480 gcry_err_code_t _gcry_cipher_eax_authenticate
481 /*           */   (gcry_cipher_hd_t c,
482                    const unsigned char *aadbuf, size_t aadbuflen);
483 gcry_err_code_t _gcry_cipher_eax_get_tag
484 /*           */   (gcry_cipher_hd_t c,
485                    unsigned char *outtag, size_t taglen);
486 gcry_err_code_t _gcry_cipher_eax_check_tag
487 /*           */   (gcry_cipher_hd_t c,
488                    const unsigned char *intag, size_t taglen);
489 gcry_err_code_t _gcry_cipher_eax_setkey
490 /*           */   (gcry_cipher_hd_t c);
491
492
493 /*-- cipher-gcm.c --*/
494 gcry_err_code_t _gcry_cipher_gcm_encrypt
495 /*           */   (gcry_cipher_hd_t c,
496                    unsigned char *outbuf, size_t outbuflen,
497                    const unsigned char *inbuf, size_t inbuflen);
498 gcry_err_code_t _gcry_cipher_gcm_decrypt
499 /*           */   (gcry_cipher_hd_t c,
500                    unsigned char *outbuf, size_t outbuflen,
501                    const unsigned char *inbuf, size_t inbuflen);
502 gcry_err_code_t _gcry_cipher_gcm_setiv
503 /*           */   (gcry_cipher_hd_t c,
504                    const unsigned char *iv, size_t ivlen);
505 gcry_err_code_t _gcry_cipher_gcm_authenticate
506 /*           */   (gcry_cipher_hd_t c,
507                    const unsigned char *aadbuf, size_t aadbuflen);
508 gcry_err_code_t _gcry_cipher_gcm_get_tag
509 /*           */   (gcry_cipher_hd_t c,
510                    unsigned char *outtag, size_t taglen);
511 gcry_err_code_t _gcry_cipher_gcm_check_tag
512 /*           */   (gcry_cipher_hd_t c,
513                    const unsigned char *intag, size_t taglen);
514 void _gcry_cipher_gcm_setkey
515 /*           */   (gcry_cipher_hd_t c);
516
517
518 /*-- cipher-poly1305.c --*/
519 gcry_err_code_t _gcry_cipher_poly1305_encrypt
520 /*           */   (gcry_cipher_hd_t c,
521                    unsigned char *outbuf, size_t outbuflen,
522                    const unsigned char *inbuf, size_t inbuflen);
523 gcry_err_code_t _gcry_cipher_poly1305_decrypt
524 /*           */   (gcry_cipher_hd_t c,
525                    unsigned char *outbuf, size_t outbuflen,
526                    const unsigned char *inbuf, size_t inbuflen);
527 gcry_err_code_t _gcry_cipher_poly1305_setiv
528 /*           */   (gcry_cipher_hd_t c,
529                    const unsigned char *iv, size_t ivlen);
530 gcry_err_code_t _gcry_cipher_poly1305_authenticate
531 /*           */   (gcry_cipher_hd_t c,
532                    const unsigned char *aadbuf, size_t aadbuflen);
533 gcry_err_code_t _gcry_cipher_poly1305_get_tag
534 /*           */   (gcry_cipher_hd_t c,
535                    unsigned char *outtag, size_t taglen);
536 gcry_err_code_t _gcry_cipher_poly1305_check_tag
537 /*           */   (gcry_cipher_hd_t c,
538                    const unsigned char *intag, size_t taglen);
539 void _gcry_cipher_poly1305_setkey
540 /*           */   (gcry_cipher_hd_t c);
541
542
543 /*-- cipher-ocb.c --*/
544 gcry_err_code_t _gcry_cipher_ocb_encrypt
545 /*           */ (gcry_cipher_hd_t c,
546                  unsigned char *outbuf, size_t outbuflen,
547                  const unsigned char *inbuf, size_t inbuflen);
548 gcry_err_code_t _gcry_cipher_ocb_decrypt
549 /*           */ (gcry_cipher_hd_t c,
550                  unsigned char *outbuf, size_t outbuflen,
551                  const unsigned char *inbuf, size_t inbuflen);
552 gcry_err_code_t _gcry_cipher_ocb_set_nonce
553 /*           */ (gcry_cipher_hd_t c, const unsigned char *nonce,
554                  size_t noncelen);
555 gcry_err_code_t _gcry_cipher_ocb_authenticate
556 /*           */ (gcry_cipher_hd_t c, const unsigned char *abuf, size_t abuflen);
557 gcry_err_code_t _gcry_cipher_ocb_get_tag
558 /*           */ (gcry_cipher_hd_t c,
559                  unsigned char *outtag, size_t taglen);
560 gcry_err_code_t _gcry_cipher_ocb_check_tag
561 /*           */ (gcry_cipher_hd_t c,
562                  const unsigned char *intag, size_t taglen);
563
564
565 /*-- cipher-xts.c --*/
566 gcry_err_code_t _gcry_cipher_xts_encrypt
567 /*           */ (gcry_cipher_hd_t c, unsigned char *outbuf, size_t outbuflen,
568                  const unsigned char *inbuf, size_t inbuflen);
569 gcry_err_code_t _gcry_cipher_xts_decrypt
570 /*           */ (gcry_cipher_hd_t c, unsigned char *outbuf, size_t outbuflen,
571                  const unsigned char *inbuf, size_t inbuflen);
572
573
574 /* Return the L-value for block N.  Note: 'cipher_ocb.c' ensures that N
575  * will never be multiple of 65536 (1 << OCB_L_TABLE_SIZE), thus N can
576  * be directly passed to _gcry_ctz() function and resulting index will
577  * never overflow the table.  */
578 static inline const unsigned char *
579 ocb_get_l (gcry_cipher_hd_t c, u64 n)
580 {
581   unsigned long ntz;
582
583 #if ((defined(__i386__) || defined(__x86_64__)) && __GNUC__ >= 4)
584   /* Assumes that N != 0. */
585   asm ("rep;bsfl %k[low], %k[ntz]\n\t"
586         : [ntz] "=r" (ntz)
587         : [low] "r" ((unsigned long)n)
588         : "cc");
589 #else
590   ntz = _gcry_ctz (n);
591 #endif
592
593   return c->u_mode.ocb.L[ntz];
594 }
595
596
597 /* Return bit-shift of blocksize. */
598 static inline unsigned int _gcry_blocksize_shift(gcry_cipher_hd_t c)
599 {
600   /* Only blocksizes 8 and 16 are used. Return value in such way
601    * that compiler can optimize calling functions based on this.  */
602   return c->spec->blocksize == 8 ? 3 : 4;
603 }
604
605
606 #endif /*G10_CIPHER_INTERNAL_H*/