libjava/classpath/java/security/KeyPairGenerator.java

   1 /* KeyPairGenerator.java --- Key Pair Generator Class
   2    Copyright (C) 1999, 2002, 2003, 2004, 2005  Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 02110-1301 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package java.security;
  40
  41 import gnu.java.lang.CPStringBuilder;
  42
  43 import gnu.java.security.Engine;
  44
  45 import java.lang.reflect.InvocationTargetException;
  46 import java.security.spec.AlgorithmParameterSpec;
  47
  48 /**
  49  * <code>KeyPairGenerator</code> is a class used to generate key-pairs for a
  50  * security algorithm.
  51  *
  52  * <p>The <code>KeyPairGenerator</code> is created with the
  53  * <code>getInstance()</code> Factory methods. It is used to generate a pair of
  54  * public and private keys for a specific algorithm and associate this key-pair
  55  * with the algorithm parameters it was initialized with.</p>
  56  *
  57  * @see KeyPair
  58  * @see AlgorithmParameterSpec
  59  * @author Mark Benvenuto
  60  * @author Casey Marshall
  61  */
  62 public abstract class KeyPairGenerator extends KeyPairGeneratorSpi
  63 {
  64   /** The service name for key pair generators. */
  65   private static final String KEY_PAIR_GENERATOR = "KeyPairGenerator";
  66
  67   Provider provider;
  68   private String algorithm;
  69
  70   /**
  71    * Constructs a new instance of <code>KeyPairGenerator</code>.
  72    *
  73    * @param algorithm
  74    *          the algorithm to use.
  75    */
  76   protected KeyPairGenerator(String algorithm)
  77   {
  78     this.algorithm = algorithm;
  79     this.provider = null;
  80   }
  81
  82   /**
  83    * Returns the name of the algorithm used.
  84    *
  85    * @return the name of the algorithm used.
  86    */
  87   public String getAlgorithm()
  88   {
  89     return algorithm;
  90   }
  91
  92   /**
  93    * Returns a new instance of <code>KeyPairGenerator</code> which generates
  94    * key-pairs for the specified algorithm.
  95    *
  96    * @param algorithm the name of the algorithm to use.
  97    * @return a new instance repesenting the desired algorithm.
  98    * @throws NoSuchAlgorithmException if the algorithm is not implemented by any
  99    *           provider.
 100    * @throws IllegalArgumentException if <code>algorithm</code> is
 101    *           <code>null</code> or is an empty string.
 102    */
 103   public static KeyPairGenerator getInstance(String algorithm)
 104       throws NoSuchAlgorithmException
 105   {
 106     Provider[] p = Security.getProviders();
 107     NoSuchAlgorithmException lastException = null;
 108     for (int i = 0; i < p.length; i++)
 109       try
 110         {
 111           return getInstance(algorithm, p[i]);
 112         }
 113       catch (NoSuchAlgorithmException x)
 114         {
 115           lastException = x;
 116         }
 117     if (lastException != null)
 118       throw lastException;
 119     throw new NoSuchAlgorithmException(algorithm);
 120   }
 121
 122   /**
 123    * Returns a new instance of <code>KeyPairGenerator</code> which generates
 124    * key-pairs for the specified algorithm from a named provider.
 125    *
 126    * @param algorithm the name of the algorithm to use.
 127    * @param provider the name of a {@link Provider} to use.
 128    * @return a new instance repesenting the desired algorithm.
 129    * @throws NoSuchAlgorithmException if the algorithm is not implemented by the
 130    *           named provider.
 131    * @throws NoSuchProviderException if the named provider was not found.
 132    * @throws IllegalArgumentException if either <code>algorithm</code> or
 133    *           <code>provider</code> is <code>null</code> or empty.
 134    */
 135   public static KeyPairGenerator getInstance(String algorithm, String provider)
 136       throws NoSuchAlgorithmException, NoSuchProviderException
 137   {
 138     if (provider == null)
 139       throw new IllegalArgumentException("provider MUST NOT be null");
 140     provider = provider.trim();
 141     if (provider.length() == 0)
 142       throw new IllegalArgumentException("provider MUST NOT be empty");
 143     Provider p = Security.getProvider(provider);
 144     if (p == null)
 145       throw new NoSuchProviderException(provider);
 146     return getInstance(algorithm, p);
 147   }
 148
 149   /**
 150    * Returns a new instance of <code>KeyPairGenerator</code> which generates
 151    * key-pairs for the specified algorithm from a designated {@link Provider}.
 152    *
 153    * @param algorithm
 154    *          the name of the algorithm to use.
 155    * @param provider
 156    *          the {@link Provider} to use.
 157    * @return a new insatnce repesenting the desired algorithm.
 158    * @throws NoSuchAlgorithmException
 159    *           if the algorithm is not implemented by the {@link Provider}.
 160    * @throws IllegalArgumentException if either <code>algorithm</code> or
 161    *           <code>provider</code> is <code>null</code>, or if
 162    *           <code>algorithm</code> is an empty string.
 163    * @since 1.4
 164    * @see Provider
 165    */
 166   public static KeyPairGenerator getInstance(String algorithm,
 167                                              Provider provider)
 168     throws NoSuchAlgorithmException
 169   {
 170     CPStringBuilder sb = new CPStringBuilder("KeyPairGenerator for algorithm [")
 171         .append(algorithm).append("] from provider[")
 172         .append(provider).append("] ");
 173     Object o;
 174     try
 175       {
 176         o = Engine.getInstance(KEY_PAIR_GENERATOR, algorithm, provider);
 177       }
 178     catch (InvocationTargetException x)
 179       {
 180         Throwable cause = x.getCause();
 181         if (cause instanceof NoSuchAlgorithmException)
 182           throw (NoSuchAlgorithmException) cause;
 183         if (cause == null)
 184           cause = x;
 185         sb.append("could not be created");
 186         NoSuchAlgorithmException y = new NoSuchAlgorithmException(sb.toString());
 187         y.initCause(cause);
 188         throw y;
 189       }
 190     KeyPairGenerator result;
 191     if (o instanceof KeyPairGenerator)
 192       {
 193         result = (KeyPairGenerator) o;
 194         result.algorithm = algorithm;
 195       }
 196     else if (o instanceof KeyPairGeneratorSpi)
 197       result = new DummyKeyPairGenerator((KeyPairGeneratorSpi) o, algorithm);
 198     else
 199       {
 200         sb.append("is of an unexpected Type: ").append(o.getClass().getName());
 201         throw new NoSuchAlgorithmException(sb.toString());
 202       }
 203     result.provider = provider;
 204     return result;
 205   }
 206
 207   /**
 208    * Returns the {@link Provider} of this instance.
 209    *
 210    * @return the {@link Provider} of this instance.
 211    */
 212   public final Provider getProvider()
 213   {
 214     return provider;
 215   }
 216
 217   /**
 218    * Initializes this instance for the specified key size. Since no source of
 219    * randomness is specified, a default one will be used.
 220    *
 221    * @param keysize
 222    *          the size of keys to use.
 223    */
 224   public void initialize(int keysize)
 225   {
 226     initialize(keysize, new SecureRandom());
 227   }
 228
 229   /**
 230    * Initializes this instance for the specified key size and
 231    * {@link SecureRandom}.
 232    *
 233    * @param keysize
 234    *          the size of keys to use.
 235    * @param random
 236    *          the {@link SecureRandom} to use.
 237    * @since 1.2
 238    */
 239   public void initialize(int keysize, SecureRandom random)
 240   {
 241   }
 242
 243   /**
 244    * Initializes this instance with the specified
 245    * {@link AlgorithmParameterSpec}. Since no source of randomness is specified,
 246    * a default one will be used.
 247    *
 248    * @param params
 249    *          the {@link AlgorithmParameterSpec} to use.
 250    * @throws InvalidAlgorithmParameterException
 251    *           if the designated specifications are invalid.
 252    * @since 1.2
 253    */
 254   public void initialize(AlgorithmParameterSpec params)
 255     throws InvalidAlgorithmParameterException
 256   {
 257     initialize(params, new SecureRandom());
 258   }
 259
 260   /**
 261    * Initializes this instance with the specified {@link AlgorithmParameterSpec}
 262    * and {@link SecureRandom}.
 263    *
 264    * @param params
 265    *          the {@link AlgorithmParameterSpec} to use.
 266    * @param random
 267    *          the {@link SecureRandom} to use.
 268    * @throws InvalidAlgorithmParameterException
 269    *           if the designated specifications are invalid.
 270    * @since 1.2
 271    */
 272   public void initialize(AlgorithmParameterSpec params, SecureRandom random)
 273     throws InvalidAlgorithmParameterException
 274   {
 275     super.initialize(params, random);
 276   }
 277
 278   /**
 279    * Generates a new "DSA" {@link KeyPair} from the "GNU" security provider.
 280    *
 281    * <p>This method generates a unique key-pair each time it is called.</p>
 282    *
 283    * @return a new unique {@link KeyPair}.
 284    * @see #generateKeyPair()
 285    * @since 1.2
 286    */
 287   public final KeyPair genKeyPair()
 288   {
 289     try
 290       {
 291         return getInstance("DSA", "GNU").generateKeyPair();
 292       }
 293     catch (Exception e)
 294       {
 295         System.err.println("genKeyPair failed: " + e);
 296         e.printStackTrace();
 297         return null;
 298       }
 299   }
 300
 301   /**
 302    * Generates a new "DSA" {@link KeyPair} from the "GNU" security provider.
 303    *
 304    * <p>This method generates a unique key pair each time it is called.</p>
 305    *
 306    * @return a new unique {@link KeyPair}.
 307    * @see #genKeyPair()
 308    */
 309   public KeyPair generateKeyPair()
 310   {
 311     return genKeyPair();
 312   }
 313 }