fef0ecba31c8bd9f1376739535694d5a4b909a0d
[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 /* Magic values for the context structure.  */
30 #define CTX_MAGIC_NORMAL 0x24091964
31 #define CTX_MAGIC_SECURE 0x46919042
32
33 /* Try to use 16 byte aligned cipher context for better performance.
34    We use the aligned attribute, thus it is only possible to implement
35    this with gcc.  */
36 #undef NEED_16BYTE_ALIGNED_CONTEXT
37 #ifdef HAVE_GCC_ATTRIBUTE_ALIGNED
38 # define NEED_16BYTE_ALIGNED_CONTEXT 1
39 #endif
40
41 /* Undef this symbol to trade GCM speed for 256 bytes of memory per context */
42 #define GCM_USE_TABLES 1
43
44
45 /* GCM_USE_INTEL_PCLMUL indicates whether to compile GCM with Intel PCLMUL
46    code.  */
47 #undef GCM_USE_INTEL_PCLMUL
48 #if defined(ENABLE_PCLMUL_SUPPORT) && defined(GCM_USE_TABLES)
49 # if ((defined(__i386__) && SIZEOF_UNSIGNED_LONG == 4) || defined(__x86_64__))
50 #  if __GNUC__ >= 4
51 #   define GCM_USE_INTEL_PCLMUL 1
52 #  endif
53 # endif
54 #endif /* GCM_USE_INTEL_PCLMUL */
55
56
57 typedef unsigned int (*ghash_fn_t) (gcry_cipher_hd_t c, byte *result,
58                                     const byte *buf, size_t nblocks);
59
60
61 /* A VIA processor with the Padlock engine as well as the Intel AES_NI
62    instructions require an alignment of most data on a 16 byte
63    boundary.  Because we trick out the compiler while allocating the
64    context, the align attribute as used in rijndael.c does not work on
65    its own.  Thus we need to make sure that the entire context
66    structure is a aligned on that boundary.  We achieve this by
67    defining a new type and use that instead of our usual alignment
68    type.  */
69 typedef union
70 {
71   PROPERLY_ALIGNED_TYPE foo;
72 #ifdef NEED_16BYTE_ALIGNED_CONTEXT
73   char bar[16] __attribute__ ((aligned (16)));
74 #endif
75   char c[1];
76 } cipher_context_alignment_t;
77
78
79 /* The handle structure.  */
80 struct gcry_cipher_handle
81 {
82   int magic;
83   size_t actual_handle_size;     /* Allocated size of this handle. */
84   size_t handle_offset;          /* Offset to the malloced block.  */
85   gcry_cipher_spec_t *spec;
86
87   /* The algorithm id.  This is a hack required because the module
88      interface does not easily allow to retrieve this value. */
89   int algo;
90
91   /* A structure with function pointers for bulk operations.  Due to
92      limitations of the module system (we don't want to change the
93      API) we need to keep these function pointers here.  The cipher
94      open function intializes them and the actual encryption routines
95      use them if they are not NULL.  */
96   struct {
97     void (*cfb_enc)(void *context, unsigned char *iv,
98                     void *outbuf_arg, const void *inbuf_arg,
99                     size_t nblocks);
100     void (*cfb_dec)(void *context, unsigned char *iv,
101                     void *outbuf_arg, const void *inbuf_arg,
102                     size_t nblocks);
103     void (*cbc_enc)(void *context, unsigned char *iv,
104                     void *outbuf_arg, const void *inbuf_arg,
105                     size_t nblocks, int cbc_mac);
106     void (*cbc_dec)(void *context, unsigned char *iv,
107                     void *outbuf_arg, const void *inbuf_arg,
108                     size_t nblocks);
109     void (*ctr_enc)(void *context, unsigned char *iv,
110                     void *outbuf_arg, const void *inbuf_arg,
111                     size_t nblocks);
112   } bulk;
113
114
115   int mode;
116   unsigned int flags;
117
118   struct {
119     unsigned int key:1; /* Set to 1 if a key has been set.  */
120     unsigned int iv:1;  /* Set to 1 if a IV has been set.  */
121     unsigned int tag:1; /* Set to 1 if a tag is finalized. */
122   } marks;
123
124   /* The initialization vector.  For best performance we make sure
125      that it is properly aligned.  In particular some implementations
126      of bulk operations expect an 16 byte aligned IV.  IV is also used
127      to store CBC-MAC in CCM mode; counter IV is stored in U_CTR.  */
128   union {
129     cipher_context_alignment_t iv_align;
130     unsigned char iv[MAX_BLOCKSIZE];
131   } u_iv;
132
133   /* The counter for CTR mode.  This field is also used by AESWRAP and
134      thus we can't use the U_IV union.  */
135   union {
136     cipher_context_alignment_t iv_align;
137     unsigned char ctr[MAX_BLOCKSIZE];
138   } u_ctr;
139
140   /* Space to save an IV or CTR for chaining operations.  */
141   unsigned char lastiv[MAX_BLOCKSIZE];
142   int unused;  /* Number of unused bytes in LASTIV. */
143
144   union {
145 #ifdef HAVE_U64_TYPEDEF
146     /* Mode specific storage for CCM mode. */
147     struct {
148       u64 encryptlen;
149       u64 aadlen;
150       unsigned int authlen;
151
152       /* Space to save partial input lengths for MAC. */
153       unsigned char macbuf[GCRY_CCM_BLOCK_LEN];
154       int mac_unused;  /* Number of unprocessed bytes in MACBUF. */
155
156       unsigned char s0[GCRY_CCM_BLOCK_LEN];
157
158       unsigned int nonce:1;/* Set to 1 if nonce has been set.  */
159       unsigned int lengths:1; /* Set to 1 if CCM length parameters has been
160                                  processed.  */
161     } ccm;
162 #endif
163
164     /* Mode specific storage for Poly1305 mode. */
165     struct {
166       /* byte counter for AAD and data. */
167       u32 bytecount[2];
168
169       unsigned int aad_finalized:1;
170       unsigned int bytecount_over_limits:1;
171
172       poly1305_context_t ctx;
173     } poly1305;
174
175     /* Mode specific storage for CMAC mode. */
176     struct {
177       unsigned int tag:1; /* Set to 1 if tag has been finalized.  */
178
179       /* Subkeys for tag creation, not cleared by gcry_cipher_reset. */
180       unsigned char subkeys[2][MAX_BLOCKSIZE];
181     } cmac;
182
183     /* Mode specific storage for GCM mode. */
184     struct {
185       /* The interim tag for GCM mode.  */
186       union {
187         cipher_context_alignment_t iv_align;
188         unsigned char tag[MAX_BLOCKSIZE];
189       } u_tag;
190
191       /* Space to save partial input lengths for MAC. */
192       unsigned char macbuf[GCRY_CCM_BLOCK_LEN];
193       int mac_unused;  /* Number of unprocessed bytes in MACBUF. */
194
195
196       /* byte counters for GCM */
197       u32 aadlen[2];
198       u32 datalen[2];
199
200       /* encrypted tag counter */
201       unsigned char tagiv[MAX_BLOCKSIZE];
202
203       unsigned int ghash_data_finalized:1;
204       unsigned int ghash_aad_finalized:1;
205
206       unsigned int datalen_over_limits:1;
207       unsigned int disallow_encryption_because_of_setiv_in_fips_mode:1;
208
209       /* --- Following members are not cleared in gcry_cipher_reset --- */
210
211       /* GHASH multiplier from key.  */
212       union {
213         cipher_context_alignment_t iv_align;
214         unsigned char key[MAX_BLOCKSIZE];
215       } u_ghash_key;
216
217       /* GHASH implementation in use. */
218       ghash_fn_t ghash_fn;
219
220       /* Pre-calculated table for GCM. */
221 #ifdef GCM_USE_TABLES
222  #if defined(HAVE_U64_TYPEDEF) && (SIZEOF_UNSIGNED_LONG == 8 \
223                                    || defined(__x86_64__))
224       #define GCM_TABLES_USE_U64 1
225       u64 gcm_table[2 * 16];
226  #else
227       #undef GCM_TABLES_USE_U64
228       u32 gcm_table[4 * 16];
229  #endif
230 #endif
231     } gcm;
232   } u_mode;
233
234   /* What follows are two contexts of the cipher in use.  The first
235      one needs to be aligned well enough for the cipher operation
236      whereas the second one is a copy created by cipher_setkey and
237      used by cipher_reset.  That second copy has no need for proper
238      aligment because it is only accessed by memcpy.  */
239   cipher_context_alignment_t context;
240 };
241
242
243 /*-- cipher-cbc.c --*/
244 gcry_err_code_t _gcry_cipher_cbc_encrypt
245 /*           */ (gcry_cipher_hd_t c,
246                  unsigned char *outbuf, size_t outbuflen,
247                  const unsigned char *inbuf, size_t inbuflen);
248 gcry_err_code_t _gcry_cipher_cbc_decrypt
249 /*           */ (gcry_cipher_hd_t c,
250                  unsigned char *outbuf, size_t outbuflen,
251                  const unsigned char *inbuf, size_t inbuflen);
252
253 /*-- cipher-cfb.c --*/
254 gcry_err_code_t _gcry_cipher_cfb_encrypt
255 /*           */ (gcry_cipher_hd_t c,
256                  unsigned char *outbuf, size_t outbuflen,
257                  const unsigned char *inbuf, size_t inbuflen);
258 gcry_err_code_t _gcry_cipher_cfb_decrypt
259 /*           */ (gcry_cipher_hd_t c,
260                  unsigned char *outbuf, size_t outbuflen,
261                  const unsigned char *inbuf, size_t inbuflen);
262
263
264 /*-- cipher-ofb.c --*/
265 gcry_err_code_t _gcry_cipher_ofb_encrypt
266 /*           */ (gcry_cipher_hd_t c,
267                  unsigned char *outbuf, size_t outbuflen,
268                  const unsigned char *inbuf, size_t inbuflen);
269
270 /*-- cipher-ctr.c --*/
271 gcry_err_code_t _gcry_cipher_ctr_encrypt
272 /*           */ (gcry_cipher_hd_t c,
273                  unsigned char *outbuf, size_t outbuflen,
274                  const unsigned char *inbuf, size_t inbuflen);
275
276
277 /*-- cipher-aeswrap.c --*/
278 gcry_err_code_t _gcry_cipher_aeswrap_encrypt
279 /*           */   (gcry_cipher_hd_t c,
280                    byte *outbuf, size_t outbuflen,
281                    const byte *inbuf, size_t inbuflen);
282 gcry_err_code_t _gcry_cipher_aeswrap_decrypt
283 /*           */   (gcry_cipher_hd_t c,
284                    byte *outbuf, size_t outbuflen,
285                    const byte *inbuf, size_t inbuflen);
286
287
288 /*-- cipher-ccm.c --*/
289 gcry_err_code_t _gcry_cipher_ccm_encrypt
290 /*           */ (gcry_cipher_hd_t c,
291                  unsigned char *outbuf, size_t outbuflen,
292                  const unsigned char *inbuf, size_t inbuflen);
293 gcry_err_code_t _gcry_cipher_ccm_decrypt
294 /*           */ (gcry_cipher_hd_t c,
295                  unsigned char *outbuf, size_t outbuflen,
296                  const unsigned char *inbuf, size_t inbuflen);
297 gcry_err_code_t _gcry_cipher_ccm_set_nonce
298 /*           */ (gcry_cipher_hd_t c, const unsigned char *nonce,
299                  size_t noncelen);
300 gcry_err_code_t _gcry_cipher_ccm_authenticate
301 /*           */ (gcry_cipher_hd_t c, const unsigned char *abuf, size_t abuflen);
302 #ifdef HAVE_U64_TYPEDEF
303 gcry_err_code_t _gcry_cipher_ccm_set_lengths
304 /*           */ (gcry_cipher_hd_t c, u64 encryptedlen, u64 aadlen, u64 taglen);
305 #endif
306 gcry_err_code_t _gcry_cipher_ccm_get_tag
307 /*           */ (gcry_cipher_hd_t c,
308                  unsigned char *outtag, size_t taglen);
309 gcry_err_code_t _gcry_cipher_ccm_check_tag
310 /*           */ (gcry_cipher_hd_t c,
311                  const unsigned char *intag, size_t taglen);
312
313
314 /*-- cipher-gcm.c --*/
315 gcry_err_code_t _gcry_cipher_gcm_encrypt
316 /*           */   (gcry_cipher_hd_t c,
317                    unsigned char *outbuf, size_t outbuflen,
318                    const unsigned char *inbuf, size_t inbuflen);
319 gcry_err_code_t _gcry_cipher_gcm_decrypt
320 /*           */   (gcry_cipher_hd_t c,
321                    unsigned char *outbuf, size_t outbuflen,
322                    const unsigned char *inbuf, size_t inbuflen);
323 gcry_err_code_t _gcry_cipher_gcm_setiv
324 /*           */   (gcry_cipher_hd_t c,
325                    const unsigned char *iv, size_t ivlen);
326 gcry_err_code_t _gcry_cipher_gcm_authenticate
327 /*           */   (gcry_cipher_hd_t c,
328                    const unsigned char *aadbuf, size_t aadbuflen);
329 gcry_err_code_t _gcry_cipher_gcm_get_tag
330 /*           */   (gcry_cipher_hd_t c,
331                    unsigned char *outtag, size_t taglen);
332 gcry_err_code_t _gcry_cipher_gcm_check_tag
333 /*           */   (gcry_cipher_hd_t c,
334                    const unsigned char *intag, size_t taglen);
335 void _gcry_cipher_gcm_setkey
336 /*           */   (gcry_cipher_hd_t c);
337
338
339 /*-- cipher-poly1305.c --*/
340 gcry_err_code_t _gcry_cipher_poly1305_encrypt
341 /*           */   (gcry_cipher_hd_t c,
342                    unsigned char *outbuf, size_t outbuflen,
343                    const unsigned char *inbuf, size_t inbuflen);
344 gcry_err_code_t _gcry_cipher_poly1305_decrypt
345 /*           */   (gcry_cipher_hd_t c,
346                    unsigned char *outbuf, size_t outbuflen,
347                    const unsigned char *inbuf, size_t inbuflen);
348 gcry_err_code_t _gcry_cipher_poly1305_setiv
349 /*           */   (gcry_cipher_hd_t c,
350                    const unsigned char *iv, size_t ivlen);
351 gcry_err_code_t _gcry_cipher_poly1305_authenticate
352 /*           */   (gcry_cipher_hd_t c,
353                    const unsigned char *aadbuf, size_t aadbuflen);
354 gcry_err_code_t _gcry_cipher_poly1305_get_tag
355 /*           */   (gcry_cipher_hd_t c,
356                    unsigned char *outtag, size_t taglen);
357 gcry_err_code_t _gcry_cipher_poly1305_check_tag
358 /*           */   (gcry_cipher_hd_t c,
359                    const unsigned char *intag, size_t taglen);
360 void _gcry_cipher_poly1305_setkey
361 /*           */   (gcry_cipher_hd_t c);
362
363 #endif /*G10_CIPHER_INTERNAL_H*/