/*

 * 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, 2013, 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 */

	T4_AES_128_CTR,

	T4_AES_192_CTR,

	T4_AES_256_CTR,

	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)

/* RSA_METHOD structure used by ENGINE_set_RSA() */

extern RSA_METHOD *t4_RSA(void);

/* DH_METHOD structure used by ENGINE_set_DH() */

extern DH_METHOD *t4_DH(void);

/* DSA_METHOD structure used by ENGINE_set_DSA() */

extern DSA_METHOD *t4_DSA(void);

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

	NID_aes_128_ctr, NID_aes_192_ctr, NID_aes_256_ctr,

	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

	{T4_AES_128_CTR,	NID_aes_128_ctr,	16, 16, 16,

							EVP_CIPH_NO_PADDING},

	{T4_AES_192_CTR,	NID_aes_192_ctr,	16, 24, 24,

							EVP_CIPH_NO_PADDING},

	{T4_AES_256_CTR,	NID_aes_256_ctr,	16, 32, 32,

							EVP_CIPH_NO_PADDING},

	{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

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);

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

static EVP_CIPHER t4_aes_128_ctr = {

	NID_aes_128_ctr,

	16, 16, 16,

	EVP_CIPH_CTR_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_aes_192_ctr,

	16, 24, 16,

	EVP_CIPH_CTR_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_aes_256_ctr,

	16, 32, 16,

	EVP_CIPH_CTR_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

};

/*

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

/*

 * Utility Functions

 */

/*

 */

static void

t4_instructions_present(_Bool *aes_present, _Bool *des_present,

{

#ifdef	OPENSSL_NO_DES

#undef	AV_SPARC_DES

#define	AV_SPARC_DES	0

#endif

	uint_t		ui;

	(void) getisax(&ui, 1);

	*aes_present = ((ui & AV_SPARC_AES) != 0);

	*des_present = ((ui & AV_SPARC_DES) != 0);

	*montmul_present = ((ui & AV_SPARC_MONT) != 0);

}

/*

 * Cipher functions

 */

/*

 * Registered by the ENGINE with ENGINE_set_ciphers().

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

 */

/* ARGSUSED */

static int

t4_get_all_ciphers(ENGINE *e, const EVP_CIPHER **cipher,

    const int **nids, int nid)

{

	if (cipher == NULL) { /* return a list of all supported ciphers */

		*nids = (t4_cipher_count > 0) ? t4_cipher_nids : NULL;

		return (t4_cipher_count);

	}

	switch (nid) {

	case NID_aes_128_cbc:

		*cipher = &t4_aes_128_cbc;

		break;

	case NID_aes_192_cbc:

		*cipher = &t4_aes_192_cbc;

		break;

	case NID_aes_256_cbc:

		*cipher = &t4_aes_256_cbc;

		break;

	case NID_aes_128_ecb:

		*cipher = &t4_aes_128_ecb;

		break;

	case NID_aes_192_ecb:

		*cipher = &t4_aes_192_ecb;

		break;

	case NID_aes_256_ecb:

		*cipher = &t4_aes_256_ecb;

		break;

#ifndef	SOLARIS_NO_AES_CFB128

	case NID_aes_128_cfb128:

		*cipher = &t4_aes_128_cfb128;

		break;

	case NID_aes_192_cfb128:

		*cipher = &t4_aes_192_cfb128;

		break;

	case NID_aes_256_cfb128:

		*cipher = &t4_aes_256_cfb128;

		break;

#endif	/* !SOLARIS_NO_AES_CFB128 */

#ifndef	OPENSSL_NO_DES

	case NID_des_cbc:

		*cipher = &t4_des_cbc;

		break;

	case NID_des_ede3_cbc:

		*cipher = &t4_des3_cbc;

		break;

	case NID_des_ecb:

		*cipher = &t4_des_ecb;

		break;

	case NID_des_ede3_ecb:

		*cipher = &t4_des3_ecb;

		break;

#endif	/* !OPENSSL_NO_DES */

	case NID_aes_128_ctr:

		*cipher = &t4_aes_128_ctr;

		break;

	case NID_aes_192_ctr:

		*cipher = &t4_aes_192_ctr;

		break;

	case NID_aes_256_ctr:

		*cipher = &t4_aes_256_ctr;

		break;

	default:

		/* cipher not supported */

		*cipher = NULL;

		return (0);

	}

	return (1);

}

/* Called by t4_cipher_init_aes() */

static t4_cipher_id

get_cipher_index_by_nid(int nid)

{

	t4_cipher_id i;

	for (i = (t4_cipher_id)0; i < T4_CIPHER_MAX; ++i)