/* 

 * Support for VIA PadLock Advanced Cryptography Engine (ACE)

 * Written by Michal Ludvig <michal@logix.cz>

 *            http://www.logix.cz/michal

 *

 * Big thanks to Andy Polyakov for a help with optimization, 

 * assembler fixes, port to MS Windows and a lot of other 

 * valuable work on this engine!

 */

/* ====================================================================

 * Copyright (c) 1999-2001 The OpenSSL Project.  All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 *

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 *

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in

 *    the documentation and/or other materials provided with the

 *    distribution.

 *

 * 3. All advertising materials mentioning features or use of this

 *    software must display the following acknowledgment:

 *    "This product includes software developed by the OpenSSL Project

 *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"

 *

 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to

 *    endorse or promote products derived from this software without

 *    prior written permission. For written permission, please contact

 *    licensing@OpenSSL.org.

 *

 * 5. Products derived from this software may not be called "OpenSSL"

 *    nor may "OpenSSL" appear in their names without prior written

 *    permission of the OpenSSL Project.

 *

 * 6. Redistributions of any form whatsoever must retain the following

 *    acknowledgment:

 *    "This product includes software developed by the OpenSSL Project

 *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"

 *

 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY

 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR

 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,

 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED

 * OF THE POSSIBILITY OF SUCH DAMAGE.

 * ====================================================================

 *

 * This product includes cryptographic software written by Eric Young

 * (eay@cryptsoft.com).  This product includes software written by Tim

 * Hudson (tjh@cryptsoft.com).

 *

 */

#include <stdio.h>

#include <string.h>

#include <openssl/opensslconf.h>

#include <openssl/crypto.h>

#include <openssl/dso.h>

#include <openssl/engine.h>

#include <openssl/evp.h>

#ifndef OPENSSL_NO_AES

#include <openssl/aes.h>

#endif

#include <openssl/rand.h>

#include <openssl/err.h>

#ifndef OPENSSL_NO_HW

#ifndef OPENSSL_NO_HW_PADLOCK

/* Attempt to have a single source for both 0.9.7 and 0.9.8 :-) */

#if (OPENSSL_VERSION_NUMBER >= 0x00908000L)

#  ifndef OPENSSL_NO_DYNAMIC_ENGINE

#    define DYNAMIC_ENGINE

#  endif

#elif (OPENSSL_VERSION_NUMBER >= 0x00907000L)

#  ifdef ENGINE_DYNAMIC_SUPPORT

#    define DYNAMIC_ENGINE

#  endif

#else

#  error "Only OpenSSL >= 0.9.7 is supported"

#endif

/* VIA PadLock AES is available *ONLY* on some x86 CPUs.

   Not only that it doesn't exist elsewhere, but it

   even can't be compiled on other platforms!

   In addition, because of the heavy use of inline assembler,

   compiler choice is limited to GCC and Microsoft C. */

#undef COMPILE_HW_PADLOCK

#if !defined(I386_ONLY) && !defined(OPENSSL_NO_INLINE_ASM)

# if (defined(__GNUC__) && (defined(__i386__) || defined(__i386))) || \

     (defined(_MSC_VER) && defined(_M_IX86))

#  define COMPILE_HW_PADLOCK

static ENGINE *ENGINE_padlock (void);

# endif

#endif

EXPORT_C void ENGINE_load_padlock (void)

{

/* On non-x86 CPUs it just returns. */

#ifdef COMPILE_HW_PADLOCK

	ENGINE *toadd = ENGINE_padlock ();

	if (!toadd) return;

	ENGINE_add (toadd);

	ENGINE_free (toadd);

	ERR_clear_error ();

#endif

}

#ifdef COMPILE_HW_PADLOCK

/* We do these includes here to avoid header problems on platforms that

   do not have the VIA padlock anyway... */

#ifdef _MSC_VER

# include <malloc.h>

# define alloca _alloca

#else

# include <stdlib.h>

#endif

/* Function for ENGINE detection and control */

static int padlock_available(void);

static int padlock_init(ENGINE *e);

/* RNG Stuff */

static RAND_METHOD padlock_rand;

/* Cipher Stuff */

#ifndef OPENSSL_NO_AES

static int padlock_ciphers(ENGINE *e, const EVP_CIPHER **cipher, const int **nids, int nid);

#endif

/* Engine names */

static const char *padlock_id = "padlock";

static char padlock_name[100];

/* Available features */

static int padlock_use_ace = 0;	/* Advanced Cryptography Engine */

static int padlock_use_rng = 0;	/* Random Number Generator */

#ifndef OPENSSL_NO_AES

static int padlock_aes_align_required = 1;

#endif

/* ===== Engine "management" functions ===== */

/* Prepare the ENGINE structure for registration */

static int

padlock_bind_helper(ENGINE *e)

{

	/* Check available features */

	padlock_available();

#if 1	/* disable RNG for now, see commentary in vicinity of RNG code */

	padlock_use_rng=0;

#endif

	/* Generate a nice engine name with available features */

	BIO_snprintf(padlock_name, sizeof(padlock_name),

		"VIA PadLock (%s, %s)", 

		 padlock_use_rng ? "RNG" : "no-RNG",

		 padlock_use_ace ? "ACE" : "no-ACE");

	/* Register everything or return with an error */ 

	if (!ENGINE_set_id(e, padlock_id) ||

	    !ENGINE_set_name(e, padlock_name) ||

	    !ENGINE_set_init_function(e, padlock_init) ||

#ifndef OPENSSL_NO_AES

	    (padlock_use_ace && !ENGINE_set_ciphers (e, padlock_ciphers)) ||

#endif

	    (padlock_use_rng && !ENGINE_set_RAND (e, &padlock_rand))) {

		return 0;

	}

	/* Everything looks good */

	return 1;

}

/* Constructor */

static ENGINE *

ENGINE_padlock(void)

{

	ENGINE *eng = ENGINE_new();

	if (!eng) {

		return NULL;

	}

	if (!padlock_bind_helper(eng)) {

		ENGINE_free(eng);

		return NULL;

	}

	return eng;

}

/* Check availability of the engine */

static int

padlock_init(ENGINE *e)

{

	return (padlock_use_rng || padlock_use_ace);

}

/* This stuff is needed if this ENGINE is being compiled into a self-contained

 * shared-library.

 */

#ifdef DYNAMIC_ENGINE

static int

padlock_bind_fn(ENGINE *e, const char *id)

{

	if (id && (strcmp(id, padlock_id) != 0)) {

		return 0;

	}

	if (!padlock_bind_helper(e))  {

		return 0;

	}

	return 1;

}

IMPLEMENT_DYNAMIC_CHECK_FN ();

IMPLEMENT_DYNAMIC_BIND_FN (padlock_bind_fn);

#endif /* DYNAMIC_ENGINE */

/* ===== Here comes the "real" engine ===== */

#ifndef OPENSSL_NO_AES

/* Some AES-related constants */

#define AES_BLOCK_SIZE		16

#define AES_KEY_SIZE_128	16

#define AES_KEY_SIZE_192	24

#define AES_KEY_SIZE_256	32

/* Here we store the status information relevant to the 

   current context. */

/* BIG FAT WARNING:

 * 	Inline assembler in PADLOCK_XCRYPT_ASM()

 * 	depends on the order of items in this structure.

 * 	Don't blindly modify, reorder, etc!

 */

struct padlock_cipher_data

{

	unsigned char iv[AES_BLOCK_SIZE];	/* Initialization vector */

	union {	unsigned int pad[4];

		struct {

			int rounds:4;

			int dgst:1;	/* n/a in C3 */

			int align:1;	/* n/a in C3 */

			int ciphr:1;	/* n/a in C3 */

			unsigned int keygen:1;

			int interm:1;

			unsigned int encdec:1;

			int ksize:2;

		} b;

	} cword;		/* Control word */

	AES_KEY ks;		/* Encryption key */

};

/*

 * Essentially this variable belongs in thread local storage.

 * Having this variable global on the other hand can only cause

 * few bogus key reloads [if any at all on single-CPU system],

 * so we accept the penatly...

 */

static volatile struct padlock_cipher_data *padlock_saved_context;

#endif

/*

 * =======================================================

 * Inline assembler section(s).

 * =======================================================

 * Order of arguments is chosen to facilitate Windows port

 * using __fastcall calling convention. If you wish to add

 * more routines, keep in mind that first __fastcall

 * argument is passed in %ecx and second - in %edx.

 * =======================================================

 */

#if defined(__GNUC__) && __GNUC__>=2

/*

 * As for excessive "push %ebx"/"pop %ebx" found all over.

 * When generating position-independent code GCC won't let

 * us use "b" in assembler templates nor even respect "ebx"

 * in "clobber description." Therefore the trouble...

 */

/* Helper function - check if a CPUID instruction

   is available on this CPU */

static int

padlock_insn_cpuid_available(void)

{

	int result = -1;

	/* We're checking if the bit #21 of EFLAGS 

	   can be toggled. If yes = CPUID is available. */

	asm volatile (

		"pushf\n"

		"popl %%eax\n"

		"xorl $0x200000, %%eax\n"

		"movl %%eax, %%ecx\n"

		"andl $0x200000, %%ecx\n"

		"pushl %%eax\n"

		"popf\n"

		"pushf\n"

		"popl %%eax\n"

		"andl $0x200000, %%eax\n"

		"xorl %%eax, %%ecx\n"

		"movl %%ecx, %0\n"

		: "=r" (result) : : "eax", "ecx");

	return (result == 0);

}

/* Load supported features of the CPU to see if

   the PadLock is available. */

static int

padlock_available(void)

{

	char vendor_string[16];

	unsigned int eax, edx;

	/* First check if the CPUID instruction is available at all... */

	if (! padlock_insn_cpuid_available())

		return 0;

	/* Are we running on the Centaur (VIA) CPU? */

	eax = 0x00000000;

	vendor_string[12] = 0;

	asm volatile (

		"pushl	%%ebx\n"

		"cpuid\n"

		"movl	%%ebx,(%%edi)\n"

		"movl	%%edx,4(%%edi)\n"

		"movl	%%ecx,8(%%edi)\n"

		"popl	%%ebx"

		: "+a"(eax) : "D"(vendor_string) : "ecx", "edx");

	if (strcmp(vendor_string, "CentaurHauls") != 0)

		return 0;

	/* Check for Centaur Extended Feature Flags presence */

	eax = 0xC0000000;

	asm volatile ("pushl %%ebx; cpuid; popl	%%ebx"

		: "+a"(eax) : : "ecx", "edx");

	if (eax < 0xC0000001)

		return 0;

	/* Read the Centaur Extended Feature Flags */

	eax = 0xC0000001;

	asm volatile ("pushl %%ebx; cpuid; popl %%ebx"

		: "+a"(eax), "=d"(edx) : : "ecx");

	/* Fill up some flags */

	padlock_use_ace = ((edx & (0x3<<6)) == (0x3<<6));

	padlock_use_rng = ((edx & (0x3<<2)) == (0x3<<2));

	return padlock_use_ace + padlock_use_rng;

}

#ifndef OPENSSL_NO_AES

/* Our own htonl()/ntohl() */

static inline void

padlock_bswapl(AES_KEY *ks)

{

	size_t i = sizeof(ks->rd_key)/sizeof(ks->rd_key[0]);

	unsigned int *key = ks->rd_key;

	while (i--) {

		asm volatile ("bswapl %0" : "+r"(*key));

		key++;

	}

}

#endif

/* Force key reload from memory to the CPU microcode.

   Loading EFLAGS from the stack clears EFLAGS[30] 

   which does the trick. */

static inline void

padlock_reload_key(void)

{

	asm volatile ("pushfl; popfl");

}

#ifndef OPENSSL_NO_AES

/*

 * This is heuristic key context tracing. At first one

 * believes that one should use atomic swap instructions,

 * but it's not actually necessary. Point is that if

 * padlock_saved_context was changed by another thread

 * after we've read it and before we compare it with cdata,

 * our key *shall* be reloaded upon thread context switch

 * and we are therefore set in either case...

 */

static inline void

padlock_verify_context(struct padlock_cipher_data *cdata)

{

	asm volatile (

	"pushfl\n"

"	btl	$30,(%%esp)\n"

"	jnc	1f\n"

"	cmpl	%2,%1\n"

"	je	1f\n"

"	popfl\n"

"	subl	$4,%%esp\n"

"1:	addl	$4,%%esp\n"

"	movl	%2,%0"

	:"+m"(padlock_saved_context)

	: "r"(padlock_saved_context), "r"(cdata) : "cc");

}

/* Template for padlock_xcrypt_* modes */

/* BIG FAT WARNING: 

 * 	The offsets used with 'leal' instructions

 * 	describe items of the 'padlock_cipher_data'

 * 	structure.

 */

#define PADLOCK_XCRYPT_ASM(name,rep_xcrypt)	\

static inline void *name(size_t cnt,		\

	struct padlock_cipher_data *cdata,	\

	void *out, const void *inp) 		\

{	void *iv; 				\

	asm volatile ( "pushl	%%ebx\n"	\

		"	leal	16(%0),%%edx\n"	\

		"	leal	32(%0),%%ebx\n"	\

			rep_xcrypt "\n"		\

		"	popl	%%ebx"		\

		: "=a"(iv), "=c"(cnt), "=D"(out), "=S"(inp) \

		: "0"(cdata), "1"(cnt), "2"(out), "3"(inp) \

		: "edx", "cc", "memory");	\

	return iv;				\

}

/* Generate all functions with appropriate opcodes */

PADLOCK_XCRYPT_ASM(padlock_xcrypt_ecb, ".byte 0xf3,0x0f,0xa7,0xc8")	/* rep xcryptecb */

PADLOCK_XCRYPT_ASM(padlock_xcrypt_cbc, ".byte 0xf3,0x0f,0xa7,0xd0")	/* rep xcryptcbc */

PADLOCK_XCRYPT_ASM(padlock_xcrypt_cfb, ".byte 0xf3,0x0f,0xa7,0xe0")	/* rep xcryptcfb */

PADLOCK_XCRYPT_ASM(padlock_xcrypt_ofb, ".byte 0xf3,0x0f,0xa7,0xe8")	/* rep xcryptofb */

#endif

/* The RNG call itself */

static inline unsigned int

padlock_xstore(void *addr, unsigned int edx_in)

{

	unsigned int eax_out;

	asm volatile (".byte 0x0f,0xa7,0xc0"	/* xstore */

	    : "=a"(eax_out),"=m"(*(unsigned *)addr)

	    : "D"(addr), "d" (edx_in)

	    );

	return eax_out;

}

/* Why not inline 'rep movsd'? I failed to find information on what

 * value in Direction Flag one can expect and consequently have to

 * apply "better-safe-than-sorry" approach and assume "undefined."

 * I could explicitly clear it and restore the original value upon

 * return from padlock_aes_cipher, but it's presumably too much

 * trouble for too little gain...

 *

 * In case you wonder 'rep xcrypt*' instructions above are *not*

 * affected by the Direction Flag and pointers advance toward

 * larger addresses unconditionally.

 */ 

static inline unsigned char *

padlock_memcpy(void *dst,const void *src,size_t n)

{

	long       *d=dst;

	const long *s=src;

	n /= sizeof(*d);

	do { *d++ = *s++; } while (--n);

	return dst;

}

#elif defined(_MSC_VER)

/*

 * Unlike GCC these are real functions. In order to minimize impact

 * on performance we adhere to __fastcall calling convention in

 * order to get two first arguments passed through %ecx and %edx.

 * Which kind of suits very well, as instructions in question use

 * both %ecx and %edx as input:-)

 */

#define REP_XCRYPT(code)		\

	_asm _emit 0xf3			\

	_asm _emit 0x0f _asm _emit 0xa7	\

	_asm _emit code

/* BIG FAT WARNING: 

 * 	The offsets used with 'lea' instructions

 * 	describe items of the 'padlock_cipher_data'

 * 	structure.

 */

#define PADLOCK_XCRYPT_ASM(name,code)	\

static void * __fastcall 		\

	name (size_t cnt, void *cdata,	\

	void *outp, const void *inp)	\

{	_asm	mov	eax,edx		\

	_asm	lea	edx,[eax+16]	\

	_asm	lea	ebx,[eax+32]	\

	_asm	mov	edi,outp	\

	_asm	mov	esi,inp		\

	REP_XCRYPT(code)		\

}

PADLOCK_XCRYPT_ASM(padlock_xcrypt_ecb,0xc8)

PADLOCK_XCRYPT_ASM(padlock_xcrypt_cbc,0xd0)

PADLOCK_XCRYPT_ASM(padlock_xcrypt_cfb,0xe0)

PADLOCK_XCRYPT_ASM(padlock_xcrypt_ofb,0xe8)

static int __fastcall

padlock_xstore(void *outp,unsigned int code)

{	_asm	mov	edi,ecx

	_asm _emit 0x0f _asm _emit 0xa7 _asm _emit 0xc0

}