xref: /titanic_41/usr/src/lib/pkcs11/libpkcs11/common/metaAttrMasters.h (revision 034448fe565200cb042559f50fab6cf751f182c5)
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 #ifndef _META_ATTRMASTERS_H
27 #define	_META_ATTRMASTERS_H
28 
29 #pragma ident	"%Z%%M%	%I%	%E% SMI"
30 
31 #ifdef	__cplusplus
32 extern "C" {
33 #endif
34 
35 /*
36  * Master object templates
37  *
38  * [This file should only be included by a single source file. This is a
39  * non-traditional header file in that it simply contains a bunch of large,
40  * preinitialized static const structures. They're stored here to keep them
41  * "out of the way."]
42  *
43  * In PKCS#11, each object is well-defined... Each object type has an exact
44  * set of attributes, and each attribute always has some value. Some
45  * attribute values must be specificed when the object is created, others
46  * are optional (ie, a default value exisits). Thus, the template an
47  * application provides when creating a new object may be a subset of the
48  * allowed attributes. The "master" templates presented here, however,
49  * are complete.
50  */
51 
52 
53 /*
54  * Aliases for some field values in generic_attr_t, so that the initialization
55  * below isn't just a confusing mess of B_TRUE and B_FALSE. Lint
56  * complaints about using "!Foo" in const initializers,
57  * so we #define each value.
58  */
59 
60 #define	unused		0
61 #define	Mallocd		B_TRUE
62 #define	Clone		B_TRUE
63 #define	EmptyValue	B_TRUE
64 #define	NotMallocd	B_FALSE
65 #define	NotClone	B_FALSE
66 #define	NotEmptyValue	B_FALSE
67 #define	EMPTYDATE	' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '
68 #define	EMPTY		'\0'
69 
70 /*
71  * A note regarding CKA_CLASS and sub-type (eg CKA_KEY_TYPE)
72  *
73  * These two attributes have been moved to the top of the master template
74  * definitions. All the metaslot code assumes that CKA_CLASS resides in index=0,
75  * and the sub-type resides in index=1.
76  */
77 
78 
79 /*
80  * Common storage object attributes, Table 19 (p81) of PKCS#11 2.11r1 spec.
81  */
82 #define	COMMON_STORAGE_ATTRIBUTES					\
83 	{ { CKA_TOKEN, NULL, sizeof (CK_BBOOL) },			\
84 		NotMallocd, Clone, NotEmptyValue, B_FALSE,		\
85 		CK_FALSE, unused, { unused } },				\
86 	{ { CKA_PRIVATE, NULL, sizeof (CK_BBOOL) },			\
87 		NotMallocd, Clone, NotEmptyValue, B_FALSE,		\
88 		CK_FALSE, unused, { unused } },				\
89 	{ { CKA_MODIFIABLE, NULL, sizeof (CK_BBOOL) },			\
90 		NotMallocd, Clone, NotEmptyValue, B_FALSE,		\
91 		CK_TRUE, unused, { unused } },				\
92 	{ { CKA_LABEL, NULL, 0 },					\
93 		NotMallocd, Clone, EmptyValue, B_FALSE,			\
94 		unused, unused, { EMPTY } }
95 
96 /*
97  * Common certificate attributes, Table 21 (p83) of PKCS#11 2.11r1 spec.
98  * (CKA_CERTIFICATE_TYPE has been moved, to place at top of template)
99  *
100  */
101 #define	COMMON_CERTIFICATE_ATTRIBUTES					\
102 	{ { CKA_TRUSTED, NULL, sizeof (CK_BBOOL) },			\
103 		NotMallocd, NotClone, NotEmptyValue, B_FALSE,		\
104 		CK_FALSE, unused, { unused } }
105 
106 /*
107  * Common key attributes, Table 25 (p89) of PKCS#11 2.11r1 spec.
108  * (CKA_KEY_TYPE has been moved, to place at top of template)
109  *
110  */
111 #define	COMMON_KEY_ATTRIBUTES						\
112 	{ { CKA_ID, NULL, 0 },						\
113 		NotMallocd, Clone, EmptyValue, B_FALSE,			\
114 		unused, unused, { EMPTY } },				\
115 	{ { CKA_START_DATE, NULL, sizeof (CK_DATE) },			\
116 		NotMallocd, Clone, EmptyValue, B_FALSE,			\
117 		unused, unused, { EMPTYDATE } },			\
118 	{ { CKA_END_DATE, NULL, sizeof (CK_DATE) },			\
119 		NotMallocd, Clone, EmptyValue, B_FALSE,			\
120 		unused, unused, { EMPTYDATE } },			\
121 	{ { CKA_DERIVE, NULL, sizeof (CK_BBOOL) },			\
122 		NotMallocd, Clone, NotEmptyValue, B_FALSE,		\
123 		CK_FALSE, unused, { unused } },				\
124 	{ { CKA_LOCAL, NULL, sizeof (CK_BBOOL) },			\
125 		NotMallocd, NotClone, NotEmptyValue, B_FALSE,		\
126 		CK_FALSE, unused, { unused } },				\
127 	{ { CKA_KEY_GEN_MECHANISM, NULL, sizeof (CK_MECHANISM_TYPE) },	\
128 		NotMallocd, NotClone, EmptyValue, B_FALSE,		\
129 		unused, CK_UNAVAILABLE_INFORMATION, { unused } }
130 
131 /*
132  * Common public-key attributes, Table 26 (p90) of PKCS#11 2.11r1 spec.
133  *
134  * CKA_SUBJECT has the PKCS#11-specified default. The object-usage attributes
135  * are token-specific defaults.
136  *
137  */
138 #define	COMMON_PUBKEY_ATTRIBUTES					\
139 	{ { CKA_SUBJECT, NULL, 0 },					\
140 		NotMallocd, Clone, EmptyValue, B_FALSE,			\
141 		unused, unused, { EMPTY } },				\
142 	{ { CKA_ENCRYPT, NULL, sizeof (CK_BBOOL) },			\
143 		NotMallocd, Clone, NotEmptyValue, B_FALSE,		\
144 		CK_TRUE, unused, { unused } },				\
145 	{ { CKA_VERIFY, NULL, sizeof (CK_BBOOL) },			\
146 		NotMallocd, Clone, NotEmptyValue, B_FALSE,		\
147 		CK_TRUE, unused, { unused } },				\
148 	{ { CKA_VERIFY_RECOVER, NULL, sizeof (CK_BBOOL) },		\
149 		NotMallocd, Clone, NotEmptyValue, B_FALSE,		\
150 		CK_TRUE, unused, { unused } },				\
151 	{ { CKA_WRAP, NULL, sizeof (CK_BBOOL) },			\
152 		NotMallocd, Clone, NotEmptyValue, B_FALSE,		\
153 		CK_TRUE, unused, { unused } },				\
154 	{ { CKA_TRUSTED, NULL, sizeof (CK_BBOOL) },			\
155 		NotMallocd, NotClone, NotEmptyValue, B_FALSE,		\
156 		CK_FALSE, unused, { unused } }
157 
158 /*
159  * Common private-key attributes, Table 34 (p97) of PKCS#11 2.11r1 spec.
160  */
161 #define	COMMON_PRIVKEY_ATTRIBUTES					\
162 	{ { CKA_SUBJECT, NULL, 0 },					\
163 		NotMallocd, Clone, EmptyValue, B_FALSE,			\
164 		unused, unused, { EMPTY } },				\
165 	{ { CKA_SENSITIVE, NULL, sizeof (CK_BBOOL) },			\
166 		NotMallocd, Clone, NotEmptyValue, B_FALSE,		\
167 		CK_FALSE, unused, { unused } },				\
168 	{ { CKA_SECONDARY_AUTH, NULL, sizeof (CK_BBOOL) },		\
169 		NotMallocd, Clone, EmptyValue, B_FALSE,			\
170 		CK_FALSE, unused, { unused } },				\
171 	{ { CKA_DECRYPT, NULL, sizeof (CK_BBOOL) },			\
172 		NotMallocd, Clone, NotEmptyValue, B_FALSE,		\
173 		CK_TRUE, unused, { unused } },				\
174 	{ { CKA_SIGN, NULL, sizeof (CK_BBOOL) },			\
175 		NotMallocd, Clone, NotEmptyValue, B_FALSE,		\
176 		CK_TRUE, unused, { unused } },				\
177 	{ { CKA_SIGN_RECOVER, NULL, sizeof (CK_BBOOL) },		\
178 		NotMallocd, Clone, NotEmptyValue, B_FALSE,		\
179 		CK_TRUE, unused, { unused } },				\
180 	{ { CKA_UNWRAP, NULL, sizeof (CK_BBOOL) },			\
181 		NotMallocd, Clone, NotEmptyValue, B_FALSE,		\
182 		CK_TRUE, unused, { unused } },				\
183 	{ { CKA_EXTRACTABLE, NULL, sizeof (CK_BBOOL) },			\
184 		NotMallocd, Clone, NotEmptyValue, B_FALSE,		\
185 		CK_TRUE, unused, { unused } },				\
186 	{ { CKA_ALWAYS_SENSITIVE, NULL, sizeof (CK_BBOOL) },		\
187 		NotMallocd, NotClone, NotEmptyValue, B_FALSE,		\
188 		CK_FALSE, unused, { unused } },				\
189 	{ { CKA_NEVER_EXTRACTABLE, NULL, sizeof (CK_BBOOL) },		\
190 		NotMallocd, NotClone, NotEmptyValue, B_FALSE,		\
191 		CK_FALSE, unused, { unused } }
192 
193 
194 /*
195  * Common secret-key attributes, Table 42 (p108) of PKCS#11 2.11r1 spec.
196  */
197 #define	COMMON_SECKEY_ATTRIBUTES					\
198 	{ { CKA_SENSITIVE, NULL, sizeof (CK_BBOOL) },			\
199 		NotMallocd, Clone, NotEmptyValue, B_FALSE,		\
200 		CK_FALSE, unused, { unused } },				\
201 	{ { CKA_ENCRYPT, NULL, sizeof (CK_BBOOL) },			\
202 		NotMallocd, Clone, NotEmptyValue, B_FALSE,		\
203 		CK_TRUE, unused, { unused } },				\
204 	{ { CKA_DECRYPT, NULL, sizeof (CK_BBOOL) },			\
205 		NotMallocd, Clone, NotEmptyValue, B_FALSE,		\
206 		CK_TRUE, unused, { unused } },				\
207 	{ { CKA_SIGN, NULL, sizeof (CK_BBOOL) },			\
208 		NotMallocd, Clone, NotEmptyValue, B_FALSE,		\
209 		CK_TRUE, unused, { unused } },				\
210 	{ { CKA_VERIFY, NULL, sizeof (CK_BBOOL) },			\
211 		NotMallocd, Clone, NotEmptyValue, B_FALSE,		\
212 		CK_TRUE, unused, { unused } },				\
213 	{ { CKA_WRAP, NULL, sizeof (CK_BBOOL) },			\
214 		NotMallocd, Clone, NotEmptyValue, B_FALSE,		\
215 		CK_TRUE, unused, { unused } },				\
216 	{ { CKA_UNWRAP, NULL, sizeof (CK_BBOOL) },			\
217 		NotMallocd, Clone, NotEmptyValue, B_FALSE,		\
218 		CK_TRUE, unused, { unused } },				\
219 	{ { CKA_EXTRACTABLE, NULL, sizeof (CK_BBOOL) },			\
220 		NotMallocd, Clone, NotEmptyValue, B_FALSE,		\
221 		CK_TRUE, unused, { unused } },				\
222 	{ { CKA_ALWAYS_SENSITIVE, NULL, sizeof (CK_BBOOL) },		\
223 		NotMallocd, NotClone, NotEmptyValue, B_FALSE,		\
224 		CK_FALSE, unused, { unused } },				\
225 	{ { CKA_NEVER_EXTRACTABLE, NULL, sizeof (CK_BBOOL) },		\
226 		NotMallocd, NotClone, NotEmptyValue, B_FALSE,		\
227 		CK_FALSE, unused, { unused } }
228 
229 /*
230  * Common domain-paramaters attributes, Table 60 (p123) of PKCS#11 2.11r1 spec.
231  * (CKA_KEY_TYPE has been removed, to place elsewhere)
232  */
233 #define	COMMON_DOMAIN_ATTRIBUTES					\
234 	{ { CKA_LOCAL, NULL, sizeof (CK_BBOOL) },			\
235 		NotMallocd, Clone, NotEmptyValue, B_FALSE,		\
236 		CK_FALSE, unused, { unused } }
237 
238 
239 /* ========================= HW Objects ========================= */
240 
241 
242 /*
243  * Master template for: CKO_HW_FEATURE + CKH_CLOCK
244  */
245 static const generic_attr_t OBJ_HW_CLOCK[] =
246 {
247 	{ { CKA_CLASS, NULL, sizeof (CK_OBJECT_CLASS) },
248 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
249 		unused, CKO_HW_FEATURE, { unused } },
250 	{ { CKA_HW_FEATURE_TYPE, NULL, sizeof (CK_HW_FEATURE_TYPE) },
251 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
252 		unused, CKH_CLOCK, { unused } },
253 	{ { CKA_VALUE, NULL, 16 },
254 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
255 		unused, unused, { EMPTYDATE, EMPTYDATE } }
256 };
257 
258 
259 /*
260  * Master template for: CKO_HW_FEATURE + CKH_MONOTONIC_COUNTER
261  *
262  * NOTE: no sub-type for this class!
263  */
264 static const generic_attr_t OBJ_HW_MONOTONIC[] =
265 {
266 	{ { CKA_CLASS, NULL, sizeof (CK_OBJECT_CLASS) },
267 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
268 		unused, CKO_HW_FEATURE, { unused } },
269 	{ { CKA_HW_FEATURE_TYPE, NULL, sizeof (CK_HW_FEATURE_TYPE) },
270 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
271 		unused, CKH_MONOTONIC_COUNTER, { unused } },
272 	{ { CKA_VALUE, NULL, 0 },
273 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
274 		unused, unused, { EMPTY } },
275 	{ { CKA_RESET_ON_INIT, NULL, sizeof (CK_BBOOL) },
276 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
277 		CK_FALSE, unused, { unused } },
278 	{ { CKA_HAS_RESET, NULL, sizeof (CK_BBOOL) },
279 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
280 		CK_FALSE, unused, { unused } }
281 };
282 
283 
284 /* ========================= Data Objects ========================= */
285 
286 
287 /*
288  * Master template for CKO_DATA + (no subtypes for this class)
289  *
290  * Defaults are according to PKCS#11.
291  *
292  * NOTE: no sub-type for this class!
293  */
294 static const generic_attr_t OBJ_DATA[] =
295 {
296 	{ { CKA_CLASS, NULL, sizeof (CK_OBJECT_CLASS) },
297 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
298 		unused, CKO_DATA, { unused } },
299 	COMMON_STORAGE_ATTRIBUTES,
300 	{ { CKA_APPLICATION, NULL, 0 },
301 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
302 		unused, unused, { EMPTY } },
303 	{ { CKA_OBJECT_ID, NULL, 0 },
304 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
305 		unused, unused, { EMPTY } },
306 	{ { CKA_VALUE, NULL, 0 },
307 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
308 		unused, unused, { EMPTY } }
309 };
310 
311 
312 /* ========================= Certificate Objects ========================= */
313 
314 
315 /*
316  * Master template for CKO_CERTIFICATE + CKC_X_509
317  *
318  * Defaults are according to PKCS#11.
319  */
320 static const generic_attr_t OBJ_CERT_X509[] =
321 {
322 	{ { CKA_CLASS, NULL, sizeof (CK_OBJECT_CLASS) },
323 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
324 		unused, CKO_CERTIFICATE, { unused } },
325 	{ { CKA_CERTIFICATE_TYPE, NULL, sizeof (CK_CERTIFICATE_TYPE) },
326 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
327 		unused, CKC_X_509, { unused } },
328 	COMMON_STORAGE_ATTRIBUTES,
329 	COMMON_CERTIFICATE_ATTRIBUTES,
330 	{ { CKA_SUBJECT, NULL, 0 },
331 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
332 		unused, unused, { EMPTY } },
333 	{ { CKA_ID, NULL, 0 },
334 		NotMallocd, Clone, EmptyValue, B_FALSE,
335 		unused, unused, { EMPTY } },
336 	{ { CKA_ISSUER, NULL, 0 },
337 		NotMallocd, Clone, EmptyValue, B_FALSE,
338 		unused, unused, { EMPTY } },
339 	{ { CKA_SERIAL_NUMBER, NULL, 0 },
340 		NotMallocd, Clone, EmptyValue, B_FALSE,
341 		unused, unused, { EMPTY } },
342 	{ { CKA_VALUE, NULL, 0 },
343 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
344 		unused, unused, { EMPTY } }
345 };
346 
347 
348 /*
349  * Master template for CKO_CERTIFICATE + CKC_X_509_ATTR_CERT
350  *
351  * Defaults are according to PKCS#11.
352  */
353 static const generic_attr_t OBJ_CERT_X509ATTR[] =
354 {
355 	{ { CKA_CLASS, NULL, sizeof (CK_OBJECT_CLASS) },
356 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
357 		unused, CKO_CERTIFICATE, { unused } },
358 	{ { CKA_CERTIFICATE_TYPE, NULL, sizeof (CK_CERTIFICATE_TYPE) },
359 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
360 		unused, CKC_X_509_ATTR_CERT, { unused } },
361 	COMMON_STORAGE_ATTRIBUTES,
362 	COMMON_CERTIFICATE_ATTRIBUTES,
363 	{ { CKA_OWNER, NULL, 0 },
364 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
365 		unused, unused, { EMPTY } },
366 	{ { CKA_AC_ISSUER, NULL, 0 },
367 		NotMallocd, Clone, EmptyValue, B_FALSE,
368 		unused, unused, { EMPTY } },
369 	{ { CKA_SERIAL_NUMBER, NULL, 0 },
370 		NotMallocd, Clone, EmptyValue, B_FALSE,
371 		unused, unused, { EMPTY } },
372 	{ { CKA_ATTR_TYPES, NULL, 0 },
373 		NotMallocd, Clone, EmptyValue, B_FALSE,
374 		unused, unused, { EMPTY } },
375 	{ { CKA_VALUE, NULL, 0 },
376 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
377 		unused, unused, { EMPTY } }
378 };
379 
380 
381 /* ========================= Public Keys ========================= */
382 
383 
384 /*
385  * Master template for CKO_PUBLIC_KEY + CKK_RSA
386  */
387 static const generic_attr_t OBJ_PUBKEY_RSA[] =
388 {
389 	{ { CKA_CLASS, NULL, sizeof (CK_OBJECT_CLASS) },
390 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
391 		unused, CKO_PUBLIC_KEY, { unused } },
392 	{ { CKA_KEY_TYPE, NULL, sizeof (CK_KEY_TYPE) },
393 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
394 		unused, CKK_RSA, { unused } },
395 	COMMON_STORAGE_ATTRIBUTES,
396 	COMMON_KEY_ATTRIBUTES,
397 	COMMON_PUBKEY_ATTRIBUTES,
398 	{ { CKA_MODULUS, NULL, 0 },
399 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
400 		unused, unused, { EMPTY } },
401 	{ { CKA_MODULUS_BITS, NULL, sizeof (CK_ULONG)},
402 		NotMallocd, NotClone, NotEmptyValue, B_FALSE,
403 		unused, 0, { unused } },
404 	{ { CKA_PUBLIC_EXPONENT, NULL, 0 },
405 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
406 		unused, unused, { EMPTY } }
407 };
408 
409 
410 /*
411  * Master template for CKO_PUBLIC_KEY + CKK_DSA
412  *
413  */
414 static const generic_attr_t OBJ_PUBKEY_DSA[] =
415 {
416 	{ { CKA_CLASS, NULL, sizeof (CK_OBJECT_CLASS) },
417 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
418 		unused, CKO_PUBLIC_KEY, { unused } },
419 	{ { CKA_KEY_TYPE, NULL, sizeof (CK_KEY_TYPE) },
420 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
421 		unused, CKK_DSA, { unused } },
422 	COMMON_STORAGE_ATTRIBUTES,
423 	COMMON_KEY_ATTRIBUTES,
424 	COMMON_PUBKEY_ATTRIBUTES,
425 	{ { CKA_PRIME, NULL, 0 },
426 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
427 		unused, unused, { EMPTY } },
428 	{ { CKA_SUBPRIME, NULL, 0 },
429 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
430 		unused, unused, { EMPTY } },
431 	{ { CKA_BASE, NULL, 0 },
432 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
433 		unused, unused, { EMPTY } },
434 	{ { CKA_VALUE, NULL, 0 },
435 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
436 		unused, unused, { EMPTY } }
437 };
438 
439 
440 /*
441  * Master template for CKO_PUBLIC_KEY + CKK_EC
442  *
443  */
444 static const generic_attr_t OBJ_PUBKEY_EC[] =
445 {
446 	{ { CKA_CLASS, NULL, sizeof (CK_OBJECT_CLASS) },
447 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
448 		unused, CKO_PUBLIC_KEY, { unused } },
449 	{ { CKA_KEY_TYPE, NULL, sizeof (CK_KEY_TYPE) },
450 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
451 		unused, CKK_EC, { unused } },
452 	COMMON_STORAGE_ATTRIBUTES,
453 	COMMON_KEY_ATTRIBUTES,
454 	COMMON_PUBKEY_ATTRIBUTES,
455 	{ { CKA_EC_PARAMS, NULL, 0 },
456 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
457 		unused, unused, { EMPTY } },
458 	{ { CKA_EC_POINT, NULL, 0 },
459 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
460 		unused, unused, { EMPTY } }
461 };
462 
463 
464 /*
465  * Master template for CKO_PUBLIC_KEY + CKK_DH
466  *
467  */
468 static const generic_attr_t OBJ_PUBKEY_DH[] =
469 {
470 	{ { CKA_CLASS, NULL, sizeof (CK_OBJECT_CLASS) },
471 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
472 		unused, CKO_PUBLIC_KEY, { unused } },
473 	{ { CKA_KEY_TYPE, NULL, sizeof (CK_KEY_TYPE) },
474 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
475 		unused, CKK_DH, { unused } },
476 	COMMON_STORAGE_ATTRIBUTES,
477 	COMMON_KEY_ATTRIBUTES,
478 	COMMON_PUBKEY_ATTRIBUTES,
479 	{ { CKA_PRIME, NULL, 0 },
480 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
481 		unused, unused, { EMPTY } },
482 	{ { CKA_BASE, NULL, 0 },
483 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
484 		unused, unused, { EMPTY } },
485 	{ { CKA_VALUE, NULL, 0 },
486 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
487 		unused, unused, { EMPTY } }
488 };
489 
490 
491 /*
492  * Master template for CKO_PUBLIC_KEY + CKK_X9_42_DH
493  *
494  */
495 static const generic_attr_t OBJ_PUBKEY_X942DH[] =
496 {
497 	{ { CKA_CLASS, NULL, sizeof (CK_OBJECT_CLASS) },
498 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
499 		unused, CKO_PUBLIC_KEY, { unused } },
500 	{ { CKA_KEY_TYPE, NULL, sizeof (CK_KEY_TYPE) },
501 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
502 		unused, CKK_X9_42_DH, { unused } },
503 	COMMON_STORAGE_ATTRIBUTES,
504 	COMMON_KEY_ATTRIBUTES,
505 	COMMON_PUBKEY_ATTRIBUTES,
506 	{ { CKA_PRIME, NULL, 0 },
507 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
508 		unused, unused, { EMPTY } },
509 	{ { CKA_BASE, NULL, 0 },
510 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
511 		unused, unused, { EMPTY } },
512 	{ { CKA_SUBPRIME, NULL, 0 },
513 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
514 		unused, unused, { EMPTY } },
515 	{ { CKA_VALUE, NULL, 0 },
516 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
517 		unused, unused, { EMPTY } }
518 };
519 
520 
521 /*
522  * Master template for CKO_PUBLIC_KEY + CKK_KEA
523  *
524  */
525 static const generic_attr_t OBJ_PUBKEY_KEA[] =
526 {
527 	{ { CKA_CLASS, NULL, sizeof (CK_OBJECT_CLASS) },
528 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
529 		unused, CKO_PUBLIC_KEY, { unused } },
530 	{ { CKA_KEY_TYPE, NULL, sizeof (CK_KEY_TYPE) },
531 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
532 		unused, CKK_KEA, { unused } },
533 	COMMON_STORAGE_ATTRIBUTES,
534 	COMMON_KEY_ATTRIBUTES,
535 	COMMON_PUBKEY_ATTRIBUTES,
536 	{ { CKA_PRIME, NULL, 0 },
537 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
538 		unused, unused, { EMPTY } },
539 	{ { CKA_BASE, NULL, 0 },
540 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
541 		unused, unused, { EMPTY } },
542 	{ { CKA_SUBPRIME, NULL, 0 },
543 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
544 		unused, unused, { EMPTY } },
545 	{ { CKA_VALUE, NULL, 0 },
546 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
547 		unused, unused, { EMPTY } }
548 };
549 
550 
551 /* ========================= Private Keys ========================= */
552 
553 
554 /*
555  * Master template for CKO_PRIVATE_KEY + CKK_RSA
556  *
557  */
558 static const generic_attr_t OBJ_PRIVKEY_RSA[] =
559 {
560 	{ { CKA_CLASS, NULL, sizeof (CK_OBJECT_CLASS) },
561 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
562 		unused, CKO_PRIVATE_KEY, { unused } },
563 	{ { CKA_KEY_TYPE, NULL, sizeof (CK_KEY_TYPE) },
564 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
565 		unused, CKK_RSA, { unused } },
566 	COMMON_STORAGE_ATTRIBUTES,
567 	COMMON_KEY_ATTRIBUTES,
568 	COMMON_PRIVKEY_ATTRIBUTES,
569 	{ { CKA_MODULUS, NULL, 0 },
570 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
571 		unused, unused, { EMPTY } },
572 	{ { CKA_PRIVATE_EXPONENT, NULL, 0 },
573 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
574 		unused, unused, { EMPTY } },
575 	{ { CKA_PUBLIC_EXPONENT, NULL, 0 },
576 		NotMallocd, Clone, EmptyValue, B_FALSE,
577 		unused, unused, { EMPTY } },
578 	{ { CKA_PRIME_1, NULL, 0 },
579 		NotMallocd, Clone, EmptyValue, B_FALSE,
580 		unused, unused, { EMPTY } },
581 	{ { CKA_PRIME_2, NULL, 0 },
582 		NotMallocd, Clone, EmptyValue, B_FALSE,
583 		unused, unused, { EMPTY } },
584 	{ { CKA_EXPONENT_1, NULL, 0 },
585 		NotMallocd, Clone, EmptyValue, B_FALSE,
586 		unused, unused, { EMPTY } },
587 	{ { CKA_EXPONENT_2, NULL, 0 },
588 		NotMallocd, Clone, EmptyValue, B_FALSE,
589 		unused, unused, { EMPTY } },
590 	{ { CKA_COEFFICIENT, NULL, 0 },
591 		NotMallocd, Clone, EmptyValue, B_FALSE,
592 		unused, unused, { EMPTY } }
593 };
594 
595 
596 /*
597  * Master template for CKO_PRIVATE_KEY + CKK_DSA
598  *
599  */
600 static const generic_attr_t OBJ_PRIVKEY_DSA[] =
601 {
602 	{ { CKA_CLASS, NULL, sizeof (CK_OBJECT_CLASS) },
603 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
604 		unused, CKO_PRIVATE_KEY, { unused } },
605 	{ { CKA_KEY_TYPE, NULL, sizeof (CK_KEY_TYPE) },
606 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
607 		unused, CKK_DSA, { unused } },
608 	COMMON_STORAGE_ATTRIBUTES,
609 	COMMON_KEY_ATTRIBUTES,
610 	COMMON_PRIVKEY_ATTRIBUTES,
611 	{ { CKA_PRIME, NULL, 0 },
612 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
613 		unused, unused, { EMPTY } },
614 	{ { CKA_SUBPRIME, NULL, 0 },
615 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
616 		unused, unused, { EMPTY } },
617 	{ { CKA_BASE, NULL, 0 },
618 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
619 		unused, unused, { EMPTY } },
620 	{ { CKA_VALUE, NULL, 0 },
621 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
622 		unused, unused, { EMPTY } }
623 };
624 
625 
626 /*
627  * Master template for CKO_PRIVATE_KEY + CKK_EC
628  *
629  */
630 static const generic_attr_t OBJ_PRIVKEY_EC[] =
631 {
632 	{ { CKA_CLASS, NULL, sizeof (CK_OBJECT_CLASS) },
633 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
634 		unused, CKO_PRIVATE_KEY, { unused } },
635 	{ { CKA_KEY_TYPE, NULL, sizeof (CK_KEY_TYPE) },
636 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
637 		unused, CKK_EC, { unused } },
638 	COMMON_STORAGE_ATTRIBUTES,
639 	COMMON_KEY_ATTRIBUTES,
640 	COMMON_PRIVKEY_ATTRIBUTES,
641 	{ { CKA_EC_PARAMS, NULL, 0 },
642 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
643 		unused, unused, { EMPTY } },
644 	{ { CKA_VALUE, NULL, 0 },
645 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
646 		unused, unused, { EMPTY } }
647 };
648 
649 
650 /*
651  * Master template for CKO_PRIVATE_KEY + CKK_DH
652  */
653 static const generic_attr_t OBJ_PRIVKEY_DH[] =
654 {
655 	{ { CKA_CLASS, NULL, sizeof (CK_OBJECT_CLASS) },
656 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
657 		unused, CKO_PRIVATE_KEY, { unused } },
658 	{ { CKA_KEY_TYPE, NULL, sizeof (CK_KEY_TYPE) },
659 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
660 		unused, CKK_DH, { unused } },
661 	COMMON_STORAGE_ATTRIBUTES,
662 	COMMON_KEY_ATTRIBUTES,
663 	COMMON_PRIVKEY_ATTRIBUTES,
664 	{ { CKA_PRIME, NULL, 0 },
665 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
666 		unused, unused, { EMPTY } },
667 	{ { CKA_BASE, NULL, 0 },
668 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
669 		unused, unused, { EMPTY } },
670 	{ { CKA_VALUE, NULL, 0 },
671 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
672 		unused, unused, { EMPTY } },
673 	{ { CKA_VALUE_BITS, NULL, sizeof (CK_ULONG) },
674 		NotMallocd, NotClone, NotEmptyValue, B_FALSE,
675 		unused, 0, { unused } }
676 };
677 
678 
679 /*
680  * Master template for CKO_PRIVATE_KEY + CKK_X9_42_DH
681  *
682  */
683 static const generic_attr_t OBJ_PRIVKEY_X942DH[] =
684 {
685 	{ { CKA_CLASS, NULL, sizeof (CK_OBJECT_CLASS) },
686 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
687 		unused, CKO_PRIVATE_KEY, { unused } },
688 	{ { CKA_KEY_TYPE, NULL, sizeof (CK_KEY_TYPE) },
689 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
690 		unused, CKK_X9_42_DH, { unused } },
691 	COMMON_STORAGE_ATTRIBUTES,
692 	COMMON_KEY_ATTRIBUTES,
693 	COMMON_PRIVKEY_ATTRIBUTES,
694 	{ { CKA_PRIME, NULL, 0 },
695 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
696 		unused, unused, { EMPTY } },
697 	{ { CKA_SUBPRIME, NULL, 0 },
698 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
699 		unused, unused, { EMPTY } },
700 	{ { CKA_BASE, NULL, 0 },
701 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
702 		unused, unused, { EMPTY } },
703 	{ { CKA_VALUE, NULL, 0 },
704 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
705 		unused, unused, { EMPTY } }
706 };
707 
708 
709 /*
710  * Master template for CKO_PRIVATE_KEY + CKK_KEA
711  *
712  */
713 static const generic_attr_t OBJ_PRIVKEY_KEA[] =
714 {
715 	{ { CKA_CLASS, NULL, sizeof (CK_OBJECT_CLASS) },
716 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
717 		unused, CKO_PRIVATE_KEY, { unused } },
718 	{ { CKA_KEY_TYPE, NULL, sizeof (CK_KEY_TYPE) },
719 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
720 		unused, CKK_KEA, { unused } },
721 	COMMON_STORAGE_ATTRIBUTES,
722 	COMMON_KEY_ATTRIBUTES,
723 	COMMON_PRIVKEY_ATTRIBUTES,
724 	{ { CKA_PRIME, NULL, 0 },
725 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
726 		unused, unused, { EMPTY } },
727 	{ { CKA_BASE, NULL, 0 },
728 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
729 		unused, unused, { EMPTY } },
730 	{ { CKA_SUBPRIME, NULL, 0 },
731 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
732 		unused, unused, { EMPTY } },
733 	{ { CKA_VALUE, NULL, 0 },
734 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
735 		unused, unused, { EMPTY } }
736 };
737 
738 
739 /* ========================= Secret Keys ========================= */
740 
741 
742 /*
743  * Master template for CKO_SECRET_KEY + (fixed-length keytype)
744  */
745 static const generic_attr_t OBJ_SECKEY[] =
746 {
747 	{ { CKA_CLASS, NULL, sizeof (CK_OBJECT_CLASS) },
748 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
749 		unused, CKO_SECRET_KEY, { unused } },
750 	{ { CKA_KEY_TYPE, NULL, sizeof (CK_KEY_TYPE) },
751 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
752 		unused, CKK_GENERIC_SECRET, { unused } },
753 	COMMON_STORAGE_ATTRIBUTES,
754 	COMMON_KEY_ATTRIBUTES,
755 	COMMON_SECKEY_ATTRIBUTES,
756 	{ { CKA_VALUE, NULL, 0 },
757 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
758 		unused, unused, { EMPTY } }
759 };
760 
761 
762 /*
763  * Master template for CKO_SECRET_KEY + (variable-length keytype)
764  *
765  */
766 static const generic_attr_t OBJ_SECKEY_WITHLEN[] =
767 {
768 	{ { CKA_CLASS, NULL, sizeof (CK_OBJECT_CLASS) },
769 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
770 		unused, CKO_SECRET_KEY, { unused } },
771 	{ { CKA_KEY_TYPE, NULL, sizeof (CK_KEY_TYPE) },
772 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
773 		unused, CKK_GENERIC_SECRET, { unused } },
774 	COMMON_STORAGE_ATTRIBUTES,
775 	COMMON_KEY_ATTRIBUTES,
776 	COMMON_SECKEY_ATTRIBUTES,
777 	{ { CKA_VALUE, NULL, 0 },
778 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
779 		unused, unused, { EMPTY } },
780 	{ { CKA_VALUE_LEN, NULL, sizeof (CK_ULONG) },
781 		NotMallocd, NotClone, NotEmptyValue, B_FALSE,
782 		unused, 0, { unused } }
783 };
784 
785 
786 /* ========================= Domain Parameters ========================= */
787 
788 
789 /*
790  * Master template for CKO_DOMAIN_PARAMETERS + CKK_DSA
791  *
792  */
793 static const generic_attr_t OBJ_DOM_DSA[] =
794 {
795 	{ { CKA_CLASS, NULL, sizeof (CK_OBJECT_CLASS) },
796 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
797 		unused, CKO_DOMAIN_PARAMETERS, { unused } },
798 	{ { CKA_KEY_TYPE, NULL, sizeof (CK_KEY_TYPE) },
799 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
800 		unused, CKK_DSA, { unused } },
801 	COMMON_STORAGE_ATTRIBUTES,
802 	COMMON_DOMAIN_ATTRIBUTES,
803 	{ { CKA_PRIME, NULL, 0 },
804 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
805 		unused, unused, { EMPTY } },
806 	{ { CKA_SUBPRIME, NULL, 0 },
807 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
808 		unused, unused, { EMPTY } },
809 	{ { CKA_BASE, NULL, 0 },
810 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
811 		unused, unused, { EMPTY } },
812 	{ { CKA_PRIME_BITS, NULL, sizeof (CK_ULONG) },
813 		NotMallocd, NotClone, NotEmptyValue, B_FALSE,
814 		unused, 0, { unused } }
815 };
816 
817 /*
818  * Master template for CKO_DOMAIN_PARAMETERS + CKK_DH
819  *
820  */
821 static const generic_attr_t OBJ_DOM_DH[] =
822 {
823 	{ { CKA_CLASS, NULL, sizeof (CK_OBJECT_CLASS) },
824 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
825 		unused, CKO_DOMAIN_PARAMETERS, { unused } },
826 	{ { CKA_KEY_TYPE, NULL, sizeof (CK_KEY_TYPE) },
827 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
828 		unused, CKK_DH, { unused } },
829 	COMMON_STORAGE_ATTRIBUTES,
830 	COMMON_DOMAIN_ATTRIBUTES,
831 	{ { CKA_PRIME, NULL, 0 },
832 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
833 		unused, unused, { EMPTY } },
834 	{ { CKA_BASE, NULL, 0 },
835 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
836 		unused, unused, { EMPTY } },
837 	{ { CKA_PRIME_BITS, NULL, sizeof (CK_ULONG) },
838 		NotMallocd, NotClone, NotEmptyValue, B_FALSE,
839 		unused, 0, { unused } }
840 };
841 
842 /*
843  * Master template for CKO_DOMAIN_PARAMETERS + CKK_X9_42_DH
844  *
845  */
846 static const generic_attr_t OBJ_DOM_X942DH[] =
847 {
848 	{ { CKA_CLASS, NULL, sizeof (CK_OBJECT_CLASS) },
849 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
850 		unused, CKO_DOMAIN_PARAMETERS, { unused } },
851 	{ { CKA_KEY_TYPE, NULL, sizeof (CK_KEY_TYPE) },
852 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
853 		unused, CKK_X9_42_DH, { unused } },
854 	COMMON_STORAGE_ATTRIBUTES,
855 	COMMON_DOMAIN_ATTRIBUTES,
856 	{ { CKA_PRIME, NULL, 0 },
857 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
858 		unused, unused, { EMPTY } },
859 	{ { CKA_BASE, NULL, 0 },
860 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
861 		unused, unused, { EMPTY } },
862 	{ { CKA_SUBPRIME, NULL, 0 },
863 		NotMallocd, Clone, NotEmptyValue, B_FALSE,
864 		unused, unused, { EMPTY } },
865 	{ { CKA_PRIME_BITS, NULL, sizeof (CK_ULONG) },
866 		NotMallocd, NotClone, NotEmptyValue, B_FALSE,
867 		unused, 0, { unused } },
868 	{ { CKA_SUBPRIME_BITS, NULL, sizeof (CK_ULONG) },
869 		NotMallocd, NotClone, NotEmptyValue, B_FALSE,
870 		unused, 0, { unused } }
871 };
872 
873 #ifdef	__cplusplus
874 }
875 #endif
876 
877 #endif /* _META_ATTRMASTERS_H */
878