1 package org.gudy.bouncycastle.jce.provider;
2 
3 import java.security.AlgorithmParameterGeneratorSpi;
4 import java.security.AlgorithmParameters;
5 import java.security.InvalidAlgorithmParameterException;
6 import java.security.SecureRandom;
7 import java.security.spec.AlgorithmParameterSpec;
8 import java.security.spec.DSAParameterSpec;
9 
10 import javax.crypto.spec.DHGenParameterSpec;
11 import javax.crypto.spec.DHParameterSpec;
12 import javax.crypto.spec.IvParameterSpec;
13 import javax.crypto.spec.RC2ParameterSpec;
14 
15 import org.gudy.bouncycastle.jce.provider.BouncyCastleProvider;
16 import org.gudy.bouncycastle.jce.provider.JDKAlgorithmParameterGenerator;
17 import org.gudy.bouncycastle.crypto.generators.DHParametersGenerator;
18 import org.gudy.bouncycastle.crypto.generators.DSAParametersGenerator;
19 import org.gudy.bouncycastle.crypto.generators.ElGamalParametersGenerator;
20 import org.gudy.bouncycastle.crypto.params.DHParameters;
21 import org.gudy.bouncycastle.crypto.params.DSAParameters;
22 import org.gudy.bouncycastle.crypto.params.ElGamalParameters;
23 import org.gudy.bouncycastle.jce.spec.ElGamalParameterSpec;
24 
25 public abstract class JDKAlgorithmParameterGenerator
26     extends AlgorithmParameterGeneratorSpi
27 {
28     protected SecureRandom  random;
29     protected int           strength = 1024;
30 
engineInit( int strength, SecureRandom random)31     protected void engineInit(
32         int             strength,
33         SecureRandom    random)
34     {
35         this.strength = strength;
36         this.random = random;
37     }
38 
39     public static class DH
40         extends JDKAlgorithmParameterGenerator
41     {
42         private int l = 0;
43 
engineInit( AlgorithmParameterSpec genParamSpec, SecureRandom random)44         protected void engineInit(
45             AlgorithmParameterSpec  genParamSpec,
46             SecureRandom            random)
47             throws InvalidAlgorithmParameterException
48         {
49             if (!(genParamSpec instanceof DHGenParameterSpec))
50             {
51                 throw new InvalidAlgorithmParameterException("DH parameter generator requires a DHGenParameterSpec for initialisation");
52             }
53             DHGenParameterSpec  spec = (DHGenParameterSpec)genParamSpec;
54 
55             this.strength = spec.getPrimeSize();
56             this.l = spec.getExponentSize();
57             this.random = random;
58         }
59 
engineGenerateParameters()60         protected AlgorithmParameters engineGenerateParameters()
61         {
62             DHParametersGenerator        pGen = new DHParametersGenerator();
63 
64 			if ( random != null )
65 			{
66 				pGen.init(strength, 20, random);
67 			}
68 			else
69 			{
70 				pGen.init(strength, 20, new SecureRandom());
71 			}
72 
73             DHParameters                p = pGen.generateParameters();
74 
75             AlgorithmParameters params;
76 
77             try
78             {
79                 params = AlgorithmParameters.getInstance("DH", BouncyCastleProvider.PROVIDER_NAME);
80                 params.init(new DHParameterSpec(p.getP(), p.getG(), l));
81             }
82             catch (Exception e)
83             {
84                 throw new RuntimeException(e.getMessage());
85             }
86 
87             return params;
88         }
89     }
90 
91     public static class DSA
92         extends JDKAlgorithmParameterGenerator
93     {
engineInit( AlgorithmParameterSpec genParamSpec, SecureRandom random)94         protected void engineInit(
95             AlgorithmParameterSpec  genParamSpec,
96             SecureRandom            random)
97             throws InvalidAlgorithmParameterException
98         {
99             throw new InvalidAlgorithmParameterException("No supported AlgorithmParameterSpec for DSA parameter generation.");
100         }
101 
engineGenerateParameters()102         protected AlgorithmParameters engineGenerateParameters()
103         {
104             DSAParametersGenerator pGen = new DSAParametersGenerator();
105 
106 			if ( random != null )
107 			{
108 				pGen.init(strength, 20, random);
109 			}
110 			else
111 			{
112 				pGen.init(strength, 20, new SecureRandom());
113 			}
114 
115             DSAParameters p = pGen.generateParameters();
116 
117             AlgorithmParameters params;
118 
119             try
120             {
121                 params = AlgorithmParameters.getInstance("DSA", BouncyCastleProvider.PROVIDER_NAME);
122                 params.init(new DSAParameterSpec(p.getP(), p.getQ(), p.getG()));
123             }
124             catch (Exception e)
125             {
126                 throw new RuntimeException(e.getMessage());
127             }
128 
129             return params;
130         }
131     }
132 
133     public static class ElGamal
134         extends JDKAlgorithmParameterGenerator
135     {
engineInit( AlgorithmParameterSpec genParamSpec, SecureRandom random)136         protected void engineInit(
137             AlgorithmParameterSpec  genParamSpec,
138             SecureRandom            random)
139             throws InvalidAlgorithmParameterException
140         {
141             throw new InvalidAlgorithmParameterException("No supported AlgorithmParameterSpec for ElGamal parameter generation.");
142         }
143 
engineGenerateParameters()144         protected AlgorithmParameters engineGenerateParameters()
145         {
146             ElGamalParametersGenerator pGen = new ElGamalParametersGenerator();
147 
148 			if ( random != null )
149 			{
150 				pGen.init(strength, 20, random);
151 			}
152 			else
153 			{
154 				pGen.init(strength, 20, new SecureRandom());
155 			}
156 
157             ElGamalParameters p = pGen.generateParameters();
158 
159             AlgorithmParameters params;
160 
161             try
162             {
163                 params = AlgorithmParameters.getInstance("ElGamal", BouncyCastleProvider.PROVIDER_NAME);
164                 params.init(new ElGamalParameterSpec(p.getP(), p.getG()));
165             }
166             catch (Exception e)
167             {
168                 throw new RuntimeException(e.getMessage());
169             }
170 
171             return params;
172         }
173     }
174 
175     public static class DES
176         extends JDKAlgorithmParameterGenerator
177     {
engineInit( AlgorithmParameterSpec genParamSpec, SecureRandom random)178         protected void engineInit(
179             AlgorithmParameterSpec  genParamSpec,
180             SecureRandom            random)
181             throws InvalidAlgorithmParameterException
182         {
183             throw new InvalidAlgorithmParameterException("No supported AlgorithmParameterSpec for DES parameter generation.");
184         }
185 
engineGenerateParameters()186         protected AlgorithmParameters engineGenerateParameters()
187         {
188             byte[]  iv = new byte[8];
189 
190 			if (random == null)
191 			{
192                 random = new SecureRandom();
193 			}
194 
195             random.nextBytes(iv);
196 
197             AlgorithmParameters params;
198 
199             try
200             {
201                 params = AlgorithmParameters.getInstance("DES", BouncyCastleProvider.PROVIDER_NAME);
202                 params.init(new IvParameterSpec(iv));
203             }
204             catch (Exception e)
205             {
206                 throw new RuntimeException(e.getMessage());
207             }
208 
209             return params;
210         }
211     }
212 
213     public static class RC2
214         extends JDKAlgorithmParameterGenerator
215     {
216         RC2ParameterSpec    spec = null;
217 
engineInit( AlgorithmParameterSpec genParamSpec, SecureRandom random)218         protected void engineInit(
219             AlgorithmParameterSpec  genParamSpec,
220             SecureRandom            random)
221             throws InvalidAlgorithmParameterException
222         {
223             if (genParamSpec instanceof RC2ParameterSpec)
224             {
225                 spec = (RC2ParameterSpec)genParamSpec;
226                 return;
227             }
228 
229             throw new InvalidAlgorithmParameterException("No supported AlgorithmParameterSpec for RC2 parameter generation.");
230         }
231 
engineGenerateParameters()232         protected AlgorithmParameters engineGenerateParameters()
233         {
234             AlgorithmParameters params;
235 
236             if (spec == null)
237             {
238                 byte[]  iv = new byte[8];
239 
240                 if (random == null)
241                 {
242                     random = new SecureRandom();
243                 }
244 
245                 random.nextBytes(iv);
246 
247                 try
248                 {
249                     params = AlgorithmParameters.getInstance("RC2", BouncyCastleProvider.PROVIDER_NAME);
250                     params.init(new IvParameterSpec(iv));
251                 }
252                 catch (Exception e)
253                 {
254                     throw new RuntimeException(e.getMessage());
255                 }
256             }
257             else
258             {
259                 try
260                 {
261                     params = AlgorithmParameters.getInstance("RC2", BouncyCastleProvider.PROVIDER_NAME);
262                     params.init(spec);
263                 }
264                 catch (Exception e)
265                 {
266                     throw new RuntimeException(e.getMessage());
267                 }
268             }
269 
270             return params;
271         }
272     }
273 
274     public static class AES
275         extends JDKAlgorithmParameterGenerator
276     {
engineInit( AlgorithmParameterSpec genParamSpec, SecureRandom random)277         protected void engineInit(
278             AlgorithmParameterSpec  genParamSpec,
279             SecureRandom            random)
280             throws InvalidAlgorithmParameterException
281         {
282             throw new InvalidAlgorithmParameterException("No supported AlgorithmParameterSpec for AES parameter generation.");
283         }
284 
engineGenerateParameters()285         protected AlgorithmParameters engineGenerateParameters()
286         {
287             byte[]  iv = new byte[16];
288 
289 			if (random == null)
290 			{
291                 random = new SecureRandom();
292 			}
293 
294             random.nextBytes(iv);
295 
296             AlgorithmParameters params;
297 
298             try
299             {
300                 params = AlgorithmParameters.getInstance("AES", BouncyCastleProvider.PROVIDER_NAME);
301                 params.init(new IvParameterSpec(iv));
302             }
303             catch (Exception e)
304             {
305                 throw new RuntimeException(e.getMessage());
306             }
307 
308             return params;
309         }
310     }
311 
312     public static class IDEA
313         extends JDKAlgorithmParameterGenerator
314     {
engineInit( AlgorithmParameterSpec genParamSpec, SecureRandom random)315         protected void engineInit(
316             AlgorithmParameterSpec  genParamSpec,
317             SecureRandom            random)
318             throws InvalidAlgorithmParameterException
319         {
320             throw new InvalidAlgorithmParameterException("No supported AlgorithmParameterSpec for IDEA parameter generation.");
321         }
322 
engineGenerateParameters()323         protected AlgorithmParameters engineGenerateParameters()
324         {
325             byte[]  iv = new byte[8];
326 
327 			if (random == null)
328 			{
329                 random = new SecureRandom();
330 			}
331 
332             random.nextBytes(iv);
333 
334             AlgorithmParameters params;
335 
336             try
337             {
338                 params = AlgorithmParameters.getInstance("IDEA", BouncyCastleProvider.PROVIDER_NAME);
339                 params.init(new IvParameterSpec(iv));
340             }
341             catch (Exception e)
342             {
343                 throw new RuntimeException(e.getMessage());
344             }
345 
346             return params;
347         }
348     }
349 
350     public static class CAST5
351         extends JDKAlgorithmParameterGenerator
352     {
engineInit( AlgorithmParameterSpec genParamSpec, SecureRandom random)353         protected void engineInit(
354             AlgorithmParameterSpec  genParamSpec,
355             SecureRandom            random)
356             throws InvalidAlgorithmParameterException
357         {
358             throw new InvalidAlgorithmParameterException("No supported AlgorithmParameterSpec for CAST5 parameter generation.");
359         }
360 
engineGenerateParameters()361         protected AlgorithmParameters engineGenerateParameters()
362         {
363             byte[]  iv = new byte[8];
364 
365 			if (random == null)
366 			{
367                 random = new SecureRandom();
368 			}
369 
370             random.nextBytes(iv);
371 
372             AlgorithmParameters params;
373 
374             try
375             {
376                 params = AlgorithmParameters.getInstance("CAST5", BouncyCastleProvider.PROVIDER_NAME);
377                 params.init(new IvParameterSpec(iv));
378             }
379             catch (Exception e)
380             {
381                 throw new RuntimeException(e.getMessage());
382             }
383 
384             return params;
385         }
386     }
387 }
388