001: package org.bouncycastle.jce.provider.test;
002:
003: import java.math.BigInteger;
004: import java.security.KeyFactory;
005: import java.security.KeyPair;
006: import java.security.KeyPairGenerator;
007: import java.security.MessageDigest;
008: import java.security.PrivateKey;
009: import java.security.PublicKey;
010: import java.security.SecureRandom;
011: import java.security.Security;
012: import java.security.Signature;
013: import java.security.spec.RSAPrivateKeySpec;
014: import java.security.spec.RSAPublicKeySpec;
015:
016: import javax.crypto.Cipher;
017:
018: import org.bouncycastle.jce.provider.BouncyCastleProvider;
019: import org.bouncycastle.util.Arrays;
020: import org.bouncycastle.util.encoders.Hex;
021: import org.bouncycastle.util.test.SimpleTest;
022:
023: public class SigTest extends SimpleTest {
024: /**
025: * signature with a "forged signature" (sig block not at end of plain text)
026: */
027: private void testBadSig(PrivateKey priv, PublicKey pub)
028: throws Exception {
029: MessageDigest sha1 = MessageDigest.getInstance("SHA1", "BC");
030: Cipher signer = Cipher
031: .getInstance("RSA/ECB/PKCS1Padding", "BC");
032:
033: signer.init(Cipher.ENCRYPT_MODE, priv);
034:
035: byte[] block = new byte[signer.getBlockSize()];
036:
037: sha1.update((byte) 0);
038:
039: byte[] sigHeader = Hex.decode("3021300906052b0e03021a05000414");
040: System.arraycopy(sigHeader, 0, block, 0, sigHeader.length);
041:
042: byte[] dig = sha1.digest();
043:
044: System.arraycopy(dig, 0, block, sigHeader.length, dig.length);
045:
046: System.arraycopy(sigHeader, 0, block, sigHeader.length
047: + dig.length, sigHeader.length);
048:
049: byte[] sig = signer.doFinal(block);
050:
051: Signature verifier = Signature.getInstance("SHA1WithRSA", "BC");
052:
053: verifier.initVerify(pub);
054:
055: verifier.update((byte) 0);
056:
057: if (verifier.verify(sig)) {
058: fail("bad signature passed");
059: }
060: }
061:
062: public void performTest() throws Exception {
063: Signature sig = Signature.getInstance("SHA1WithRSAEncryption",
064: "BC");
065: KeyPairGenerator fact;
066: KeyPair keyPair;
067: byte[] data = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
068:
069: fact = KeyPairGenerator.getInstance("RSA", "BC");
070:
071: fact.initialize(768, new SecureRandom());
072:
073: keyPair = fact.generateKeyPair();
074:
075: PrivateKey signingKey = keyPair.getPrivate();
076: PublicKey verifyKey = keyPair.getPublic();
077:
078: testBadSig(signingKey, verifyKey);
079:
080: sig.initSign(signingKey);
081:
082: sig.update(data);
083:
084: byte[] sigBytes = sig.sign();
085:
086: sig.initVerify(verifyKey);
087:
088: sig.update(data);
089:
090: if (!sig.verify(sigBytes)) {
091: fail("SHA1 verification failed");
092: }
093:
094: sig = Signature.getInstance("MD2WithRSAEncryption", "BC");
095:
096: sig.initSign(signingKey);
097:
098: sig.update(data);
099:
100: sigBytes = sig.sign();
101:
102: sig.initVerify(verifyKey);
103:
104: sig.update(data);
105:
106: if (!sig.verify(sigBytes)) {
107: fail("MD2 verification failed");
108: }
109:
110: sig = Signature.getInstance("MD5WithRSAEncryption", "BC");
111:
112: sig.initSign(signingKey);
113:
114: sig.update(data);
115:
116: sigBytes = sig.sign();
117:
118: sig.initVerify(verifyKey);
119:
120: sig.update(data);
121:
122: if (!sig.verify(sigBytes)) {
123: fail("MD5 verification failed");
124: }
125:
126: sig = Signature.getInstance("RIPEMD160WithRSAEncryption", "BC");
127:
128: sig.initSign(signingKey);
129:
130: sig.update(data);
131:
132: sigBytes = sig.sign();
133:
134: sig.initVerify(verifyKey);
135:
136: sig.update(data);
137:
138: if (!sig.verify(sigBytes)) {
139: fail("RIPEMD160 verification failed");
140: }
141:
142: //
143: // RIPEMD-128
144: //
145: sig = Signature.getInstance("RIPEMD128WithRSAEncryption", "BC");
146:
147: sig.initSign(signingKey);
148:
149: sig.update(data);
150:
151: sigBytes = sig.sign();
152:
153: sig.initVerify(verifyKey);
154:
155: sig.update(data);
156:
157: if (!sig.verify(sigBytes)) {
158: fail("RIPEMD128 verification failed");
159: }
160:
161: //
162: // RIPEMD256
163: //
164: sig = Signature.getInstance("RIPEMD256WithRSAEncryption", "BC");
165:
166: sig.initSign(signingKey);
167:
168: sig.update(data);
169:
170: sigBytes = sig.sign();
171:
172: sig.initVerify(verifyKey);
173:
174: sig.update(data);
175:
176: if (!sig.verify(sigBytes)) {
177: fail("RIPEMD256 verification failed");
178: }
179:
180: //
181: // SHA-224
182: //
183: sig = Signature.getInstance("SHA224WithRSAEncryption", "BC");
184:
185: sig.initSign(signingKey);
186:
187: sig.update(data);
188:
189: sigBytes = sig.sign();
190:
191: sig.initVerify(verifyKey);
192:
193: sig.update(data);
194:
195: if (!sig.verify(sigBytes)) {
196: fail("SHA224 verification failed");
197: }
198:
199: //
200: // SHA-256
201: //
202: sig = Signature.getInstance("SHA256WithRSAEncryption", "BC");
203:
204: sig.initSign(signingKey);
205:
206: sig.update(data);
207:
208: sigBytes = sig.sign();
209:
210: sig.initVerify(verifyKey);
211:
212: sig.update(data);
213:
214: if (!sig.verify(sigBytes)) {
215: fail("SHA256 verification failed");
216: }
217:
218: //
219: // SHA-384
220: //
221: sig = Signature.getInstance("SHA384WithRSAEncryption", "BC");
222:
223: sig.initSign(signingKey);
224:
225: sig.update(data);
226:
227: sigBytes = sig.sign();
228:
229: sig.initVerify(verifyKey);
230:
231: sig.update(data);
232:
233: if (!sig.verify(sigBytes)) {
234: fail("SHA384 verification failed");
235: }
236:
237: //
238: // SHA-512
239: //
240: sig = Signature.getInstance("SHA512WithRSAEncryption", "BC");
241:
242: sig.initSign(signingKey);
243:
244: sig.update(data);
245:
246: sigBytes = sig.sign();
247:
248: sig.initVerify(verifyKey);
249:
250: sig.update(data);
251:
252: if (!sig.verify(sigBytes)) {
253: fail("SHA512 verification failed");
254: }
255:
256: //
257: // ISO Sigs.
258: //
259: sig = Signature.getInstance("MD5WithRSA/ISO9796-2", "BC");
260:
261: sig.initSign(signingKey);
262:
263: sig.update(data);
264:
265: sigBytes = sig.sign();
266:
267: sig.initVerify(verifyKey);
268:
269: sig.update(data);
270:
271: if (!sig.verify(sigBytes)) {
272: fail("MD5/ISO verification failed");
273: }
274:
275: sig = Signature.getInstance("SHA1WithRSA/ISO9796-2", "BC");
276:
277: sig.initSign(signingKey);
278:
279: sig.update(data);
280:
281: sigBytes = sig.sign();
282:
283: sig.initVerify(verifyKey);
284:
285: sig.update(data);
286:
287: if (!sig.verify(sigBytes)) {
288: fail("SHA1/ISO verification failed");
289: }
290:
291: sig = Signature.getInstance("RIPEMD160WithRSA/ISO9796-2", "BC");
292:
293: sig.initSign(signingKey);
294:
295: sig.update(data);
296:
297: sigBytes = sig.sign();
298:
299: sig.initVerify(verifyKey);
300:
301: sig.update(data);
302:
303: if (!sig.verify(sigBytes)) {
304: fail("RIPEMD160/ISO verification failed");
305: }
306:
307: //
308: // standard vector test - B.1.3 RIPEMD160, implicit.
309: //
310: BigInteger mod = new BigInteger(
311: "ffffffff78f6c55506c59785e871211ee120b0b5dd644aa796d82413a47b24573f1be5745b5cd9950f6b389b52350d4e01e90009669a8720bf265a2865994190a661dea3c7828e2e7ca1b19651adc2d5",
312: 16);
313: BigInteger pub = new BigInteger("03", 16);
314: BigInteger pri = new BigInteger(
315: "2aaaaaaa942920e38120ee965168302fd0301d73a4e60c7143ceb0adf0bf30b9352f50e8b9e4ceedd65343b2179005b2f099915e4b0c37e41314bb0821ad8330d23cba7f589e0f129b04c46b67dfce9d",
316: 16);
317:
318: KeyFactory f = KeyFactory.getInstance("RSA", "BC");
319:
320: PrivateKey privKey = f.generatePrivate(new RSAPrivateKeySpec(
321: mod, pri));
322: PublicKey pubKey = f.generatePublic(new RSAPublicKeySpec(mod,
323: pub));
324: byte[] testSig = Hex
325: .decode("5cf9a01854dbacaec83aae8efc563d74538192e95466babacd361d7c86000fe42dcb4581e48e4feb862d04698da9203b1803b262105104d510b365ee9c660857ba1c001aa57abfd1c8de92e47c275cae");
326:
327: data = Hex
328: .decode("fedcba9876543210fedcba9876543210fedcba9876543210fedcba9876543210fedcba9876543210fedcba9876543210fedcba9876543210fedcba9876543210fedcba9876543210fedcba9876543210fedcba9876543210fedcba9876543210fedcba9876543210fedcba9876543210");
329:
330: sig = Signature.getInstance("RIPEMD160WithRSA/ISO9796-2", "BC");
331:
332: sig.initSign(privKey);
333:
334: sig.update(data);
335:
336: sigBytes = sig.sign();
337:
338: if (!Arrays.areEqual(testSig, sigBytes)) {
339: fail("SigTest: failed ISO9796-2 generation Test");
340: }
341:
342: sig.initVerify(pubKey);
343:
344: sig.update(data);
345:
346: if (!sig.verify(sigBytes)) {
347: fail("RIPEMD160/ISO verification failed");
348: }
349: }
350:
351: public String getName() {
352: return "SigTest";
353: }
354:
355: public static void main(String[] args) {
356: Security.addProvider(new BouncyCastleProvider());
357:
358: runTest(new SigTest());
359: }
360: }
|