/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (the "License").

 * You may not use this file except in compliance with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

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

#include <errno.h>

#include <openssl/bio.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 boolean_t t4_aes_instructions_present(void);

#pragma inline(t4_aes_instructions_present)

static boolean_t t4_digest_instructions_present(void);

#pragma inline(t4_digest_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_undef, /* NID_t4_aes_128_ctr */

	NID_undef, /* NID_t4_aes_192_ctr */

	NID_undef, /* NID_t4_aes_256_ctr */

#endif

	NID_aes_128_ecb,

	NID_aes_192_ecb,

	NID_aes_256_ecb,

};

static const 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 the last field, app_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

 * For the T4 engine, field app_data points to t4_cipher_ctx_t.

 */

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

};

/*

 * Return true if executing on a SPARC processor with AES instruction support,

 * such as a T4; otherwise false.

 */

static boolean_t

t4_aes_instructions_present(void)

{

	uint_t ui;

	(void) getisax(&ui, 1);

	return ((ui & AV_SPARC_AES) != 0);

}

/*

 * Return true if executing on a SPARC processor with MD5/SHA1/SHA{1,256,512}

 * instruction support, such as a T4; otherwise false.

 */

static boolean_t

t4_digest_instructions_present(void)

{

#ifndef	OPENSSL_NO_SHA

#define	UI_MASK	(AV_SPARC_MD5 | AV_SPARC_SHA1 | AV_SPARC_SHA256 | \

	AV_SPARC_SHA512)

#else

#define	UI_MASK	(AV_SPARC_MD5)

#endif

	uint_t		ui;

	(void) getisax(&ui, 1);

	return ((ui & UI_MASK) == UI_MASK);

}

#ifndef	SOLARIS_NO_AES_CTR

/* Create a new NID when we have no OID for that mechanism */

static int

t4_add_NID(char *sn, char *ln)

{

	ASN1_OBJECT	*o;

	int		nid;

	if ((o = ASN1_OBJECT_create(OBJ_new_nid(1), (unsigned char *)"",

	    1, sn, ln)) == NULL) {

		T4err(T4_F_ADD_NID, T4_R_ASN1_OBJECT_CREATE);

		return (0);

	}

	/* Will return NID_undef on error */

	nid = OBJ_add_object(o);

	ASN1_OBJECT_free(o);

	return (nid);

}

/*

 * Create new NIDs for AES counter mode.

 * OpenSSL doesn't support them now so we have to help ourselves here.

 */

static int

t4_add_aes_ctr_NIDs(void)

{

	/* Are we already set? */

	if (NID_t4_aes_256_ctr != NID_undef)

		return (1);

	/*

	 * There are no official names for AES counter modes yet so we just

	 * follow the format of those that exist.

	 */

	/* Initialize NID_t4_aes_*_ctr and t4_cipher_table[] variables */

	if ((NID_t4_aes_128_ctr = t4_add_NID("AES-128-CTR", "aes-128-ctr")) ==

	    NID_undef)

		return (0);

	t4_cipher_table[T4_AES_128_CTR].nid =

	    t4_aes_128_ctr.nid = NID_t4_aes_128_ctr;

	if ((NID_t4_aes_192_ctr = t4_add_NID("AES-192-CTR", "aes-192-ctr")) ==

	    NID_undef)

		return (0);

	t4_cipher_table[T4_AES_192_CTR].nid =

	    t4_aes_192_ctr.nid = NID_t4_aes_192_ctr;

	if ((NID_t4_aes_256_ctr = t4_add_NID("AES-256-CTR", "aes-256-ctr")) ==

	    NID_undef)

		return (0);

	t4_cipher_table[T4_AES_256_CTR].nid =

	    t4_aes_256_ctr.nid = NID_t4_aes_256_ctr;

	/* Initialize t4_cipher_nids[] */

	for (int i = 0; i < t4_cipher_count; ++i) {

		if (t4_cipher_nids[i] == NID_undef) { /* found */

			t4_cipher_nids[i] = NID_t4_aes_128_ctr;

			t4_cipher_nids[++i] = NID_t4_aes_192_ctr;

			t4_cipher_nids[++i] = NID_t4_aes_256_ctr;

			break;

		}

	}

	return (1);

}

static void

t4_free_aes_ctr_NIDs(void)

{

	ASN1_OBJECT *o = NULL;

	/* Clear entries in t4_cipher_nids[] */

	for (int i = 0; i < t4_cipher_count; ++i) {

		if (t4_cipher_nids[i] == NID_t4_aes_128_ctr) {

			t4_cipher_nids[i] = NID_undef;

		} else if (t4_cipher_nids[i] == NID_t4_aes_192_ctr) {

			t4_cipher_nids[i] = NID_undef;

		} else if (t4_cipher_nids[i] == NID_t4_aes_256_ctr) {

			t4_cipher_nids[i] = NID_undef;

		}

	}

	/* Clear NID_t4_aes_*_ctr and t4_cipher_table[] variables */

	if (NID_t4_aes_128_ctr != NID_undef) {

		o = OBJ_nid2obj(NID_t4_aes_128_ctr);

		if (o != NULL)

			ASN1_OBJECT_free(o);

		NID_t4_aes_128_ctr = NID_undef;

		t4_cipher_table[T4_AES_128_CTR].nid =

		    t4_aes_128_ctr.nid = NID_undef;

	}

	if (NID_t4_aes_192_ctr != NID_undef) {