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