package org.apache.harmony.security.tests.java.security;
import junit.framework.TestCase;
import java.nio.ByteBuffer;
import java.security.AlgorithmParameters;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.InvalidParameterException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.Signature;
import java.security.SignatureException;
import java.security.SignatureSpi;
import java.security.spec.AlgorithmParameterSpec;
import java.util.HashSet;
import java.util.Set;
public class SignatureSpiTest extends TestCase {
protected void setUp() throws Exception {
super.setUp();
}
protected void tearDown() throws Exception {
super.tearDown();
}
@SuppressWarnings("cast")
public void testSignatureSpi() {
try {
MySignatureSpi1 ss1 = new MySignatureSpi1();
assertNotNull(ss1);
assertTrue(ss1 instanceof SignatureSpi);
} catch (Exception e) {
fail("Unexpected exception " + e.getMessage());
}
}
public void testClone() {
MySignatureSpi1 ss1 = new MySignatureSpi1();
try {
MySignatureSpi1 ssc1 = (MySignatureSpi1) ss1.clone();
assertTrue(ss1 != ssc1);
} catch (CloneNotSupportedException e) {
fail("Unexpected CloneNotSupportedException " + e.getMessage());
}
MySignatureSpi2 ss2 = new MySignatureSpi2();
try {
ss2.clone();
fail("CloneNotSupportedException expected ");
} catch (CloneNotSupportedException e) {
// expected
}
}
public void testAbstractMethods() {
MySignatureSpi1 ss1 = new MySignatureSpi1();
byte[] b = {0, 1, 2, 3, 4, 5};
try {
ss1.engineGetParameter("test");
ss1.engineInitSign(null);
ss1.engineInitVerify(null);
ss1.engineSetParameter("test", null);
ss1.engineSign();
ss1.engineUpdate(b[1]);
ss1.engineUpdate(b, 0, b.length);
ss1.engineVerify(b);
} catch (Exception e) {
fail("Unexpected exception " + e.getMessage());
}
}
private boolean engineGetParametersCalled = false;
private boolean engineGetParametersExceptionOcurred = false;
public void testEngineGetParameters() {
// or rather test that no UnsupportedOperationException is thrown?
@SuppressWarnings("unused")
Signature s = new Signature("dummy") {
protected AlgorithmParameters engineGetParameters() {
engineGetParametersCalled = true;
try {
super.engineGetParameters();
} catch (UnsupportedOperationException e) {
engineGetParametersExceptionOcurred = true;
}
return null;
}
@Override
protected Object engineGetParameter(String param)
throws InvalidParameterException {
return null;
}
@Override
protected void engineInitSign(PrivateKey privateKey)
throws InvalidKeyException {
}
@Override
protected void engineInitVerify(PublicKey publicKey)
throws InvalidKeyException {
}
@Override
protected void engineSetParameter(String param, Object value)
throws InvalidParameterException {
}
@Override
protected byte[] engineSign() throws SignatureException {
return null;
}
@Override
protected void engineUpdate(byte b) throws SignatureException {
}
@Override
protected void engineUpdate(byte[] b, int off, int len)
throws SignatureException {
}
@Override
protected boolean engineVerify(byte[] sigBytes)
throws SignatureException {
return false;
}
};
// must call engineGetParameters
s.getParameters();
assertTrue(engineGetParametersCalled);
assertTrue(engineGetParametersExceptionOcurred);
}
class MySignatureSpi1 extends SignatureSpi implements Cloneable {
public Object engineGetParameter(String param) {
return null;
}
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
public void engineInitSign(PrivateKey privateKey) {
}
public void engineInitVerify(PublicKey publicKey) {
}
public void engineSetParameter(String param, Object value) {
}
public byte[] engineSign() {
return null;
}
public void engineUpdate(byte b) {
}
public void engineUpdate(byte[] b, int off, int len) {
}
public boolean engineVerify(byte[] sigBytes) {
return false;
}
}
class MySignatureSpi2 extends SignatureSpi {
public Object engineGetParameter(String param) {
return null;
}
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
public void engineInitSign(PrivateKey privateKey) {
}
public void engineInitVerify(PublicKey publicKey) {
}
public void engineSetParameter(String param, Object value) {
}
public byte[] engineSign() {
return null;
}
public void engineUpdate(byte b) {
}
public void engineUpdate(byte[] b, int off, int len) {
}
public boolean engineVerify(byte[] sigBytes) {
return false;
}
}
@SuppressWarnings("unused")
class MySignature extends Signature {
Set<String> calledMethods = new HashSet<String>();
protected MySignature(String algorithm) {
super(algorithm);
}
@Override
protected Object engineGetParameter(String param)
throws InvalidParameterException {
methodCalled("engineGetParameter_String");
return null;
}
@Override
protected void engineInitSign(PrivateKey privateKey)
throws InvalidKeyException {
methodCalled("engineInitSign_PrivateKey");
}
@Override
protected void engineInitVerify(PublicKey publicKey)
throws InvalidKeyException {
methodCalled("engineInitVerify_PublicKey");
}
@Override
protected void engineSetParameter(String param, Object value)
throws InvalidParameterException {
methodCalled("engineSetParameter_String_Object");
}
@Override
protected byte[] engineSign() throws SignatureException {
methodCalled("engineSign");
return null;
}
@Override
protected void engineUpdate(byte b) throws SignatureException {
methodCalled("engineUpdate_[B");
}
@Override
protected void engineUpdate(byte[] b, int off, int len)
throws SignatureException {
methodCalled("engineUpdate_[BII");
}
@Override
protected boolean engineVerify(byte[] sigBytes)
throws SignatureException {
methodCalled("engineVerify_[B");
return false;
}
@Override
protected void engineInitSign(PrivateKey privateKey, SecureRandom random)
throws InvalidKeyException {
methodCalled("engineInitSign_PrivateKey_SecureRandom");
}
@Override
protected void engineSetParameter(AlgorithmParameterSpec params)
throws InvalidAlgorithmParameterException {
methodCalled("engineSetParameter_AlgorithmParameterSpec");
}
@Override
protected int engineSign(byte[] outbuf, int offset, int len)
throws SignatureException {
methodCalled("engineSign_[BII");
return 0;
}
@Override
protected void engineUpdate(ByteBuffer input) {
methodCalled("engineUpdate_ByteBuffer");
}
@Override
protected boolean engineVerify(byte[] sigBytes, int offset, int length)
throws SignatureException {
methodCalled("engineVerify_[BII");
return false;
}
boolean wasMethodCalled(String methodName) {
return calledMethods.contains(methodName);
}
void methodCalled(String methodName) {
calledMethods.add(methodName);
}
}
public void testEngineInitSign_PrivateKey_SecureRandom() {
MySignature signature = new MySignature("dummy");
try {
signature.initSign(null, null);
assertTrue("SPI method not called", signature
.wasMethodCalled("engineInitSign_PrivateKey_SecureRandom"));
} catch (InvalidKeyException e) {
fail("unexpected exception: " + e);
}
}
public void testEngineSetParameter()
{
MySignature signature = new MySignature("dummy");
try {
signature.setParameter(null);
assertTrue(
"SPI method not called",
signature
.wasMethodCalled("engineSetParameter_AlgorithmParameterSpec"));
} catch (InvalidAlgorithmParameterException e) {
fail("unexpected exception: " + e);
}
}
public void testEngineSign_BII() {
MySignature signature = new MySignature("dummy");
try {
signature.initSign(new PrivateKey() {
public String getFormat() {
return null;
}
public byte[] getEncoded() {
return null;
}
public String getAlgorithm() {
return null;
}
});
} catch (InvalidKeyException e) {
fail("unexpected exception: " + e);
}
byte[] buf = new byte[10];
try {
signature.sign(buf, 2, 1);
assertTrue("SPI method not called", signature
.wasMethodCalled("engineSign_[BII"));
} catch (SignatureException e) {
fail("unexpected exception: " + e);
}
}
public void testEngineUpdate_ByteBuffer() {
MySignature signature = new MySignature("dummy");
try {
signature.initSign(new PrivateKey() {
public String getFormat() {
return null;
}
public byte[] getEncoded() {
return null;
}
public String getAlgorithm() {
return null;
}
});
} catch (InvalidKeyException e) {
fail("unexpected exception: " + e);
}
try {
signature.update(ByteBuffer.wrap("Hello".getBytes()));
assertTrue("SPI method not called", signature
.wasMethodCalled("engineUpdate_ByteBuffer"));
} catch (SignatureException e) {
fail("unexpected exception");
}
}
public void testEngineVerify_BII() {
MySignature signature = new MySignature("dummy");
try {
signature.initVerify(new PublicKey() {
public String getFormat() {
return null;
}
public byte[] getEncoded() {
return null;
}
public String getAlgorithm() {
return null;
}
});
} catch (InvalidKeyException e) {
fail("unexpected exception");
}
byte[] buf = new byte[10];
try {
signature.verify(buf, 2, 5);
signature.wasMethodCalled("engineVerify_[BII");
} catch (SignatureException e) {
fail("unexpected exception");
}
}
}