001 /* AlgorithmParameterGenerator.java --- Algorithm Parameter Generator
002 Copyright (C) 1999, 2003, 2004 Free Software Foundation, Inc.
003
004 This file is part of GNU Classpath.
005
006 GNU Classpath is free software; you can redistribute it and/or modify
007 it under the terms of the GNU General Public License as published by
008 the Free Software Foundation; either version 2, or (at your option)
009 any later version.
010
011 GNU Classpath is distributed in the hope that it will be useful, but
012 WITHOUT ANY WARRANTY; without even the implied warranty of
013 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
014 General Public License for more details.
015
016 You should have received a copy of the GNU General Public License
017 along with GNU Classpath; see the file COPYING. If not, write to the
018 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
019 02110-1301 USA.
020
021 Linking this library statically or dynamically with other modules is
022 making a combined work based on this library. Thus, the terms and
023 conditions of the GNU General Public License cover the whole
024 combination.
025
026 As a special exception, the copyright holders of this library give you
027 permission to link this library with independent modules to produce an
028 executable, regardless of the license terms of these independent
029 modules, and to copy and distribute the resulting executable under
030 terms of your choice, provided that you also meet, for each linked
031 independent module, the terms and conditions of the license of that
032 module. An independent module is a module which is not derived from
033 or based on this library. If you modify this library, you may extend
034 this exception to your version of the library, but you are not
035 obligated to do so. If you do not wish to do so, delete this
036 exception statement from your version. */
037
038
039 package java.security;
040
041 import gnu.java.security.Engine;
042
043 import java.lang.reflect.InvocationTargetException;
044 import java.security.spec.AlgorithmParameterSpec;
045
046 /**
047 * <code>AlgorithmParameterGenerator</code> is used to generate algorithm
048 * parameters for specified algorithms.
049 *
050 * <p>In case the client does not explicitly initialize the
051 * <code>AlgorithmParameterGenerator</code> (via a call to an
052 * <code>init()</code> method), each provider must supply (and document) a
053 * default initialization. For example, the <b>GNU</b> provider uses a default
054 * modulus prime size of <code>1024</code> bits for the generation of <i>DSA</i>
055 * parameters.
056 *
057 * @author Mark Benvenuto
058 * @since 1.2
059 * @see AlgorithmParameters
060 * @see AlgorithmParameterSpec
061 */
062 public class AlgorithmParameterGenerator
063 {
064 /** Service name for algorithm parameter generators. */
065 private static final String ALGORITHM_PARAMETER_GENERATOR =
066 "AlgorithmParameterGenerator";
067
068 private AlgorithmParameterGeneratorSpi paramGenSpi;
069 private Provider provider;
070 private String algorithm;
071
072 /**
073 * Constructs a new instance of <code>AlgorithmParameterGenerator</code>.
074 *
075 * @param paramGenSpi
076 * the generator to use.
077 * @param provider
078 * the provider to use.
079 * @param algorithm
080 * the algorithm to use.
081 */
082 protected AlgorithmParameterGenerator(AlgorithmParameterGeneratorSpi
083 paramGenSpi, Provider provider,
084 String algorithm)
085 {
086 this.paramGenSpi = paramGenSpi;
087 this.provider = provider;
088 this.algorithm = algorithm;
089 }
090
091 /** @return the name of the algorithm. */
092 public final String getAlgorithm()
093 {
094 return algorithm;
095 }
096
097 /**
098 * Returns a new <code>AlgorithmParameterGenerator</code> instance which
099 * generates algorithm parameters for the specified algorithm.
100 *
101 * @param algorithm the name of algorithm to use.
102 * @return the new instance.
103 * @throws NoSuchAlgorithmException if <code>algorithm</code> is not
104 * implemented by any provider.
105 * @throws IllegalArgumentException if <code>algorithm</code> is
106 * <code>null</code> or is an empty string.
107 */
108 public static AlgorithmParameterGenerator getInstance(String algorithm)
109 throws NoSuchAlgorithmException
110 {
111 Provider[] p = Security.getProviders();
112 NoSuchAlgorithmException lastException = null;
113 for (int i = 0; i < p.length; i++)
114 try
115 {
116 return getInstance(algorithm, p[i]);
117 }
118 catch (NoSuchAlgorithmException x)
119 {
120 lastException = x;
121 }
122 if (lastException != null)
123 throw lastException;
124 throw new NoSuchAlgorithmException(algorithm);
125 }
126
127 /**
128 * Returns a new <code>AlgorithmParameterGenerator</code> instance which
129 * generates algorithm parameters for the specified algorithm.
130 *
131 * @param algorithm the name of algorithm to use.
132 * @param provider the name of the {@link Provider} to use.
133 * @return the new instance.
134 * @throws NoSuchAlgorithmException if the algorithm is not implemented by the
135 * named provider.
136 * @throws NoSuchProviderException if the named provider was not found.
137 * @throws IllegalArgumentException if either <code>algorithm</code> or
138 * <code>provider</code> is <code>null</code> or empty.
139 */
140 public static AlgorithmParameterGenerator getInstance(String algorithm,
141 String provider)
142 throws NoSuchAlgorithmException, NoSuchProviderException
143 {
144 if (provider == null)
145 throw new IllegalArgumentException("provider MUST NOT be null");
146 provider = provider.trim();
147 if (provider.length() == 0)
148 throw new IllegalArgumentException("provider MUST NOT be empty");
149 Provider p = Security.getProvider(provider);
150 if (p == null)
151 throw new NoSuchProviderException(provider);
152 return getInstance(algorithm, p);
153 }
154
155 /**
156 * Returns a new <code>AlgorithmParameterGenerator</code> instance which
157 * generates algorithm parameters for the specified algorithm.
158 *
159 * @param algorithm the name of algorithm to use.
160 * @param provider the {@link Provider} to use.
161 * @return the new instance.
162 * @throws NoSuchAlgorithmException if the algorithm is not implemented by
163 * {@link Provider}.
164 * @throws IllegalArgumentException if either <code>algorithm</code> or
165 * <code>provider</code> is <code>null</code>, or if
166 * <code>algorithm</code> is an empty string.
167 * @since 1.4
168 * @see Provider
169 */
170 public static AlgorithmParameterGenerator getInstance(String algorithm,
171 Provider provider)
172 throws NoSuchAlgorithmException
173 {
174 StringBuilder sb = new StringBuilder()
175 .append("AlgorithmParameterGenerator for algorithm [")
176 .append(algorithm).append("] from provider[")
177 .append(provider).append("] could not be created");
178 Throwable cause;
179 try
180 {
181 Object spi = Engine.getInstance(ALGORITHM_PARAMETER_GENERATOR,
182 algorithm,
183 provider);
184 return new AlgorithmParameterGenerator((AlgorithmParameterGeneratorSpi) spi,
185 provider,
186 algorithm);
187 }
188 catch (InvocationTargetException x)
189 {
190 cause = x.getCause();
191 if (cause instanceof NoSuchAlgorithmException)
192 throw (NoSuchAlgorithmException) cause;
193 if (cause == null)
194 cause = x;
195 }
196 catch (ClassCastException x)
197 {
198 cause = x;
199 }
200 NoSuchAlgorithmException x = new NoSuchAlgorithmException(sb.toString());
201 x.initCause(cause);
202 throw x;
203 }
204
205 /** @return the {@link Provider} of this generator. */
206 public final Provider getProvider()
207 {
208 return provider;
209 }
210
211 /**
212 * Initializes this instance with the specified size. Since no source of
213 * randomness is supplied, a default one will be used.
214 *
215 * @param size
216 * size (in bits) to use.
217 */
218 public final void init(int size)
219 {
220 init(size, new SecureRandom());
221 }
222
223 /**
224 * Initializes this instance with the specified key-size and source of
225 * randomness.
226 *
227 * @param size
228 * the size (in bits) to use.
229 * @param random
230 * the {@link SecureRandom} to use.
231 */
232 public final void init(int size, SecureRandom random)
233 {
234 paramGenSpi.engineInit(size, random);
235 }
236
237 /**
238 * Initializes this instance with the specified {@link AlgorithmParameterSpec}.
239 * Since no source of randomness is supplied, a default one will be used.
240 *
241 * @param genParamSpec
242 * the {@link AlgorithmParameterSpec} to use.
243 * @throws InvalidAlgorithmParameterException
244 * if <code>genParamSpec</code> is invalid.
245 */
246 public final void init(AlgorithmParameterSpec genParamSpec)
247 throws InvalidAlgorithmParameterException
248 {
249 init(genParamSpec, new SecureRandom());
250 }
251
252 /**
253 * Initializes this instance with the specified {@link AlgorithmParameterSpec}
254 * and source of randomness.
255 *
256 * @param genParamSpec
257 * the {@link AlgorithmParameterSpec} to use.
258 * @param random
259 * the {@link SecureRandom} to use.
260 * @throws InvalidAlgorithmParameterException
261 * if <code>genParamSpec</code> is invalid.
262 */
263 public final void init(AlgorithmParameterSpec genParamSpec,
264 SecureRandom random)
265 throws InvalidAlgorithmParameterException
266 {
267 paramGenSpi.engineInit(genParamSpec, random);
268 }
269
270 /** @return a new instance of {@link AlgorithmParameters}. */
271 public final AlgorithmParameters generateParameters()
272 {
273 return paramGenSpi.engineGenerateParameters();
274 }
275 }