]>
Commit | Line | Data |
---|---|---|
86e3c28a CIK |
1 | /* |
2 | * CDDL HEADER START | |
3 | * | |
4 | * The contents of this file are subject to the terms of the | |
5 | * Common Development and Distribution License (the "License"). | |
6 | * You may not use this file except in compliance with the License. | |
7 | * | |
8 | * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE | |
9 | * or http://www.opensolaris.org/os/licensing. | |
10 | * See the License for the specific language governing permissions | |
11 | * and limitations under the License. | |
12 | * | |
13 | * When distributing Covered Code, include this CDDL HEADER in each | |
14 | * file and include the License file at usr/src/OPENSOLARIS.LICENSE. | |
15 | * If applicable, add the following below this CDDL HEADER, with the | |
16 | * fields enclosed by brackets "[]" replaced with your own identifying | |
17 | * information: Portions Copyright [yyyy] [name of copyright owner] | |
18 | * | |
19 | * CDDL HEADER END | |
20 | */ | |
21 | /* | |
22 | * Copyright 2007 Sun Microsystems, Inc. All rights reserved. | |
23 | * Use is subject to license terms. | |
24 | */ | |
25 | ||
26 | #include <sys/zfs_context.h> | |
27 | #include <sys/crypto/common.h> | |
28 | #include <sys/crypto/impl.h> | |
29 | #include <sys/crypto/api.h> | |
30 | #include <sys/crypto/spi.h> | |
31 | #include <sys/crypto/sched_impl.h> | |
32 | ||
33 | /* | |
34 | * Crypto contexts manipulation routines | |
35 | */ | |
36 | ||
37 | /* | |
38 | * crypto_create_ctx_template() | |
39 | * | |
40 | * Arguments: | |
41 | * | |
42 | * mech: crypto_mechanism_t pointer. | |
43 | * mech_type is a valid value previously returned by | |
44 | * crypto_mech2id(); | |
45 | * When the mech's parameter is not NULL, its definition depends | |
46 | * on the standard definition of the mechanism. | |
47 | * key: pointer to a crypto_key_t structure. | |
48 | * ptmpl: a storage for the opaque crypto_ctx_template_t, allocated and | |
49 | * initialized by the software provider this routine is | |
50 | * dispatched to. | |
51 | * kmflag: KM_SLEEP/KM_NOSLEEP mem. alloc. flag. | |
52 | * | |
53 | * Description: | |
54 | * Redirects the call to the software provider of the specified | |
55 | * mechanism. That provider will allocate and pre-compute/pre-expand | |
56 | * the context template, reusable by later calls to crypto_xxx_init(). | |
57 | * The size and address of that provider context template are stored | |
58 | * in an internal structure, kcf_ctx_template_t. The address of that | |
59 | * structure is given back to the caller in *ptmpl. | |
60 | * | |
61 | * Context: | |
62 | * Process or interrupt. | |
63 | * | |
64 | * Returns: | |
65 | * CRYPTO_SUCCESS when the context template is successfully created. | |
66 | * CRYPTO_HOST_MEMEORY: mem alloc failure | |
67 | * CRYPTO_ARGUMENTS_BAD: NULL storage for the ctx template. | |
68 | * RYPTO_MECHANISM_INVALID: invalid mechanism 'mech'. | |
69 | */ | |
70 | int | |
71 | crypto_create_ctx_template(crypto_mechanism_t *mech, crypto_key_t *key, | |
72 | crypto_ctx_template_t *ptmpl, int kmflag) | |
73 | { | |
74 | int error; | |
75 | kcf_mech_entry_t *me; | |
76 | kcf_provider_desc_t *pd; | |
77 | kcf_ctx_template_t *ctx_tmpl; | |
78 | crypto_mechanism_t prov_mech; | |
79 | ||
80 | /* A few args validation */ | |
81 | ||
82 | if (ptmpl == NULL) | |
83 | return (CRYPTO_ARGUMENTS_BAD); | |
84 | ||
85 | if (mech == NULL) | |
86 | return (CRYPTO_MECHANISM_INVALID); | |
87 | ||
88 | error = kcf_get_sw_prov(mech->cm_type, &pd, &me, B_TRUE); | |
89 | if (error != CRYPTO_SUCCESS) | |
90 | return (error); | |
91 | ||
92 | if ((ctx_tmpl = (kcf_ctx_template_t *)kmem_alloc( | |
93 | sizeof (kcf_ctx_template_t), kmflag)) == NULL) { | |
94 | KCF_PROV_REFRELE(pd); | |
95 | return (CRYPTO_HOST_MEMORY); | |
96 | } | |
97 | ||
98 | /* Pass a mechtype that the provider understands */ | |
99 | prov_mech.cm_type = KCF_TO_PROV_MECHNUM(pd, mech->cm_type); | |
100 | prov_mech.cm_param = mech->cm_param; | |
101 | prov_mech.cm_param_len = mech->cm_param_len; | |
102 | ||
103 | error = KCF_PROV_CREATE_CTX_TEMPLATE(pd, &prov_mech, key, | |
104 | &(ctx_tmpl->ct_prov_tmpl), &(ctx_tmpl->ct_size), KCF_RHNDL(kmflag)); | |
105 | ||
106 | if (error == CRYPTO_SUCCESS) { | |
107 | ctx_tmpl->ct_generation = me->me_gen_swprov; | |
108 | *ptmpl = ctx_tmpl; | |
109 | } else { | |
110 | kmem_free(ctx_tmpl, sizeof (kcf_ctx_template_t)); | |
111 | } | |
112 | KCF_PROV_REFRELE(pd); | |
113 | ||
114 | return (error); | |
115 | } | |
116 | ||
117 | /* | |
118 | * crypto_destroy_ctx_template() | |
119 | * | |
120 | * Arguments: | |
121 | * | |
122 | * tmpl: an opaque crypto_ctx_template_t previously created by | |
123 | * crypto_create_ctx_template() | |
124 | * | |
125 | * Description: | |
126 | * Frees the inbedded crypto_spi_ctx_template_t, then the | |
127 | * kcf_ctx_template_t. | |
128 | * | |
129 | * Context: | |
130 | * Process or interrupt. | |
131 | * | |
132 | */ | |
133 | void | |
134 | crypto_destroy_ctx_template(crypto_ctx_template_t tmpl) | |
135 | { | |
136 | kcf_ctx_template_t *ctx_tmpl = (kcf_ctx_template_t *)tmpl; | |
137 | ||
138 | if (ctx_tmpl == NULL) | |
139 | return; | |
140 | ||
141 | ASSERT(ctx_tmpl->ct_prov_tmpl != NULL); | |
142 | ||
143 | bzero(ctx_tmpl->ct_prov_tmpl, ctx_tmpl->ct_size); | |
144 | kmem_free(ctx_tmpl->ct_prov_tmpl, ctx_tmpl->ct_size); | |
145 | kmem_free(ctx_tmpl, sizeof (kcf_ctx_template_t)); | |
146 | } | |
147 | ||
148 | #if defined(_KERNEL) && defined(HAVE_SPL) | |
149 | EXPORT_SYMBOL(crypto_create_ctx_template); | |
150 | EXPORT_SYMBOL(crypto_destroy_ctx_template); | |
151 | #endif |