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.security.Engine;
  42
  43 import java.lang.reflect.InvocationTargetException;
  44 import java.security.spec.AlgorithmParameterSpec;
  45
  46 /**
  47  * <code>KeyPairGenerator</code> is a class used to generate key-pairs for a
  48  * security algorithm.
  49  *
  50  * <p>The <code>KeyPairGenerator</code> is created with the
  51  * <code>getInstance()</code> Factory methods. It is used to generate a pair of
  52  * public and private keys for a specific algorithm and associate this key-pair
  53  * with the algorithm parameters it was initialized with.</p>
  54  *
  55  * @see KeyPair
  56  * @see AlgorithmParameterSpec
  57  * @author Mark Benvenuto
  58  * @author Casey Marshall
  59  */
  60 public abstract class KeyPairGenerator extends KeyPairGeneratorSpi
  61 {
  62   /** The service name for key pair generators. */
  63   private static final String KEY_PAIR_GENERATOR = "KeyPairGenerator";
  64
  65   Provider provider;
  66   private String algorithm;
  67
  68   /**
  69    * Constructs a new instance of <code>KeyPairGenerator</code>.
  70    *
  71    * @param algorithm
  72    *          the algorithm to use.
  73    */
  74   protected KeyPairGenerator(String algorithm)
  75   {
  76     this.algorithm = algorithm;
  77     this.provider = null;
  78   }
  79
  80   /**
  81    * Returns the name of the algorithm used.
  82    *
  83    * @return the name of the algorithm used.
  84    */
  85   public String getAlgorithm()
  86   {
  87     return algorithm;
  88   }
  89
  90   /**
  91    * Returns a new instance of <code>KeyPairGenerator</code> which generates
  92    * key-pairs for the specified algorithm.
  93    *
  94    * @param algorithm the name of the algorithm to use.
  95    * @return a new instance repesenting the desired algorithm.
  96    * @throws NoSuchAlgorithmException if the algorithm is not implemented by any
  97    *           provider.
  98    * @throws IllegalArgumentException if <code>algorithm</code> is
  99    *           <code>null</code> or is an empty string.
 100    */
 101   public static KeyPairGenerator getInstance(String algorithm)
 102       throws NoSuchAlgorithmException
 103   {
 104     Provider[] p = Security.getProviders();
 105     NoSuchAlgorithmException lastException = null;
 106     for (int i = 0; i < p.length; i++)
 107       try
 108         {
 109           return getInstance(algorithm, p[i]);
 110         }
 111       catch (NoSuchAlgorithmException x)
 112         {
 113           lastException = x;
 114         }
 115     if (lastException != null)
 116       throw lastException;
 117     throw new NoSuchAlgorithmException(algorithm);
 118   }
 119
 120   /**
 121    * Returns a new instance of <code>KeyPairGenerator</code> which generates
 122    * key-pairs for the specified algorithm from a named provider.
 123    *
 124    * @param algorithm the name of the algorithm to use.
 125    * @param provider the name of a {@link Provider} to use.
 126    * @return a new instance repesenting the desired algorithm.
 127    * @throws NoSuchAlgorithmException if the algorithm is not implemented by the
 128    *           named provider.
 129    * @throws NoSuchProviderException if the named provider was not found.
 130    * @throws IllegalArgumentException if either <code>algorithm</code> or
 131    *           <code>provider</code> is <code>null</code> or empty.
 132    */
 133   public static KeyPairGenerator getInstance(String algorithm, String provider)
 134       throws NoSuchAlgorithmException, NoSuchProviderException
 135   {
 136     if (provider == null)
 137       throw new IllegalArgumentException("provider MUST NOT be null");
 138     provider = provider.trim();
 139     if (provider.length() == 0)
 140       throw new IllegalArgumentException("provider MUST NOT be empty");
 141     Provider p = Security.getProvider(provider);
 142     if (p == null)
 143       throw new NoSuchProviderException(provider);
 144     return getInstance(algorithm, p);
 145   }
 146
 147   /**
 148    * Returns a new instance of <code>KeyPairGenerator</code> which generates
 149    * key-pairs for the specified algorithm from a designated {@link Provider}.
 150    *
 151    * @param algorithm
 152    *          the name of the algorithm to use.
 153    * @param provider
 154    *          the {@link Provider} to use.
 155    * @return a new insatnce repesenting the desired algorithm.
 156    * @throws NoSuchAlgorithmException
 157    *           if the algorithm is not implemented by the {@link Provider}.
 158    * @throws IllegalArgumentException if either <code>algorithm</code> or
 159    *           <code>provider</code> is <code>null</code>, or if
 160    *           <code>algorithm</code> is an empty string.
 161    * @since 1.4
 162    * @see Provider
 163    */
 164   public static KeyPairGenerator getInstance(String algorithm,
 165                                              Provider provider)
 166     throws NoSuchAlgorithmException
 167   {
 168     StringBuilder sb = new StringBuilder("KeyPairGenerator for algorithm [")
 169         .append(algorithm).append("] from provider[")
 170         .append(provider).append("] ");
 171     Object o;
 172     try
 173       {
 174         o = Engine.getInstance(KEY_PAIR_GENERATOR, algorithm, provider);
 175       }
 176     catch (InvocationTargetException x)
 177       {
 178         Throwable cause = x.getCause();
 179         if (cause instanceof NoSuchAlgorithmException)
 180           throw (NoSuchAlgorithmException) cause;
 181         if (cause == null)
 182           cause = x;
 183         sb.append("could not be created");
 184         NoSuchAlgorithmException y = new NoSuchAlgorithmException(sb.toString());
 185         y.initCause(cause);
 186         throw y;
 187       }
 188     KeyPairGenerator result;
 189     if (o instanceof KeyPairGenerator)
 190       {
 191         result = (KeyPairGenerator) o;
 192         result.algorithm = algorithm;
 193       }
 194     else if (o instanceof KeyPairGeneratorSpi)
 195       result = new DummyKeyPairGenerator((KeyPairGeneratorSpi) o, algorithm);
 196     else
 197       {
 198         sb.append("is of an unexpected Type: ").append(o.getClass().getName());
 199         throw new NoSuchAlgorithmException(sb.toString());
 200       }
 201     result.provider = provider;
 202     return result;
 203   }
 204
 205   /**
 206    * Returns the {@link Provider} of this instance.
 207    *
 208    * @return the {@link Provider} of this instance.
 209    */
 210   public final Provider getProvider()
 211   {
 212     return provider;
 213   }
 214
 215   /**
 216    * Initializes this instance for the specified key size. Since no source of
 217    * randomness is specified, a default one will be used.
 218    *
 219    * @param keysize
 220    *          the size of keys to use.
 221    */
 222   public void initialize(int keysize)
 223   {
 224     initialize(keysize, new SecureRandom());
 225   }
 226
 227   /**
 228    * Initializes this instance for the specified key size and
 229    * {@link SecureRandom}.
 230    *
 231    * @param keysize
 232    *          the size of keys to use.
 233    * @param random
 234    *          the {@link SecureRandom} to use.
 235    * @since 1.2
 236    */
 237   public void initialize(int keysize, SecureRandom random)
 238   {
 239   }
 240
 241   /**
 242    * Initializes this instance with the specified
 243    * {@link AlgorithmParameterSpec}. Since no source of randomness is specified,
 244    * a default one will be used.
 245    *
 246    * @param params
 247    *          the {@link AlgorithmParameterSpec} to use.
 248    * @throws InvalidAlgorithmParameterException
 249    *           if the designated specifications are invalid.
 250    * @since 1.2
 251    */
 252   public void initialize(AlgorithmParameterSpec params)
 253     throws InvalidAlgorithmParameterException
 254   {
 255     initialize(params, new SecureRandom());
 256   }
 257
 258   /**
 259    * Initializes this instance with the specified {@link AlgorithmParameterSpec}
 260    * and {@link SecureRandom}.
 261    *
 262    * @param params
 263    *          the {@link AlgorithmParameterSpec} to use.
 264    * @param random
 265    *          the {@link SecureRandom} to use.
 266    * @throws InvalidAlgorithmParameterException
 267    *           if the designated specifications are invalid.
 268    * @since 1.2
 269    */
 270   public void initialize(AlgorithmParameterSpec params, SecureRandom random)
 271     throws InvalidAlgorithmParameterException
 272   {
 273     super.initialize(params, random);
 274   }
 275
 276   /**
 277    * Generates a new "DSA" {@link KeyPair} from the "GNU" security provider.
 278    *
 279    * <p>This method generates a unique key-pair each time it is called.</p>
 280    *
 281    * @return a new unique {@link KeyPair}.
 282    * @see #generateKeyPair()
 283    * @since 1.2
 284    */
 285   public final KeyPair genKeyPair()
 286   {
 287     try
 288       {
 289         return getInstance("DSA", "GNU").generateKeyPair();
 290       }
 291     catch (Exception e)
 292       {
 293         System.err.println("genKeyPair failed: " + e);
 294         e.printStackTrace();
 295         return null;
 296       }
 297   }
 298
 299   /**
 300    * Generates a new "DSA" {@link KeyPair} from the "GNU" security provider.
 301    *
 302    * <p>This method generates a unique key pair each time it is called.</p>
 303    *
 304    * @return a new unique {@link KeyPair}.
 305    * @see #genKeyPair()
 306    */
 307   public KeyPair generateKeyPair()
 308   {
 309     return genKeyPair();
 310   }
 311 }