/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* Notes.
* 1. The class doesn't contain tests against "update(..)" methods
* invoked on a Signature objects whose state is "INIT" or "VERIFY".
* Relevant checks are in tests against MessageDigest class methods.
*
* 2. The testSignbyteArrayintint03() is commented out
* because of compatibility with RI issue in current implementation of the Signature class.
*/
package org.apache.harmony.security.tests.provider.crypto;
import java.math.BigInteger;
import java.security.InvalidKeyException;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.Signature;
import java.security.SignatureException;
import java.security.interfaces.DSAParams;
import java.security.interfaces.DSAPrivateKey;
import java.security.interfaces.DSAPublicKey;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.DSAParameterSpec;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
public class SHA1withDSA_SignatureTest extends TestCase {
private static final String algorithm = "SHA1withDSA";
private static final String provider = "Crypto";
private static final String provider1 = "BC"; // see testVerifybyteArray04()
private Signature signs[];
private Signature signingSigns[];
private Signature verifyingSign;
private static KeyPair keys;
private static KeyPairGenerator keyPairGenerator;
private static final BigInteger MINUS_ONE = BigInteger.valueOf(-1);
private static final BigInteger params[][] = new BigInteger[][] {
{ BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO },
{ BigInteger.ZERO, BigInteger.ZERO, BigInteger.ONE },
{ BigInteger.ZERO, BigInteger.ONE, BigInteger.ONE },
{ BigInteger.ONE, BigInteger.ZERO, BigInteger.ONE },
{ BigInteger.ONE, BigInteger.ONE, BigInteger.ONE },
{ MINUS_ONE, MINUS_ONE, MINUS_ONE },
{ BigInteger.ONE, BigInteger.ONE, MINUS_ONE },
{ MINUS_ONE, BigInteger.ONE, BigInteger.ONE },
{ BigInteger.ONE, MINUS_ONE, BigInteger.ONE }, };
private static PrivateKey privateKey;
private static PublicKey publicKey;
private static PrivateKey privateKey2;
private static PublicKey publicKey2;
private static PrivateKey myRSAPrivateKey;
private static PublicKey myRSAPublicKey;
private static SecureRandom mySecureRandom;
private static byte signature[];
private static byte bytes1[] = new byte[1000];
private static byte bytes2[] = new byte[10];
private static byte message[] = new byte[1000];
// offset to use in corresponding methods
private static int offset;
private static boolean flag;
static {
try {
keyPairGenerator = KeyPairGenerator.getInstance("DSA");
keyPairGenerator.initialize(1024);
keys = keyPairGenerator.generateKeyPair();
privateKey = keys.getPrivate();
publicKey = keys.getPublic();
privateKey2 = Predefined.getPrivateKey();
publicKey2 = Predefined.getPublicKey();
myRSAPrivateKey = getRSAPrivateKey();
myRSAPublicKey = getRSAPublicKey();
mySecureRandom = new SecureRandom();
mySecureRandom.nextBytes(bytes1);
mySecureRandom.nextBytes(bytes2);
mySecureRandom.nextBytes(message);
byte myByte[] = new byte[1];
mySecureRandom.nextBytes(myByte);
offset = myByte[0] & 037;
flag = true;
} catch (Exception e) {
flag = false;
}
}
/*
* @see TestCase#setUp()
*/
protected void setUp() throws Exception {
if (!flag) {
throw new Exception("some problem in static initializer");
}
super.setUp();
signs = new Signature[] { Signature.getInstance(algorithm, provider),
Signature.getInstance(algorithm, provider),
Signature.getInstance(algorithm, provider),
Signature.getInstance(algorithm, provider),
Signature.getInstance(algorithm, provider) };
signs[1].initSign(privateKey);
signs[2].initSign(privateKey, null);
signs[3].initSign(privateKey, mySecureRandom);
signs[4].initVerify(publicKey);
signingSigns = new Signature[] { signs[1], signs[2], signs[3] };
verifyingSign = signs[4];
}
static private DSAPrivateKey getDSAPrivateKey(BigInteger p, BigInteger q,
BigInteger g, BigInteger x) {
final BigInteger pp = p;
final BigInteger qq = q;
final BigInteger gg = g;
final BigInteger xx = x;
return new DSAPrivateKey() {
public BigInteger getX() {
return xx;
}
public DSAParams getParams() {
BigInteger p = pp;
BigInteger q = qq;
BigInteger g = gg;
return new DSAParameterSpec(p, q, g);
}
public String getAlgorithm() {
return "dummy";
}
public byte[] getEncoded() {
return new byte[0];
}
public String getFormat() {
return "dummy";
}
};
}
static private DSAPublicKey getDSAPublicKey(BigInteger p, BigInteger q,
BigInteger g, BigInteger y) {
final BigInteger pp = p;
final BigInteger qq = q;
final BigInteger gg = g;
final BigInteger yy = y;
return new DSAPublicKey() {
public BigInteger getY() {
return yy;
}
public DSAParams getParams() {
BigInteger p = pp;
BigInteger q = qq;
BigInteger g = gg;
return new DSAParameterSpec(p, q, g);
}
public String getAlgorithm() {
return "dummy";
}
public byte[] getEncoded() {
return new byte[0];
}
public String getFormat() {
return "dummy";
}
};
}
static private RSAPrivateKey getRSAPrivateKey() {
return new RSAPrivateKey() {
public BigInteger getPrivateExponent() {
return BigInteger.ZERO;
}
public BigInteger getModulus() {
return BigInteger.ZERO;
}
public String getAlgorithm() {
return "RSA";
}
public byte[] getEncoded() {
return new byte[] { 0 };
}
public String getFormat() {
return "fff";
}
};
}
static private RSAPublicKey getRSAPublicKey() {
return new RSAPublicKey() {
public BigInteger getPublicExponent() {
return BigInteger.ZERO;
}
public BigInteger getModulus() {
return BigInteger.ZERO;
}
public String getAlgorithm() {
return "RSA";
}
public byte[] getEncoded() {
return new byte[] { 0 };
}
public String getFormat() {
return "fff";
}
};
}
/**
* The test against "initSign(PrivateKey)" method.
* It checks out that regardless of a Signature object's state
* the method throws InvalidKeyException if PrivateKey is null or not DSAPrivateKey
*/
public final void testInitSignPrivateKey01() {
for (int i = 0; i < signs.length; i++) {
try {
signs[i].initSign(null);
fail("case1: no InvalidKeyException : i=" + i);
} catch (InvalidKeyException e) {}
try {
signs[i].initSign(myRSAPrivateKey);
fail("case: no InvalidKeyException : i=" + i);
} catch (InvalidKeyException e) {}
}
}
/**
* The test against "initSign(PrivateKey)" method.
* It checks out that regardless of a Signature object's state
* the method throws InvalidKeyException if
* PrivateKey is DSAPrivateKey and the key is invalid, that is,
* BigIntegers constituting the key have incorrect values.
*/
public final void testInitSignPrivateKey02() throws Exception {
for (int i = 0; i < signs.length; i++) {
for (int j = 0; j < params.length; j++) {
try {
signs[i].initSign(getDSAPrivateKey(params[j][0],
params[j][1], params[j][2], BigInteger.ZERO));
fail("no InvalidKeyException : i =" + i + " j=" + j);
} catch (InvalidKeyException e) {}
}
}
}
/**
* The test against the "initSign(PrivateKey)" method.
* It checks out that the method negates the effect of previous call
* if it is invoked with a different argument.
*
* Note.
* In RI, negating effect of previous call includes
* discarding updates done before calling the method.
*/
public final void testInitSignPrivateKey03() throws Exception {
// Initially all signing Signature objects are initialized with some PublicKey
// and the "verifyingSign" object with corresponding PrivateKey.
verifyingSign.initVerify(publicKey2);
for (int i = 0; i < signingSigns.length; i++) {
signingSigns[i].update(bytes1, 0, bytes1.length);
signingSigns[i].initSign(privateKey2); // another PrivateKey
signingSigns[i].update(bytes2, 0, bytes2.length);
signature = signingSigns[i].sign();
// it is expected that "signature" is one generated only for "bytes2" update
verifyingSign.update(bytes2, 0, bytes2.length);
assertTrue("returned 'false' : i=" + i, verifyingSign
.verify(signature));
}
}
/**
* The test against the "initSign(PrivateKey)" method.
* It checks out that the method negates the effect of previous call
* if it is invoked with the same argument.
*
* Notes.
* 1. In RI, negating effect of previous call includes
* discarding updates done before calling the method.
* 2.
* The specification for the method contains the following clause:
* "If this method is called again with a different argument,
* it negates the effect of this call."
* which meaning requires certainty in case of sequence
* initSign - update - initSign
* RI behavior is such that with respect to "update"
* it doesn't matter whether argument is the same or different.
*/
public final void testInitSignPrivateKey04() throws Exception {
for (int i = 0; i < signingSigns.length; i++) {
signingSigns[i].update(bytes1, 0, bytes1.length);
signingSigns[i].initSign(privateKey); // the same PrivateKey
signingSigns[i].update(bytes2, 0, bytes2.length);
signature = signingSigns[i].sign();
// it is expected that "signature" is one generated only for "bytes2" update
verifyingSign.update(bytes2, 0, bytes2.length);
assertTrue("returned 'false' : i=" + i, verifyingSign
.verify(signature));
}
}
/**
* The test against "initVerify(PublicKey)" methods
* It checks out that regardless of a Signature object's state
* the method throws InvalidKeyException if
* PublicKey is null or is not DSAPublicKey
*/
public final void testInitVerifyPublicKey01() {
PublicKey pk = null;
for (int i = 0; i < signs.length; i++) {
try {
signs[i].initVerify(pk);
fail("case1 : no InvalidKeyException i=" + i);
} catch (InvalidKeyException e) {}
try {
signs[i].initVerify(myRSAPublicKey);
fail("case2 : no InvalidKeyException i=" + i);
} catch (InvalidKeyException e) {}
}
}
/**
* The test against "initSign(PrivateKey)" method.
* It checks out that regardless of a Signature object's state
* the method throws InvalidKeyException if
* PublicKey is DSAPublicKey and the key is invalid, that is,
* BigIntegers constituting the key have incorrect values.
*/
public final void testInitVerifyPublicKey02() throws Exception {
for (int i = 0; i < signs.length; i++) {
for (int j = 0; j < params.length; j++) {
try {
signs[i].initVerify(getDSAPublicKey(params[j][0],
params[j][1], params[j][2], BigInteger.ZERO));
fail("no InvalidKeyException : i=" + i + " j=" + j);
} catch (InvalidKeyException e) {}
}
}
}
/**
* The test against the "initVerify(PublicKey)" method.
* It checks out that the method negates the effect of previous call
* if it is invoked with a different argument,
* that is, after initializing with PublicKey from another KeyPair
* the "verify" method returns "false".
*/
public final void testInitVerifyPublicKey03() throws Exception {
signingSigns[0].update(bytes1, 0, bytes1.length);
signature = signingSigns[0].sign();
verifyingSign.initVerify(publicKey2); // another key
verifyingSign.update(bytes1, 0, bytes1.length);
assertFalse("case1: returned 'true'", verifyingSign.verify(signature));
}
/**
* The test against the "initVerify(PublicKey)" method.
* It checks out that the method negates the effect of previous call
* if it is invoked with the same argument.
* Like it is for "initSign", RI behavior is such that with respect to "update"
* it doesn't matter whether argument is the same or different.
*
* Note.
* In RI negating effect of previous call includes
* discarding updates done before calling the method.
*/
public final void testInitVerifyPublicKey04() throws Exception {
signingSigns[0].update(bytes1, 0, bytes1.length);
signature = signingSigns[0].sign();
verifyingSign.update(bytes2, 0, bytes2.length);
verifyingSign.initVerify(publicKey); // the same key
verifyingSign.update(bytes1, 0, bytes1.length);
assertTrue("case2: returned 'false'", verifyingSign.verify(signature));
}
/*
* The method returns
* - -1 if a signature's syntax is incorrect
* - length of the signature otherwise.
*/
private int checkSignature(byte sig[], int offset) {
int n1 = sig[offset + 3];
int n2 = sig[offset + n1 + 5];
if (sig[offset] != 0x30 || sig[offset + 1] != (n1 + n2 + 4)
|| sig[offset + 2] != 2 || sig[offset + n1 + 4] != 2 || n1 > 21
|| n2 > 21) {
return -1;
}
return (n1 + n2 + 6);
}
/**
* The test against the "sign()" method.
* It checks out that Signature object returned by the method has correct ASN1 encoding.
*/
public final void testSign01() throws Exception {
byte sig[];
for (int i = 0; i < signingSigns.length; i++) {
signingSigns[i].update(message);
sig = signingSigns[i].sign();
try {
int n = checkSignature(sig, 0);
if (n < 0) {
fail("incorrect signature : i=" + i);
}
if (n != sig.length) {
fail("incorrect signature's length : n=" + n
+ " sig.length= " + sig.length);
}
} catch (ArrayIndexOutOfBoundsException e) {
fail("incorrect signature: " + e);
}
}
}
/**
* The test against the "sign(byte[], int, int)" method.
* It checks out that Signature object returned by the method has correct ASN1 encoding.
*/
public final void testSignbyteArrayintint01() throws Exception {
byte sig[] = new byte[offset + 100];
for (int i = 0; i < signingSigns.length; i++) {
int n1;
signingSigns[i].update(message);
n1 = signingSigns[i].sign(sig, offset, 50);
try {
int n2 = checkSignature(sig, offset);
if (n2 < 0) {
fail("signature bytes have invalid encoding");
}
if (n1 != n2) {
fail("incorrect signature's length : n1=" + n1 + " n2="
+ n2);
}
} catch (ArrayIndexOutOfBoundsException e) {
fail("incorrect signature: " + e);
}
}
}
/**
* The test agains the "sign(byte[], int, int)" method.
* It checks out that if a Signature object's state is SIGN
* passing to the object "offset" and "len" arguments that satisfy the condition:
* "offset + len <= outbuf.length"
* but "len" < actual length of signature results in throwing SignatureException.
*
* Note.
* As signature's length varies we use length value of 44 which is certainly less than signature's length,
*/
public final void testSignbyteArrayintint02() throws Exception {
byte sig[] = new byte[50];
for (int i = 0; i < signingSigns.length; i++) {
signingSigns[i].update(message);
try {
signingSigns[i].sign(sig, 0, 44);
fail("case1 : no SignatureException : i=" + i);
} catch (SignatureException e) {}
}
}
/**
* The test agains the "sign(byte[], int, int)" method.
* It checks out that if a Signature object's state is SIGN
* passing to the object "offset" and "len" arguments that satisfy the condition:
* "offset < 0" and "len" >= actual length of signature
* results in throwing ArrayIndexOutOfBoundsException.
*/
// public final void testSignbyteArrayintint03() throws Exception {
//
// byte sig[] = new byte[50];
//
// for ( int i = 0; i < signingSigns.length; i++ ) {
//
// signingSigns[i].update(message);
//
// // because 50 is more than length of any signature,
// // for offset==-1 and len==50 ArrayIndexOutOfBoundsException is expected
// //
// try {
// signingSigns[i].sign(sig, -1, 50);
// fail("no ArrayIndexOutOfBoundsException");
// } catch (ArrayIndexOutOfBoundsException e) {
// }
//
// // because 40 is less than length of any signature",
// //for offset==-1 and len==40 ArrayIndexOutOfBoundsException is not expected
// //
// try {
// signingSigns[i].sign(sig, -1, 40);
// fail("no SignatureException");
// } catch (ArrayIndexOutOfBoundsException e) {
// fail("ArrayIndexOutOfBoundsException");
// } catch (SignatureException e) {
// }
// }
// }
/**
* The test against the "verify(byte[])" method.
* It checks out that for given message and signature signed with some PrivateKey
* (1) the method returns "true" if PublicKey is from the same KeyPair,
* (2) the method returns "false" otherwise.
*/
public final void testVerifybyteArray01() throws Exception {
byte sigBytes[];
signingSigns[0].update(message);
sigBytes = signingSigns[0].sign();
verifyingSign.update(message);
assertTrue("case1: test failure", verifyingSign.verify(sigBytes));
verifyingSign.initVerify(publicKey2);
verifyingSign.update(message);
assertFalse("case2: test failure", verifyingSign.verify(sigBytes));
}
/**
* The test is against the pair "sign() - verify(byte[])" method.
* It checks out that the "verify" method returns "true"
* if a verifying Signature object was updated with the same message
* which was used to update a signing Signature object.
*/
public final void testVerifybyteArray02() throws Exception {
byte sig1[];
byte sig2[];
for (int i = 0; i < signingSigns.length; i++) {
signingSigns[i].update(bytes1);
verifyingSign.update(bytes1);
sig1 = signingSigns[i].sign();
assertTrue("case 1: test failure : i=" + i, verifyingSign
.verify(sig1));
signingSigns[i].update(bytes1);
signingSigns[i].update(bytes2);
verifyingSign.update(bytes1);
verifyingSign.update(bytes2);
sig2 = signingSigns[i].sign();
assertTrue("case 2: test failure : i=" + i, verifyingSign
.verify(sig2));
verifyingSign.update(bytes1);
verifyingSign.update(bytes2);
assertFalse("case 3: test failure : i=" + i, verifyingSign
.verify(sig1));
}
}
/**
* The compatibility with RI test.
* It checks out that
* for the predefined message and signature signed with PrivateKey from RI
* the method invoked on a Signature object initialized with corresponding PublicKey from RI
* returns "true".
*/
public final void testVerifybyteArray03() throws Exception {
verifyingSign.initVerify(publicKey2);
verifyingSign.update(Predefined.getMessage());
assertTrue("not verified", verifyingSign.verify(Predefined
.getSignature()));
}
/**
* The test against the pair "sign - verify" methods.
* Its specific is that signing and verifying are performed by two providers,
* provider and provider1;
* so, the test checks up on compatibility signing-verifying between implementations.
*/
public final void testVerifybyteArray04() throws Exception {
Signature signingSign, verifyingSign;
byte sigBytes[];
byte message[] = new byte[1000];
// testcase1 - signing with "provider", verifying with "provider1"
signingSign = Signature.getInstance(algorithm, provider);
verifyingSign = Signature.getInstance(algorithm, provider1);
mySecureRandom.nextBytes(message);
signingSign.initSign(privateKey);
signingSign.update(message);
sigBytes = signingSign.sign();
verifyingSign.initVerify(publicKey);
verifyingSign.update(message);
assertTrue("case1: test failure", verifyingSign.verify(sigBytes));
// testcase2 - signing with "provider1", verifying with "provider"
signingSign = Signature.getInstance(algorithm, provider1);
verifyingSign = Signature.getInstance(algorithm, provider);
mySecureRandom.nextBytes(message);
signingSign.initSign(privateKey);
signingSign.update(message);
sigBytes = signingSign.sign();
verifyingSign.initVerify(publicKey);
verifyingSign.update(message);
assertTrue("case2: test failure", verifyingSign.verify(sigBytes));
}
/**
* The test against the "verify(byte[], int, int)" method.
* It checks out that if Signature object's state is VERIFY
* the method throws IllegalArgumentException in case of the following arguments :
* outbufs == null or
* offset < 0 or
* length < 0 or
* offset+length > outbuf.length
*/
public final void testVerifybyteArrayintint01() throws Exception {
byte bArray[] = new byte[100];
// case1 : null byte array
try {
verifyingSign.verify(null, 0, 48);
fail("case1 : no IllegalArgumentException");
} catch (IllegalArgumentException e) {}
// case2 : len < 0
try {
verifyingSign.verify(bArray, 0, -1);
fail("case2 : no IllegalArgumentException");
} catch (IllegalArgumentException e) {}
// case3 : offset < 0
try {
verifyingSign.verify(bArray, -1, 48);
fail("case3: no IllegalArgumentException");
} catch (IllegalArgumentException e) {}
// case4 : offset+len > outbuf.length
try {
int k = bArray.length / 2;
verifyingSign.verify(bArray, k, bArray.length - k + 1);
fail("case4: no IllegalArgumentException");
} catch (IllegalArgumentException e) {}
}
/**
* The test against the "verify(byte[], int, int)" method.
* It checks out that if Signature object's state is VERIFY
* the method throws up SignatureException if
* (1) offset+length < 0
* (2) offset > signature.length
* (3) SignatureException if outbuf's lentgh is correct
* whereas a signature doesn't meet ASN1 syntax.
*/
public final void testVerifybyteArrayintint02() throws Exception {
byte sigBytes[] = new byte[100]; // wrong signature
try {
verifyingSign.verify(sigBytes, Integer.MAX_VALUE, 2);
fail("testcase1 : no SignatureException");
} catch (SignatureException e) {}
try {
verifyingSign.verify(sigBytes, 2, Integer.MAX_VALUE);
fail("testcase2 : no SignatureException");
} catch (SignatureException e) {}
verifyingSign.update(message);
try {
verifyingSign.verify(sigBytes, 0, 50);
fail("testcase3 : SignatureException");
} catch (SignatureException e) {}
}
/**
* The test is against the "verify(byte[], int, int)" method.
* It checks out that in case of correct signature the method throws SignatureException
* if value of "length" is less than signature's length
*/
public final void testVerifybyteArrayintint03() throws Exception {
byte sig[] = new byte[offset + 100];
verifyingSign.update(message);
for (int i = 0; i < signingSigns.length; i++) {
int n;
signingSigns[i].update(message);
n = signingSigns[i].sign(sig, offset, 50);
try {
verifyingSign.verify(sig, offset, n - 1);
fail("test failure : i=" + i + " offset=" + offset);
} catch (SignatureException e) {
verifyingSign.verify(sig, offset, n);
}
}
}
/**
* The test against the "verify(byte[], int, int)" method.
* It check out that if a call to the method returns normally
* a Signature object resets itself.
*/
public final void testVerifybyteArrayintint04() throws Exception {
byte sig[] = new byte[100];
int n = 0;
;
byte sigBytes[] = new byte[100]; // bytes for correct signature
// the signature has correct ASN1 syntax but its value is negative;
// so, the "verify(...)" methods should return "false" without throwing an exception
sig[0] = 48;
sig[1] = 44;
sig[2] = 2;
sig[3] = 20;
sig[4] = (byte) 0x8f; // negative value
sig[24] = 2;
sig[25] = 20;
sig[26] = (byte) 0x8f; // negative value
signingSigns[0].update(message);
n = signingSigns[0].sign(sigBytes, 0, 50);
// testcase1: first call returns true,
// second returns false though signature is the same
verifyingSign.update(message);
assertTrue("case1: test failure", verifyingSign.verify(sigBytes, 0, n));
assertFalse("case2: test failure", verifyingSign.verify(sigBytes, 0, n));
// testcase2: first call returns false (incorrect signature),
// second returns false too, in spite of correct signature (!),
// because Signature object was reset in first call
verifyingSign.update(message);
assertFalse("case3: test failure", verifyingSign.verify(sig, 0, 46));
assertFalse("case4: test failure", verifyingSign.verify(sigBytes, 0, n));
}
/**
* The test against the "verify(byte[], int, int)" method.
* It check out that a Signature object doesn't reset itself if
* the method throws up an exception.
*/
public final void testVerifybyteArrayintint05() throws Exception {
byte sig[] = new byte[100]; //incorrect signature
byte sigBytes[] = new byte[100];
int n = 0;
signingSigns[0].update(message);
n = signingSigns[0].sign(sigBytes, 0, 50);
verifyingSign.update(message);
try {
verifyingSign.verify(null, 0, n);
} catch (IllegalArgumentException e) {}
try {
verifyingSign.verify(sigBytes, -1, n);
} catch (IllegalArgumentException e) {}
try {
verifyingSign.verify(sigBytes, 0, -1);
} catch (IllegalArgumentException e) {}
try {
verifyingSign.verify(sigBytes, sigBytes.length - 10, 30);
} catch (IllegalArgumentException e) {}
try {
verifyingSign.verify(sigBytes, Integer.MAX_VALUE, n);
} catch (SignatureException e) {}
try {
verifyingSign.verify(sig, 0, n);
} catch (SignatureException e) {}
// if the method doesn't reset the expected result of verificaton is "true"
assertTrue("test failure : n=" + n, verifyingSign
.verify(sigBytes, 0, n));
}
/**
* The test is against the pair "sign(byte[],int,int) - verify(byte[],int,int)" method.
* It checks out that the "verify" method returns "true"
* if a verifying Signature object was updated with the same message
* which was used to update a signing Signature object.
*/
public final void testVerifybyteArrayintint06() throws Exception {
byte sig1[] = new byte[offset + 100];
byte sig2[] = new byte[offset + 100];
int n1, n2;
for (int i = 0; i < signingSigns.length; i++) {
signingSigns[i].update(bytes1);
verifyingSign.update(bytes1);
n1 = signingSigns[i].sign(sig1, offset, 50);
assertTrue("case 1: test failure : i=" + i + " offset=" + offset,
verifyingSign.verify(sig1, offset, n1));
signingSigns[i].update(bytes1);
signingSigns[i].update(bytes2);
verifyingSign.update(bytes1);
verifyingSign.update(bytes2);
n2 = signingSigns[i].sign(sig2, offset, 50);
assertTrue("case 2: test failure : i=" + i + " offset=" + offset,
verifyingSign.verify(sig2, offset, n2));
verifyingSign.update(bytes1);
verifyingSign.update(bytes2);
assertFalse("case 3: test failure : i=" + i + " offset=" + offset,
verifyingSign.verify(sig1, offset, n1));
}
}
public static Test suite() {
return new TestSuite(SHA1withDSA_SignatureTest.class);
}
public static void main(String[] args) {
junit.textui.TestRunner.run(suite());
}
}
class Predefined {
static DSAPublicKey publicKey = new DSAPublicKey() {
byte yb[] = new byte[] { 91, 91, -5, 113, -35, 61, -111, -29, -59, -5,
-53, -72, 93, 38, 81, 10, -75, 122, -60, -88, -74, -91, -108,
88, 55, -57, 119, -2, -104, -71, 83, 45, -55, -111, 46, -23,
-113, -34, 105, 18, -36, -33, 3, 21, 23, 93, -128, -52, 42,
-11, 55, 50, -27, 51, 49, 50, -20, -92, -120, -56, 28, -114,
-30, 36, -91, -102, 39, -50, -104, -73, -94, -34, -99, -25, 76,
-40, 4, -89, 1, -107, -66, -87, -112, 22, -40, -118, 59, -26,
90, -90, -103, -75, -104, 26, -31, 54, -95, 105, 67, -4, -44,
35, -75, 0, -69, 60, 65, -78, 49, 5, 1, 111, -122, 83, 22, -35,
-65, 122, 120, -104, -78, -25, -35, 12, -106, 101, 21, 33 };
byte pb[] = new byte[] { 0, -3, 127, 83, -127, 29, 117, 18, 41, 82,
-33, 74, -100, 46, -20, -28, -25, -10, 17, -73, 82, 60, -17,
68, 0, -61, 30, 63, -128, -74, 81, 38, 105, 69, 93, 64, 34, 81,
-5, 89, 61, -115, 88, -6, -65, -59, -11, -70, 48, -10, -53,
-101, 85, 108, -41, -127, 59, -128, 29, 52, 111, -14, 102, 96,
-73, 107, -103, 80, -91, -92, -97, -97, -24, 4, 123, 16, 34,
-62, 79, -69, -87, -41, -2, -73, -58, 27, -8, 59, 87, -25, -58,
-88, -90, 21, 15, 4, -5, -125, -10, -45, -59, 30, -61, 2, 53,
84, 19, 90, 22, -111, 50, -10, 117, -13, -82, 43, 97, -41, 42,
-17, -14, 34, 3, 25, -99, -47, 72, 1, -57 };
byte qb[] = new byte[] { 0, -105, 96, 80, -113, 21, 35, 11, -52, -78,
-110, -71, -126, -94, -21, -124, 11, -16, 88, 28, -11 };
byte gb[] = new byte[] { 0, -9, -31, -96, -123, -42, -101, 61, -34,
-53, -68, -85, 92, 54, -72, 87, -71, 121, -108, -81, -69, -6,
58, -22, -126, -7, 87, 76, 11, 61, 7, -126, 103, 81, 89, 87,
-114, -70, -44, 89, 79, -26, 113, 7, 16, -127, -128, -76, 73,
22, 113, 35, -24, 76, 40, 22, 19, -73, -49, 9, 50, -116, -56,
-90, -31, 60, 22, 122, -117, 84, 124, -115, 40, -32, -93, -82,
30, 43, -77, -90, 117, -111, 110, -93, 127, 11, -6, 33, 53, 98,
-15, -5, 98, 122, 1, 36, 59, -52, -92, -15, -66, -88, 81, -112,
-119, -88, -125, -33, -31, 90, -27, -97, 6, -110, -117, 102,
94, -128, 123, 85, 37, 100, 1, 76, 59, -2, -49, 73, 42 };
public BigInteger getY() {
return new BigInteger(yb);
}
public DSAParams getParams() {
BigInteger p = new BigInteger(pb);
BigInteger q = new BigInteger(qb);
BigInteger g = new BigInteger(gb);
return (DSAParams) (new DSAParameterSpec(p, q, g));
}
public String getAlgorithm() {
return "DSA";
}
public byte[] getEncoded() {
return null;
}
public String getFormat() {
return null;
}
};
static DSAPrivateKey privateKey = new DSAPrivateKey() {
byte xb[] = new byte[] { 12, 31, -39, 65, -61, -54, -91, 37, -93, -115,
81, 122, -24, -104, -31, -106, 113, -39, -69, 34 };
byte pb[] = new byte[] { 0, -3, 127, 83, -127, 29, 117, 18, 41, 82,
-33, 74, -100, 46, -20, -28, -25, -10, 17, -73, 82, 60, -17,
68, 0, -61, 30, 63, -128, -74, 81, 38, 105, 69, 93, 64, 34, 81,
-5, 89, 61, -115, 88, -6, -65, -59, -11, -70, 48, -10, -53,
-101, 85, 108, -41, -127, 59, -128, 29, 52, 111, -14, 102, 96,
-73, 107, -103, 80, -91, -92, -97, -97, -24, 4, 123, 16, 34,
-62, 79, -69, -87, -41, -2, -73, -58, 27, -8, 59, 87, -25, -58,
-88, -90, 21, 15, 4, -5, -125, -10, -45, -59, 30, -61, 2, 53,
84, 19, 90, 22, -111, 50, -10, 117, -13, -82, 43, 97, -41, 42,
-17, -14, 34, 3, 25, -99, -47, 72, 1, -57 };
byte qb[] = new byte[] { 0, -105, 96, 80, -113, 21, 35, 11, -52, -78,
-110, -71, -126, -94, -21, -124, 11, -16, 88, 28, -11 };
byte gb[] = new byte[] { 0, -9, -31, -96, -123, -42, -101, 61, -34,
-53, -68, -85, 92, 54, -72, 87, -71, 121, -108, -81, -69, -6,
58, -22, -126, -7, 87, 76, 11, 61, 7, -126, 103, 81, 89, 87,
-114, -70, -44, 89, 79, -26, 113, 7, 16, -127, -128, -76, 73,
22, 113, 35, -24, 76, 40, 22, 19, -73, -49, 9, 50, -116, -56,
-90, -31, 60, 22, 122, -117, 84, 124, -115, 40, -32, -93, -82,
30, 43, -77, -90, 117, -111, 110, -93, 127, 11, -6, 33, 53, 98,
-15, -5, 98, 122, 1, 36, 59, -52, -92, -15, -66, -88, 81, -112,
-119, -88, -125, -33, -31, 90, -27, -97, 6, -110, -117, 102,
94, -128, 123, 85, 37, 100, 1, 76, 59, -2, -49, 73, 42 };
public BigInteger getX() {
return new BigInteger(xb);
}
public DSAParams getParams() {
BigInteger p = new BigInteger(pb);
BigInteger q = new BigInteger(qb);
BigInteger g = new BigInteger(gb);
return (DSAParams) (new DSAParameterSpec(p, q, g));
}
public String getAlgorithm() {
return "DSA";
}
public byte[] getEncoded() {
return null;
}
public String getFormat() {
return null;
}
};
static byte msg[] = new byte[] { -126, -74, -45, -105, 31, 30, 76, -78, 56,
31, -67, -7, 40, 36, -59, -1, -41, -46, -63, -98, -10, -56, 18, 69,
107, -118, -70, -9, -32, 49, -48, 11, -73, 98, -67, 82, 96, 126,
24, -40, -15, 20, 81, 103, 119, -114, -9, -85, 56, 20, -98, 89,
-37, 34, -44, 19, -19, -126, -87, -40, -102, -96, 102, -30, 30,
115, -68, -108, -44, 88, -65, 35, 85, 123, -1, -82, 110, 67, 99,
84, -32, 44, 67, 75, -121, 28, -128, 49, -54, 52, 53, 119, -114,
-99, -61, -58, -119, -97, 91, 66 };
static byte sig[] = new byte[] { 48, 44, 2, 20, 33, -6, -66, -52, 17, -91,
-90, 83, -128, 73, -114, 49, 118, 82, -65, 123, -19, 94, -26, 106,
2, 20, 59, 75, -86, -115, 94, -125, 80, -91, -57, 61, -73, -5,
-109, -93, 103, -10, -73, -21, 99, 81 };
static byte[] getMessage() {
return msg;
}
static byte[] getSignature() {
return sig;
}
static int getSignatureLength() {
return sig.length;
}
static DSAPublicKey getPublicKey() {
return publicKey;
}
static DSAPrivateKey getPrivateKey() {
return privateKey;
}
}