Back to index...

	/*
	* Copyright (c) 2003, 2019, Oracle and/or its affiliates. All rights reserved.
	*/

	/* Copyright (c) 2002 Graz University of Technology. All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are met:
	*
	* 1. Redistributions of source code must retain the above copyright notice,
	* this list of conditions and the following disclaimer.
	*
	* 2. Redistributions in binary form must reproduce the above copyright notice,
	* this list of conditions and the following disclaimer in the documentation
	* and/or other materials provided with the distribution.
	*
	* 3. The end-user documentation included with the redistribution, if any, must
	* include the following acknowledgment:
	*
	* "This product includes software developed by IAIK of Graz University of
	* Technology."
	*
	* Alternately, this acknowledgment may appear in the software itself, if
	* and wherever such third-party acknowledgments normally appear.
	*
	* 4. The names "Graz University of Technology" and "IAIK of Graz University of
	* Technology" must not be used to endorse or promote products derived from
	* this software without prior written permission.
	*
	* 5. Products derived from this software may not be called
	* "IAIK PKCS Wrapper", nor may "IAIK" appear in their name, without prior
	* written permission of Graz University of Technology.
	*
	* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED
	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
	* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE LICENSOR BE
	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
	* OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
	* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
	* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	* POSSIBILITY OF SUCH DAMAGE.
	*/

	package sun.security.pkcs11.wrapper;

	import java.math.BigInteger;

	import java.util.*;

	import static sun.security.pkcs11.wrapper.PKCS11Constants.*;

	/**
	* This class contains onyl static methods. It is the place for all functions
	* that are used by several classes in this package.
	*
	* @author Karl Scheibelhofer <Karl.Scheibelhofer@iaik.at>
	* @author Martin Schlaeffer <schlaeff@sbox.tugraz.at>
	*/
	public class Functions {

	// maps between ids and their names, forward and reverse
	// ids are stored as Integers to save space
	// since only the lower 32 bits are ever used anyway

	// mechanisms (CKM_*)
	private static final Map<Integer,String> mechNames =
	new HashMap<Integer,String>();

	private static final Map<String,Integer> mechIds =
	new HashMap<String,Integer>();

	private static final Map<String, Long> hashMechIds =
	new HashMap<String, Long>();

	// key types (CKK_*)
	private static final Map<Integer,String> keyNames =
	new HashMap<Integer,String>();

	private static final Map<String,Integer> keyIds =
	new HashMap<String,Integer>();

	// attributes (CKA_*)
	private static final Map<Integer,String> attributeNames =
	new HashMap<Integer,String>();

	private static final Map<String,Integer> attributeIds =
	new HashMap<String,Integer>();

	// object classes (CKO_*)
	private static final Map<Integer,String> objectClassNames =
	new HashMap<Integer,String>();

	private static final Map<String,Integer> objectClassIds =
	new HashMap<String,Integer>();

	// MGFs (CKG_*)
	private static final Map<Integer,String> mgfNames =
	new HashMap<Integer,String>();

	private static final Map<String,Integer> mgfIds =
	new HashMap<String,Integer>();

	/**
	* For converting numbers to their hex presentation.
	*/
	private static final char[] HEX_DIGITS = "0123456789ABCDEF".toCharArray();

	/**
	* Converts a long value to a hexadecimal String of length 16. Includes
	* leading zeros if necessary.
	*
	* @param value The long value to be converted.
	* @return The hexadecimal string representation of the long value.
	*/
	public static String toFullHexString(long value) {
	long currentValue = value;
	StringBuffer stringBuffer = new StringBuffer(16);
	for(int j = 0; j < 16; j++) {
	int currentDigit = (int) currentValue & 0xf;
	stringBuffer.append(HEX_DIGITS[currentDigit]);
	currentValue >>>= 4;
	}

	return stringBuffer.reverse().toString();
	}

	/**
	* Converts a int value to a hexadecimal String of length 8. Includes
	* leading zeros if necessary.
	*
	* @param value The int value to be converted.
	* @return The hexadecimal string representation of the int value.
	*/
	public static String toFullHexString(int value) {
	int currentValue = value;
	StringBuffer stringBuffer = new StringBuffer(8);
	for(int i = 0; i < 8; i++) {
	int currentDigit = currentValue & 0xf;
	stringBuffer.append(HEX_DIGITS[currentDigit]);
	currentValue >>>= 4;
	}

	return stringBuffer.reverse().toString();
	}

	/**
	* converts a long value to a hexadecimal String
	*
	* @param value the long value to be converted
	* @return the hexadecimal string representation of the long value
	*/
	public static String toHexString(long value) {
	return Long.toHexString(value);
	}

	/**
	* Converts a byte array to a hexadecimal String. Each byte is presented by
	* its two digit hex-code; 0x0A -> "0a", 0x00 -> "00". No leading "0x" is
	* included in the result.
	*
	* @param value the byte array to be converted
	* @return the hexadecimal string representation of the byte array
	*/
	public static String toHexString(byte[] value) {
	if (value == null) {
	return null;
	}

	StringBuffer buffer = new StringBuffer(2 * value.length);
	int single;

	for (int i = 0; i < value.length; i++) {
	single = value[i] & 0xFF;

	if (single < 0x10) {
	buffer.append('0');
	}

	buffer.append(Integer.toString(single, 16));
	}

	return buffer.toString();
	}

	/**
	* converts a long value to a binary String
	*
	* @param value the long value to be converted
	* @return the binary string representation of the long value
	*/
	public static String toBinaryString(long value) {
	return Long.toString(value, 2);
	}

	/**
	* converts a byte array to a binary String
	*
	* @param value the byte array to be converted
	* @return the binary string representation of the byte array
	*/
	public static String toBinaryString(byte[] value) {
	BigInteger helpBigInteger = new BigInteger(1, value);

	return helpBigInteger.toString(2);
	}

	private static class Flags {
	private final long[] flagIds;
	private final String[] flagNames;
	Flags(long[] flagIds, String[] flagNames) {
	if (flagIds.length != flagNames.length) {
	throw new AssertionError("Array lengths do not match");
	}
	this.flagIds = flagIds;
	this.flagNames = flagNames;
	}
	String toString(long val) {
	StringBuilder sb = new StringBuilder();
	boolean first = true;
	for (int i = 0; i < flagIds.length; i++) {
	if ((val & flagIds[i]) != 0) {
	if (first == false) {
	sb.append(" \| ");
	}
	sb.append(flagNames[i]);
	first = false;
	}
	}
	return sb.toString();
	}
	}

	private static final Flags slotInfoFlags = new Flags(new long[] {
	CKF_TOKEN_PRESENT,
	CKF_REMOVABLE_DEVICE,
	CKF_HW_SLOT,
	}, new String[] {
	"CKF_TOKEN_PRESENT",
	"CKF_REMOVABLE_DEVICE",
	"CKF_HW_SLOT",
	});

	/**
	* converts the long value flags to a SlotInfoFlag string
	*
	* @param flags the flags to be converted
	* @return the SlotInfoFlag string representation of the flags
	*/
	public static String slotInfoFlagsToString(long flags) {
	return slotInfoFlags.toString(flags);
	}

	private static final Flags tokenInfoFlags = new Flags(new long[] {
	CKF_RNG,
	CKF_WRITE_PROTECTED,
	CKF_LOGIN_REQUIRED,
	CKF_USER_PIN_INITIALIZED,
	CKF_RESTORE_KEY_NOT_NEEDED,
	CKF_CLOCK_ON_TOKEN,
	CKF_PROTECTED_AUTHENTICATION_PATH,
	CKF_DUAL_CRYPTO_OPERATIONS,
	CKF_TOKEN_INITIALIZED,
	CKF_SECONDARY_AUTHENTICATION,
	CKF_USER_PIN_COUNT_LOW,
	CKF_USER_PIN_FINAL_TRY,
	CKF_USER_PIN_LOCKED,
	CKF_USER_PIN_TO_BE_CHANGED,
	CKF_SO_PIN_COUNT_LOW,
	CKF_SO_PIN_FINAL_TRY,
	CKF_SO_PIN_LOCKED,
	CKF_SO_PIN_TO_BE_CHANGED,
	}, new String[] {
	"CKF_RNG",
	"CKF_WRITE_PROTECTED",
	"CKF_LOGIN_REQUIRED",
	"CKF_USER_PIN_INITIALIZED",
	"CKF_RESTORE_KEY_NOT_NEEDED",
	"CKF_CLOCK_ON_TOKEN",
	"CKF_PROTECTED_AUTHENTICATION_PATH",
	"CKF_DUAL_CRYPTO_OPERATIONS",
	"CKF_TOKEN_INITIALIZED",
	"CKF_SECONDARY_AUTHENTICATION",
	"CKF_USER_PIN_COUNT_LOW",
	"CKF_USER_PIN_FINAL_TRY",
	"CKF_USER_PIN_LOCKED",
	"CKF_USER_PIN_TO_BE_CHANGED",
	"CKF_SO_PIN_COUNT_LOW",
	"CKF_SO_PIN_FINAL_TRY",
	"CKF_SO_PIN_LOCKED",
	"CKF_SO_PIN_TO_BE_CHANGED",
	});

	/**
	* converts long value flags to a TokenInfoFlag string
	*
	* @param flags the flags to be converted
	* @return the TokenInfoFlag string representation of the flags
	*/
	public static String tokenInfoFlagsToString(long flags) {
	return tokenInfoFlags.toString(flags);
	}

	private static final Flags sessionInfoFlags = new Flags(new long[] {
	CKF_RW_SESSION,
	CKF_SERIAL_SESSION,
	}, new String[] {
	"CKF_RW_SESSION",
	"CKF_SERIAL_SESSION",
	});

	/**
	* converts the long value flags to a SessionInfoFlag string
	*
	* @param flags the flags to be converted
	* @return the SessionInfoFlag string representation of the flags
	*/
	public static String sessionInfoFlagsToString(long flags) {
	return sessionInfoFlags.toString(flags);
	}

	/**
	* converts the long value state to a SessionState string
	*
	* @param state the state to be converted
	* @return the SessionState string representation of the state
	*/
	public static String sessionStateToString(long state) {
	String name;

	if (state == CKS_RO_PUBLIC_SESSION) {
	name = "CKS_RO_PUBLIC_SESSION";
	} else if (state == CKS_RO_USER_FUNCTIONS) {
	name = "CKS_RO_USER_FUNCTIONS";
	} else if (state == CKS_RW_PUBLIC_SESSION) {
	name = "CKS_RW_PUBLIC_SESSION";
	} else if (state == CKS_RW_USER_FUNCTIONS) {
	name = "CKS_RW_USER_FUNCTIONS";
	} else if (state == CKS_RW_SO_FUNCTIONS) {
	name = "CKS_RW_SO_FUNCTIONS";
	} else {
	name = "ERROR: unknown session state 0x" + toFullHexString(state);
	}

	return name;
	}

	private static final Flags mechanismInfoFlags = new Flags(new long[] {
	CKF_HW,
	CKF_ENCRYPT,
	CKF_DECRYPT,
	CKF_DIGEST,
	CKF_SIGN,
	CKF_SIGN_RECOVER,
	CKF_VERIFY,
	CKF_VERIFY_RECOVER,
	CKF_GENERATE,
	CKF_GENERATE_KEY_PAIR,
	CKF_WRAP,
	CKF_UNWRAP,
	CKF_DERIVE,
	CKF_EC_F_P,
	CKF_EC_F_2M,
	CKF_EC_ECPARAMETERS,
	CKF_EC_NAMEDCURVE,
	CKF_EC_UNCOMPRESS,
	CKF_EC_COMPRESS,
	CKF_EXTENSION,
	}, new String[] {
	"CKF_HW",
	"CKF_ENCRYPT",
	"CKF_DECRYPT",
	"CKF_DIGEST",
	"CKF_SIGN",
	"CKF_SIGN_RECOVER",
	"CKF_VERIFY",
	"CKF_VERIFY_RECOVER",
	"CKF_GENERATE",
	"CKF_GENERATE_KEY_PAIR",
	"CKF_WRAP",
	"CKF_UNWRAP",
	"CKF_DERIVE",
	"CKF_EC_F_P",
	"CKF_EC_F_2M",
	"CKF_EC_ECPARAMETERS",
	"CKF_EC_NAMEDCURVE",
	"CKF_EC_UNCOMPRESS",
	"CKF_EC_COMPRESS",
	"CKF_EXTENSION",
	});

	/**
	* converts the long value flags to a MechanismInfoFlag string
	*
	* @param flags the flags to be converted
	* @return the MechanismInfoFlag string representation of the flags
	*/
	public static String mechanismInfoFlagsToString(long flags) {
	return mechanismInfoFlags.toString(flags);
	}

	private static String getName(Map<Integer,String> nameMap, long id) {
	String name = null;
	if ((id >>> 32) == 0) {
	name = nameMap.get(Integer.valueOf((int)id));
	}
	if (name == null) {
	if ((id & CKM_VENDOR_DEFINED) != 0) {
	name = "(Vendor-Specific) 0x" + toFullHexString(id);
	} else {
	name = "(Unknown) 0x" + toFullHexString(id);
	}
	}
	return name;
	}

	public static long getId(Map<String,Integer> idMap, String name) {
	Integer mech = idMap.get(name);
	if (mech == null) {
	throw new IllegalArgumentException("Unknown name " + name);
	}
	return mech.intValue() & 0xffffffffL;
	}

	public static String getMechanismName(long id) {
	return getName(mechNames, id);
	}

	public static long getMechanismId(String name) {
	return getId(mechIds, name);
	}

	public static String getKeyName(long id) {
	return getName(keyNames, id);
	}

	public static long getKeyId(String name) {
	return getId(keyIds, name);
	}

	public static String getAttributeName(long id) {
	return getName(attributeNames, id);
	}

	public static long getAttributeId(String name) {
	return getId(attributeIds, name);
	}

	public static String getObjectClassName(long id) {
	return getName(objectClassNames, id);
	}

	public static long getObjectClassId(String name) {
	return getId(objectClassIds, name);
	}

	public static long getHashMechId(String name) {
	return hashMechIds.get(name);
	}

	public static String getMGFName(long id) {
	return getName(mgfNames, id);
	}

	public static long getMGFId(String name) {
	return getId(mgfIds, name);
	}

	/**
	* Check the given arrays for equalitiy. This method considers both arrays as
	* equal, if both are <code>null</code> or both have the same length and
	* contain exactly the same char values.
	*
	* @param array1 The first array.
	* @param array2 The second array.
	* @return True, if both arrays are <code>null</code> or both have the same
	* length and contain exactly the same char values. False, otherwise.
	* @preconditions
	* @postconditions
	*/
	private static boolean equals(char[] array1, char[] array2) {
	return Arrays.equals(array1, array2);
	}

	/**
	* Check the given dates for equalitiy. This method considers both dates as
	* equal, if both are <code>null</code> or both contain exactly the same char
	* values.
	*
	* @param date1 The first date.
	* @param date2 The second date.
	* @return True, if both dates are <code>null</code> or both contain the same
	* char values. False, otherwise.
	* @preconditions
	* @postconditions
	*/
	public static boolean equals(CK_DATE date1, CK_DATE date2) {
	boolean equal = false;

	if (date1 == date2) {
	equal = true;
	} else if ((date1 != null) && (date2 != null)) {
	equal = equals(date1.year, date2.year)
	&& equals(date1.month, date2.month)
	&& equals(date1.day, date2.day);
	} else {
	equal = false;
	}

	return equal ;
	}

	/**
	* Calculate a hash code for the given byte array.
	*
	* @param array The byte array.
	* @return A hash code for the given array.
	* @preconditions
	* @postconditions
	*/
	public static int hashCode(byte[] array) {
	int hash = 0;

	if (array != null) {
	for (int i = 0; (i < 4) && (i < array.length); i++) {
	hash ^= (0xFF & array[i]) << ((i%4) << 3);
	}
	}

	return hash ;
	}

	/**
	* Calculate a hash code for the given char array.
	*
	* @param array The char array.
	* @return A hash code for the given array.
	* @preconditions
	* @postconditions
	*/
	public static int hashCode(char[] array) {
	int hash = 0;

	if (array != null) {
	for (int i = 0; (i < 4) && (i < array.length); i++) {
	hash ^= (0xFFFF & array[i]) << ((i%2) << 4);
	}
	}

	return hash ;
	}

	/**
	* Calculate a hash code for the given date object.
	*
	* @param date The date object.
	* @return A hash code for the given date.
	* @preconditions
	* @postconditions
	*/
	public static int hashCode(CK_DATE date) {
	int hash = 0;

	if (date != null) {
	if (date.year.length == 4) {
	hash ^= (0xFFFF & date.year[0]) << 16;
	hash ^= 0xFFFF & date.year[1];
	hash ^= (0xFFFF & date.year[2]) << 16;
	hash ^= 0xFFFF & date.year[3];
	}
	if (date.month.length == 2) {
	hash ^= (0xFFFF & date.month[0]) << 16;
	hash ^= 0xFFFF & date.month[1];
	}
	if (date.day.length == 2) {
	hash ^= (0xFFFF & date.day[0]) << 16;
	hash ^= 0xFFFF & date.day[1];
	}
	}

	return hash ;
	}

	private static void addMapping(Map<Integer,String> nameMap,
	Map<String,Integer> idMap, long id, String name) {
	if ((id >>> 32) != 0) {
	throw new AssertionError("Id has high bits set: " + id + ", " + name);
	}
	Integer intId = Integer.valueOf((int)id);
	if (nameMap.put(intId, name) != null) {
	throw new AssertionError("Duplicate id: " + id + ", " + name);
	}
	if (idMap.put(name, intId) != null) {
	throw new AssertionError("Duplicate name: " + id + ", " + name);
	}
	}

	private static void addMech(long id, String name) {
	addMapping(mechNames, mechIds, id, name);
	}

	private static void addKeyType(long id, String name) {
	addMapping(keyNames, keyIds, id, name);
	}

	private static void addAttribute(long id, String name) {
	addMapping(attributeNames, attributeIds, id, name);
	}

	private static void addObjectClass(long id, String name) {
	addMapping(objectClassNames, objectClassIds, id, name);
	}

	private static void addHashMech(long id, String... names) {
	for (String n : names) {
	hashMechIds.put(n, id);
	}
	}

	private static void addMGF(long id, String name) {
	addMapping(mgfNames, mgfIds, id, name);
	}

	static {
	addMech(CKM_RSA_PKCS_KEY_PAIR_GEN, "CKM_RSA_PKCS_KEY_PAIR_GEN");
	addMech(CKM_RSA_PKCS, "CKM_RSA_PKCS");
	addMech(CKM_RSA_9796, "CKM_RSA_9796");
	addMech(CKM_RSA_X_509, "CKM_RSA_X_509");
	addMech(CKM_MD2_RSA_PKCS, "CKM_MD2_RSA_PKCS");
	addMech(CKM_MD5_RSA_PKCS, "CKM_MD5_RSA_PKCS");
	addMech(CKM_SHA1_RSA_PKCS, "CKM_SHA1_RSA_PKCS");
	addMech(CKM_RIPEMD128_RSA_PKCS, "CKM_RIPEMD128_RSA_PKCS");
	addMech(CKM_RIPEMD160_RSA_PKCS, "CKM_RIPEMD160_RSA_PKCS");
	addMech(CKM_RSA_PKCS_OAEP, "CKM_RSA_PKCS_OAEP");
	addMech(CKM_RSA_X9_31_KEY_PAIR_GEN, "CKM_RSA_X9_31_KEY_PAIR_GEN");
	addMech(CKM_RSA_X9_31, "CKM_RSA_X9_31");
	addMech(CKM_SHA1_RSA_X9_31, "CKM_SHA1_RSA_X9_31");
	addMech(CKM_RSA_PKCS_PSS, "CKM_RSA_PKCS_PSS");
	addMech(CKM_SHA1_RSA_PKCS_PSS, "CKM_SHA1_RSA_PKCS_PSS");
	addMech(CKM_DSA_KEY_PAIR_GEN, "CKM_DSA_KEY_PAIR_GEN");
	addMech(CKM_DSA, "CKM_DSA");
	addMech(CKM_DSA_SHA1, "CKM_DSA_SHA1");
	addMech(CKM_DSA_SHA224, "CKM_DSA_SHA224");
	addMech(CKM_DSA_SHA256, "CKM_DSA_SHA256");
	addMech(CKM_DSA_SHA384, "CKM_DSA_SHA384");
	addMech(CKM_DSA_SHA512, "CKM_DSA_SHA512");

	addMech(CKM_DH_PKCS_KEY_PAIR_GEN, "CKM_DH_PKCS_KEY_PAIR_GEN");
	addMech(CKM_DH_PKCS_DERIVE, "CKM_DH_PKCS_DERIVE");
	addMech(CKM_X9_42_DH_KEY_PAIR_GEN, "CKM_X9_42_DH_KEY_PAIR_GEN");
	addMech(CKM_X9_42_DH_DERIVE, "CKM_X9_42_DH_DERIVE");
	addMech(CKM_X9_42_DH_HYBRID_DERIVE, "CKM_X9_42_DH_HYBRID_DERIVE");
	addMech(CKM_X9_42_MQV_DERIVE, "CKM_X9_42_MQV_DERIVE");

	addMech(CKM_SHA256_RSA_PKCS, "CKM_SHA256_RSA_PKCS");
	addMech(CKM_SHA384_RSA_PKCS, "CKM_SHA384_RSA_PKCS");
	addMech(CKM_SHA512_RSA_PKCS, "CKM_SHA512_RSA_PKCS");
	addMech(CKM_SHA256_RSA_PKCS_PSS, "CKM_SHA256_RSA_PKCS_PSS");
	addMech(CKM_SHA384_RSA_PKCS_PSS, "CKM_SHA384_RSA_PKCS_PSS");
	addMech(CKM_SHA512_RSA_PKCS_PSS, "CKM_SHA512_RSA_PKCS_PSS");
	addMech(CKM_SHA224_RSA_PKCS, "CKM_SHA224_RSA_PKCS");
	addMech(CKM_SHA224_RSA_PKCS_PSS, "CKM_SHA224_RSA_PKCS_PSS");

	addMech(CKM_RC2_KEY_GEN, "CKM_RC2_KEY_GEN");
	addMech(CKM_RC2_ECB, "CKM_RC2_ECB");
	addMech(CKM_RC2_CBC, "CKM_RC2_CBC");
	addMech(CKM_RC2_MAC, "CKM_RC2_MAC");
	addMech(CKM_RC2_MAC_GENERAL, "CKM_RC2_MAC_GENERAL");
	addMech(CKM_RC2_CBC_PAD, "CKM_RC2_CBC_PAD");
	addMech(CKM_RC4_KEY_GEN, "CKM_RC4_KEY_GEN");
	addMech(CKM_RC4, "CKM_RC4");
	addMech(CKM_DES_KEY_GEN, "CKM_DES_KEY_GEN");
	addMech(CKM_DES_ECB, "CKM_DES_ECB");
	addMech(CKM_DES_CBC, "CKM_DES_CBC");
	addMech(CKM_DES_MAC, "CKM_DES_MAC");
	addMech(CKM_DES_MAC_GENERAL, "CKM_DES_MAC_GENERAL");
	addMech(CKM_DES_CBC_PAD, "CKM_DES_CBC_PAD");
	addMech(CKM_DES2_KEY_GEN, "CKM_DES2_KEY_GEN");
	addMech(CKM_DES3_KEY_GEN, "CKM_DES3_KEY_GEN");
	addMech(CKM_DES3_ECB, "CKM_DES3_ECB");
	addMech(CKM_DES3_CBC, "CKM_DES3_CBC");
	addMech(CKM_DES3_MAC, "CKM_DES3_MAC");
	addMech(CKM_DES3_MAC_GENERAL, "CKM_DES3_MAC_GENERAL");
	addMech(CKM_DES3_CBC_PAD, "CKM_DES3_CBC_PAD");
	addMech(CKM_DES3_CMAC_GENERAL, "CKM_DES3_CMAC_GENERAL");
	addMech(CKM_DES3_CMAC, "CKM_DES3_CMAC");

	addMech(CKM_CDMF_KEY_GEN, "CKM_CDMF_KEY_GEN");
	addMech(CKM_CDMF_ECB, "CKM_CDMF_ECB");
	addMech(CKM_CDMF_CBC, "CKM_CDMF_CBC");
	addMech(CKM_CDMF_MAC, "CKM_CDMF_MAC");
	addMech(CKM_CDMF_MAC_GENERAL, "CKM_CDMF_MAC_GENERAL");
	addMech(CKM_CDMF_CBC_PAD, "CKM_CDMF_CBC_PAD");

	addMech(CKM_DES_OFB64, "CKM_DES_OFB64");
	addMech(CKM_DES_OFB8, "CKM_DES_OFB8");
	addMech(CKM_DES_CFB64, "CKM_DES_CFB64");
	addMech(CKM_DES_CFB8, "CKM_DES_CFB8");

	addMech(CKM_MD2, "CKM_MD2");
	addMech(CKM_MD2_HMAC, "CKM_MD2_HMAC");
	addMech(CKM_MD2_HMAC_GENERAL, "CKM_MD2_HMAC_GENERAL");
	addMech(CKM_MD5, "CKM_MD5");
	addMech(CKM_MD5_HMAC, "CKM_MD5_HMAC");
	addMech(CKM_MD5_HMAC_GENERAL, "CKM_MD5_HMAC_GENERAL");
	addMech(CKM_SHA_1, "CKM_SHA_1");
	addMech(CKM_SHA_1_HMAC, "CKM_SHA_1_HMAC");
	addMech(CKM_SHA_1_HMAC_GENERAL, "CKM_SHA_1_HMAC_GENERAL");
	addMech(CKM_RIPEMD128, "CKM_RIPEMD128");
	addMech(CKM_RIPEMD128_HMAC, "CKM_RIPEMD128_HMAC");
	addMech(CKM_RIPEMD128_HMAC_GENERAL, "CKM_RIPEMD128_HMAC_GENERAL");
	addMech(CKM_RIPEMD160, "CKM_RIPEMD160");
	addMech(CKM_RIPEMD160_HMAC, "CKM_RIPEMD160_HMAC");
	addMech(CKM_RIPEMD160_HMAC_GENERAL, "CKM_RIPEMD160_HMAC_GENERAL");
	addMech(CKM_SHA224, "CKM_SHA224");
	addMech(CKM_SHA224_HMAC, "CKM_SHA224_HMAC");
	addMech(CKM_SHA224_HMAC_GENERAL, "CKM_SHA224_HMAC_GENERAL");
	addMech(CKM_SHA256, "CKM_SHA256");
	addMech(CKM_SHA256_HMAC, "CKM_SHA256_HMAC");
	addMech(CKM_SHA256_HMAC_GENERAL, "CKM_SHA256_HMAC_GENERAL");
	addMech(CKM_SHA384, "CKM_SHA384");
	addMech(CKM_SHA384_HMAC, "CKM_SHA384_HMAC");
	addMech(CKM_SHA384_HMAC_GENERAL, "CKM_SHA384_HMAC_GENERAL");
	addMech(CKM_SHA512, "CKM_SHA512");
	addMech(CKM_SHA512_HMAC, "CKM_SHA512_HMAC");
	addMech(CKM_SHA512_HMAC_GENERAL, "CKM_SHA512_HMAC_GENERAL");
	addMech(CKM_SHA512_224, "CKM_SHA512_224");
	addMech(CKM_SHA512_224_HMAC, "CKM_SHA512_224_HMAC");
	addMech(CKM_SHA512_224_HMAC_GENERAL, "CKM_SHA512_224_HMAC_GENERAL");
	addMech(CKM_SHA512_224_KEY_DERIVATION, "CKM_SHA512_224_KEY_DERIVATION");
	addMech(CKM_SHA512_256, "CKM_SHA512_256");
	addMech(CKM_SHA512_256_HMAC, "CKM_SHA512_256_HMAC");
	addMech(CKM_SHA512_256_HMAC_GENERAL, "CKM_SHA512_256_HMAC_GENERAL");
	addMech(CKM_SHA512_256_KEY_DERIVATION, "CKM_SHA512_256_KEY_DERIVATION");
	addMech(CKM_SHA512_T, "CKM_SHA512_T");
	addMech(CKM_SHA512_T_HMAC, "CKM_SHA512_T_HMAC");
	addMech(CKM_SHA512_T_HMAC_GENERAL, "CKM_SHA512_T_HMAC_GENERAL");
	addMech(CKM_SHA512_T_KEY_DERIVATION, "CKM_SHA512_T_KEY_DERIVATION");

	addMech(CKM_SECURID_KEY_GEN, "CKM_SECURID_KEY_GEN");
	addMech(CKM_SECURID, "CKM_SECURID");
	addMech(CKM_HOTP_KEY_GEN, "CKM_HOTP_KEY_GEN");
	addMech(CKM_HOTP, "CKM_HOTP");
	addMech(CKM_ACTI, "CKM_ACTI");
	addMech(CKM_ACTI_KEY_GEN, "CKM_ACTI_KEY_GEN");

	addMech(CKM_CAST_KEY_GEN, "CKM_CAST_KEY_GEN");
	addMech(CKM_CAST_ECB, "CKM_CAST_ECB");
	addMech(CKM_CAST_CBC, "CKM_CAST_CBC");
	addMech(CKM_CAST_MAC, "CKM_CAST_MAC");
	addMech(CKM_CAST_MAC_GENERAL, "CKM_CAST_MAC_GENERAL");
	addMech(CKM_CAST_CBC_PAD, "CKM_CAST_CBC_PAD");
	addMech(CKM_CAST3_KEY_GEN, "CKM_CAST3_KEY_GEN");
	addMech(CKM_CAST3_ECB, "CKM_CAST3_ECB");
	addMech(CKM_CAST3_CBC, "CKM_CAST3_CBC");
	addMech(CKM_CAST3_MAC, "CKM_CAST3_MAC");
	addMech(CKM_CAST3_MAC_GENERAL, "CKM_CAST3_MAC_GENERAL");
	addMech(CKM_CAST3_CBC_PAD, "CKM_CAST3_CBC_PAD");
	addMech(CKM_CAST128_KEY_GEN, "CKM_CAST128_KEY_GEN");
	addMech(CKM_CAST128_ECB, "CKM_CAST128_ECB");
	addMech(CKM_CAST128_CBC, "CKM_CAST128_CBC");
	addMech(CKM_CAST128_MAC, "CKM_CAST128_MAC");
	addMech(CKM_CAST128_MAC_GENERAL, "CKM_CAST128_MAC_GENERAL");
	addMech(CKM_CAST128_CBC_PAD, "CKM_CAST128_CBC_PAD");
	addMech(CKM_RC5_KEY_GEN, "CKM_RC5_KEY_GEN");
	addMech(CKM_RC5_ECB, "CKM_RC5_ECB");
	addMech(CKM_RC5_CBC, "CKM_RC5_CBC");
	addMech(CKM_RC5_MAC, "CKM_RC5_MAC");
	addMech(CKM_RC5_MAC_GENERAL, "CKM_RC5_MAC_GENERAL");
	addMech(CKM_RC5_CBC_PAD, "CKM_RC5_CBC_PAD");
	addMech(CKM_IDEA_KEY_GEN, "CKM_IDEA_KEY_GEN");
	addMech(CKM_IDEA_ECB, "CKM_IDEA_ECB");
	addMech(CKM_IDEA_CBC, "CKM_IDEA_CBC");
	addMech(CKM_IDEA_MAC, "CKM_IDEA_MAC");
	addMech(CKM_IDEA_MAC_GENERAL, "CKM_IDEA_MAC_GENERAL");
	addMech(CKM_IDEA_CBC_PAD, "CKM_IDEA_CBC_PAD");
	addMech(CKM_GENERIC_SECRET_KEY_GEN, "CKM_GENERIC_SECRET_KEY_GEN");
	addMech(CKM_CONCATENATE_BASE_AND_KEY, "CKM_CONCATENATE_BASE_AND_KEY");
	addMech(CKM_CONCATENATE_BASE_AND_DATA, "CKM_CONCATENATE_BASE_AND_DATA");
	addMech(CKM_CONCATENATE_DATA_AND_BASE, "CKM_CONCATENATE_DATA_AND_BASE");
	addMech(CKM_XOR_BASE_AND_DATA, "CKM_XOR_BASE_AND_DATA");
	addMech(CKM_EXTRACT_KEY_FROM_KEY, "CKM_EXTRACT_KEY_FROM_KEY");
	addMech(CKM_SSL3_PRE_MASTER_KEY_GEN, "CKM_SSL3_PRE_MASTER_KEY_GEN");
	addMech(CKM_SSL3_MASTER_KEY_DERIVE, "CKM_SSL3_MASTER_KEY_DERIVE");
	addMech(CKM_SSL3_KEY_AND_MAC_DERIVE, "CKM_SSL3_KEY_AND_MAC_DERIVE");
	addMech(CKM_SSL3_MASTER_KEY_DERIVE_DH, "CKM_SSL3_MASTER_KEY_DERIVE_DH");
	addMech(CKM_TLS_PRE_MASTER_KEY_GEN, "CKM_TLS_PRE_MASTER_KEY_GEN");
	addMech(CKM_TLS_MASTER_KEY_DERIVE, "CKM_TLS_MASTER_KEY_DERIVE");
	addMech(CKM_TLS_KEY_AND_MAC_DERIVE, "CKM_TLS_KEY_AND_MAC_DERIVE");
	addMech(CKM_TLS_MASTER_KEY_DERIVE_DH, "CKM_TLS_MASTER_KEY_DERIVE_DH");
	addMech(CKM_TLS_PRF, "CKM_TLS_PRF");
	addMech(CKM_SSL3_MD5_MAC, "CKM_SSL3_MD5_MAC");
	addMech(CKM_SSL3_SHA1_MAC, "CKM_SSL3_SHA1_MAC");

	addMech(CKM_MD5_KEY_DERIVATION, "CKM_MD5_KEY_DERIVATION");
	addMech(CKM_MD2_KEY_DERIVATION, "CKM_MD2_KEY_DERIVATION");
	addMech(CKM_SHA1_KEY_DERIVATION, "CKM_SHA1_KEY_DERIVATION");
	addMech(CKM_SHA224_KEY_DERIVATION, "CKM_SHA224_KEY_DERIVATION");
	addMech(CKM_SHA256_KEY_DERIVATION, "CKM_SHA256_KEY_DERIVATION");
	addMech(CKM_SHA384_KEY_DERIVATION, "CKM_SHA384_KEY_DERIVATION");
	addMech(CKM_SHA512_KEY_DERIVATION, "CKM_SHA512_KEY_DERIVATION");
	addMech(CKM_PBE_MD2_DES_CBC, "CKM_PBE_MD2_DES_CBC");
	addMech(CKM_PBE_MD5_DES_CBC, "CKM_PBE_MD5_DES_CBC");
	addMech(CKM_PBE_MD5_CAST_CBC, "CKM_PBE_MD5_CAST_CBC");
	addMech(CKM_PBE_MD5_CAST3_CBC, "CKM_PBE_MD5_CAST3_CBC");
	addMech(CKM_PBE_MD5_CAST128_CBC, "CKM_PBE_MD5_CAST128_CBC");
	addMech(CKM_PBE_SHA1_CAST128_CBC, "CKM_PBE_SHA1_CAST128_CBC");
	addMech(CKM_PBE_SHA1_RC4_128, "CKM_PBE_SHA1_RC4_128");
	addMech(CKM_PBE_SHA1_RC4_40, "CKM_PBE_SHA1_RC4_40");
	addMech(CKM_PBE_SHA1_DES3_EDE_CBC, "CKM_PBE_SHA1_DES3_EDE_CBC");
	addMech(CKM_PBE_SHA1_DES2_EDE_CBC, "CKM_PBE_SHA1_DES2_EDE_CBC");
	addMech(CKM_PBE_SHA1_RC2_128_CBC, "CKM_PBE_SHA1_RC2_128_CBC");
	addMech(CKM_PBE_SHA1_RC2_40_CBC, "CKM_PBE_SHA1_RC2_40_CBC");
	addMech(CKM_PKCS5_PBKD2, "CKM_PKCS5_PBKD2");
	addMech(CKM_PBA_SHA1_WITH_SHA1_HMAC, "CKM_PBA_SHA1_WITH_SHA1_HMAC");

	addMech(CKM_WTLS_PRE_MASTER_KEY_GEN, "CKM_WTLS_PRE_MASTER_KEY_GEN");
	addMech(CKM_WTLS_MASTER_KEY_DERIVE, "CKM_WTLS_MASTER_KEY_DERIVE");
	addMech(CKM_WTLS_MASTER_KEY_DERIVE_DH_ECC,
	"CKM_WTLS_MASTER_KEY_DERIVE_DH_ECC");
	addMech(CKM_WTLS_PRF, "CKM_WTLS_PRF");
	addMech(CKM_WTLS_SERVER_KEY_AND_MAC_DERIVE,
	"CKM_WTLS_SERVER_KEY_AND_MAC_DERIVE");
	addMech(CKM_WTLS_CLIENT_KEY_AND_MAC_DERIVE,
	"CKM_WTLS_CLIENT_KEY_AND_MAC_DERIVE");
	addMech(CKM_TLS10_MAC_SERVER, "CKM_TLS10_MAC_SERVER");
	addMech(CKM_TLS10_MAC_CLIENT, "CKM_TLS10_MAC_CLIENT");
	addMech(CKM_TLS12_MAC, "CKM_TLS12_MAC");
	addMech(CKM_TLS12_KDF, "CKM_TLS12_KDF");
	addMech(CKM_TLS12_MASTER_KEY_DERIVE, "CKM_TLS12_MASTER_KEY_DERIVE");
	addMech(CKM_TLS12_KEY_AND_MAC_DERIVE, "CKM_TLS12_KEY_AND_MAC_DERIVE");
	addMech(CKM_TLS12_MASTER_KEY_DERIVE_DH, "CKM_TLS12_MASTER_KEY_DERIVE_DH");
	addMech(CKM_TLS12_KEY_SAFE_DERIVE, "CKM_TLS12_KEY_SAFE_DERIVE");
	addMech(CKM_TLS_MAC, "CKM_TLS_MAC");
	addMech(CKM_TLS_KDF, "CKM_TLS_KDF");

	addMech(CKM_KEY_WRAP_LYNKS, "CKM_KEY_WRAP_LYNKS");
	addMech(CKM_KEY_WRAP_SET_OAEP, "CKM_KEY_WRAP_SET_OAEP");

	addMech(CKM_CMS_SIG, "CKM_CMS_SIG");
	addMech(CKM_KIP_DERIVE, "CKM_KIP_DERIVE");
	addMech(CKM_KIP_WRAP, "CKM_KIP_WRAP");
	addMech(CKM_KIP_MAC, "CKM_KIP_MAC");
	addMech(CKM_CAMELLIA_KEY_GEN, "CKM_CAMELLIA_KEY_GEN");
	addMech(CKM_CAMELLIA_ECB, "CKM_CAMELLIA_ECB");
	addMech(CKM_CAMELLIA_CBC, "CKM_CAMELLIA_CBC");
	addMech(CKM_CAMELLIA_MAC, "CKM_CAMELLIA_MAC");
	addMech(CKM_CAMELLIA_MAC_GENERAL, "CKM_CAMELLIA_MAC_GENERAL");
	addMech(CKM_CAMELLIA_CBC_PAD, "CKM_CAMELLIA_CBC_PAD");
	addMech(CKM_CAMELLIA_ECB_ENCRYPT_DATA, "CKM_CAMELLIA_ECB_ENCRYPT_DATA");
	addMech(CKM_CAMELLIA_CBC_ENCRYPT_DATA, "CKM_CAMELLIA_CBC_ENCRYPT_DATA");
	addMech(CKM_CAMELLIA_CTR, "CKM_CAMELLIA_CTR");

	addMech(CKM_ARIA_KEY_GEN, "CKM_ARIA_KEY_GEN");
	addMech(CKM_ARIA_ECB, "CKM_ARIA_ECB");
	addMech(CKM_ARIA_CBC, "CKM_ARIA_CBC");
	addMech(CKM_ARIA_MAC, "CKM_ARIA_MAC");
	addMech(CKM_ARIA_MAC_GENERAL, "CKM_ARIA_MAC_GENERAL");
	addMech(CKM_ARIA_CBC_PAD, "CKM_ARIA_CBC_PAD");
	addMech(CKM_ARIA_ECB_ENCRYPT_DATA, "CKM_ARIA_ECB_ENCRYPT_DATA");
	addMech(CKM_ARIA_CBC_ENCRYPT_DATA, "CKM_ARIA_CBC_ENCRYPT_DATA");

	addMech(CKM_SEED_KEY_GEN, "CKM_SEED_KEY_GEN");
	addMech(CKM_SEED_ECB, "CKM_SEED_ECB");
	addMech(CKM_SEED_CBC, "CKM_SEED_CBC");
	addMech(CKM_SEED_MAC, "CKM_SEED_MAC");
	addMech(CKM_SEED_MAC_GENERAL, "CKM_SEED_MAC_GENERAL");
	addMech(CKM_SEED_CBC_PAD, "CKM_SEED_CBC_PAD");
	addMech(CKM_SEED_ECB_ENCRYPT_DATA, "CKM_SEED_ECB_ENCRYPT_DATA");
	addMech(CKM_SEED_CBC_ENCRYPT_DATA, "CKM_SEED_CBC_ENCRYPT_DATA");

	addMech(CKM_SKIPJACK_KEY_GEN, "CKM_SKIPJACK_KEY_GEN");
	addMech(CKM_SKIPJACK_ECB64, "CKM_SKIPJACK_ECB64");
	addMech(CKM_SKIPJACK_CBC64, "CKM_SKIPJACK_CBC64");
	addMech(CKM_SKIPJACK_OFB64, "CKM_SKIPJACK_OFB64");
	addMech(CKM_SKIPJACK_CFB64, "CKM_SKIPJACK_CFB64");
	addMech(CKM_SKIPJACK_CFB32, "CKM_SKIPJACK_CFB32");
	addMech(CKM_SKIPJACK_CFB16, "CKM_SKIPJACK_CFB16");
	addMech(CKM_SKIPJACK_CFB8, "CKM_SKIPJACK_CFB8");
	addMech(CKM_SKIPJACK_WRAP, "CKM_SKIPJACK_WRAP");
	addMech(CKM_SKIPJACK_PRIVATE_WRAP, "CKM_SKIPJACK_PRIVATE_WRAP");
	addMech(CKM_SKIPJACK_RELAYX, "CKM_SKIPJACK_RELAYX");
	addMech(CKM_KEA_KEY_PAIR_GEN, "CKM_KEA_KEY_PAIR_GEN");
	addMech(CKM_KEA_KEY_DERIVE, "CKM_KEA_KEY_DERIVE");
	addMech(CKM_FORTEZZA_TIMESTAMP, "CKM_FORTEZZA_TIMESTAMP");
	addMech(CKM_BATON_KEY_GEN, "CKM_BATON_KEY_GEN");
	addMech(CKM_BATON_ECB128, "CKM_BATON_ECB128");
	addMech(CKM_BATON_ECB96, "CKM_BATON_ECB96");
	addMech(CKM_BATON_CBC128, "CKM_BATON_CBC128");
	addMech(CKM_BATON_COUNTER, "CKM_BATON_COUNTER");
	addMech(CKM_BATON_SHUFFLE, "CKM_BATON_SHUFFLE");
	addMech(CKM_BATON_WRAP, "CKM_BATON_WRAP");
	addMech(CKM_EC_KEY_PAIR_GEN, "CKM_EC_KEY_PAIR_GEN");
	addMech(CKM_ECDSA, "CKM_ECDSA");
	addMech(CKM_ECDSA_SHA1, "CKM_ECDSA_SHA1");
	addMech(CKM_ECDSA_SHA224, "CKM_ECDSA_SHA224");
	addMech(CKM_ECDSA_SHA256, "CKM_ECDSA_SHA256");
	addMech(CKM_ECDSA_SHA384, "CKM_ECDSA_SHA384");
	addMech(CKM_ECDSA_SHA512, "CKM_ECDSA_SHA512");

	addMech(CKM_ECDH1_DERIVE, "CKM_ECDH1_DERIVE");
	addMech(CKM_ECDH1_COFACTOR_DERIVE, "CKM_ECDH1_COFACTOR_DERIVE");
	addMech(CKM_ECMQV_DERIVE, "CKM_ECMQV_DERIVE");
	addMech(CKM_ECDH_AES_KEY_WRAP, "CKM_ECDH_AES_KEY_WRAP");
	addMech(CKM_RSA_AES_KEY_WRAP, "CKM_RSA_AES_KEY_WRAP");

	addMech(CKM_JUNIPER_KEY_GEN, "CKM_JUNIPER_KEY_GEN");
	addMech(CKM_JUNIPER_ECB128, "CKM_JUNIPER_ECB128");
	addMech(CKM_JUNIPER_CBC128, "CKM_JUNIPER_CBC128");
	addMech(CKM_JUNIPER_COUNTER, "CKM_JUNIPER_COUNTER");
	addMech(CKM_JUNIPER_SHUFFLE, "CKM_JUNIPER_SHUFFLE");
	addMech(CKM_JUNIPER_WRAP, "CKM_JUNIPER_WRAP");
	addMech(CKM_FASTHASH, "CKM_FASTHASH");
	addMech(CKM_AES_KEY_GEN, "CKM_AES_KEY_GEN");
	addMech(CKM_AES_ECB, "CKM_AES_ECB");
	addMech(CKM_AES_CBC, "CKM_AES_CBC");
	addMech(CKM_AES_MAC, "CKM_AES_MAC");
	addMech(CKM_AES_MAC_GENERAL, "CKM_AES_MAC_GENERAL");
	addMech(CKM_AES_CBC_PAD, "CKM_AES_CBC_PAD");
	addMech(CKM_AES_CTR, "CKM_AES_CTR");
	addMech(CKM_AES_GCM, "CKM_AES_GCM");
	addMech(CKM_AES_CCM, "CKM_AES_CCM");
	addMech(CKM_AES_CTS, "CKM_AES_CTS");
	addMech(CKM_AES_CMAC, "CKM_AES_CMAC");
	addMech(CKM_AES_CMAC_GENERAL, "CKM_AES_CMAC_GENERAL");
	addMech(CKM_AES_XCBC_MAC, "CKM_AES_XCBC_MAC");
	addMech(CKM_AES_XCBC_MAC_96, "CKM_AES_XCBC_MAC_96");
	addMech(CKM_AES_GMAC, "CKM_AES_GMAC");

	addMech(CKM_BLOWFISH_KEY_GEN, "CKM_BLOWFISH_KEY_GEN");
	addMech(CKM_BLOWFISH_CBC, "CKM_BLOWFISH_CBC");
	addMech(CKM_TWOFISH_KEY_GEN, "CKM_TWOFISH_KEY_GEN");
	addMech(CKM_TWOFISH_CBC, "CKM_TWOFISH_CBC");
	addMech(CKM_BLOWFISH_CBC_PAD, "CKM_BLOWFISH_CBC_PAD");
	addMech(CKM_TWOFISH_CBC_PAD, "CKM_TWOFISH_CBC_PAD");

	addMech(CKM_DES_ECB_ENCRYPT_DATA, "CKM_DES_ECB_ENCRYPT_DATA");
	addMech(CKM_DES_CBC_ENCRYPT_DATA, "CKM_DES_CBC_ENCRYPT_DATA");
	addMech(CKM_DES3_ECB_ENCRYPT_DATA, "CKM_DES3_ECB_ENCRYPT_DATA");
	addMech(CKM_DES3_CBC_ENCRYPT_DATA, "CKM_DES3_CBC_ENCRYPT_DATA");
	addMech(CKM_AES_ECB_ENCRYPT_DATA, "CKM_AES_ECB_ENCRYPT_DATA");
	addMech(CKM_AES_CBC_ENCRYPT_DATA, "CKM_AES_CBC_ENCRYPT_DATA");

	addMech(CKM_GOSTR3410_KEY_PAIR_GEN, "CKM_GOSTR3410_KEY_PAIR_GEN");
	addMech(CKM_GOSTR3410, "CKM_GOSTR3410");
	addMech(CKM_GOSTR3410_WITH_GOSTR3411, "CKM_GOSTR3410_WITH_GOSTR3411");
	addMech(CKM_GOSTR3410_KEY_WRAP, "CKM_GOSTR3410_KEY_WRAP");
	addMech(CKM_GOSTR3410_DERIVE, "CKM_GOSTR3410_DERIVE");
	addMech(CKM_GOSTR3411, "CKM_GOSTR3411");
	addMech(CKM_GOSTR3411_HMAC, "CKM_GOSTR3411_HMAC");
	addMech(CKM_GOST28147_KEY_GEN, "CKM_GOST28147_KEY_GEN");
	addMech(CKM_GOST28147_ECB, "CKM_GOST28147_ECB");
	addMech(CKM_GOST28147, "CKM_GOST28147");
	addMech(CKM_GOST28147_MAC, "CKM_GOST28147_MAC");
	addMech(CKM_GOST28147_KEY_WRAP, "CKM_GOST28147_KEY_WRAP");

	addMech(CKM_DSA_PARAMETER_GEN, "CKM_DSA_PARAMETER_GEN");
	addMech(CKM_DH_PKCS_PARAMETER_GEN, "CKM_DH_PKCS_PARAMETER_GEN");
	addMech(CKM_X9_42_DH_PARAMETER_GEN, "CKM_X9_42_DH_PARAMETER_GEN");
	addMech(CKM_DSA_PROBABLISTIC_PARAMETER_GEN,
	"CKM_DSA_PROBABLISTIC_PARAMETER_GEN");
	addMech(CKM_DSA_SHAWE_TAYLOR_PARAMETER_GEN,
	"CKM_DSA_SHAWE_TAYLOR_PARAMETER_GEN");
	addMech(CKM_AES_OFB, "CKM_AES_OFB");
	addMech(CKM_AES_CFB64, "CKM_AES_CFB64");
	addMech(CKM_AES_CFB8, "CKM_AES_CFB8");
	addMech(CKM_AES_CFB128, "CKM_AES_CFB128");
	addMech(CKM_AES_CFB1, "CKM_AES_CFB1");
	addMech(CKM_AES_KEY_WRAP, "CKM_AES_KEY_WRAP");
	addMech(CKM_AES_KEY_WRAP_PAD, "CKM_AES_KEY_WRAP_PAD");

	addMech(CKM_RSA_PKCS_TPM_1_1, "CKM_RSA_PKCS_TPM_1_1");
	addMech(CKM_RSA_PKCS_OAEP_TPM_1_1, "CKM_RSA_PKCS_OAEP_TPM_1_1");

	addMech(CKM_VENDOR_DEFINED, "CKM_VENDOR_DEFINED");

	addMech(CKM_NSS_TLS_PRF_GENERAL, "CKM_NSS_TLS_PRF_GENERAL");

	addMech(PCKM_SECURERANDOM, "SecureRandom");
	addMech(PCKM_KEYSTORE, "KeyStore");

	addHashMech(CKM_SHA_1, "SHA-1", "SHA", "SHA1");
	addHashMech(CKM_SHA224, "SHA-224", "SHA224");
	addHashMech(CKM_SHA256, "SHA-256", "SHA256");
	addHashMech(CKM_SHA384, "SHA-384", "SHA384");
	addHashMech(CKM_SHA512, "SHA-512", "SHA512");
	addHashMech(CKM_SHA512_224, "SHA-512/224", "SHA512/224");
	addHashMech(CKM_SHA512_256, "SHA-512/256", "SHA512/256");

	addKeyType(CKK_RSA, "CKK_RSA");
	addKeyType(CKK_DSA, "CKK_DSA");
	addKeyType(CKK_DH, "CKK_DH");
	addKeyType(CKK_EC, "CKK_EC");
	addKeyType(CKK_X9_42_DH, "CKK_X9_42_DH");
	addKeyType(CKK_KEA, "CKK_KEA");
	addKeyType(CKK_GENERIC_SECRET, "CKK_GENERIC_SECRET");
	addKeyType(CKK_RC2, "CKK_RC2");
	addKeyType(CKK_RC4, "CKK_RC4");
	addKeyType(CKK_DES, "CKK_DES");
	addKeyType(CKK_DES2, "CKK_DES2");
	addKeyType(CKK_DES3, "CKK_DES3");
	addKeyType(CKK_CAST, "CKK_CAST");
	addKeyType(CKK_CAST3, "CKK_CAST3");
	addKeyType(CKK_CAST128, "CKK_CAST128");
	addKeyType(CKK_RC5, "CKK_RC5");
	addKeyType(CKK_IDEA, "CKK_IDEA");
	addKeyType(CKK_SKIPJACK, "CKK_SKIPJACK");
	addKeyType(CKK_BATON, "CKK_BATON");
	addKeyType(CKK_JUNIPER, "CKK_JUNIPER");
	addKeyType(CKK_CDMF, "CKK_CDMF");
	addKeyType(CKK_AES, "CKK_AES");
	addKeyType(CKK_BLOWFISH, "CKK_BLOWFISH");
	addKeyType(CKK_TWOFISH, "CKK_TWOFISH");
	addKeyType(CKK_SECURID, "CKK_SECURID");
	addKeyType(CKK_HOTP, "CKK_HOTP");
	addKeyType(CKK_ACTI, "CKK_ACTI");
	addKeyType(CKK_CAMELLIA, "CKK_CAMELLIA");
	addKeyType(CKK_ARIA, "CKK_ARIA");
	addKeyType(CKK_MD5_HMAC, "CKK_MD5_HMAC");
	addKeyType(CKK_SHA_1_HMAC, "CKK_SHA_1_HMAC");
	addKeyType(CKK_RIPEMD128_HMAC, "CKK_RIPEMD128_HMAC");
	addKeyType(CKK_RIPEMD160_HMAC, "CKK_RIPEMD160_HMAC");
	addKeyType(CKK_SHA256_HMAC, "CKK_SHA256_HMAC");
	addKeyType(CKK_SHA384_HMAC, "CKK_SHA384_HMAC");
	addKeyType(CKK_SHA512_HMAC, "CKK_SHA512_HMAC");
	addKeyType(CKK_SHA224_HMAC, "CKK_SHA224_HMAC");
	addKeyType(CKK_SEED, "CKK_SEED");
	addKeyType(CKK_GOSTR3410, "CKK_GOSTR3410");
	addKeyType(CKK_GOSTR3411, "CKK_GOSTR3411");
	addKeyType(CKK_GOST28147, "CKK_GOST28147");

	addKeyType(CKK_VENDOR_DEFINED, "CKK_VENDOR_DEFINED");

	addKeyType(PCKK_ANY, "*");

	addAttribute(CKA_CLASS, "CKA_CLASS");
	addAttribute(CKA_TOKEN, "CKA_TOKEN");
	addAttribute(CKA_PRIVATE, "CKA_PRIVATE");
	addAttribute(CKA_LABEL, "CKA_LABEL");
	addAttribute(CKA_APPLICATION, "CKA_APPLICATION");
	addAttribute(CKA_VALUE, "CKA_VALUE");
	addAttribute(CKA_OBJECT_ID, "CKA_OBJECT_ID");
	addAttribute(CKA_CERTIFICATE_TYPE, "CKA_CERTIFICATE_TYPE");
	addAttribute(CKA_ISSUER, "CKA_ISSUER");
	addAttribute(CKA_SERIAL_NUMBER, "CKA_SERIAL_NUMBER");
	addAttribute(CKA_AC_ISSUER, "CKA_AC_ISSUER");
	addAttribute(CKA_OWNER, "CKA_OWNER");
	addAttribute(CKA_ATTR_TYPES, "CKA_ATTR_TYPES");
	addAttribute(CKA_TRUSTED, "CKA_TRUSTED");
	addAttribute(CKA_CERTIFICATE_CATEGORY, "CKA_CERTIFICATE_CATEGORY");
	addAttribute(CKA_JAVA_MIDP_SECURITY_DOMAIN,
	"CKA_JAVA_MIDP_SECURITY_DOMAIN");
	addAttribute(CKA_URL, "CKA_URL");
	addAttribute(CKA_HASH_OF_SUBJECT_PUBLIC_KEY,
	"CKA_HASH_OF_SUBJECT_PUBLIC_KEY");
	addAttribute(CKA_HASH_OF_ISSUER_PUBLIC_KEY,
	"CKA_HASH_OF_ISSUER_PUBLIC_KEY");
	addAttribute(CKA_NAME_HASH_ALGORITHM, "CKA_NAME_HASH_ALGORITHM");
	addAttribute(CKA_CHECK_VALUE, "CKA_CHECK_VALUE");
	addAttribute(CKA_KEY_TYPE, "CKA_KEY_TYPE");
	addAttribute(CKA_SUBJECT, "CKA_SUBJECT");
	addAttribute(CKA_ID, "CKA_ID");
	addAttribute(CKA_SENSITIVE, "CKA_SENSITIVE");
	addAttribute(CKA_ENCRYPT, "CKA_ENCRYPT");
	addAttribute(CKA_DECRYPT, "CKA_DECRYPT");
	addAttribute(CKA_WRAP, "CKA_WRAP");
	addAttribute(CKA_UNWRAP, "CKA_UNWRAP");
	addAttribute(CKA_SIGN, "CKA_SIGN");
	addAttribute(CKA_SIGN_RECOVER, "CKA_SIGN_RECOVER");
	addAttribute(CKA_VERIFY, "CKA_VERIFY");
	addAttribute(CKA_VERIFY_RECOVER, "CKA_VERIFY_RECOVER");
	addAttribute(CKA_DERIVE, "CKA_DERIVE");
	addAttribute(CKA_START_DATE, "CKA_START_DATE");
	addAttribute(CKA_END_DATE, "CKA_END_DATE");
	addAttribute(CKA_MODULUS, "CKA_MODULUS");
	addAttribute(CKA_MODULUS_BITS, "CKA_MODULUS_BITS");
	addAttribute(CKA_PUBLIC_EXPONENT, "CKA_PUBLIC_EXPONENT");
	addAttribute(CKA_PRIVATE_EXPONENT, "CKA_PRIVATE_EXPONENT");
	addAttribute(CKA_PRIME_1, "CKA_PRIME_1");
	addAttribute(CKA_PRIME_2, "CKA_PRIME_2");
	addAttribute(CKA_EXPONENT_1, "CKA_EXPONENT_1");
	addAttribute(CKA_EXPONENT_2, "CKA_EXPONENT_2");
	addAttribute(CKA_COEFFICIENT, "CKA_COEFFICIENT");
	addAttribute(CKA_PUBLIC_KEY_INFO, "CKA_PUBLIC_KEY_INFO");
	addAttribute(CKA_PRIME, "CKA_PRIME");
	addAttribute(CKA_SUBPRIME, "CKA_SUBPRIME");
	addAttribute(CKA_BASE, "CKA_BASE");
	addAttribute(CKA_PRIME_BITS, "CKA_PRIME_BITS");
	addAttribute(CKA_SUB_PRIME_BITS, "CKA_SUB_PRIME_BITS");
	addAttribute(CKA_VALUE_BITS, "CKA_VALUE_BITS");
	addAttribute(CKA_VALUE_LEN, "CKA_VALUE_LEN");

	addAttribute(CKA_EXTRACTABLE, "CKA_EXTRACTABLE");
	addAttribute(CKA_LOCAL, "CKA_LOCAL");
	addAttribute(CKA_NEVER_EXTRACTABLE, "CKA_NEVER_EXTRACTABLE");
	addAttribute(CKA_ALWAYS_SENSITIVE, "CKA_ALWAYS_SENSITIVE");

	addAttribute(CKA_KEY_GEN_MECHANISM, "CKA_KEY_GEN_MECHANISM");
	addAttribute(CKA_MODIFIABLE, "CKA_MODIFIABLE");
	addAttribute(CKA_COPYABLE, "CKA_COPYABLE");
	addAttribute(CKA_DESTROYABLE, "CKA_DESTROYABLE");

	addAttribute(CKA_EC_PARAMS, "CKA_EC_PARAMS");
	addAttribute(CKA_EC_POINT, "CKA_EC_POINT");

	addAttribute(CKA_SECONDARY_AUTH, "CKA_SECONDARY_AUTH");
	addAttribute(CKA_AUTH_PIN_FLAGS, "CKA_AUTH_PIN_FLAGS");
	addAttribute(CKA_ALWAYS_AUTHENTICATE, "CKA_ALWAYS_AUTHENTICATE");
	addAttribute(CKA_WRAP_WITH_TRUSTED, "CKA_WRAP_WITH_TRUSTED");
	addAttribute(CKA_WRAP_TEMPLATE, "CKA_WRAP_TEMPLATE");
	addAttribute(CKA_UNWRAP_TEMPLATE, "CKA_UNWRAP_TEMPLATE");
	addAttribute(CKA_DERIVE_TEMPLATE, "CKA_DERIVE_TEMPLATE");
	addAttribute(CKA_OTP_FORMAT, "CKA_OTP_FORMAT");
	addAttribute(CKA_OTP_LENGTH, "CKA_OTP_LENGTH");
	addAttribute(CKA_OTP_TIME_INTERVAL, "CKA_OTP_TIME_INTERVAL");
	addAttribute(CKA_OTP_USER_FRIENDLY_MODE,"CKA_OTP_USER_FRIENDLY_MODE");
	addAttribute(CKA_OTP_CHALLENGE_REQUIREMENT,
	"CKA_OTP_CHALLENGE_REQUIREMENT");
	addAttribute(CKA_OTP_TIME_REQUIREMENT, "CKA_OTP_TIME_REQUIREMENT");
	addAttribute(CKA_OTP_COUNTER_REQUIREMENT,
	"CKA_OTP_COUNTER_REQUIREMENT");
	addAttribute(CKA_OTP_PIN_REQUIREMENT, "CKA_OTP_PIN_REQUIREMENT");
	addAttribute(CKA_OTP_COUNTER, "CKA_OTP_COUNTER");
	addAttribute(CKA_OTP_TIME, "CKA_OTP_TIME");
	addAttribute(CKA_OTP_USER_IDENTIFIER, "CKA_OTP_USER_IDENTIFIER");
	addAttribute(CKA_OTP_SERVICE_IDENTIFIER,"CKA_OTP_SERVICE_IDENTIFIER");
	addAttribute(CKA_OTP_SERVICE_LOGO, "CKA_OTP_SERVICE_LOGO");
	addAttribute(CKA_OTP_SERVICE_LOGO_TYPE, "CKA_OTP_SERVICE_LOGO_TYPE");
	addAttribute(CKA_GOSTR3410_PARAMS, "CKA_GOSTR3410_PARAMS");
	addAttribute(CKA_GOSTR3411_PARAMS, "CKA_GOSTR3411_PARAMS");
	addAttribute(CKA_GOST28147_PARAMS, "CKA_GOST28147_PARAMS");

	addAttribute(CKA_HW_FEATURE_TYPE, "CKA_HW_FEATURE_TYPE");
	addAttribute(CKA_RESET_ON_INIT, "CKA_RESET_ON_INIT");
	addAttribute(CKA_HAS_RESET, "CKA_HAS_RESET");

	addAttribute(CKA_PIXEL_X, "CKA_PIXEL_X");
	addAttribute(CKA_PIXEL_Y, "CKA_PIXEL_Y");
	addAttribute(CKA_RESOLUTION, "CKA_RESOLUTION");
	addAttribute(CKA_CHAR_ROWS, "CKA_CHAR_ROWS");
	addAttribute(CKA_CHAR_COLUMNS, "CKA_CHAR_COLUMNS");
	addAttribute(CKA_COLOR, "CKA_COLOR");
	addAttribute(CKA_BITS_PER_PIXEL, "CKA_BITS_PER_PIXEL");
	addAttribute(CKA_CHAR_SETS, "CKA_CHAR_SETS");
	addAttribute(CKA_ENCODING_METHODS, "CKA_ENCODING_METHODS");
	addAttribute(CKA_MIME_TYPES, "CKA_MIME_TYPES");
	addAttribute(CKA_MECHANISM_TYPE, "CKA_MECHANISM_TYPE");
	addAttribute(CKA_REQUIRED_CMS_ATTRIBUTES,
	"CKA_REQUIRED_CMS_ATTRIBUTES");
	addAttribute(CKA_DEFAULT_CMS_ATTRIBUTES,"CKA_DEFAULT_CMS_ATTRIBUTES");
	addAttribute(CKA_SUPPORTED_CMS_ATTRIBUTES,
	"CKA_SUPPORTED_CMS_ATTRIBUTES");
	addAttribute(CKA_ALLOWED_MECHANISMS, "CKA_ALLOWED_MECHANISMS");

	addAttribute(CKA_VENDOR_DEFINED, "CKA_VENDOR_DEFINED");
	addAttribute(CKA_NETSCAPE_DB, "CKA_NETSCAPE_DB");

	addAttribute(CKA_NETSCAPE_TRUST_SERVER_AUTH, "CKA_NETSCAPE_TRUST_SERVER_AUTH");
	addAttribute(CKA_NETSCAPE_TRUST_CLIENT_AUTH, "CKA_NETSCAPE_TRUST_CLIENT_AUTH");
	addAttribute(CKA_NETSCAPE_TRUST_CODE_SIGNING, "CKA_NETSCAPE_TRUST_CODE_SIGNING");
	addAttribute(CKA_NETSCAPE_TRUST_EMAIL_PROTECTION, "CKA_NETSCAPE_TRUST_EMAIL_PROTECTION");
	addAttribute(CKA_NETSCAPE_CERT_SHA1_HASH, "CKA_NETSCAPE_CERT_SHA1_HASH");
	addAttribute(CKA_NETSCAPE_CERT_MD5_HASH, "CKA_NETSCAPE_CERT_MD5_HASH");

	addObjectClass(CKO_DATA, "CKO_DATA");
	addObjectClass(CKO_CERTIFICATE, "CKO_CERTIFICATE");
	addObjectClass(CKO_PUBLIC_KEY, "CKO_PUBLIC_KEY");
	addObjectClass(CKO_PRIVATE_KEY, "CKO_PRIVATE_KEY");
	addObjectClass(CKO_SECRET_KEY, "CKO_SECRET_KEY");
	addObjectClass(CKO_HW_FEATURE, "CKO_HW_FEATURE");
	addObjectClass(CKO_DOMAIN_PARAMETERS, "CKO_DOMAIN_PARAMETERS");
	addObjectClass(CKO_VENDOR_DEFINED, "CKO_VENDOR_DEFINED");

	addObjectClass(PCKO_ANY, "*");

	addMGF(CKG_MGF1_SHA1, "CKG_MGF1_SHA1");
	addMGF(CKG_MGF1_SHA256, "CKG_MGF1_SHA256");
	addMGF(CKG_MGF1_SHA384, "CKG_MGF1_SHA384");
	addMGF(CKG_MGF1_SHA512, "CKG_MGF1_SHA512");
	addMGF(CKG_MGF1_SHA224, "CKG_MGF1_SHA224");
	}

	}

Back to index...