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