jdk/src/share/classes/sun/security/pkcs11/P11KeyPairGenerator.java - edge/openjdk - Git at Google

 /*
  * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */

 package sun.security.pkcs11;

 import java.math.BigInteger;

 import java.security.*;
 import java.security.spec.*;

 import javax.crypto.spec.DHParameterSpec;

 import sun.security.provider.ParameterCache;

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

 import sun.security.rsa.RSAKeyFactory;

 /**
  * KeyPairGenerator implementation class. This class currently supports
  * RSA, DSA, DH, and EC.
  *
  * Note that for DSA and DH we rely on the Sun and SunJCE providers to
  * obtain the parameters from.
  *
  * @author  Andreas Sterbenz
  * @since   1.5
  */
 final class P11KeyPairGenerator extends KeyPairGeneratorSpi {

     // token instance
     private final Token token;

     // algorithm name
     private final String algorithm;

     // mechanism id
     private final long mechanism;

     // selected or default key size, always valid
     private int keySize;

     // parameters specified via init, if any
     private AlgorithmParameterSpec params;

     // for RSA, selected or default value of public exponent, always valid
     private BigInteger rsaPublicExponent = RSAKeyGenParameterSpec.F4;

     // the supported keysize range of the native PKCS11 library
     // if the value cannot be retrieved or unspecified, -1 is used.
     private final int minKeySize;
     private final int maxKeySize;

     // SecureRandom instance, if specified in init
     private SecureRandom random;

     P11KeyPairGenerator(Token token, String algorithm, long mechanism)
             throws PKCS11Exception {
         super();
         int minKeyLen = -1;
         int maxKeyLen = -1;
         try {
             CK_MECHANISM_INFO mechInfo = token.getMechanismInfo(mechanism);
             if (mechInfo != null) {
                 minKeyLen = (int) mechInfo.ulMinKeySize;
                 maxKeyLen = (int) mechInfo.ulMaxKeySize;
             }
         } catch (PKCS11Exception p11e) {
             // Should never happen
             throw new ProviderException
                         ("Unexpected error while getting mechanism info", p11e);
         }
         // set default key sizes and apply our own algorithm-specific limits
         // override lower limit to disallow unsecure keys being generated
         // override upper limit to deter DOS attack
         if (algorithm.equals("EC")) {
             keySize = 256;
             if ((minKeyLen == -1) || (minKeyLen < 112)) {
                 minKeyLen = 112;
             }
             if ((maxKeyLen == -1) || (maxKeyLen > 2048)) {
                 maxKeyLen = 2048;
             }
         } else {
             // RSA, DH, and DSA
             keySize = 1024;
             if ((minKeyLen == -1) || (minKeyLen < 512)) {
                 minKeyLen = 512;
             }
             if (algorithm.equals("RSA")) {
                 if ((maxKeyLen == -1) || (maxKeyLen > 64 * 1024)) {
                     maxKeyLen = 64 * 1024;
                 }
             }
         }

         // auto-adjust default keysize in case it's out-of-range
         if ((minKeyLen != -1) && (keySize < minKeyLen)) {
             keySize = minKeyLen;
         }
         if ((maxKeyLen != -1) && (keySize > maxKeyLen)) {
             keySize = maxKeyLen;
         }
         this.token = token;
         this.algorithm = algorithm;
         this.mechanism = mechanism;
         this.minKeySize = minKeyLen;
         this.maxKeySize = maxKeyLen;
         initialize(keySize, null);
     }

     // see JCA spec
     public void initialize(int keySize, SecureRandom random) {
         token.ensureValid();
         try {
             checkKeySize(keySize, null);
         } catch (InvalidAlgorithmParameterException e) {
             throw new InvalidParameterException(e.getMessage());
         }
         this.params = null;
         if (algorithm.equals("EC")) {
             params = P11ECKeyFactory.getECParameterSpec(keySize);
             if (params == null) {
                 throw new InvalidParameterException(
                     "No EC parameters available for key size "
                     + keySize + " bits");
             }
         }
         this.keySize = keySize;
         this.random = random;
     }

     // see JCA spec
     public void initialize(AlgorithmParameterSpec params, SecureRandom random)
             throws InvalidAlgorithmParameterException {
         token.ensureValid();
         int tmpKeySize;
         if (algorithm.equals("DH")) {
             if (params instanceof DHParameterSpec == false) {
                 throw new InvalidAlgorithmParameterException
                         ("DHParameterSpec required for Diffie-Hellman");
             }
             DHParameterSpec dhParams = (DHParameterSpec) params;
             tmpKeySize = dhParams.getP().bitLength();
             checkKeySize(tmpKeySize, null);
             // XXX sanity check params
         } else if (algorithm.equals("RSA")) {
             if (params instanceof RSAKeyGenParameterSpec == false) {
                 throw new InvalidAlgorithmParameterException
                         ("RSAKeyGenParameterSpec required for RSA");
             }
             RSAKeyGenParameterSpec rsaParams =
                 (RSAKeyGenParameterSpec) params;
             tmpKeySize = rsaParams.getKeysize();
             checkKeySize(tmpKeySize, rsaParams);
             // override the supplied params to null
             params = null;
             this.rsaPublicExponent = rsaParams.getPublicExponent();
             // XXX sanity check params
         } else if (algorithm.equals("DSA")) {
             if (params instanceof DSAParameterSpec == false) {
                 throw new InvalidAlgorithmParameterException
                         ("DSAParameterSpec required for DSA");
             }
             DSAParameterSpec dsaParams = (DSAParameterSpec) params;
             tmpKeySize = dsaParams.getP().bitLength();
             checkKeySize(tmpKeySize, null);
             // XXX sanity check params
         } else if (algorithm.equals("EC")) {
             ECParameterSpec ecParams;
             if (params instanceof ECParameterSpec) {
                 ecParams = P11ECKeyFactory.getECParameterSpec(
                     (ECParameterSpec)params);
                 if (ecParams == null) {
                     throw new InvalidAlgorithmParameterException
                         ("Unsupported curve: " + params);
                 }
             } else if (params instanceof ECGenParameterSpec) {
                 String name = ((ECGenParameterSpec) params).getName();
                 ecParams = P11ECKeyFactory.getECParameterSpec(name);
                 if (ecParams == null) {
                     throw new InvalidAlgorithmParameterException
                         ("Unknown curve name: " + name);
                 }
                 // override the supplied params with the derived one
                 params = ecParams;
             } else {
                 throw new InvalidAlgorithmParameterException
                     ("ECParameterSpec or ECGenParameterSpec required for EC");
             }
             tmpKeySize = ecParams.getCurve().getField().getFieldSize();
             checkKeySize(tmpKeySize, null);
         } else {
             throw new ProviderException("Unknown algorithm: " + algorithm);
         }
         this.keySize = tmpKeySize;
         this.params = params;
         this.random = random;
     }

     // NOTE: 'params' is only used for checking RSA keys currently.
     private void checkKeySize(int keySize, RSAKeyGenParameterSpec params)
         throws InvalidAlgorithmParameterException {
         // check native range first
         if ((minKeySize != -1) && (keySize < minKeySize)) {
             throw new InvalidAlgorithmParameterException(algorithm +
                 " key must be at least " + minKeySize + " bits");
         }
         if ((maxKeySize != -1) && (keySize > maxKeySize)) {
             throw new InvalidAlgorithmParameterException(algorithm +
                 " key must be at most " + maxKeySize + " bits");
         }

         // check our own algorithm-specific limits also
         if (algorithm.equals("EC")) {
             if (keySize < 112) {
                 throw new InvalidAlgorithmParameterException
                     ("Key size must be at least 112 bit");
             }
             if (keySize > 2048) {
                 // sanity check, nobody really wants keys this large
                 throw new InvalidAlgorithmParameterException
                     ("Key size must be at most 2048 bit");
             }
         } else {
             // RSA, DH, DSA
             if (keySize < 512) {
                 throw new InvalidAlgorithmParameterException
                     ("Key size must be at least 512 bit");
             }
             if (algorithm.equals("RSA")) {
                 BigInteger tmpExponent = rsaPublicExponent;
                 if (params != null) {
                     tmpExponent = params.getPublicExponent();
                 }
                 try {
                     // Reuse the checking in SunRsaSign provider.
                     // If maxKeySize is -1, then replace it with
                     // Integer.MAX_VALUE to indicate no limit.
                     RSAKeyFactory.checkKeyLengths(keySize, tmpExponent,
                         minKeySize,
                         (maxKeySize==-1? Integer.MAX_VALUE:maxKeySize));
                 } catch (InvalidKeyException e) {
                     throw new InvalidAlgorithmParameterException(e.getMessage());
                 }
             } else {
                 if (algorithm.equals("DH") && (params != null)) {
                     // sanity check, nobody really wants keys this large
                     if (keySize > 64 * 1024) {
                         throw new InvalidAlgorithmParameterException
                             ("Key size must be at most 65536 bit");
                     }
                 } else {
                     // this restriction is in the spec for DSA
                     // since we currently use DSA parameters for DH as well,
                     // it also applies to DH if no parameters are specified
                     if ((keySize != 2048) &&
                         ((keySize > 1024) || ((keySize & 0x3f) != 0))) {
                         throw new InvalidAlgorithmParameterException(algorithm +
                             " key must be multiples of 64 if less than 1024 bits" +
                             ", or 2048 bits");
                     }
                 }
             }
         }
     }

     // see JCA spec
     public KeyPair generateKeyPair() {
         token.ensureValid();
         CK_ATTRIBUTE[] publicKeyTemplate;
         CK_ATTRIBUTE[] privateKeyTemplate;
         long keyType;
         if (algorithm.equals("RSA")) {
             keyType = CKK_RSA;
             publicKeyTemplate = new CK_ATTRIBUTE[] {
                 new CK_ATTRIBUTE(CKA_MODULUS_BITS, keySize),
                 new CK_ATTRIBUTE(CKA_PUBLIC_EXPONENT, rsaPublicExponent),
             };
             privateKeyTemplate = new CK_ATTRIBUTE[] {
                 // empty
             };
         } else if (algorithm.equals("DSA")) {
             keyType = CKK_DSA;
             DSAParameterSpec dsaParams;
             if (params == null) {
                 try {
                     dsaParams = ParameterCache.getDSAParameterSpec
                                                     (keySize, random);
                 } catch (GeneralSecurityException e) {
                     throw new ProviderException
                             ("Could not generate DSA parameters", e);
                 }
             } else {
                 dsaParams = (DSAParameterSpec)params;
             }
             publicKeyTemplate = new CK_ATTRIBUTE[] {
                 new CK_ATTRIBUTE(CKA_PRIME, dsaParams.getP()),
                 new CK_ATTRIBUTE(CKA_SUBPRIME, dsaParams.getQ()),
                 new CK_ATTRIBUTE(CKA_BASE, dsaParams.getG()),
             };
             privateKeyTemplate = new CK_ATTRIBUTE[] {
                 // empty
             };
         } else if (algorithm.equals("DH")) {
             keyType = CKK_DH;
             DHParameterSpec dhParams;
             int privateBits;
             if (params == null) {
                 try {
                     dhParams = ParameterCache.getDHParameterSpec
                                                     (keySize, random);
                 } catch (GeneralSecurityException e) {
                     throw new ProviderException
                             ("Could not generate DH parameters", e);
                 }
                 privateBits = 0;
             } else {
                 dhParams = (DHParameterSpec)params;
                 privateBits = dhParams.getL();
             }
             if (privateBits <= 0) {
                 // XXX find better defaults
                 privateBits = (keySize >= 1024) ? 768 : 512;
             }
             publicKeyTemplate = new CK_ATTRIBUTE[] {
                 new CK_ATTRIBUTE(CKA_PRIME, dhParams.getP()),
                 new CK_ATTRIBUTE(CKA_BASE, dhParams.getG())
             };
             privateKeyTemplate = new CK_ATTRIBUTE[] {
                 new CK_ATTRIBUTE(CKA_VALUE_BITS, privateBits),
             };
         } else if (algorithm.equals("EC")) {
             keyType = CKK_EC;
             byte[] encodedParams =
                     P11ECKeyFactory.encodeParameters((ECParameterSpec)params);
             publicKeyTemplate = new CK_ATTRIBUTE[] {
                 new CK_ATTRIBUTE(CKA_EC_PARAMS, encodedParams),
             };
             privateKeyTemplate = new CK_ATTRIBUTE[] {
                 // empty
             };
         } else {
             throw new ProviderException("Unknown algorithm: " + algorithm);
         }
         Session session = null;
         try {
             session = token.getObjSession();
             publicKeyTemplate = token.getAttributes
                 (O_GENERATE, CKO_PUBLIC_KEY, keyType, publicKeyTemplate);
             privateKeyTemplate = token.getAttributes
                 (O_GENERATE, CKO_PRIVATE_KEY, keyType, privateKeyTemplate);
             long[] keyIDs = token.p11.C_GenerateKeyPair
                 (session.id(), new CK_MECHANISM(mechanism),
                 publicKeyTemplate, privateKeyTemplate);
             PublicKey publicKey = P11Key.publicKey
                 (session, keyIDs[0], algorithm, keySize, publicKeyTemplate);
             PrivateKey privateKey = P11Key.privateKey
                 (session, keyIDs[1], algorithm, keySize, privateKeyTemplate);
             return new KeyPair(publicKey, privateKey);
         } catch (PKCS11Exception e) {
             throw new ProviderException(e);
         } finally {
             token.releaseSession(session);
         }
     }
 }
	/*
	* Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package sun.security.pkcs11;

	import java.math.BigInteger;

	import java.security.*;
	import java.security.spec.*;

	import javax.crypto.spec.DHParameterSpec;

	import sun.security.provider.ParameterCache;

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

	import sun.security.rsa.RSAKeyFactory;

	/**
	* KeyPairGenerator implementation class. This class currently supports
	* RSA, DSA, DH, and EC.
	*
	* Note that for DSA and DH we rely on the Sun and SunJCE providers to
	* obtain the parameters from.
	*
	* @author Andreas Sterbenz
	* @since 1.5
	*/
	final class P11KeyPairGenerator extends KeyPairGeneratorSpi {

	// token instance
	private final Token token;

	// algorithm name
	private final String algorithm;

	// mechanism id
	private final long mechanism;

	// selected or default key size, always valid
	private int keySize;

	// parameters specified via init, if any
	private AlgorithmParameterSpec params;

	// for RSA, selected or default value of public exponent, always valid
	private BigInteger rsaPublicExponent = RSAKeyGenParameterSpec.F4;

	// the supported keysize range of the native PKCS11 library
	// if the value cannot be retrieved or unspecified, -1 is used.
	private final int minKeySize;
	private final int maxKeySize;

	// SecureRandom instance, if specified in init
	private SecureRandom random;

	P11KeyPairGenerator(Token token, String algorithm, long mechanism)
	throws PKCS11Exception {
	super();
	int minKeyLen = -1;
	int maxKeyLen = -1;
	try {
	CK_MECHANISM_INFO mechInfo = token.getMechanismInfo(mechanism);
	if (mechInfo != null) {
	minKeyLen = (int) mechInfo.ulMinKeySize;
	maxKeyLen = (int) mechInfo.ulMaxKeySize;
	}
	} catch (PKCS11Exception p11e) {
	// Should never happen
	throw new ProviderException
	("Unexpected error while getting mechanism info", p11e);
	}
	// set default key sizes and apply our own algorithm-specific limits
	// override lower limit to disallow unsecure keys being generated
	// override upper limit to deter DOS attack
	if (algorithm.equals("EC")) {
	keySize = 256;
	if ((minKeyLen == -1) \|\| (minKeyLen < 112)) {
	minKeyLen = 112;
	}
	if ((maxKeyLen == -1) \|\| (maxKeyLen > 2048)) {
	maxKeyLen = 2048;
	}
	} else {
	// RSA, DH, and DSA
	keySize = 1024;
	if ((minKeyLen == -1) \|\| (minKeyLen < 512)) {
	minKeyLen = 512;
	}
	if (algorithm.equals("RSA")) {
	if ((maxKeyLen == -1) \|\| (maxKeyLen > 64 * 1024)) {
	maxKeyLen = 64 * 1024;
	}
	}
	}

	// auto-adjust default keysize in case it's out-of-range
	if ((minKeyLen != -1) && (keySize < minKeyLen)) {
	keySize = minKeyLen;
	}
	if ((maxKeyLen != -1) && (keySize > maxKeyLen)) {
	keySize = maxKeyLen;
	}
	this.token = token;
	this.algorithm = algorithm;
	this.mechanism = mechanism;
	this.minKeySize = minKeyLen;
	this.maxKeySize = maxKeyLen;
	initialize(keySize, null);
	}

	// see JCA spec
	public void initialize(int keySize, SecureRandom random) {
	token.ensureValid();
	try {
	checkKeySize(keySize, null);
	} catch (InvalidAlgorithmParameterException e) {
	throw new InvalidParameterException(e.getMessage());
	}
	this.params = null;
	if (algorithm.equals("EC")) {
	params = P11ECKeyFactory.getECParameterSpec(keySize);
	if (params == null) {
	throw new InvalidParameterException(
	"No EC parameters available for key size "
	+ keySize + " bits");
	}
	}
	this.keySize = keySize;
	this.random = random;
	}

	// see JCA spec
	public void initialize(AlgorithmParameterSpec params, SecureRandom random)
	throws InvalidAlgorithmParameterException {
	token.ensureValid();
	int tmpKeySize;
	if (algorithm.equals("DH")) {
	if (params instanceof DHParameterSpec == false) {
	throw new InvalidAlgorithmParameterException
	("DHParameterSpec required for Diffie-Hellman");
	}
	DHParameterSpec dhParams = (DHParameterSpec) params;
	tmpKeySize = dhParams.getP().bitLength();
	checkKeySize(tmpKeySize, null);
	// XXX sanity check params
	} else if (algorithm.equals("RSA")) {
	if (params instanceof RSAKeyGenParameterSpec == false) {
	throw new InvalidAlgorithmParameterException
	("RSAKeyGenParameterSpec required for RSA");
	}
	RSAKeyGenParameterSpec rsaParams =
	(RSAKeyGenParameterSpec) params;
	tmpKeySize = rsaParams.getKeysize();
	checkKeySize(tmpKeySize, rsaParams);
	// override the supplied params to null
	params = null;
	this.rsaPublicExponent = rsaParams.getPublicExponent();
	// XXX sanity check params
	} else if (algorithm.equals("DSA")) {
	if (params instanceof DSAParameterSpec == false) {
	throw new InvalidAlgorithmParameterException
	("DSAParameterSpec required for DSA");
	}
	DSAParameterSpec dsaParams = (DSAParameterSpec) params;
	tmpKeySize = dsaParams.getP().bitLength();
	checkKeySize(tmpKeySize, null);
	// XXX sanity check params
	} else if (algorithm.equals("EC")) {
	ECParameterSpec ecParams;
	if (params instanceof ECParameterSpec) {
	ecParams = P11ECKeyFactory.getECParameterSpec(
	(ECParameterSpec)params);
	if (ecParams == null) {
	throw new InvalidAlgorithmParameterException
	("Unsupported curve: " + params);
	}
	} else if (params instanceof ECGenParameterSpec) {
	String name = ((ECGenParameterSpec) params).getName();
	ecParams = P11ECKeyFactory.getECParameterSpec(name);
	if (ecParams == null) {
	throw new InvalidAlgorithmParameterException
	("Unknown curve name: " + name);
	}
	// override the supplied params with the derived one
	params = ecParams;
	} else {
	throw new InvalidAlgorithmParameterException
	("ECParameterSpec or ECGenParameterSpec required for EC");
	}
	tmpKeySize = ecParams.getCurve().getField().getFieldSize();
	checkKeySize(tmpKeySize, null);
	} else {
	throw new ProviderException("Unknown algorithm: " + algorithm);
	}
	this.keySize = tmpKeySize;
	this.params = params;
	this.random = random;
	}

	// NOTE: 'params' is only used for checking RSA keys currently.
	private void checkKeySize(int keySize, RSAKeyGenParameterSpec params)
	throws InvalidAlgorithmParameterException {
	// check native range first
	if ((minKeySize != -1) && (keySize < minKeySize)) {
	throw new InvalidAlgorithmParameterException(algorithm +
	" key must be at least " + minKeySize + " bits");
	}
	if ((maxKeySize != -1) && (keySize > maxKeySize)) {
	throw new InvalidAlgorithmParameterException(algorithm +
	" key must be at most " + maxKeySize + " bits");
	}

	// check our own algorithm-specific limits also
	if (algorithm.equals("EC")) {
	if (keySize < 112) {
	throw new InvalidAlgorithmParameterException
	("Key size must be at least 112 bit");
	}
	if (keySize > 2048) {
	// sanity check, nobody really wants keys this large
	throw new InvalidAlgorithmParameterException
	("Key size must be at most 2048 bit");
	}
	} else {
	// RSA, DH, DSA
	if (keySize < 512) {
	throw new InvalidAlgorithmParameterException
	("Key size must be at least 512 bit");
	}
	if (algorithm.equals("RSA")) {
	BigInteger tmpExponent = rsaPublicExponent;
	if (params != null) {
	tmpExponent = params.getPublicExponent();
	}
	try {
	// Reuse the checking in SunRsaSign provider.
	// If maxKeySize is -1, then replace it with
	// Integer.MAX_VALUE to indicate no limit.
	RSAKeyFactory.checkKeyLengths(keySize, tmpExponent,
	minKeySize,
	(maxKeySize==-1? Integer.MAX_VALUE:maxKeySize));
	} catch (InvalidKeyException e) {
	throw new InvalidAlgorithmParameterException(e.getMessage());
	}
	} else {
	if (algorithm.equals("DH") && (params != null)) {
	// sanity check, nobody really wants keys this large
	if (keySize > 64 * 1024) {
	throw new InvalidAlgorithmParameterException
	("Key size must be at most 65536 bit");
	}
	} else {
	// this restriction is in the spec for DSA
	// since we currently use DSA parameters for DH as well,
	// it also applies to DH if no parameters are specified
	if ((keySize != 2048) &&
	((keySize > 1024) \|\| ((keySize & 0x3f) != 0))) {
	throw new InvalidAlgorithmParameterException(algorithm +
	" key must be multiples of 64 if less than 1024 bits" +
	", or 2048 bits");
	}
	}
	}
	}
	}

	// see JCA spec
	public KeyPair generateKeyPair() {
	token.ensureValid();
	CK_ATTRIBUTE[] publicKeyTemplate;
	CK_ATTRIBUTE[] privateKeyTemplate;
	long keyType;
	if (algorithm.equals("RSA")) {
	keyType = CKK_RSA;
	publicKeyTemplate = new CK_ATTRIBUTE[] {
	new CK_ATTRIBUTE(CKA_MODULUS_BITS, keySize),
	new CK_ATTRIBUTE(CKA_PUBLIC_EXPONENT, rsaPublicExponent),
	};
	privateKeyTemplate = new CK_ATTRIBUTE[] {
	// empty
	};
	} else if (algorithm.equals("DSA")) {
	keyType = CKK_DSA;
	DSAParameterSpec dsaParams;
	if (params == null) {
	try {
	dsaParams = ParameterCache.getDSAParameterSpec
	(keySize, random);
	} catch (GeneralSecurityException e) {
	throw new ProviderException
	("Could not generate DSA parameters", e);
	}
	} else {
	dsaParams = (DSAParameterSpec)params;
	}
	publicKeyTemplate = new CK_ATTRIBUTE[] {
	new CK_ATTRIBUTE(CKA_PRIME, dsaParams.getP()),
	new CK_ATTRIBUTE(CKA_SUBPRIME, dsaParams.getQ()),
	new CK_ATTRIBUTE(CKA_BASE, dsaParams.getG()),
	};
	privateKeyTemplate = new CK_ATTRIBUTE[] {
	// empty
	};
	} else if (algorithm.equals("DH")) {
	keyType = CKK_DH;
	DHParameterSpec dhParams;
	int privateBits;
	if (params == null) {
	try {
	dhParams = ParameterCache.getDHParameterSpec
	(keySize, random);
	} catch (GeneralSecurityException e) {
	throw new ProviderException
	("Could not generate DH parameters", e);
	}
	privateBits = 0;
	} else {
	dhParams = (DHParameterSpec)params;
	privateBits = dhParams.getL();
	}
	if (privateBits <= 0) {
	// XXX find better defaults
	privateBits = (keySize >= 1024) ? 768 : 512;
	}
	publicKeyTemplate = new CK_ATTRIBUTE[] {
	new CK_ATTRIBUTE(CKA_PRIME, dhParams.getP()),
	new CK_ATTRIBUTE(CKA_BASE, dhParams.getG())
	};
	privateKeyTemplate = new CK_ATTRIBUTE[] {
	new CK_ATTRIBUTE(CKA_VALUE_BITS, privateBits),
	};
	} else if (algorithm.equals("EC")) {
	keyType = CKK_EC;
	byte[] encodedParams =
	P11ECKeyFactory.encodeParameters((ECParameterSpec)params);
	publicKeyTemplate = new CK_ATTRIBUTE[] {
	new CK_ATTRIBUTE(CKA_EC_PARAMS, encodedParams),
	};
	privateKeyTemplate = new CK_ATTRIBUTE[] {
	// empty
	};
	} else {
	throw new ProviderException("Unknown algorithm: " + algorithm);
	}
	Session session = null;
	try {
	session = token.getObjSession();
	publicKeyTemplate = token.getAttributes
	(O_GENERATE, CKO_PUBLIC_KEY, keyType, publicKeyTemplate);
	privateKeyTemplate = token.getAttributes
	(O_GENERATE, CKO_PRIVATE_KEY, keyType, privateKeyTemplate);
	long[] keyIDs = token.p11.C_GenerateKeyPair
	(session.id(), new CK_MECHANISM(mechanism),
	publicKeyTemplate, privateKeyTemplate);
	PublicKey publicKey = P11Key.publicKey
	(session, keyIDs[0], algorithm, keySize, publicKeyTemplate);
	PrivateKey privateKey = P11Key.privateKey
	(session, keyIDs[1], algorithm, keySize, privateKeyTemplate);
	return new KeyPair(publicKey, privateKey);
	} catch (PKCS11Exception e) {
	throw new ProviderException(e);
	} finally {
	token.releaseSession(session);
	}
	}
	}