开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 其他游戏 > 查看源码
eng_padlock.c
资源名称：wow-313-source.rar　[点击查看]
上传用户：yisoukefu
上传日期：2020-08-09
资源大小：39506k
文件大小：31k
源码类别：

其他游戏

开发平台：

Visual C++

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