Index: gnu/java/security/provider/Gnu.java =================================================================== RCS file: /cvsroot/classpath/classpath/gnu/java/security/provider/Gnu.java,v retrieving revision 1.9 diff -u -b -B -r1.9 Gnu.java --- gnu/java/security/provider/Gnu.java 13 Sep 2005 22:09:43 -0000 1.9 +++ gnu/java/security/provider/Gnu.java 25 Sep 2005 21:30:05 -0000 @@ -46,7 +46,7 @@ { public Gnu() { - super("GNU", 1.0, "GNU provider v1.0 implementing SHA-1, MD5, DSA, RSA, X.509 Certificates and CRLs, PKIX certificate path validators, Collection cert stores, Diffie-Hellman key agreement"); + super("GNU", 1.0, "GNU provider v1.0 implementing SHA-1, MD5, DSA, RSA, X.509 Certificates and CRLs, PKIX certificate path validators, Collection cert stores, Diffie-Hellman key agreement and key pair generator"); AccessController.doPrivileged (new PrivilegedAction() { @@ -100,10 +100,12 @@ // Key Pair Generator put("KeyPairGenerator.DSA", gnu.java.security.provider.DSAKeyPairGenerator.class.getName()); + put("KeyPairGenerator.DiffieHellman", DiffieHellmanKeyPairGeneratorImpl.class.getName ()); put("Alg.Alias.KeyPairGenerator.OID.1.2.840.10040.4.1", "DSA"); put("Alg.Alias.KeyPairGenerator.1.2.840.10040.4.1", "DSA"); put("Alg.Alias.KeyPairGenerator.1.3.14.3.2.12", "DSA"); + put("Alg.Alias.KeyPairGenerator.DH", "DiffieHellman"); // Key Factory put("KeyFactory.DSA", @@ -121,6 +123,9 @@ put("Alg.Alias.KeyFactory.OID.1.2.840.10040.4.1", "DSA"); put("Alg.Alias.KeyFactory.1.2.840.10040.4.1", "DSA"); put("Alg.Alias.KeyFactory.1.3.14.3.2.12", "DSA"); + + put("KeyFactory.DiffieHellman", DiffieHellmanKeyFactoryImpl.class.getName()); + put("Alg.Alias.KeyFactory.DH", "DiffieHellman"); // Message Digests put("MessageDigest.SHA", gnu.java.security.provider.SHA.class.getName()); Index: gnu/java/security/provider/DiffieHellmanKeyFactoryImpl.java =================================================================== RCS file: gnu/java/security/provider/DiffieHellmanKeyFactoryImpl.java diff -N gnu/java/security/provider/DiffieHellmanKeyFactoryImpl.java --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ gnu/java/security/provider/DiffieHellmanKeyFactoryImpl.java 25 Sep 2005 21:38:12 -0000 @@ -0,0 +1,123 @@ +/* DiffieHellmanKeyFactoryImpl.java -- + Copyright (C) 2005 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + + +package gnu.java.security.provider; + +import gnu.javax.crypto.GnuDHPrivateKey; + +import java.security.InvalidKeyException; +import java.security.Key; +import java.security.KeyFactorySpi; +import java.security.PrivateKey; +import java.security.PublicKey; +import java.security.spec.InvalidKeySpecException; +import java.security.spec.KeySpec; + +import javax.crypto.spec.DHParameterSpec; +import javax.crypto.spec.DHPrivateKeySpec; +import javax.crypto.spec.DHPublicKeySpec; + +import javax.crypto.interfaces.DHPrivateKey; +import javax.crypto.interfaces.DHPublicKey; + +public class DiffieHellmanKeyFactoryImpl extends KeyFactorySpi +{ + protected PrivateKey engineGeneratePrivate (final KeySpec spec) + throws InvalidKeySpecException + { + if (spec instanceof DHPrivateKeySpec) + { + DHPrivateKeySpec dh = (DHPrivateKeySpec) spec; + return new GnuDHPrivateKey (dh.getX (), + new DHParameterSpec (dh.getP (), dh.getG ())); + } + throw new InvalidKeySpecException (); + } + + protected PublicKey engineGeneratePublic (final KeySpec spec) + throws InvalidKeySpecException + { + if (spec instanceof DHPublicKeySpec) + { + DHPublicKeySpec dh = (DHPublicKeySpec) spec; + return new GnuDHPublicKey (new DHParameterSpec (dh.getP (), dh.getG ()), + dh.getY(), null); + } + throw new InvalidKeySpecException (); + } + + protected KeySpec engineGetKeySpec (final Key key, final Class specClass) + throws InvalidKeySpecException + { + if (key instanceof DHPrivateKey) + { + if (DHPrivateKeySpec.class.isAssignableFrom (specClass)) + { + DHParameterSpec params = ((DHPrivateKey) key).getParams (); + return new DHPrivateKeySpec (((DHPrivateKey) key).getX (), + params.getP (), params.getG ()); + } + } + if (key instanceof DHPublicKey) + { + if (DHPublicKeySpec.class.isAssignableFrom (specClass)) + { + DHParameterSpec params = ((DHPublicKey) key).getParams (); + return new DHPublicKeySpec (((DHPublicKey) key).getY (), + params.getP (), params.getG ()); + } + } + throw new InvalidKeySpecException (); + } + + protected Key engineTranslateKey (final Key key) + throws InvalidKeyException + { + if (key instanceof DHPrivateKey) + { + return new GnuDHPrivateKey (((DHPrivateKey) key).getX (), + ((DHPrivateKey) key).getParams ()); + } + if (key instanceof DHPublicKey) + { + return new GnuDHPublicKey (((DHPublicKey) key).getParams (), + ((DHPublicKey) key).getY (), null); + } + throw new InvalidKeyException (); + } +} Index: gnu/java/security/provider/DiffieHellmanKeyPairGeneratorImpl.java =================================================================== RCS file: gnu/java/security/provider/DiffieHellmanKeyPairGeneratorImpl.java diff -N gnu/java/security/provider/DiffieHellmanKeyPairGeneratorImpl.java --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ gnu/java/security/provider/DiffieHellmanKeyPairGeneratorImpl.java 25 Sep 2005 21:38:12 -0000 @@ -0,0 +1,86 @@ +/* DiffieHellmanKeyPairGeneratorImpl.java -- + Copyright (C) 2005 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + + +package gnu.java.security.provider; + +import gnu.javax.crypto.GnuDHPrivateKey; + +import java.math.BigInteger; + +import java.security.KeyPair; +import java.security.KeyPairGeneratorSpi; +import java.security.SecureRandom; +import java.security.spec.AlgorithmParameterSpec; + +import javax.crypto.spec.DHParameterSpec; + +public class DiffieHellmanKeyPairGeneratorImpl extends KeyPairGeneratorSpi +{ + private SecureRandom random; + private DHParameterSpec params; + + public KeyPair generateKeyPair () + { + if (params == null || random == null) + throw new IllegalStateException ("not initialized"); + byte[] buf = new byte[(params.getP ().bitLength() >>> 3)]; + random.nextBytes (buf); + BigInteger x = new BigInteger (1, buf); + BigInteger y = params.getG ().modPow (x, params.getP ()); + GnuDHPublicKey pub = new GnuDHPublicKey (params, y, null); + GnuDHPrivateKey priv = new GnuDHPrivateKey (x, params); + + return new KeyPair (pub, priv); + } + + public void initialize (final int keysize, final SecureRandom random) + { + throw new UnsupportedOperationException ("key generation without parameters not supported"); + } + + public void initialize (final AlgorithmParameterSpec params, + final SecureRandom random) + { + if (!(params instanceof DHParameterSpec)) + throw new IllegalArgumentException ("expecting Diffie-Hellman parameters"); + this.params = (DHParameterSpec) params; + this.random = random; + if (this.random == null) + this.random = new SecureRandom (); + } +}