libjava/classpath/java/security/AlgorithmParameters.java

   1 /* AlgorithmParameters.java --- Algorithm Parameters Implementation Class
   2    Copyright (C) 1999, 2003, 2004  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.io.IOException;
  44 import java.lang.reflect.InvocationTargetException;
  45 import java.security.spec.AlgorithmParameterSpec;
  46 import java.security.spec.InvalidParameterSpecException;
  47
  48 /**
  49  * <code>AlgorithmParameters</code> is an Algorithm Parameters class which
  50  * provides an interface through which the user can manage the parameters of an
  51  * Algorithm.
  52  *
  53  * @author Mark Benvenuto
  54  * @since 1.2
  55  * @see AlgorithmParameterSpec
  56  * @see java.security.spec.DSAParameterSpec
  57  * @see KeyPairGenerator
  58  */
  59 public class AlgorithmParameters
  60 {
  61   /** Service name for algorithm parameters. */
  62   private static final String ALGORITHM_PARAMETERS = "AlgorithmParameters";
  63
  64   private AlgorithmParametersSpi paramSpi;
  65   private Provider provider;
  66   private String algorithm;
  67
  68   /**
  69    * Constructs a new instance of <code>AlgorithmParameters</code>.
  70    *
  71    * @param paramSpi
  72    *          the engine to use.
  73    * @param provider
  74    *          the provider to use.
  75    * @param algorithm
  76    *          the algorithm to use.
  77    */
  78   protected AlgorithmParameters(AlgorithmParametersSpi paramSpi,
  79                                 Provider provider, String algorithm)
  80   {
  81     this.paramSpi = paramSpi;
  82     this.provider = provider;
  83     this.algorithm = algorithm;
  84   }
  85
  86   /** @return A string with the name of the algorithm used. */
  87   public final String getAlgorithm()
  88   {
  89     return algorithm;
  90   }
  91
  92   /**
  93    * Returns a new instance of <code>AlgorithmParameters</code> representing
  94    * the specified algorithm parameters.
  95    * <p>
  96    * The returned <code>AlgorithmParameters</code> must still be initialized
  97    * with an <code>init()</code> method.
  98    *
  99    * @param algorithm the algorithm to use.
 100    * @return the new instance repesenting the desired algorithm.
 101    * @throws NoSuchAlgorithmException if the algorithm is not implemented by any
 102    *           provider.
 103    * @throws IllegalArgumentException if <code>algorithm</code> is
 104    *           <code>null</code> or is an empty string.
 105    */
 106   public static AlgorithmParameters getInstance(String algorithm)
 107       throws NoSuchAlgorithmException
 108   {
 109     Provider[] p = Security.getProviders();
 110     NoSuchAlgorithmException lastException = null;
 111     for (int i = 0; i < p.length; i++)
 112       try
 113         {
 114           return getInstance(algorithm, p[i]);
 115         }
 116       catch (NoSuchAlgorithmException x)
 117         {
 118           lastException = x;
 119         }
 120     if (lastException != null)
 121       throw lastException;
 122     throw new NoSuchAlgorithmException(algorithm);
 123   }
 124
 125   /**
 126    * Returns a new instance of <code>AlgorithmParameters</code> representing
 127    * the specified algorithm parameters from a named provider.
 128    * <p>
 129    * The returned <code>AlgorithmParameters</code> must still be intialized
 130    * with an <code>init()</code> method.
 131    * </p>
 132    *
 133    * @param algorithm the algorithm to use.
 134    * @param provider the name of the {@link Provider} to use.
 135    * @return the new instance repesenting the desired algorithm.
 136    * @throws NoSuchAlgorithmException if the algorithm is not implemented by the
 137    *           named provider.
 138    * @throws NoSuchProviderException if the named provider was not found.
 139    * @throws IllegalArgumentException if either <code>algorithm</code> or
 140    *           <code>provider</code> is <code>null</code> or empty.
 141    */
 142   public static AlgorithmParameters getInstance(String algorithm,
 143                                                 String provider)
 144       throws NoSuchAlgorithmException, NoSuchProviderException
 145   {
 146     if (provider == null)
 147       throw new IllegalArgumentException("provider MUST NOT be null");
 148     provider = provider.trim();
 149     if (provider.length() == 0)
 150       throw new IllegalArgumentException("provider MUST NOT be empty");
 151     Provider p = Security.getProvider(provider);
 152     if (p == null)
 153       throw new NoSuchProviderException(provider);
 154     return getInstance(algorithm, p);
 155   }
 156
 157   /**
 158    * Returns a new instance of <code>AlgorithmParameters</code> representing
 159    * the specified algorithm parameters from the specified {@link Provider}.
 160    * <p>
 161    * The returned <code>AlgorithmParameters</code> must still be intialized
 162    * with an <code>init()</code> method.
 163    *
 164    * @param algorithm the algorithm to use.
 165    * @param provider the {@link Provider} to use.
 166    * @return the new instance repesenting the desired algorithm.
 167    * @throws NoSuchAlgorithmException if the algorithm is not implemented by the
 168    *           {@link Provider}.
 169    * @throws IllegalArgumentException if either <code>algorithm</code> or
 170    *           <code>provider</code> is <code>null</code>, or if
 171    *           <code>algorithm</code> is an empty string.
 172    * @since 1.4
 173    */
 174   public static AlgorithmParameters getInstance(String algorithm,
 175                                                 Provider provider)
 176       throws NoSuchAlgorithmException
 177   {
 178     StringBuilder sb = new StringBuilder("AlgorithmParameters for algorithm [")
 179         .append(algorithm).append("] from provider[")
 180         .append(provider).append("] could not be created");
 181     Throwable cause;
 182     try
 183       {
 184         Object spi = Engine.getInstance(ALGORITHM_PARAMETERS, algorithm, provider);
 185         return new AlgorithmParameters((AlgorithmParametersSpi) spi,
 186                                        provider,
 187                                        algorithm);
 188       }
 189     catch (InvocationTargetException x)
 190       {
 191         cause = x.getCause();
 192         if (cause instanceof NoSuchAlgorithmException)
 193           throw (NoSuchAlgorithmException) cause;
 194         if (cause == null)
 195           cause = x;
 196       }
 197     catch (ClassCastException x)
 198       {
 199         cause = x;
 200       }
 201     NoSuchAlgorithmException x = new NoSuchAlgorithmException(sb.toString());
 202     x.initCause(cause);
 203     throw x;
 204   }
 205
 206   /** @return the provider of this parameter object. */
 207   public final Provider getProvider()
 208   {
 209     return provider;
 210   }
 211
 212   /**
 213    * Initializes the engine with the specified {@link AlgorithmParameterSpec}.
 214    *
 215    * @param paramSpec
 216    *          A {@link AlgorithmParameterSpec} to use.
 217    * @throws InvalidParameterSpecException
 218    *           if <code>paramSpec</code> is invalid.
 219    */
 220   public final void init(AlgorithmParameterSpec paramSpec)
 221     throws InvalidParameterSpecException
 222   {
 223     paramSpi.engineInit(paramSpec);
 224   }
 225
 226   /**
 227    * Initializes the engine with the specified parameters stored in the byte
 228    * array and decodes them according to the ASN.1 specification. If the ASN.1
 229    * specification exists then it succeeds otherwise an {@link IOException} is
 230    * thrown.
 231    *
 232    * @param params
 233    *          the parameters to use.
 234    * @throws IOException
 235    *           if a decoding error occurs.
 236    */
 237   public final void init(byte[]params) throws IOException
 238   {
 239     paramSpi.engineInit(params);
 240   }
 241
 242   /**
 243    * Initializes the engine with the specified parameters stored in the byte
 244    * array and decodes them according to the specified decoding specification.
 245    * If <code>format</code> is <code>null</code>, then this method decodes the
 246    * byte array using the ASN.1 specification if it exists, otherwise it throws
 247    * an {@link IOException}.
 248    *
 249    * @param params
 250    *          the parameters to use.
 251    * @param format
 252    *          the name of decoding format to use.
 253    * @throws IOException
 254    *           if a decoding error occurs.
 255    */
 256   public final void init(byte[]params, String format) throws IOException
 257   {
 258     paramSpi.engineInit(params, format);
 259   }
 260
 261   /**
 262    * Returns a new instance of <code>AlgorithmParameters</code> as a
 263    * designated parameter specification {@link Class}.
 264    *
 265    * @param paramSpec
 266    *          the {@link Class} to use.
 267    * @return the parameter specification.
 268    * @throws InvalidParameterSpecException
 269    *           if <code>paramSpec</code> is invalid.
 270    */
 271   public final <T extends AlgorithmParameterSpec>
 272   T getParameterSpec(Class<T> paramSpec)
 273     throws InvalidParameterSpecException
 274   {
 275     return paramSpi.engineGetParameterSpec(paramSpec);
 276   }
 277
 278   /**
 279    * Returns the parameters in the default encoding format. The primary encoding
 280    * format is ASN.1 if it exists for the specified type.
 281    *
 282    * @return byte array representing the parameters.
 283    */
 284   public final byte[] getEncoded() throws IOException
 285   {
 286     return paramSpi.engineGetEncoded();
 287   }
 288
 289   /**
 290    * Returns the parameters in the specified encoding format. If
 291    * <code>format</code> is <code>null</code> then the ASN.1 encoding
 292    * format is used if it exists for the specified type.
 293    *
 294    * @param format
 295    *          the name of the encoding format to use.
 296    * @return the parameters encoded using the specified encoding scheme.
 297    * @throws IOException
 298    *           if an encoding exception occurs, or if this parameter object has
 299    *           not been initialized.
 300    */
 301   public final byte[] getEncoded(String format) throws IOException
 302   {
 303     return paramSpi.engineGetEncoded(format);
 304   }
 305
 306   /**
 307    * Returns a string representation of the encoded form.
 308    *
 309    * @return a string representation of the encoded form.
 310    */
 311   public final String toString()
 312   {
 313     return paramSpi.engineToString();
 314   }
 315 }