VIA C3 processor extends IA-32 instruction set with instuctions
[openssl.git] / crypto / engine / eng_padlock.c
1 /* 
2  * Support for VIA PadLock Advanced Cryptography Engine (ACE)
3  * Written by Michal Ludvig <michal@logix.cz>
4  *            http://www.logix.cz/michal
5  *
6  * Big thanks to Andy Polyakov for a help with optimization, 
7  * assembler fixes, port to MS Windows and a lot of other 
8  * valuable work on this engine!
9  */
10
11 /* ====================================================================
12  * Copyright (c) 1999-2001 The OpenSSL Project.  All rights reserved.
13  *
14  * Redistribution and use in source and binary forms, with or without
15  * modification, are permitted provided that the following conditions
16  * are met:
17  *
18  * 1. Redistributions of source code must retain the above copyright
19  *    notice, this list of conditions and the following disclaimer.
20  *
21  * 2. Redistributions in binary form must reproduce the above copyright
22  *    notice, this list of conditions and the following disclaimer in
23  *    the documentation and/or other materials provided with the
24  *    distribution.
25  *
26  * 3. All advertising materials mentioning features or use of this
27  *    software must display the following acknowledgment:
28  *    "This product includes software developed by the OpenSSL Project
29  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
30  *
31  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
32  *    endorse or promote products derived from this software without
33  *    prior written permission. For written permission, please contact
34  *    licensing@OpenSSL.org.
35  *
36  * 5. Products derived from this software may not be called "OpenSSL"
37  *    nor may "OpenSSL" appear in their names without prior written
38  *    permission of the OpenSSL Project.
39  *
40  * 6. Redistributions of any form whatsoever must retain the following
41  *    acknowledgment:
42  *    "This product includes software developed by the OpenSSL Project
43  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
44  *
45  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
46  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
47  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
48  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
49  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
50  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
51  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
52  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
53  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
54  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
55  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
56  * OF THE POSSIBILITY OF SUCH DAMAGE.
57  * ====================================================================
58  *
59  * This product includes cryptographic software written by Eric Young
60  * (eay@cryptsoft.com).  This product includes software written by Tim
61  * Hudson (tjh@cryptsoft.com).
62  *
63  */
64
65
66 #include <stdio.h>
67 #include <string.h>
68
69 #include <openssl/crypto.h>
70 #include <openssl/dso.h>
71 #include <openssl/engine.h>
72 #include <openssl/evp.h>
73 #include <openssl/aes.h>
74
75 #ifndef OPENSSL_NO_HW
76 #ifndef OPENSSL_NO_HW_PADLOCK
77
78 /* Attempt to have a single source for both 0.9.7 and 0.9.8 :-) */
79 #if (OPENSSL_VERSION_NUMBER >= 0x00908000L)
80 #  ifndef OPENSSL_NO_DYNAMIC_ENGINE
81 #    define DYNAMIC_ENGINE
82 #  endif
83 #elif (OPENSSL_VERSION_NUMBER >= 0x00907000L)
84 #  ifdef ENGINE_DYNAMIC_SUPPORT
85 #    define DYNAMIC_ENGINE
86 #  endif
87 #else
88 #  error "Only OpenSSL >= 0.9.7 is supported"
89 #endif
90
91 /* VIA PadLock AES is available *ONLY* on some x86 CPUs.
92    Not only that it doesn't exist elsewhere, but it
93    even can't be compiled on other platforms!
94  
95    In addition, because of the heavy use of inline assembler,
96    compiler choice is limited to GCC and Microsoft C. */
97 #undef COMPILE_HW_PADLOCK
98 #if !defined(I386_ONLY) && !defined(OPENSSL_NO_INLINE_ASM)
99 # if defined(__i386__) || defined(__i386) || defined(_M_IX86)
100 #  define COMPILE_HW_PADLOCK
101 # endif
102 #endif
103
104 static ENGINE *ENGINE_padlock (void);
105
106 void ENGINE_load_padlock (void)
107 {
108 /* On non-x86 CPUs it just returns. */
109 #ifdef COMPILE_HW_PADLOCK
110         ENGINE *toadd = ENGINE_padlock ();
111         if (!toadd) return;
112         ENGINE_add (toadd);
113         ENGINE_free (toadd);
114         ERR_clear_error ();
115 #endif
116 }
117
118 #ifdef COMPILE_HW_PADLOCK
119 /* Function for ENGINE detection and control */
120 static int padlock_available(void);
121 static int padlock_init(ENGINE *e);
122
123 /* RNG Stuff */
124 static RAND_METHOD padlock_rand;
125
126 /* Cipher Stuff */
127 static int padlock_ciphers(ENGINE *e, const EVP_CIPHER **cipher, const int **nids, int nid);
128
129 /* Engine names */
130 static const char *padlock_id = "padlock";
131 static char padlock_name[100];
132
133 /* Available features */
134 static int padlock_use_ace = 0; /* Advanced Cryptography Engine */
135 static int padlock_use_rng = 0; /* Random Number Generator */
136 static int padlock_aes_align_required = 1;
137
138 /* ===== Engine "management" functions ===== */
139
140 /* Prepare the ENGINE structure for registration */
141 static int
142 padlock_bind_helper(ENGINE *e)
143 {
144         /* Check available features */
145         padlock_available();
146
147 #if 1   /* disable RNG for now, see commentary in vicinity of RNG code */
148         padlock_use_rng=0;
149 #endif
150
151         /* Generate a nice engine name with available features */
152         snprintf(padlock_name, sizeof(padlock_name), "VIA PadLock (%s, %s)", 
153                  padlock_use_rng ? "RNG" : "no-RNG",
154                  padlock_use_ace ? "ACE" : "no-ACE");
155
156         /* Register everything or return with an error */ 
157         if (!ENGINE_set_id(e, padlock_id) ||
158             !ENGINE_set_name(e, padlock_name) ||
159
160             !ENGINE_set_init_function(e, padlock_init) ||
161
162             (padlock_use_ace && !ENGINE_set_ciphers (e, padlock_ciphers)) ||
163             (padlock_use_rng && !ENGINE_set_RAND (e, &padlock_rand))) {
164                 return 0;
165         }
166
167         /* Everything looks good */
168         return 1;
169 }
170
171 /* Constructor */
172 static ENGINE *
173 ENGINE_padlock(void)
174 {
175         ENGINE *eng = ENGINE_new();
176
177         if (!eng) {
178                 return NULL;
179         }
180
181         if (!padlock_bind_helper(eng)) {
182                 ENGINE_free(eng);
183                 return NULL;
184         }
185
186         return eng;
187 }
188
189 /* Check availability of the engine */
190 static int
191 padlock_init(ENGINE *e)
192 {
193         return (padlock_use_rng || padlock_use_ace);
194 }
195
196 /* This stuff is needed if this ENGINE is being compiled into a self-contained
197  * shared-library.
198  */
199 #ifdef DYNAMIC_ENGINE
200 static int
201 padlock_bind_fn(ENGINE *e, const char *id)
202 {
203         if (id && (strcmp(id, padlock_id) != 0)) {
204                 return 0;
205         }
206
207         if (!padlock_bind_helper(e))  {
208                 return 0;
209         }
210
211         return 1;
212 }
213
214 IMPLEMENT_DYNAMIC_CHECK_FN ();
215 IMPLEMENT_DYNAMIC_BIND_FN (padlock_bind_fn);
216 #endif /* DYNAMIC_ENGINE */
217
218 /* ===== Here comes the "real" engine ===== */
219
220 /* Some AES-related constants */
221 #define AES_BLOCK_SIZE          16
222 #define AES_KEY_SIZE_128        16
223 #define AES_KEY_SIZE_192        24
224 #define AES_KEY_SIZE_256        32
225
226 /* Here we store the status information relevant to the 
227    current context. */
228 /* BIG FAT WARNING:
229  *      Inline assembler in PADLOCK_XCRYPT_ASM()
230  *      depends on the order of items in this structure.
231  *      Don't blindly modify, reorder, etc!
232  */
233 struct padlock_cipher_data
234 {
235         unsigned char iv[AES_BLOCK_SIZE];       /* Initialization vector */
236         union { unsigned int pad[4];
237                 struct {
238                         int rounds:4;
239                         int algo:3;
240                         int keygen:1;
241                         int interm:1;
242                         int encdec:1;
243                         int ksize:2;
244                 } b;
245         } cword;                /* Control word */
246         AES_KEY ks;             /* Encryption key */
247 };
248
249 /*
250  * =======================================================
251  * Inline assembler section(s).
252  * =======================================================
253  * Order of arguments is chosen to facilitate Windows port
254  * using __fastcall calling convention. If you wish to add
255  * more routines, keep in mind that in __fastcall first
256  * argument is passed in %ecx and second - in %edx.
257  * =======================================================
258  */
259 #if defined(__GNUC__) && __GNUC__>=2
260 /*
261  * As for excessive "push %ebx"/"pop %ebx" found all over.
262  * When generating position-independent code GCC won't let
263  * us use "b" in assembler templates nor even respect "ebx"
264  * in "clobber description." Therefore the trouble...
265  */
266
267 /* Helper function - check if a CPUID instruction
268    is available on this CPU */
269 static int
270 padlock_insn_cpuid_available(void)
271 {
272         int result = -1;
273
274         /* We're checking if the bit #21 of EFLAGS 
275            can be toggled. If yes = CPUID is available. */
276         asm volatile (
277                 "pushf\n"
278                 "popl %%eax\n"
279                 "xorl $0x200000, %%eax\n"
280                 "movl %%eax, %%ecx\n"
281                 "andl $0x200000, %%ecx\n"
282                 "pushl %%eax\n"
283                 "popf\n"
284                 "pushf\n"
285                 "popl %%eax\n"
286                 "andl $0x200000, %%eax\n"
287                 "xorl %%eax, %%ecx\n"
288                 "movl %%ecx, %0\n"
289                 : "=r" (result) : : "eax", "ecx");
290         
291         return (result == 0);
292 }
293
294 /* Load supported features of the CPU to see if
295    the PadLock is available. */
296 static int
297 padlock_available(void)
298 {
299         char vendor_string[16];
300         unsigned int eax, edx;
301
302         /* First check if the CPUID instruction is available at all... */
303         if (! padlock_insn_cpuid_available())
304                 return 0;
305
306         /* Are we running on the Centaur (VIA) CPU? */
307         eax = 0x00000000;
308         vendor_string[12] = 0;
309         asm volatile (
310                 "pushl  %%ebx\n"
311                 "cpuid\n"
312                 "movl   %%ebx,(%%edi)\n"
313                 "movl   %%edx,4(%%edi)\n"
314                 "movl   %%ecx,8(%%edi)\n"
315                 "popl   %%ebx"
316                 : "+a"(eax) : "D"(vendor_string) : "ecx", "edx");
317         if (strcmp(vendor_string, "CentaurHauls") != 0)
318                 return 0;
319
320         /* Check for Centaur Extended Feature Flags presence */
321         eax = 0xC0000000;
322         asm volatile ("pushl %%ebx; cpuid; popl %%ebx"
323                 : "+a"(eax) : : "ecx", "edx");
324         if (eax < 0xC0000001)
325                 return 0;
326
327         /* Read the Centaur Extended Feature Flags */
328         eax = 0xC0000001;
329         asm volatile ("pushl %%ebx; cpuid; popl %%ebx"
330                 : "+a"(eax), "=d"(edx) : : "ecx");
331
332         /* Fill up some flags */
333         padlock_use_ace = ((edx & (0x3<<6)) == (0x3<<6));
334         padlock_use_rng = ((edx & (0x3<<2)) == (0x3<<2));
335
336         return padlock_use_ace + padlock_use_rng;
337 }
338
339 /* Our own htonl()/ntohl() */
340 static inline void
341 padlock_bswapl(AES_KEY *ks)
342 {
343         size_t i = sizeof(ks->rd_key)/sizeof(ks->rd_key[0]);
344         unsigned long *key = ks->rd_key;
345
346         while (i--) {
347                 asm volatile ("bswapl %0" : "+r"(*key));
348                 key++;
349         }
350 }
351
352 /* Force key reload from memory to the CPU microcode.
353    Loading EFLAGS from the stack clears EFLAGS[30] 
354    which does the trick. */
355 static inline void
356 padlock_reload_key(void)
357 {
358         asm volatile ("pushfl; popfl");
359 }
360
361 /*
362  * This is heuristic key context tracing. At first one
363  * believes that one should use atomic swap instructions,
364  * but it's not actually necessary. Point is that if
365  * saved_cdata was changed by another thread after we've
366  * read it and before we compare it with cdata, our key
367  * *shall* be reloaded upon thread context switch and
368  * we are therefore set in either case...
369  */
370 static inline void
371 padlock_verify_context(struct padlock_cipher_data *cdata)
372 {
373         static struct padlock_cipher_data *saved_cdata;
374
375         asm volatile (
376         "pushfl\n"
377 "       bt      $30,(%%esp)\n"
378 "       jnc     1f\n"
379 "       cmp     %2,%1\n"
380 "       je      1f\n"
381 "       mov     %2,%0\n"
382 "       popfl\n"
383 "       sub     $4,%%esp\n"
384 "1:     add     $4,%%esp"
385         :"+m"(saved_cdata) : "r"(saved_cdata), "r"(cdata) : "cc");
386 }
387
388 /* Template for padlock_xcrypt_* modes */
389 /* BIG FAT WARNING: 
390  *      The offsets used with 'leal' instructions
391  *      describe items of the 'padlock_cipher_data'
392  *      structure.
393  */
394 #define PADLOCK_XCRYPT_ASM(name,rep_xcrypt)     \
395 static inline void *name(size_t cnt,            \
396         struct padlock_cipher_data *cdata,      \
397         void *out, const void *inp)             \
398 {       void *iv;                               \
399         asm volatile ( "pushl   %%ebx\n"        \
400                 "       leal    16(%0),%%edx\n" \
401                 "       leal    32(%0),%%ebx\n" \
402                         rep_xcrypt "\n"         \
403                 "       popl    %%ebx"          \
404                 : "=a"(iv), "=c"(cnt), "=D"(out), "=S"(inp) \
405                 : "0"(cdata), "1"(cnt), "2"(out), "3"(inp) \
406                 : "edx", "cc");                 \
407         return iv;                              \
408 }
409
410 /* Generate all functions with appropriate opcodes */
411 PADLOCK_XCRYPT_ASM(padlock_xcrypt_ecb, ".byte 0xf3,0x0f,0xa7,0xc8");    /* rep xcryptecb */
412 PADLOCK_XCRYPT_ASM(padlock_xcrypt_cbc, ".byte 0xf3,0x0f,0xa7,0xd0");    /* rep xcryptcbc */
413 PADLOCK_XCRYPT_ASM(padlock_xcrypt_cfb, ".byte 0xf3,0x0f,0xa7,0xe0");    /* rep xcryptcfb */
414 PADLOCK_XCRYPT_ASM(padlock_xcrypt_ofb, ".byte 0xf3,0x0f,0xa7,0xe8");    /* rep xcryptofb */
415
416 /* The RNG call itself */
417 static inline unsigned int
418 padlock_xstore(void *addr, unsigned int edx_in)
419 {
420         unsigned int eax_out;
421
422         asm volatile (".byte 0x0f,0xa7,0xc0"    /* xstore */
423             : "=a"(eax_out),"=m"(*(unsigned *)addr)
424             : "D"(addr), "d" (edx_in)
425             );
426
427         return eax_out;
428 }
429
430 #elif defined(_MSC_VER)
431 /*
432  * Unlike GCC these are real functions. In order to minimize impact
433  * on performance we adhere to __fastcall calling convention in
434  * order to get two first arguments passed through %ecx and %edx.
435  * Which kind of suits very well, as instructions in question use
436  * both %ecx and %edx as input:-)
437  */
438 #define REP_XCRYPT(code)                \
439         _asm _emit 0xf3                 \
440         _asm _emit 0x0f _asm _emit 0xa7 \
441         _asm _emit code
442
443 /* BIG FAT WARNING: 
444  *      The offsets used with 'lea' instructions
445  *      describe items of the 'padlock_cipher_data'
446  *      structure.
447  */
448 #define PADLOCK_XCRYPT_ASM(name,code)   \
449 static void * __fastcall                \
450         name (size_t cnt, void *cdata,  \
451         void *outp, const void *inp)    \
452 {       _asm    mov     eax,edx         \
453         _asm    lea     ebx,[eax+16]    \
454         _asm    lea     edx,[eax+32]    \
455         _asm    mov     edi,outp        \
456         _asm    mov     esi,inp         \
457         REP_XCRYPT(code)                \
458 }
459
460 PADLOCK_XCRYPT_ASM(padlock_xcrypt_ecb,0xc8)
461 PADLOCK_XCRYPT_ASM(padlock_xcrypt_cbc,0xd0)
462 PADLOCK_XCRYPT_ASM(padlock_xcrypt_cfb,0xe0)
463 PADLOCK_XCRYPT_ASM(padlock_xcrypt_ofb,0xe8)
464
465 static int __fastcall
466 padlock_xstore(void *outp,unsigned int code)
467 {       _asm    mov     edi,ecx
468         _asm _emit 0x0f _asm _emit 0xa7 _asm _emit 0xc0
469 }
470
471 static void __fastcall
472 padlock_reload_key(void)
473 {       _asm pushfd _asm popfd          }
474
475 static void __fastcall
476 padlock_verify_context(void *cdata)
477 {       static void *saved_cdata;
478
479         _asm    {
480                 pushfd
481                 bt      DWORD PTR[esp],30
482                 jnc     skip
483                 cmp     ecx,saved_cdata
484                 je      skip
485                 mov     saved_cdata,ecx
486                 popfd
487                 sub     esp,4
488         skip:   add     esp,4
489                 }
490 }
491
492 sttic int __fastcall
493 padlock_available(void)
494 {       _asm    {
495                 pushfd
496                 pop     eax
497                 mov     ecx,eax
498                 xor     eax,1<<21
499                 push    eax
500                 popfd
501                 pushfd
502                 pop     eax
503                 xor     eax,ecx
504                 bt      eax,21
505                 jnc     noluck
506                 mov     eax,0
507                 cpuid
508                 xor     eax,eax
509                 cmp     ebx,'tneC'
510                 jne     noluck
511                 cmp     edx,'Hrua'
512                 jne     noluck
513                 cmp     ecx,'slua'
514                 jne     noluck
515                 mov     eax,0xC0000000
516                 cpuid
517                 mov     edx,eax
518                 xor     eax,eax
519                 cmp     edx,0xC0000001
520                 jb      noluck
521                 mov     eax,0xC0000001
522                 cpuid
523                 xor     eax,eax
524                 bt      edx,6
525                 jnc     skip_a
526                 bt      edx,7
527                 jnc     skip_a
528                 mov     padlock_use_ace,1
529                 inc     eax
530         skip_a: bt      edx,2
531                 jnc     skip_r
532                 bt      edx,3
533                 jnc     skip_r
534                 mov     padlock_use_rng,1
535                 inc     eax
536         skip_r:
537         noluck:
538                 }
539 }
540
541 static void __fastcall
542 padlock_bswapl(void *key)
543 {       _asm    {
544                 pushfd
545                 cld
546                 mov     esi,ecx
547                 mov     edi,ecx
548                 mov     ecx,60
549         up:
550                 lodsd
551                 bswap   eax
552                 stosd
553                 loop    up
554                 popfd
555                 }
556 }
557 #endif
558
559 /* ===== AES encryption/decryption ===== */
560
561 #if defined(NID_aes_128_cfb128) && ! defined (NID_aes_128_cfb)
562 #define NID_aes_128_cfb NID_aes_128_cfb128
563 #endif
564
565 #if defined(NID_aes_128_ofb128) && ! defined (NID_aes_128_ofb)
566 #define NID_aes_128_ofb NID_aes_128_ofb128
567 #endif
568
569 #if defined(NID_aes_192_cfb128) && ! defined (NID_aes_192_cfb)
570 #define NID_aes_192_cfb NID_aes_192_cfb128
571 #endif
572
573 #if defined(NID_aes_192_ofb128) && ! defined (NID_aes_192_ofb)
574 #define NID_aes_192_ofb NID_aes_192_ofb128
575 #endif
576
577 #if defined(NID_aes_256_cfb128) && ! defined (NID_aes_256_cfb)
578 #define NID_aes_256_cfb NID_aes_256_cfb128
579 #endif
580
581 #if defined(NID_aes_256_ofb128) && ! defined (NID_aes_256_ofb)
582 #define NID_aes_256_ofb NID_aes_256_ofb128
583 #endif
584
585 /* List of supported ciphers. */
586 static int padlock_cipher_nids[] = {
587         NID_aes_128_ecb,
588         NID_aes_128_cbc,
589         NID_aes_128_cfb,
590         NID_aes_128_ofb,
591
592         NID_aes_192_ecb,
593         NID_aes_192_cbc,
594 //      NID_aes_192_cfb,        /* FIXME: AES192/256 CFB/OFB don't work. */
595 //      NID_aes_192_ofb,
596
597         NID_aes_256_ecb,
598         NID_aes_256_cbc,
599 //      NID_aes_256_cfb,
600 //      NID_aes_256_ofb,
601 };
602 static int padlock_cipher_nids_num = (sizeof(padlock_cipher_nids)/
603                                       sizeof(padlock_cipher_nids[0]));
604
605 /* Function prototypes ... */
606 static int padlock_aes_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
607                                 const unsigned char *iv, int enc);
608 static int padlock_aes_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
609                               const unsigned char *in, unsigned int nbytes);
610
611 #define ALIGNED_CIPHER_DATA(ctx) ((struct padlock_cipher_data *)(ctx->cipher_data + ((0x10 - ((size_t)(ctx->cipher_data) & 0x0F)) & 0x0F)))
612
613 /* Declaring so many ciphers by hand would be a pain.
614    Instead introduce a bit of preprocessor magic :-) */
615 #define DECLARE_AES_EVP(ksize,lmode,umode)      \
616 static const EVP_CIPHER padlock_aes_##ksize##_##lmode = {       \
617         NID_aes_##ksize##_##lmode,              \
618         AES_BLOCK_SIZE,                 \
619         AES_KEY_SIZE_##ksize,           \
620         AES_BLOCK_SIZE,                 \
621         0 | EVP_CIPH_##umode##_MODE,    \
622         padlock_aes_init_key,           \
623         padlock_aes_cipher,             \
624         NULL,                           \
625         sizeof(struct padlock_cipher_data) + 16,        \
626         EVP_CIPHER_set_asn1_iv,         \
627         EVP_CIPHER_get_asn1_iv,         \
628         NULL,                           \
629         NULL                            \
630 }
631
632 DECLARE_AES_EVP(128,ecb,ECB);
633 DECLARE_AES_EVP(128,cbc,CBC);
634 DECLARE_AES_EVP(128,cfb,CFB);
635 DECLARE_AES_EVP(128,ofb,OFB);
636
637 DECLARE_AES_EVP(192,ecb,ECB);
638 DECLARE_AES_EVP(192,cbc,CBC);
639 DECLARE_AES_EVP(192,cfb,CFB);
640 DECLARE_AES_EVP(192,ofb,OFB);
641
642 DECLARE_AES_EVP(256,ecb,ECB);
643 DECLARE_AES_EVP(256,cbc,CBC);
644 DECLARE_AES_EVP(256,cfb,CFB);
645 DECLARE_AES_EVP(256,ofb,OFB);
646
647 static int
648 padlock_ciphers (ENGINE *e, const EVP_CIPHER **cipher, const int **nids, int nid)
649 {
650         /* No specific cipher => return a list of supported nids ... */
651         if (!cipher) {
652                 *nids = padlock_cipher_nids;
653                 return padlock_cipher_nids_num;
654         }
655
656         /* ... or the requested "cipher" otherwise */
657         switch (nid) {
658           case NID_aes_128_ecb:
659             *cipher = &padlock_aes_128_ecb;
660             break;
661           case NID_aes_128_cbc:
662             *cipher = &padlock_aes_128_cbc;
663             break;
664           case NID_aes_128_cfb:
665             *cipher = &padlock_aes_128_cfb;
666             break;
667           case NID_aes_128_ofb:
668             *cipher = &padlock_aes_128_ofb;
669             break;
670
671           case NID_aes_192_ecb:
672             *cipher = &padlock_aes_192_ecb;
673             break;
674           case NID_aes_192_cbc:
675             *cipher = &padlock_aes_192_cbc;
676             break;
677           case NID_aes_192_cfb:
678             *cipher = &padlock_aes_192_cfb;
679             break;
680           case NID_aes_192_ofb:
681             *cipher = &padlock_aes_192_ofb;
682             break;
683
684           case NID_aes_256_ecb:
685             *cipher = &padlock_aes_256_ecb;
686             break;
687           case NID_aes_256_cbc:
688             *cipher = &padlock_aes_256_cbc;
689             break;
690           case NID_aes_256_cfb:
691             *cipher = &padlock_aes_256_cfb;
692             break;
693           case NID_aes_256_ofb:
694             *cipher = &padlock_aes_256_ofb;
695             break;
696
697           default:
698             /* Sorry, we don't support this NID */
699             *cipher = NULL;
700             return 0;
701         }
702
703         return 1;
704 }
705
706 /* Prepare the encryption key for PadLock usage */
707 static int
708 padlock_aes_init_key (EVP_CIPHER_CTX *ctx, const unsigned char *key,
709                       const unsigned char *iv, int enc)
710 {
711         struct padlock_cipher_data *cdata;
712         int key_len = EVP_CIPHER_CTX_key_length(ctx) * 8;
713
714         if (key==NULL) return 0;        /* ERROR */
715
716         cdata = ALIGNED_CIPHER_DATA(ctx);
717         memset(cdata, 0, sizeof(struct padlock_cipher_data));
718
719         /* Prepare Control word. */
720         cdata->cword.b.encdec = (ctx->encrypt == 0);
721         cdata->cword.b.rounds = 10 + (key_len - 128) / 32;
722         cdata->cword.b.ksize = (key_len - 128) / 64;
723
724         switch(key_len) {
725                 case 128:
726                         /* PadLock can generate an extended key for
727                            AES128 in hardware */
728                         memcpy(cdata->ks.rd_key, key, AES_KEY_SIZE_128);
729                         cdata->cword.b.keygen = 0;
730                         break;
731
732                 case 192:
733                 case 256:
734                         /* Generate an extended AES key in software.
735                            Needed for AES192/AES256 */
736                         if (enc)
737                                 AES_set_encrypt_key(key, key_len, &cdata->ks);
738                         else
739                                 AES_set_decrypt_key(key, key_len, &cdata->ks);
740
741                         /* OpenSSL internal functions use byte-swapped extended key. */
742                         padlock_bswapl(&cdata->ks);
743
744                         cdata->cword.b.keygen = 1;
745                         break;
746
747                 default:
748                         /* ERROR */
749                         return 0;
750         }
751
752         /*
753          * This is done to cover for cases when user reuses the
754          * context for new key. The catch is that if we don't do
755          * this, padlock_eas_cipher might proceed with old key...
756          */
757         padlock_reload_key ();
758
759         return 1;
760 }
761
762 /* 
763  * Simplified version of padlock_aes_cipher() used when
764  * 1) both input and output buffers are at aligned addresses.
765  * or when
766  * 2) running on a newer CPU that doesn't require aligned buffers.
767  */
768 static int
769 padlock_aes_cipher_omnivorous(EVP_CIPHER_CTX *ctx, unsigned char *out_arg,
770                 const unsigned char *in_arg, size_t nbytes)
771 {
772         struct padlock_cipher_data *cdata;
773         void  *iv;
774
775         cdata = ALIGNED_CIPHER_DATA(ctx);
776         padlock_verify_context(cdata);
777
778         switch (EVP_CIPHER_CTX_mode(ctx)) {
779         case EVP_CIPH_ECB_MODE:
780                 padlock_xcrypt_ecb(nbytes/AES_BLOCK_SIZE, cdata, out_arg, in_arg);
781                 break;
782
783         case EVP_CIPH_CBC_MODE:
784                 memcpy(cdata->iv, ctx->iv, AES_BLOCK_SIZE);
785                 iv = padlock_xcrypt_cbc(nbytes/AES_BLOCK_SIZE, cdata, out_arg, in_arg);
786                 memcpy(ctx->iv, iv, AES_BLOCK_SIZE);
787                 break;
788
789         case EVP_CIPH_CFB_MODE:
790                 memcpy(cdata->iv, ctx->iv, AES_BLOCK_SIZE);
791                 iv = padlock_xcrypt_cfb(nbytes/AES_BLOCK_SIZE, cdata, out_arg, in_arg);
792                 memcpy(ctx->iv, iv, AES_BLOCK_SIZE);
793                 break;
794
795         case EVP_CIPH_OFB_MODE:
796                 memcpy(cdata->iv, ctx->iv, AES_BLOCK_SIZE);
797                 padlock_xcrypt_ofb(nbytes/AES_BLOCK_SIZE, cdata, out_arg, in_arg);
798                 memcpy(ctx->iv, cdata->iv, AES_BLOCK_SIZE);
799                 break;
800
801         default:
802                 return 0;
803         }
804
805         memset(cdata->iv, 0, AES_BLOCK_SIZE);
806
807         return 1;
808 }
809
810 #ifndef  PADLOCK_CHUNK
811 # define PADLOCK_CHUNK  4096    /* Must be a power of 2 larger than 16 */
812 #endif
813 #if PADLOCK_CHUNK<16 || PADLOCK_CHUNK&(PADLOCK_CHUNK-1)
814 # error "insane PADLOCK_CHUNK..."
815 #endif
816
817 /* Re-align the arguments to 16-Bytes boundaries and run the 
818    encryption function itself. This function is not AES-specific. */
819 static int
820 padlock_aes_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out_arg,
821                    const unsigned char *in_arg, size_t nbytes)
822 {
823         struct padlock_cipher_data *cdata;
824         const  void *inp;
825         void  *out, *iv;
826         int    inp_misaligned, out_misaligned, realign_in_loop;
827         size_t chunk, allocated;
828
829         if (nbytes == 0)
830                 return 1;
831         if (nbytes % AES_BLOCK_SIZE)
832                 return 0; /* are we expected to do tail processing? */
833
834 #if 0
835         /* There is more work to support CPUs that don't require alignment.
836            Therefore disabled completely for now... */
837         if (!padlock_aes_align_required)
838                 return padlock_aes_cipher_omnivorous(ctx, out_arg, in_arg, nbytes);
839 #endif
840
841         inp_misaligned = (((size_t)in_arg) & 0x0F);
842         out_misaligned = (((size_t)out_arg) & 0x0F);
843
844         /* Note that even if output is aligned and input not,
845          * I still prefer to loop instead of copy the whole
846          * input and then encrypt in one stroke. This is done
847          * in order to improve L1 cache utilization... */
848         realign_in_loop = out_misaligned|inp_misaligned;
849
850         if (!realign_in_loop)
851                 return padlock_aes_cipher_omnivorous(ctx, out_arg, in_arg, nbytes);
852
853         /* this takes one "if" out of the loops */
854         chunk  = nbytes;
855         chunk %= PADLOCK_CHUNK;
856         if (chunk==0) chunk = PADLOCK_CHUNK;
857
858         if (out_misaligned) {
859                 /* optmize for small input */
860                 allocated = (chunk<nbytes?PADLOCK_CHUNK:nbytes);
861 #ifdef _MSC_VER
862                 out  = _alloca(0x10 + allocated);
863 #else
864                 out  =  alloca(0x10 + allocated);
865 #endif
866                 out += (0x10 - ((size_t)out & 0x0F)) & 0x0F;
867         }
868         else
869                 out = out_arg;
870
871         cdata = ALIGNED_CIPHER_DATA(ctx);
872         padlock_verify_context(cdata);
873
874         switch (EVP_CIPHER_CTX_mode(ctx)) {
875         case EVP_CIPH_ECB_MODE:
876                 do      {
877                         if (inp_misaligned)
878                                 inp = memcpy(out, in_arg, chunk);
879                         else
880                                 inp = in_arg;
881                         in_arg += chunk;
882
883                         padlock_xcrypt_ecb(chunk/AES_BLOCK_SIZE, cdata, out, inp);
884
885                         if (out_misaligned)
886                                 out_arg = memcpy(out_arg, out, chunk) + chunk;
887                         else
888                                 out     = out_arg+=chunk;
889
890                         nbytes -= chunk;
891                         chunk   = PADLOCK_CHUNK;
892                 } while (nbytes);
893                 break;
894
895         case EVP_CIPH_CBC_MODE:
896                 memcpy(cdata->iv, ctx->iv, AES_BLOCK_SIZE);
897                 goto cbc_shortcut;
898                 do      {
899                         if (iv != cdata->iv)
900                                 memcpy(cdata->iv, iv, AES_BLOCK_SIZE);
901                         chunk = PADLOCK_CHUNK;
902                 cbc_shortcut: /* optimize for small input */
903                         if (inp_misaligned)
904                                 inp = memcpy(out, in_arg, chunk);
905                         else
906                                 inp = in_arg;
907                         in_arg += chunk;
908
909                         iv = padlock_xcrypt_cbc(chunk/AES_BLOCK_SIZE, cdata, out, inp);
910
911                         if (out_misaligned)
912                                 out_arg = memcpy(out_arg, out, chunk) + chunk;
913                         else
914                                 out     = out_arg+=chunk;
915
916                 } while (nbytes -= chunk);
917                 memcpy(ctx->iv, iv, AES_BLOCK_SIZE);
918                 break;
919
920         case EVP_CIPH_CFB_MODE:
921                 memcpy (cdata->iv, ctx->iv, AES_BLOCK_SIZE);
922                 goto cfb_shortcut;
923                 do      {
924                         if (iv != cdata->iv)
925                                 memcpy(cdata->iv, iv, AES_BLOCK_SIZE);
926                         chunk = PADLOCK_CHUNK;
927                 cfb_shortcut: /* optimize for small input */
928                         if (inp_misaligned)
929                                 inp = memcpy(out, in_arg, chunk);
930                         else
931                                 inp = in_arg;
932                         in_arg += chunk;
933
934                         iv = padlock_xcrypt_cfb(chunk/AES_BLOCK_SIZE, cdata, out, inp);
935
936                         if (out_misaligned)
937                                 out_arg = memcpy(out_arg, out, chunk) + chunk;
938                         else
939                                 out     = out_arg+=chunk;
940
941                 } while (nbytes -= chunk);
942                 memcpy(ctx->iv, iv, AES_BLOCK_SIZE);
943                 break;
944
945         case EVP_CIPH_OFB_MODE:
946                 memcpy(cdata->iv, ctx->iv, AES_BLOCK_SIZE);
947                 do      {
948                         if (inp_misaligned)
949                                 inp = memcpy(out, in_arg, chunk);
950                         else
951                                 inp = in_arg;
952                         in_arg += chunk;
953
954                         padlock_xcrypt_ofb(chunk/AES_BLOCK_SIZE, cdata, out, inp);
955
956                         if (out_misaligned)
957                                 out_arg = memcpy(out_arg, out, chunk) + chunk;
958                         else
959                                 out     = out_arg+=chunk;
960
961                         nbytes -= chunk;
962                         chunk   = PADLOCK_CHUNK;
963                 } while (nbytes);
964                 memcpy(ctx->iv, cdata->iv, AES_BLOCK_SIZE);
965                 break;
966
967         default:
968                 return 0;
969         }
970
971         /* Clean the realign buffer if it was used */
972         if (out_misaligned) {
973                 volatile unsigned long *p=out;
974                 size_t   n = allocated/sizeof(*p);
975                 while (n--) *p++=0;
976         }
977
978         memset(cdata->iv, 0, AES_BLOCK_SIZE);
979
980         return 1;
981 }
982
983 /* ===== Random Number Generator ===== */
984 /*
985  * This code is not engaged. The reason is that it does not comply
986  * with recommendations for VIA RNG usage for secure applications
987  * (posted at http://www.via.com.tw/en/viac3/c3.jsp) nor does it
988  * provide meaningful error control...
989  */
990 /* Wrapper that provides an interface between the API and 
991    the raw PadLock RNG */
992 static int
993 padlock_rand_bytes(unsigned char *output, int count)
994 {
995         unsigned int eax, buf;
996
997         while (count >= 8) {
998                 eax = padlock_xstore(output, 0);
999                 if (!(eax&(1<<6)))      return 0; /* RNG disabled */
1000                 /* this ---vv--- covers DC bias, Raw Bits and String Filter */
1001                 if (eax&(0x1F<<10))     return 0;
1002                 if ((eax&0x1F)==0)      continue; /* no data, retry... */
1003                 if ((eax&0x1F)!=8)      return 0; /* fatal failure...  */
1004                 output += 8;
1005                 count  -= 8;
1006         }
1007         while (count > 0) {
1008                 eax = padlock_xstore(&buf, 3);
1009                 if (!(eax&(1<<6)))      return 0; /* RNG disabled */
1010                 /* this ---vv--- covers DC bias, Raw Bits and String Filter */
1011                 if (eax&(0x1F<<10))     return 0;
1012                 if ((eax&0x1F)==0)      continue; /* no data, retry... */
1013                 if ((eax&0x1F)!=1)      return 0; /* fatal failure...  */
1014                 *output++ = (unsigned char)buf;
1015                 count--;
1016         }
1017         *(volatile unsigned int *)&buf=0;
1018
1019         return 1;
1020 }
1021
1022 /* Dummy but necessary function */
1023 static int
1024 padlock_rand_status(void)
1025 {
1026         return 1;
1027 }
1028
1029 /* Prepare structure for registration */
1030 static RAND_METHOD padlock_rand = {
1031         NULL,                   /* seed */
1032         padlock_rand_bytes,     /* bytes */
1033         NULL,                   /* cleanup */
1034         NULL,                   /* add */
1035         padlock_rand_bytes,     /* pseudorand */
1036         padlock_rand_status,    /* rand status */
1037 };
1038
1039 #endif /* COMPILE_HW_PADLOCK */
1040
1041 #endif /* !OPENSSL_NO_HW_PADLOCK */
1042 #endif /* !OPENSSL_NO_HW */