plugins/org.eclipse.net4j.util/src/org/eclipse/net4j/util/security/DiffieHellman.java - cdo/cdo - Git at Google

 /*
  * Copyright (c) 2012-2015 Eike Stepper (Berlin, Germany) and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *    Eike Stepper - initial API and implementation
  */
 package org.eclipse.net4j.util.security;

 import org.eclipse.net4j.util.io.ExtendedDataInput;
 import org.eclipse.net4j.util.io.ExtendedDataOutput;
 import org.eclipse.net4j.util.io.IORuntimeException;

 import javax.crypto.Cipher;
 import javax.crypto.KeyAgreement;
 import javax.crypto.SecretKey;
 import javax.crypto.interfaces.DHPublicKey;
 import javax.crypto.spec.DHParameterSpec;

 import java.io.IOException;
 import java.math.BigInteger;
 import java.security.AlgorithmParameterGenerator;
 import java.security.AlgorithmParameters;
 import java.security.GeneralSecurityException;
 import java.security.KeyFactory;
 import java.security.KeyPair;
 import java.security.KeyPairGenerator;
 import java.security.PrivateKey;
 import java.security.PublicKey;
 import java.security.spec.X509EncodedKeySpec;

 /**
  * Executes the Diffie-Hellman key agreement protocol between 2 parties: {@link Server} and {@link Client}.
  *
  * @author Eike Stepper
  * @since 3.3
  */
 public class DiffieHellman
 {
   /**
    * Executes the server-side of the Diffie-Hellman key agreement protocol.
    *
    * @author Eike Stepper
    */
   public static class Server
   {
     public static final String DEFAULT_SECRET_ALGORITHM = "DES";

     public static final String DEFAULT_CYPHER_TRANSFORMATION = "DES/CBC/PKCS5Padding";

     private final String realm;

     private final PrivateKey privateKey;

     private final Challenge challenge;

     public Server(String realm, DHParameterSpec dhParamSpec, String secretAlgorithm, String cypherTransformation)
     {
       this.realm = realm;

       try
       {
         // Create DH key pair, using the passed DH parameters
         KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("DH");
         keyPairGenerator.initialize(dhParamSpec);
         KeyPair keyPair = keyPairGenerator.generateKeyPair();

         privateKey = keyPair.getPrivate();

         // Encode public key
         byte[] pubKeyEnc = keyPair.getPublic().getEncoded();

         // Create and remember Challenge object
         challenge = new Challenge(realm, secretAlgorithm, cypherTransformation, pubKeyEnc);
       }
       catch (GeneralSecurityException ex)
       {
         throw new SecurityException(ex);
       }
     }

     public Server(String realm, DHParameterSpec dhParamSpec)
     {
       this(realm, dhParamSpec, DEFAULT_SECRET_ALGORITHM, DEFAULT_CYPHER_TRANSFORMATION);
     }

     public Server(String realm)
     {
       this(realm, SkipParameterSpec.INSTANCE);
     }

     public final String getRealm()
     {
       return realm;
     }

     public final Challenge getChallenge()
     {
       return challenge;
     }

     public byte[] handleResponse(Client.Response response)
     {
       try
       {
         // Instantiate a DH public key from the client's encoded key material.
         KeyFactory keyFactory = KeyFactory.getInstance("DH");
         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(response.getClientPubKeyEnc());
         PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);

         // Create and initialize DH KeyAgreement object
         KeyAgreement keyAgree = KeyAgreement.getInstance("DH");
         keyAgree.init(privateKey);

         // Use Client's public key for the first (and only) phase of her version of the DH protocol.
         keyAgree.doPhase(pubKey, true);
         SecretKey sharedSecret = keyAgree.generateSecret(challenge.getSecretAlgorithm());

         // Prepare the cipher used to decrypt
         Cipher serverCipher = Cipher.getInstance(challenge.getCypherTransformation());

         byte[] encodedParams = response.getParamsEnc();
         if (encodedParams == null)
         {
           serverCipher.init(Cipher.DECRYPT_MODE, sharedSecret);
         }
         else
         {
           // Instantiate AlgorithmParameters object from parameter encoding obtained from client
           AlgorithmParameters params = AlgorithmParameters.getInstance(challenge.getSecretAlgorithm());
           params.init(encodedParams);

           serverCipher.init(Cipher.DECRYPT_MODE, sharedSecret, params);
         }

         // Decrypt
         return serverCipher.doFinal(response.getCipherText());
       }
       catch (GeneralSecurityException ex)
       {
         throw new SecurityException(ex);
       }
       catch (IOException ex)
       {
         throw new IORuntimeException(ex);
       }
     }

     /**
      * @author Eike Stepper
      */
     public static final class Challenge
     {
       private final String serverRealm;

       private final String secretAlgorithm;

       private final String cypherTransformation;

       private final byte[] serverPubKeyEnc;

       public Challenge(String serverRealm, String secretAlgorithm, String cypherTransformation, byte[] serverPubKeyEnc)
       {
         this.serverRealm = serverRealm;
         this.secretAlgorithm = secretAlgorithm;
         this.cypherTransformation = cypherTransformation;
         this.serverPubKeyEnc = serverPubKeyEnc;
       }

       public Challenge(ExtendedDataInput in) throws IOException
       {
         serverRealm = in.readString();
         secretAlgorithm = in.readString();
         cypherTransformation = in.readString();
         serverPubKeyEnc = in.readByteArray();
       }

       public void write(ExtendedDataOutput out) throws IOException
       {
         out.writeString(serverRealm);
         out.writeString(secretAlgorithm);
         out.writeString(cypherTransformation);
         out.writeByteArray(serverPubKeyEnc);
       }

       public String getServerRealm()
       {
         return serverRealm;
       }

       public String getSecretAlgorithm()
       {
         return secretAlgorithm;
       }

       public String getCypherTransformation()
       {
         return cypherTransformation;
       }

       public byte[] getServerPubKeyEnc()
       {
         return serverPubKeyEnc;
       }
     }
   }

   /**
    * Executes the client-side of the Diffie-Hellman key agreement protocol.
    *
    * @author Eike Stepper
    */
   public static class Client
   {
     public Client()
     {
     }

     public Response handleChallenge(Server.Challenge challenge, byte[] clearText)
     {
       try
       {
         KeyFactory keyFactory = KeyFactory.getInstance("DH");
         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(challenge.getServerPubKeyEnc());
         PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);

         // Use the DH parameters associated with the server's public key to generate own key pair
         DHParameterSpec dhParamSpec = ((DHPublicKey)pubKey).getParams();

         // Create own DH key pair
         KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("DH");
         keyPairGenerator.initialize(dhParamSpec);
         KeyPair keyPair = keyPairGenerator.generateKeyPair();

         // Create and initialize DH KeyAgreement object
         KeyAgreement clientKeyAgree = KeyAgreement.getInstance("DH");
         clientKeyAgree.init(keyPair.getPrivate());

         // Encode public key
         byte[] pubKeyEnc = keyPair.getPublic().getEncoded();

         // Use server's public key for the first (and only) phase of his version of the DH protocol
         clientKeyAgree.doPhase(pubKey, true);
         SecretKey sharedSecret = clientKeyAgree.generateSecret(challenge.getSecretAlgorithm());

         // Encrypt
         Cipher clientCipher = Cipher.getInstance(challenge.getCypherTransformation());
         clientCipher.init(Cipher.ENCRYPT_MODE, sharedSecret);
         byte[] ciphertext = clientCipher.doFinal(clearText);

         // Retrieve the parameter that was used, and transfer it to the server in encoded format
         AlgorithmParameters params = clientCipher.getParameters();
         byte[] paramsEnc = params == null ? null : params.getEncoded();

         return new Response(pubKeyEnc, ciphertext, paramsEnc);
       }
       catch (GeneralSecurityException ex)
       {
         throw new SecurityException(ex);
       }
       catch (IOException ex)
       {
         throw new IORuntimeException(ex);
       }
     }

     /**
      * @author Eike Stepper
      */
     public static final class Response
     {
       private final byte[] clientPubKeyEnc;

       private final byte[] cipherText;

       private final byte[] paramsEnc;

       public Response(byte[] clientPubKeyEnc, byte[] cipherText, byte[] paramsEnc)
       {
         this.clientPubKeyEnc = clientPubKeyEnc;
         this.cipherText = cipherText;
         this.paramsEnc = paramsEnc;
       }

       public Response(ExtendedDataInput in) throws IOException
       {
         clientPubKeyEnc = in.readByteArray();
         cipherText = in.readByteArray();
         paramsEnc = in.readByteArray();
       }

       public void write(ExtendedDataOutput out) throws IOException
       {
         out.writeByteArray(clientPubKeyEnc);
         out.writeByteArray(cipherText);
         out.writeByteArray(paramsEnc);
       }

       public byte[] getClientPubKeyEnc()
       {
         return clientPubKeyEnc;
       }

       public byte[] getCipherText()
       {
         return cipherText;
       }

       public byte[] getParamsEnc()
       {
         return paramsEnc;
       }
     }
   }

   /**
    * @author Eike Stepper
    */
   public static final class SkipParameterSpec
   {
     /**
      * The 1024 bit Diffie-Hellman modulus values used by SKIP
      */
     private static final byte skip1024ModulusBytes[] = { (byte)0xF4, (byte)0x88, (byte)0xFD, (byte)0x58, (byte)0x4E,
       (byte)0x49, (byte)0xDB, (byte)0xCD, (byte)0x20, (byte)0xB4, (byte)0x9D, (byte)0xE4, (byte)0x91, (byte)0x07,
       (byte)0x36, (byte)0x6B, (byte)0x33, (byte)0x6C, (byte)0x38, (byte)0x0D, (byte)0x45, (byte)0x1D, (byte)0x0F,
       (byte)0x7C, (byte)0x88, (byte)0xB3, (byte)0x1C, (byte)0x7C, (byte)0x5B, (byte)0x2D, (byte)0x8E, (byte)0xF6,
       (byte)0xF3, (byte)0xC9, (byte)0x23, (byte)0xC0, (byte)0x43, (byte)0xF0, (byte)0xA5, (byte)0x5B, (byte)0x18,
       (byte)0x8D, (byte)0x8E, (byte)0xBB, (byte)0x55, (byte)0x8C, (byte)0xB8, (byte)0x5D, (byte)0x38, (byte)0xD3,
       (byte)0x34, (byte)0xFD, (byte)0x7C, (byte)0x17, (byte)0x57, (byte)0x43, (byte)0xA3, (byte)0x1D, (byte)0x18,
       (byte)0x6C, (byte)0xDE, (byte)0x33, (byte)0x21, (byte)0x2C, (byte)0xB5, (byte)0x2A, (byte)0xFF, (byte)0x3C,
       (byte)0xE1, (byte)0xB1, (byte)0x29, (byte)0x40, (byte)0x18, (byte)0x11, (byte)0x8D, (byte)0x7C, (byte)0x84,
       (byte)0xA7, (byte)0x0A, (byte)0x72, (byte)0xD6, (byte)0x86, (byte)0xC4, (byte)0x03, (byte)0x19, (byte)0xC8,
       (byte)0x07, (byte)0x29, (byte)0x7A, (byte)0xCA, (byte)0x95, (byte)0x0C, (byte)0xD9, (byte)0x96, (byte)0x9F,
       (byte)0xAB, (byte)0xD0, (byte)0x0A, (byte)0x50, (byte)0x9B, (byte)0x02, (byte)0x46, (byte)0xD3, (byte)0x08,
       (byte)0x3D, (byte)0x66, (byte)0xA4, (byte)0x5D, (byte)0x41, (byte)0x9F, (byte)0x9C, (byte)0x7C, (byte)0xBD,
       (byte)0x89, (byte)0x4B, (byte)0x22, (byte)0x19, (byte)0x26, (byte)0xBA, (byte)0xAB, (byte)0xA2, (byte)0x5E,
       (byte)0xC3, (byte)0x55, (byte)0xE9, (byte)0x2F, (byte)0x78, (byte)0xC7 };

     /**
      * The SKIP 1024 bit modulus
      */
     private static final BigInteger skip1024Modulus = new BigInteger(1, skip1024ModulusBytes);

     /**
      * The base used with the SKIP 1024 bit modulus
      */
     private static final BigInteger skip1024Base = BigInteger.valueOf(2);

     public static final DHParameterSpec INSTANCE = new DHParameterSpec(skip1024Modulus, skip1024Base);
   }

   /**
    * Creates Diffie-Hellman parameters.
    *
    * @author Eike Stepper
    */
   public static final class ParameterSpecGenerator
   {
     /**
      * Create Diffie-Hellman parameters.
      * <p>
      * Takes VERY long...
      */
     public static DHParameterSpec generate(int bits)
     {
       try
       {
         AlgorithmParameterGenerator paramGen = AlgorithmParameterGenerator.getInstance("DH");
         paramGen.init(bits);

         AlgorithmParameters params = paramGen.generateParameters();
         return params.getParameterSpec(DHParameterSpec.class);
       }
       catch (GeneralSecurityException ex)
       {
         throw new SecurityException(ex);
       }
     }
   }
 }
	/*
	* Copyright (c) 2012-2015 Eike Stepper (Berlin, Germany) and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* Eike Stepper - initial API and implementation
	*/
	package org.eclipse.net4j.util.security;

	import org.eclipse.net4j.util.io.ExtendedDataInput;
	import org.eclipse.net4j.util.io.ExtendedDataOutput;
	import org.eclipse.net4j.util.io.IORuntimeException;

	import javax.crypto.Cipher;
	import javax.crypto.KeyAgreement;
	import javax.crypto.SecretKey;
	import javax.crypto.interfaces.DHPublicKey;
	import javax.crypto.spec.DHParameterSpec;

	import java.io.IOException;
	import java.math.BigInteger;
	import java.security.AlgorithmParameterGenerator;
	import java.security.AlgorithmParameters;
	import java.security.GeneralSecurityException;
	import java.security.KeyFactory;
	import java.security.KeyPair;
	import java.security.KeyPairGenerator;
	import java.security.PrivateKey;
	import java.security.PublicKey;
	import java.security.spec.X509EncodedKeySpec;

	/**
	* Executes the Diffie-Hellman key agreement protocol between 2 parties: {@link Server} and {@link Client}.
	*
	* @author Eike Stepper
	* @since 3.3
	*/
	public class DiffieHellman
	{
	/**
	* Executes the server-side of the Diffie-Hellman key agreement protocol.
	*
	* @author Eike Stepper
	*/
	public static class Server
	{
	public static final String DEFAULT_SECRET_ALGORITHM = "DES";

	public static final String DEFAULT_CYPHER_TRANSFORMATION = "DES/CBC/PKCS5Padding";

	private final String realm;

	private final PrivateKey privateKey;

	private final Challenge challenge;

	public Server(String realm, DHParameterSpec dhParamSpec, String secretAlgorithm, String cypherTransformation)
	{
	this.realm = realm;

	try
	{
	// Create DH key pair, using the passed DH parameters
	KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("DH");
	keyPairGenerator.initialize(dhParamSpec);
	KeyPair keyPair = keyPairGenerator.generateKeyPair();

	privateKey = keyPair.getPrivate();

	// Encode public key
	byte[] pubKeyEnc = keyPair.getPublic().getEncoded();

	// Create and remember Challenge object
	challenge = new Challenge(realm, secretAlgorithm, cypherTransformation, pubKeyEnc);
	}
	catch (GeneralSecurityException ex)
	{
	throw new SecurityException(ex);
	}
	}

	public Server(String realm, DHParameterSpec dhParamSpec)
	{
	this(realm, dhParamSpec, DEFAULT_SECRET_ALGORITHM, DEFAULT_CYPHER_TRANSFORMATION);
	}

	public Server(String realm)
	{
	this(realm, SkipParameterSpec.INSTANCE);
	}

	public final String getRealm()
	{
	return realm;
	}

	public final Challenge getChallenge()
	{
	return challenge;
	}

	public byte[] handleResponse(Client.Response response)
	{
	try
	{
	// Instantiate a DH public key from the client's encoded key material.
	KeyFactory keyFactory = KeyFactory.getInstance("DH");
	X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(response.getClientPubKeyEnc());
	PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);

	// Create and initialize DH KeyAgreement object
	KeyAgreement keyAgree = KeyAgreement.getInstance("DH");
	keyAgree.init(privateKey);

	// Use Client's public key for the first (and only) phase of her version of the DH protocol.
	keyAgree.doPhase(pubKey, true);
	SecretKey sharedSecret = keyAgree.generateSecret(challenge.getSecretAlgorithm());

	// Prepare the cipher used to decrypt
	Cipher serverCipher = Cipher.getInstance(challenge.getCypherTransformation());

	byte[] encodedParams = response.getParamsEnc();
	if (encodedParams == null)
	{
	serverCipher.init(Cipher.DECRYPT_MODE, sharedSecret);
	}
	else
	{
	// Instantiate AlgorithmParameters object from parameter encoding obtained from client
	AlgorithmParameters params = AlgorithmParameters.getInstance(challenge.getSecretAlgorithm());
	params.init(encodedParams);

	serverCipher.init(Cipher.DECRYPT_MODE, sharedSecret, params);
	}

	// Decrypt
	return serverCipher.doFinal(response.getCipherText());
	}
	catch (GeneralSecurityException ex)
	{
	throw new SecurityException(ex);
	}
	catch (IOException ex)
	{
	throw new IORuntimeException(ex);
	}
	}

	/**
	* @author Eike Stepper
	*/
	public static final class Challenge
	{
	private final String serverRealm;

	private final String secretAlgorithm;

	private final String cypherTransformation;

	private final byte[] serverPubKeyEnc;

	public Challenge(String serverRealm, String secretAlgorithm, String cypherTransformation, byte[] serverPubKeyEnc)
	{
	this.serverRealm = serverRealm;
	this.secretAlgorithm = secretAlgorithm;
	this.cypherTransformation = cypherTransformation;
	this.serverPubKeyEnc = serverPubKeyEnc;
	}

	public Challenge(ExtendedDataInput in) throws IOException
	{
	serverRealm = in.readString();
	secretAlgorithm = in.readString();
	cypherTransformation = in.readString();
	serverPubKeyEnc = in.readByteArray();
	}

	public void write(ExtendedDataOutput out) throws IOException
	{
	out.writeString(serverRealm);
	out.writeString(secretAlgorithm);
	out.writeString(cypherTransformation);
	out.writeByteArray(serverPubKeyEnc);
	}

	public String getServerRealm()
	{
	return serverRealm;
	}

	public String getSecretAlgorithm()
	{
	return secretAlgorithm;
	}

	public String getCypherTransformation()
	{
	return cypherTransformation;
	}

	public byte[] getServerPubKeyEnc()
	{
	return serverPubKeyEnc;
	}
	}
	}

	/**
	* Executes the client-side of the Diffie-Hellman key agreement protocol.
	*
	* @author Eike Stepper
	*/
	public static class Client
	{
	public Client()
	{
	}

	public Response handleChallenge(Server.Challenge challenge, byte[] clearText)
	{
	try
	{
	KeyFactory keyFactory = KeyFactory.getInstance("DH");
	X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(challenge.getServerPubKeyEnc());
	PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);

	// Use the DH parameters associated with the server's public key to generate own key pair
	DHParameterSpec dhParamSpec = ((DHPublicKey)pubKey).getParams();

	// Create own DH key pair
	KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("DH");
	keyPairGenerator.initialize(dhParamSpec);
	KeyPair keyPair = keyPairGenerator.generateKeyPair();

	// Create and initialize DH KeyAgreement object
	KeyAgreement clientKeyAgree = KeyAgreement.getInstance("DH");
	clientKeyAgree.init(keyPair.getPrivate());

	// Encode public key
	byte[] pubKeyEnc = keyPair.getPublic().getEncoded();

	// Use server's public key for the first (and only) phase of his version of the DH protocol
	clientKeyAgree.doPhase(pubKey, true);
	SecretKey sharedSecret = clientKeyAgree.generateSecret(challenge.getSecretAlgorithm());

	// Encrypt
	Cipher clientCipher = Cipher.getInstance(challenge.getCypherTransformation());
	clientCipher.init(Cipher.ENCRYPT_MODE, sharedSecret);
	byte[] ciphertext = clientCipher.doFinal(clearText);

	// Retrieve the parameter that was used, and transfer it to the server in encoded format
	AlgorithmParameters params = clientCipher.getParameters();
	byte[] paramsEnc = params == null ? null : params.getEncoded();

	return new Response(pubKeyEnc, ciphertext, paramsEnc);
	}
	catch (GeneralSecurityException ex)
	{
	throw new SecurityException(ex);
	}
	catch (IOException ex)
	{
	throw new IORuntimeException(ex);
	}
	}

	/**
	* @author Eike Stepper
	*/
	public static final class Response
	{
	private final byte[] clientPubKeyEnc;

	private final byte[] cipherText;

	private final byte[] paramsEnc;

	public Response(byte[] clientPubKeyEnc, byte[] cipherText, byte[] paramsEnc)
	{
	this.clientPubKeyEnc = clientPubKeyEnc;
	this.cipherText = cipherText;
	this.paramsEnc = paramsEnc;
	}

	public Response(ExtendedDataInput in) throws IOException
	{
	clientPubKeyEnc = in.readByteArray();
	cipherText = in.readByteArray();
	paramsEnc = in.readByteArray();
	}

	public void write(ExtendedDataOutput out) throws IOException
	{
	out.writeByteArray(clientPubKeyEnc);
	out.writeByteArray(cipherText);
	out.writeByteArray(paramsEnc);
	}

	public byte[] getClientPubKeyEnc()
	{
	return clientPubKeyEnc;
	}

	public byte[] getCipherText()
	{
	return cipherText;
	}

	public byte[] getParamsEnc()
	{
	return paramsEnc;
	}
	}
	}

	/**
	* @author Eike Stepper
	*/
	public static final class SkipParameterSpec
	{
	/**
	* The 1024 bit Diffie-Hellman modulus values used by SKIP
	*/
	private static final byte skip1024ModulusBytes[] = { (byte)0xF4, (byte)0x88, (byte)0xFD, (byte)0x58, (byte)0x4E,
	(byte)0x49, (byte)0xDB, (byte)0xCD, (byte)0x20, (byte)0xB4, (byte)0x9D, (byte)0xE4, (byte)0x91, (byte)0x07,
	(byte)0x36, (byte)0x6B, (byte)0x33, (byte)0x6C, (byte)0x38, (byte)0x0D, (byte)0x45, (byte)0x1D, (byte)0x0F,
	(byte)0x7C, (byte)0x88, (byte)0xB3, (byte)0x1C, (byte)0x7C, (byte)0x5B, (byte)0x2D, (byte)0x8E, (byte)0xF6,
	(byte)0xF3, (byte)0xC9, (byte)0x23, (byte)0xC0, (byte)0x43, (byte)0xF0, (byte)0xA5, (byte)0x5B, (byte)0x18,
	(byte)0x8D, (byte)0x8E, (byte)0xBB, (byte)0x55, (byte)0x8C, (byte)0xB8, (byte)0x5D, (byte)0x38, (byte)0xD3,
	(byte)0x34, (byte)0xFD, (byte)0x7C, (byte)0x17, (byte)0x57, (byte)0x43, (byte)0xA3, (byte)0x1D, (byte)0x18,
	(byte)0x6C, (byte)0xDE, (byte)0x33, (byte)0x21, (byte)0x2C, (byte)0xB5, (byte)0x2A, (byte)0xFF, (byte)0x3C,
	(byte)0xE1, (byte)0xB1, (byte)0x29, (byte)0x40, (byte)0x18, (byte)0x11, (byte)0x8D, (byte)0x7C, (byte)0x84,
	(byte)0xA7, (byte)0x0A, (byte)0x72, (byte)0xD6, (byte)0x86, (byte)0xC4, (byte)0x03, (byte)0x19, (byte)0xC8,
	(byte)0x07, (byte)0x29, (byte)0x7A, (byte)0xCA, (byte)0x95, (byte)0x0C, (byte)0xD9, (byte)0x96, (byte)0x9F,
	(byte)0xAB, (byte)0xD0, (byte)0x0A, (byte)0x50, (byte)0x9B, (byte)0x02, (byte)0x46, (byte)0xD3, (byte)0x08,
	(byte)0x3D, (byte)0x66, (byte)0xA4, (byte)0x5D, (byte)0x41, (byte)0x9F, (byte)0x9C, (byte)0x7C, (byte)0xBD,
	(byte)0x89, (byte)0x4B, (byte)0x22, (byte)0x19, (byte)0x26, (byte)0xBA, (byte)0xAB, (byte)0xA2, (byte)0x5E,
	(byte)0xC3, (byte)0x55, (byte)0xE9, (byte)0x2F, (byte)0x78, (byte)0xC7 };

	/**
	* The SKIP 1024 bit modulus
	*/
	private static final BigInteger skip1024Modulus = new BigInteger(1, skip1024ModulusBytes);

	/**
	* The base used with the SKIP 1024 bit modulus
	*/
	private static final BigInteger skip1024Base = BigInteger.valueOf(2);

	public static final DHParameterSpec INSTANCE = new DHParameterSpec(skip1024Modulus, skip1024Base);
	}

	/**
	* Creates Diffie-Hellman parameters.
	*
	* @author Eike Stepper
	*/
	public static final class ParameterSpecGenerator
	{
	/**
	* Create Diffie-Hellman parameters.
	* <p>
	* Takes VERY long...
	*/
	public static DHParameterSpec generate(int bits)
	{
	try
	{
	AlgorithmParameterGenerator paramGen = AlgorithmParameterGenerator.getInstance("DH");
	paramGen.init(bits);

	AlgorithmParameters params = paramGen.generateParameters();
	return params.getParameterSpec(DHParameterSpec.class);
	}
	catch (GeneralSecurityException ex)
	{
	throw new SecurityException(ex);
	}
	}
	}
	}