/*

 * This product includes cryptographic software developed by the OpenSSL

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

 */

/*

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

 * Copyright (c) 1998-2011 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

 *    [email protected].

 *

 * 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.

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

 */

/*

 * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.

 */

/*

 * This engine supports SPARC microprocessors that provide AES and other

 * cipher and hash instructions, such as the T4 microprocessor.

 */

#include <openssl/opensslconf.h>

#if !defined(OPENSSL_NO_HW) && !defined(OPENSSL_NO_HW_AES_T4) && \

	!defined(OPENSSL_NO_AES)

#include <sys/types.h>

#include <sys/auxv.h>	/* getisax() */

#include <stdlib.h>

#include <stdbool.h>

#include <string.h>

#include <errno.h>

#include <openssl/aes.h>

#include <openssl/engine.h>

#include "eng_t4_aes_asm.h"

#define	T4_LIB_NAME "SPARC T4 engine"

#include "eng_t4_err.c"

/* Copied from Solaris aes_impl.h */

#ifndef	MAX_AES_NR

#define	MAX_AES_NR		14 /* Maximum number of rounds */

#endif

#ifndef	MAX_AES_NB

#define	MAX_AES_NB		4  /* Number of columns comprising a state */

#endif

/* Index for the supported ciphers */

typedef enum {

	T4_AES_128_CBC,

	T4_AES_192_CBC,

	T4_AES_256_CBC,

#ifndef	SOLARIS_NO_AES_CFB128

	T4_AES_128_CFB128,

	T4_AES_192_CFB128,

	T4_AES_256_CFB128,

#endif	/* !SOLARIS_NO_AES_CFB128 */

#ifndef	SOLARIS_NO_AES_CTR

	T4_AES_128_CTR,

	T4_AES_192_CTR,

	T4_AES_256_CTR,

#endif

	T4_AES_128_ECB,

	T4_AES_192_ECB,

	T4_AES_256_ECB,

	T4_CIPHER_MAX

} t4_cipher_id;

/* T4 cipher context; must be 8-byte aligned (last field must be uint64_t)  */

typedef struct t4_cipher_ctx {

	t4_cipher_id	index;

	uint64_t	*iv;

	uint64_t	aligned_iv_buffer[2]; /* use if original IV unaligned */

	/* Encryption and decryption key schedule are the same: */

	uint64_t	t4_ks[((MAX_AES_NR) + 1) * (MAX_AES_NB)];

} t4_cipher_ctx_t;

typedef struct t4_cipher {

	t4_cipher_id	id;

	int		nid;

	int		iv_len;

	int		min_key_len;

	int		max_key_len;

	unsigned long	flags;

} t4_cipher_t;

/* Constants used when creating the ENGINE */

static const char *ENGINE_T4_ID = "t4";

static const char *ENGINE_T4_NAME = "SPARC T4 engine support";

static const char *ENGINE_NO_T4_NAME = "SPARC T4 engine support (no T4)";

#if (defined(sun4v) || defined(__sparcv9) || defined(__sparcv8plus) || \

	defined(__sparcv8)) && !defined(OPENSSL_NO_ASM)

#define	COMPILE_HW_T4

static int t4_bind_helper(ENGINE *e, const char *id);

#pragma inline(t4_bind_helper)

#endif

/*

 * This makes the engine "built-in" with OpenSSL.

 * On non-T4 CPUs this just returns.

 * Called by ENGINE_load_builtin_engines().

 */

void

ENGINE_load_t4(void)

{

#ifdef	COMPILE_HW_T4

	ENGINE *toadd = ENGINE_new();

	if (toadd != NULL) {

		if (t4_bind_helper(toadd, ENGINE_T4_ID) != 0) {

			(void) ENGINE_add(toadd);

			(void) ENGINE_free(toadd);

			ERR_clear_error();

		} else {

			(void) ENGINE_free(toadd);

		}

	}

#endif

}

#ifdef	COMPILE_HW_T4

static int t4_bind(ENGINE *e);

#ifndef	DYNAMIC_ENGINE

#pragma inline(t4_bind)

#endif

static t4_cipher_id get_cipher_index_by_nid(int nid);

#pragma inline(get_cipher_index_by_nid)

static void t4_instructions_present(_Bool *aes_present, _Bool *des_present,

#pragma inline(t4_instructions_present)

/* Digest registration function. Called by ENGINE_set_ciphers() */

int t4_get_all_digests(ENGINE *e, const EVP_MD **digest,

    const int **nids, int nid);

#ifndef	SOLARIS_NO_AES_CTR

/*

 * NIDs for AES counter mode that will be defined during the engine

 * initialization (because OpenSSL doesn't support CTR mode).

 */

static int NID_t4_aes_128_ctr = NID_undef;

static int NID_t4_aes_192_ctr = NID_undef;

static int NID_t4_aes_256_ctr = NID_undef;

static int t4_add_NID(char *sn, char *ln);

static int t4_add_aes_ctr_NIDs(void);

#pragma inline(t4_add_aes_ctr_NIDs)

static void t4_free_aes_ctr_NIDs(void);

#define	T4_FREE_AES_CTR_NIDS	t4_free_aes_ctr_NIDs()

#else

#define	T4_FREE_AES_CTR_NIDS

#endif	/* !SOLARIS_NO_AES_CTR */

/* Static variables */

/* This can't be const as NID*ctr is inserted when the engine is initialized */

static int t4_cipher_nids[] = {

	NID_aes_128_cbc, NID_aes_192_cbc, NID_aes_256_cbc,

#ifndef	SOLARIS_NO_AES_CFB128

	NID_aes_128_cfb128, NID_aes_192_cfb128, NID_aes_256_cfb128,

#endif

#ifndef	SOLARIS_NO_AES_CTR

	/* NID_t4_aes_128_ctr, NID_t4_aes_192, NID_t4_aes_256 */

	NID_undef, NID_undef, NID_undef,

#endif

	NID_aes_128_ecb, NID_aes_192_ecb, NID_aes_256_ecb,

#ifndef	OPENSSL_NO_DES

	/* Must be at end of list (see t4_des_cipher_count in t4_bind() */

	NID_des_cbc, NID_des_ede3_cbc, NID_des_ecb, NID_des_ede3_ecb,

#endif

};

static const int t4_des_cipher_count = 4;

static int t4_cipher_count =

	(sizeof (t4_cipher_nids) / sizeof (t4_cipher_nids[0]));

/*

 * Cipher Table for all supported symmetric ciphers.

 * Must be in same order as t4_cipher_id.

 */

static t4_cipher_t t4_cipher_table[] = {

	/* ID			NID			IV min- max-key flags */

	{T4_AES_128_CBC,	NID_aes_128_cbc,	16, 16, 16, 0},

	{T4_AES_192_CBC,	NID_aes_192_cbc,	16, 24, 24, 0},

	{T4_AES_256_CBC,	NID_aes_256_cbc,	16, 32, 32, 0},

#ifndef	SOLARIS_NO_AES_CFB128

	{T4_AES_128_CFB128,	NID_aes_128_cfb128,	16, 16, 16,

							EVP_CIPH_NO_PADDING},

	{T4_AES_192_CFB128,	NID_aes_192_cfb128,	16, 24, 24,

							EVP_CIPH_NO_PADDING},

	{T4_AES_256_CFB128,	NID_aes_256_cfb128,	16, 32, 32,

							EVP_CIPH_NO_PADDING},

#endif

#ifndef	SOLARIS_NO_AES_CTR

	/* We don't know the correct NIDs until the engine is initialized */

	{T4_AES_128_CTR,	NID_undef,		16, 16, 16,

							EVP_CIPH_NO_PADDING},

	{T4_AES_192_CTR,	NID_undef,		16, 24, 24,

							EVP_CIPH_NO_PADDING},

	{T4_AES_256_CTR,	NID_undef,		16, 32, 32,

							EVP_CIPH_NO_PADDING},

#endif

	{T4_AES_128_ECB,	NID_aes_128_ecb,	0, 16, 16, 0},

	{T4_AES_192_ECB,	NID_aes_192_ecb,	0, 24, 24, 0},

	{T4_AES_256_ECB,	NID_aes_256_ecb,	0, 32, 32, 0},

};

/* Formal declaration for functions in EVP_CIPHER structure */

static int t4_cipher_init_aes(EVP_CIPHER_CTX *ctx, const unsigned char *key,

    const unsigned char *iv, int enc);

static int t4_cipher_do_aes_128_cbc(EVP_CIPHER_CTX *ctx, unsigned char *out,

    const unsigned char *in, size_t inl);

static int t4_cipher_do_aes_192_cbc(EVP_CIPHER_CTX *ctx, unsigned char *out,

    const unsigned char *in, size_t inl);

static int t4_cipher_do_aes_256_cbc(EVP_CIPHER_CTX *ctx, unsigned char *out,

    const unsigned char *in, size_t inl);

#ifndef	SOLARIS_NO_AES_CFB128

static int t4_cipher_do_aes_128_cfb128(EVP_CIPHER_CTX *ctx, unsigned char *out,

    const unsigned char *in, size_t inl);

static int t4_cipher_do_aes_192_cfb128(EVP_CIPHER_CTX *ctx, unsigned char *out,

    const unsigned char *in, size_t inl);

static int t4_cipher_do_aes_256_cfb128(EVP_CIPHER_CTX *ctx, unsigned char *out,

    const unsigned char *in, size_t inl);

#endif

#ifndef	SOLARIS_NO_AES_CTR

static int t4_cipher_do_aes_128_ctr(EVP_CIPHER_CTX *ctx, unsigned char *out,

    const unsigned char *in, size_t inl);

static int t4_cipher_do_aes_192_ctr(EVP_CIPHER_CTX *ctx, unsigned char *out,

    const unsigned char *in, size_t inl);

static int t4_cipher_do_aes_256_ctr(EVP_CIPHER_CTX *ctx, unsigned char *out,

    const unsigned char *in, size_t inl);

#endif	/* !SOLARIS_NO_AES_CTR */

static int t4_cipher_do_aes_128_ecb(EVP_CIPHER_CTX *ctx, unsigned char *out,

    const unsigned char *in, size_t inl);

static int t4_cipher_do_aes_192_ecb(EVP_CIPHER_CTX *ctx, unsigned char *out,

    const unsigned char *in, size_t inl);

static int t4_cipher_do_aes_256_ecb(EVP_CIPHER_CTX *ctx, unsigned char *out,

    const unsigned char *in, size_t inl);

/*

 * Cipher Algorithms

 *

 * OpenSSL's libcrypto EVP stuff. This is how this engine gets wired to EVP.

 * EVP_CIPHER is defined in evp.h.  To maintain binary compatibility the

 * definition cannot be modified.

 * Stuff specific to the t4 engine is kept in t4_cipher_ctx_t, which is

 * pointed to by cipher_data or md_data

 *

 * Fields: nid, block_size, key_len, iv_len, flags,

 *	init(), do_cipher(), cleanup(),

 *	ctx_size,

 *	set_asn1_parameters(), get_asn1_parameters(), ctrl(), app_data

 */

static const EVP_CIPHER t4_aes_128_cbc = {

	NID_aes_128_cbc,

	16, 16, 16,

	EVP_CIPH_CBC_MODE,

	t4_cipher_init_aes, t4_cipher_do_aes_128_cbc, NULL,

	sizeof (t4_cipher_ctx_t),

	EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv,

	NULL, NULL

};

static const EVP_CIPHER t4_aes_192_cbc = {

	NID_aes_192_cbc,

	16, 24, 16,

	EVP_CIPH_CBC_MODE,

	t4_cipher_init_aes, t4_cipher_do_aes_192_cbc, NULL,

	sizeof (t4_cipher_ctx_t),

	EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv,

	NULL, NULL

};

static const EVP_CIPHER t4_aes_256_cbc = {

	NID_aes_256_cbc,

	16, 32, 16,

	EVP_CIPH_CBC_MODE,

	t4_cipher_init_aes, t4_cipher_do_aes_256_cbc, NULL,

	sizeof (t4_cipher_ctx_t),

	EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv,

	NULL, NULL

};

#ifndef	SOLARIS_NO_AES_CFB128

static const EVP_CIPHER t4_aes_128_cfb128 = {

	NID_aes_128_cfb128,

	16, 16, 16,

	EVP_CIPH_CFB_MODE,

	t4_cipher_init_aes, t4_cipher_do_aes_128_cfb128, NULL,

	sizeof (t4_cipher_ctx_t),

	EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv,

	NULL, NULL

};

static const EVP_CIPHER t4_aes_192_cfb128 = {

	NID_aes_192_cfb128,

	16, 24, 16,

	EVP_CIPH_CFB_MODE,

	t4_cipher_init_aes, t4_cipher_do_aes_192_cfb128, NULL,

	sizeof (t4_cipher_ctx_t),

	EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv,

	NULL, NULL

};

static const EVP_CIPHER t4_aes_256_cfb128 = {

	NID_aes_256_cfb128,

	16, 32, 16,

	EVP_CIPH_CFB_MODE,

	t4_cipher_init_aes, t4_cipher_do_aes_256_cfb128, NULL,

	sizeof (t4_cipher_ctx_t),

	EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv,

	NULL, NULL

};

#endif	/* !SOLARIS_NO_AES_CFB128 */

#ifndef	SOLARIS_NO_AES_CTR

/*

 * Counter mode is not defined in OpenSSL.

 * NID_undef's will be changed to AES counter mode NIDs as soon as they are

 * created in t4_add_aes_ctr_NIDs() when the engine is initialized.

 * Note that the need to change these structures during initialization is the

 * reason why we don't define them with the const keyword.

 */

static EVP_CIPHER t4_aes_128_ctr = {

	NID_undef,

	16, 16, 16,

	EVP_CIPH_CBC_MODE,

	t4_cipher_init_aes, t4_cipher_do_aes_128_ctr, NULL,

	sizeof (t4_cipher_ctx_t),

	EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv,

	NULL, NULL

};

static EVP_CIPHER t4_aes_192_ctr = {

	NID_undef,

	16, 24, 16,

	EVP_CIPH_CBC_MODE,

	t4_cipher_init_aes, t4_cipher_do_aes_192_ctr, NULL,

	sizeof (t4_cipher_ctx_t),

	EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv,

	NULL, NULL

};

static EVP_CIPHER t4_aes_256_ctr = {

	NID_undef,

	16, 32, 16,

	EVP_CIPH_CBC_MODE,

	t4_cipher_init_aes, t4_cipher_do_aes_256_ctr, NULL,

	sizeof (t4_cipher_ctx_t),

	EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv,

	NULL, NULL

};

#endif	/* !SOLARIS_NO_AES_CTR */

/*

 * ECB modes don't use an Initial Vector, so that's why set_asn1_parameters,

 * get_asn1_parameters, and cleanup fields are set to NULL.

 */

static const EVP_CIPHER t4_aes_128_ecb = {

	NID_aes_128_ecb,

	16, 16, 0,

	EVP_CIPH_ECB_MODE,

	t4_cipher_init_aes, t4_cipher_do_aes_128_ecb, NULL,

	sizeof (t4_cipher_ctx_t),

	NULL, NULL, NULL, NULL

};

static const EVP_CIPHER t4_aes_192_ecb = {

	NID_aes_192_ecb,

	16, 24, 0,

	EVP_CIPH_ECB_MODE,

	t4_cipher_init_aes, t4_cipher_do_aes_192_ecb, NULL,

	sizeof (t4_cipher_ctx_t),

	NULL, NULL, NULL, NULL

};

static const EVP_CIPHER t4_aes_256_ecb = {

	NID_aes_256_ecb,

	16, 32, 0,

	EVP_CIPH_ECB_MODE,

	t4_cipher_init_aes, t4_cipher_do_aes_256_ecb, NULL,

	sizeof (t4_cipher_ctx_t),

	NULL, NULL, NULL, NULL

};

#ifndef	OPENSSL_NO_DES

extern const EVP_CIPHER t4_des_cbc;

extern const EVP_CIPHER t4_des3_cbc;

extern const EVP_CIPHER t4_des_ecb;

extern const EVP_CIPHER t4_des3_ecb;

#endif	/* OPENSSL_NO_DES */

/*

 * Message Digest variables

 */

static const int t4_digest_nids[] = {

#ifndef	OPENSSL_NO_MD5

	NID_md5,

#endif

#ifndef	OPENSSL_NO_SHA

#ifndef	OPENSSL_NO_SHA1

	NID_sha1,

#endif

#ifndef	OPENSSL_NO_SHA256

	NID_sha224,

	NID_sha256,

#endif

#ifndef	OPENSSL_NO_SHA512

	NID_sha384,

	NID_sha512,

#endif

#endif	/* !OPENSSL_NO_SHA */

};

static const int t4_digest_count =

	(sizeof (t4_digest_nids) / sizeof (t4_digest_nids[0]));

#ifndef	OPENSSL_NO_MD5

extern const EVP_MD t4_md5;

#endif

#ifndef	OPENSSL_NO_SHA

#ifndef	OPENSSL_NO_SHA1

extern const EVP_MD t4_sha1;

#endif

#ifndef	OPENSSL_NO_SHA256

extern const EVP_MD t4_sha224;

extern const EVP_MD t4_sha256;

#endif

#ifndef	OPENSSL_NO_SHA512

extern const EVP_MD t4_sha384;

extern const EVP_MD t4_sha512;

#endif

#endif	/* !OPENSSL_NO_SHA */

/*

 * Message Digest functions

 */

/*

 * Registered by the ENGINE with ENGINE_set_digests().

 * Finds out how to deal with a particular digest NID in the ENGINE.

 */

/* ARGSUSED */

int

t4_get_all_digests(ENGINE *e, const EVP_MD **digest,

    const int **nids, int nid)

{

	if (digest == NULL) { /* return a list of all supported digests */

		*nids = (t4_digest_count > 0) ? t4_digest_nids : NULL;

		return (t4_digest_count);

	}

	switch (nid) {

#ifndef	OPENSSL_NO_MD5

	case NID_md5:

		*digest = &t4_md5;

		break;

#endif

#ifndef	OPENSSL_NO_SHA

#ifndef	OPENSSL_NO_SHA1

	/*

	 * A special case. For "openssl dgst -dss1 ...",

	 * OpenSSL calls EVP_get_digestbyname() on "dss1" which ends up

	 * calling t4_get_all_digests() for NID_dsa. Internally, if an

	 * engine is not used, OpenSSL uses SHA1_Init() as expected for

	 * DSA. So, we must return t4_sha1 for NID_dsa as well. Note

	 * that this must have changed between 0.9.8 and 1.0.0 since we

	 * did not have the problem with the 0.9.8 version.