Poly1305-AEAD: updated implementation to match draft-irtf-cfrg-chacha20-poly1305-03
[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. */
167       u32 aadcount[2];
168
169       /* byte counter for data. */
170       u32 datacount[2];
171
172       unsigned int aad_finalized:1;
173       unsigned int bytecount_over_limits:1;
174
175       poly1305_context_t ctx;
176     } poly1305;
177
178     /* Mode specific storage for CMAC mode. */
179     struct {
180       unsigned int tag:1; /* Set to 1 if tag has been finalized.  */
181
182       /* Subkeys for tag creation, not cleared by gcry_cipher_reset. */
183       unsigned char subkeys[2][MAX_BLOCKSIZE];
184     } cmac;
185
186     /* Mode specific storage for GCM mode. */
187     struct {
188       /* The interim tag for GCM mode.  */
189       union {
190         cipher_context_alignment_t iv_align;
191         unsigned char tag[MAX_BLOCKSIZE];
192       } u_tag;
193
194       /* Space to save partial input lengths for MAC. */
195       unsigned char macbuf[GCRY_CCM_BLOCK_LEN];
196       int mac_unused;  /* Number of unprocessed bytes in MACBUF. */
197
198
199       /* byte counters for GCM */
200       u32 aadlen[2];
201       u32 datalen[2];
202
203       /* encrypted tag counter */
204       unsigned char tagiv[MAX_BLOCKSIZE];
205
206       unsigned int ghash_data_finalized:1;
207       unsigned int ghash_aad_finalized:1;
208
209       unsigned int datalen_over_limits:1;
210       unsigned int disallow_encryption_because_of_setiv_in_fips_mode:1;
211
212       /* --- Following members are not cleared in gcry_cipher_reset --- */
213
214       /* GHASH multiplier from key.  */
215       union {
216         cipher_context_alignment_t iv_align;
217         unsigned char key[MAX_BLOCKSIZE];
218       } u_ghash_key;
219
220       /* GHASH implementation in use. */
221       ghash_fn_t ghash_fn;
222
223       /* Pre-calculated table for GCM. */
224 #ifdef GCM_USE_TABLES
225  #if defined(HAVE_U64_TYPEDEF) && (SIZEOF_UNSIGNED_LONG == 8 \
226                                    || defined(__x86_64__))
227       #define GCM_TABLES_USE_U64 1
228       u64 gcm_table[2 * 16];
229  #else
230       #undef GCM_TABLES_USE_U64
231       u32 gcm_table[4 * 16];
232  #endif
233 #endif
234     } gcm;
235   } u_mode;
236
237   /* What follows are two contexts of the cipher in use.  The first
238      one needs to be aligned well enough for the cipher operation
239      whereas the second one is a copy created by cipher_setkey and
240      used by cipher_reset.  That second copy has no need for proper
241      aligment because it is only accessed by memcpy.  */
242   cipher_context_alignment_t context;
243 };
244
245
246 /*-- cipher-cbc.c --*/
247 gcry_err_code_t _gcry_cipher_cbc_encrypt
248 /*           */ (gcry_cipher_hd_t c,
249                  unsigned char *outbuf, size_t outbuflen,
250                  const unsigned char *inbuf, size_t inbuflen);
251 gcry_err_code_t _gcry_cipher_cbc_decrypt
252 /*           */ (gcry_cipher_hd_t c,
253                  unsigned char *outbuf, size_t outbuflen,
254                  const unsigned char *inbuf, size_t inbuflen);
255
256 /*-- cipher-cfb.c --*/
257 gcry_err_code_t _gcry_cipher_cfb_encrypt
258 /*           */ (gcry_cipher_hd_t c,
259                  unsigned char *outbuf, size_t outbuflen,
260                  const unsigned char *inbuf, size_t inbuflen);
261 gcry_err_code_t _gcry_cipher_cfb_decrypt
262 /*           */ (gcry_cipher_hd_t c,
263                  unsigned char *outbuf, size_t outbuflen,
264                  const unsigned char *inbuf, size_t inbuflen);
265
266
267 /*-- cipher-ofb.c --*/
268 gcry_err_code_t _gcry_cipher_ofb_encrypt
269 /*           */ (gcry_cipher_hd_t c,
270                  unsigned char *outbuf, size_t outbuflen,
271                  const unsigned char *inbuf, size_t inbuflen);
272
273 /*-- cipher-ctr.c --*/
274 gcry_err_code_t _gcry_cipher_ctr_encrypt
275 /*           */ (gcry_cipher_hd_t c,
276                  unsigned char *outbuf, size_t outbuflen,
277                  const unsigned char *inbuf, size_t inbuflen);
278
279
280 /*-- cipher-aeswrap.c --*/
281 gcry_err_code_t _gcry_cipher_aeswrap_encrypt
282 /*           */   (gcry_cipher_hd_t c,
283                    byte *outbuf, size_t outbuflen,
284                    const byte *inbuf, size_t inbuflen);
285 gcry_err_code_t _gcry_cipher_aeswrap_decrypt
286 /*           */   (gcry_cipher_hd_t c,
287                    byte *outbuf, size_t outbuflen,
288                    const byte *inbuf, size_t inbuflen);
289
290
291 /*-- cipher-ccm.c --*/
292 gcry_err_code_t _gcry_cipher_ccm_encrypt
293 /*           */ (gcry_cipher_hd_t c,
294                  unsigned char *outbuf, size_t outbuflen,
295                  const unsigned char *inbuf, size_t inbuflen);
296 gcry_err_code_t _gcry_cipher_ccm_decrypt
297 /*           */ (gcry_cipher_hd_t c,
298                  unsigned char *outbuf, size_t outbuflen,
299                  const unsigned char *inbuf, size_t inbuflen);
300 gcry_err_code_t _gcry_cipher_ccm_set_nonce
301 /*           */ (gcry_cipher_hd_t c, const unsigned char *nonce,
302                  size_t noncelen);
303 gcry_err_code_t _gcry_cipher_ccm_authenticate
304 /*           */ (gcry_cipher_hd_t c, const unsigned char *abuf, size_t abuflen);
305 #ifdef HAVE_U64_TYPEDEF
306 gcry_err_code_t _gcry_cipher_ccm_set_lengths
307 /*           */ (gcry_cipher_hd_t c, u64 encryptedlen, u64 aadlen, u64 taglen);
308 #endif
309 gcry_err_code_t _gcry_cipher_ccm_get_tag
310 /*           */ (gcry_cipher_hd_t c,
311                  unsigned char *outtag, size_t taglen);
312 gcry_err_code_t _gcry_cipher_ccm_check_tag
313 /*           */ (gcry_cipher_hd_t c,
314                  const unsigned char *intag, size_t taglen);
315
316
317 /*-- cipher-gcm.c --*/
318 gcry_err_code_t _gcry_cipher_gcm_encrypt
319 /*           */   (gcry_cipher_hd_t c,
320                    unsigned char *outbuf, size_t outbuflen,
321                    const unsigned char *inbuf, size_t inbuflen);
322 gcry_err_code_t _gcry_cipher_gcm_decrypt
323 /*           */   (gcry_cipher_hd_t c,
324                    unsigned char *outbuf, size_t outbuflen,
325                    const unsigned char *inbuf, size_t inbuflen);
326 gcry_err_code_t _gcry_cipher_gcm_setiv
327 /*           */   (gcry_cipher_hd_t c,
328                    const unsigned char *iv, size_t ivlen);
329 gcry_err_code_t _gcry_cipher_gcm_authenticate
330 /*           */   (gcry_cipher_hd_t c,
331                    const unsigned char *aadbuf, size_t aadbuflen);
332 gcry_err_code_t _gcry_cipher_gcm_get_tag
333 /*           */   (gcry_cipher_hd_t c,
334                    unsigned char *outtag, size_t taglen);
335 gcry_err_code_t _gcry_cipher_gcm_check_tag
336 /*           */   (gcry_cipher_hd_t c,
337                    const unsigned char *intag, size_t taglen);
338 void _gcry_cipher_gcm_setkey
339 /*           */   (gcry_cipher_hd_t c);
340
341
342 /*-- cipher-poly1305.c --*/
343 gcry_err_code_t _gcry_cipher_poly1305_encrypt
344 /*           */   (gcry_cipher_hd_t c,
345                    unsigned char *outbuf, size_t outbuflen,
346                    const unsigned char *inbuf, size_t inbuflen);
347 gcry_err_code_t _gcry_cipher_poly1305_decrypt
348 /*           */   (gcry_cipher_hd_t c,
349                    unsigned char *outbuf, size_t outbuflen,
350                    const unsigned char *inbuf, size_t inbuflen);
351 gcry_err_code_t _gcry_cipher_poly1305_setiv
352 /*           */   (gcry_cipher_hd_t c,
353                    const unsigned char *iv, size_t ivlen);
354 gcry_err_code_t _gcry_cipher_poly1305_authenticate
355 /*           */   (gcry_cipher_hd_t c,
356                    const unsigned char *aadbuf, size_t aadbuflen);
357 gcry_err_code_t _gcry_cipher_poly1305_get_tag
358 /*           */   (gcry_cipher_hd_t c,
359                    unsigned char *outtag, size_t taglen);
360 gcry_err_code_t _gcry_cipher_poly1305_check_tag
361 /*           */   (gcry_cipher_hd_t c,
362                    const unsigned char *intag, size_t taglen);
363 void _gcry_cipher_poly1305_setkey
364 /*           */   (gcry_cipher_hd_t c);
365
366 #endif /*G10_CIPHER_INTERNAL_H*/