1 /* |
|
2 * Copyright (c) 2003, 2015, Oracle and/or its affiliates. All rights reserved. |
|
3 */ |
|
4 |
|
5 /* Copyright (c) 2002 Graz University of Technology. All rights reserved. |
|
6 * |
|
7 * Redistribution and use in source and binary forms, with or without |
|
8 * modification, are permitted provided that the following conditions are met: |
|
9 * |
|
10 * 1. Redistributions of source code must retain the above copyright notice, |
|
11 * this list of conditions and the following disclaimer. |
|
12 * |
|
13 * 2. Redistributions in binary form must reproduce the above copyright notice, |
|
14 * this list of conditions and the following disclaimer in the documentation |
|
15 * and/or other materials provided with the distribution. |
|
16 * |
|
17 * 3. The end-user documentation included with the redistribution, if any, must |
|
18 * include the following acknowledgment: |
|
19 * |
|
20 * "This product includes software developed by IAIK of Graz University of |
|
21 * Technology." |
|
22 * |
|
23 * Alternately, this acknowledgment may appear in the software itself, if |
|
24 * and wherever such third-party acknowledgments normally appear. |
|
25 * |
|
26 * 4. The names "Graz University of Technology" and "IAIK of Graz University of |
|
27 * Technology" must not be used to endorse or promote products derived from |
|
28 * this software without prior written permission. |
|
29 * |
|
30 * 5. Products derived from this software may not be called |
|
31 * "IAIK PKCS Wrapper", nor may "IAIK" appear in their name, without prior |
|
32 * written permission of Graz University of Technology. |
|
33 * |
|
34 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED |
|
35 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
|
36 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
|
37 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE LICENSOR BE |
|
38 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, |
|
39 * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
|
40 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, |
|
41 * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON |
|
42 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
|
43 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
|
44 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
|
45 * POSSIBILITY OF SUCH DAMAGE. |
|
46 */ |
|
47 |
|
48 package sun.security.pkcs11.wrapper; |
|
49 |
|
50 import java.math.BigInteger; |
|
51 |
|
52 import java.util.*; |
|
53 |
|
54 import static sun.security.pkcs11.wrapper.PKCS11Constants.*; |
|
55 |
|
56 /** |
|
57 * This class contains onyl static methods. It is the place for all functions |
|
58 * that are used by several classes in this package. |
|
59 * |
|
60 * @author Karl Scheibelhofer <Karl.Scheibelhofer@iaik.at> |
|
61 * @author Martin Schlaeffer <schlaeff@sbox.tugraz.at> |
|
62 */ |
|
63 public class Functions { |
|
64 |
|
65 // maps between ids and their names, forward and reverse |
|
66 // ids are stored as Integers to save space |
|
67 // since only the lower 32 bits are ever used anyway |
|
68 |
|
69 // mechanisms (CKM_*) |
|
70 private static final Map<Integer,String> mechNames = |
|
71 new HashMap<Integer,String>(); |
|
72 |
|
73 private static final Map<String,Integer> mechIds = |
|
74 new HashMap<String,Integer>(); |
|
75 |
|
76 // key types (CKK_*) |
|
77 private static final Map<Integer,String> keyNames = |
|
78 new HashMap<Integer,String>(); |
|
79 |
|
80 private static final Map<String,Integer> keyIds = |
|
81 new HashMap<String,Integer>(); |
|
82 |
|
83 // attributes (CKA_*) |
|
84 private static final Map<Integer,String> attributeNames = |
|
85 new HashMap<Integer,String>(); |
|
86 |
|
87 private static final Map<String,Integer> attributeIds = |
|
88 new HashMap<String,Integer>(); |
|
89 |
|
90 // object classes (CKO_*) |
|
91 private static final Map<Integer,String> objectClassNames = |
|
92 new HashMap<Integer,String>(); |
|
93 |
|
94 private static final Map<String,Integer> objectClassIds = |
|
95 new HashMap<String,Integer>(); |
|
96 |
|
97 |
|
98 /** |
|
99 * For converting numbers to their hex presentation. |
|
100 */ |
|
101 private static final char[] HEX_DIGITS = "0123456789ABCDEF".toCharArray(); |
|
102 |
|
103 /** |
|
104 * Converts a long value to a hexadecimal String of length 16. Includes |
|
105 * leading zeros if necessary. |
|
106 * |
|
107 * @param value The long value to be converted. |
|
108 * @return The hexadecimal string representation of the long value. |
|
109 */ |
|
110 public static String toFullHexString(long value) { |
|
111 long currentValue = value; |
|
112 StringBuilder sb = new StringBuilder(16); |
|
113 for(int j = 0; j < 16; j++) { |
|
114 int currentDigit = (int) currentValue & 0xf; |
|
115 sb.append(HEX_DIGITS[currentDigit]); |
|
116 currentValue >>>= 4; |
|
117 } |
|
118 |
|
119 return sb.reverse().toString(); |
|
120 } |
|
121 |
|
122 /** |
|
123 * Converts a int value to a hexadecimal String of length 8. Includes |
|
124 * leading zeros if necessary. |
|
125 * |
|
126 * @param value The int value to be converted. |
|
127 * @return The hexadecimal string representation of the int value. |
|
128 */ |
|
129 public static String toFullHexString(int value) { |
|
130 int currentValue = value; |
|
131 StringBuilder sb = new StringBuilder(8); |
|
132 for(int i = 0; i < 8; i++) { |
|
133 int currentDigit = currentValue & 0xf; |
|
134 sb.append(HEX_DIGITS[currentDigit]); |
|
135 currentValue >>>= 4; |
|
136 } |
|
137 |
|
138 return sb.reverse().toString(); |
|
139 } |
|
140 |
|
141 /** |
|
142 * converts a long value to a hexadecimal String |
|
143 * |
|
144 * @param value the long value to be converted |
|
145 * @return the hexadecimal string representation of the long value |
|
146 */ |
|
147 public static String toHexString(long value) { |
|
148 return Long.toHexString(value); |
|
149 } |
|
150 |
|
151 /** |
|
152 * Converts a byte array to a hexadecimal String. Each byte is presented by |
|
153 * its two digit hex-code; 0x0A -> "0a", 0x00 -> "00". No leading "0x" is |
|
154 * included in the result. |
|
155 * |
|
156 * @param value the byte array to be converted |
|
157 * @return the hexadecimal string representation of the byte array |
|
158 */ |
|
159 public static String toHexString(byte[] value) { |
|
160 if (value == null) { |
|
161 return null; |
|
162 } |
|
163 |
|
164 StringBuilder sb = new StringBuilder(2 * value.length); |
|
165 int single; |
|
166 |
|
167 for (int i = 0; i < value.length; i++) { |
|
168 single = value[i] & 0xFF; |
|
169 |
|
170 if (single < 0x10) { |
|
171 sb.append('0'); |
|
172 } |
|
173 |
|
174 sb.append(Integer.toString(single, 16)); |
|
175 } |
|
176 |
|
177 return sb.toString(); |
|
178 } |
|
179 |
|
180 /** |
|
181 * converts a long value to a binary String |
|
182 * |
|
183 * @param value the long value to be converted |
|
184 * @return the binary string representation of the long value |
|
185 */ |
|
186 public static String toBinaryString(long value) { |
|
187 return Long.toString(value, 2); |
|
188 } |
|
189 |
|
190 /** |
|
191 * converts a byte array to a binary String |
|
192 * |
|
193 * @param value the byte array to be converted |
|
194 * @return the binary string representation of the byte array |
|
195 */ |
|
196 public static String toBinaryString(byte[] value) { |
|
197 BigInteger helpBigInteger = new BigInteger(1, value); |
|
198 |
|
199 return helpBigInteger.toString(2); |
|
200 } |
|
201 |
|
202 private static class Flags { |
|
203 private final long[] flagIds; |
|
204 private final String[] flagNames; |
|
205 Flags(long[] flagIds, String[] flagNames) { |
|
206 if (flagIds.length != flagNames.length) { |
|
207 throw new AssertionError("Array lengths do not match"); |
|
208 } |
|
209 this.flagIds = flagIds; |
|
210 this.flagNames = flagNames; |
|
211 } |
|
212 String toString(long val) { |
|
213 StringBuilder sb = new StringBuilder(); |
|
214 boolean first = true; |
|
215 for (int i = 0; i < flagIds.length; i++) { |
|
216 if ((val & flagIds[i]) != 0) { |
|
217 if (first == false) { |
|
218 sb.append(" | "); |
|
219 } |
|
220 sb.append(flagNames[i]); |
|
221 first = false; |
|
222 } |
|
223 } |
|
224 return sb.toString(); |
|
225 } |
|
226 } |
|
227 |
|
228 private static final Flags slotInfoFlags = new Flags(new long[] { |
|
229 CKF_TOKEN_PRESENT, |
|
230 CKF_REMOVABLE_DEVICE, |
|
231 CKF_HW_SLOT, |
|
232 }, new String[] { |
|
233 "CKF_TOKEN_PRESENT", |
|
234 "CKF_REMOVABLE_DEVICE", |
|
235 "CKF_HW_SLOT", |
|
236 }); |
|
237 |
|
238 /** |
|
239 * converts the long value flags to a SlotInfoFlag string |
|
240 * |
|
241 * @param flags the flags to be converted |
|
242 * @return the SlotInfoFlag string representation of the flags |
|
243 */ |
|
244 public static String slotInfoFlagsToString(long flags) { |
|
245 return slotInfoFlags.toString(flags); |
|
246 } |
|
247 |
|
248 private static final Flags tokenInfoFlags = new Flags(new long[] { |
|
249 CKF_RNG, |
|
250 CKF_WRITE_PROTECTED, |
|
251 CKF_LOGIN_REQUIRED, |
|
252 CKF_USER_PIN_INITIALIZED, |
|
253 CKF_RESTORE_KEY_NOT_NEEDED, |
|
254 CKF_CLOCK_ON_TOKEN, |
|
255 CKF_PROTECTED_AUTHENTICATION_PATH, |
|
256 CKF_DUAL_CRYPTO_OPERATIONS, |
|
257 CKF_TOKEN_INITIALIZED, |
|
258 CKF_SECONDARY_AUTHENTICATION, |
|
259 CKF_USER_PIN_COUNT_LOW, |
|
260 CKF_USER_PIN_FINAL_TRY, |
|
261 CKF_USER_PIN_LOCKED, |
|
262 CKF_USER_PIN_TO_BE_CHANGED, |
|
263 CKF_SO_PIN_COUNT_LOW, |
|
264 CKF_SO_PIN_FINAL_TRY, |
|
265 CKF_SO_PIN_LOCKED, |
|
266 CKF_SO_PIN_TO_BE_CHANGED, |
|
267 }, new String[] { |
|
268 "CKF_RNG", |
|
269 "CKF_WRITE_PROTECTED", |
|
270 "CKF_LOGIN_REQUIRED", |
|
271 "CKF_USER_PIN_INITIALIZED", |
|
272 "CKF_RESTORE_KEY_NOT_NEEDED", |
|
273 "CKF_CLOCK_ON_TOKEN", |
|
274 "CKF_PROTECTED_AUTHENTICATION_PATH", |
|
275 "CKF_DUAL_CRYPTO_OPERATIONS", |
|
276 "CKF_TOKEN_INITIALIZED", |
|
277 "CKF_SECONDARY_AUTHENTICATION", |
|
278 "CKF_USER_PIN_COUNT_LOW", |
|
279 "CKF_USER_PIN_FINAL_TRY", |
|
280 "CKF_USER_PIN_LOCKED", |
|
281 "CKF_USER_PIN_TO_BE_CHANGED", |
|
282 "CKF_SO_PIN_COUNT_LOW", |
|
283 "CKF_SO_PIN_FINAL_TRY", |
|
284 "CKF_SO_PIN_LOCKED", |
|
285 "CKF_SO_PIN_TO_BE_CHANGED", |
|
286 }); |
|
287 |
|
288 /** |
|
289 * converts long value flags to a TokenInfoFlag string |
|
290 * |
|
291 * @param flags the flags to be converted |
|
292 * @return the TokenInfoFlag string representation of the flags |
|
293 */ |
|
294 public static String tokenInfoFlagsToString(long flags) { |
|
295 return tokenInfoFlags.toString(flags); |
|
296 } |
|
297 |
|
298 private static final Flags sessionInfoFlags = new Flags(new long[] { |
|
299 CKF_RW_SESSION, |
|
300 CKF_SERIAL_SESSION, |
|
301 }, new String[] { |
|
302 "CKF_RW_SESSION", |
|
303 "CKF_SERIAL_SESSION", |
|
304 }); |
|
305 |
|
306 /** |
|
307 * converts the long value flags to a SessionInfoFlag string |
|
308 * |
|
309 * @param flags the flags to be converted |
|
310 * @return the SessionInfoFlag string representation of the flags |
|
311 */ |
|
312 public static String sessionInfoFlagsToString(long flags) { |
|
313 return sessionInfoFlags.toString(flags); |
|
314 } |
|
315 |
|
316 /** |
|
317 * converts the long value state to a SessionState string |
|
318 * |
|
319 * @param state the state to be converted |
|
320 * @return the SessionState string representation of the state |
|
321 */ |
|
322 public static String sessionStateToString(long state) { |
|
323 String name; |
|
324 |
|
325 if (state == CKS_RO_PUBLIC_SESSION) { |
|
326 name = "CKS_RO_PUBLIC_SESSION"; |
|
327 } else if (state == CKS_RO_USER_FUNCTIONS) { |
|
328 name = "CKS_RO_USER_FUNCTIONS"; |
|
329 } else if (state == CKS_RW_PUBLIC_SESSION) { |
|
330 name = "CKS_RW_PUBLIC_SESSION"; |
|
331 } else if (state == CKS_RW_USER_FUNCTIONS) { |
|
332 name = "CKS_RW_USER_FUNCTIONS"; |
|
333 } else if (state == CKS_RW_SO_FUNCTIONS) { |
|
334 name = "CKS_RW_SO_FUNCTIONS"; |
|
335 } else { |
|
336 name = "ERROR: unknown session state 0x" + toFullHexString(state); |
|
337 } |
|
338 |
|
339 return name; |
|
340 } |
|
341 |
|
342 private static final Flags mechanismInfoFlags = new Flags(new long[] { |
|
343 CKF_HW, |
|
344 CKF_ENCRYPT, |
|
345 CKF_DECRYPT, |
|
346 CKF_DIGEST, |
|
347 CKF_SIGN, |
|
348 CKF_SIGN_RECOVER, |
|
349 CKF_VERIFY, |
|
350 CKF_VERIFY_RECOVER, |
|
351 CKF_GENERATE, |
|
352 CKF_GENERATE_KEY_PAIR, |
|
353 CKF_WRAP, |
|
354 CKF_UNWRAP, |
|
355 CKF_DERIVE, |
|
356 CKF_EC_F_P, |
|
357 CKF_EC_F_2M, |
|
358 CKF_EC_ECPARAMETERS, |
|
359 CKF_EC_NAMEDCURVE, |
|
360 CKF_EC_UNCOMPRESS, |
|
361 CKF_EC_COMPRESS, |
|
362 CKF_EXTENSION, |
|
363 }, new String[] { |
|
364 "CKF_HW", |
|
365 "CKF_ENCRYPT", |
|
366 "CKF_DECRYPT", |
|
367 "CKF_DIGEST", |
|
368 "CKF_SIGN", |
|
369 "CKF_SIGN_RECOVER", |
|
370 "CKF_VERIFY", |
|
371 "CKF_VERIFY_RECOVER", |
|
372 "CKF_GENERATE", |
|
373 "CKF_GENERATE_KEY_PAIR", |
|
374 "CKF_WRAP", |
|
375 "CKF_UNWRAP", |
|
376 "CKF_DERIVE", |
|
377 "CKF_EC_F_P", |
|
378 "CKF_EC_F_2M", |
|
379 "CKF_EC_ECPARAMETERS", |
|
380 "CKF_EC_NAMEDCURVE", |
|
381 "CKF_EC_UNCOMPRESS", |
|
382 "CKF_EC_COMPRESS", |
|
383 "CKF_EXTENSION", |
|
384 }); |
|
385 |
|
386 /** |
|
387 * converts the long value flags to a MechanismInfoFlag string |
|
388 * |
|
389 * @param flags the flags to be converted |
|
390 * @return the MechanismInfoFlag string representation of the flags |
|
391 */ |
|
392 public static String mechanismInfoFlagsToString(long flags) { |
|
393 return mechanismInfoFlags.toString(flags); |
|
394 } |
|
395 |
|
396 private static String getName(Map<Integer,String> nameMap, long id) { |
|
397 String name = null; |
|
398 if ((id >>> 32) == 0) { |
|
399 name = nameMap.get(Integer.valueOf((int)id)); |
|
400 } |
|
401 if (name == null) { |
|
402 name = "Unknown 0x" + toFullHexString(id); |
|
403 } |
|
404 return name; |
|
405 } |
|
406 |
|
407 public static long getId(Map<String,Integer> idMap, String name) { |
|
408 Integer mech = idMap.get(name); |
|
409 if (mech == null) { |
|
410 throw new IllegalArgumentException("Unknown name " + name); |
|
411 } |
|
412 return mech.intValue() & 0xffffffffL; |
|
413 } |
|
414 |
|
415 public static String getMechanismName(long id) { |
|
416 return getName(mechNames, id); |
|
417 } |
|
418 |
|
419 public static long getMechanismId(String name) { |
|
420 return getId(mechIds, name); |
|
421 } |
|
422 |
|
423 public static String getKeyName(long id) { |
|
424 return getName(keyNames, id); |
|
425 } |
|
426 |
|
427 public static long getKeyId(String name) { |
|
428 return getId(keyIds, name); |
|
429 } |
|
430 |
|
431 public static String getAttributeName(long id) { |
|
432 return getName(attributeNames, id); |
|
433 } |
|
434 |
|
435 public static long getAttributeId(String name) { |
|
436 return getId(attributeIds, name); |
|
437 } |
|
438 |
|
439 public static String getObjectClassName(long id) { |
|
440 return getName(objectClassNames, id); |
|
441 } |
|
442 |
|
443 public static long getObjectClassId(String name) { |
|
444 return getId(objectClassIds, name); |
|
445 } |
|
446 |
|
447 /** |
|
448 * Check the given arrays for equalitiy. This method considers both arrays as |
|
449 * equal, if both are <code>null</code> or both have the same length and |
|
450 * contain exactly the same char values. |
|
451 * |
|
452 * @param array1 The first array. |
|
453 * @param array2 The second array. |
|
454 * @return True, if both arrays are <code>null</code> or both have the same |
|
455 * length and contain exactly the same char values. False, otherwise. |
|
456 * @preconditions |
|
457 * @postconditions |
|
458 */ |
|
459 private static boolean equals(char[] array1, char[] array2) { |
|
460 return Arrays.equals(array1, array2); |
|
461 } |
|
462 |
|
463 /** |
|
464 * Check the given dates for equalitiy. This method considers both dates as |
|
465 * equal, if both are <code>null</code> or both contain exactly the same char |
|
466 * values. |
|
467 * |
|
468 * @param date1 The first date. |
|
469 * @param date2 The second date. |
|
470 * @return True, if both dates are <code>null</code> or both contain the same |
|
471 * char values. False, otherwise. |
|
472 * @preconditions |
|
473 * @postconditions |
|
474 */ |
|
475 public static boolean equals(CK_DATE date1, CK_DATE date2) { |
|
476 boolean equal = false; |
|
477 |
|
478 if (date1 == date2) { |
|
479 equal = true; |
|
480 } else if ((date1 != null) && (date2 != null)) { |
|
481 equal = equals(date1.year, date2.year) |
|
482 && equals(date1.month, date2.month) |
|
483 && equals(date1.day, date2.day); |
|
484 } else { |
|
485 equal = false; |
|
486 } |
|
487 |
|
488 return equal ; |
|
489 } |
|
490 |
|
491 /** |
|
492 * Calculate a hash code for the given byte array. |
|
493 * |
|
494 * @param array The byte array. |
|
495 * @return A hash code for the given array. |
|
496 * @preconditions |
|
497 * @postconditions |
|
498 */ |
|
499 public static int hashCode(byte[] array) { |
|
500 int hash = 0; |
|
501 |
|
502 if (array != null) { |
|
503 for (int i = 0; (i < 4) && (i < array.length); i++) { |
|
504 hash ^= (0xFF & array[i]) << ((i%4) << 3); |
|
505 } |
|
506 } |
|
507 |
|
508 return hash ; |
|
509 } |
|
510 |
|
511 /** |
|
512 * Calculate a hash code for the given char array. |
|
513 * |
|
514 * @param array The char array. |
|
515 * @return A hash code for the given array. |
|
516 * @preconditions |
|
517 * @postconditions |
|
518 */ |
|
519 public static int hashCode(char[] array) { |
|
520 int hash = 0; |
|
521 |
|
522 if (array != null) { |
|
523 for (int i = 0; (i < 4) && (i < array.length); i++) { |
|
524 hash ^= (0xFFFF & array[i]) << ((i%2) << 4); |
|
525 } |
|
526 } |
|
527 |
|
528 return hash ; |
|
529 } |
|
530 |
|
531 /** |
|
532 * Calculate a hash code for the given date object. |
|
533 * |
|
534 * @param date The date object. |
|
535 * @return A hash code for the given date. |
|
536 * @preconditions |
|
537 * @postconditions |
|
538 */ |
|
539 public static int hashCode(CK_DATE date) { |
|
540 int hash = 0; |
|
541 |
|
542 if (date != null) { |
|
543 if (date.year.length == 4) { |
|
544 hash ^= (0xFFFF & date.year[0]) << 16; |
|
545 hash ^= 0xFFFF & date.year[1]; |
|
546 hash ^= (0xFFFF & date.year[2]) << 16; |
|
547 hash ^= 0xFFFF & date.year[3]; |
|
548 } |
|
549 if (date.month.length == 2) { |
|
550 hash ^= (0xFFFF & date.month[0]) << 16; |
|
551 hash ^= 0xFFFF & date.month[1]; |
|
552 } |
|
553 if (date.day.length == 2) { |
|
554 hash ^= (0xFFFF & date.day[0]) << 16; |
|
555 hash ^= 0xFFFF & date.day[1]; |
|
556 } |
|
557 } |
|
558 |
|
559 return hash ; |
|
560 } |
|
561 |
|
562 private static void addMapping(Map<Integer,String> nameMap, |
|
563 Map<String,Integer> idMap, long id, String name) { |
|
564 if ((id >>> 32) != 0) { |
|
565 throw new AssertionError("Id has high bits set: " + id + ", " + name); |
|
566 } |
|
567 Integer intId = Integer.valueOf((int)id); |
|
568 if (nameMap.put(intId, name) != null) { |
|
569 throw new AssertionError("Duplicate id: " + id + ", " + name); |
|
570 } |
|
571 if (idMap.put(name, intId) != null) { |
|
572 throw new AssertionError("Duplicate name: " + id + ", " + name); |
|
573 } |
|
574 } |
|
575 |
|
576 private static void addMech(long id, String name) { |
|
577 addMapping(mechNames, mechIds, id, name); |
|
578 } |
|
579 |
|
580 private static void addKeyType(long id, String name) { |
|
581 addMapping(keyNames, keyIds, id, name); |
|
582 } |
|
583 |
|
584 private static void addAttribute(long id, String name) { |
|
585 addMapping(attributeNames, attributeIds, id, name); |
|
586 } |
|
587 |
|
588 private static void addObjectClass(long id, String name) { |
|
589 addMapping(objectClassNames, objectClassIds, id, name); |
|
590 } |
|
591 |
|
592 static { |
|
593 addMech(CKM_RSA_PKCS_KEY_PAIR_GEN, "CKM_RSA_PKCS_KEY_PAIR_GEN"); |
|
594 addMech(CKM_RSA_PKCS, "CKM_RSA_PKCS"); |
|
595 addMech(CKM_RSA_9796, "CKM_RSA_9796"); |
|
596 addMech(CKM_RSA_X_509, "CKM_RSA_X_509"); |
|
597 addMech(CKM_MD2_RSA_PKCS, "CKM_MD2_RSA_PKCS"); |
|
598 addMech(CKM_MD5_RSA_PKCS, "CKM_MD5_RSA_PKCS"); |
|
599 addMech(CKM_SHA1_RSA_PKCS, "CKM_SHA1_RSA_PKCS"); |
|
600 addMech(CKM_RIPEMD128_RSA_PKCS, "CKM_RIPEMD128_RSA_PKCS"); |
|
601 addMech(CKM_RIPEMD160_RSA_PKCS, "CKM_RIPEMD160_RSA_PKCS"); |
|
602 addMech(CKM_RSA_PKCS_OAEP, "CKM_RSA_PKCS_OAEP"); |
|
603 addMech(CKM_RSA_X9_31_KEY_PAIR_GEN, "CKM_RSA_X9_31_KEY_PAIR_GEN"); |
|
604 addMech(CKM_RSA_X9_31, "CKM_RSA_X9_31"); |
|
605 addMech(CKM_SHA1_RSA_X9_31, "CKM_SHA1_RSA_X9_31"); |
|
606 addMech(CKM_RSA_PKCS_PSS, "CKM_RSA_PKCS_PSS"); |
|
607 addMech(CKM_SHA1_RSA_PKCS_PSS, "CKM_SHA1_RSA_PKCS_PSS"); |
|
608 addMech(CKM_DSA_KEY_PAIR_GEN, "CKM_DSA_KEY_PAIR_GEN"); |
|
609 addMech(CKM_DSA, "CKM_DSA"); |
|
610 addMech(CKM_DSA_SHA1, "CKM_DSA_SHA1"); |
|
611 addMech(CKM_DH_PKCS_KEY_PAIR_GEN, "CKM_DH_PKCS_KEY_PAIR_GEN"); |
|
612 addMech(CKM_DH_PKCS_DERIVE, "CKM_DH_PKCS_DERIVE"); |
|
613 addMech(CKM_X9_42_DH_KEY_PAIR_GEN, "CKM_X9_42_DH_KEY_PAIR_GEN"); |
|
614 addMech(CKM_X9_42_DH_DERIVE, "CKM_X9_42_DH_DERIVE"); |
|
615 addMech(CKM_X9_42_DH_HYBRID_DERIVE, "CKM_X9_42_DH_HYBRID_DERIVE"); |
|
616 addMech(CKM_X9_42_MQV_DERIVE, "CKM_X9_42_MQV_DERIVE"); |
|
617 addMech(CKM_SHA224_RSA_PKCS, "CKM_SHA224_RSA_PKCS"); |
|
618 addMech(CKM_SHA256_RSA_PKCS, "CKM_SHA256_RSA_PKCS"); |
|
619 addMech(CKM_SHA384_RSA_PKCS, "CKM_SHA384_RSA_PKCS"); |
|
620 addMech(CKM_SHA512_RSA_PKCS, "CKM_SHA512_RSA_PKCS"); |
|
621 addMech(CKM_RC2_KEY_GEN, "CKM_RC2_KEY_GEN"); |
|
622 addMech(CKM_RC2_ECB, "CKM_RC2_ECB"); |
|
623 addMech(CKM_RC2_CBC, "CKM_RC2_CBC"); |
|
624 addMech(CKM_RC2_MAC, "CKM_RC2_MAC"); |
|
625 addMech(CKM_RC2_MAC_GENERAL, "CKM_RC2_MAC_GENERAL"); |
|
626 addMech(CKM_RC2_CBC_PAD, "CKM_RC2_CBC_PAD"); |
|
627 addMech(CKM_RC4_KEY_GEN, "CKM_RC4_KEY_GEN"); |
|
628 addMech(CKM_RC4, "CKM_RC4"); |
|
629 addMech(CKM_DES_KEY_GEN, "CKM_DES_KEY_GEN"); |
|
630 addMech(CKM_DES_ECB, "CKM_DES_ECB"); |
|
631 addMech(CKM_DES_CBC, "CKM_DES_CBC"); |
|
632 addMech(CKM_DES_MAC, "CKM_DES_MAC"); |
|
633 addMech(CKM_DES_MAC_GENERAL, "CKM_DES_MAC_GENERAL"); |
|
634 addMech(CKM_DES_CBC_PAD, "CKM_DES_CBC_PAD"); |
|
635 addMech(CKM_DES2_KEY_GEN, "CKM_DES2_KEY_GEN"); |
|
636 addMech(CKM_DES3_KEY_GEN, "CKM_DES3_KEY_GEN"); |
|
637 addMech(CKM_DES3_ECB, "CKM_DES3_ECB"); |
|
638 addMech(CKM_DES3_CBC, "CKM_DES3_CBC"); |
|
639 addMech(CKM_DES3_MAC, "CKM_DES3_MAC"); |
|
640 addMech(CKM_DES3_MAC_GENERAL, "CKM_DES3_MAC_GENERAL"); |
|
641 addMech(CKM_DES3_CBC_PAD, "CKM_DES3_CBC_PAD"); |
|
642 addMech(CKM_CDMF_KEY_GEN, "CKM_CDMF_KEY_GEN"); |
|
643 addMech(CKM_CDMF_ECB, "CKM_CDMF_ECB"); |
|
644 addMech(CKM_CDMF_CBC, "CKM_CDMF_CBC"); |
|
645 addMech(CKM_CDMF_MAC, "CKM_CDMF_MAC"); |
|
646 addMech(CKM_CDMF_MAC_GENERAL, "CKM_CDMF_MAC_GENERAL"); |
|
647 addMech(CKM_CDMF_CBC_PAD, "CKM_CDMF_CBC_PAD"); |
|
648 addMech(CKM_MD2, "CKM_MD2"); |
|
649 addMech(CKM_MD2_HMAC, "CKM_MD2_HMAC"); |
|
650 addMech(CKM_MD2_HMAC_GENERAL, "CKM_MD2_HMAC_GENERAL"); |
|
651 addMech(CKM_MD5, "CKM_MD5"); |
|
652 addMech(CKM_MD5_HMAC, "CKM_MD5_HMAC"); |
|
653 addMech(CKM_MD5_HMAC_GENERAL, "CKM_MD5_HMAC_GENERAL"); |
|
654 addMech(CKM_SHA_1, "CKM_SHA_1"); |
|
655 addMech(CKM_SHA_1_HMAC, "CKM_SHA_1_HMAC"); |
|
656 addMech(CKM_SHA_1_HMAC_GENERAL, "CKM_SHA_1_HMAC_GENERAL"); |
|
657 addMech(CKM_RIPEMD128, "CKM_RIPEMD128"); |
|
658 addMech(CKM_RIPEMD128_HMAC, "CKM_RIPEMD128_HMAC"); |
|
659 addMech(CKM_RIPEMD128_HMAC_GENERAL, "CKM_RIPEMD128_HMAC_GENERAL"); |
|
660 addMech(CKM_RIPEMD160, "CKM_RIPEMD160"); |
|
661 addMech(CKM_RIPEMD160_HMAC, "CKM_RIPEMD160_HMAC"); |
|
662 addMech(CKM_RIPEMD160_HMAC_GENERAL, "CKM_RIPEMD160_HMAC_GENERAL"); |
|
663 addMech(CKM_SHA224, "CKM_SHA224"); |
|
664 addMech(CKM_SHA224_HMAC, "CKM_SHA224_HMAC"); |
|
665 addMech(CKM_SHA224_HMAC_GENERAL, "CKM_SHA224_HMAC_GENERAL"); |
|
666 addMech(CKM_SHA256, "CKM_SHA256"); |
|
667 addMech(CKM_SHA256_HMAC, "CKM_SHA256_HMAC"); |
|
668 addMech(CKM_SHA256_HMAC_GENERAL, "CKM_SHA256_HMAC_GENERAL"); |
|
669 addMech(CKM_SHA384, "CKM_SHA384"); |
|
670 addMech(CKM_SHA384_HMAC, "CKM_SHA384_HMAC"); |
|
671 addMech(CKM_SHA384_HMAC_GENERAL, "CKM_SHA384_HMAC_GENERAL"); |
|
672 addMech(CKM_SHA512, "CKM_SHA512"); |
|
673 addMech(CKM_SHA512_HMAC, "CKM_SHA512_HMAC"); |
|
674 addMech(CKM_SHA512_HMAC_GENERAL, "CKM_SHA512_HMAC_GENERAL"); |
|
675 addMech(CKM_CAST_KEY_GEN, "CKM_CAST_KEY_GEN"); |
|
676 addMech(CKM_CAST_ECB, "CKM_CAST_ECB"); |
|
677 addMech(CKM_CAST_CBC, "CKM_CAST_CBC"); |
|
678 addMech(CKM_CAST_MAC, "CKM_CAST_MAC"); |
|
679 addMech(CKM_CAST_MAC_GENERAL, "CKM_CAST_MAC_GENERAL"); |
|
680 addMech(CKM_CAST_CBC_PAD, "CKM_CAST_CBC_PAD"); |
|
681 addMech(CKM_CAST3_KEY_GEN, "CKM_CAST3_KEY_GEN"); |
|
682 addMech(CKM_CAST3_ECB, "CKM_CAST3_ECB"); |
|
683 addMech(CKM_CAST3_CBC, "CKM_CAST3_CBC"); |
|
684 addMech(CKM_CAST3_MAC, "CKM_CAST3_MAC"); |
|
685 addMech(CKM_CAST3_MAC_GENERAL, "CKM_CAST3_MAC_GENERAL"); |
|
686 addMech(CKM_CAST3_CBC_PAD, "CKM_CAST3_CBC_PAD"); |
|
687 addMech(CKM_CAST128_KEY_GEN, "CKM_CAST128_KEY_GEN"); |
|
688 addMech(CKM_CAST128_ECB, "CKM_CAST128_ECB"); |
|
689 addMech(CKM_CAST128_CBC, "CKM_CAST128_CBC"); |
|
690 addMech(CKM_CAST128_MAC, "CKM_CAST128_MAC"); |
|
691 addMech(CKM_CAST128_MAC_GENERAL, "CKM_CAST128_MAC_GENERAL"); |
|
692 addMech(CKM_CAST128_CBC_PAD, "CKM_CAST128_CBC_PAD"); |
|
693 addMech(CKM_RC5_KEY_GEN, "CKM_RC5_KEY_GEN"); |
|
694 addMech(CKM_RC5_ECB, "CKM_RC5_ECB"); |
|
695 addMech(CKM_RC5_CBC, "CKM_RC5_CBC"); |
|
696 addMech(CKM_RC5_MAC, "CKM_RC5_MAC"); |
|
697 addMech(CKM_RC5_MAC_GENERAL, "CKM_RC5_MAC_GENERAL"); |
|
698 addMech(CKM_RC5_CBC_PAD, "CKM_RC5_CBC_PAD"); |
|
699 addMech(CKM_IDEA_KEY_GEN, "CKM_IDEA_KEY_GEN"); |
|
700 addMech(CKM_IDEA_ECB, "CKM_IDEA_ECB"); |
|
701 addMech(CKM_IDEA_CBC, "CKM_IDEA_CBC"); |
|
702 addMech(CKM_IDEA_MAC, "CKM_IDEA_MAC"); |
|
703 addMech(CKM_IDEA_MAC_GENERAL, "CKM_IDEA_MAC_GENERAL"); |
|
704 addMech(CKM_IDEA_CBC_PAD, "CKM_IDEA_CBC_PAD"); |
|
705 addMech(CKM_GENERIC_SECRET_KEY_GEN, "CKM_GENERIC_SECRET_KEY_GEN"); |
|
706 addMech(CKM_CONCATENATE_BASE_AND_KEY, "CKM_CONCATENATE_BASE_AND_KEY"); |
|
707 addMech(CKM_CONCATENATE_BASE_AND_DATA, "CKM_CONCATENATE_BASE_AND_DATA"); |
|
708 addMech(CKM_CONCATENATE_DATA_AND_BASE, "CKM_CONCATENATE_DATA_AND_BASE"); |
|
709 addMech(CKM_XOR_BASE_AND_DATA, "CKM_XOR_BASE_AND_DATA"); |
|
710 addMech(CKM_EXTRACT_KEY_FROM_KEY, "CKM_EXTRACT_KEY_FROM_KEY"); |
|
711 addMech(CKM_SSL3_PRE_MASTER_KEY_GEN, "CKM_SSL3_PRE_MASTER_KEY_GEN"); |
|
712 addMech(CKM_SSL3_MASTER_KEY_DERIVE, "CKM_SSL3_MASTER_KEY_DERIVE"); |
|
713 addMech(CKM_SSL3_KEY_AND_MAC_DERIVE, "CKM_SSL3_KEY_AND_MAC_DERIVE"); |
|
714 addMech(CKM_SSL3_MASTER_KEY_DERIVE_DH, "CKM_SSL3_MASTER_KEY_DERIVE_DH"); |
|
715 addMech(CKM_TLS_PRE_MASTER_KEY_GEN, "CKM_TLS_PRE_MASTER_KEY_GEN"); |
|
716 addMech(CKM_TLS_MASTER_KEY_DERIVE, "CKM_TLS_MASTER_KEY_DERIVE"); |
|
717 addMech(CKM_TLS_KEY_AND_MAC_DERIVE, "CKM_TLS_KEY_AND_MAC_DERIVE"); |
|
718 addMech(CKM_TLS_MASTER_KEY_DERIVE_DH, "CKM_TLS_MASTER_KEY_DERIVE_DH"); |
|
719 addMech(CKM_TLS_PRF, "CKM_TLS_PRF"); |
|
720 addMech(CKM_SSL3_MD5_MAC, "CKM_SSL3_MD5_MAC"); |
|
721 addMech(CKM_SSL3_SHA1_MAC, "CKM_SSL3_SHA1_MAC"); |
|
722 addMech(CKM_MD5_KEY_DERIVATION, "CKM_MD5_KEY_DERIVATION"); |
|
723 addMech(CKM_MD2_KEY_DERIVATION, "CKM_MD2_KEY_DERIVATION"); |
|
724 addMech(CKM_SHA1_KEY_DERIVATION, "CKM_SHA1_KEY_DERIVATION"); |
|
725 addMech(CKM_SHA224_KEY_DERIVATION, "CKM_SHA224_KEY_DERIVATION"); |
|
726 addMech(CKM_SHA256_KEY_DERIVATION, "CKM_SHA256_KEY_DERIVATION"); |
|
727 addMech(CKM_SHA384_KEY_DERIVATION, "CKM_SHA384_KEY_DERIVATION"); |
|
728 addMech(CKM_SHA512_KEY_DERIVATION, "CKM_SHA512_KEY_DERIVATION"); |
|
729 addMech(CKM_PBE_MD2_DES_CBC, "CKM_PBE_MD2_DES_CBC"); |
|
730 addMech(CKM_PBE_MD5_DES_CBC, "CKM_PBE_MD5_DES_CBC"); |
|
731 addMech(CKM_PBE_MD5_CAST_CBC, "CKM_PBE_MD5_CAST_CBC"); |
|
732 addMech(CKM_PBE_MD5_CAST3_CBC, "CKM_PBE_MD5_CAST3_CBC"); |
|
733 addMech(CKM_PBE_MD5_CAST128_CBC, "CKM_PBE_MD5_CAST128_CBC"); |
|
734 addMech(CKM_PBE_SHA1_CAST128_CBC, "CKM_PBE_SHA1_CAST128_CBC"); |
|
735 addMech(CKM_PBE_SHA1_RC4_128, "CKM_PBE_SHA1_RC4_128"); |
|
736 addMech(CKM_PBE_SHA1_RC4_40, "CKM_PBE_SHA1_RC4_40"); |
|
737 addMech(CKM_PBE_SHA1_DES3_EDE_CBC, "CKM_PBE_SHA1_DES3_EDE_CBC"); |
|
738 addMech(CKM_PBE_SHA1_DES2_EDE_CBC, "CKM_PBE_SHA1_DES2_EDE_CBC"); |
|
739 addMech(CKM_PBE_SHA1_RC2_128_CBC, "CKM_PBE_SHA1_RC2_128_CBC"); |
|
740 addMech(CKM_PBE_SHA1_RC2_40_CBC, "CKM_PBE_SHA1_RC2_40_CBC"); |
|
741 addMech(CKM_PKCS5_PBKD2, "CKM_PKCS5_PBKD2"); |
|
742 addMech(CKM_PBA_SHA1_WITH_SHA1_HMAC, "CKM_PBA_SHA1_WITH_SHA1_HMAC"); |
|
743 addMech(CKM_KEY_WRAP_LYNKS, "CKM_KEY_WRAP_LYNKS"); |
|
744 addMech(CKM_KEY_WRAP_SET_OAEP, "CKM_KEY_WRAP_SET_OAEP"); |
|
745 addMech(CKM_SKIPJACK_KEY_GEN, "CKM_SKIPJACK_KEY_GEN"); |
|
746 addMech(CKM_SKIPJACK_ECB64, "CKM_SKIPJACK_ECB64"); |
|
747 addMech(CKM_SKIPJACK_CBC64, "CKM_SKIPJACK_CBC64"); |
|
748 addMech(CKM_SKIPJACK_OFB64, "CKM_SKIPJACK_OFB64"); |
|
749 addMech(CKM_SKIPJACK_CFB64, "CKM_SKIPJACK_CFB64"); |
|
750 addMech(CKM_SKIPJACK_CFB32, "CKM_SKIPJACK_CFB32"); |
|
751 addMech(CKM_SKIPJACK_CFB16, "CKM_SKIPJACK_CFB16"); |
|
752 addMech(CKM_SKIPJACK_CFB8, "CKM_SKIPJACK_CFB8"); |
|
753 addMech(CKM_SKIPJACK_WRAP, "CKM_SKIPJACK_WRAP"); |
|
754 addMech(CKM_SKIPJACK_PRIVATE_WRAP, "CKM_SKIPJACK_PRIVATE_WRAP"); |
|
755 addMech(CKM_SKIPJACK_RELAYX, "CKM_SKIPJACK_RELAYX"); |
|
756 addMech(CKM_KEA_KEY_PAIR_GEN, "CKM_KEA_KEY_PAIR_GEN"); |
|
757 addMech(CKM_KEA_KEY_DERIVE, "CKM_KEA_KEY_DERIVE"); |
|
758 addMech(CKM_FORTEZZA_TIMESTAMP, "CKM_FORTEZZA_TIMESTAMP"); |
|
759 addMech(CKM_BATON_KEY_GEN, "CKM_BATON_KEY_GEN"); |
|
760 addMech(CKM_BATON_ECB128, "CKM_BATON_ECB128"); |
|
761 addMech(CKM_BATON_ECB96, "CKM_BATON_ECB96"); |
|
762 addMech(CKM_BATON_CBC128, "CKM_BATON_CBC128"); |
|
763 addMech(CKM_BATON_COUNTER, "CKM_BATON_COUNTER"); |
|
764 addMech(CKM_BATON_SHUFFLE, "CKM_BATON_SHUFFLE"); |
|
765 addMech(CKM_BATON_WRAP, "CKM_BATON_WRAP"); |
|
766 addMech(CKM_EC_KEY_PAIR_GEN, "CKM_EC_KEY_PAIR_GEN"); |
|
767 addMech(CKM_ECDSA, "CKM_ECDSA"); |
|
768 addMech(CKM_ECDSA_SHA1, "CKM_ECDSA_SHA1"); |
|
769 addMech(CKM_ECDH1_DERIVE, "CKM_ECDH1_DERIVE"); |
|
770 addMech(CKM_ECDH1_COFACTOR_DERIVE, "CKM_ECDH1_COFACTOR_DERIVE"); |
|
771 addMech(CKM_ECMQV_DERIVE, "CKM_ECMQV_DERIVE"); |
|
772 addMech(CKM_JUNIPER_KEY_GEN, "CKM_JUNIPER_KEY_GEN"); |
|
773 addMech(CKM_JUNIPER_ECB128, "CKM_JUNIPER_ECB128"); |
|
774 addMech(CKM_JUNIPER_CBC128, "CKM_JUNIPER_CBC128"); |
|
775 addMech(CKM_JUNIPER_COUNTER, "CKM_JUNIPER_COUNTER"); |
|
776 addMech(CKM_JUNIPER_SHUFFLE, "CKM_JUNIPER_SHUFFLE"); |
|
777 addMech(CKM_JUNIPER_WRAP, "CKM_JUNIPER_WRAP"); |
|
778 addMech(CKM_FASTHASH, "CKM_FASTHASH"); |
|
779 addMech(CKM_AES_KEY_GEN, "CKM_AES_KEY_GEN"); |
|
780 addMech(CKM_AES_ECB, "CKM_AES_ECB"); |
|
781 addMech(CKM_AES_CBC, "CKM_AES_CBC"); |
|
782 addMech(CKM_AES_MAC, "CKM_AES_MAC"); |
|
783 addMech(CKM_AES_MAC_GENERAL, "CKM_AES_MAC_GENERAL"); |
|
784 addMech(CKM_AES_CBC_PAD, "CKM_AES_CBC_PAD"); |
|
785 addMech(CKM_BLOWFISH_KEY_GEN, "CKM_BLOWFISH_KEY_GEN"); |
|
786 addMech(CKM_BLOWFISH_CBC, "CKM_BLOWFISH_CBC"); |
|
787 addMech(CKM_DSA_PARAMETER_GEN, "CKM_DSA_PARAMETER_GEN"); |
|
788 addMech(CKM_DH_PKCS_PARAMETER_GEN, "CKM_DH_PKCS_PARAMETER_GEN"); |
|
789 addMech(CKM_X9_42_DH_PARAMETER_GEN, "CKM_X9_42_DH_PARAMETER_GEN"); |
|
790 addMech(CKM_VENDOR_DEFINED, "CKM_VENDOR_DEFINED"); |
|
791 |
|
792 addMech(CKM_NSS_TLS_PRF_GENERAL, "CKM_NSS_TLS_PRF_GENERAL"); |
|
793 |
|
794 addMech(PCKM_SECURERANDOM, "SecureRandom"); |
|
795 addMech(PCKM_KEYSTORE, "KeyStore"); |
|
796 |
|
797 addKeyType(CKK_RSA, "CKK_RSA"); |
|
798 addKeyType(CKK_DSA, "CKK_DSA"); |
|
799 addKeyType(CKK_DH, "CKK_DH"); |
|
800 addKeyType(CKK_EC, "CKK_EC"); |
|
801 addKeyType(CKK_X9_42_DH, "CKK_X9_42_DH"); |
|
802 addKeyType(CKK_KEA, "CKK_KEA"); |
|
803 addKeyType(CKK_GENERIC_SECRET, "CKK_GENERIC_SECRET"); |
|
804 addKeyType(CKK_RC2, "CKK_RC2"); |
|
805 addKeyType(CKK_RC4, "CKK_RC4"); |
|
806 addKeyType(CKK_DES, "CKK_DES"); |
|
807 addKeyType(CKK_DES2, "CKK_DES2"); |
|
808 addKeyType(CKK_DES3, "CKK_DES3"); |
|
809 addKeyType(CKK_CAST, "CKK_CAST"); |
|
810 addKeyType(CKK_CAST3, "CKK_CAST3"); |
|
811 addKeyType(CKK_CAST128, "CKK_CAST128"); |
|
812 addKeyType(CKK_RC5, "CKK_RC5"); |
|
813 addKeyType(CKK_IDEA, "CKK_IDEA"); |
|
814 addKeyType(CKK_SKIPJACK, "CKK_SKIPJACK"); |
|
815 addKeyType(CKK_BATON, "CKK_BATON"); |
|
816 addKeyType(CKK_JUNIPER, "CKK_JUNIPER"); |
|
817 addKeyType(CKK_CDMF, "CKK_CDMF"); |
|
818 addKeyType(CKK_AES, "CKK_AES"); |
|
819 addKeyType(CKK_BLOWFISH, "CKK_BLOWFISH"); |
|
820 addKeyType(CKK_VENDOR_DEFINED, "CKK_VENDOR_DEFINED"); |
|
821 |
|
822 addKeyType(PCKK_ANY, "*"); |
|
823 |
|
824 addAttribute(CKA_CLASS, "CKA_CLASS"); |
|
825 addAttribute(CKA_TOKEN, "CKA_TOKEN"); |
|
826 addAttribute(CKA_PRIVATE, "CKA_PRIVATE"); |
|
827 addAttribute(CKA_LABEL, "CKA_LABEL"); |
|
828 addAttribute(CKA_APPLICATION, "CKA_APPLICATION"); |
|
829 addAttribute(CKA_VALUE, "CKA_VALUE"); |
|
830 addAttribute(CKA_OBJECT_ID, "CKA_OBJECT_ID"); |
|
831 addAttribute(CKA_CERTIFICATE_TYPE, "CKA_CERTIFICATE_TYPE"); |
|
832 addAttribute(CKA_ISSUER, "CKA_ISSUER"); |
|
833 addAttribute(CKA_SERIAL_NUMBER, "CKA_SERIAL_NUMBER"); |
|
834 addAttribute(CKA_AC_ISSUER, "CKA_AC_ISSUER"); |
|
835 addAttribute(CKA_OWNER, "CKA_OWNER"); |
|
836 addAttribute(CKA_ATTR_TYPES, "CKA_ATTR_TYPES"); |
|
837 addAttribute(CKA_TRUSTED, "CKA_TRUSTED"); |
|
838 addAttribute(CKA_KEY_TYPE, "CKA_KEY_TYPE"); |
|
839 addAttribute(CKA_SUBJECT, "CKA_SUBJECT"); |
|
840 addAttribute(CKA_ID, "CKA_ID"); |
|
841 addAttribute(CKA_SENSITIVE, "CKA_SENSITIVE"); |
|
842 addAttribute(CKA_ENCRYPT, "CKA_ENCRYPT"); |
|
843 addAttribute(CKA_DECRYPT, "CKA_DECRYPT"); |
|
844 addAttribute(CKA_WRAP, "CKA_WRAP"); |
|
845 addAttribute(CKA_UNWRAP, "CKA_UNWRAP"); |
|
846 addAttribute(CKA_SIGN, "CKA_SIGN"); |
|
847 addAttribute(CKA_SIGN_RECOVER, "CKA_SIGN_RECOVER"); |
|
848 addAttribute(CKA_VERIFY, "CKA_VERIFY"); |
|
849 addAttribute(CKA_VERIFY_RECOVER, "CKA_VERIFY_RECOVER"); |
|
850 addAttribute(CKA_DERIVE, "CKA_DERIVE"); |
|
851 addAttribute(CKA_START_DATE, "CKA_START_DATE"); |
|
852 addAttribute(CKA_END_DATE, "CKA_END_DATE"); |
|
853 addAttribute(CKA_MODULUS, "CKA_MODULUS"); |
|
854 addAttribute(CKA_MODULUS_BITS, "CKA_MODULUS_BITS"); |
|
855 addAttribute(CKA_PUBLIC_EXPONENT, "CKA_PUBLIC_EXPONENT"); |
|
856 addAttribute(CKA_PRIVATE_EXPONENT, "CKA_PRIVATE_EXPONENT"); |
|
857 addAttribute(CKA_PRIME_1, "CKA_PRIME_1"); |
|
858 addAttribute(CKA_PRIME_2, "CKA_PRIME_2"); |
|
859 addAttribute(CKA_EXPONENT_1, "CKA_EXPONENT_1"); |
|
860 addAttribute(CKA_EXPONENT_2, "CKA_EXPONENT_2"); |
|
861 addAttribute(CKA_COEFFICIENT, "CKA_COEFFICIENT"); |
|
862 addAttribute(CKA_PRIME, "CKA_PRIME"); |
|
863 addAttribute(CKA_SUBPRIME, "CKA_SUBPRIME"); |
|
864 addAttribute(CKA_BASE, "CKA_BASE"); |
|
865 addAttribute(CKA_PRIME_BITS, "CKA_PRIME_BITS"); |
|
866 addAttribute(CKA_SUB_PRIME_BITS, "CKA_SUB_PRIME_BITS"); |
|
867 addAttribute(CKA_VALUE_BITS, "CKA_VALUE_BITS"); |
|
868 addAttribute(CKA_VALUE_LEN, "CKA_VALUE_LEN"); |
|
869 addAttribute(CKA_EXTRACTABLE, "CKA_EXTRACTABLE"); |
|
870 addAttribute(CKA_LOCAL, "CKA_LOCAL"); |
|
871 addAttribute(CKA_NEVER_EXTRACTABLE, "CKA_NEVER_EXTRACTABLE"); |
|
872 addAttribute(CKA_ALWAYS_SENSITIVE, "CKA_ALWAYS_SENSITIVE"); |
|
873 addAttribute(CKA_KEY_GEN_MECHANISM, "CKA_KEY_GEN_MECHANISM"); |
|
874 addAttribute(CKA_MODIFIABLE, "CKA_MODIFIABLE"); |
|
875 addAttribute(CKA_EC_PARAMS, "CKA_EC_PARAMS"); |
|
876 addAttribute(CKA_EC_POINT, "CKA_EC_POINT"); |
|
877 addAttribute(CKA_SECONDARY_AUTH, "CKA_SECONDARY_AUTH"); |
|
878 addAttribute(CKA_AUTH_PIN_FLAGS, "CKA_AUTH_PIN_FLAGS"); |
|
879 addAttribute(CKA_HW_FEATURE_TYPE, "CKA_HW_FEATURE_TYPE"); |
|
880 addAttribute(CKA_RESET_ON_INIT, "CKA_RESET_ON_INIT"); |
|
881 addAttribute(CKA_HAS_RESET, "CKA_HAS_RESET"); |
|
882 addAttribute(CKA_VENDOR_DEFINED, "CKA_VENDOR_DEFINED"); |
|
883 addAttribute(CKA_NETSCAPE_DB, "CKA_NETSCAPE_DB"); |
|
884 |
|
885 addAttribute(CKA_NETSCAPE_TRUST_SERVER_AUTH, "CKA_NETSCAPE_TRUST_SERVER_AUTH"); |
|
886 addAttribute(CKA_NETSCAPE_TRUST_CLIENT_AUTH, "CKA_NETSCAPE_TRUST_CLIENT_AUTH"); |
|
887 addAttribute(CKA_NETSCAPE_TRUST_CODE_SIGNING, "CKA_NETSCAPE_TRUST_CODE_SIGNING"); |
|
888 addAttribute(CKA_NETSCAPE_TRUST_EMAIL_PROTECTION, "CKA_NETSCAPE_TRUST_EMAIL_PROTECTION"); |
|
889 addAttribute(CKA_NETSCAPE_CERT_SHA1_HASH, "CKA_NETSCAPE_CERT_SHA1_HASH"); |
|
890 addAttribute(CKA_NETSCAPE_CERT_MD5_HASH, "CKA_NETSCAPE_CERT_MD5_HASH"); |
|
891 |
|
892 addObjectClass(CKO_DATA, "CKO_DATA"); |
|
893 addObjectClass(CKO_CERTIFICATE, "CKO_CERTIFICATE"); |
|
894 addObjectClass(CKO_PUBLIC_KEY, "CKO_PUBLIC_KEY"); |
|
895 addObjectClass(CKO_PRIVATE_KEY, "CKO_PRIVATE_KEY"); |
|
896 addObjectClass(CKO_SECRET_KEY, "CKO_SECRET_KEY"); |
|
897 addObjectClass(CKO_HW_FEATURE, "CKO_HW_FEATURE"); |
|
898 addObjectClass(CKO_DOMAIN_PARAMETERS, "CKO_DOMAIN_PARAMETERS"); |
|
899 addObjectClass(CKO_VENDOR_DEFINED, "CKO_VENDOR_DEFINED"); |
|
900 |
|
901 addObjectClass(PCKO_ANY, "*"); |
|
902 |
|
903 } |
|
904 |
|
905 } |
|