001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: */
017:
018: /**
019: * @author Vera Y. Petrashkova
020: * @version $Revision$
021: */package java.security;
022:
023: import java.security.spec.AlgorithmParameterSpec;
024:
025: import org.apache.harmony.security.fortress.Engine;
026: import org.apache.harmony.security.internal.nls.Messages;
027:
028: /**
029: *
030: * @com.intel.drl.spec_ref
031: *
032: */
033: public abstract class KeyPairGenerator extends KeyPairGeneratorSpi {
034:
035: // Store KeyPairGenerator SERVICE name
036: private static final String SERVICE = "KeyPairGenerator"; //$NON-NLS-1$
037:
038: // Used to access common engine functionality
039: private static Engine engine = new Engine(SERVICE);
040:
041: // Store SecureRandom
042: private static SecureRandom random = new SecureRandom();
043:
044: // Store used provider
045: private Provider provider;
046:
047: // Store used algorithm
048: private String algorithm;
049:
050: /**
051: * @com.intel.drl.spec_ref
052: *
053: */
054: protected KeyPairGenerator(String algorithm) {
055: this .algorithm = algorithm;
056: }
057:
058: /**
059: * @com.intel.drl.spec_ref
060: *
061: */
062: public String getAlgorithm() {
063: return algorithm;
064: }
065:
066: /**
067: * @com.intel.drl.spec_ref
068: *
069: * throws NullPointerException when algorithm is null
070: */
071: public static KeyPairGenerator getInstance(String algorithm)
072: throws NoSuchAlgorithmException {
073: if (algorithm == null) {
074: throw new NullPointerException(Messages
075: .getString("security.01")); //$NON-NLS-1$
076: }
077: KeyPairGenerator result;
078: synchronized (engine) {
079: engine.getInstance(algorithm, null);
080: if (engine.spi instanceof KeyPairGenerator) {
081: result = (KeyPairGenerator) engine.spi;
082: result.algorithm = algorithm;
083: result.provider = engine.provider;
084: return result;
085: } else {
086: result = new KeyPairGeneratorImpl(
087: (KeyPairGeneratorSpi) engine.spi,
088: engine.provider, algorithm);
089: return result;
090: }
091: }
092: }
093:
094: /**
095: * @com.intel.drl.spec_ref
096: *
097: * throws NullPointerException if algorithm is null (instead of
098: * NoSuchAlgorithmException) as in 1.4 release
099: */
100: public static KeyPairGenerator getInstance(String algorithm,
101: String provider) throws NoSuchAlgorithmException,
102: NoSuchProviderException {
103: if ((provider == null) || (provider.length() == 0)) {
104: throw new IllegalArgumentException(Messages
105: .getString("security.02")); //$NON-NLS-1$
106: }
107: Provider impProvider = Security.getProvider(provider);
108: if (impProvider == null) {
109: throw new NoSuchProviderException(provider);
110: }
111: return getInstance(algorithm, impProvider);
112: }
113:
114: /**
115: * @com.intel.drl.spec_ref
116: *
117: * throws NullPointerException if algorithm is null (instead of
118: * NoSuchAlgorithmException) as in 1.4 release
119: */
120: public static KeyPairGenerator getInstance(String algorithm,
121: Provider provider) throws NoSuchAlgorithmException {
122: if (provider == null) {
123: throw new IllegalArgumentException(Messages
124: .getString("security.04")); //$NON-NLS-1$
125: }
126: if (algorithm == null) {
127: throw new NullPointerException(Messages
128: .getString("security.01")); //$NON-NLS-1$
129: }
130: KeyPairGenerator result;
131: synchronized (engine) {
132: engine.getInstance(algorithm, provider, null);
133: if (engine.spi instanceof KeyPairGenerator) {
134: result = (KeyPairGenerator) engine.spi;
135: result.algorithm = algorithm;
136: result.provider = provider;
137: return result;
138: } else {
139: result = new KeyPairGeneratorImpl(
140: (KeyPairGeneratorSpi) engine.spi, provider,
141: algorithm);
142: return result;
143: }
144: }
145: }
146:
147: /**
148: * @com.intel.drl.spec_ref
149: *
150: */
151: public final Provider getProvider() {
152: return provider;
153: }
154:
155: /**
156: * @com.intel.drl.spec_ref
157: *
158: */
159: public void initialize(int keysize) {
160: initialize(keysize, random);
161: }
162:
163: /**
164: * @com.intel.drl.spec_ref
165: *
166: */
167: public void initialize(AlgorithmParameterSpec param)
168: throws InvalidAlgorithmParameterException {
169: initialize(param, random);
170: }
171:
172: /**
173: * @com.intel.drl.spec_ref
174: *
175: */
176: public final KeyPair genKeyPair() {
177: return generateKeyPair();
178: }
179:
180: public KeyPair generateKeyPair() {
181: return null;
182: }
183:
184: /**
185: * @com.intel.drl.spec_ref
186: *
187: */
188: public void initialize(int keysize, SecureRandom random) {
189: }
190:
191: /**
192: * @com.intel.drl.spec_ref
193: *
194: */
195: public void initialize(AlgorithmParameterSpec param,
196: SecureRandom random)
197: throws InvalidAlgorithmParameterException {
198: }
199:
200: /**
201: *
202: * Internal class: KeyPairGenerator implementation
203: *
204: */
205: private static class KeyPairGeneratorImpl extends KeyPairGenerator {
206: // Save KeyPairGeneratorSpi
207: private KeyPairGeneratorSpi spiImpl;
208:
209: // Implementation of KeyPaiGenerator constructor
210: //
211: // @param KeyPairGeneratorSpi
212: // @param provider
213: // @param algorithm
214: private KeyPairGeneratorImpl(
215: KeyPairGeneratorSpi keyPairGeneratorSpi,
216: Provider provider, String algorithm) {
217: super (algorithm);
218: super .provider = provider;
219: spiImpl = keyPairGeneratorSpi;
220: }
221:
222: // implementation of initialize(int keysize, SecureRandom random)
223: // using corresponding spi initialize() method
224: public void initialize(int keysize, SecureRandom random) {
225: spiImpl.initialize(keysize, random);
226: }
227:
228: // implementation of generateKeyPair()
229: // using corresponding spi generateKeyPair() method
230: public KeyPair generateKeyPair() {
231: return spiImpl.generateKeyPair();
232: }
233:
234: // implementation of initialize(int keysize, SecureRandom random)
235: // using corresponding spi initialize() method
236: public void initialize(AlgorithmParameterSpec param,
237: SecureRandom random)
238: throws InvalidAlgorithmParameterException {
239: spiImpl.initialize(param, random);
240: }
241:
242: }
243:
244: }
|