DSA Signature sign/verify using BC/Standard JCE

[George Politis]

Hi all,

If there's anyone crypto-savvy around here, I'd really appreciate it if he could have a look at this test cases http://pastebin.ca/1490739 and tell me why 2 of them fail.

Thanks in advance.

I paste the code here too.

package you.name.it;

import java.io.*;
import java.math.*;
import java.nio.*;
import java.security.*;
import java.security.interfaces.*;
import java.util.*;
import org.bouncycastle.asn1.*;
import org.bouncycastle.crypto.params.*;
import org.bouncycastle.crypto.signers.*;
import org.bouncycastle.util.*;
import org.junit.*;

public class CryptoUtilsTest extends junit.framework.TestCase {

	@Test
	public void testSignWithBCVerifyWithBC() throws Exception {

		KeyPair pair = generateDsaKeyPair();
		byte[] b = getRandomBytes(32);

		BigInteger[] rs = signWithBC(b, pair.getPrivate());

		byte[] rsb = toByteArray(rs);
		assertTrue(verifyWithBC(b, pair.getPublic(), rsb));

		assertTrue(verifyWithBC(b, pair.getPublic(), rs[0], rs[1]));

		byte[] asnSignature = derEncode(rs[0], rs[1]);
		BigInteger[] rsCalculated = derDecode(asnSignature);
		assertTrue(verifyWithBC(b, pair.getPublic(), rsCalculated[0],
				rsCalculated[1]));
	}

	@Test
	public void testSignWithJCEVerifyWithJCE() throws Exception {

		KeyPair pair = generateDsaKeyPair();
		byte[] b = getRandomBytes(32);

		byte[] asnSignature = signWithStandardJCE(b, pair.getPrivate());

		assertTrue(verifyWithStandardJCE(b, pair.getPublic(), asnSignature));

		BigInteger[] rs = derDecode(asnSignature);
		byte[] asnSignatureCalculated = derEncode(rs[0], rs[1]);

		assertTrue(verifyWithStandardJCE(b, pair.getPublic(),
				asnSignatureCalculated));
	}

	@Test
	public void testSignWithBCVerifyWithJCE() throws Exception {

		KeyPair pair = generateDsaKeyPair();
		byte[] b = getRandomBytes(32);

		BigInteger[] rs = signWithBC(b, pair.getPrivate());
		byte[] asnSignature = derEncode(rs[0], rs[1]);

		Boolean result = verifyWithStandardJCE(b, pair.getPublic(),
				asnSignature);
		assertTrue(result);
	}

	@Test
	public void testSignWithJCEVerifyWithBC() throws Exception {
		KeyPair pair = generateDsaKeyPair();
		byte[] b = getRandomBytes(32);
		byte[] asnSignature = signWithStandardJCE(b, pair.getPrivate());

		BigInteger[] rs = derDecode(asnSignature);
		assertTrue(verifyWithBC(b, pair.getPublic(), rs[0], rs[1]));
	}

	private static BigInteger[] derDecode(byte[] encoding) throws IOException {
		ASN1InputStream aIn = new ASN1InputStream(encoding);
		ASN1Sequence s = (ASN1Sequence) aIn.readObject();

		BigInteger[] sig = new BigInteger[2];

		sig[0] = ((DERInteger) s.getObjectAt(0)).getValue();
		sig[1] = ((DERInteger) s.getObjectAt(1)).getValue();

		return sig;
	}

	private static byte[] derEncode(BigInteger r, BigInteger s)
			throws IOException {
		ByteArrayOutputStream bos = new ByteArrayOutputStream();
		DERSequenceGenerator seqGen = new DERSequenceGenerator(bos);

		seqGen.addObject(new DERInteger(r));
		seqGen.addObject(new DERInteger(s));
		seqGen.close();

		byte[] asnsignature = bos.toByteArray();
		bos.close();
		seqGen.close();
		return asnsignature;
	}

	private static byte[] signWithStandardJCE(byte[] b, PrivateKey privatekey)
			throws NoSuchAlgorithmException, InvalidKeyException,
			SignatureException {

		Signature signer = Signature.getInstance(privatekey.getAlgorithm());
		signer.initSign(privatekey);
		signer.update(b);
		return signer.sign();
	}

	private byte[] toByteArray(BigInteger[] rs) {
		byte[] rb = BigIntegers.asUnsignedByteArray(rs[0]);
		byte[] sb = BigIntegers.asUnsignedByteArray(rs[1]);
		ByteBuffer buff = ByteBuffer.allocate(rb.length + sb.length);
		buff.put(rb);
		buff.put(sb);
		return buff.array();
	}

	private static BigInteger[] signWithBC(byte[] b, PrivateKey privatekey)
			throws NoSuchAlgorithmException, InvalidKeyException,
			SignatureException {

		if (!(privatekey instanceof DSAPrivateKey))
			throw new IllegalArgumentException();

		DSAParams dsaParams = ((DSAPrivateKey) privatekey).getParams();
		DSAParameters bcDSAParams = new DSAParameters(dsaParams.getP(),
				dsaParams.getQ(), dsaParams.getG());

		DSAPrivateKey dsaPrivateKey = (DSAPrivateKey) privatekey;
		DSAPrivateKeyParameters dsaPrivParms = new DSAPrivateKeyParameters(
				dsaPrivateKey.getX(), bcDSAParams);

		DSASigner dsaSigner = new DSASigner();
		dsaSigner.init(true, dsaPrivParms);

		return dsaSigner.generateSignature(b);
	}

	private static Boolean verifyWithBC(byte[] b, PublicKey pubKey, byte[] rs)
			throws NoSuchAlgorithmException, InvalidKeyException,
			SignatureException {

		if (!(pubKey instanceof DSAPublicKey))
			throw new IllegalArgumentException();

		DSAParams dsaParams = ((DSAPublicKey) pubKey).getParams();
		int qlen = dsaParams.getQ().bitLength() / 8;
		ByteBuffer buff = ByteBuffer.wrap(rs);
		byte[] r = new byte[qlen];
		buff.get(r);
		byte[] s = new byte[qlen];
		buff.get(s);
		return verifyWithBC(b, pubKey, r, s);
	}

	private static Boolean verifyWithBC(byte[] b, PublicKey pubKey, byte[] r,
			byte[] s) throws InvalidKeyException, NoSuchAlgorithmException,
			SignatureException {
		Boolean result = verifyWithBC(b, pubKey, new BigInteger(1, r),
				new BigInteger(1, s));
		return result;
	}

	private static Boolean verifyWithBC(byte[] b, PublicKey pubKey,
			BigInteger r, BigInteger s) throws NoSuchAlgorithmException,
			InvalidKeyException, SignatureException {

		if (!(pubKey instanceof DSAPublicKey))
			throw new IllegalArgumentException();

		/*
		 * Signature signer = Signature.getInstance(pubKey.getAlgorithm());
		 * signer.initVerify(pubKey); signer.update(b); Boolean result =
		 * signer.verify(signature);
		 */
		// construct the BC objects from pub key specs
		DSAParams dsaParams = ((DSAPublicKey) pubKey).getParams();
		DSAParameters bcDSAParams = new DSAParameters(dsaParams.getP(),
				dsaParams.getQ(), dsaParams.getG());

		DSAPublicKey dsaPrivateKey = (DSAPublicKey) pubKey;
		DSAPublicKeyParameters dsaPrivParms = new DSAPublicKeyParameters(
				dsaPrivateKey.getY(), bcDSAParams);

		// and now do the signature verification
		DSASigner dsaSigner = new DSASigner();
		dsaSigner.init(false, dsaPrivParms);

		Boolean result = dsaSigner.verifySignature(b, r, s);
		return result;
	}

	private static Boolean verifyWithStandardJCE(byte[] b, PublicKey pubKey,
			byte[] signature) throws NoSuchAlgorithmException,
			InvalidKeyException, SignatureException {
		Signature signer = Signature.getInstance(pubKey.getAlgorithm());
		signer.initVerify(pubKey);
		signer.update(b);
		return signer.verify(signature);
	}

	private static KeyPair generateDsaKeyPair() throws NoSuchAlgorithmException {
		KeyPairGenerator kg = KeyPairGenerator.getInstance("DSA");
		kg.initialize(1024, new SecureRandom());
		return kg.genKeyPair();
	}

	private static byte[] getRandomBytes(int length) {
		byte[] b = new byte[length];
		Random rnd = new Random();
		rnd.nextBytes(b);
		return b;
	}
}

[Paul Clapham]

"Geekius", please check your private messages regarding an important administrative matter.

Thank you.