eng_aesni.c: win32 fix.
[openssl.git] / crypto / engine / eng_aesni.c
1 /*
2  * Support for Intel AES-NI intruction set
3  *   Author: Huang Ying <ying.huang@intel.com>
4  *
5  * Intel AES-NI is a new set of Single Instruction Multiple Data
6  * (SIMD) instructions that are going to be introduced in the next
7  * generation of Intel processor, as of 2009. These instructions
8  * enable fast and secure data encryption and decryption, using the
9  * Advanced Encryption Standard (AES), defined by FIPS Publication
10  * number 197.  The architecture introduces six instructions that
11  * offer full hardware support for AES. Four of them support high
12  * performance data encryption and decryption, and the other two
13  * instructions support the AES key expansion procedure.
14  *
15  * The white paper can be downloaded from:
16  *   http://softwarecommunity.intel.com/isn/downloads/intelavx/AES-Instructions-Set_WP.pdf
17  *
18  * This file is based on engines/e_padlock.c
19  */
20
21 /* ====================================================================
22  * Copyright (c) 1999-2001 The OpenSSL Project.  All rights reserved.
23  *
24  * Redistribution and use in source and binary forms, with or without
25  * modification, are permitted provided that the following conditions
26  * are met:
27  *
28  * 1. Redistributions of source code must retain the above copyright
29  *    notice, this list of conditions and the following disclaimer.
30  *
31  * 2. Redistributions in binary form must reproduce the above copyright
32  *    notice, this list of conditions and the following disclaimer in
33  *    the documentation and/or other materials provided with the
34  *    distribution.
35  *
36  * 3. All advertising materials mentioning features or use of this
37  *    software must display the following acknowledgment:
38  *    "This product includes software developed by the OpenSSL Project
39  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
40  *
41  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
42  *    endorse or promote products derived from this software without
43  *    prior written permission. For written permission, please contact
44  *    licensing@OpenSSL.org.
45  *
46  * 5. Products derived from this software may not be called "OpenSSL"
47  *    nor may "OpenSSL" appear in their names without prior written
48  *    permission of the OpenSSL Project.
49  *
50  * 6. Redistributions of any form whatsoever must retain the following
51  *    acknowledgment:
52  *    "This product includes software developed by the OpenSSL Project
53  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
54  *
55  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
56  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
57  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
58  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
59  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
60  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
61  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
62  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
63  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
64  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
65  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
66  * OF THE POSSIBILITY OF SUCH DAMAGE.
67  * ====================================================================
68  *
69  * This product includes cryptographic software written by Eric Young
70  * (eay@cryptsoft.com).  This product includes software written by Tim
71  * Hudson (tjh@cryptsoft.com).
72  *
73  */
74
75
76 #include <openssl/opensslconf.h>
77
78 #if !defined(OPENSSL_NO_HW) && !defined(OPENSSL_NO_HW_AES_NI) && !defined(OPENSSL_NO_AES)
79
80 #include <stdio.h>
81 #include "cryptlib.h"
82 #include <openssl/dso.h>
83 #include <openssl/engine.h>
84 #include <openssl/evp.h>
85 #include <openssl/aes.h>
86 #include <openssl/err.h>
87 #include <openssl/modes.h>
88
89 /* AES-NI is available *ONLY* on some x86 CPUs.  Not only that it
90    doesn't exist elsewhere, but it even can't be compiled on other
91    platforms! */
92 #undef COMPILE_HW_AESNI
93 #if (defined(__x86_64) || defined(__x86_64__) || \
94      defined(_M_AMD64) || defined(_M_X64) || \
95      defined(OPENSSL_IA32_SSE2)) && !defined(OPENSSL_NO_ASM)
96 #define COMPILE_HW_AESNI
97 static ENGINE *ENGINE_aesni (void);
98 #endif
99
100 void ENGINE_load_aesni (void)
101 {
102 /* On non-x86 CPUs it just returns. */
103 #ifdef COMPILE_HW_AESNI
104         ENGINE *toadd = ENGINE_aesni();
105         if (!toadd)
106                 return;
107         ENGINE_add (toadd);
108         ENGINE_free (toadd);
109         ERR_clear_error ();
110 #endif
111 }
112
113 #ifdef COMPILE_HW_AESNI
114 int aesni_set_encrypt_key(const unsigned char *userKey, int bits,
115                               AES_KEY *key);
116 int aesni_set_decrypt_key(const unsigned char *userKey, int bits,
117                               AES_KEY *key);
118
119 void aesni_encrypt(const unsigned char *in, unsigned char *out,
120                        const AES_KEY *key);
121 void aesni_decrypt(const unsigned char *in, unsigned char *out,
122                        const AES_KEY *key);
123
124 void aesni_ecb_encrypt(const unsigned char *in,
125                            unsigned char *out,
126                            size_t length,
127                            const AES_KEY *key,
128                            int enc);
129 void aesni_cbc_encrypt(const unsigned char *in,
130                            unsigned char *out,
131                            size_t length,
132                            const AES_KEY *key,
133                            unsigned char *ivec, int enc);
134
135 /* Function for ENGINE detection and control */
136 static int aesni_init(ENGINE *e);
137
138 /* Cipher Stuff */
139 static int aesni_ciphers(ENGINE *e, const EVP_CIPHER **cipher,
140                                 const int **nids, int nid);
141
142 #define AESNI_MIN_ALIGN 16
143 #define AESNI_ALIGN(x) \
144         ((void *)(((unsigned long)(x)+AESNI_MIN_ALIGN-1)&~(AESNI_MIN_ALIGN-1)))
145
146 /* Engine names */
147 static const char   aesni_id[] = "aesni",
148                     aesni_name[] = "Intel AES-NI engine",
149                     no_aesni_name[] = "Intel AES-NI engine (no-aesni)";
150
151 /* ===== Engine "management" functions ===== */
152
153 /* Prepare the ENGINE structure for registration */
154 static int
155 aesni_bind_helper(ENGINE *e)
156 {
157         int engage = (OPENSSL_ia32cap_P[1] & (1 << (57-32))) != 0;
158
159         /* Register everything or return with an error */
160         if (!ENGINE_set_id(e, aesni_id) ||
161             !ENGINE_set_name(e, engage ? aesni_name : no_aesni_name) ||
162
163             !ENGINE_set_init_function(e, aesni_init) ||
164             (engage && !ENGINE_set_ciphers (e, aesni_ciphers))
165             )
166                 return 0;
167
168         /* Everything looks good */
169         return 1;
170 }
171
172 /* Constructor */
173 static ENGINE *
174 ENGINE_aesni(void)
175 {
176         ENGINE *eng = ENGINE_new();
177
178         if (!eng) {
179                 return NULL;
180         }
181
182         if (!aesni_bind_helper(eng)) {
183                 ENGINE_free(eng);
184                 return NULL;
185         }
186
187         return eng;
188 }
189
190 /* Check availability of the engine */
191 static int
192 aesni_init(ENGINE *e)
193 {
194         return 1;
195 }
196
197 #if defined(NID_aes_128_cfb128) && ! defined (NID_aes_128_cfb)
198 #define NID_aes_128_cfb NID_aes_128_cfb128
199 #endif
200
201 #if defined(NID_aes_128_ofb128) && ! defined (NID_aes_128_ofb)
202 #define NID_aes_128_ofb NID_aes_128_ofb128
203 #endif
204
205 #if defined(NID_aes_192_cfb128) && ! defined (NID_aes_192_cfb)
206 #define NID_aes_192_cfb NID_aes_192_cfb128
207 #endif
208
209 #if defined(NID_aes_192_ofb128) && ! defined (NID_aes_192_ofb)
210 #define NID_aes_192_ofb NID_aes_192_ofb128
211 #endif
212
213 #if defined(NID_aes_256_cfb128) && ! defined (NID_aes_256_cfb)
214 #define NID_aes_256_cfb NID_aes_256_cfb128
215 #endif
216
217 #if defined(NID_aes_256_ofb128) && ! defined (NID_aes_256_ofb)
218 #define NID_aes_256_ofb NID_aes_256_ofb128
219 #endif
220
221 /* List of supported ciphers. */
222 static int aesni_cipher_nids[] = {
223         NID_aes_128_ecb,
224         NID_aes_128_cbc,
225         NID_aes_128_cfb,
226         NID_aes_128_ofb,
227
228         NID_aes_192_ecb,
229         NID_aes_192_cbc,
230         NID_aes_192_cfb,
231         NID_aes_192_ofb,
232
233         NID_aes_256_ecb,
234         NID_aes_256_cbc,
235         NID_aes_256_cfb,
236         NID_aes_256_ofb,
237 };
238 static int aesni_cipher_nids_num =
239         (sizeof(aesni_cipher_nids)/sizeof(aesni_cipher_nids[0]));
240
241 typedef struct
242 {
243         AES_KEY ks;
244         unsigned int _pad1[3];
245 } AESNI_KEY;
246
247 static int
248 aesni_init_key (EVP_CIPHER_CTX *ctx, const unsigned char *user_key,
249                     const unsigned char *iv, int enc)
250 {
251         int ret;
252         AES_KEY *key = AESNI_ALIGN(ctx->cipher_data);
253
254         if ((ctx->cipher->flags & EVP_CIPH_MODE) == EVP_CIPH_CFB_MODE
255             || (ctx->cipher->flags & EVP_CIPH_MODE) == EVP_CIPH_OFB_MODE
256             || enc)
257                 ret=aesni_set_encrypt_key(user_key, ctx->key_len * 8, key);
258         else
259                 ret=aesni_set_decrypt_key(user_key, ctx->key_len * 8, key);
260
261         if(ret < 0) {
262                 EVPerr(EVP_F_AES_INIT_KEY,EVP_R_AES_KEY_SETUP_FAILED);
263                 return 0;
264         }
265
266         return 1;
267 }
268
269 static int aesni_cipher_ecb(EVP_CIPHER_CTX *ctx, unsigned char *out,
270                  const unsigned char *in, size_t inl)
271 {       AES_KEY *key = AESNI_ALIGN(ctx->cipher_data);
272         aesni_ecb_encrypt(in, out, inl, key, ctx->encrypt);
273         return 1;
274 }
275 static int aesni_cipher_cbc(EVP_CIPHER_CTX *ctx, unsigned char *out,
276                  const unsigned char *in, size_t inl)
277 {       AES_KEY *key = AESNI_ALIGN(ctx->cipher_data);
278         aesni_cbc_encrypt(in, out, inl, key,
279                               ctx->iv, ctx->encrypt);
280         return 1;
281 }
282 static int aesni_cipher_cfb(EVP_CIPHER_CTX *ctx, unsigned char *out,
283                  const unsigned char *in, size_t inl)
284 {       AES_KEY *key = AESNI_ALIGN(ctx->cipher_data);
285         CRYPTO_cfb128_encrypt(in, out, inl, key, ctx->iv,
286                                 &ctx->num, ctx->encrypt,
287                                 (block128_f)aesni_encrypt);
288         return 1;
289 }
290 static int aesni_cipher_ofb(EVP_CIPHER_CTX *ctx, unsigned char *out,
291                  const unsigned char *in, size_t inl)
292 {       AES_KEY *key = AESNI_ALIGN(ctx->cipher_data);
293         CRYPTO_ofb128_encrypt(in, out, inl, key, ctx->iv,
294                                 &ctx->num, (block128_f)aesni_encrypt);
295         return 1;
296 }
297
298 #define AES_BLOCK_SIZE          16
299
300 #define EVP_CIPHER_block_size_ECB       AES_BLOCK_SIZE
301 #define EVP_CIPHER_block_size_CBC       AES_BLOCK_SIZE
302 #define EVP_CIPHER_block_size_OFB       1
303 #define EVP_CIPHER_block_size_CFB       1
304
305 /* Declaring so many ciphers by hand would be a pain.
306    Instead introduce a bit of preprocessor magic :-) */
307 #define DECLARE_AES_EVP(ksize,lmode,umode)      \
308 static const EVP_CIPHER aesni_##ksize##_##lmode = {     \
309         NID_aes_##ksize##_##lmode,                      \
310         EVP_CIPHER_block_size_##umode,                  \
311         ksize / 8,                                      \
312         AES_BLOCK_SIZE,                                 \
313         0 | EVP_CIPH_##umode##_MODE,                    \
314         aesni_init_key,                         \
315         aesni_cipher_##lmode,                           \
316         NULL,                                           \
317         sizeof(AESNI_KEY),                              \
318         EVP_CIPHER_set_asn1_iv,                         \
319         EVP_CIPHER_get_asn1_iv,                         \
320         NULL,                                           \
321         NULL                                            \
322 }
323
324 DECLARE_AES_EVP(128,ecb,ECB);
325 DECLARE_AES_EVP(128,cbc,CBC);
326 DECLARE_AES_EVP(128,cfb,CFB);
327 DECLARE_AES_EVP(128,ofb,OFB);
328
329 DECLARE_AES_EVP(192,ecb,ECB);
330 DECLARE_AES_EVP(192,cbc,CBC);
331 DECLARE_AES_EVP(192,cfb,CFB);
332 DECLARE_AES_EVP(192,ofb,OFB);
333
334 DECLARE_AES_EVP(256,ecb,ECB);
335 DECLARE_AES_EVP(256,cbc,CBC);
336 DECLARE_AES_EVP(256,cfb,CFB);
337 DECLARE_AES_EVP(256,ofb,OFB);
338
339 static int
340 aesni_ciphers (ENGINE *e, const EVP_CIPHER **cipher,
341                       const int **nids, int nid)
342 {
343         /* No specific cipher => return a list of supported nids ... */
344         if (!cipher) {
345                 *nids = aesni_cipher_nids;
346                 return aesni_cipher_nids_num;
347         }
348
349         /* ... or the requested "cipher" otherwise */
350         switch (nid) {
351         case NID_aes_128_ecb:
352                 *cipher = &aesni_128_ecb;
353                 break;
354         case NID_aes_128_cbc:
355                 *cipher = &aesni_128_cbc;
356                 break;
357         case NID_aes_128_cfb:
358                 *cipher = &aesni_128_cfb;
359                 break;
360         case NID_aes_128_ofb:
361                 *cipher = &aesni_128_ofb;
362                 break;
363
364         case NID_aes_192_ecb:
365                 *cipher = &aesni_192_ecb;
366                 break;
367         case NID_aes_192_cbc:
368                 *cipher = &aesni_192_cbc;
369                 break;
370         case NID_aes_192_cfb:
371                 *cipher = &aesni_192_cfb;
372                 break;
373         case NID_aes_192_ofb:
374                 *cipher = &aesni_192_ofb;
375                 break;
376
377         case NID_aes_256_ecb:
378                 *cipher = &aesni_256_ecb;
379                 break;
380         case NID_aes_256_cbc:
381                 *cipher = &aesni_256_cbc;
382                 break;
383         case NID_aes_256_cfb:
384                 *cipher = &aesni_256_cfb;
385                 break;
386         case NID_aes_256_ofb:
387                 *cipher = &aesni_256_ofb;
388                 break;
389
390         default:
391                 /* Sorry, we don't support this NID */
392                 *cipher = NULL;
393                 return 0;
394         }
395
396         return 1;
397 }
398
399 #endif /* COMPILE_HW_AESNI */
400 #endif /* !defined(OPENSSL_NO_HW) && !defined(OPENSSL_NO_HW_AESNI) && !defined(OPENSSL_NO_AES) */