1 /* 2 * Copyright (c) 2003, 2020, 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 private static final Map<String, Long> hashMechIds = 77 new HashMap<String, Long>(); 78 79 // key types (CKK_*) 80 private static final Map<Integer,String> keyNames = 81 new HashMap<Integer,String>(); 82 83 private static final Map<String,Integer> keyIds = 84 new HashMap<String,Integer>(); 85 86 // attributes (CKA_*) 87 private static final Map<Integer,String> attributeNames = 88 new HashMap<Integer,String>(); 89 90 private static final Map<String,Integer> attributeIds = 91 new HashMap<String,Integer>(); 92 93 // object classes (CKO_*) 94 private static final Map<Integer,String> objectClassNames = 95 new HashMap<Integer,String>(); 96 97 private static final Map<String,Integer> objectClassIds = 98 new HashMap<String,Integer>(); 99 100 // MGFs (CKG_*) 101 private static final Map<Integer,String> mgfNames = 102 new HashMap<Integer,String>(); 103 104 private static final Map<String,Integer> mgfIds = 105 new HashMap<String,Integer>(); 106 107 /** 108 * For converting numbers to their hex presentation. 109 */ 110 private static final char[] HEX_DIGITS = "0123456789ABCDEF".toCharArray(); 111 112 /** 113 * Converts a long value to a hexadecimal String of length 16. Includes 114 * leading zeros if necessary. 115 * 116 * @param value The long value to be converted. 117 * @return The hexadecimal string representation of the long value. 118 */ toFullHexString(long value)119 public static String toFullHexString(long value) { 120 long currentValue = value; 121 StringBuilder sb = new StringBuilder(16); 122 for(int j = 0; j < 16; j++) { 123 int currentDigit = (int) currentValue & 0xf; 124 sb.append(HEX_DIGITS[currentDigit]); 125 currentValue >>>= 4; 126 } 127 128 return sb.reverse().toString(); 129 } 130 131 /** 132 * Converts a int value to a hexadecimal String of length 8. Includes 133 * leading zeros if necessary. 134 * 135 * @param value The int value to be converted. 136 * @return The hexadecimal string representation of the int value. 137 */ toFullHexString(int value)138 public static String toFullHexString(int value) { 139 int currentValue = value; 140 StringBuilder sb = new StringBuilder(8); 141 for(int i = 0; i < 8; i++) { 142 int currentDigit = currentValue & 0xf; 143 sb.append(HEX_DIGITS[currentDigit]); 144 currentValue >>>= 4; 145 } 146 147 return sb.reverse().toString(); 148 } 149 150 /** 151 * converts a long value to a hexadecimal String 152 * 153 * @param value the long value to be converted 154 * @return the hexadecimal string representation of the long value 155 */ toHexString(long value)156 public static String toHexString(long value) { 157 return Long.toHexString(value); 158 } 159 160 /** 161 * Converts a byte array to a hexadecimal String. Each byte is presented by 162 * its two digit hex-code; 0x0A -> "0a", 0x00 -> "00". No leading "0x" is 163 * included in the result. 164 * 165 * @param value the byte array to be converted 166 * @return the hexadecimal string representation of the byte array 167 */ toHexString(byte[] value)168 public static String toHexString(byte[] value) { 169 if (value == null) { 170 return null; 171 } 172 173 StringBuilder sb = new StringBuilder(2 * value.length); 174 int single; 175 176 for (int i = 0; i < value.length; i++) { 177 single = value[i] & 0xFF; 178 179 if (single < 0x10) { 180 sb.append('0'); 181 } 182 183 sb.append(Integer.toString(single, 16)); 184 } 185 186 return sb.toString(); 187 } 188 189 /** 190 * converts a long value to a binary String 191 * 192 * @param value the long value to be converted 193 * @return the binary string representation of the long value 194 */ toBinaryString(long value)195 public static String toBinaryString(long value) { 196 return Long.toString(value, 2); 197 } 198 199 /** 200 * converts a byte array to a binary String 201 * 202 * @param value the byte array to be converted 203 * @return the binary string representation of the byte array 204 */ toBinaryString(byte[] value)205 public static String toBinaryString(byte[] value) { 206 BigInteger helpBigInteger = new BigInteger(1, value); 207 208 return helpBigInteger.toString(2); 209 } 210 211 private static class Flags { 212 private final long[] flagIds; 213 private final String[] flagNames; Flags(long[] flagIds, String[] flagNames)214 Flags(long[] flagIds, String[] flagNames) { 215 if (flagIds.length != flagNames.length) { 216 throw new AssertionError("Array lengths do not match"); 217 } 218 this.flagIds = flagIds; 219 this.flagNames = flagNames; 220 } toString(long val)221 String toString(long val) { 222 StringBuilder sb = new StringBuilder(); 223 boolean first = true; 224 for (int i = 0; i < flagIds.length; i++) { 225 if ((val & flagIds[i]) != 0) { 226 if (first == false) { 227 sb.append(" | "); 228 } 229 sb.append(flagNames[i]); 230 first = false; 231 } 232 } 233 return sb.toString(); 234 } 235 } 236 237 private static final Flags slotInfoFlags = new Flags(new long[] { 238 CKF_TOKEN_PRESENT, 239 CKF_REMOVABLE_DEVICE, 240 CKF_HW_SLOT, 241 }, new String[] { 242 "CKF_TOKEN_PRESENT", 243 "CKF_REMOVABLE_DEVICE", 244 "CKF_HW_SLOT", 245 }); 246 247 /** 248 * converts the long value flags to a SlotInfoFlag string 249 * 250 * @param flags the flags to be converted 251 * @return the SlotInfoFlag string representation of the flags 252 */ slotInfoFlagsToString(long flags)253 public static String slotInfoFlagsToString(long flags) { 254 return slotInfoFlags.toString(flags); 255 } 256 257 private static final Flags tokenInfoFlags = new Flags(new long[] { 258 CKF_RNG, 259 CKF_WRITE_PROTECTED, 260 CKF_LOGIN_REQUIRED, 261 CKF_USER_PIN_INITIALIZED, 262 CKF_RESTORE_KEY_NOT_NEEDED, 263 CKF_CLOCK_ON_TOKEN, 264 CKF_PROTECTED_AUTHENTICATION_PATH, 265 CKF_DUAL_CRYPTO_OPERATIONS, 266 CKF_TOKEN_INITIALIZED, 267 CKF_SECONDARY_AUTHENTICATION, 268 CKF_USER_PIN_COUNT_LOW, 269 CKF_USER_PIN_FINAL_TRY, 270 CKF_USER_PIN_LOCKED, 271 CKF_USER_PIN_TO_BE_CHANGED, 272 CKF_SO_PIN_COUNT_LOW, 273 CKF_SO_PIN_FINAL_TRY, 274 CKF_SO_PIN_LOCKED, 275 CKF_SO_PIN_TO_BE_CHANGED, 276 }, new String[] { 277 "CKF_RNG", 278 "CKF_WRITE_PROTECTED", 279 "CKF_LOGIN_REQUIRED", 280 "CKF_USER_PIN_INITIALIZED", 281 "CKF_RESTORE_KEY_NOT_NEEDED", 282 "CKF_CLOCK_ON_TOKEN", 283 "CKF_PROTECTED_AUTHENTICATION_PATH", 284 "CKF_DUAL_CRYPTO_OPERATIONS", 285 "CKF_TOKEN_INITIALIZED", 286 "CKF_SECONDARY_AUTHENTICATION", 287 "CKF_USER_PIN_COUNT_LOW", 288 "CKF_USER_PIN_FINAL_TRY", 289 "CKF_USER_PIN_LOCKED", 290 "CKF_USER_PIN_TO_BE_CHANGED", 291 "CKF_SO_PIN_COUNT_LOW", 292 "CKF_SO_PIN_FINAL_TRY", 293 "CKF_SO_PIN_LOCKED", 294 "CKF_SO_PIN_TO_BE_CHANGED", 295 }); 296 297 /** 298 * converts long value flags to a TokenInfoFlag string 299 * 300 * @param flags the flags to be converted 301 * @return the TokenInfoFlag string representation of the flags 302 */ tokenInfoFlagsToString(long flags)303 public static String tokenInfoFlagsToString(long flags) { 304 return tokenInfoFlags.toString(flags); 305 } 306 307 private static final Flags sessionInfoFlags = new Flags(new long[] { 308 CKF_RW_SESSION, 309 CKF_SERIAL_SESSION, 310 }, new String[] { 311 "CKF_RW_SESSION", 312 "CKF_SERIAL_SESSION", 313 }); 314 315 /** 316 * converts the long value flags to a SessionInfoFlag string 317 * 318 * @param flags the flags to be converted 319 * @return the SessionInfoFlag string representation of the flags 320 */ sessionInfoFlagsToString(long flags)321 public static String sessionInfoFlagsToString(long flags) { 322 return sessionInfoFlags.toString(flags); 323 } 324 325 /** 326 * converts the long value state to a SessionState string 327 * 328 * @param state the state to be converted 329 * @return the SessionState string representation of the state 330 */ sessionStateToString(long state)331 public static String sessionStateToString(long state) { 332 String name; 333 334 if (state == CKS_RO_PUBLIC_SESSION) { 335 name = "CKS_RO_PUBLIC_SESSION"; 336 } else if (state == CKS_RO_USER_FUNCTIONS) { 337 name = "CKS_RO_USER_FUNCTIONS"; 338 } else if (state == CKS_RW_PUBLIC_SESSION) { 339 name = "CKS_RW_PUBLIC_SESSION"; 340 } else if (state == CKS_RW_USER_FUNCTIONS) { 341 name = "CKS_RW_USER_FUNCTIONS"; 342 } else if (state == CKS_RW_SO_FUNCTIONS) { 343 name = "CKS_RW_SO_FUNCTIONS"; 344 } else { 345 name = "ERROR: unknown session state 0x" + toFullHexString(state); 346 } 347 348 return name; 349 } 350 351 private static final Flags mechanismInfoFlags = new Flags(new long[] { 352 CKF_HW, 353 CKF_MESSAGE_ENCRYPT, 354 CKF_MESSAGE_DECRYPT, 355 CKF_MESSAGE_SIGN, 356 CKF_MESSAGE_VERIFY, 357 CKF_MULTI_MESSAGE, 358 CKF_FIND_OBJECTS, 359 CKF_ENCRYPT, 360 CKF_DECRYPT, 361 CKF_DIGEST, 362 CKF_SIGN, 363 CKF_SIGN_RECOVER, 364 CKF_VERIFY, 365 CKF_VERIFY_RECOVER, 366 CKF_GENERATE, 367 CKF_GENERATE_KEY_PAIR, 368 CKF_WRAP, 369 CKF_UNWRAP, 370 CKF_DERIVE, 371 CKF_EC_F_P, 372 CKF_EC_F_2M, 373 CKF_EC_ECPARAMETERS, 374 CKF_EC_OID, 375 CKF_EC_UNCOMPRESS, 376 CKF_EC_COMPRESS, 377 CKF_EC_CURVENAME, 378 CKF_EXTENSION, 379 }, new String[] { 380 "CKF_HW", 381 "CKF_MESSAGE_ENCRYPT", 382 "CKF_MESSAGE_DECRYPT", 383 "CKF_MESSAGE_SIGN", 384 "CKF_MESSAGE_VERIFY", 385 "CKF_MULTI_MESSAGE", 386 "CKF_FIND_OBJECTS", 387 "CKF_ENCRYPT", 388 "CKF_DECRYPT", 389 "CKF_DIGEST", 390 "CKF_SIGN", 391 "CKF_SIGN_RECOVER", 392 "CKF_VERIFY", 393 "CKF_VERIFY_RECOVER", 394 "CKF_GENERATE", 395 "CKF_GENERATE_KEY_PAIR", 396 "CKF_WRAP", 397 "CKF_UNWRAP", 398 "CKF_DERIVE", 399 "CKF_EC_F_P", 400 "CKF_EC_F_2M", 401 "CKF_EC_ECPARAMETERS", 402 "CKF_EC_OID", 403 "CKF_EC_UNCOMPRESS", 404 "CKF_EC_COMPRESS", 405 "CKF_EC_CURVENAME", 406 "CKF_EXTENSION", 407 }); 408 409 /** 410 * converts the long value flags to a MechanismInfoFlag string 411 * 412 * @param flags the flags to be converted 413 * @return the MechanismInfoFlag string representation of the flags 414 */ mechanismInfoFlagsToString(long flags)415 public static String mechanismInfoFlagsToString(long flags) { 416 return mechanismInfoFlags.toString(flags); 417 } 418 getName(Map<Integer,String> nameMap, long id)419 private static String getName(Map<Integer,String> nameMap, long id) { 420 String name = null; 421 if ((id >>> 32) == 0) { 422 name = nameMap.get(Integer.valueOf((int)id)); 423 } 424 if (name == null) { 425 if ((id & CKM_VENDOR_DEFINED) != 0) { 426 name = "(Vendor-Specific) 0x" + toFullHexString(id); 427 } else { 428 name = "(Unknown) 0x" + toFullHexString(id); 429 } 430 } 431 return name; 432 } 433 getId(Map<String,Integer> idMap, String name)434 public static long getId(Map<String,Integer> idMap, String name) { 435 Integer mech = idMap.get(name); 436 if (mech == null) { 437 throw new IllegalArgumentException("Unknown name " + name); 438 } 439 return mech.intValue() & 0xffffffffL; 440 } 441 getMechanismName(long id)442 public static String getMechanismName(long id) { 443 return getName(mechNames, id); 444 } 445 getMechanismId(String name)446 public static long getMechanismId(String name) { 447 return getId(mechIds, name); 448 } 449 getKeyName(long id)450 public static String getKeyName(long id) { 451 return getName(keyNames, id); 452 } 453 getKeyId(String name)454 public static long getKeyId(String name) { 455 return getId(keyIds, name); 456 } 457 getAttributeName(long id)458 public static String getAttributeName(long id) { 459 return getName(attributeNames, id); 460 } 461 getAttributeId(String name)462 public static long getAttributeId(String name) { 463 return getId(attributeIds, name); 464 } 465 getObjectClassName(long id)466 public static String getObjectClassName(long id) { 467 return getName(objectClassNames, id); 468 } 469 getObjectClassId(String name)470 public static long getObjectClassId(String name) { 471 return getId(objectClassIds, name); 472 } 473 getHashMechId(String name)474 public static long getHashMechId(String name) { 475 return hashMechIds.get(name); 476 } 477 getMGFName(long id)478 public static String getMGFName(long id) { 479 return getName(mgfNames, id); 480 } 481 getMGFId(String name)482 public static long getMGFId(String name) { 483 return getId(mgfIds, name); 484 } 485 486 /** 487 * Check the given arrays for equalitiy. This method considers both arrays as 488 * equal, if both are <code>null</code> or both have the same length and 489 * contain exactly the same char values. 490 * 491 * @param array1 The first array. 492 * @param array2 The second array. 493 * @return True, if both arrays are <code>null</code> or both have the same 494 * length and contain exactly the same char values. False, otherwise. 495 * @preconditions 496 * @postconditions 497 */ equals(char[] array1, char[] array2)498 private static boolean equals(char[] array1, char[] array2) { 499 return Arrays.equals(array1, array2); 500 } 501 502 /** 503 * Check the given dates for equalitiy. This method considers both dates as 504 * equal, if both are <code>null</code> or both contain exactly the same char 505 * values. 506 * 507 * @param date1 The first date. 508 * @param date2 The second date. 509 * @return True, if both dates are <code>null</code> or both contain the same 510 * char values. False, otherwise. 511 * @preconditions 512 * @postconditions 513 */ equals(CK_DATE date1, CK_DATE date2)514 public static boolean equals(CK_DATE date1, CK_DATE date2) { 515 boolean equal = false; 516 517 if (date1 == date2) { 518 equal = true; 519 } else if ((date1 != null) && (date2 != null)) { 520 equal = equals(date1.year, date2.year) 521 && equals(date1.month, date2.month) 522 && equals(date1.day, date2.day); 523 } else { 524 equal = false; 525 } 526 527 return equal ; 528 } 529 530 /** 531 * Calculate a hash code for the given byte array. 532 * 533 * @param array The byte array. 534 * @return A hash code for the given array. 535 * @preconditions 536 * @postconditions 537 */ hashCode(byte[] array)538 public static int hashCode(byte[] array) { 539 int hash = 0; 540 541 if (array != null) { 542 for (int i = 0; (i < 4) && (i < array.length); i++) { 543 hash ^= (0xFF & array[i]) << ((i%4) << 3); 544 } 545 } 546 547 return hash ; 548 } 549 550 /** 551 * Calculate a hash code for the given char array. 552 * 553 * @param array The char array. 554 * @return A hash code for the given array. 555 * @preconditions 556 * @postconditions 557 */ hashCode(char[] array)558 public static int hashCode(char[] array) { 559 int hash = 0; 560 561 if (array != null) { 562 for (int i = 0; (i < 4) && (i < array.length); i++) { 563 hash ^= (0xFFFF & array[i]) << ((i%2) << 4); 564 } 565 } 566 567 return hash ; 568 } 569 570 /** 571 * Calculate a hash code for the given date object. 572 * 573 * @param date The date object. 574 * @return A hash code for the given date. 575 * @preconditions 576 * @postconditions 577 */ hashCode(CK_DATE date)578 public static int hashCode(CK_DATE date) { 579 int hash = 0; 580 581 if (date != null) { 582 if (date.year.length == 4) { 583 hash ^= (0xFFFF & date.year[0]) << 16; 584 hash ^= 0xFFFF & date.year[1]; 585 hash ^= (0xFFFF & date.year[2]) << 16; 586 hash ^= 0xFFFF & date.year[3]; 587 } 588 if (date.month.length == 2) { 589 hash ^= (0xFFFF & date.month[0]) << 16; 590 hash ^= 0xFFFF & date.month[1]; 591 } 592 if (date.day.length == 2) { 593 hash ^= (0xFFFF & date.day[0]) << 16; 594 hash ^= 0xFFFF & date.day[1]; 595 } 596 } 597 598 return hash ; 599 } 600 addMapping(Map<Integer,String> nameMap, Map<String,Integer> idMap, long id, String name)601 private static void addMapping(Map<Integer,String> nameMap, 602 Map<String,Integer> idMap, long id, String name) { 603 if ((id >>> 32) != 0) { 604 throw new AssertionError("Id has high bits set: " + id + ", " + name); 605 } 606 Integer intId = Integer.valueOf((int)id); 607 if (nameMap.put(intId, name) != null) { 608 throw new AssertionError("Duplicate id: " + id + ", " + name); 609 } 610 if (idMap.put(name, intId) != null) { 611 throw new AssertionError("Duplicate name: " + id + ", " + name); 612 } 613 } 614 addMech(long id, String name)615 private static void addMech(long id, String name) { 616 addMapping(mechNames, mechIds, id, name); 617 } 618 addKeyType(long id, String name)619 private static void addKeyType(long id, String name) { 620 addMapping(keyNames, keyIds, id, name); 621 } 622 addAttribute(long id, String name)623 private static void addAttribute(long id, String name) { 624 addMapping(attributeNames, attributeIds, id, name); 625 } 626 addObjectClass(long id, String name)627 private static void addObjectClass(long id, String name) { 628 addMapping(objectClassNames, objectClassIds, id, name); 629 } 630 addHashMech(long id, String... names)631 private static void addHashMech(long id, String... names) { 632 for (String n : names) { 633 hashMechIds.put(n, id); 634 } 635 } 636 addMGF(long id, String name)637 private static void addMGF(long id, String name) { 638 addMapping(mgfNames, mgfIds, id, name); 639 } 640 641 // The ordering here follows the PKCS11Constants class 642 static { addMech(CKM_RSA_PKCS_KEY_PAIR_GEN, R)643 addMech(CKM_RSA_PKCS_KEY_PAIR_GEN, "CKM_RSA_PKCS_KEY_PAIR_GEN"); addMech(CKM_RSA_PKCS, R)644 addMech(CKM_RSA_PKCS, "CKM_RSA_PKCS"); addMech(CKM_RSA_9796, R)645 addMech(CKM_RSA_9796, "CKM_RSA_9796"); addMech(CKM_RSA_X_509, R)646 addMech(CKM_RSA_X_509, "CKM_RSA_X_509"); addMech(CKM_MD2_RSA_PKCS, R)647 addMech(CKM_MD2_RSA_PKCS, "CKM_MD2_RSA_PKCS"); addMech(CKM_MD5_RSA_PKCS, R)648 addMech(CKM_MD5_RSA_PKCS, "CKM_MD5_RSA_PKCS"); addMech(CKM_SHA1_RSA_PKCS, R)649 addMech(CKM_SHA1_RSA_PKCS, "CKM_SHA1_RSA_PKCS"); addMech(CKM_RIPEMD128_RSA_PKCS, R)650 addMech(CKM_RIPEMD128_RSA_PKCS, "CKM_RIPEMD128_RSA_PKCS"); addMech(CKM_RIPEMD160_RSA_PKCS, R)651 addMech(CKM_RIPEMD160_RSA_PKCS, "CKM_RIPEMD160_RSA_PKCS"); addMech(CKM_RSA_PKCS_OAEP, R)652 addMech(CKM_RSA_PKCS_OAEP, "CKM_RSA_PKCS_OAEP"); addMech(CKM_RSA_X9_31_KEY_PAIR_GEN, R)653 addMech(CKM_RSA_X9_31_KEY_PAIR_GEN, "CKM_RSA_X9_31_KEY_PAIR_GEN"); addMech(CKM_RSA_X9_31, R)654 addMech(CKM_RSA_X9_31, "CKM_RSA_X9_31"); addMech(CKM_SHA1_RSA_X9_31, R)655 addMech(CKM_SHA1_RSA_X9_31, "CKM_SHA1_RSA_X9_31"); addMech(CKM_RSA_PKCS_PSS, R)656 addMech(CKM_RSA_PKCS_PSS, "CKM_RSA_PKCS_PSS"); addMech(CKM_SHA1_RSA_PKCS_PSS, R)657 addMech(CKM_SHA1_RSA_PKCS_PSS, "CKM_SHA1_RSA_PKCS_PSS"); addMech(CKM_DSA_KEY_PAIR_GEN, R)658 addMech(CKM_DSA_KEY_PAIR_GEN, "CKM_DSA_KEY_PAIR_GEN"); addMech(CKM_DSA, R)659 addMech(CKM_DSA, "CKM_DSA"); addMech(CKM_DSA_SHA1, R)660 addMech(CKM_DSA_SHA1, "CKM_DSA_SHA1"); addMech(CKM_DSA_SHA224, R)661 addMech(CKM_DSA_SHA224, "CKM_DSA_SHA224"); addMech(CKM_DSA_SHA256, R)662 addMech(CKM_DSA_SHA256, "CKM_DSA_SHA256"); addMech(CKM_DSA_SHA384, R)663 addMech(CKM_DSA_SHA384, "CKM_DSA_SHA384"); addMech(CKM_DSA_SHA512, R)664 addMech(CKM_DSA_SHA512, "CKM_DSA_SHA512"); addMech(CKM_DSA_SHA3_224, R)665 addMech(CKM_DSA_SHA3_224, "CKM_DSA_SHA3_224"); addMech(CKM_DSA_SHA3_256, R)666 addMech(CKM_DSA_SHA3_256, "CKM_DSA_SHA3_256"); addMech(CKM_DSA_SHA3_384, R)667 addMech(CKM_DSA_SHA3_384, "CKM_DSA_SHA3_384"); addMech(CKM_DSA_SHA3_512, R)668 addMech(CKM_DSA_SHA3_512, "CKM_DSA_SHA3_512"); 669 addMech(CKM_DH_PKCS_KEY_PAIR_GEN, R)670 addMech(CKM_DH_PKCS_KEY_PAIR_GEN, "CKM_DH_PKCS_KEY_PAIR_GEN"); addMech(CKM_DH_PKCS_DERIVE, R)671 addMech(CKM_DH_PKCS_DERIVE, "CKM_DH_PKCS_DERIVE"); addMech(CKM_X9_42_DH_KEY_PAIR_GEN, R)672 addMech(CKM_X9_42_DH_KEY_PAIR_GEN, "CKM_X9_42_DH_KEY_PAIR_GEN"); addMech(CKM_X9_42_DH_DERIVE, R)673 addMech(CKM_X9_42_DH_DERIVE, "CKM_X9_42_DH_DERIVE"); addMech(CKM_X9_42_DH_HYBRID_DERIVE, R)674 addMech(CKM_X9_42_DH_HYBRID_DERIVE, "CKM_X9_42_DH_HYBRID_DERIVE"); addMech(CKM_X9_42_MQV_DERIVE, R)675 addMech(CKM_X9_42_MQV_DERIVE, "CKM_X9_42_MQV_DERIVE"); 676 addMech(CKM_SHA256_RSA_PKCS, R)677 addMech(CKM_SHA256_RSA_PKCS, "CKM_SHA256_RSA_PKCS"); addMech(CKM_SHA384_RSA_PKCS, R)678 addMech(CKM_SHA384_RSA_PKCS, "CKM_SHA384_RSA_PKCS"); addMech(CKM_SHA512_RSA_PKCS, R)679 addMech(CKM_SHA512_RSA_PKCS, "CKM_SHA512_RSA_PKCS"); addMech(CKM_SHA256_RSA_PKCS_PSS, R)680 addMech(CKM_SHA256_RSA_PKCS_PSS, "CKM_SHA256_RSA_PKCS_PSS"); addMech(CKM_SHA384_RSA_PKCS_PSS, R)681 addMech(CKM_SHA384_RSA_PKCS_PSS, "CKM_SHA384_RSA_PKCS_PSS"); addMech(CKM_SHA512_RSA_PKCS_PSS, R)682 addMech(CKM_SHA512_RSA_PKCS_PSS, "CKM_SHA512_RSA_PKCS_PSS"); addMech(CKM_SHA224_RSA_PKCS, R)683 addMech(CKM_SHA224_RSA_PKCS, "CKM_SHA224_RSA_PKCS"); addMech(CKM_SHA224_RSA_PKCS_PSS, R)684 addMech(CKM_SHA224_RSA_PKCS_PSS, "CKM_SHA224_RSA_PKCS_PSS"); 685 addMech(CKM_SHA512_224, R)686 addMech(CKM_SHA512_224, "CKM_SHA512_224"); addMech(CKM_SHA512_224_HMAC, R)687 addMech(CKM_SHA512_224_HMAC, "CKM_SHA512_224_HMAC"); addMech(CKM_SHA512_224_HMAC_GENERAL, R)688 addMech(CKM_SHA512_224_HMAC_GENERAL, "CKM_SHA512_224_HMAC_GENERAL"); addMech(CKM_SHA512_224_KEY_DERIVATION, R)689 addMech(CKM_SHA512_224_KEY_DERIVATION, "CKM_SHA512_224_KEY_DERIVATION"); addMech(CKM_SHA512_256, R)690 addMech(CKM_SHA512_256, "CKM_SHA512_256"); addMech(CKM_SHA512_256_HMAC, R)691 addMech(CKM_SHA512_256_HMAC, "CKM_SHA512_256_HMAC"); addMech(CKM_SHA512_256_HMAC_GENERAL, R)692 addMech(CKM_SHA512_256_HMAC_GENERAL, "CKM_SHA512_256_HMAC_GENERAL"); addMech(CKM_SHA512_256_KEY_DERIVATION, R)693 addMech(CKM_SHA512_256_KEY_DERIVATION, "CKM_SHA512_256_KEY_DERIVATION"); addMech(CKM_SHA512_T, R)694 addMech(CKM_SHA512_T, "CKM_SHA512_T"); addMech(CKM_SHA512_T_HMAC, R)695 addMech(CKM_SHA512_T_HMAC, "CKM_SHA512_T_HMAC"); addMech(CKM_SHA512_T_HMAC_GENERAL, R)696 addMech(CKM_SHA512_T_HMAC_GENERAL, "CKM_SHA512_T_HMAC_GENERAL"); addMech(CKM_SHA512_T_KEY_DERIVATION, R)697 addMech(CKM_SHA512_T_KEY_DERIVATION, "CKM_SHA512_T_KEY_DERIVATION"); 698 addMech(CKM_SHA3_256_RSA_PKCS, R)699 addMech(CKM_SHA3_256_RSA_PKCS, "CKM_SHA3_256_RSA_PKCS"); addMech(CKM_SHA3_384_RSA_PKCS, R)700 addMech(CKM_SHA3_384_RSA_PKCS, "CKM_SHA3_384_RSA_PKCS"); addMech(CKM_SHA3_512_RSA_PKCS, R)701 addMech(CKM_SHA3_512_RSA_PKCS, "CKM_SHA3_512_RSA_PKCS"); addMech(CKM_SHA3_256_RSA_PKCS_PSS, R)702 addMech(CKM_SHA3_256_RSA_PKCS_PSS, "CKM_SHA3_256_RSA_PKCS_PSS"); addMech(CKM_SHA3_384_RSA_PKCS_PSS, R)703 addMech(CKM_SHA3_384_RSA_PKCS_PSS, "CKM_SHA3_384_RSA_PKCS_PSS"); addMech(CKM_SHA3_512_RSA_PKCS_PSS, R)704 addMech(CKM_SHA3_512_RSA_PKCS_PSS, "CKM_SHA3_512_RSA_PKCS_PSS"); addMech(CKM_SHA3_224_RSA_PKCS, R)705 addMech(CKM_SHA3_224_RSA_PKCS, "CKM_SHA3_224_RSA_PKCS"); addMech(CKM_SHA3_224_RSA_PKCS_PSS, R)706 addMech(CKM_SHA3_224_RSA_PKCS_PSS, "CKM_SHA3_224_RSA_PKCS_PSS"); 707 addMech(CKM_RC2_KEY_GEN, R)708 addMech(CKM_RC2_KEY_GEN, "CKM_RC2_KEY_GEN"); addMech(CKM_RC2_ECB, R)709 addMech(CKM_RC2_ECB, "CKM_RC2_ECB"); addMech(CKM_RC2_CBC, R)710 addMech(CKM_RC2_CBC, "CKM_RC2_CBC"); addMech(CKM_RC2_MAC, R)711 addMech(CKM_RC2_MAC, "CKM_RC2_MAC"); addMech(CKM_RC2_MAC_GENERAL, R)712 addMech(CKM_RC2_MAC_GENERAL, "CKM_RC2_MAC_GENERAL"); addMech(CKM_RC2_CBC_PAD, R)713 addMech(CKM_RC2_CBC_PAD, "CKM_RC2_CBC_PAD"); addMech(CKM_RC4_KEY_GEN, R)714 addMech(CKM_RC4_KEY_GEN, "CKM_RC4_KEY_GEN"); addMech(CKM_RC4, R)715 addMech(CKM_RC4, "CKM_RC4"); addMech(CKM_DES_KEY_GEN, R)716 addMech(CKM_DES_KEY_GEN, "CKM_DES_KEY_GEN"); addMech(CKM_DES_ECB, R)717 addMech(CKM_DES_ECB, "CKM_DES_ECB"); addMech(CKM_DES_CBC, R)718 addMech(CKM_DES_CBC, "CKM_DES_CBC"); addMech(CKM_DES_MAC, R)719 addMech(CKM_DES_MAC, "CKM_DES_MAC"); addMech(CKM_DES_MAC_GENERAL, R)720 addMech(CKM_DES_MAC_GENERAL, "CKM_DES_MAC_GENERAL"); addMech(CKM_DES_CBC_PAD, R)721 addMech(CKM_DES_CBC_PAD, "CKM_DES_CBC_PAD"); addMech(CKM_DES2_KEY_GEN, R)722 addMech(CKM_DES2_KEY_GEN, "CKM_DES2_KEY_GEN"); addMech(CKM_DES3_KEY_GEN, R)723 addMech(CKM_DES3_KEY_GEN, "CKM_DES3_KEY_GEN"); addMech(CKM_DES3_ECB, R)724 addMech(CKM_DES3_ECB, "CKM_DES3_ECB"); addMech(CKM_DES3_CBC, R)725 addMech(CKM_DES3_CBC, "CKM_DES3_CBC"); addMech(CKM_DES3_MAC, R)726 addMech(CKM_DES3_MAC, "CKM_DES3_MAC"); addMech(CKM_DES3_MAC_GENERAL, R)727 addMech(CKM_DES3_MAC_GENERAL, "CKM_DES3_MAC_GENERAL"); addMech(CKM_DES3_CBC_PAD, R)728 addMech(CKM_DES3_CBC_PAD, "CKM_DES3_CBC_PAD"); addMech(CKM_DES3_CMAC_GENERAL, R)729 addMech(CKM_DES3_CMAC_GENERAL, "CKM_DES3_CMAC_GENERAL"); addMech(CKM_DES3_CMAC, R)730 addMech(CKM_DES3_CMAC, "CKM_DES3_CMAC"); 731 addMech(CKM_CDMF_KEY_GEN, R)732 addMech(CKM_CDMF_KEY_GEN, "CKM_CDMF_KEY_GEN"); addMech(CKM_CDMF_ECB, R)733 addMech(CKM_CDMF_ECB, "CKM_CDMF_ECB"); addMech(CKM_CDMF_CBC, R)734 addMech(CKM_CDMF_CBC, "CKM_CDMF_CBC"); addMech(CKM_CDMF_MAC, R)735 addMech(CKM_CDMF_MAC, "CKM_CDMF_MAC"); addMech(CKM_CDMF_MAC_GENERAL, R)736 addMech(CKM_CDMF_MAC_GENERAL, "CKM_CDMF_MAC_GENERAL"); addMech(CKM_CDMF_CBC_PAD, R)737 addMech(CKM_CDMF_CBC_PAD, "CKM_CDMF_CBC_PAD"); 738 addMech(CKM_DES_OFB64, R)739 addMech(CKM_DES_OFB64, "CKM_DES_OFB64"); addMech(CKM_DES_OFB8, R)740 addMech(CKM_DES_OFB8, "CKM_DES_OFB8"); addMech(CKM_DES_CFB64, R)741 addMech(CKM_DES_CFB64, "CKM_DES_CFB64"); addMech(CKM_DES_CFB8, R)742 addMech(CKM_DES_CFB8, "CKM_DES_CFB8"); 743 addMech(CKM_MD2, R)744 addMech(CKM_MD2, "CKM_MD2"); addMech(CKM_MD2_HMAC, R)745 addMech(CKM_MD2_HMAC, "CKM_MD2_HMAC"); addMech(CKM_MD2_HMAC_GENERAL, R)746 addMech(CKM_MD2_HMAC_GENERAL, "CKM_MD2_HMAC_GENERAL"); addMech(CKM_MD5, R)747 addMech(CKM_MD5, "CKM_MD5"); addMech(CKM_MD5_HMAC, R)748 addMech(CKM_MD5_HMAC, "CKM_MD5_HMAC"); addMech(CKM_MD5_HMAC_GENERAL, R)749 addMech(CKM_MD5_HMAC_GENERAL, "CKM_MD5_HMAC_GENERAL"); addMech(CKM_SHA_1, R)750 addMech(CKM_SHA_1, "CKM_SHA_1"); addMech(CKM_SHA_1_HMAC, R)751 addMech(CKM_SHA_1_HMAC, "CKM_SHA_1_HMAC"); addMech(CKM_SHA_1_HMAC_GENERAL, R)752 addMech(CKM_SHA_1_HMAC_GENERAL, "CKM_SHA_1_HMAC_GENERAL"); addMech(CKM_RIPEMD128, R)753 addMech(CKM_RIPEMD128, "CKM_RIPEMD128"); addMech(CKM_RIPEMD128_HMAC, R)754 addMech(CKM_RIPEMD128_HMAC, "CKM_RIPEMD128_HMAC"); addMech(CKM_RIPEMD128_HMAC_GENERAL, R)755 addMech(CKM_RIPEMD128_HMAC_GENERAL, "CKM_RIPEMD128_HMAC_GENERAL"); addMech(CKM_RIPEMD160, R)756 addMech(CKM_RIPEMD160, "CKM_RIPEMD160"); addMech(CKM_RIPEMD160_HMAC, R)757 addMech(CKM_RIPEMD160_HMAC, "CKM_RIPEMD160_HMAC"); addMech(CKM_RIPEMD160_HMAC_GENERAL, R)758 addMech(CKM_RIPEMD160_HMAC_GENERAL, "CKM_RIPEMD160_HMAC_GENERAL"); addMech(CKM_SHA256, R)759 addMech(CKM_SHA256, "CKM_SHA256"); addMech(CKM_SHA256_HMAC, R)760 addMech(CKM_SHA256_HMAC, "CKM_SHA256_HMAC"); addMech(CKM_SHA256_HMAC_GENERAL, R)761 addMech(CKM_SHA256_HMAC_GENERAL, "CKM_SHA256_HMAC_GENERAL"); addMech(CKM_SHA224, R)762 addMech(CKM_SHA224, "CKM_SHA224"); addMech(CKM_SHA224_HMAC, R)763 addMech(CKM_SHA224_HMAC, "CKM_SHA224_HMAC"); addMech(CKM_SHA224_HMAC_GENERAL, R)764 addMech(CKM_SHA224_HMAC_GENERAL, "CKM_SHA224_HMAC_GENERAL"); addMech(CKM_SHA384, R)765 addMech(CKM_SHA384, "CKM_SHA384"); addMech(CKM_SHA384_HMAC, R)766 addMech(CKM_SHA384_HMAC, "CKM_SHA384_HMAC"); addMech(CKM_SHA384_HMAC_GENERAL, R)767 addMech(CKM_SHA384_HMAC_GENERAL, "CKM_SHA384_HMAC_GENERAL"); addMech(CKM_SHA512, R)768 addMech(CKM_SHA512, "CKM_SHA512"); addMech(CKM_SHA512_HMAC, R)769 addMech(CKM_SHA512_HMAC, "CKM_SHA512_HMAC"); addMech(CKM_SHA512_HMAC_GENERAL, R)770 addMech(CKM_SHA512_HMAC_GENERAL, "CKM_SHA512_HMAC_GENERAL"); 771 addMech(CKM_SECURID_KEY_GEN, R)772 addMech(CKM_SECURID_KEY_GEN, "CKM_SECURID_KEY_GEN"); addMech(CKM_SECURID, R)773 addMech(CKM_SECURID, "CKM_SECURID"); addMech(CKM_HOTP_KEY_GEN, R)774 addMech(CKM_HOTP_KEY_GEN, "CKM_HOTP_KEY_GEN"); addMech(CKM_HOTP, R)775 addMech(CKM_HOTP, "CKM_HOTP"); addMech(CKM_ACTI, R)776 addMech(CKM_ACTI, "CKM_ACTI"); addMech(CKM_ACTI_KEY_GEN, R)777 addMech(CKM_ACTI_KEY_GEN, "CKM_ACTI_KEY_GEN"); 778 addMech(CKM_SHA3_256, R)779 addMech(CKM_SHA3_256, "CKM_SHA3_256"); addMech(CKM_SHA3_256_HMAC, R)780 addMech(CKM_SHA3_256_HMAC, "CKM_SHA3_256_HMAC"); addMech(CKM_SHA3_256_HMAC_GENERAL, R)781 addMech(CKM_SHA3_256_HMAC_GENERAL, "CKM_SHA3_256_HMAC_GENERAL"); addMech(CKM_SHA3_256_KEY_GEN, R)782 addMech(CKM_SHA3_256_KEY_GEN, "CKM_SHA3_256_KEY_GEN"); addMech(CKM_SHA3_224, R)783 addMech(CKM_SHA3_224, "CKM_SHA3_224"); addMech(CKM_SHA3_224_HMAC, R)784 addMech(CKM_SHA3_224_HMAC, "CKM_SHA3_224_HMAC"); addMech(CKM_SHA3_224_HMAC_GENERAL, R)785 addMech(CKM_SHA3_224_HMAC_GENERAL, "CKM_SHA3_224_HMAC_GENERAL"); addMech(CKM_SHA3_224_KEY_GEN, R)786 addMech(CKM_SHA3_224_KEY_GEN, "CKM_SHA3_224_KEY_GEN"); addMech(CKM_SHA3_384, R)787 addMech(CKM_SHA3_384, "CKM_SHA3_384"); addMech(CKM_SHA3_384_HMAC, R)788 addMech(CKM_SHA3_384_HMAC, "CKM_SHA3_384_HMAC"); addMech(CKM_SHA3_384_HMAC_GENERAL, R)789 addMech(CKM_SHA3_384_HMAC_GENERAL, "CKM_SHA3_384_HMAC_GENERAL"); addMech(CKM_SHA3_384_KEY_GEN, R)790 addMech(CKM_SHA3_384_KEY_GEN, "CKM_SHA3_384_KEY_GEN"); addMech(CKM_SHA3_512, R)791 addMech(CKM_SHA3_512, "CKM_SHA3_512"); addMech(CKM_SHA3_512_HMAC, R)792 addMech(CKM_SHA3_512_HMAC, "CKM_SHA3_512_HMAC"); addMech(CKM_SHA3_512_HMAC_GENERAL, R)793 addMech(CKM_SHA3_512_HMAC_GENERAL, "CKM_SHA3_512_HMAC_GENERAL"); addMech(CKM_SHA3_512_KEY_GEN, R)794 addMech(CKM_SHA3_512_KEY_GEN, "CKM_SHA3_512_KEY_GEN"); 795 addMech(CKM_CAST_KEY_GEN, R)796 addMech(CKM_CAST_KEY_GEN, "CKM_CAST_KEY_GEN"); addMech(CKM_CAST_ECB, R)797 addMech(CKM_CAST_ECB, "CKM_CAST_ECB"); addMech(CKM_CAST_CBC, R)798 addMech(CKM_CAST_CBC, "CKM_CAST_CBC"); addMech(CKM_CAST_MAC, R)799 addMech(CKM_CAST_MAC, "CKM_CAST_MAC"); addMech(CKM_CAST_MAC_GENERAL, R)800 addMech(CKM_CAST_MAC_GENERAL, "CKM_CAST_MAC_GENERAL"); addMech(CKM_CAST_CBC_PAD, R)801 addMech(CKM_CAST_CBC_PAD, "CKM_CAST_CBC_PAD"); addMech(CKM_CAST3_KEY_GEN, R)802 addMech(CKM_CAST3_KEY_GEN, "CKM_CAST3_KEY_GEN"); addMech(CKM_CAST3_ECB, R)803 addMech(CKM_CAST3_ECB, "CKM_CAST3_ECB"); addMech(CKM_CAST3_CBC, R)804 addMech(CKM_CAST3_CBC, "CKM_CAST3_CBC"); addMech(CKM_CAST3_MAC, R)805 addMech(CKM_CAST3_MAC, "CKM_CAST3_MAC"); addMech(CKM_CAST3_MAC_GENERAL, R)806 addMech(CKM_CAST3_MAC_GENERAL, "CKM_CAST3_MAC_GENERAL"); addMech(CKM_CAST3_CBC_PAD, R)807 addMech(CKM_CAST3_CBC_PAD, "CKM_CAST3_CBC_PAD"); addMech(CKM_CAST128_KEY_GEN, R)808 addMech(CKM_CAST128_KEY_GEN, "CKM_CAST128_KEY_GEN"); addMech(CKM_CAST128_ECB, R)809 addMech(CKM_CAST128_ECB, "CKM_CAST128_ECB"); addMech(CKM_CAST128_CBC, R)810 addMech(CKM_CAST128_CBC, "CKM_CAST128_CBC"); addMech(CKM_CAST128_MAC, R)811 addMech(CKM_CAST128_MAC, "CKM_CAST128_MAC"); addMech(CKM_CAST128_MAC_GENERAL, R)812 addMech(CKM_CAST128_MAC_GENERAL, "CKM_CAST128_MAC_GENERAL"); addMech(CKM_CAST128_CBC_PAD, R)813 addMech(CKM_CAST128_CBC_PAD, "CKM_CAST128_CBC_PAD"); addMech(CKM_RC5_KEY_GEN, R)814 addMech(CKM_RC5_KEY_GEN, "CKM_RC5_KEY_GEN"); addMech(CKM_RC5_ECB, R)815 addMech(CKM_RC5_ECB, "CKM_RC5_ECB"); addMech(CKM_RC5_CBC, R)816 addMech(CKM_RC5_CBC, "CKM_RC5_CBC"); addMech(CKM_RC5_MAC, R)817 addMech(CKM_RC5_MAC, "CKM_RC5_MAC"); addMech(CKM_RC5_MAC_GENERAL, R)818 addMech(CKM_RC5_MAC_GENERAL, "CKM_RC5_MAC_GENERAL"); addMech(CKM_RC5_CBC_PAD, R)819 addMech(CKM_RC5_CBC_PAD, "CKM_RC5_CBC_PAD"); addMech(CKM_IDEA_KEY_GEN, R)820 addMech(CKM_IDEA_KEY_GEN, "CKM_IDEA_KEY_GEN"); addMech(CKM_IDEA_ECB, R)821 addMech(CKM_IDEA_ECB, "CKM_IDEA_ECB"); addMech(CKM_IDEA_CBC, R)822 addMech(CKM_IDEA_CBC, "CKM_IDEA_CBC"); addMech(CKM_IDEA_MAC, R)823 addMech(CKM_IDEA_MAC, "CKM_IDEA_MAC"); addMech(CKM_IDEA_MAC_GENERAL, R)824 addMech(CKM_IDEA_MAC_GENERAL, "CKM_IDEA_MAC_GENERAL"); addMech(CKM_IDEA_CBC_PAD, R)825 addMech(CKM_IDEA_CBC_PAD, "CKM_IDEA_CBC_PAD"); addMech(CKM_GENERIC_SECRET_KEY_GEN, R)826 addMech(CKM_GENERIC_SECRET_KEY_GEN, "CKM_GENERIC_SECRET_KEY_GEN"); addMech(CKM_CONCATENATE_BASE_AND_KEY, R)827 addMech(CKM_CONCATENATE_BASE_AND_KEY, "CKM_CONCATENATE_BASE_AND_KEY"); addMech(CKM_CONCATENATE_BASE_AND_DATA, R)828 addMech(CKM_CONCATENATE_BASE_AND_DATA, "CKM_CONCATENATE_BASE_AND_DATA"); addMech(CKM_CONCATENATE_DATA_AND_BASE, R)829 addMech(CKM_CONCATENATE_DATA_AND_BASE, "CKM_CONCATENATE_DATA_AND_BASE"); addMech(CKM_XOR_BASE_AND_DATA, R)830 addMech(CKM_XOR_BASE_AND_DATA, "CKM_XOR_BASE_AND_DATA"); addMech(CKM_EXTRACT_KEY_FROM_KEY, R)831 addMech(CKM_EXTRACT_KEY_FROM_KEY, "CKM_EXTRACT_KEY_FROM_KEY"); addMech(CKM_SSL3_PRE_MASTER_KEY_GEN, R)832 addMech(CKM_SSL3_PRE_MASTER_KEY_GEN, "CKM_SSL3_PRE_MASTER_KEY_GEN"); addMech(CKM_SSL3_MASTER_KEY_DERIVE, R)833 addMech(CKM_SSL3_MASTER_KEY_DERIVE, "CKM_SSL3_MASTER_KEY_DERIVE"); addMech(CKM_SSL3_KEY_AND_MAC_DERIVE, R)834 addMech(CKM_SSL3_KEY_AND_MAC_DERIVE, "CKM_SSL3_KEY_AND_MAC_DERIVE"); addMech(CKM_SSL3_MASTER_KEY_DERIVE_DH, R)835 addMech(CKM_SSL3_MASTER_KEY_DERIVE_DH, "CKM_SSL3_MASTER_KEY_DERIVE_DH"); addMech(CKM_TLS_PRE_MASTER_KEY_GEN, R)836 addMech(CKM_TLS_PRE_MASTER_KEY_GEN, "CKM_TLS_PRE_MASTER_KEY_GEN"); addMech(CKM_TLS_MASTER_KEY_DERIVE, R)837 addMech(CKM_TLS_MASTER_KEY_DERIVE, "CKM_TLS_MASTER_KEY_DERIVE"); addMech(CKM_TLS_KEY_AND_MAC_DERIVE, R)838 addMech(CKM_TLS_KEY_AND_MAC_DERIVE, "CKM_TLS_KEY_AND_MAC_DERIVE"); addMech(CKM_TLS_MASTER_KEY_DERIVE_DH, R)839 addMech(CKM_TLS_MASTER_KEY_DERIVE_DH, "CKM_TLS_MASTER_KEY_DERIVE_DH"); addMech(CKM_TLS_PRF, R)840 addMech(CKM_TLS_PRF, "CKM_TLS_PRF"); addMech(CKM_SSL3_MD5_MAC, R)841 addMech(CKM_SSL3_MD5_MAC, "CKM_SSL3_MD5_MAC"); addMech(CKM_SSL3_SHA1_MAC, R)842 addMech(CKM_SSL3_SHA1_MAC, "CKM_SSL3_SHA1_MAC"); 843 addMech(CKM_MD5_KEY_DERIVATION, R)844 addMech(CKM_MD5_KEY_DERIVATION, "CKM_MD5_KEY_DERIVATION"); addMech(CKM_MD2_KEY_DERIVATION, R)845 addMech(CKM_MD2_KEY_DERIVATION, "CKM_MD2_KEY_DERIVATION"); addMech(CKM_SHA1_KEY_DERIVATION, R)846 addMech(CKM_SHA1_KEY_DERIVATION, "CKM_SHA1_KEY_DERIVATION"); addMech(CKM_SHA256_KEY_DERIVATION, R)847 addMech(CKM_SHA256_KEY_DERIVATION, "CKM_SHA256_KEY_DERIVATION"); addMech(CKM_SHA384_KEY_DERIVATION, R)848 addMech(CKM_SHA384_KEY_DERIVATION, "CKM_SHA384_KEY_DERIVATION"); addMech(CKM_SHA512_KEY_DERIVATION, R)849 addMech(CKM_SHA512_KEY_DERIVATION, "CKM_SHA512_KEY_DERIVATION"); addMech(CKM_SHA224_KEY_DERIVATION, R)850 addMech(CKM_SHA224_KEY_DERIVATION, "CKM_SHA224_KEY_DERIVATION"); addMech(CKM_SHA3_256_KEY_DERIVATION, R)851 addMech(CKM_SHA3_256_KEY_DERIVATION, "CKM_SHA3_256_KEY_DERIVATION"); addMech(CKM_SHA3_224_KEY_DERIVATION, R)852 addMech(CKM_SHA3_224_KEY_DERIVATION, "CKM_SHA3_224_KEY_DERIVATION"); addMech(CKM_SHA3_384_KEY_DERIVATION, R)853 addMech(CKM_SHA3_384_KEY_DERIVATION, "CKM_SHA3_384_KEY_DERIVATION"); addMech(CKM_SHA3_512_KEY_DERIVATION, R)854 addMech(CKM_SHA3_512_KEY_DERIVATION, "CKM_SHA3_512_KEY_DERIVATION"); addMech(CKM_SHAKE_128_KEY_DERIVATION, R)855 addMech(CKM_SHAKE_128_KEY_DERIVATION, "CKM_SHAKE_128_KEY_DERIVATION"); addMech(CKM_SHAKE_256_KEY_DERIVATION, R)856 addMech(CKM_SHAKE_256_KEY_DERIVATION, "CKM_SHAKE_256_KEY_DERIVATION"); 857 addMech(CKM_PBE_MD2_DES_CBC, R)858 addMech(CKM_PBE_MD2_DES_CBC, "CKM_PBE_MD2_DES_CBC"); addMech(CKM_PBE_MD5_DES_CBC, R)859 addMech(CKM_PBE_MD5_DES_CBC, "CKM_PBE_MD5_DES_CBC"); addMech(CKM_PBE_MD5_CAST_CBC, R)860 addMech(CKM_PBE_MD5_CAST_CBC, "CKM_PBE_MD5_CAST_CBC"); addMech(CKM_PBE_MD5_CAST3_CBC, R)861 addMech(CKM_PBE_MD5_CAST3_CBC, "CKM_PBE_MD5_CAST3_CBC"); addMech(CKM_PBE_MD5_CAST128_CBC, R)862 addMech(CKM_PBE_MD5_CAST128_CBC, "CKM_PBE_MD5_CAST128_CBC"); addMech(CKM_PBE_SHA1_CAST128_CBC, R)863 addMech(CKM_PBE_SHA1_CAST128_CBC, "CKM_PBE_SHA1_CAST128_CBC"); addMech(CKM_PBE_SHA1_RC4_128, R)864 addMech(CKM_PBE_SHA1_RC4_128, "CKM_PBE_SHA1_RC4_128"); addMech(CKM_PBE_SHA1_RC4_40, R)865 addMech(CKM_PBE_SHA1_RC4_40, "CKM_PBE_SHA1_RC4_40"); addMech(CKM_PBE_SHA1_DES3_EDE_CBC, R)866 addMech(CKM_PBE_SHA1_DES3_EDE_CBC, "CKM_PBE_SHA1_DES3_EDE_CBC"); addMech(CKM_PBE_SHA1_DES2_EDE_CBC, R)867 addMech(CKM_PBE_SHA1_DES2_EDE_CBC, "CKM_PBE_SHA1_DES2_EDE_CBC"); addMech(CKM_PBE_SHA1_RC2_128_CBC, R)868 addMech(CKM_PBE_SHA1_RC2_128_CBC, "CKM_PBE_SHA1_RC2_128_CBC"); addMech(CKM_PBE_SHA1_RC2_40_CBC, R)869 addMech(CKM_PBE_SHA1_RC2_40_CBC, "CKM_PBE_SHA1_RC2_40_CBC"); addMech(CKM_PKCS5_PBKD2, R)870 addMech(CKM_PKCS5_PBKD2, "CKM_PKCS5_PBKD2"); addMech(CKM_PBA_SHA1_WITH_SHA1_HMAC, R)871 addMech(CKM_PBA_SHA1_WITH_SHA1_HMAC, "CKM_PBA_SHA1_WITH_SHA1_HMAC"); 872 addMech(CKM_WTLS_PRE_MASTER_KEY_GEN, R)873 addMech(CKM_WTLS_PRE_MASTER_KEY_GEN, "CKM_WTLS_PRE_MASTER_KEY_GEN"); addMech(CKM_WTLS_MASTER_KEY_DERIVE, R)874 addMech(CKM_WTLS_MASTER_KEY_DERIVE, "CKM_WTLS_MASTER_KEY_DERIVE"); addMech(CKM_WTLS_MASTER_KEY_DERIVE_DH_ECC, R)875 addMech(CKM_WTLS_MASTER_KEY_DERIVE_DH_ECC, 876 "CKM_WTLS_MASTER_KEY_DERIVE_DH_ECC"); addMech(CKM_WTLS_PRF, R)877 addMech(CKM_WTLS_PRF, "CKM_WTLS_PRF"); addMech(CKM_WTLS_SERVER_KEY_AND_MAC_DERIVE, R)878 addMech(CKM_WTLS_SERVER_KEY_AND_MAC_DERIVE, 879 "CKM_WTLS_SERVER_KEY_AND_MAC_DERIVE"); addMech(CKM_WTLS_CLIENT_KEY_AND_MAC_DERIVE, R)880 addMech(CKM_WTLS_CLIENT_KEY_AND_MAC_DERIVE, 881 "CKM_WTLS_CLIENT_KEY_AND_MAC_DERIVE"); addMech(CKM_TLS10_MAC_SERVER, R)882 addMech(CKM_TLS10_MAC_SERVER, "CKM_TLS10_MAC_SERVER"); addMech(CKM_TLS10_MAC_CLIENT, R)883 addMech(CKM_TLS10_MAC_CLIENT, "CKM_TLS10_MAC_CLIENT"); addMech(CKM_TLS12_MAC, R)884 addMech(CKM_TLS12_MAC, "CKM_TLS12_MAC"); addMech(CKM_TLS12_KDF, R)885 addMech(CKM_TLS12_KDF, "CKM_TLS12_KDF"); addMech(CKM_TLS12_MASTER_KEY_DERIVE, R)886 addMech(CKM_TLS12_MASTER_KEY_DERIVE, "CKM_TLS12_MASTER_KEY_DERIVE"); addMech(CKM_TLS12_KEY_AND_MAC_DERIVE, R)887 addMech(CKM_TLS12_KEY_AND_MAC_DERIVE, "CKM_TLS12_KEY_AND_MAC_DERIVE"); addMech(CKM_TLS12_MASTER_KEY_DERIVE_DH, R)888 addMech(CKM_TLS12_MASTER_KEY_DERIVE_DH, "CKM_TLS12_MASTER_KEY_DERIVE_DH"); addMech(CKM_TLS12_KEY_SAFE_DERIVE, R)889 addMech(CKM_TLS12_KEY_SAFE_DERIVE, "CKM_TLS12_KEY_SAFE_DERIVE"); addMech(CKM_TLS_MAC, R)890 addMech(CKM_TLS_MAC, "CKM_TLS_MAC"); addMech(CKM_TLS_KDF, R)891 addMech(CKM_TLS_KDF, "CKM_TLS_KDF"); 892 addMech(CKM_KEY_WRAP_LYNKS, R)893 addMech(CKM_KEY_WRAP_LYNKS, "CKM_KEY_WRAP_LYNKS"); addMech(CKM_KEY_WRAP_SET_OAEP, R)894 addMech(CKM_KEY_WRAP_SET_OAEP, "CKM_KEY_WRAP_SET_OAEP"); 895 addMech(CKM_CMS_SIG, R)896 addMech(CKM_CMS_SIG, "CKM_CMS_SIG"); addMech(CKM_KIP_DERIVE, R)897 addMech(CKM_KIP_DERIVE, "CKM_KIP_DERIVE"); addMech(CKM_KIP_WRAP, R)898 addMech(CKM_KIP_WRAP, "CKM_KIP_WRAP"); addMech(CKM_KIP_MAC, R)899 addMech(CKM_KIP_MAC, "CKM_KIP_MAC"); addMech(CKM_CAMELLIA_KEY_GEN, R)900 addMech(CKM_CAMELLIA_KEY_GEN, "CKM_CAMELLIA_KEY_GEN"); addMech(CKM_CAMELLIA_ECB, R)901 addMech(CKM_CAMELLIA_ECB, "CKM_CAMELLIA_ECB"); addMech(CKM_CAMELLIA_CBC, R)902 addMech(CKM_CAMELLIA_CBC, "CKM_CAMELLIA_CBC"); addMech(CKM_CAMELLIA_MAC, R)903 addMech(CKM_CAMELLIA_MAC, "CKM_CAMELLIA_MAC"); addMech(CKM_CAMELLIA_MAC_GENERAL, R)904 addMech(CKM_CAMELLIA_MAC_GENERAL, "CKM_CAMELLIA_MAC_GENERAL"); addMech(CKM_CAMELLIA_CBC_PAD, R)905 addMech(CKM_CAMELLIA_CBC_PAD, "CKM_CAMELLIA_CBC_PAD"); addMech(CKM_CAMELLIA_ECB_ENCRYPT_DATA, R)906 addMech(CKM_CAMELLIA_ECB_ENCRYPT_DATA, "CKM_CAMELLIA_ECB_ENCRYPT_DATA"); addMech(CKM_CAMELLIA_CBC_ENCRYPT_DATA, R)907 addMech(CKM_CAMELLIA_CBC_ENCRYPT_DATA, "CKM_CAMELLIA_CBC_ENCRYPT_DATA"); addMech(CKM_CAMELLIA_CTR, R)908 addMech(CKM_CAMELLIA_CTR, "CKM_CAMELLIA_CTR"); 909 addMech(CKM_ARIA_KEY_GEN, R)910 addMech(CKM_ARIA_KEY_GEN, "CKM_ARIA_KEY_GEN"); addMech(CKM_ARIA_ECB, R)911 addMech(CKM_ARIA_ECB, "CKM_ARIA_ECB"); addMech(CKM_ARIA_CBC, R)912 addMech(CKM_ARIA_CBC, "CKM_ARIA_CBC"); addMech(CKM_ARIA_MAC, R)913 addMech(CKM_ARIA_MAC, "CKM_ARIA_MAC"); addMech(CKM_ARIA_MAC_GENERAL, R)914 addMech(CKM_ARIA_MAC_GENERAL, "CKM_ARIA_MAC_GENERAL"); addMech(CKM_ARIA_CBC_PAD, R)915 addMech(CKM_ARIA_CBC_PAD, "CKM_ARIA_CBC_PAD"); addMech(CKM_ARIA_ECB_ENCRYPT_DATA, R)916 addMech(CKM_ARIA_ECB_ENCRYPT_DATA, "CKM_ARIA_ECB_ENCRYPT_DATA"); addMech(CKM_ARIA_CBC_ENCRYPT_DATA, R)917 addMech(CKM_ARIA_CBC_ENCRYPT_DATA, "CKM_ARIA_CBC_ENCRYPT_DATA"); 918 addMech(CKM_SEED_KEY_GEN, R)919 addMech(CKM_SEED_KEY_GEN, "CKM_SEED_KEY_GEN"); addMech(CKM_SEED_ECB, R)920 addMech(CKM_SEED_ECB, "CKM_SEED_ECB"); addMech(CKM_SEED_CBC, R)921 addMech(CKM_SEED_CBC, "CKM_SEED_CBC"); addMech(CKM_SEED_MAC, R)922 addMech(CKM_SEED_MAC, "CKM_SEED_MAC"); addMech(CKM_SEED_MAC_GENERAL, R)923 addMech(CKM_SEED_MAC_GENERAL, "CKM_SEED_MAC_GENERAL"); addMech(CKM_SEED_CBC_PAD, R)924 addMech(CKM_SEED_CBC_PAD, "CKM_SEED_CBC_PAD"); addMech(CKM_SEED_ECB_ENCRYPT_DATA, R)925 addMech(CKM_SEED_ECB_ENCRYPT_DATA, "CKM_SEED_ECB_ENCRYPT_DATA"); addMech(CKM_SEED_CBC_ENCRYPT_DATA, R)926 addMech(CKM_SEED_CBC_ENCRYPT_DATA, "CKM_SEED_CBC_ENCRYPT_DATA"); 927 addMech(CKM_SKIPJACK_KEY_GEN, R)928 addMech(CKM_SKIPJACK_KEY_GEN, "CKM_SKIPJACK_KEY_GEN"); addMech(CKM_SKIPJACK_ECB64, R)929 addMech(CKM_SKIPJACK_ECB64, "CKM_SKIPJACK_ECB64"); addMech(CKM_SKIPJACK_CBC64, R)930 addMech(CKM_SKIPJACK_CBC64, "CKM_SKIPJACK_CBC64"); addMech(CKM_SKIPJACK_OFB64, R)931 addMech(CKM_SKIPJACK_OFB64, "CKM_SKIPJACK_OFB64"); addMech(CKM_SKIPJACK_CFB64, R)932