engines/e_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/opensslconf.h>
  70 #include <openssl/crypto.h>
  71 #include <openssl/dso.h>
  72 #include <openssl/engine.h>
  73 #include <openssl/evp.h>
  74 #ifndef OPENSSL_NO_AES
  75 #include <openssl/aes.h>
  76 #endif
  77 #include <openssl/rand.h>
  78 #include <openssl/err.h>
  79
  80 #ifndef OPENSSL_NO_HW
  81 #ifndef OPENSSL_NO_HW_PADLOCK
  82
  83 /* Attempt to have a single source for both 0.9.7 and 0.9.8 :-) */
  84 #if (OPENSSL_VERSION_NUMBER >= 0x00908000L)
  85 #  ifndef OPENSSL_NO_DYNAMIC_ENGINE
  86 #    define DYNAMIC_ENGINE
  87 #  endif
  88 #elif (OPENSSL_VERSION_NUMBER >= 0x00907000L)
  89 #  ifdef ENGINE_DYNAMIC_SUPPORT
  90 #    define DYNAMIC_ENGINE
  91 #  endif
  92 #else
  93 #  error "Only OpenSSL >= 0.9.7 is supported"
  94 #endif
  95
  96 /* VIA PadLock AES is available *ONLY* on some x86 CPUs.
  97    Not only that it doesn't exist elsewhere, but it
  98    even can't be compiled on other platforms!
  99
 100    In addition, because of the heavy use of inline assembler,
 101    compiler choice is limited to GCC and Microsoft C. */
 102 #undef COMPILE_HW_PADLOCK
 103 #if !defined(I386_ONLY) && !defined(OPENSSL_NO_INLINE_ASM)
 104 # if (defined(__GNUC__) && (defined(__i386__) || defined(__i386))) || \
 105      (defined(_MSC_VER) && defined(_M_IX86))
 106 #  define COMPILE_HW_PADLOCK
 107 # endif
 108 #endif
 109
 110 #ifdef OPENSSL_NO_DYNAMIC_ENGINE
 111 #ifdef COMPILE_HW_PADLOCK
 112 static ENGINE *ENGINE_padlock (void);
 113 #endif
 114
 115 void ENGINE_load_padlock (void)
 116 {
 117 /* On non-x86 CPUs it just returns. */
 118 #ifdef COMPILE_HW_PADLOCK
 119         ENGINE *toadd = ENGINE_padlock ();
 120         if (!toadd) return;
 121         ENGINE_add (toadd);
 122         ENGINE_free (toadd);
 123         ERR_clear_error ();
 124 #endif
 125 }
 126
 127 #endif
 128
 129 #ifdef COMPILE_HW_PADLOCK
 130 /* We do these includes here to avoid header problems on platforms that
 131    do not have the VIA padlock anyway... */
 132 #include <stdlib.h>
 133 #ifdef _WIN32
 134 # include <malloc.h>
 135 # ifndef alloca
 136 #  define alloca _alloca
 137 # endif
 138 #elif defined(__GNUC__)
 139 # ifndef alloca
 140 #  define alloca(s) __builtin_alloca(s)
 141 # endif
 142 #endif
 143
 144 /* Function for ENGINE detection and control */
 145 static int padlock_available(void);
 146 static int padlock_init(ENGINE *e);
 147
 148 /* RNG Stuff */
 149 static RAND_METHOD padlock_rand;
 150
 151 /* Cipher Stuff */
 152 #ifndef OPENSSL_NO_AES
 153 static int padlock_ciphers(ENGINE *e, const EVP_CIPHER **cipher, const int **nids, int nid);
 154 #endif
 155
 156 /* Engine names */
 157 static const char *padlock_id = "padlock";
 158 static char padlock_name[100];
 159
 160 /* Available features */
 161 static int padlock_use_ace = 0; /* Advanced Cryptography Engine */
 162 static int padlock_use_rng = 0; /* Random Number Generator */
 163 #ifndef OPENSSL_NO_AES
 164 static int padlock_aes_align_required = 1;
 165 #endif
 166
 167 /* ===== Engine "management" functions ===== */
 168
 169 /* Prepare the ENGINE structure for registration */
 170 static int
 171 padlock_bind_helper(ENGINE *e)
 172 {
 173         /* Check available features */
 174         padlock_available();
 175
 176 #if 1   /* disable RNG for now, see commentary in vicinity of RNG code */
 177         padlock_use_rng=0;
 178 #endif
 179
 180         /* Generate a nice engine name with available features */
 181         BIO_snprintf(padlock_name, sizeof(padlock_name),
 182                 "VIA PadLock (%s, %s)",
 183                  padlock_use_rng ? "RNG" : "no-RNG",
 184                  padlock_use_ace ? "ACE" : "no-ACE");
 185
 186         /* Register everything or return with an error */
 187         if (!ENGINE_set_id(e, padlock_id) ||
 188             !ENGINE_set_name(e, padlock_name) ||
 189
 190             !ENGINE_set_init_function(e, padlock_init) ||
 191 #ifndef OPENSSL_NO_AES
 192             (padlock_use_ace && !ENGINE_set_ciphers (e, padlock_ciphers)) ||
 193 #endif
 194             (padlock_use_rng && !ENGINE_set_RAND (e, &padlock_rand))) {
 195                 return 0;
 196         }
 197
 198         /* Everything looks good */
 199         return 1;
 200 }
 201
 202 #ifdef OPENSSL_NO_DYNAMIC_ENGINE
 203
 204 /* Constructor */
 205 static ENGINE *
 206 ENGINE_padlock(void)
 207 {
 208         ENGINE *eng = ENGINE_new();
 209
 210         if (!eng) {
 211                 return NULL;
 212         }
 213
 214         if (!padlock_bind_helper(eng)) {
 215                 ENGINE_free(eng);
 216                 return NULL;
 217         }
 218
 219         return eng;
 220 }
 221
 222 #endif
 223
 224 /* Check availability of the engine */
 225 static int
 226 padlock_init(ENGINE *e)
 227 {
 228         return (padlock_use_rng || padlock_use_ace);
 229 }
 230
 231 /* This stuff is needed if this ENGINE is being compiled into a self-contained
 232  * shared-library.
 233  */
 234 #ifdef DYNAMIC_ENGINE
 235 static int
 236 padlock_bind_fn(ENGINE *e, const char *id)
 237 {
 238         if (id && (strcmp(id, padlock_id) != 0)) {
 239                 return 0;
 240         }
 241
 242         if (!padlock_bind_helper(e))  {
 243                 return 0;
 244         }
 245
 246         return 1;
 247 }
 248
 249 IMPLEMENT_DYNAMIC_CHECK_FN()
 250 IMPLEMENT_DYNAMIC_BIND_FN (padlock_bind_fn)
 251 #endif /* DYNAMIC_ENGINE */
 252
 253 /* ===== Here comes the "real" engine ===== */
 254
 255 #ifndef OPENSSL_NO_AES
 256 /* Some AES-related constants */
 257 #define AES_BLOCK_SIZE          16
 258 #define AES_KEY_SIZE_128        16
 259 #define AES_KEY_SIZE_192        24
 260 #define AES_KEY_SIZE_256        32
 261
 262 /* Here we store the status information relevant to the
 263    current context. */
 264 /* BIG FAT WARNING:
 265  *      Inline assembler in PADLOCK_XCRYPT_ASM()
 266  *      depends on the order of items in this structure.
 267  *      Don't blindly modify, reorder, etc!
 268  */
 269 struct padlock_cipher_data
 270 {
 271         unsigned char iv[AES_BLOCK_SIZE];       /* Initialization vector */
 272         union { unsigned int pad[4];
 273                 struct {
 274                         int rounds:4;
 275                         int dgst:1;     /* n/a in C3 */
 276                         int align:1;    /* n/a in C3 */
 277                         int ciphr:1;    /* n/a in C3 */
 278                         unsigned int keygen:1;
 279                         int interm:1;
 280                         unsigned int encdec:1;
 281                         int ksize:2;
 282                 } b;
 283         } cword;                /* Control word */
 284         AES_KEY ks;             /* Encryption key */
 285 };
 286
 287 /*
 288  * Essentially this variable belongs in thread local storage.
 289  * Having this variable global on the other hand can only cause
 290  * few bogus key reloads [if any at all on single-CPU system],
 291  * so we accept the penatly...
 292  */
 293 static volatile struct padlock_cipher_data *padlock_saved_context;
 294 #endif
 295
 296 /*
 297  * =======================================================
 298  * Inline assembler section(s).
 299  * =======================================================
 300  * Order of arguments is chosen to facilitate Windows port
 301  * using __fastcall calling convention. If you wish to add
 302  * more routines, keep in mind that first __fastcall
 303  * argument is passed in %ecx and second - in %edx.
 304  * =======================================================
 305  */
 306 #if defined(__GNUC__) && __GNUC__>=2
 307 /*
 308  * As for excessive "push %ebx"/"pop %ebx" found all over.
 309  * When generating position-independent code GCC won't let
 310  * us use "b" in assembler templates nor even respect "ebx"
 311  * in "clobber description." Therefore the trouble...
 312  */
 313
 314 /* Helper function - check if a CPUID instruction
 315    is available on this CPU */
 316 static int
 317 padlock_insn_cpuid_available(void)
 318 {
 319         int result = -1;
 320
 321         /* We're checking if the bit #21 of EFLAGS
 322            can be toggled. If yes = CPUID is available. */
 323         asm volatile (
 324                 "pushf\n"
 325                 "popl %%eax\n"
 326                 "xorl $0x200000, %%eax\n"
 327                 "movl %%eax, %%ecx\n"
 328                 "andl $0x200000, %%ecx\n"
 329                 "pushl %%eax\n"
 330                 "popf\n"
 331                 "pushf\n"
 332                 "popl %%eax\n"
 333                 "andl $0x200000, %%eax\n"
 334                 "xorl %%eax, %%ecx\n"
 335                 "movl %%ecx, %0\n"
 336                 : "=r" (result) : : "eax", "ecx");
 337
 338         return (result == 0);
 339 }
 340
 341 /* Load supported features of the CPU to see if
 342    the PadLock is available. */
 343 static int
 344 padlock_available(void)
 345 {
 346         char vendor_string[16];
 347         unsigned int eax, edx;
 348
 349         /* First check if the CPUID instruction is available at all... */
 350         if (! padlock_insn_cpuid_available())
 351                 return 0;
 352
 353         /* Are we running on the Centaur (VIA) CPU? */
 354         eax = 0x00000000;
 355         vendor_string[12] = 0;
 356         asm volatile (
 357                 "pushl  %%ebx\n"
 358                 "cpuid\n"
 359                 "movl   %%ebx,(%%edi)\n"
 360                 "movl   %%edx,4(%%edi)\n"
 361                 "movl   %%ecx,8(%%edi)\n"
 362                 "popl   %%ebx"
 363                 : "+a"(eax) : "D"(vendor_string) : "ecx", "edx");
 364         if (strcmp(vendor_string, "CentaurHauls") != 0)
 365                 return 0;
 366
 367         /* Check for Centaur Extended Feature Flags presence */
 368         eax = 0xC0000000;
 369         asm volatile ("pushl %%ebx; cpuid; popl %%ebx"
 370                 : "+a"(eax) : : "ecx", "edx");
 371         if (eax < 0xC0000001)
 372                 return 0;
 373
 374         /* Read the Centaur Extended Feature Flags */
 375         eax = 0xC0000001;
 376         asm volatile ("pushl %%ebx; cpuid; popl %%ebx"
 377                 : "+a"(eax), "=d"(edx) : : "ecx");
 378
 379         /* Fill up some flags */
 380         padlock_use_ace = ((edx & (0x3<<6)) == (0x3<<6));
 381         padlock_use_rng = ((edx & (0x3<<2)) == (0x3<<2));
 382
 383         return padlock_use_ace + padlock_use_rng;
 384 }
 385
 386 #ifndef OPENSSL_NO_AES
 387 /* Our own htonl()/ntohl() */
 388 static inline void
 389 padlock_bswapl(AES_KEY *ks)
 390 {
 391         size_t i = sizeof(ks->rd_key)/sizeof(ks->rd_key[0]);
 392         unsigned int *key = ks->rd_key;
 393
 394         while (i--) {
 395                 asm volatile ("bswapl %0" : "+r"(*key));
 396                 key++;
 397         }
 398 }
 399 #endif
 400
 401 /* Force key reload from memory to the CPU microcode.
 402    Loading EFLAGS from the stack clears EFLAGS[30]
 403    which does the trick. */
 404 static inline void
 405 padlock_reload_key(void)
 406 {
 407         asm volatile ("pushfl; popfl");
 408 }
 409
 410 #ifndef OPENSSL_NO_AES
 411 /*
 412  * This is heuristic key context tracing. At first one
 413  * believes that one should use atomic swap instructions,
 414  * but it's not actually necessary. Point is that if
 415  * padlock_saved_context was changed by another thread
 416  * after we've read it and before we compare it with cdata,
 417  * our key *shall* be reloaded upon thread context switch
 418  * and we are therefore set in either case...
 419  */
 420 static inline void
 421 padlock_verify_context(struct padlock_cipher_data *cdata)
 422 {
 423         asm volatile (
 424         "pushfl\n"
 425 "       btl     $30,(%%esp)\n"
 426 "       jnc     1f\n"
 427 "       cmpl    %2,%1\n"
 428 "       je      1f\n"
 429 "       popfl\n"
 430 "       subl    $4,%%esp\n"
 431 "1:     addl    $4,%%esp\n"
 432 "       movl    %2,%0"
 433         :"+m"(padlock_saved_context)
 434         : "r"(padlock_saved_context), "r"(cdata) : "cc");
 435 }
 436
 437 /* Template for padlock_xcrypt_* modes */
 438 /* BIG FAT WARNING:
 439  *      The offsets used with 'leal' instructions
 440  *      describe items of the 'padlock_cipher_data'
 441  *      structure.
 442  */
 443 #define PADLOCK_XCRYPT_ASM(name,rep_xcrypt)     \
 444 static inline void *name(size_t cnt,            \
 445         struct padlock_cipher_data *cdata,      \
 446         void *out, const void *inp)             \
 447 {       void *iv;                               \
 448         asm volatile ( "pushl   %%ebx\n"        \
 449                 "       leal    16(%0),%%edx\n" \
 450                 "       leal    32(%0),%%ebx\n" \
 451                         rep_xcrypt "\n"         \
 452                 "       popl    %%ebx"          \
 453                 : "=a"(iv), "=c"(cnt), "=D"(out), "=S"(inp) \
 454                 : "0"(cdata), "1"(cnt), "2"(out), "3"(inp)  \
 455                 : "edx", "cc", "memory");       \
 456         return iv;                              \
 457 }
 458
 459 /* Generate all functions with appropriate opcodes */
 460 PADLOCK_XCRYPT_ASM(padlock_xcrypt_ecb, ".byte 0xf3,0x0f,0xa7,0xc8")     /* rep xcryptecb */
 461 PADLOCK_XCRYPT_ASM(padlock_xcrypt_cbc, ".byte 0xf3,0x0f,0xa7,0xd0")     /* rep xcryptcbc */
 462 PADLOCK_XCRYPT_ASM(padlock_xcrypt_cfb, ".byte 0xf3,0x0f,0xa7,0xe0")     /* rep xcryptcfb */
 463 PADLOCK_XCRYPT_ASM(padlock_xcrypt_ofb, ".byte 0xf3,0x0f,0xa7,0xe8")     /* rep xcryptofb */
 464 #endif
 465
 466 /* The RNG call itself */
 467 static inline unsigned int
 468 padlock_xstore(void *addr, unsigned int edx_in)
 469 {
 470         unsigned int eax_out;
 471
 472         asm volatile (".byte 0x0f,0xa7,0xc0"    /* xstore */
 473             : "=a"(eax_out),"=m"(*(unsigned *)addr)
 474             : "D"(addr), "d" (edx_in)
 475             );
 476
 477         return eax_out;
 478 }
 479
 480 /* Why not inline 'rep movsd'? I failed to find information on what
 481  * value in Direction Flag one can expect and consequently have to
 482  * apply "better-safe-than-sorry" approach and assume "undefined."
 483  * I could explicitly clear it and restore the original value upon
 484  * return from padlock_aes_cipher, but it's presumably too much
 485  * trouble for too little gain...
 486  *
 487  * In case you wonder 'rep xcrypt*' instructions above are *not*
 488  * affected by the Direction Flag and pointers advance toward
 489  * larger addresses unconditionally.
 490  */
 491 static inline unsigned char *
 492 padlock_memcpy(void *dst,const void *src,size_t n)
 493 {
 494         long       *d=dst;
 495         const long *s=src;
 496
 497         n /= sizeof(*d);
 498         do { *d++ = *s++; } while (--n);
 499
 500         return dst;
 501 }
 502
 503 #elif defined(_MSC_VER)
 504 /*
 505  * Unlike GCC these are real functions. In order to minimize impact
 506  * on performance we adhere to __fastcall calling convention in
 507  * order to get two first arguments passed through %ecx and %edx.
 508  * Which kind of suits very well, as instructions in question use
 509  * both %ecx and %edx as input:-)
 510  */
 511 #define REP_XCRYPT(code)                \
 512         _asm _emit 0xf3                 \
 513         _asm _emit 0x0f _asm _emit 0xa7 \
 514         _asm _emit code
 515
 516 /* BIG FAT WARNING:
 517  *      The offsets used with 'lea' instructions
 518  *      describe items of the 'padlock_cipher_data'
 519  *      structure.
 520  */
 521 #define PADLOCK_XCRYPT_ASM(name,code)   \
 522 static void * __fastcall                \
 523         name (size_t cnt, void *cdata,  \
 524         void *outp, const void *inp)    \
 525 {       _asm    mov     eax,edx         \
 526         _asm    lea     edx,[eax+16]    \
 527         _asm    lea     ebx,[eax+32]    \
 528         _asm    mov     edi,outp        \
 529         _asm    mov     esi,inp         \
 530         REP_XCRYPT(code)                \
 531 }
 532
 533 PADLOCK_XCRYPT_ASM(padlock_xcrypt_ecb,0xc8)
 534 PADLOCK_XCRYPT_ASM(padlock_xcrypt_cbc,0xd0)
 535 PADLOCK_XCRYPT_ASM(padlock_xcrypt_cfb,0xe0)
 536 PADLOCK_XCRYPT_ASM(padlock_xcrypt_ofb,0xe8)
 537
 538 static int __fastcall
 539 padlock_xstore(void *outp,unsigned int code)
 540 {       _asm    mov     edi,ecx
 541         _asm _emit 0x0f _asm _emit 0xa7 _asm _emit 0xc0
 542 }
 543
 544 static void __fastcall
 545 padlock_reload_key(void)
 546 {       _asm pushfd _asm popfd          }
 547
 548 static void __fastcall
 549 padlock_verify_context(void *cdata)
 550 {       _asm    {
 551                 pushfd
 552                 bt      DWORD PTR[esp],30
 553                 jnc     skip
 554                 cmp     ecx,padlock_saved_context
 555                 je      skip
 556                 popfd
 557                 sub     esp,4
 558         skip:   add     esp,4
 559                 mov     padlock_saved_context,ecx
 560                 }
 561 }
 562
 563 static int
 564 padlock_available(void)
 565 {       _asm    {
 566                 pushfd
 567                 pop     eax
 568                 mov     ecx,eax
 569                 xor     eax,1<<21
 570                 push    eax
 571                 popfd
 572                 pushfd
 573                 pop     eax
 574                 xor     eax,ecx
 575                 bt      eax,21
 576                 jnc     noluck
 577                 mov     eax,0
 578                 cpuid
 579                 xor     eax,eax
 580                 cmp     ebx,'tneC'
 581                 jne     noluck
 582                 cmp     edx,'Hrua'
 583                 jne     noluck
 584                 cmp     ecx,'slua'
 585                 jne     noluck
 586                 mov     eax,0xC0000000
 587                 cpuid
 588                 mov     edx,eax
 589                 xor     eax,eax
 590                 cmp     edx,0xC0000001
 591                 jb      noluck
 592                 mov     eax,0xC0000001
 593                 cpuid
 594                 xor     eax,eax
 595                 bt      edx,6
 596                 jnc     skip_a
 597                 bt      edx,7
 598                 jnc     skip_a
 599                 mov     padlock_use_ace,1
 600                 inc     eax
 601         skip_a: bt      edx,2
 602                 jnc     skip_r
 603                 bt      edx,3
 604                 jnc     skip_r
 605                 mov     padlock_use_rng,1
 606                 inc     eax
 607         skip_r:
 608         noluck:
 609                 }
 610 }
 611
 612 static void __fastcall
 613 padlock_bswapl(void *key)
 614 {       _asm    {
 615                 pushfd
 616                 cld
 617                 mov     esi,ecx
 618                 mov     edi,ecx
 619                 mov     ecx,60
 620         up:     lodsd
 621                 bswap   eax
 622                 stosd
 623                 loop    up
 624                 popfd
 625                 }
 626 }
 627
 628 /* MS actually specifies status of Direction Flag and compiler even
 629  * manages to compile following as 'rep movsd' all by itself...
 630  */
 631 #define padlock_memcpy(o,i,n) ((unsigned char *)memcpy((o),(i),(n)&~3U))
 632 #endif
 633
 634 /* ===== AES encryption/decryption ===== */
 635 #ifndef OPENSSL_NO_AES
 636
 637 #if defined(NID_aes_128_cfb128) && ! defined (NID_aes_128_cfb)
 638 #define NID_aes_128_cfb NID_aes_128_cfb128
 639 #endif
 640
 641 #if defined(NID_aes_128_ofb128) && ! defined (NID_aes_128_ofb)
 642 #define NID_aes_128_ofb NID_aes_128_ofb128
 643 #endif
 644
 645 #if defined(NID_aes_192_cfb128) && ! defined (NID_aes_192_cfb)
 646 #define NID_aes_192_cfb NID_aes_192_cfb128
 647 #endif
 648
 649 #if defined(NID_aes_192_ofb128) && ! defined (NID_aes_192_ofb)
 650 #define NID_aes_192_ofb NID_aes_192_ofb128
 651 #endif
 652
 653 #if defined(NID_aes_256_cfb128) && ! defined (NID_aes_256_cfb)
 654 #define NID_aes_256_cfb NID_aes_256_cfb128
 655 #endif
 656
 657 #if defined(NID_aes_256_ofb128) && ! defined (NID_aes_256_ofb)
 658 #define NID_aes_256_ofb NID_aes_256_ofb128
 659 #endif
 660
 661 /* List of supported ciphers. */
 662 static int padlock_cipher_nids[] = {
 663         NID_aes_128_ecb,
 664         NID_aes_128_cbc,
 665         NID_aes_128_cfb,
 666         NID_aes_128_ofb,
 667
 668         NID_aes_192_ecb,
 669         NID_aes_192_cbc,
 670         NID_aes_192_cfb,
 671         NID_aes_192_ofb,
 672
 673         NID_aes_256_ecb,
 674         NID_aes_256_cbc,
 675         NID_aes_256_cfb,
 676         NID_aes_256_ofb,
 677 };
 678 static int padlock_cipher_nids_num = (sizeof(padlock_cipher_nids)/
 679                                       sizeof(padlock_cipher_nids[0]));
 680
 681 /* Function prototypes ... */
 682 static int padlock_aes_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 683                                 const unsigned char *iv, int enc);
 684 static int padlock_aes_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 685                               const unsigned char *in, size_t nbytes);
 686
 687 #define NEAREST_ALIGNED(ptr) ( (unsigned char *)(ptr) +         \
 688         ( (0x10 - ((size_t)(ptr) & 0x0F)) & 0x0F )      )
 689 #define ALIGNED_CIPHER_DATA(ctx) ((struct padlock_cipher_data *)\
 690         NEAREST_ALIGNED(ctx->cipher_data))
 691
 692 #define EVP_CIPHER_block_size_ECB       AES_BLOCK_SIZE
 693 #define EVP_CIPHER_block_size_CBC       AES_BLOCK_SIZE
 694 #define EVP_CIPHER_block_size_OFB       1
 695 #define EVP_CIPHER_block_size_CFB       1
 696
 697 /* Declaring so many ciphers by hand would be a pain.
 698    Instead introduce a bit of preprocessor magic :-) */
 699 #define DECLARE_AES_EVP(ksize,lmode,umode)      \
 700 static const EVP_CIPHER padlock_aes_##ksize##_##lmode = {       \
 701         NID_aes_##ksize##_##lmode,              \
 702         EVP_CIPHER_block_size_##umode,  \
 703         AES_KEY_SIZE_##ksize,           \
 704         AES_BLOCK_SIZE,                 \
 705         0 | EVP_CIPH_##umode##_MODE,    \
 706         padlock_aes_init_key,           \
 707         padlock_aes_cipher,             \
 708         NULL,                           \
 709         sizeof(struct padlock_cipher_data) + 16,        \
 710         EVP_CIPHER_set_asn1_iv,         \
 711         EVP_CIPHER_get_asn1_iv,         \
 712         NULL,                           \
 713         NULL                            \
 714 }
 715
 716 DECLARE_AES_EVP(128,ecb,ECB);
 717 DECLARE_AES_EVP(128,cbc,CBC);
 718 DECLARE_AES_EVP(128,cfb,CFB);
 719 DECLARE_AES_EVP(128,ofb,OFB);
 720
 721 DECLARE_AES_EVP(192,ecb,ECB);
 722 DECLARE_AES_EVP(192,cbc,CBC);
 723 DECLARE_AES_EVP(192,cfb,CFB);
 724 DECLARE_AES_EVP(192,ofb,OFB);
 725
 726 DECLARE_AES_EVP(256,ecb,ECB);
 727 DECLARE_AES_EVP(256,cbc,CBC);
 728 DECLARE_AES_EVP(256,cfb,CFB);
 729 DECLARE_AES_EVP(256,ofb,OFB);
 730
 731 static int
 732 padlock_ciphers (ENGINE *e, const EVP_CIPHER **cipher, const int **nids, int nid)
 733 {
 734         /* No specific cipher => return a list of supported nids ... */
 735         if (!cipher) {
 736                 *nids = padlock_cipher_nids;
 737                 return padlock_cipher_nids_num;
 738         }
 739
 740         /* ... or the requested "cipher" otherwise */
 741         switch (nid) {
 742           case NID_aes_128_ecb:
 743             *cipher = &padlock_aes_128_ecb;
 744             break;
 745           case NID_aes_128_cbc:
 746             *cipher = &padlock_aes_128_cbc;
 747             break;
 748           case NID_aes_128_cfb:
 749             *cipher = &padlock_aes_128_cfb;
 750             break;
 751           case NID_aes_128_ofb:
 752             *cipher = &padlock_aes_128_ofb;
 753             break;
 754
 755           case NID_aes_192_ecb:
 756             *cipher = &padlock_aes_192_ecb;
 757             break;
 758           case NID_aes_192_cbc:
 759             *cipher = &padlock_aes_192_cbc;
 760             break;
 761           case NID_aes_192_cfb:
 762             *cipher = &padlock_aes_192_cfb;
 763             break;
 764           case NID_aes_192_ofb:
 765             *cipher = &padlock_aes_192_ofb;
 766             break;
 767
 768           case NID_aes_256_ecb:
 769             *cipher = &padlock_aes_256_ecb;
 770             break;
 771           case NID_aes_256_cbc:
 772             *cipher = &padlock_aes_256_cbc;
 773             break;
 774           case NID_aes_256_cfb:
 775             *cipher = &padlock_aes_256_cfb;
 776             break;
 777           case NID_aes_256_ofb:
 778             *cipher = &padlock_aes_256_ofb;
 779             break;
 780
 781           default:
 782             /* Sorry, we don't support this NID */
 783             *cipher = NULL;
 784             return 0;
 785         }
 786
 787         return 1;
 788 }
 789
 790 /* Prepare the encryption key for PadLock usage */
 791 static int
 792 padlock_aes_init_key (EVP_CIPHER_CTX *ctx, const unsigned char *key,
 793                       const unsigned char *iv, int enc)
 794 {
 795         struct padlock_cipher_data *cdata;
 796         int key_len = EVP_CIPHER_CTX_key_length(ctx) * 8;
 797
 798         if (key==NULL) return 0;        /* ERROR */
 799
 800         cdata = ALIGNED_CIPHER_DATA(ctx);
 801         memset(cdata, 0, sizeof(struct padlock_cipher_data));
 802
 803         /* Prepare Control word. */
 804         if (EVP_CIPHER_CTX_mode(ctx) == EVP_CIPH_OFB_MODE)
 805                 cdata->cword.b.encdec = 0;
 806         else
 807                 cdata->cword.b.encdec = (ctx->encrypt == 0);
 808         cdata->cword.b.rounds = 10 + (key_len - 128) / 32;
 809         cdata->cword.b.ksize = (key_len - 128) / 64;
 810
 811         switch(key_len) {
 812                 case 128:
 813                         /* PadLock can generate an extended key for
 814                            AES128 in hardware */
 815                         memcpy(cdata->ks.rd_key, key, AES_KEY_SIZE_128);
 816                         cdata->cword.b.keygen = 0;
 817                         break;
 818
 819                 case 192:
 820                 case 256:
 821                         /* Generate an extended AES key in software.
 822                            Needed for AES192/AES256 */
 823                         /* Well, the above applies to Stepping 8 CPUs
 824                            and is listed as hardware errata. They most
 825                            likely will fix it at some point and then
 826                            a check for stepping would be due here. */
 827                         if (EVP_CIPHER_CTX_mode(ctx) == EVP_CIPH_CFB_MODE ||
 828                             EVP_CIPHER_CTX_mode(ctx) == EVP_CIPH_OFB_MODE ||
 829                             enc)
 830                                 AES_set_encrypt_key(key, key_len, &cdata->ks);
 831                         else
 832                                 AES_set_decrypt_key(key, key_len, &cdata->ks);
 833 #ifndef AES_ASM
 834                         /* OpenSSL C functions use byte-swapped extended key. */
 835                         padlock_bswapl(&cdata->ks);
 836 #endif
 837                         cdata->cword.b.keygen = 1;
 838                         break;
 839
 840                 default:
 841                         /* ERROR */
 842                         return 0;
 843         }
 844
 845         /*
 846          * This is done to cover for cases when user reuses the
 847          * context for new key. The catch is that if we don't do
 848          * this, padlock_eas_cipher might proceed with old key...
 849          */
 850         padlock_reload_key ();
 851
 852         return 1;
 853 }
 854
 855 /*
 856  * Simplified version of padlock_aes_cipher() used when
 857  * 1) both input and output buffers are at aligned addresses.
 858  * or when
 859  * 2) running on a newer CPU that doesn't require aligned buffers.
 860  */
 861 static int
 862 padlock_aes_cipher_omnivorous(EVP_CIPHER_CTX *ctx, unsigned char *out_arg,
 863                 const unsigned char *in_arg, size_t nbytes)
 864 {
 865         struct padlock_cipher_data *cdata;
 866         void  *iv;
 867
 868         cdata = ALIGNED_CIPHER_DATA(ctx);
 869         padlock_verify_context(cdata);
 870
 871         switch (EVP_CIPHER_CTX_mode(ctx)) {
 872         case EVP_CIPH_ECB_MODE:
 873                 padlock_xcrypt_ecb(nbytes/AES_BLOCK_SIZE, cdata, out_arg, in_arg);
 874                 break;
 875
 876         case EVP_CIPH_CBC_MODE:
 877                 memcpy(cdata->iv, ctx->iv, AES_BLOCK_SIZE);
 878                 iv = padlock_xcrypt_cbc(nbytes/AES_BLOCK_SIZE, cdata, out_arg, in_arg);
 879                 memcpy(ctx->iv, iv, AES_BLOCK_SIZE);
 880                 break;
 881
 882         case EVP_CIPH_CFB_MODE:
 883                 memcpy(cdata->iv, ctx->iv, AES_BLOCK_SIZE);
 884                 iv = padlock_xcrypt_cfb(nbytes/AES_BLOCK_SIZE, cdata, out_arg, in_arg);
 885                 memcpy(ctx->iv, iv, AES_BLOCK_SIZE);
 886                 break;
 887
 888         case EVP_CIPH_OFB_MODE:
 889                 memcpy(cdata->iv, ctx->iv, AES_BLOCK_SIZE);
 890                 padlock_xcrypt_ofb(nbytes/AES_BLOCK_SIZE, cdata, out_arg, in_arg);
 891                 memcpy(ctx->iv, cdata->iv, AES_BLOCK_SIZE);
 892                 break;
 893
 894         default:
 895                 return 0;
 896         }
 897
 898         memset(cdata->iv, 0, AES_BLOCK_SIZE);
 899
 900         return 1;
 901 }
 902
 903 #ifndef  PADLOCK_CHUNK
 904 # define PADLOCK_CHUNK  512     /* Must be a power of 2 larger than 16 */
 905 #endif
 906 #if PADLOCK_CHUNK<16 || PADLOCK_CHUNK&(PADLOCK_CHUNK-1)
 907 # error "insane PADLOCK_CHUNK..."
 908 #endif
 909
 910 /* Re-align the arguments to 16-Bytes boundaries and run the
 911    encryption function itself. This function is not AES-specific. */
 912 static int
 913 padlock_aes_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out_arg,
 914                    const unsigned char *in_arg, size_t nbytes)
 915 {
 916         struct padlock_cipher_data *cdata;
 917         const  void *inp;
 918         unsigned char  *out;
 919         void  *iv;
 920         int    inp_misaligned, out_misaligned, realign_in_loop;
 921         size_t chunk, allocated=0;
 922
 923         /* ctx->num is maintained in byte-oriented modes,
 924            such as CFB and OFB... */
 925         if ((chunk = ctx->num)) { /* borrow chunk variable */
 926                 unsigned char *ivp=ctx->iv;
 927
 928                 switch (EVP_CIPHER_CTX_mode(ctx)) {
 929                 case EVP_CIPH_CFB_MODE:
 930                         if (chunk >= AES_BLOCK_SIZE)
 931                                 return 0; /* bogus value */
 932
 933                         if (ctx->encrypt)
 934                                 while (chunk<AES_BLOCK_SIZE && nbytes!=0) {
 935                                         ivp[chunk] = *(out_arg++) = *(in_arg++) ^ ivp[chunk];
 936                                         chunk++, nbytes--;
 937                                 }
 938                         else    while (chunk<AES_BLOCK_SIZE && nbytes!=0) {
 939                                         unsigned char c = *(in_arg++);
 940                                         *(out_arg++) = c ^ ivp[chunk];
 941                                         ivp[chunk++] = c, nbytes--;
 942                                 }
 943
 944                         ctx->num = chunk%AES_BLOCK_SIZE;
 945                         break;
 946                 case EVP_CIPH_OFB_MODE:
 947                         if (chunk >= AES_BLOCK_SIZE)
 948                                 return 0; /* bogus value */
 949
 950                         while (chunk<AES_BLOCK_SIZE && nbytes!=0) {
 951                                 *(out_arg++) = *(in_arg++) ^ ivp[chunk];
 952                                 chunk++, nbytes--;
 953                         }
 954
 955                         ctx->num = chunk%AES_BLOCK_SIZE;
 956                         break;
 957                 }
 958         }
 959
 960         if (nbytes == 0)
 961                 return 1;
 962 #if 0
 963         if (nbytes % AES_BLOCK_SIZE)
 964                 return 0; /* are we expected to do tail processing? */
 965 #else
 966         /* nbytes is always multiple of AES_BLOCK_SIZE in ECB and CBC
 967            modes and arbitrary value in byte-oriented modes, such as
 968            CFB and OFB... */
 969 #endif
 970
 971         /* VIA promises CPUs that won't require alignment in the future.
 972            For now padlock_aes_align_required is initialized to 1 and
 973            the condition is never met... */
 974         /* C7 core is capable to manage unaligned input in non-ECB[!]
 975            mode, but performance penalties appear to be approximately
 976            same as for software alignment below or ~3x. They promise to
 977            improve it in the future, but for now we can just as well
 978            pretend that it can only handle aligned input... */
 979         if (!padlock_aes_align_required && (nbytes%AES_BLOCK_SIZE)==0)
 980                 return padlock_aes_cipher_omnivorous(ctx, out_arg, in_arg, nbytes);
 981
 982         inp_misaligned = (((size_t)in_arg) & 0x0F);
 983         out_misaligned = (((size_t)out_arg) & 0x0F);
 984
 985         /* Note that even if output is aligned and input not,
 986          * I still prefer to loop instead of copy the whole
 987          * input and then encrypt in one stroke. This is done
 988          * in order to improve L1 cache utilization... */
 989         realign_in_loop = out_misaligned|inp_misaligned;
 990
 991         if (!realign_in_loop && (nbytes%AES_BLOCK_SIZE)==0)
 992                 return padlock_aes_cipher_omnivorous(ctx, out_arg, in_arg, nbytes);
 993
 994         /* this takes one "if" out of the loops */
 995         chunk  = nbytes;
 996         chunk %= PADLOCK_CHUNK;
 997         if (chunk==0) chunk = PADLOCK_CHUNK;
 998
 999         if (out_misaligned) {
1000                 /* optmize for small input */
1001                 allocated = (chunk<nbytes?PADLOCK_CHUNK:nbytes);
1002                 out = alloca(0x10 + allocated);
1003                 out = NEAREST_ALIGNED(out);
1004         }
1005         else
1006                 out = out_arg;
1007
1008         cdata = ALIGNED_CIPHER_DATA(ctx);
1009         padlock_verify_context(cdata);
1010
1011         switch (EVP_CIPHER_CTX_mode(ctx)) {
1012         case EVP_CIPH_ECB_MODE:
1013                 do      {
1014                         if (inp_misaligned)
1015                                 inp = padlock_memcpy(out, in_arg, chunk);
1016                         else
1017                                 inp = in_arg;
1018                         in_arg += chunk;
1019
1020                         padlock_xcrypt_ecb(chunk/AES_BLOCK_SIZE, cdata, out, inp);
1021
1022                         if (out_misaligned)
1023                                 out_arg = padlock_memcpy(out_arg, out, chunk) + chunk;
1024                         else
1025                                 out     = out_arg+=chunk;
1026
1027                         nbytes -= chunk;
1028                         chunk   = PADLOCK_CHUNK;
1029                 } while (nbytes);
1030                 break;
1031
1032         case EVP_CIPH_CBC_MODE:
1033                 memcpy(cdata->iv, ctx->iv, AES_BLOCK_SIZE);
1034                 goto cbc_shortcut;
1035                 do      {
1036                         if (iv != cdata->iv)
1037                                 memcpy(cdata->iv, iv, AES_BLOCK_SIZE);
1038                         chunk = PADLOCK_CHUNK;
1039                 cbc_shortcut: /* optimize for small input */
1040                         if (inp_misaligned)
1041                                 inp = padlock_memcpy(out, in_arg, chunk);
1042                         else
1043                                 inp = in_arg;
1044                         in_arg += chunk;
1045
1046                         iv = padlock_xcrypt_cbc(chunk/AES_BLOCK_SIZE, cdata, out, inp);
1047
1048                         if (out_misaligned)
1049                                 out_arg = padlock_memcpy(out_arg, out, chunk) + chunk;
1050                         else
1051                                 out     = out_arg+=chunk;
1052
1053                 } while (nbytes -= chunk);
1054                 memcpy(ctx->iv, iv, AES_BLOCK_SIZE);
1055                 break;
1056
1057         case EVP_CIPH_CFB_MODE:
1058                 memcpy (iv = cdata->iv, ctx->iv, AES_BLOCK_SIZE);
1059                 chunk &= ~(AES_BLOCK_SIZE-1);
1060                 if (chunk)      goto cfb_shortcut;
1061                 else            goto cfb_skiploop;
1062                 do      {
1063                         if (iv != cdata->iv)
1064                                 memcpy(cdata->iv, iv, AES_BLOCK_SIZE);
1065                         chunk = PADLOCK_CHUNK;
1066                 cfb_shortcut: /* optimize for small input */
1067                         if (inp_misaligned)
1068                                 inp = padlock_memcpy(out, in_arg, chunk);
1069                         else
1070                                 inp = in_arg;
1071                         in_arg += chunk;
1072
1073                         iv = padlock_xcrypt_cfb(chunk/AES_BLOCK_SIZE, cdata, out, inp);
1074
1075                         if (out_misaligned)
1076                                 out_arg = padlock_memcpy(out_arg, out, chunk) + chunk;
1077                         else
1078                                 out     = out_arg+=chunk;
1079
1080                         nbytes -= chunk;
1081                 } while (nbytes >= AES_BLOCK_SIZE);
1082
1083                 cfb_skiploop:
1084                 if (nbytes) {
1085                         unsigned char *ivp = cdata->iv;
1086
1087                         if (iv != ivp) {
1088                                 memcpy(ivp, iv, AES_BLOCK_SIZE);
1089                                 iv = ivp;
1090                         }
1091                         ctx->num = nbytes;
1092                         if (cdata->cword.b.encdec) {
1093                                 cdata->cword.b.encdec=0;
1094                                 padlock_reload_key();
1095                                 padlock_xcrypt_ecb(1,cdata,ivp,ivp);
1096                                 cdata->cword.b.encdec=1;
1097                                 padlock_reload_key();
1098                                 while(nbytes) {
1099                                         unsigned char c = *(in_arg++);
1100                                         *(out_arg++) = c ^ *ivp;
1101                                         *(ivp++) = c, nbytes--;
1102                                 }
1103                         }
1104                         else {  padlock_reload_key();
1105                                 padlock_xcrypt_ecb(1,cdata,ivp,ivp);
1106                                 padlock_reload_key();
1107                                 while (nbytes) {
1108                                         *ivp = *(out_arg++) = *(in_arg++) ^ *ivp;
1109                                         ivp++, nbytes--;
1110                                 }
1111                         }
1112                 }
1113
1114                 memcpy(ctx->iv, iv, AES_BLOCK_SIZE);
1115                 break;
1116
1117         case EVP_CIPH_OFB_MODE:
1118                 memcpy(cdata->iv, ctx->iv, AES_BLOCK_SIZE);
1119                 chunk &= ~(AES_BLOCK_SIZE-1);
1120                 if (chunk) do   {
1121                         if (inp_misaligned)
1122                                 inp = padlock_memcpy(out, in_arg, chunk);
1123                         else
1124                                 inp = in_arg;
1125                         in_arg += chunk;
1126
1127                         padlock_xcrypt_ofb(chunk/AES_BLOCK_SIZE, cdata, out, inp);
1128
1129                         if (out_misaligned)
1130                                 out_arg = padlock_memcpy(out_arg, out, chunk) + chunk;
1131                         else
1132                                 out     = out_arg+=chunk;
1133
1134                         nbytes -= chunk;
1135                         chunk   = PADLOCK_CHUNK;
1136                 } while (nbytes >= AES_BLOCK_SIZE);
1137
1138                 if (nbytes) {
1139                         unsigned char *ivp = cdata->iv;
1140
1141                         ctx->num = nbytes;
1142                         padlock_reload_key();   /* empirically found */
1143                         padlock_xcrypt_ecb(1,cdata,ivp,ivp);
1144                         padlock_reload_key();   /* empirically found */
1145                         while (nbytes) {
1146                                 *(out_arg++) = *(in_arg++) ^ *ivp;
1147                                 ivp++, nbytes--;
1148                         }
1149                 }
1150
1151                 memcpy(ctx->iv, cdata->iv, AES_BLOCK_SIZE);
1152                 break;
1153
1154         default:
1155                 return 0;
1156         }
1157
1158         /* Clean the realign buffer if it was used */
1159         if (out_misaligned) {
1160                 volatile unsigned long *p=(void *)out;
1161                 size_t   n = allocated/sizeof(*p);
1162                 while (n--) *p++=0;
1163         }
1164
1165         memset(cdata->iv, 0, AES_BLOCK_SIZE);
1166
1167         return 1;
1168 }
1169
1170 #endif /* OPENSSL_NO_AES */
1171
1172 /* ===== Random Number Generator ===== */
1173 /*
1174  * This code is not engaged. The reason is that it does not comply
1175  * with recommendations for VIA RNG usage for secure applications
1176  * (posted at http://www.via.com.tw/en/viac3/c3.jsp) nor does it
1177  * provide meaningful error control...
1178  */
1179 /* Wrapper that provides an interface between the API and
1180    the raw PadLock RNG */
1181 static int
1182 padlock_rand_bytes(unsigned char *output, int count)
1183 {
1184         unsigned int eax, buf;
1185
1186         while (count >= 8) {
1187                 eax = padlock_xstore(output, 0);
1188                 if (!(eax&(1<<6)))      return 0; /* RNG disabled */
1189                 /* this ---vv--- covers DC bias, Raw Bits and String Filter */
1190                 if (eax&(0x1F<<10))     return 0;
1191                 if ((eax&0x1F)==0)      continue; /* no data, retry... */
1192                 if ((eax&0x1F)!=8)      return 0; /* fatal failure...  */
1193                 output += 8;
1194                 count  -= 8;
1195         }
1196         while (count > 0) {
1197                 eax = padlock_xstore(&buf, 3);
1198                 if (!(eax&(1<<6)))      return 0; /* RNG disabled */
1199                 /* this ---vv--- covers DC bias, Raw Bits and String Filter */
1200                 if (eax&(0x1F<<10))     return 0;
1201                 if ((eax&0x1F)==0)      continue; /* no data, retry... */
1202                 if ((eax&0x1F)!=1)      return 0; /* fatal failure...  */
1203                 *output++ = (unsigned char)buf;
1204                 count--;
1205         }
1206         *(volatile unsigned int *)&buf=0;
1207
1208         return 1;
1209 }
1210
1211 /* Dummy but necessary function */
1212 static int
1213 padlock_rand_status(void)
1214 {
1215         return 1;
1216 }
1217
1218 /* Prepare structure for registration */
1219 static RAND_METHOD padlock_rand = {
1220         NULL,                   /* seed */
1221         padlock_rand_bytes,     /* bytes */
1222         NULL,                   /* cleanup */
1223         NULL,                   /* add */
1224         padlock_rand_bytes,     /* pseudorand */
1225         padlock_rand_status,    /* rand status */
1226 };
1227
1228 #else  /* !COMPILE_HW_PADLOCK */
1229 #ifndef OPENSSL_NO_DYNAMIC_ENGINE
1230 OPENSSL_EXPORT
1231 int bind_engine(ENGINE *e, const char *id, const dynamic_fns *fns);
1232 OPENSSL_EXPORT
1233 int bind_engine(ENGINE *e, const char *id, const dynamic_fns *fns) { return 0; }
1234 IMPLEMENT_DYNAMIC_CHECK_FN()
1235 #endif
1236 #endif /* COMPILE_HW_PADLOCK */
1237
1238 #endif /* !OPENSSL_NO_HW_PADLOCK */
1239 #endif /* !OPENSSL_NO_HW */