kernelEmulate.c revision 4df55fde49134f9735f84011f23a767c75e393c7
/*
* 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 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#include <errno.h>
#include <stdio.h>
#include <strings.h>
#include <sys/crypto/ioctl.h>
#include <security/cryptoki.h>
#include "kernelGlobal.h"
#include "kernelSession.h"
#include "kernelEmulate.h"
/*
* Helper routine to know if this is a HMAC. We can't just check
* the CKF_SIGN mech flag as it is set for non-HMAC mechs too.
*/
boolean_t
is_hmac(CK_MECHANISM_TYPE mechanism)
{
switch (mechanism) {
case CKM_SSL3_MD5_MAC:
case CKM_SSL3_SHA1_MAC:
case CKM_MD5_HMAC_GENERAL:
case CKM_MD5_HMAC:
case CKM_SHA_1_HMAC_GENERAL:
case CKM_SHA_1_HMAC:
case CKM_SHA256_HMAC_GENERAL:
case CKM_SHA256_HMAC:
case CKM_SHA384_HMAC_GENERAL:
case CKM_SHA384_HMAC:
case CKM_SHA512_HMAC_GENERAL:
case CKM_SHA512_HMAC:
return (B_TRUE);
default:
return (B_FALSE);
}
}
/*
* Helper routine to allocate an emulation structure for the session.
* buflen indicates the size of the scratch buffer to be allocated.
*/
CK_RV
emulate_buf_init(kernel_session_t *session_p, int buflen, int opflag)
{
digest_buf_t *bufp;
crypto_active_op_t *opp;
opp = (opflag & OP_DIGEST) ? &(session_p->digest) : \
((opflag & OP_SIGN) ? &(session_p->sign) : &(session_p->verify));
bufp = opp->context;
if (bufp != NULL) {
bufp->indata_len = 0;
/*
* We can reuse the context structure, digest_buf_t.
* See if we can reuse the scratch buffer in the context too.
*/
if (buflen > bufp->buf_len) {
free(bufp->buf);
bufp->buf = NULL;
}
} else {
bufp = opp->context = calloc(1, sizeof (digest_buf_t));
if (bufp == NULL) {
return (CKR_HOST_MEMORY);
}
}
if (bufp->buf == NULL) {
bufp->buf = malloc(buflen);
if (bufp->buf == NULL) {
free(bufp);
opp->context = NULL;
return (CKR_HOST_MEMORY);
}
bufp->buf_len = buflen;
}
return (CKR_OK);
}
/*
* Setup the support necessary to do this operation in a
* single part. We allocate a buffer to accumulate the
* input data from later calls. We also get ready for
* the case where we have to do it in software by initializing
* a standby context. The opflag tells if this is a sign or verify.
*/
CK_RV
emulate_init(kernel_session_t *session_p, CK_MECHANISM_PTR pMechanism,
crypto_key_t *keyp, int opflag)
{
CK_RV rv;
crypto_active_op_t *opp;
if ((rv = emulate_buf_init(session_p, EDIGEST_LENGTH, opflag)) !=
CKR_OK)
return (rv);
opp = (opflag & OP_SIGN) ? &(session_p->sign) : &(session_p->verify);
opflag |= OP_INIT;
rv = do_soft_hmac_init(get_spp(opp), pMechanism, keyp->ck_data,
keyp->ck_length >> 3, opflag);
return (rv);
}
#define DO_SOFT_UPDATE(opp, pPart, ulPartLen, opflag) \
if ((opflag) & OP_DIGEST) { \
rv = do_soft_digest(get_spp(opp), NULL, pPart, \
ulPartLen, NULL, NULL, opflag); \
} else { \
rv = do_soft_hmac_update(get_spp(opp), pPart, \
ulPartLen, opflag); \
}
/*
* Accumulate the input data in the buffer, allocating a bigger
* buffer if needed. If we reach the maximum input data size
* that can be accumulated, start using the software from then on.
* The opflag tells if this is a digest, sign or verify.
*/
CK_RV
emulate_update(kernel_session_t *session_p, CK_BYTE_PTR pPart,
CK_ULONG ulPartLen, int opflag)
{
CK_RV rv;
int maxlen;
digest_buf_t *bufp;
boolean_t use_soft = B_FALSE;
crypto_active_op_t *opp;
if (opflag & OP_DIGEST) {
opp = &(session_p->digest);
if (!SLOT_HAS_LIMITED_HASH(session_p))
return (CKR_ARGUMENTS_BAD);
maxlen = SLOT_HASH_MAX_INDATA_LEN(session_p);
} else if (opflag & (OP_SIGN | OP_VERIFY)) {
opp = (opflag & OP_SIGN) ?
&(session_p->sign) : &(session_p->verify);
if (!SLOT_HAS_LIMITED_HMAC(session_p))
return (CKR_ARGUMENTS_BAD);
maxlen = SLOT_HMAC_MAX_INDATA_LEN(session_p);
} else
return (CKR_ARGUMENTS_BAD);
if (opp->flags & CRYPTO_EMULATE_USING_SW) {
opflag |= OP_UPDATE;
DO_SOFT_UPDATE(opp, pPart, ulPartLen, opflag);
opp->flags |= CRYPTO_EMULATE_UPDATE_DONE;
return (rv);
}
bufp = opp->context;
if (bufp == NULL) {
return (CKR_FUNCTION_FAILED);
}
/* Did we exceed the maximum allowed? */
if (bufp->indata_len + ulPartLen > maxlen) {
use_soft = B_TRUE;
} else if (ulPartLen > (bufp->buf_len - bufp->indata_len)) {
int siz = ulPartLen < bufp->buf_len ?
bufp->buf_len * 2 : bufp->buf_len + ulPartLen;
uint8_t *old = bufp->buf;
bufp->buf = realloc(bufp->buf, siz);
if (bufp->buf == NULL) {
/* Try harder rather than failing */
bufp->buf = old;
use_soft = B_TRUE;
} else
bufp->buf_len = siz;
}
if (use_soft) {
opp->flags |= CRYPTO_EMULATE_USING_SW;
if (opflag & OP_DIGEST) {
CK_MECHANISM_PTR pMechanism;
pMechanism = &(opp->mech);
rv = do_soft_digest(get_spp(opp), pMechanism, NULL, 0,
NULL, NULL, OP_INIT);
if (rv != CKR_OK)
return (rv);
}
opflag |= OP_UPDATE;
DO_SOFT_UPDATE(opp, bufp->buf, bufp->indata_len, opflag);
opp->flags |= CRYPTO_EMULATE_UPDATE_DONE;
if (rv == CKR_OK) {
DO_SOFT_UPDATE(opp, pPart, ulPartLen, opflag);
}
return (rv);
}
/* accumulate the update data */
bcopy(pPart, bufp->buf + bufp->indata_len, ulPartLen);
bufp->indata_len += ulPartLen;
return (CKR_OK);
}