/*

 * This product includes cryptographic software developed by the OpenSSL

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

 * product includes cryptographic software written by Eric Young

 * ([email protected]).

 */

/*

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

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

 *

 * This file implements the SHA-512 message digest operations.

 */

#include <openssl/opensslconf.h>

#if !defined(OPENSSL_NO_HW) && !defined(OPENSSL_NO_HW_MD_T4)

#if !defined(OPENSSL_NO_SHA) && !defined(OPENSSL_NO_SHA512)

#include <sys/types.h>

#include <stdlib.h>

#include <string.h>

#include <errno.h>

#include <openssl/engine.h>

/*

 * Solaris sys/sha2.h and OpenSSL openssl/sha.h both define

 * SHA512_CTX, SHA512_CTX, SHA512, SHA384, and SHA512.

 * For SHA2, OpenSSL SHA512_CTX has extra num and md_len fields at

 * the end and Solaris SHA2_CTX has an extra algotype field at the beginning.

 */

#include "eng_t4_sha2_asm.h"

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

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

#define	COMPILE_HW_T4

#endif

#ifdef	COMPILE_HW_T4

/* Formal declaration for functions in EVP_MD structure */

static int t4_digest_init_sha384(EVP_MD_CTX *ctx);

static int t4_digest_init_sha512(EVP_MD_CTX *ctx);

static int t4_digest_update_sha512(EVP_MD_CTX *ctx, const void *data,

    size_t len);

static int t4_digest_final_sha512(EVP_MD_CTX *ctx, unsigned char *md);

static int t4_digest_copy_sha512(EVP_MD_CTX *to, const EVP_MD_CTX *from);

/*

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

 * EVP_MD 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: type, pkey_type, md_size, flags,

 *	init(), update(), final(),

 *	copy(), cleanup(), sign(), verify(),

 *	required_pkey_type, block_size, ctx_size, md5_ctrl()

 */

const EVP_MD t4_sha512 = {

	NID_sha512, NID_sha512WithRSAEncryption, SHA512_DIGEST_LENGTH,

	EVP_MD_FLAG_PKEY_METHOD_SIGNATURE | EVP_MD_FLAG_DIGALGID_ABSENT,

	t4_digest_init_sha512, t4_digest_update_sha512, t4_digest_final_sha512,

	t4_digest_copy_sha512, NULL,

	EVP_PKEY_RSA_method, SHA512_CBLOCK,

	sizeof (T4_SHA512_CTX), NULL

	};

/* SHA-384 uses the same context, cblock size, & update function as SHA-512: */

const EVP_MD t4_sha384 = {

	NID_sha384, NID_sha384WithRSAEncryption, SHA384_DIGEST_LENGTH,

	EVP_MD_FLAG_PKEY_METHOD_SIGNATURE | EVP_MD_FLAG_DIGALGID_ABSENT,

	t4_digest_init_sha384, t4_digest_update_sha512, t4_digest_final_sha512,

	t4_digest_copy_sha512, NULL,

	EVP_PKEY_RSA_method, SHA512_CBLOCK,

	sizeof (T4_SHA512_CTX), NULL

	};

/*

 * SHA512 functions (part of FIPS 180-2 Secure Hash Standard)

 */

static int

t4_digest_init_sha512(EVP_MD_CTX *ctx)

{

	T4_SHA512_CTX	*c = (T4_SHA512_CTX *)ctx->md_data;

	c->Nl = c->Nh = c->num = 0;

	c->h[0] = 0x6a09e667f3bcc908ULL;

	c->h[1] = 0xbb67ae8584caa73bULL;

	c->h[2] = 0x3c6ef372fe94f82bULL;

	c->h[3] = 0xa54ff53a5f1d36f1ULL;

	c->h[4] = 0x510e527fade682d1ULL;

	c->h[5] = 0x9b05688c2b3e6c1fULL;

	c->h[6] = 0x1f83d9abfb41bd6bULL;

	c->h[7] = 0x5be0cd19137e2179ULL;

	c->md_len = SHA512_DIGEST_LENGTH;

	return (1);

}

static int

t4_digest_init_sha384(EVP_MD_CTX *ctx)

{

	T4_SHA512_CTX	*c = (T4_SHA512_CTX *)ctx->md_data;

	c->Nl = c->Nh = c->num = 0;

	c->h[0] = 0xcbbb9d5dc1059ed8ULL;

	c->h[1] = 0x629a292a367cd507ULL;

	c->h[2] = 0x9159015a3070dd17ULL;

	c->h[3] = 0x152fecd8f70e5939ULL;

	c->h[4] = 0x67332667ffc00b31ULL;

	c->h[5] = 0x8eb44a8768581511ULL;

	c->h[6] = 0xdb0c2e0d64f98fa7ULL;

	c->h[7] = 0x47b5481dbefa4fa4ULL;

	c->md_len = SHA384_DIGEST_LENGTH;

	return (1);

}

/*

 * Continue SHA512 or SHA384 digest operation, using the message block to

 * update context.

 * Modified from SHA512_Update() in OpenSSL crypto/sha/sha512.c.

 */

static int

t4_digest_update_sha512(EVP_MD_CTX *ctx, const void *_data, size_t len)

{

	T4_SHA512_CTX	*c = (T4_SHA512_CTX *)ctx->md_data;

	SHA_LONG64	l;

	unsigned char	*p = c->u.p;

	const unsigned char *data = (const unsigned char *)_data;

	if (len == 0)

		return (1);

	l = (c->Nl + (((SHA_LONG64)len) << 3)) & 0xffffffffffffffffULL;

	if (l < c->Nl)

		c->Nh++;

	if (sizeof (len) >= 8) {

		c->Nh += (((SHA_LONG64)len) >> 61);

	}

	c->Nl = l;

	if (c->num != 0) {

		size_t n = sizeof (c->u) - c->num;

		if (len < n) {

			memcpy(p + c->num, data, len);

			c->num += (unsigned int)len;

			return (1);

		} else	{

			memcpy(p + c->num, data, n);

			c->num = 0;

			len -= n;

			data += n;

			t4_sha512_multiblock(c, p, 1);

		}

	}

	if (len >= sizeof (c->u)) {

		if ((size_t)data % sizeof (c->u.d[0]) != 0) {

			/* Align unaligned data one block-at-a-time */

			while (len >= sizeof (c->u)) {

				memcpy(p, data, sizeof (c->u));

				t4_sha512_multiblock(c, p, 1);

				len  -= sizeof (c->u);

				data += sizeof (c->u);

			}

		} else {

			t4_sha512_multiblock(c, data, len / sizeof (c->u));

			data += len;

			len  %= sizeof (c->u);

			data -= len;

		}

	}

	if (len != 0) {

		memcpy(p, data, len);

		c->num = (int)len;

	}

	return (1);

}

/*

 * End SHA-512 or SHA-384 digest operation, finalizing message digest and

 * zeroing context.

 * Modified from SHA512_Final() in OpenSSL crypto/sha/sha512.c.

 */

static int

t4_digest_final_sha512(EVP_MD_CTX *ctx, unsigned char *md)

{

	T4_SHA512_CTX	*c = (T4_SHA512_CTX *)ctx->md_data;

	unsigned char	*p = (unsigned char *)c->u.p;

	size_t		n = c->num;

	p[n] = 0x80;	/* There always is a room for one */

	n++;

	if (n > (sizeof (c->u) - 16)) {

		memset(p + n, 0, sizeof (c->u) - n);

		n = 0;

		t4_sha512_multiblock(c, p, 1);

	}

	memset(p+n, 0, sizeof (c->u) - 16 - n);

	c->u.d[SHA_LBLOCK - 2] = c->Nh;

	c->u.d[SHA_LBLOCK - 1] = c->Nl;

	t4_sha512_multiblock(c, p, 1);

	if (md == 0)

		return (0);

	switch (c->md_len) {

		/* Let compiler decide if it's appropriate to unroll... */

		case SHA384_DIGEST_LENGTH:

			for (n = 0; n < SHA384_DIGEST_LENGTH / 8; n++) {

				SHA_LONG64 t = c->h[n];

				*(md++)	= (unsigned char)(t >> 56);

				*(md++)	= (unsigned char)(t >> 48);

				*(md++)	= (unsigned char)(t >> 40);

				*(md++)	= (unsigned char)(t >> 32);

				*(md++)	= (unsigned char)(t >> 24);

				*(md++)	= (unsigned char)(t >> 16);

				*(md++)	= (unsigned char)(t >> 8);

				*(md++)	= (unsigned char)(t);

			}

			break;

		case SHA512_DIGEST_LENGTH:

			for (n = 0; n < SHA512_DIGEST_LENGTH / 8; n++) {

				SHA_LONG64 t = c->h[n];

				*(md++)	= (unsigned char)(t >> 56);

				*(md++)	= (unsigned char)(t >> 48);

				*(md++)	= (unsigned char)(t >> 40);

				*(md++)	= (unsigned char)(t >> 32);

				*(md++)	= (unsigned char)(t >> 24);

				*(md++)	= (unsigned char)(t >> 16);

				*(md++)	= (unsigned char)(t >> 8);

				*(md++)	= (unsigned char)(t);

			}

			break;

		/* ... as well as make sure md_len is not abused. */

		default:

			return (0);

	}

	return (1);

}

/* Required for Engine API */

static int

t4_digest_copy_sha512(EVP_MD_CTX *to, const EVP_MD_CTX *from)

{

	if ((to->md_data != NULL) && (from->md_data != NULL)) {

		(void) memcpy(to->md_data, from->md_data,

		    sizeof (T4_SHA512_CTX));

	}

	return (1);

}

#endif	/* COMPILE_HW_T4 */

#endif	/* !OPENSSL_NO_SHA && !OPENSSL_NO_SHA512 */

#endif	/* !OPENSSL_NO_HW && !OPENSSL_NO_HW_MD_T4 */