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: * @author Boris V. Kuznetsov
019: * @version $Revision$
020: */package java.security;
021:
022: import java.nio.ByteBuffer;
023: import java.security.spec.AlgorithmParameterSpec;
024:
025: import org.apache.harmony.security.internal.nls.Messages;
026:
027: /**
028: * @com.intel.drl.spec_ref
029: *
030: */
031:
032: public abstract class SignatureSpi {
033:
034: /**
035: * @com.intel.drl.spec_ref
036: *
037: */
038: protected SecureRandom appRandom;
039:
040: /**
041: * @com.intel.drl.spec_ref
042: *
043: */
044: protected abstract void engineInitVerify(PublicKey publicKey)
045: throws InvalidKeyException;
046:
047: /**
048: * @com.intel.drl.spec_ref
049: *
050: */
051: protected abstract void engineInitSign(PrivateKey privateKey)
052: throws InvalidKeyException;
053:
054: /**
055: * @com.intel.drl.spec_ref
056: *
057: */
058: protected void engineInitSign(PrivateKey privateKey,
059: SecureRandom random) throws InvalidKeyException {
060: appRandom = random;
061: engineInitSign(privateKey);
062: }
063:
064: /**
065: * @com.intel.drl.spec_ref
066: *
067: */
068: protected abstract void engineUpdate(byte b)
069: throws SignatureException;
070:
071: /**
072: * @com.intel.drl.spec_ref
073: *
074: */
075: protected abstract void engineUpdate(byte[] b, int off, int len)
076: throws SignatureException;
077:
078: /**
079: * @com.intel.drl.spec_ref
080: *
081: * The SignatureException is not specified for this method.
082: * So throw RuntimeException if underlying engineUpdate(byte[] b, int off, int len)
083: * throws SignatureException.
084: */
085: protected void engineUpdate(ByteBuffer input) {
086: if (!input.hasRemaining()) {
087: return;
088: }
089: byte[] tmp;
090: if (input.hasArray()) {
091: tmp = input.array();
092: int offset = input.arrayOffset();
093: int position = input.position();
094: int limit = input.limit();
095: try {
096: engineUpdate(tmp, offset + position, limit - position);
097: } catch (SignatureException e) {
098: throw new RuntimeException(e); //Wrap SignatureException
099: }
100: input.position(limit);
101: } else {
102: tmp = new byte[input.limit() - input.position()];
103: input.get(tmp);
104: try {
105: engineUpdate(tmp, 0, tmp.length);
106: } catch (SignatureException e) {
107: throw new RuntimeException(e); //Wrap SignatureException
108: }
109: }
110: }
111:
112: /**
113: * @com.intel.drl.spec_ref
114: *
115: */
116: protected abstract byte[] engineSign() throws SignatureException;
117:
118: /**
119: * @com.intel.drl.spec_ref
120: *
121: */
122: protected int engineSign(byte[] outbuf, int offset, int len)
123: throws SignatureException {
124: byte tmp[] = engineSign();
125: if (tmp == null) {
126: return 0;
127: }
128: if (len < tmp.length) {
129: throw new SignatureException(Messages
130: .getString("security.2D")); //$NON-NLS-1$
131: }
132: if (offset < 0) {
133: throw new SignatureException(Messages
134: .getString("security.1C")); //$NON-NLS-1$
135: }
136: if (offset + len > outbuf.length) {
137: throw new SignatureException(Messages
138: .getString("security.05")); //$NON-NLS-1$
139: }
140: System.arraycopy(tmp, 0, outbuf, offset, tmp.length);
141: return tmp.length;
142: }
143:
144: /**
145: * @com.intel.drl.spec_ref
146: *
147: */
148: protected abstract boolean engineVerify(byte[] sigBytes)
149: throws SignatureException;
150:
151: /**
152: * @com.intel.drl.spec_ref
153: *
154: */
155: protected boolean engineVerify(byte[] sigBytes, int offset,
156: int length) throws SignatureException {
157: byte tmp[] = new byte[length];
158: System.arraycopy(sigBytes, offset, tmp, 0, length);
159: return engineVerify(tmp);
160: }
161:
162: /**
163: * @com.intel.drl.spec_ref
164: *
165: * @deprecated Use
166: * {@link SignatureSpi#engineSetParameter(AlgorithmParameterSpec) engineSetParameter}
167: */
168: @Deprecated
169: protected abstract void engineSetParameter(String param,
170: Object value) throws InvalidParameterException;
171:
172: /**
173: * @com.intel.drl.spec_ref
174: *
175: */
176: protected void engineSetParameter(AlgorithmParameterSpec params)
177: throws InvalidAlgorithmParameterException {
178: throw new UnsupportedOperationException();
179: }
180:
181: /**
182: * @com.intel.drl.spec_ref
183: *
184: */
185: protected AlgorithmParameters engineGetParameters() {
186: throw new UnsupportedOperationException();
187: }
188:
189: /**
190: * @com.intel.drl.spec_ref
191: *
192: * @deprecated There is no generally accepted parameter naming convention.
193: */
194: @Deprecated
195: protected abstract Object engineGetParameter(String param)
196: throws InvalidParameterException;
197:
198: /**
199: * @com.intel.drl.spec_ref
200: *
201: */
202: public Object clone() throws CloneNotSupportedException {
203: if (this instanceof Cloneable) {
204: return super .clone();
205: } else {
206: throw new CloneNotSupportedException();
207: }
208: }
209: }
|