e20ea562f5b1a7b473a247e8400f471f078a9d63
[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     void (*ocb_crypt)(gcry_cipher_hd_t c, void *outbuf_arg,
132                       const void *inbuf_arg, size_t nblocks, int encrypt);
133     void (*ocb_auth)(gcry_cipher_hd_t c, const void *abuf_arg, size_t nblocks);
134   } bulk;
135
136
137   int mode;
138   unsigned int flags;
139
140   struct {
141     unsigned int key:1; /* Set to 1 if a key has been set.  */
142     unsigned int iv:1;  /* Set to 1 if a IV has been set.  */
143     unsigned int tag:1; /* Set to 1 if a tag is finalized. */
144     unsigned int finalize:1; /* Next encrypt/decrypt has the final data.  */
145   } marks;
146
147   /* The initialization vector.  For best performance we make sure
148      that it is properly aligned.  In particular some implementations
149      of bulk operations expect an 16 byte aligned IV.  IV is also used
150      to store CBC-MAC in CCM mode; counter IV is stored in U_CTR.  For
151      OCB mode it is used for the offset value.  */
152   union {
153     cipher_context_alignment_t iv_align;
154     unsigned char iv[MAX_BLOCKSIZE];
155   } u_iv;
156
157   /* The counter for CTR mode.  This field is also used by AESWRAP and
158      thus we can't use the U_IV union.  For OCB mode it is used for
159      the checksum.  */
160   union {
161     cipher_context_alignment_t iv_align;
162     unsigned char ctr[MAX_BLOCKSIZE];
163   } u_ctr;
164
165   /* Space to save an IV or CTR for chaining operations.  */
166   unsigned char lastiv[MAX_BLOCKSIZE];
167   int unused;  /* Number of unused bytes in LASTIV. */
168
169   union {
170 #ifdef HAVE_U64_TYPEDEF
171     /* Mode specific storage for CCM mode. */
172     struct {
173       u64 encryptlen;
174       u64 aadlen;
175       unsigned int authlen;
176
177       /* Space to save partial input lengths for MAC. */
178       unsigned char macbuf[GCRY_CCM_BLOCK_LEN];
179       int mac_unused;  /* Number of unprocessed bytes in MACBUF. */
180
181       unsigned char s0[GCRY_CCM_BLOCK_LEN];
182
183       unsigned int nonce:1;/* Set to 1 if nonce has been set.  */
184       unsigned int lengths:1; /* Set to 1 if CCM length parameters has been
185                                  processed.  */
186     } ccm;
187 #endif
188
189     /* Mode specific storage for Poly1305 mode. */
190     struct {
191       /* byte counter for AAD. */
192       u32 aadcount[2];
193
194       /* byte counter for data. */
195       u32 datacount[2];
196
197       unsigned int aad_finalized:1;
198       unsigned int bytecount_over_limits:1;
199
200       poly1305_context_t ctx;
201     } poly1305;
202
203     /* Mode specific storage for CMAC mode. */
204     struct {
205       unsigned int tag:1; /* Set to 1 if tag has been finalized.  */
206
207       /* Subkeys for tag creation, not cleared by gcry_cipher_reset. */
208       unsigned char subkeys[2][MAX_BLOCKSIZE];
209     } cmac;
210
211     /* Mode specific storage for GCM mode. */
212     struct {
213       /* The interim tag for GCM mode.  */
214       union {
215         cipher_context_alignment_t iv_align;
216         unsigned char tag[MAX_BLOCKSIZE];
217       } u_tag;
218
219       /* Space to save partial input lengths for MAC. */
220       unsigned char macbuf[GCRY_CCM_BLOCK_LEN];
221       int mac_unused;  /* Number of unprocessed bytes in MACBUF. */
222
223
224       /* byte counters for GCM */
225       u32 aadlen[2];
226       u32 datalen[2];
227
228       /* encrypted tag counter */
229       unsigned char tagiv[MAX_BLOCKSIZE];
230
231       unsigned int ghash_data_finalized:1;
232       unsigned int ghash_aad_finalized:1;
233
234       unsigned int datalen_over_limits:1;
235       unsigned int disallow_encryption_because_of_setiv_in_fips_mode:1;
236
237       /* --- Following members are not cleared in gcry_cipher_reset --- */
238
239       /* GHASH multiplier from key.  */
240       union {
241         cipher_context_alignment_t iv_align;
242         unsigned char key[MAX_BLOCKSIZE];
243       } u_ghash_key;
244
245       /* GHASH implementation in use. */
246       ghash_fn_t ghash_fn;
247
248       /* Pre-calculated table for GCM. */
249 #ifdef GCM_USE_TABLES
250  #if defined(HAVE_U64_TYPEDEF) && (SIZEOF_UNSIGNED_LONG == 8 \
251                                    || defined(__x86_64__))
252       #define GCM_TABLES_USE_U64 1
253       u64 gcm_table[2 * 16];
254  #else
255       #undef GCM_TABLES_USE_U64
256       u32 gcm_table[4 * 16];
257  #endif
258 #endif
259     } gcm;
260
261     /* Mode specific storage for OCB mode. */
262     struct {
263       /* Helper variables and pre-computed table of L values.  */
264       unsigned char L_star[OCB_BLOCK_LEN];
265       unsigned char L_dollar[OCB_BLOCK_LEN];
266       unsigned char L[OCB_BLOCK_LEN][OCB_L_TABLE_SIZE];
267
268       /* The tag is valid if marks.tag has been set.  */
269       unsigned char tag[OCB_BLOCK_LEN];
270
271       /* A buffer to hold the offset for the AAD processing.  */
272       unsigned char aad_offset[OCB_BLOCK_LEN];
273
274       /* A buffer to hold the current sum of AAD processing.  We can't
275          use tag here because tag may already hold the preprocessed
276          checksum of the data.  */
277       unsigned char aad_sum[OCB_BLOCK_LEN];
278
279       /* Number of data/aad blocks processed so far.  */
280       u64 data_nblocks;
281       u64 aad_nblocks;
282
283       /* Length of the tag.  Fixed for now but may eventually be
284          specified using a set of gcry_cipher_flags.  */
285       unsigned char taglen;
286
287       /* Flags indicating that the final data/aad block has been
288          processed.  */
289       unsigned int data_finalized:1;
290       unsigned int aad_finalized:1;
291
292     } ocb;
293
294   } u_mode;
295
296   /* What follows are two contexts of the cipher in use.  The first
297      one needs to be aligned well enough for the cipher operation
298      whereas the second one is a copy created by cipher_setkey and
299      used by cipher_reset.  That second copy has no need for proper
300      aligment because it is only accessed by memcpy.  */
301   cipher_context_alignment_t context;
302 };
303
304
305 /*-- cipher-cbc.c --*/
306 gcry_err_code_t _gcry_cipher_cbc_encrypt
307 /*           */ (gcry_cipher_hd_t c,
308                  unsigned char *outbuf, size_t outbuflen,
309                  const unsigned char *inbuf, size_t inbuflen);
310 gcry_err_code_t _gcry_cipher_cbc_decrypt
311 /*           */ (gcry_cipher_hd_t c,
312                  unsigned char *outbuf, size_t outbuflen,
313                  const unsigned char *inbuf, size_t inbuflen);
314
315 /*-- cipher-cfb.c --*/
316 gcry_err_code_t _gcry_cipher_cfb_encrypt
317 /*           */ (gcry_cipher_hd_t c,
318                  unsigned char *outbuf, size_t outbuflen,
319                  const unsigned char *inbuf, size_t inbuflen);
320 gcry_err_code_t _gcry_cipher_cfb_decrypt
321 /*           */ (gcry_cipher_hd_t c,
322                  unsigned char *outbuf, size_t outbuflen,
323                  const unsigned char *inbuf, size_t inbuflen);
324
325
326 /*-- cipher-ofb.c --*/
327 gcry_err_code_t _gcry_cipher_ofb_encrypt
328 /*           */ (gcry_cipher_hd_t c,
329                  unsigned char *outbuf, size_t outbuflen,
330                  const unsigned char *inbuf, size_t inbuflen);
331
332 /*-- cipher-ctr.c --*/
333 gcry_err_code_t _gcry_cipher_ctr_encrypt
334 /*           */ (gcry_cipher_hd_t c,
335                  unsigned char *outbuf, size_t outbuflen,
336                  const unsigned char *inbuf, size_t inbuflen);
337
338
339 /*-- cipher-aeswrap.c --*/
340 gcry_err_code_t _gcry_cipher_aeswrap_encrypt
341 /*           */   (gcry_cipher_hd_t c,
342                    byte *outbuf, size_t outbuflen,
343                    const byte *inbuf, size_t inbuflen);
344 gcry_err_code_t _gcry_cipher_aeswrap_decrypt
345 /*           */   (gcry_cipher_hd_t c,
346                    byte *outbuf, size_t outbuflen,
347                    const byte *inbuf, size_t inbuflen);
348
349
350 /*-- cipher-ccm.c --*/
351 gcry_err_code_t _gcry_cipher_ccm_encrypt
352 /*           */ (gcry_cipher_hd_t c,
353                  unsigned char *outbuf, size_t outbuflen,
354                  const unsigned char *inbuf, size_t inbuflen);
355 gcry_err_code_t _gcry_cipher_ccm_decrypt
356 /*           */ (gcry_cipher_hd_t c,
357                  unsigned char *outbuf, size_t outbuflen,
358                  const unsigned char *inbuf, size_t inbuflen);
359 gcry_err_code_t _gcry_cipher_ccm_set_nonce
360 /*           */ (gcry_cipher_hd_t c, const unsigned char *nonce,
361                  size_t noncelen);
362 gcry_err_code_t _gcry_cipher_ccm_authenticate
363 /*           */ (gcry_cipher_hd_t c, const unsigned char *abuf, size_t abuflen);
364 #ifdef HAVE_U64_TYPEDEF
365 gcry_err_code_t _gcry_cipher_ccm_set_lengths
366 /*           */ (gcry_cipher_hd_t c, u64 encryptedlen, u64 aadlen, u64 taglen);
367 #endif
368 gcry_err_code_t _gcry_cipher_ccm_get_tag
369 /*           */ (gcry_cipher_hd_t c,
370                  unsigned char *outtag, size_t taglen);
371 gcry_err_code_t _gcry_cipher_ccm_check_tag
372 /*           */ (gcry_cipher_hd_t c,
373                  const unsigned char *intag, size_t taglen);
374
375
376 /*-- cipher-gcm.c --*/
377 gcry_err_code_t _gcry_cipher_gcm_encrypt
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_gcm_decrypt
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_gcm_setiv
386 /*           */   (gcry_cipher_hd_t c,
387                    const unsigned char *iv, size_t ivlen);
388 gcry_err_code_t _gcry_cipher_gcm_authenticate
389 /*           */   (gcry_cipher_hd_t c,
390                    const unsigned char *aadbuf, size_t aadbuflen);
391 gcry_err_code_t _gcry_cipher_gcm_get_tag
392 /*           */   (gcry_cipher_hd_t c,
393                    unsigned char *outtag, size_t taglen);
394 gcry_err_code_t _gcry_cipher_gcm_check_tag
395 /*           */   (gcry_cipher_hd_t c,
396                    const unsigned char *intag, size_t taglen);
397 void _gcry_cipher_gcm_setkey
398 /*           */   (gcry_cipher_hd_t c);
399
400
401 /*-- cipher-poly1305.c --*/
402 gcry_err_code_t _gcry_cipher_poly1305_encrypt
403 /*           */   (gcry_cipher_hd_t c,
404                    unsigned char *outbuf, size_t outbuflen,
405                    const unsigned char *inbuf, size_t inbuflen);
406 gcry_err_code_t _gcry_cipher_poly1305_decrypt
407 /*           */   (gcry_cipher_hd_t c,
408                    unsigned char *outbuf, size_t outbuflen,
409                    const unsigned char *inbuf, size_t inbuflen);
410 gcry_err_code_t _gcry_cipher_poly1305_setiv
411 /*           */   (gcry_cipher_hd_t c,
412                    const unsigned char *iv, size_t ivlen);
413 gcry_err_code_t _gcry_cipher_poly1305_authenticate
414 /*           */   (gcry_cipher_hd_t c,
415                    const unsigned char *aadbuf, size_t aadbuflen);
416 gcry_err_code_t _gcry_cipher_poly1305_get_tag
417 /*           */   (gcry_cipher_hd_t c,
418                    unsigned char *outtag, size_t taglen);
419 gcry_err_code_t _gcry_cipher_poly1305_check_tag
420 /*           */   (gcry_cipher_hd_t c,
421                    const unsigned char *intag, size_t taglen);
422 void _gcry_cipher_poly1305_setkey
423 /*           */   (gcry_cipher_hd_t c);
424
425
426 /*-- cipher-ocb.c --*/
427 gcry_err_code_t _gcry_cipher_ocb_encrypt
428 /*           */ (gcry_cipher_hd_t c,
429                  unsigned char *outbuf, size_t outbuflen,
430                  const unsigned char *inbuf, size_t inbuflen);
431 gcry_err_code_t _gcry_cipher_ocb_decrypt
432 /*           */ (gcry_cipher_hd_t c,
433                  unsigned char *outbuf, size_t outbuflen,
434                  const unsigned char *inbuf, size_t inbuflen);
435 gcry_err_code_t _gcry_cipher_ocb_set_nonce
436 /*           */ (gcry_cipher_hd_t c, const unsigned char *nonce,
437                  size_t noncelen);
438 gcry_err_code_t _gcry_cipher_ocb_authenticate
439 /*           */ (gcry_cipher_hd_t c, const unsigned char *abuf, size_t abuflen);
440 gcry_err_code_t _gcry_cipher_ocb_get_tag
441 /*           */ (gcry_cipher_hd_t c,
442                  unsigned char *outtag, size_t taglen);
443 gcry_err_code_t _gcry_cipher_ocb_check_tag
444 /*           */ (gcry_cipher_hd_t c,
445                  const unsigned char *intag, size_t taglen);
446 const unsigned char *_gcry_cipher_ocb_get_l
447 /*           */ (gcry_cipher_hd_t c, unsigned char *l_tmp, u64 n);
448
449
450 #endif /*G10_CIPHER_INTERNAL_H*/