crypto/api/kcf_ctxops.c

	kcf_ctxops.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I% %E% SMI"

#include <sys/errno.h>
#include <sys/types.h>
#include <sys/systm.h>
#include <sys/kmem.h>
#include <sys/crypto/common.h>
#include <sys/crypto/impl.h>
#include <sys/crypto/api.h>
#include <sys/crypto/spi.h>
#include <sys/crypto/sched_impl.h>

/*
 * Crypto contexts manipulation routines
 */

/*
 * crypto_create_ctx_template()
 *
 * Arguments:
 *
 *  mech:   crypto_mechanism_t pointer.
 *      mech_type is a valid value previously returned by
 *      crypto_mech2id();
 *      When the mech's parameter is not NULL, its definition depends
 *      on the standard definition of the mechanism.
 *  key:    pointer to a crypto_key_t structure.
 *  ptmpl:  a storage for the opaque crypto_ctx_template_t, allocated and
 *      initialized by the software provider this routine is
 *      dispatched to.
 *  kmflag: KM_SLEEP/KM_NOSLEEP mem. alloc. flag.
 *
 * Description:
 *  Redirects the call to the software provider of the specified
 *  mechanism. That provider will allocate and pre-compute/pre-expand
 *  the context template, reusable by later calls to crypto_xxx_init().
 *  The size and address of that provider context template are stored
 *  in an internal structure, kcf_ctx_template_t. The address of that
 *  structure is given back to the caller in *ptmpl.
 *
 * Context:
 *  Process or interrupt.
 *
 * Returns:
 *  CRYPTO_SUCCESS when the context template is successfully created.
 *  CRYPTO_HOST_MEMEORY: mem alloc failure
 *  CRYPTO_ARGUMENTS_BAD: NULL storage for the ctx template.
 *  RYPTO_MECHANISM_INVALID: invalid mechanism 'mech'.
 */
int
crypto_create_ctx_template(crypto_mechanism_t *mech, crypto_key_t *key,
    crypto_ctx_template_t *ptmpl, int kmflag)
{
    int error;
    kcf_mech_entry_t *me;
    kcf_prov_mech_desc_t *pm;
    kcf_provider_desc_t *pd;
    kcf_ctx_template_t *ctx_tmpl;
    crypto_mechanism_t prov_mech;
    kcf_ops_class_t class;
    int index;

    /* A few args validation */

    if (ptmpl == NULL)
        return (CRYPTO_ARGUMENTS_BAD);

    if (mech == NULL)
        return (CRYPTO_MECHANISM_INVALID);

    if (kcf_get_mech_entry(mech->cm_type, &me) != KCF_SUCCESS) {
        /* error is one of the KCF_INVALID_MECH_XXX's */
        return (CRYPTO_MECHANISM_INVALID);
    }

    /*
     * Get the software provider for the mech.
     * Lock the mech_entry until we grab the 'pd'
     */
    mutex_enter(&me->me_mutex);

    if (((pm = me->me_sw_prov) == NULL) ||
        ((pd = pm->pm_prov_desc) == NULL)) {
        mutex_exit(&me->me_mutex);
        return (CRYPTO_MECH_NOT_SUPPORTED);
    }
    KCF_PROV_REFHOLD(pd);
    mutex_exit(&me->me_mutex);

    if ((ctx_tmpl = (kcf_ctx_template_t *)kmem_alloc(
        sizeof (kcf_ctx_template_t), kmflag)) == NULL) {
        KCF_PROV_REFRELE(pd);
        return (CRYPTO_HOST_MEMORY);
    }

    /* Pass a mechtype that the provider understands */
    class = KCF_MECH2CLASS(mech->cm_type);
    index = KCF_MECH2INDEX(mech->cm_type);
    prov_mech.cm_type = pd->pd_map_mechnums[class][index];
    prov_mech.cm_param = mech->cm_param;
    prov_mech.cm_param_len = mech->cm_param_len;

    error = KCF_PROV_CREATE_CTX_TEMPLATE(pd, &prov_mech, key,
        &(ctx_tmpl->ct_prov_tmpl), &(ctx_tmpl->ct_size), KCF_RHNDL(kmflag));

    if (error == CRYPTO_SUCCESS) {
        ctx_tmpl->ct_generation = me->me_gen_swprov;
        *ptmpl = ctx_tmpl;
    } else {
        kmem_free(ctx_tmpl, sizeof (kcf_ctx_template_t));
    }
    KCF_PROV_REFRELE(pd);

    return (error);
}

/*
 * crypto_destroy_ctx_template()
 *
 * Arguments:
 *
 *  tmpl:   an opaque crypto_ctx_template_t previously created by
 *      crypto_create_ctx_template()
 *
 * Description:
 *  Frees the inbedded crypto_spi_ctx_template_t, then the
 *  kcf_ctx_template_t.
 *
 * Context:
 *  Process or interrupt.
 *
 */
void
crypto_destroy_ctx_template(crypto_ctx_template_t tmpl)
{
    kcf_ctx_template_t *ctx_tmpl = (kcf_ctx_template_t *)tmpl;

    if (ctx_tmpl == NULL)
        return;

    ASSERT(ctx_tmpl->ct_prov_tmpl != NULL);

    bzero(ctx_tmpl->ct_prov_tmpl, ctx_tmpl->ct_size);
    kmem_free(ctx_tmpl->ct_prov_tmpl, ctx_tmpl->ct_size);
    kmem_free(ctx_tmpl, sizeof (kcf_ctx_template_t));
}