|
RIPEMD160WithISO9796Part1AndRSASignatureEngine |
|
1 /* $RCSfile: RIPEMD160WithISO9796Part1AndRSASignatureEngine.java,v $
2 * $Revision: 1.4 $
3 * $Date: 2003/10/04 19:18:38 $
4 * $Author: uwe_guenther $
5 * $State: Exp $
6 *
7 * Created on December 20, 2001 6:36 PM
8 *
9 * Copyright (C) 2001 Uwe Guenther <uwe@cscc.de>
10 *
11 * This file is part of the jhbci JCE-ServiceProvider. The jhbci JCE-
12 * ServiceProvider is a library, written in JavaTM, that should be
13 * used in HBCI banking applications (clients and may be servers),
14 * to do cryptographic operations.
15 *
16 * The jhbci library is free software; you can redistribute it and/or
17 * modify it under the terms of the GNU Lesser General Public
18 * License as published by the Free Software Foundation; either
19 * version 2.1 of the License, or (at your option) any later version.
20 *
21 * The jhbci library is distributed in the hope that it will be useful,
22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
24 * Lesser General Public License for more details.
25 *
26 * You should have received a copy of the GNU Lesser General Public
27 * License along with this library; if not, write to the Free Software
28 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
29 *
30 */
31
32 package de.cscc.crypto.provider;
33
34 import java.security.AlgorithmParameters;
35 import java.security.InvalidAlgorithmParameterException;
36 import java.security.InvalidKeyException;
37 import java.security.InvalidParameterException;
38 import java.security.PrivateKey;
39 import java.security.PublicKey;
40 import java.security.SecureRandom;
41 import java.security.SignatureException;
42 import java.security.SignatureSpi;
43 import java.security.spec.AlgorithmParameterSpec;
44
45 /**
46 * RIPEMD160WithISO9796Part1AndRSASignatureEngine Class.
47 *
48 * @author <a href=mailto:uwe@cscc.de>Uwe Günther</a>
49 *
50 * @version $Revision: 1.4 $
51 */
52 public final class RIPEMD160WithISO9796Part1AndRSASignatureEngine
53 extends SignatureSpi implements Cloneable {
54
55 private RIPEMD160WithISO9796Part1AndRSASignatureImpl sig =
56 new RIPEMD160WithISO9796Part1AndRSASignatureImpl();
57
58 /** Creates new RIPEMD160WithISO9796Part1AndRSASignatureEngine. */
59 public RIPEMD160WithISO9796Part1AndRSASignatureEngine() {
60 if (JHBCI.selfIntegrityChecking() == false) {
61 throw new SecurityException("JHBCI-Provider is tampered.");
62 }
63 }
64
65 /**
66 * Creates and returns a copy of this object.
67 *
68 * @return a clone of this instance.
69 * @throws CloneNotSupportedException if the object's class does not
70 * support the <code>Cloneable</code> interface. Subclasses
71 * that override the <code>clone</code> method can also
72 * throw this exception to indicate that an instance cannot
73 * be cloned.
74 */
75 public Object clone() throws CloneNotSupportedException {
76 RIPEMD160WithISO9796Part1AndRSASignatureEngine result =
77 (RIPEMD160WithISO9796Part1AndRSASignatureEngine) super.clone();
78 result.sig =
79 (RIPEMD160WithISO9796Part1AndRSASignatureImpl) this.sig.clone();
80 return result;
81 }
82
83 /**
84 * Indicates whether some other object is "equal to" this one.
85 *
86 * @param obj the reference object with which to compare.
87 * @return <code>true</code> if this object is the same as the obj
88 * argument; <code>false</code> otherwise.
89 * @see #hashCode()
90 * @see java.util.Hashtable
91 */
92 public boolean equals(Object obj) {
93 //Only for performance.
94 if (this == obj) {
95 return true;
96 }
97
98 //If obj == null then instanceof returns false, see JLS 15.20.2
99 if (!(obj instanceof RIPEMD160WithISO9796Part1AndRSASignatureEngine)) {
100 return false;
101 }
102
103 RIPEMD160WithISO9796Part1AndRSASignatureEngine other =
104 (RIPEMD160WithISO9796Part1AndRSASignatureEngine)obj;
105
106 return this.sig.equals(other.sig);
107 }
108
109 /**
110 * Returns a hash code value for the object.
111 *
112 * @return a hash code value for this object.
113 * @see java.lang.Object#equals(java.lang.Object)
114 * @see java.util.Hashtable
115 */
116 public int hashCode() {
117 int result = 17;
118 result = 37*result + this.sig.hashCode();
119 return result;
120 }
121
122 /**
123 * Returns a string representation of the object.
124 *
125 * @return a string representation of the object.
126 */
127 public String toString() {
128 return this.sig.toString();
129 }
130
131 /**
132 * Initializes this signature object with the specified
133 * private key for signing operations.
134 *
135 * @param privateKey the private key of the identity whose signature
136 * will be generated.
137 *
138 * @throws InvalidKeyException if the key is improperly encoded, parameters
139 * are missing, and so on.
140 */
141 protected void engineInitSign(PrivateKey privateKey)
142 throws InvalidKeyException {
143 this.sig.initSign(privateKey);
144 }
145
146 /**
147 * Initializes this signature object with the specified
148 * private key and source of randomness for signing operations.
149 *
150 * <p>This concrete method has been added to this previously-defined
151 * abstract class. (For backwards compatibility, it cannot be abstract.)
152 *
153 * @param privateKey the private key of the identity whose signature
154 * will be generated.
155 * @param random the source of randomness
156 *
157 * @throws InvalidKeyException if the key is improperly encoded, parameters
158 * are missing, and so on.
159 */
160 protected void engineInitSign(PrivateKey privateKey, SecureRandom random)
161 throws InvalidKeyException {
162 this.sig.initSign(privateKey, random);
163 }
164
165 /**
166 * Initializes this signature object with the specified
167 * public key for verification operations.
168 *
169 * @param publicKey the public key of the identity whose signature is
170 * going to be verified.
171 *
172 * @throws InvalidKeyException if the key is improperly
173 * encoded, parameters are missing, and so on.
174 */
175 protected void engineInitVerify(PublicKey publicKey) throws InvalidKeyException {
176 this.sig.initVerify(publicKey);
177 }
178
179 /**
180 * Updates the data to be signed or verified
181 * using the specified byte.
182 *
183 * @param value the byte to use for the update.
184 *
185 * @throws SignatureException if the engine is not initialized
186 * properly.
187 */
188 protected void engineUpdate(byte value) throws SignatureException {
189 this.sig.update(value);
190 }
191
192 /**
193 * Updates the data to be signed or verified, using the
194 * specified array of bytes, starting at the specified offset.
195 *
196 * @param values the array of bytes
197 * @param offset the offset to start from in the array of bytes
198 * @param len the number of bytes to use, starting at offset
199 *
200 * @throws SignatureException if the engine is not initialized
201 * properly
202 * @throws NullPointerException if outbuf is null.
203 * @throws IllegalArgumentException if offset or len is negative, or the
204 * sum of offset and len is greater than length of the values array.
205 */
206 protected void engineUpdate(byte[] values, int offset, int len)
207 throws SignatureException {
208 this.sig.update(values, offset, len);
209 }
210
211 /**
212 * Returns the signature bytes of all the data
213 * updated so far.
214 * The format of the signature depends on the underlying
215 * signature scheme.
216 *
217 * @return the signature bytes of the signing operation's result.
218 *
219 * @throws SignatureException if the engine is not initialized properly.
220 */
221 protected byte[] engineSign() throws SignatureException {
222 return this.sig.sign();
223 }
224
225 /**
226 * Finishes this signature operation and stores the resulting signature
227 * bytes in the provided buffer <code>outbuf</code>, starting at
228 * <code>offset</code>.
229 * The format of the signature depends on the underlying
230 * signature scheme.
231 *
232 * <p>The signature implementation is reset to its initial state
233 * (the state it was in after a call to one of the
234 * <code>engineInitSign</code> methods)
235 * and can be reused to generate further signatures with the same private
236 * key.
237 *
238 * This method should be abstract, but we leave it concrete for
239 * binary compatibility. Knowledgeable providers should override this
240 * method.
241 *
242 * @param outbuf buffer for the signature result.
243 *
244 * @param offset offset into <code>outbuf</code> where the signature is
245 * stored.
246 *
247 * @param len number of bytes within <code>outbuf</code> allotted for the
248 * signature.
249 * Both this default implementation and the SUN provider do not
250 * return partial digests. If the value of this parameter is less
251 * than the actual signature length, this method will throw a
252 * SignatureException.
253 * This parameter is ignored if its value is greater than or equal to
254 * the actual signature length.
255 *
256 * @return the number of bytes placed into <code>outbuf</code>
257 *
258 * @throws SignatureException if an error occurs or <code>len</code>
259 * is less than the actual signature length.
260 * @throws NullPointerException if outbuf is null.
261 * @throws IllegalArgumentException if offset or len is negative, or the
262 * sum of offset and len is greater than length of the outbuf array.
263 */
264 protected int engineSign(byte[] outbuf, int offset, int len)
265 throws SignatureException {
266 return this.sig.sign(outbuf, offset, len);
267 }
268
269 /**
270 * Verifies the passed-in signature.
271 *
272 * @param sigBytes the signature bytes to be verified.
273 *
274 * @return true if the signature was verified, false if not.
275 *
276 * @throws SignatureException if the engine is not initialized
277 * properly, or the passed-in signature is improperly encoded or
278 * of the wrong type, etc.
279 */
280 protected boolean engineVerify(byte[] sigBytes) throws SignatureException {
281 return this.sig.verify(sigBytes);
282 }
283
284 /**
285 * Verifies the passed-in signature in the specified array
286 * of bytes, starting at the specified offset.
287 *
288 * <p> Note: Subclasses should overwrite the default implementation.
289 *
290 *
291 * @param sigBytes the signature bytes to be verified.
292 * @param offset the offset to start from in the array of bytes.
293 * @param len the number of bytes to use, starting at offset.
294 *
295 * @return true if the signature was verified, false if not.
296 *
297 * @throws SignatureException if the engine is not initialized
298 * properly, or the passed-in signature is improperly encoded or
299 * of the wrong type, etc.
300 */
301 protected boolean engineVerify(byte[] sigBytes, int offset, int len)
302 throws SignatureException {
303 return this.sig.verify(sigBytes, offset, len);
304 }
305
306 /**
307 * <p>This method is overridden by providers to initialize
308 * this signature engine with the specified parameter set.
309 *
310 * @param params the parameters
311 *
312 * @exception UnsupportedOperationException if this method is not
313 * overridden by a provider
314 *
315 * @throws InvalidAlgorithmParameterException if this method is
316 * overridden by a provider and the the given parameters
317 * are inappropriate for this signature engine
318 */
319 protected void engineSetParameter(AlgorithmParameterSpec params)
320 throws InvalidAlgorithmParameterException {
321 this.sig.setParameter(params);
322 }
323
324 /**
325 * <p>This method is overridden by providers to return the
326 * parameters used with this signature engine, or null
327 * if this signature engine does not use any parameters.
328 *
329 * <p>The returned parameters may be the same that were used to initialize
330 * this signature engine, or may contain a combination of default and
331 * randomly generated parameter values used by the underlying signature
332 * implementation if this signature engine requires algorithm parameters
333 * but was not initialized with any.
334 *
335 * @return the parameters used with this signature engine, or null if this
336 * signature engine does not use any parameters
337 *
338 * @throws UnsupportedOperationException if this method is
339 * not overridden by a provider
340 */
341 protected AlgorithmParameters engineGetParameters() {
342 return this.sig.getParameters();
343 }
344
345 /**
346 * Sets the specified algorithm parameter to the specified
347 * value. This method supplies a general-purpose mechanism through
348 * which it is possible to set the various parameters of this object.
349 * A parameter may be any settable parameter for the algorithm, such as
350 * a parameter size, or a source of random bits for signature generation
351 * (if appropriate), or an indication of whether or not to perform
352 * a specific but optional computation. A uniform algorithm-specific
353 * naming scheme for each parameter is desirable but left unspecified
354 * at this time.
355 *
356 * @param param the string identifier of the parameter.
357 *
358 * @param value the parameter value.
359 *
360 * @exception InvalidParameterException if <code>param</code> is an
361 * invalid parameter for this signature algorithm engine,
362 * the parameter is already set
363 * and cannot be set again, a security exception occurs, and so on.
364 *
365 * @deprecated Replaced by {@link
366 * #engineSetParameter(java.security.spec.AlgorithmParameterSpec)
367 * engineSetParameter}.
368 */
369 protected void engineSetParameter(String param, Object value)
370 throws InvalidParameterException {
371 throw new UnsupportedOperationException("Method deprecated.");
372 }
373
374 /**
375 * Gets the value of the specified algorithm parameter.
376 * This method supplies a general-purpose mechanism through which it
377 * is possible to get the various parameters of this object. A parameter
378 * may be any settable parameter for the algorithm, such as a parameter
379 * size, or a source of random bits for signature generation (if
380 * appropriate), or an indication of whether or not to perform a
381 * specific but optional computation. A uniform algorithm-specific
382 * naming scheme for each parameter is desirable but left unspecified
383 * at this time.
384 *
385 * @param param the string name of the parameter.
386 *
387 * @return the object that represents the parameter value, or null if
388 * there is none.
389 *
390 * @exception InvalidParameterException if <code>param</code> is an
391 * invalid parameter for this engine, or another exception occurs while
392 * trying to get this parameter.
393 *
394 * @deprecated
395 */
396 protected Object engineGetParameter(String param)
397 throws InvalidParameterException {
398 throw new UnsupportedOperationException("Method deprecated.");
399 }
400
401 }
402
|
RIPEMD160WithISO9796Part1AndRSASignatureEngine |
|