doc: Fix typo.
[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
76 typedef unsigned int (*ghash_fn_t) (gcry_cipher_hd_t c, byte *result,
77                                     const byte *buf, size_t nblocks);
78
79
80 /* A VIA processor with the Padlock engine as well as the Intel AES_NI
81    instructions require an alignment of most data on a 16 byte
82    boundary.  Because we trick out the compiler while allocating the
83    context, the align attribute as used in rijndael.c does not work on
84    its own.  Thus we need to make sure that the entire context
85    structure is a aligned on that boundary.  We achieve this by
86    defining a new type and use that instead of our usual alignment
87    type.  */
88 typedef union
89 {
90   PROPERLY_ALIGNED_TYPE foo;
91 #ifdef NEED_16BYTE_ALIGNED_CONTEXT
92   char bar[16] __attribute__ ((aligned (16)));
93 #endif
94   char c[1];
95 } cipher_context_alignment_t;
96
97
98 /* The handle structure.  */
99 struct gcry_cipher_handle
100 {
101   int magic;
102   size_t actual_handle_size;     /* Allocated size of this handle. */
103   size_t handle_offset;          /* Offset to the malloced block.  */
104   gcry_cipher_spec_t *spec;
105
106   /* The algorithm id.  This is a hack required because the module
107      interface does not easily allow to retrieve this value. */
108   int algo;
109
110   /* A structure with function pointers for bulk operations.  Due to
111      limitations of the module system (we don't want to change the
112      API) we need to keep these function pointers here.  The cipher
113      open function intializes them and the actual encryption routines
114      use them if they are not NULL.  */
115   struct {
116     void (*cfb_enc)(void *context, unsigned char *iv,
117                     void *outbuf_arg, const void *inbuf_arg,
118                     size_t nblocks);
119     void (*cfb_dec)(void *context, unsigned char *iv,
120                     void *outbuf_arg, const void *inbuf_arg,
121                     size_t nblocks);
122     void (*cbc_enc)(void *context, unsigned char *iv,
123                     void *outbuf_arg, const void *inbuf_arg,
124                     size_t nblocks, int cbc_mac);
125     void (*cbc_dec)(void *context, unsigned char *iv,
126                     void *outbuf_arg, const void *inbuf_arg,
127                     size_t nblocks);
128     void (*ctr_enc)(void *context, unsigned char *iv,
129                     void *outbuf_arg, const void *inbuf_arg,
130                     size_t nblocks);
131     size_t (*ocb_crypt)(gcry_cipher_hd_t c, void *outbuf_arg,
132                         const void *inbuf_arg, size_t nblocks, int encrypt);
133     size_t (*ocb_auth)(gcry_cipher_hd_t c, const void *abuf_arg,
134                        size_t nblocks);
135   } bulk;
136
137
138   int mode;
139   unsigned int flags;
140
141   struct {
142     unsigned int key:1; /* Set to 1 if a key has been set.  */
143     unsigned int iv:1;  /* Set to 1 if a IV has been set.  */
144     unsigned int tag:1; /* Set to 1 if a tag is finalized. */
145     unsigned int finalize:1; /* Next encrypt/decrypt has the final data.  */
146   } marks;
147
148   /* The initialization vector.  For best performance we make sure
149      that it is properly aligned.  In particular some implementations
150      of bulk operations expect an 16 byte aligned IV.  IV is also used
151      to store CBC-MAC in CCM mode; counter IV is stored in U_CTR.  For
152      OCB mode it is used for the offset value.  */
153   union {
154     cipher_context_alignment_t iv_align;
155     unsigned char iv[MAX_BLOCKSIZE];
156   } u_iv;
157
158   /* The counter for CTR mode.  This field is also used by AESWRAP and
159      thus we can't use the U_IV union.  For OCB mode it is used for
160      the checksum.  */
161   union {
162     cipher_context_alignment_t iv_align;
163     unsigned char ctr[MAX_BLOCKSIZE];
164   } u_ctr;
165
166   /* Space to save an IV or CTR for chaining operations.  */
167   unsigned char lastiv[MAX_BLOCKSIZE];
168   int unused;  /* Number of unused bytes in LASTIV. */
169
170   union {
171 #ifdef HAVE_U64_TYPEDEF
172     /* Mode specific storage for CCM mode. */
173     struct {
174       u64 encryptlen;
175       u64 aadlen;
176       unsigned int authlen;
177
178       /* Space to save partial input lengths for MAC. */
179       unsigned char macbuf[GCRY_CCM_BLOCK_LEN];
180       int mac_unused;  /* Number of unprocessed bytes in MACBUF. */
181
182       unsigned char s0[GCRY_CCM_BLOCK_LEN];
183
184       unsigned int nonce:1;/* Set to 1 if nonce has been set.  */
185       unsigned int lengths:1; /* Set to 1 if CCM length parameters has been
186                                  processed.  */
187     } ccm;
188 #endif
189
190     /* Mode specific storage for Poly1305 mode. */
191     struct {
192       /* byte counter for AAD. */
193       u32 aadcount[2];
194
195       /* byte counter for data. */
196       u32 datacount[2];
197
198       unsigned int aad_finalized:1;
199       unsigned int bytecount_over_limits:1;
200
201       poly1305_context_t ctx;
202     } poly1305;
203
204     /* Mode specific storage for CMAC mode. */
205     struct {
206       unsigned int tag:1; /* Set to 1 if tag has been finalized.  */
207
208       /* Subkeys for tag creation, not cleared by gcry_cipher_reset. */
209       unsigned char subkeys[2][MAX_BLOCKSIZE];
210     } cmac;
211
212     /* Mode specific storage for GCM mode. */
213     struct {
214       /* The interim tag for GCM mode.  */
215       union {
216         cipher_context_alignment_t iv_align;
217         unsigned char tag[MAX_BLOCKSIZE];
218       } u_tag;
219
220       /* Space to save partial input lengths for MAC. */
221       unsigned char macbuf[GCRY_CCM_BLOCK_LEN];
222       int mac_unused;  /* Number of unprocessed bytes in MACBUF. */
223
224
225       /* byte counters for GCM */
226       u32 aadlen[2];
227       u32 datalen[2];
228
229       /* encrypted tag counter */
230       unsigned char tagiv[MAX_BLOCKSIZE];
231
232       unsigned int ghash_data_finalized:1;
233       unsigned int ghash_aad_finalized:1;
234
235       unsigned int datalen_over_limits:1;
236       unsigned int disallow_encryption_because_of_setiv_in_fips_mode:1;
237
238       /* --- Following members are not cleared in gcry_cipher_reset --- */
239
240       /* GHASH multiplier from key.  */
241       union {
242         cipher_context_alignment_t iv_align;
243         unsigned char key[MAX_BLOCKSIZE];
244       } u_ghash_key;
245
246       /* GHASH implementation in use. */
247       ghash_fn_t ghash_fn;
248
249       /* Pre-calculated table for GCM. */
250 #ifdef GCM_USE_TABLES
251  #if defined(HAVE_U64_TYPEDEF) && (SIZEOF_UNSIGNED_LONG == 8 \
252                                    || defined(__x86_64__))
253       #define GCM_TABLES_USE_U64 1
254       u64 gcm_table[2 * 16];
255  #else
256       #undef GCM_TABLES_USE_U64
257       u32 gcm_table[4 * 16];
258  #endif
259 #endif
260     } gcm;
261
262     /* Mode specific storage for OCB mode. */
263     struct {
264       /* Helper variables and pre-computed table of L values.  */
265       unsigned char L_star[OCB_BLOCK_LEN];
266       unsigned char L_dollar[OCB_BLOCK_LEN];
267       unsigned char L[OCB_BLOCK_LEN][OCB_L_TABLE_SIZE];
268
269       /* The tag is valid if marks.tag has been set.  */
270       unsigned char tag[OCB_BLOCK_LEN];
271
272       /* A buffer to hold the offset for the AAD processing.  */
273       unsigned char aad_offset[OCB_BLOCK_LEN];
274
275       /* A buffer to hold the current sum of AAD processing.  We can't
276          use tag here because tag may already hold the preprocessed
277          checksum of the data.  */
278       unsigned char aad_sum[OCB_BLOCK_LEN];
279
280       /* Number of data/aad blocks processed so far.  */
281       u64 data_nblocks;
282       u64 aad_nblocks;
283
284       /* Length of the tag.  Fixed for now but may eventually be
285          specified using a set of gcry_cipher_flags.  */
286       unsigned char taglen;
287
288       /* Flags indicating that the final data/aad block has been
289          processed.  */
290       unsigned int data_finalized:1;
291       unsigned int aad_finalized:1;
292
293     } ocb;
294
295   } u_mode;
296
297   /* What follows are two contexts of the cipher in use.  The first
298      one needs to be aligned well enough for the cipher operation
299      whereas the second one is a copy created by cipher_setkey and
300      used by cipher_reset.  That second copy has no need for proper
301      aligment because it is only accessed by memcpy.  */
302   cipher_context_alignment_t context;
303 };
304
305
306 /*-- cipher-cbc.c --*/
307 gcry_err_code_t _gcry_cipher_cbc_encrypt
308 /*           */ (gcry_cipher_hd_t c,
309                  unsigned char *outbuf, size_t outbuflen,
310                  const unsigned char *inbuf, size_t inbuflen);
311 gcry_err_code_t _gcry_cipher_cbc_decrypt
312 /*           */ (gcry_cipher_hd_t c,
313                  unsigned char *outbuf, size_t outbuflen,
314                  const unsigned char *inbuf, size_t inbuflen);
315
316 /*-- cipher-cfb.c --*/
317 gcry_err_code_t _gcry_cipher_cfb_encrypt
318 /*           */ (gcry_cipher_hd_t c,
319                  unsigned char *outbuf, size_t outbuflen,
320                  const unsigned char *inbuf, size_t inbuflen);
321 gcry_err_code_t _gcry_cipher_cfb_decrypt
322 /*           */ (gcry_cipher_hd_t c,
323                  unsigned char *outbuf, size_t outbuflen,
324                  const unsigned char *inbuf, size_t inbuflen);
325
326
327 /*-- cipher-ofb.c --*/
328 gcry_err_code_t _gcry_cipher_ofb_encrypt
329 /*           */ (gcry_cipher_hd_t c,
330                  unsigned char *outbuf, size_t outbuflen,
331                  const unsigned char *inbuf, size_t inbuflen);
332
333 /*-- cipher-ctr.c --*/
334 gcry_err_code_t _gcry_cipher_ctr_encrypt
335 /*           */ (gcry_cipher_hd_t c,
336                  unsigned char *outbuf, size_t outbuflen,
337                  const unsigned char *inbuf, size_t inbuflen);
338
339
340 /*-- cipher-aeswrap.c --*/
341 gcry_err_code_t _gcry_cipher_aeswrap_encrypt
342 /*           */   (gcry_cipher_hd_t c,
343                    byte *outbuf, size_t outbuflen,
344                    const byte *inbuf, size_t inbuflen);
345 gcry_err_code_t _gcry_cipher_aeswrap_decrypt
346 /*           */   (gcry_cipher_hd_t c,
347                    byte *outbuf, size_t outbuflen,
348                    const byte *inbuf, size_t inbuflen);
349
350
351 /*-- cipher-ccm.c --*/
352 gcry_err_code_t _gcry_cipher_ccm_encrypt
353 /*           */ (gcry_cipher_hd_t c,
354                  unsigned char *outbuf, size_t outbuflen,
355                  const unsigned char *inbuf, size_t inbuflen);
356 gcry_err_code_t _gcry_cipher_ccm_decrypt
357 /*           */ (gcry_cipher_hd_t c,
358                  unsigned char *outbuf, size_t outbuflen,
359                  const unsigned char *inbuf, size_t inbuflen);
360 gcry_err_code_t _gcry_cipher_ccm_set_nonce
361 /*           */ (gcry_cipher_hd_t c, const unsigned char *nonce,
362                  size_t noncelen);
363 gcry_err_code_t _gcry_cipher_ccm_authenticate
364 /*           */ (gcry_cipher_hd_t c, const unsigned char *abuf, size_t abuflen);
365 #ifdef HAVE_U64_TYPEDEF
366 gcry_err_code_t _gcry_cipher_ccm_set_lengths
367 /*           */ (gcry_cipher_hd_t c, u64 encryptedlen, u64 aadlen, u64 taglen);
368 #endif
369 gcry_err_code_t _gcry_cipher_ccm_get_tag
370 /*           */ (gcry_cipher_hd_t c,
371                  unsigned char *outtag, size_t taglen);
372 gcry_err_code_t _gcry_cipher_ccm_check_tag
373 /*           */ (gcry_cipher_hd_t c,
374                  const unsigned char *intag, size_t taglen);
375
376
377 /*-- cipher-gcm.c --*/
378 gcry_err_code_t _gcry_cipher_gcm_encrypt
379 /*           */   (gcry_cipher_hd_t c,
380                    unsigned char *outbuf, size_t outbuflen,
381                    const unsigned char *inbuf, size_t inbuflen);
382 gcry_err_code_t _gcry_cipher_gcm_decrypt
383 /*           */   (gcry_cipher_hd_t c,
384                    unsigned char *outbuf, size_t outbuflen,
385                    const unsigned char *inbuf, size_t inbuflen);
386 gcry_err_code_t _gcry_cipher_gcm_setiv
387 /*           */   (gcry_cipher_hd_t c,
388                    const unsigned char *iv, size_t ivlen);
389 gcry_err_code_t _gcry_cipher_gcm_authenticate
390 /*           */   (gcry_cipher_hd_t c,
391                    const unsigned char *aadbuf, size_t aadbuflen);
392 gcry_err_code_t _gcry_cipher_gcm_get_tag
393 /*           */   (gcry_cipher_hd_t c,
394                    unsigned char *outtag, size_t taglen);
395 gcry_err_code_t _gcry_cipher_gcm_check_tag
396 /*           */   (gcry_cipher_hd_t c,
397                    const unsigned char *intag, size_t taglen);
398 void _gcry_cipher_gcm_setkey
399 /*           */   (gcry_cipher_hd_t c);
400
401
402 /*-- cipher-poly1305.c --*/
403 gcry_err_code_t _gcry_cipher_poly1305_encrypt
404 /*           */   (gcry_cipher_hd_t c,
405                    unsigned char *outbuf, size_t outbuflen,
406                    const unsigned char *inbuf, size_t inbuflen);
407 gcry_err_code_t _gcry_cipher_poly1305_decrypt
408 /*           */   (gcry_cipher_hd_t c,
409                    unsigned char *outbuf, size_t outbuflen,
410                    const unsigned char *inbuf, size_t inbuflen);
411 gcry_err_code_t _gcry_cipher_poly1305_setiv
412 /*           */   (gcry_cipher_hd_t c,
413                    const unsigned char *iv, size_t ivlen);
414 gcry_err_code_t _gcry_cipher_poly1305_authenticate
415 /*           */   (gcry_cipher_hd_t c,
416                    const unsigned char *aadbuf, size_t aadbuflen);
417 gcry_err_code_t _gcry_cipher_poly1305_get_tag
418 /*           */   (gcry_cipher_hd_t c,
419                    unsigned char *outtag, size_t taglen);
420 gcry_err_code_t _gcry_cipher_poly1305_check_tag
421 /*           */   (gcry_cipher_hd_t c,
422                    const unsigned char *intag, size_t taglen);
423 void _gcry_cipher_poly1305_setkey
424 /*           */   (gcry_cipher_hd_t c);
425
426
427 /*-- cipher-ocb.c --*/
428 gcry_err_code_t _gcry_cipher_ocb_encrypt
429 /*           */ (gcry_cipher_hd_t c,
430                  unsigned char *outbuf, size_t outbuflen,
431                  const unsigned char *inbuf, size_t inbuflen);
432 gcry_err_code_t _gcry_cipher_ocb_decrypt
433 /*           */ (gcry_cipher_hd_t c,
434                  unsigned char *outbuf, size_t outbuflen,
435                  const unsigned char *inbuf, size_t inbuflen);
436 gcry_err_code_t _gcry_cipher_ocb_set_nonce
437 /*           */ (gcry_cipher_hd_t c, const unsigned char *nonce,
438                  size_t noncelen);
439 gcry_err_code_t _gcry_cipher_ocb_authenticate
440 /*           */ (gcry_cipher_hd_t c, const unsigned char *abuf, size_t abuflen);
441 gcry_err_code_t _gcry_cipher_ocb_get_tag
442 /*           */ (gcry_cipher_hd_t c,
443                  unsigned char *outtag, size_t taglen);
444 gcry_err_code_t _gcry_cipher_ocb_check_tag
445 /*           */ (gcry_cipher_hd_t c,
446                  const unsigned char *intag, size_t taglen);
447 const unsigned char *_gcry_cipher_ocb_get_l
448 /*           */ (gcry_cipher_hd_t c, unsigned char *l_tmp, u64 n);
449
450
451 /* Inline version of _gcry_cipher_ocb_get_l, with hard-coded fast paths for
452    most common cases.  */
453 static inline const unsigned char *
454 ocb_get_l (gcry_cipher_hd_t c, unsigned char *l_tmp, u64 n)
455 {
456   if (n & 1)
457     return c->u_mode.ocb.L[0];
458   else if (n & 2)
459     return c->u_mode.ocb.L[1];
460   else
461     {
462       unsigned int ntz = _gcry_ctz64 (n);
463
464       if (ntz < OCB_L_TABLE_SIZE)
465         return c->u_mode.ocb.L[ntz];
466       else
467         return _gcry_cipher_ocb_get_l (c, l_tmp, n);
468     }
469 }
470
471 #endif /*G10_CIPHER_INTERNAL_H*/