← Back to branch summary

~motu-torrent/azureus/upstream-stable

« back to all changes in this revision

Viewing changes to org/bouncycastle/jce/provider/JDKAlgorithmParameterGenerator.java

  • Committer: John Dong
  • Date: 2007-10-22 04:54:13 UTC
  • Revision ID: john.dong@gmail.com-20071022045413-3ovb11u82rrcokxx
Commit 3.0.3.4

Show diffs side-by-side

added added

removed removed

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