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 2010 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #include <stdio.h>
27 #include <link.h>
28 #include <fcntl.h>
29 #include <ctype.h>
30 #include <sys/param.h>
31 #include <sys/types.h>
32 #include <sys/stat.h>
33 #include <ber_der.h>
34 #include <kmfapiP.h>
35 #include <libgen.h>
36 #include <cryptoutil.h>
37
38 KMF_RETURN
kmf_create_keypair(KMF_HANDLE_T handle,int num_args,KMF_ATTRIBUTE * attrlist)39 kmf_create_keypair(KMF_HANDLE_T handle,
40 int num_args,
41 KMF_ATTRIBUTE *attrlist)
42 {
43 KMF_RETURN ret = KMF_OK;
44 KMF_PLUGIN *plugin;
45 KMF_KEYSTORE_TYPE kstype;
46 uint32_t len;
47
48 KMF_ATTRIBUTE_TESTER required_attrs[] = {
49 {KMF_KEYSTORE_TYPE_ATTR, FALSE, 1, sizeof (KMF_KEYSTORE_TYPE)},
50 {KMF_PRIVKEY_HANDLE_ATTR, FALSE, sizeof (KMF_KEY_HANDLE),
51 sizeof (KMF_KEY_HANDLE)},
52 {KMF_PUBKEY_HANDLE_ATTR, FALSE, sizeof (KMF_KEY_HANDLE),
53 sizeof (KMF_KEY_HANDLE)},
54 };
55
56 int num_req_attrs = sizeof (required_attrs) /
57 sizeof (KMF_ATTRIBUTE_TESTER);
58
59 if (handle == NULL)
60 return (KMF_ERR_BAD_PARAMETER);
61
62 CLEAR_ERROR(handle, ret);
63
64 ret = test_attributes(num_req_attrs, required_attrs,
65 0, NULL, num_args, attrlist);
66
67 if (ret != KMF_OK)
68 return (ret);
69
70 len = sizeof (kstype);
71 ret = kmf_get_attr(KMF_KEYSTORE_TYPE_ATTR, attrlist, num_args,
72 &kstype, &len);
73 if (ret != KMF_OK)
74 return (ret);
75
76 plugin = FindPlugin(handle, kstype);
77 if (plugin != NULL && plugin->funclist->CreateKeypair != NULL) {
78 return (plugin->funclist->CreateKeypair(handle, num_args,
79 attrlist));
80 } else {
81 return (KMF_ERR_PLUGIN_NOTFOUND);
82 }
83 }
84
85 KMF_RETURN
kmf_delete_key_from_keystore(KMF_HANDLE_T handle,int num_args,KMF_ATTRIBUTE * attrlist)86 kmf_delete_key_from_keystore(KMF_HANDLE_T handle,
87 int num_args,
88 KMF_ATTRIBUTE *attrlist)
89 {
90 KMF_RETURN ret = KMF_OK;
91 KMF_PLUGIN *plugin;
92 KMF_KEYSTORE_TYPE kstype;
93 uint32_t len;
94 KMF_KEY_HANDLE *key;
95
96
97 KMF_ATTRIBUTE_TESTER required_attrs[] = {
98 {KMF_KEYSTORE_TYPE_ATTR, FALSE, 1, sizeof (KMF_KEYSTORE_TYPE)},
99 {KMF_KEY_HANDLE_ATTR, FALSE, sizeof (KMF_KEY_HANDLE),
100 sizeof (KMF_KEY_HANDLE)},
101 };
102
103 int num_req_attrs = sizeof (required_attrs) /
104 sizeof (KMF_ATTRIBUTE_TESTER);
105
106 if (handle == NULL)
107 return (KMF_ERR_BAD_PARAMETER);
108
109 CLEAR_ERROR(handle, ret);
110
111 ret = test_attributes(num_req_attrs, required_attrs,
112 0, NULL, num_args, attrlist);
113
114 if (ret != KMF_OK)
115 return (ret);
116
117 len = sizeof (kstype);
118 ret = kmf_get_attr(KMF_KEYSTORE_TYPE_ATTR, attrlist, num_args,
119 &kstype, &len);
120 if (ret != KMF_OK)
121 return (ret);
122
123 plugin = FindPlugin(handle, kstype);
124 if (plugin != NULL && plugin->funclist->DeleteKey != NULL) {
125 ret = plugin->funclist->DeleteKey(handle, num_args, attrlist);
126 } else {
127 ret = KMF_ERR_PLUGIN_NOTFOUND;
128 }
129
130 if (ret == KMF_OK) {
131 key = kmf_get_attr_ptr(KMF_KEY_HANDLE_ATTR, attrlist, num_args);
132 if (key == NULL)
133 return (KMF_ERR_BAD_PARAMETER);
134 if (key->keylabel != NULL)
135 free(key->keylabel);
136
137 if (key->israw && key->keyp != NULL) {
138 if (key->keyclass == KMF_ASYM_PUB ||
139 key->keyclass == KMF_ASYM_PRI) {
140 kmf_free_raw_key(key->keyp);
141 free(key->keyp);
142 } else if (key->keyclass == KMF_SYMMETRIC) {
143 kmf_free_raw_sym_key(key->keyp);
144 }
145 /* Else we don't know how to free the memory. */
146 }
147
148 (void) memset(key, 0, sizeof (KMF_KEY_HANDLE));
149 }
150
151 return (ret);
152 }
153
154 KMF_RETURN
kmf_find_key(KMF_HANDLE_T handle,int num_args,KMF_ATTRIBUTE * attrlist)155 kmf_find_key(KMF_HANDLE_T handle,
156 int num_args,
157 KMF_ATTRIBUTE *attrlist)
158 {
159 KMF_RETURN ret = KMF_OK;
160 KMF_PLUGIN *plugin;
161 KMF_KEYSTORE_TYPE kstype;
162 uint32_t len;
163
164 KMF_ATTRIBUTE_TESTER required_attrs[] = {
165 {KMF_KEYSTORE_TYPE_ATTR, FALSE, 1, sizeof (KMF_KEYSTORE_TYPE)},
166 {KMF_COUNT_ATTR, FALSE, sizeof (uint32_t),
167 sizeof (uint32_t)}
168 };
169
170 int num_req_attrs = sizeof (required_attrs) /
171 sizeof (KMF_ATTRIBUTE_TESTER);
172
173 if (handle == NULL)
174 return (KMF_ERR_BAD_PARAMETER);
175
176 CLEAR_ERROR(handle, ret);
177
178 ret = test_attributes(num_req_attrs, required_attrs,
179 0, NULL, num_args, attrlist);
180
181 if (ret != KMF_OK)
182 return (ret);
183
184 len = sizeof (kstype);
185 ret = kmf_get_attr(KMF_KEYSTORE_TYPE_ATTR, attrlist, num_args,
186 &kstype, &len);
187 if (ret != KMF_OK)
188 return (ret);
189
190 plugin = FindPlugin(handle, kstype);
191 if (plugin != NULL && plugin->funclist->FindKey != NULL) {
192 return (plugin->funclist->FindKey(handle, num_args, attrlist));
193 }
194
195 return (KMF_ERR_PLUGIN_NOTFOUND);
196 }
197
198 KMF_RETURN
kmf_create_sym_key(KMF_HANDLE_T handle,int num_args,KMF_ATTRIBUTE * attrlist)199 kmf_create_sym_key(KMF_HANDLE_T handle,
200 int num_args,
201 KMF_ATTRIBUTE *attrlist)
202 {
203 KMF_RETURN ret = KMF_OK;
204 KMF_PLUGIN *plugin;
205 KMF_KEYSTORE_TYPE kstype;
206 uint32_t len;
207
208 KMF_ATTRIBUTE_TESTER required_attrs[] = {
209 {KMF_KEYSTORE_TYPE_ATTR, FALSE, 1, sizeof (KMF_KEYSTORE_TYPE)},
210 {KMF_KEY_HANDLE_ATTR, FALSE, sizeof (KMF_KEY_HANDLE),
211 sizeof (KMF_KEY_HANDLE)},
212 {KMF_KEYALG_ATTR, FALSE, 1, sizeof (KMF_KEY_ALG)},
213 };
214
215 int num_req_attrs = sizeof (required_attrs) /
216 sizeof (KMF_ATTRIBUTE_TESTER);
217
218 if (handle == NULL)
219 return (KMF_ERR_BAD_PARAMETER);
220
221 CLEAR_ERROR(handle, ret);
222
223 ret = test_attributes(num_req_attrs, required_attrs,
224 0, NULL, num_args, attrlist);
225
226 if (ret != KMF_OK)
227 return (ret);
228
229 len = sizeof (kstype);
230 ret = kmf_get_attr(KMF_KEYSTORE_TYPE_ATTR, attrlist, num_args,
231 &kstype, &len);
232 if (ret != KMF_OK)
233 return (ret);
234
235 plugin = FindPlugin(handle, kstype);
236 if (plugin != NULL && plugin->funclist->CreateSymKey != NULL) {
237 return (plugin->funclist->CreateSymKey(handle, num_args,
238 attrlist));
239 } else {
240 return (KMF_ERR_PLUGIN_NOTFOUND);
241 }
242 }
243
244 KMF_RETURN
kmf_get_sym_key_value(KMF_HANDLE_T handle,KMF_KEY_HANDLE * symkey,KMF_RAW_SYM_KEY * rkey)245 kmf_get_sym_key_value(KMF_HANDLE_T handle, KMF_KEY_HANDLE *symkey,
246 KMF_RAW_SYM_KEY *rkey)
247 {
248 KMF_PLUGIN *plugin;
249 KMF_RETURN ret;
250
251 CLEAR_ERROR(handle, ret);
252 if (ret != KMF_OK)
253 return (ret);
254
255 if (symkey == NULL || rkey == NULL)
256 return (KMF_ERR_BAD_PARAMETER);
257
258 plugin = FindPlugin(handle, symkey->kstype);
259 if (plugin != NULL &&
260 plugin->funclist->GetSymKeyValue != NULL) {
261 return (plugin->funclist->GetSymKeyValue(handle,
262 symkey, rkey));
263 } else {
264 return (KMF_ERR_PLUGIN_NOTFOUND);
265 }
266 }
267
268 KMF_RETURN
kmf_store_key(KMF_HANDLE_T handle,int numattr,KMF_ATTRIBUTE * attrlist)269 kmf_store_key(KMF_HANDLE_T handle,
270 int numattr,
271 KMF_ATTRIBUTE *attrlist)
272 {
273 KMF_RETURN ret = KMF_OK;
274 KMF_PLUGIN *plugin;
275 KMF_KEYSTORE_TYPE kstype;
276
277 KMF_ATTRIBUTE_TESTER required_attrs[] = {
278 {KMF_KEYSTORE_TYPE_ATTR, FALSE, 1, sizeof (KMF_KEYSTORE_TYPE)},
279 };
280
281 int num_req_attrs = sizeof (required_attrs) /
282 sizeof (KMF_ATTRIBUTE_TESTER);
283
284 if (handle == NULL)
285 return (KMF_ERR_BAD_PARAMETER);
286
287 CLEAR_ERROR(handle, ret);
288
289 ret = test_attributes(num_req_attrs, required_attrs,
290 0, NULL, numattr, attrlist);
291
292 if (ret != KMF_OK)
293 return (ret);
294
295 ret = kmf_get_attr(KMF_KEYSTORE_TYPE_ATTR, attrlist, numattr,
296 &kstype, NULL);
297 if (ret != KMF_OK)
298 return (ret);
299
300 plugin = FindPlugin(handle, kstype);
301 if (plugin != NULL) {
302 if (plugin->funclist->StoreKey != NULL)
303 return (plugin->funclist->StoreKey(handle,
304 numattr, attrlist));
305 else
306 return (KMF_ERR_FUNCTION_NOT_FOUND);
307 }
308 return (KMF_ERR_PLUGIN_NOTFOUND);
309 }
310