kcf_prov_tabs.c revision d3b2efc749bec3b757d5f018cf78c9a09fa29cb3
/*
* 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
* 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 2010 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* This file is part of the core Kernel Cryptographic Framework.
* It implements the management of tables of Providers. Entries to
* added and removed when cryptographic providers register with
* and unregister from the framework, respectively. The KCF scheduler
* and ioctl pseudo driver call this function to obtain the list
* of available providers.
*
* The provider table is indexed by crypto_provider_id_t. Each
* element of the table contains a pointer to a provider descriptor,
* or NULL if the entry is free.
*
* This file also implements helper functions to allocate and free
* provider descriptors.
*/
/*
* Prov_tab is an array of providers which is updated when
* a crypto provider registers with kcf. The provider calls the
* SPI routine, crypto_register_provider(), which in turn calls
* kcf_prov_tab_add_provider().
*
* A provider unregisters by calling crypto_unregister_provider()
* which triggers the removal of the prov_tab entry.
* It also calls kcf_remove_mech_provider().
*
* prov_tab entries are not updated from kcf.conf or by cryptoadm(1M).
*/
static void kcf_free_unregistered_provs();
#if DEBUG
extern int kcf_frmwrk_debug;
static void kcf_prov_tab_dump(char *message);
#endif /* DEBUG */
/*
* Initialize a mutex and the KCF providers table, prov_tab.
* The providers table is dynamically allocated with prov_tab_max entries.
* Called from kcf module _init().
*/
void
kcf_prov_tab_init(void)
{
KM_SLEEP);
}
/*
* Add a provider to the provider table. If no free entry can be found
* for the new provider, returns CRYPTO_HOST_MEMORY. Otherwise, add
* the provider to the table, initialize the pd_prov_id field
* of the specified provider descriptor to the index in that table,
* and return CRYPTO_SUCCESS. Note that a REFHOLD is done on the
* provider when pointed to by a table entry.
*/
int
{
uint_t i;
/* see if any slots can be freed */
/* find free slot in providers table */
;
if (i == KCF_MAX_PROVIDERS) {
/* ran out of providers entries */
return (CRYPTO_HOST_MEMORY);
}
/* initialize entry */
prov_tab_num++;
/* update provider descriptor */
prov_desc->pd_prov_id = i;
/*
* The KCF-private provider handle is defined as the internal
* provider id.
*/
#if DEBUG
if (kcf_frmwrk_debug >= 1)
kcf_prov_tab_dump("kcf_prov_tab_add_provider");
#endif /* DEBUG */
return (CRYPTO_SUCCESS);
}
/*
* Remove the provider specified by its id. A REFRELE is done on the
* corresponding provider descriptor before this function returns.
* Returns CRYPTO_UNKNOWN_PROVIDER if the provider id is not valid.
*/
int
{
/*
* Validate provider id, since it can be specified by a 3rd-party
* provider.
*/
if (prov_id >= KCF_MAX_PROVIDERS ||
return (CRYPTO_INVALID_PROVIDER_ID);
}
/*
* The provider id must remain valid until the associated provider
* descriptor is freed. For this reason, we simply release our
* reference to the descriptor here. When the reference count
* reaches zero, kcf_free_provider_desc() will be invoked and
* the associated entry in the providers table will be released
* at that time.
*/
#if DEBUG
if (kcf_frmwrk_debug >= 1)
kcf_prov_tab_dump("kcf_prov_tab_rem_provider");
#endif /* DEBUG */
return (CRYPTO_SUCCESS);
}
/*
* Returns the provider descriptor corresponding to the specified
* provider id. A REFHOLD is done on the descriptor before it is
* returned to the caller. It is the responsibility of the caller
* to do a REFRELE once it is done with the provider descriptor.
*/
{
return (NULL);
}
return (prov_desc);
}
static void
{
KM_SLEEP);
KM_SLEEP);
KM_SLEEP);
KM_SLEEP);
KM_SLEEP);
KM_SLEEP);
KM_SLEEP);
sizeof (crypto_dual_cipher_mac_ops_t), KM_SLEEP);
sizeof (crypto_random_number_ops_t), KM_SLEEP);
/*
* Allocate storage to store the array of supported mechanisms
* specified by provider. We allocate extra mechanism storage
* if the provider has random_ops since we keep an internal
* mechanism, SUN_RANDOM, in this case.
*/
(*mech_list_count)++;
}
KM_SLEEP);
KM_SLEEP);
KM_SLEEP);
sizeof (crypto_provider_management_ops_t), KM_SLEEP);
KM_SLEEP);
}
static void
{
KM_SLEEP);
}
static void
{
}
static void
{
}
/*
* Allocate a provider descriptor. mech_list_count specifies the
* number of mechanisms supported by the providers, and is used
* to allocate storage for the mechanism table.
* This function may sleep while allocating memory, which is OK
* since it is invoked from user context during provider registration.
*/
{
int i, j;
/*
* pd_description serves two purposes
* - Appears as a blank padded PKCS#11 style string, that will be
* returned to applications in CK_SLOT_INFO.slotDescription.
* This means that we should not have a null character in the
* first CRYPTO_PROVIDER_DESCR_MAX_LEN bytes.
* - Appears as a null-terminated string that can be used by
* other kcf routines.
*
* So, we allocate enough room for one extra null terminator
* which keeps every one happy.
*/
KM_SLEEP);
/*
* Since the framework does not require the ops vector specified
* by the providers during registration to be persistent,
* KCF needs to allocate storage where copies of the ops
* vectors are copied.
*/
}
for (i = 0; i < KCF_OPS_CLASSSIZE; i++)
for (j = 0; j < KCF_MAXMECHTAB; j++)
return (desc);
}
/*
* Free a provider descriptor. Caller must hold prov_tab_mutex.
*
* Caution: This routine drops prov_tab_mutex.
*/
void
{
return;
/* release the associated providers table entry */
prov_tab_num--;
}
/* free the kernel memory associated with the provider descriptor */
sizeof (crypto_control_ops_t));
sizeof (crypto_digest_ops_t));
sizeof (crypto_cipher_ops_t));
sizeof (crypto_mac_ops_t));
sizeof (crypto_sign_ops_t));
sizeof (crypto_verify_ops_t));
sizeof (crypto_dual_ops_t));
sizeof (crypto_dual_cipher_mac_ops_t));
sizeof (crypto_random_number_ops_t));
sizeof (crypto_session_ops_t));
sizeof (crypto_object_ops_t));
sizeof (crypto_key_ops_t));
sizeof (crypto_provider_management_ops_t));
sizeof (crypto_ctx_ops_t));
sizeof (crypto_mech_ops_t));
sizeof (crypto_nostore_key_ops_t));
sizeof (crypto_fips140_ops_t));
}
/* free the memory associated with the mechanism info's */
}
}
}
/*
* Returns the provider descriptor corresponding to the specified
* module name. A REFHOLD is done on the descriptor before it is
* returned to the caller. It is the responsibility of the caller
* to do a REFRELE once it is done with the provider descriptor.
* Only software providers are returned by this function.
*/
{
uint_t i;
for (i = 0; i < KCF_MAX_PROVIDERS; i++) {
(!KCF_IS_PROV_REMOVED(prov_desc)) &&
MAXNAMELEN) == 0) {
return (prov_desc);
}
}
}
return (NULL);
}
/*
* Returns the provider descriptor corresponding to the specified
* device name and instance. A REFHOLD is done on the descriptor
* before it is returned to the caller. It is the responsibility
* of the caller to do a REFRELE once it is done with the provider
* descriptor. Only hardware providers are returned by this function.
*/
{
uint_t i;
for (i = 0; i < KCF_MAX_PROVIDERS; i++) {
(!KCF_IS_PROV_REMOVED(prov_desc)) &&
MAXNAMELEN) == 0 &&
return (prov_desc);
}
}
}
return (NULL);
}
/*
* Returns an array of hardware and logical provider descriptors,
* a.k.a the PKCS#11 slot list. A REFHOLD is done on each descriptor
* before the array is returned. The entire table can be freed by
* calling kcf_free_provider_tab().
*/
int
{
kcf_provider_desc_t **p = NULL;
char *last;
uint_t i, j;
int rval = CRYPTO_SUCCESS;
size_t n, final_size;
/* count the providers */
for (i = 0; i < KCF_MAX_PROVIDERS; i++) {
if (KCF_IS_PROV_USABLE(prov_desc) ||
cnt++;
}
}
}
if (cnt == 0)
goto out;
n = cnt * sizeof (kcf_provider_desc_t *);
p = kmem_zalloc(n, KM_SLEEP);
/* pointer to last entry in the array */
/* fill the slot list */
for (i = 0, j = 0; i < KCF_MAX_PROVIDERS; i++) {
if (KCF_IS_PROV_USABLE(prov_desc) ||
if ((char *)&p[j] > last) {
kcf_free_provider_tab(cnt, p);
n = n << 1;
goto again;
}
p[j++] = prov_desc;
}
}
}
final_size = j * sizeof (kcf_provider_desc_t *);
cnt = j;
ASSERT(final_size <= n);
/* check if buffer we allocated is too large */
if (final_size < n) {
char *final_buffer = NULL;
if (final_size > 0) {
}
kmem_free(p, n);
p = (kcf_provider_desc_t **)(void *)final_buffer;
}
out:
*array = p;
return (rval);
}
/*
* Returns an array of hardware provider descriptors. This routine
* used by cryptoadm(1M). A REFHOLD is done on each descriptor before
* the array is returned. The entire table can be freed by calling
* kcf_free_provider_tab().
*
* A NULL name argument puts all hardware providers in the array.
* A non-NULL name argument puts only those providers in the array
* which match the name and instance arguments.
*/
int
{
kcf_provider_desc_t **p = NULL;
char *last;
uint_t i, j;
int rval = CRYPTO_SUCCESS;
size_t n, final_size;
/* count the providers */
for (i = 0; i < KCF_MAX_PROVIDERS; i++) {
if (KCF_IS_PROV_USABLE(prov_desc) ||
MAXNAMELEN) == 0 &&
cnt++;
}
}
}
}
if (cnt == 0)
goto out;
n = cnt * sizeof (kcf_provider_desc_t *);
p = kmem_zalloc(n, kmflag);
if (p == NULL) {
goto out;
}
/* pointer to last entry in the array */
for (i = 0, j = 0; i < KCF_MAX_PROVIDERS; i++) {
if (KCF_IS_PROV_USABLE(prov_desc) ||
MAXNAMELEN) == 0 &&
if ((char *)&p[j] > last) {
kcf_free_provider_tab(cnt, p);
n = n << 1;
goto again;
}
p[j++] = prov_desc;
}
}
}
}
final_size = j * sizeof (kcf_provider_desc_t *);
ASSERT(final_size <= n);
/* check if buffer we allocated is too large */
if (final_size < n) {
char *final_buffer = NULL;
if (final_size > 0) {
if (final_buffer == NULL) {
kcf_free_provider_tab(cnt, p);
cnt = 0;
p = NULL;
goto out;
}
}
kmem_free(p, n);
p = (kcf_provider_desc_t **)(void *)final_buffer;
}
cnt = j;
out:
*array = p;
return (rval);
}
/*
* Free an array of hardware provider descriptors. A REFRELE
* is done on each descriptor before the table is freed.
*/
void
{
int i;
for (i = 0; i < count; i++) {
}
}
}
/*
* Returns in the location pointed to by pd a pointer to the descriptor
* for the software provider for the specified mechanism.
* The provider descriptor is returned held and it is the caller's
* responsibility to release it when done. The mechanism entry
* is returned if the optional argument mep is non NULL.
*
* Returns one of the CRYPTO_ * error codes on failure, and
* CRYPTO_SUCCESS on success.
*/
int
{
/* get the mechanism entry for this mechanism */
return (CRYPTO_MECHANISM_INVALID);
/*
* Get the software provider for this mechanism.
* Lock the mech_entry until we grab the 'pd'.
*/
/* no SW provider for this mechanism */
if (log_warn)
return (CRYPTO_MECH_NOT_SUPPORTED);
}
return (CRYPTO_SUCCESS);
}
#if DEBUG
/*
* Dump the Kernel crypto providers table, prov_tab.
* If kcf_frmwrk_debug is >=2, also dump the mechanism lists.
*/
static void
kcf_prov_tab_dump(char *message)
{
uint_t i, j;
printf("Providers table prov_tab at %s:\n",
for (i = 0; i < KCF_MAX_PROVIDERS; i++) {
kcf_provider_desc_t *p = prov_tab[i];
if (p != NULL) {
printf("[%d]: (%s) %d mechanisms, %s\n", i,
(p->pd_prov_type == CRYPTO_HW_PROVIDER) ?
"HW" : "SW",
p->pd_mech_list_count, p->pd_description);
if (kcf_frmwrk_debug >= 2) {
printf("\tpd_mechanisms: ");
for (j = 0; j < p->pd_mech_list_count; ++j) {
printf("%s \n",
p->pd_mechanisms[j].cm_mech_name);
}
printf("\n");
}
}
}
printf("(end of providers table)\n");
}
#endif /* DEBUG */
/*
* This function goes through the provider table and verifies
* any KCF_PROV_UNVERIFIED providers.
*
* This is called when kcfd is up and the door handle is ready. It is
* again called when the status of FIPS 140 has been determined, so providers
* delayed by FIPS 140 can now be verified.
*/
void
{
int i;
return;
for (i = 0; i < KCF_MAX_PROVIDERS; i++) {
continue;
continue;
if (!need_verify)
continue;
/*
* We need to drop this lock, since it could be
* acquired by kcf_verify_signature().
* This is safe, as any providers that are
* added to the table after we dropped the
* lock *will see* a non NULL kcf_dh and hence
* would have been verified by other means.
*/
/* This routine will release the above holds */
}
}
/* protected by prov_tab_mutex */
/* Caller must hold prov_tab_mutex */
static void
{
int i;
for (i = 0; i < KCF_MAX_PROVIDERS; i++) {
continue;
/* kcf_free_provider_desc drops prov_tab_mutex */
} else
walk_again = B_TRUE;
}
}