/*
 * The Initial Developer of the Original Code is International
 * Business Machines Corporation. Portions created by IBM
 * Corporation are Copyright (C) 2005 International Business
 * Machines Corporation. All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the Common Public License as published by
 * IBM Corporation; either version 1 of the License, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * Common Public License for more details.
 *
 * You should have received a copy of the Common Public License
 * along with this program; if not, a copy can be viewed at
 * http://www.opensource.org/licenses/cpl1.0.php.
 */
/* (C) COPYRIGHT International Business Machines Corp. 2001, 2002, 2005 */
/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include "tpmtok_int.h"

extern CK_RV
token_specific_rsa_verify_recover(
	TSS_HCONTEXT    hContext,
	CK_BYTE		*in_data,
	CK_ULONG	in_data_len,
	CK_BYTE		*out_data,
	CK_ULONG	*out_data_len,
	OBJECT		*key_obj);

CK_RV
ckm_rsa_key_pair_gen(TSS_HCONTEXT hContext,
	TEMPLATE  * publ_tmpl,
	TEMPLATE  * priv_tmpl)
{
	CK_RV		rc;

	rc = token_specific.t_rsa_generate_keypair(
	    hContext, publ_tmpl, priv_tmpl);

	return (rc);
}

static CK_RV
ckm_rsa_encrypt(
	TSS_HCONTEXT hContext,
	CK_BYTE   * in_data,
	CK_ULONG    in_data_len,
	CK_BYTE   * out_data,
	CK_ULONG  * out_data_len,
	OBJECT    * key_obj)
{
	CK_ATTRIBUTE	* attr    = NULL;
	CK_OBJECT_CLASS	keyclass;
	CK_RV		rc;

	rc = template_attribute_find(key_obj->template, CKA_CLASS, &attr);
	if (rc == FALSE) {
		return (CKR_FUNCTION_FAILED);
	} else
		keyclass = *(CK_OBJECT_CLASS *)attr->pValue;

	if (keyclass != CKO_PUBLIC_KEY) {
		return (CKR_FUNCTION_FAILED);
	}

	rc = token_specific.t_rsa_encrypt(hContext,
	    in_data, in_data_len,
	    out_data, out_data_len, key_obj);

	return (rc);
}

static CK_RV
ckm_rsa_decrypt(
	TSS_HCONTEXT hContext,
	CK_BYTE   * in_data,
	CK_ULONG    in_data_len,
	CK_BYTE   * out_data,
	CK_ULONG  * out_data_len,
	OBJECT    * key_obj) {
	CK_ATTRIBUTE	* attr	= NULL;
	CK_OBJECT_CLASS	keyclass;
	CK_RV		rc;


	rc = template_attribute_find(key_obj->template, CKA_CLASS, &attr);
	if (rc == FALSE) {
		return (CKR_FUNCTION_FAILED);
	}
	else
		keyclass = *(CK_OBJECT_CLASS *)attr->pValue;

	// this had better be a private key
	//
	if (keyclass != CKO_PRIVATE_KEY) {
		return (CKR_FUNCTION_FAILED);
	}
	rc = token_specific.t_rsa_decrypt(hContext,
	    in_data, in_data_len,
	    out_data, out_data_len, key_obj);

	return (rc);
}

static CK_RV
ckm_rsa_sign(
	TSS_HCONTEXT hContext,
	CK_BYTE   * in_data,
	CK_ULONG    in_data_len,
	CK_BYTE   * out_data,
	CK_ULONG  * out_data_len,
	OBJECT    * key_obj) {
	CK_ATTRIBUTE	* attr	= NULL;
	CK_OBJECT_CLASS	keyclass;
	CK_RV		rc;


	rc = template_attribute_find(key_obj->template, CKA_CLASS, &attr);
	if (rc == FALSE) {
		return (CKR_FUNCTION_FAILED);
	} else {
		keyclass = *(CK_OBJECT_CLASS *)attr->pValue;
	}

	if (keyclass != CKO_PRIVATE_KEY) {
		return (CKR_FUNCTION_FAILED);
	}
	rc = token_specific.t_rsa_sign(
	    hContext, in_data, in_data_len, out_data,
	    out_data_len, key_obj);

	return (rc);
}

static CK_RV
ckm_rsa_verify(
	TSS_HCONTEXT hContext,
	CK_BYTE   * in_data,
	CK_ULONG    in_data_len,
	CK_BYTE   * out_data,
	CK_ULONG    out_data_len,
	OBJECT    * key_obj) {
	CK_ATTRIBUTE	* attr	= NULL;
	CK_OBJECT_CLASS	keyclass;
	CK_RV		rc;


	rc = template_attribute_find(key_obj->template, CKA_CLASS, &attr);
	if (rc == FALSE) {
		return (CKR_FUNCTION_FAILED);
	}
	else
		keyclass = *(CK_OBJECT_CLASS *)attr->pValue;

	if (keyclass != CKO_PUBLIC_KEY) {
		return (CKR_FUNCTION_FAILED);
	}
	rc = token_specific.t_rsa_verify(hContext,
	    in_data, in_data_len, out_data,
	    out_data_len, key_obj);

	return (rc);
}

/*ARGSUSED*/
CK_RV
rsa_pkcs_encrypt(SESSION	   *sess,
	CK_BBOOL	   length_only,
	ENCR_DECR_CONTEXT *ctx,
	CK_BYTE	   *in_data,
	CK_ULONG	   in_data_len,
	CK_BYTE	   *out_data,
	CK_ULONG	  *out_data_len)
{
	OBJECT	  *key_obj  = NULL;
	CK_ATTRIBUTE    *attr	= NULL;
	CK_ULONG	 modulus_bytes;
	CK_BBOOL	 flag;
	CK_RV	    rc;


	rc = object_mgr_find_in_map1(sess->hContext, ctx->key, &key_obj);
	if (rc != CKR_OK) {
		return (rc);
	}
	flag = template_attribute_find(key_obj->template, CKA_MODULUS, &attr);
	if (flag == FALSE) {
		return (CKR_FUNCTION_FAILED);
	} else {
		modulus_bytes = attr->ulValueLen;
	}

	if (length_only == TRUE) {
		*out_data_len = modulus_bytes;
		return (CKR_OK);
	}

	if (*out_data_len < modulus_bytes) {
		*out_data_len = modulus_bytes;
		return (CKR_BUFFER_TOO_SMALL);
	}

	rc = ckm_rsa_encrypt(sess->hContext, in_data, in_data_len, out_data,
	    out_data_len, key_obj);
	return (rc);
}

/*ARGSUSED*/
CK_RV
rsa_pkcs_decrypt(SESSION	   *sess,
	CK_BBOOL	   length_only,
	ENCR_DECR_CONTEXT *ctx,
	CK_BYTE	   *in_data,
	CK_ULONG	   in_data_len,
	CK_BYTE	   *out_data,
	CK_ULONG	  *out_data_len)
{
	OBJECT	  *key_obj  = NULL;
	CK_ATTRIBUTE    *attr	= NULL;
	CK_ULONG	 modulus_bytes;
	CK_BBOOL	 flag;
	CK_RV	    rc;


	rc = object_mgr_find_in_map1(sess->hContext, ctx->key, &key_obj);
	if (rc != CKR_OK) {
		return (rc);
	}
	flag = template_attribute_find(key_obj->template, CKA_MODULUS, &attr);
	if (flag == FALSE)
		return (CKR_FUNCTION_FAILED);
	else
		modulus_bytes = attr->ulValueLen;

	if (in_data_len != modulus_bytes) {
		return (CKR_ENCRYPTED_DATA_LEN_RANGE);
	}
	if (length_only == TRUE) {
		*out_data_len = modulus_bytes - 11;
		return (CKR_OK);
	}

	rc = ckm_rsa_decrypt(sess->hContext, in_data,
	    modulus_bytes, out_data,
	    out_data_len, key_obj);

	if (rc == CKR_DATA_LEN_RANGE) {
		return (CKR_ENCRYPTED_DATA_LEN_RANGE);
	}
	return (rc);
}

CK_RV
rsa_pkcs_sign(SESSION		*sess,
	CK_BBOOL		length_only,
	SIGN_VERIFY_CONTEXT *ctx,
	CK_BYTE		*in_data,
	CK_ULONG		in_data_len,
	CK_BYTE		*out_data,
	CK_ULONG	    *out_data_len)
{
	OBJECT	  *key_obj   = NULL;
	CK_ATTRIBUTE    *attr	= NULL;
	CK_ULONG	 modulus_bytes;
	CK_BBOOL	 flag;
	CK_RV	    rc;


	if (! sess || ! ctx || ! out_data_len) {
		return (CKR_FUNCTION_FAILED);
	}
	rc = object_mgr_find_in_map1(sess->hContext, ctx->key, &key_obj);
	if (rc != CKR_OK) {
		return (rc);
	}
	flag = template_attribute_find(key_obj->template, CKA_MODULUS, &attr);
	if (flag == FALSE)
		return (CKR_FUNCTION_FAILED);
	else
		modulus_bytes = attr->ulValueLen;

	if (length_only == TRUE) {
		*out_data_len = modulus_bytes;
		return (CKR_OK);
	}

	if (*out_data_len < modulus_bytes) {
		*out_data_len = modulus_bytes;
		return (CKR_BUFFER_TOO_SMALL);
	}

	rc = ckm_rsa_sign(sess->hContext, in_data, in_data_len, out_data,
	    out_data_len, key_obj);
	return (rc);
}

/*ARGSUSED*/
CK_RV
rsa_pkcs_verify(SESSION		* sess,
	SIGN_VERIFY_CONTEXT * ctx,
	CK_BYTE		* in_data,
	CK_ULONG		in_data_len,
	CK_BYTE		* signature,
	CK_ULONG		sig_len)
{
	OBJECT	  *key_obj  = NULL;
	CK_ATTRIBUTE    *attr	= NULL;
	CK_ULONG	 modulus_bytes;
	CK_BBOOL	 flag;
	CK_RV	    rc;

	rc = object_mgr_find_in_map1(sess->hContext, ctx->key, &key_obj);
	if (rc != CKR_OK) {
		return (rc);
	}
	flag = template_attribute_find(key_obj->template, CKA_MODULUS, &attr);
	if (flag == FALSE) {
		return (CKR_FUNCTION_FAILED);
	}
	else
		modulus_bytes = attr->ulValueLen;

	// check input data length restrictions
	//
	if (sig_len != modulus_bytes) {
		return (CKR_SIGNATURE_LEN_RANGE);
	}
	// verify is a public key operation --> encrypt
	//
	rc = ckm_rsa_verify(sess->hContext, in_data, in_data_len, signature,
	    sig_len, key_obj);

	return (rc);
}

CK_RV
rsa_pkcs_verify_recover(SESSION	*sess,
	CK_BBOOL	length_only,
	SIGN_VERIFY_CONTEXT	*ctx,
	CK_BYTE		*signature,
	CK_ULONG	sig_len,
	CK_BYTE		*out_data,
	CK_ULONG	*out_data_len)
{
	OBJECT		*key_obj  = NULL;
	CK_ATTRIBUTE	*attr	= NULL;
	CK_ULONG	modulus_bytes;
	CK_BBOOL	flag;
	CK_RV		rc;

	if (! sess || ! ctx || ! out_data_len) {
		return (CKR_FUNCTION_FAILED);
	}
	rc = object_mgr_find_in_map1(sess->hContext, ctx->key, &key_obj);
	if (rc != CKR_OK) {
		return (rc);
	}
	flag = template_attribute_find(key_obj->template, CKA_MODULUS, &attr);
	if (flag == FALSE) {
		return (CKR_FUNCTION_FAILED);
	}
	else
		modulus_bytes = attr->ulValueLen;

	if (sig_len != modulus_bytes) {
		return (CKR_SIGNATURE_LEN_RANGE);
	}
	if (length_only == TRUE) {
		*out_data_len = modulus_bytes;
		return (CKR_OK);
	}

	rc = token_specific_rsa_verify_recover(sess->hContext,
	    signature, modulus_bytes, out_data, out_data_len, key_obj);

	return (rc);
}

CK_RV
rsa_hash_pkcs_sign(SESSION		* sess,
	CK_BBOOL		length_only,
	SIGN_VERIFY_CONTEXT  * ctx,
	CK_BYTE		* in_data,
	CK_ULONG		in_data_len,
	CK_BYTE		* signature,
	CK_ULONG		* sig_len)
{
	CK_BYTE	    * ber_data  = NULL;
	CK_BYTE	    * octet_str = NULL;
	CK_BYTE	    * oid	= NULL;
	CK_BYTE	    * tmp	= NULL;

	CK_ULONG		buf1[16];

	CK_BYTE		hash[SHA1_DIGEST_LENGTH];
	DIGEST_CONTEXT	digest_ctx;
	SIGN_VERIFY_CONTEXT  sign_ctx;
	CK_MECHANISM	 digest_mech;
	CK_MECHANISM	 sign_mech;
	CK_ULONG	ber_data_len, hash_len, octet_str_len, oid_len;
	CK_RV		rc;

	if (! sess || ! ctx || ! in_data) {
		return (CKR_FUNCTION_FAILED);
	}
	(void) memset(&digest_ctx, 0x0, sizeof (digest_ctx));
	(void) memset(&sign_ctx,   0x0, sizeof (sign_ctx));

	if (ctx->mech.mechanism == CKM_MD5_RSA_PKCS) {
		digest_mech.mechanism	= CKM_MD5;
		oid = ber_AlgMd5;
		oid_len = ber_AlgMd5Len;
		hash_len = MD5_DIGEST_LENGTH;
	} else {
		digest_mech.mechanism	= CKM_SHA_1;
		oid = ber_AlgSha1;
		oid_len = ber_AlgSha1Len;
		hash_len = SHA1_DIGEST_LENGTH;
	}

	digest_mech.ulParameterLen = 0;
	digest_mech.pParameter	= NULL;

	rc = digest_mgr_init(sess, &digest_ctx, &digest_mech);
	if (rc != CKR_OK) {
		goto error;
	}
	rc = digest_mgr_digest(sess, length_only, &digest_ctx, in_data,
	    in_data_len, hash, &hash_len);
	if (rc != CKR_OK)
		goto error;

	rc = ber_encode_OCTET_STRING(FALSE, &octet_str, &octet_str_len,
	    hash, hash_len);
	if (rc != CKR_OK) {
		goto error;
	}
	tmp = (CK_BYTE *)buf1;
	(void) memcpy(tmp,	   oid,	oid_len);
	(void) memcpy(tmp + oid_len, octet_str, octet_str_len);

	rc = ber_encode_SEQUENCE(FALSE, &ber_data, &ber_data_len,
	    tmp, (oid_len + octet_str_len));
	if (rc != CKR_OK)
		goto error;

	sign_mech.mechanism	= CKM_RSA_PKCS;
	sign_mech.ulParameterLen = 0;
	sign_mech.pParameter	= NULL;

	rc = sign_mgr_init(sess, &sign_ctx, &sign_mech, FALSE, ctx->key);
	if (rc != CKR_OK)
		goto error;

	rc = sign_mgr_sign(sess, length_only, &sign_ctx, ber_data,
	    ber_data_len, signature, sig_len);

error:
	if (octet_str) free(octet_str);
	if (ber_data)  free(ber_data);
	(void) digest_mgr_cleanup(&digest_ctx);
	(void) sign_mgr_cleanup(&sign_ctx);
	return (rc);
}

CK_RV
rsa_hash_pkcs_sign_update(
	SESSION		* sess,
	SIGN_VERIFY_CONTEXT  * ctx,
	CK_BYTE		* in_data,
	CK_ULONG		in_data_len)
{
	RSA_DIGEST_CONTEXT  * context = NULL;
	CK_MECHANISM	  digest_mech;
	CK_RV		 rc;

	if (! sess || ! ctx || ! in_data)
		return (CKR_FUNCTION_FAILED);

	context = (RSA_DIGEST_CONTEXT *)ctx->context;

	if (context->flag == FALSE) {
		if (ctx->mech.mechanism == CKM_MD5_RSA_PKCS)
			digest_mech.mechanism = CKM_MD5;
		else
			digest_mech.mechanism = CKM_SHA_1;

		digest_mech.ulParameterLen = 0;
		digest_mech.pParameter	= NULL;

		rc = digest_mgr_init(sess, &context->hash_context,
		    &digest_mech);
		if (rc != CKR_OK) {
			goto error;
		}
		context->flag = TRUE;
	}

	rc = digest_mgr_digest_update(sess, &context->hash_context,
	    in_data, in_data_len);
	if (rc != CKR_OK) {
		goto error;
	}
	return (CKR_OK);
error:
	(void) digest_mgr_cleanup(&context->hash_context);
	return (rc);
}

CK_RV
rsa_hash_pkcs_verify(SESSION		* sess,
	SIGN_VERIFY_CONTEXT  * ctx,
	CK_BYTE		* in_data,
	CK_ULONG		in_data_len,
	CK_BYTE		* signature,
	CK_ULONG		sig_len)
{
	CK_BYTE	    * ber_data  = NULL;
	CK_BYTE	    * octet_str = NULL;
	CK_BYTE	    * oid	= NULL;
	CK_BYTE	    * tmp	= NULL;

	CK_ULONG	buf1[16];
	CK_BYTE		hash[SHA1_DIGEST_LENGTH];
	DIGEST_CONTEXT	digest_ctx;
	SIGN_VERIFY_CONTEXT  verify_ctx;
	CK_MECHANISM	 digest_mech;
	CK_MECHANISM	 verify_mech;
	CK_ULONG	ber_data_len, hash_len, octet_str_len, oid_len;
	CK_RV		rc;

	if (! sess || ! ctx || ! in_data) {
		return (CKR_FUNCTION_FAILED);
	}
	(void) memset(&digest_ctx, 0x0, sizeof (digest_ctx));
	(void) memset(&verify_ctx, 0x0, sizeof (verify_ctx));

	if (ctx->mech.mechanism == CKM_MD5_RSA_PKCS) {
		digest_mech.mechanism	= CKM_MD5;
		oid = ber_AlgMd5;
		oid_len = ber_AlgMd5Len;
		hash_len = MD5_DIGEST_LENGTH;
	} else {
		digest_mech.mechanism	= CKM_SHA_1;
		oid = ber_AlgSha1;
		oid_len = ber_AlgSha1Len;
		hash_len = SHA1_DIGEST_LENGTH;
	}

	digest_mech.ulParameterLen = 0;
	digest_mech.pParameter	= NULL;

	rc = digest_mgr_init(sess, &digest_ctx, &digest_mech);
	if (rc != CKR_OK) {
		goto done;
	}
	rc = digest_mgr_digest(sess, FALSE, &digest_ctx, in_data,
	    in_data_len, hash, &hash_len);
	if (rc != CKR_OK) {
		goto done;
	}
	rc = ber_encode_OCTET_STRING(FALSE, &octet_str, &octet_str_len,
	    hash, hash_len);
	if (rc != CKR_OK)
		goto done;
	tmp = (CK_BYTE *)buf1;
	(void) memcpy(tmp,   oid, oid_len);
	(void) memcpy(tmp + oid_len, octet_str, octet_str_len);

	rc = ber_encode_SEQUENCE(FALSE, &ber_data, &ber_data_len, tmp,
	    (oid_len + octet_str_len));
	if (rc != CKR_OK) {
		goto done;
	}

	verify_mech.mechanism	= CKM_RSA_PKCS;
	verify_mech.ulParameterLen = 0;
	verify_mech.pParameter	= NULL;

	rc = verify_mgr_init(sess, &verify_ctx, &verify_mech, FALSE, ctx->key);
	if (rc != CKR_OK) {
		goto done;
	}
	rc = verify_mgr_verify(sess, &verify_ctx, ber_data,
	    ber_data_len, signature, sig_len);
done:
	if (octet_str) free(octet_str);
	if (ber_data)  free(ber_data);

	(void) digest_mgr_cleanup(&digest_ctx);
	(void) sign_mgr_cleanup(&verify_ctx);
	return (rc);
}

CK_RV
rsa_hash_pkcs_verify_update(SESSION		* sess,
	SIGN_VERIFY_CONTEXT  * ctx,
	CK_BYTE		*in_data,
	CK_ULONG	in_data_len)
{
	RSA_DIGEST_CONTEXT  * context = NULL;
	CK_MECHANISM	  digest_mech;
	CK_RV		 rc;

	if (! sess || ! ctx || ! in_data) {
		return (CKR_FUNCTION_FAILED);
	}
	context = (RSA_DIGEST_CONTEXT *)ctx->context;

	if (context->flag == FALSE) {
		if (ctx->mech.mechanism == CKM_MD5_RSA_PKCS)
			digest_mech.mechanism = CKM_MD5;
		else
			digest_mech.mechanism = CKM_SHA_1;

		digest_mech.ulParameterLen = 0;
		digest_mech.pParameter	= NULL;

		rc = digest_mgr_init(sess, &context->hash_context,
		    &digest_mech);
		if (rc != CKR_OK)
			goto error;
		context->flag = TRUE;
	}

	rc = digest_mgr_digest_update(sess, &context->hash_context,
	    in_data, in_data_len);
	if (rc != CKR_OK)
		goto error;
	return (CKR_OK);
error:
	(void) digest_mgr_cleanup(&context->hash_context);
	return (rc);
}

CK_RV
rsa_hash_pkcs_sign_final(SESSION		* sess,
	CK_BBOOL	length_only,
	SIGN_VERIFY_CONTEXT  * ctx,
	CK_BYTE		* signature,
	CK_ULONG	* sig_len)
{
	CK_BYTE	    * ber_data  = NULL;
	CK_BYTE	    * octet_str = NULL;
	CK_BYTE	    * oid	= NULL;
	CK_BYTE	    * tmp	= NULL;

	CK_ULONG buf1[16];
	CK_BYTE		hash[SHA1_DIGEST_LENGTH];
	RSA_DIGEST_CONTEXT  * context = NULL;
	CK_ULONG	ber_data_len, hash_len, octet_str_len, oid_len;
	CK_MECHANISM  sign_mech;
	SIGN_VERIFY_CONTEXT   sign_ctx;
	CK_RV		 rc;

	if (! sess || ! ctx || ! sig_len) {
		return (CKR_FUNCTION_FAILED);
	}

	if (ctx->mech.mechanism == CKM_MD5_RSA_PKCS) {
		oid = ber_AlgMd5;
		oid_len = ber_AlgMd5Len;
		hash_len = MD5_DIGEST_LENGTH;
	} else {
		oid = ber_AlgSha1;
		oid_len = ber_AlgSha1Len;
		hash_len = SHA1_DIGEST_LENGTH;
	}

	(void) memset(&sign_ctx, 0x0, sizeof (sign_ctx));

	context = (RSA_DIGEST_CONTEXT *)ctx->context;

	rc = digest_mgr_digest_final(sess,
	    &context->hash_context, hash, &hash_len);
	if (rc != CKR_OK) {
		goto done;
	}

	rc = ber_encode_OCTET_STRING(FALSE, &octet_str, &octet_str_len,
	    hash, hash_len);
	if (rc != CKR_OK) {
		goto done;
	}
	tmp = (CK_BYTE *)buf1;
	(void) memcpy(tmp,  oid, oid_len);
	(void) memcpy(tmp + oid_len, octet_str, octet_str_len);

	rc = ber_encode_SEQUENCE(FALSE, &ber_data, &ber_data_len,
	    tmp, (oid_len + octet_str_len));
	if (rc != CKR_OK) {
		goto done;
	}
	sign_mech.mechanism	= CKM_RSA_PKCS;
	sign_mech.ulParameterLen = 0;
	sign_mech.pParameter	= NULL;

	rc = sign_mgr_init(sess, &sign_ctx, &sign_mech, FALSE, ctx->key);
	if (rc != CKR_OK) {
		goto done;
	}
	rc = sign_mgr_sign(sess, length_only, &sign_ctx, ber_data,
	    ber_data_len, signature, sig_len);

	if (length_only == TRUE || rc == CKR_BUFFER_TOO_SMALL) {
		(void) sign_mgr_cleanup(&sign_ctx);
		return (rc);
	}

done:
	if (octet_str) free(octet_str);
	if (ber_data)  free(ber_data);

	(void) digest_mgr_cleanup(&context->hash_context);
	(void) sign_mgr_cleanup(&sign_ctx);
	return (rc);
}

CK_RV
rsa_hash_pkcs_verify_final(SESSION		* sess,
	SIGN_VERIFY_CONTEXT  * ctx,
	CK_BYTE		* signature,
	CK_ULONG		sig_len)
{
	CK_BYTE	    * ber_data  = NULL;
	CK_BYTE	    * octet_str = NULL;
	CK_BYTE	    * oid	= NULL;
	CK_BYTE	    * tmp	= NULL;

	CK_ULONG	buf1[16];
	CK_BYTE		hash[SHA1_DIGEST_LENGTH];
	RSA_DIGEST_CONTEXT  * context = NULL;
	CK_ULONG	ber_data_len, hash_len, octet_str_len, oid_len;
	CK_MECHANISM	  verify_mech;
	SIGN_VERIFY_CONTEXT   verify_ctx;
	CK_RV		 rc;

	if (! sess || ! ctx || ! signature) {
		return (CKR_FUNCTION_FAILED);
	}
	if (ctx->mech.mechanism == CKM_MD5_RSA_PKCS) {
		oid = ber_AlgMd5;
		oid_len = ber_AlgMd5Len;
		hash_len = MD5_DIGEST_LENGTH;
	} else {
		oid = ber_AlgSha1;
		oid_len = ber_AlgSha1Len;
		hash_len = SHA1_DIGEST_LENGTH;
	}

	(void) memset(&verify_ctx, 0x0, sizeof (verify_ctx));

	context = (RSA_DIGEST_CONTEXT *)ctx->context;

	rc = digest_mgr_digest_final(sess, &context->hash_context,
	    hash, &hash_len);
	if (rc != CKR_OK) {
		goto done;
	}
	rc = ber_encode_OCTET_STRING(FALSE, &octet_str, &octet_str_len,
	    hash, hash_len);
	if (rc != CKR_OK) {
		goto done;
	}
	tmp = (CK_BYTE *)buf1;
	(void) memcpy(tmp, oid, oid_len);
	(void) memcpy(tmp + oid_len, octet_str, octet_str_len);

	rc = ber_encode_SEQUENCE(FALSE, &ber_data, &ber_data_len,
	    tmp, (oid_len + octet_str_len));
	if (rc != CKR_OK) {
		goto done;
	}
	verify_mech.mechanism	= CKM_RSA_PKCS;
	verify_mech.ulParameterLen = 0;
	verify_mech.pParameter	= NULL;

	rc = verify_mgr_init(sess, &verify_ctx, &verify_mech, FALSE, ctx->key);
	if (rc != CKR_OK) {
		goto done;
	}
	rc = verify_mgr_verify(sess, &verify_ctx, ber_data,
	    ber_data_len, signature, sig_len);
done:
	if (octet_str) free(octet_str);
	if (ber_data)  free(ber_data);
	(void) digest_mgr_cleanup(&context->hash_context);
	(void) verify_mgr_cleanup(&verify_ctx);
	return (rc);
}