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