/*
* 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.
*/
package org.apache.harmony.security.tests.java.security;
import dalvik.annotation.TestTargetClass;
import dalvik.annotation.TestTargetNew;
import dalvik.annotation.TestTargets;
import dalvik.annotation.TestLevel;
import java.math.BigInteger;
import java.nio.ByteBuffer;
import java.security.AlgorithmParameters;
import java.security.InvalidKeyException;
import java.security.InvalidParameterException;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.Provider;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.Security;
import java.security.Signature;
import java.security.SignatureException;
import java.security.cert.Certificate;
import java.security.spec.DSAParameterSpec;
import java.util.HashSet;
import java.util.Set;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
@TestTargetClass(Signature.class)
public class Signature2Test extends junit.framework.TestCase {
private static final String MESSAGE = "abc";
static KeyPair dsaKeys;
static KeyPair rsaKeys;
static {
try {
KeyPairGenerator keyGen = KeyPairGenerator.getInstance("DSA");
keyGen.initialize(1024);
dsaKeys = keyGen.generateKeyPair();
KeyPairGenerator keyGen2 = KeyPairGenerator.getInstance("RSA");
keyGen2.initialize(1024);
rsaKeys = keyGen2.generateKeyPair();
} catch (Exception e) {
fail(e.toString());
}
}
/**
* @tests java.security.Signature#clone()
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "CloneNotSupportedException checking was tested",
method = "clone",
args = {}
)
public void test_clone() throws Exception {
Signature s = Signature.getInstance("DSA");
try {
s.clone();
fail("A Signature may not be cloneable");
} catch (CloneNotSupportedException e) {
// Expected - a Signature may not be cloneable
}
}
/**
* @tests java.security.Signature#getAlgorithm()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getAlgorithm",
args = {}
)
public void test_getAlgorithm() throws Exception {
String alg = Signature.getInstance("DSA").getAlgorithm();
assertTrue("getAlgorithm did not get DSA (" + alg + ")", alg
.indexOf("DSA") != -1);
}
/**
* @tests java.security.Signature#getInstance(java.lang.String)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getInstance",
args = {java.lang.String.class}
)
public void test_getInstanceLjava_lang_String() {
try {
Signature.getInstance("DSA");
} catch (Exception e) {
fail("Unexpected exception for DSA algorithm");
}
try {
Signature.getInstance("SHA-256");
fail("NoSuchAlgorithmException was not thrown for unavailable algorithm");
} catch (NoSuchAlgorithmException e) {
//expected
}
}
/**
* @tests java.security.Signature#getInstance(java.lang.String,
* java.security.Provider)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getInstance",
args = {java.lang.String.class, java.security.Provider.class}
)
public void test_getInstanceLjava_lang_StringLjava_lang_String_java_security_Provider()
throws Exception {
Provider[] providers = Security.getProviders("Signature.DSA");
for (int i = 0; i < providers.length; i++) {
Signature signature = Signature.getInstance("DSA", providers[i]);
assertEquals("DSA", signature.getAlgorithm());
assertEquals(providers[i], signature.getProvider());
}
try {
Signature.getInstance((String) null, (Provider) null);
fail("NullPointerException expected");
} catch (NullPointerException e) {
// expected
}
try {
Signature.getInstance("DSA", (Provider) null);
fail("IllegalArgumentException expected");
} catch (IllegalArgumentException e) {
// expected
}
try {
Signature.getInstance((String) null, providers[0]);
fail("NullPointerException expected");
} catch (NullPointerException e) {
// expected
}
try {
Signature.getInstance("SHA-256", providers[0]);
fail("NoSuchAlgorithmException expected");
} catch (NoSuchAlgorithmException e) {
// expected
}
}
/**
* @tests java.security.Signature#getInstance(java.lang.String,
* java.lang.String)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getInstance",
args = {java.lang.String.class, java.lang.String.class}
)
public void test_getInstanceLjava_lang_StringLjava_lang_String()
throws Exception {
Provider[] providers = Security.getProviders("Signature.DSA");
for (int i = 0; i < providers.length; i++) {
Signature.getInstance("DSA", providers[i].getName());
}// end for
try {
Signature.getInstance("SHA-256", providers[0].getName());
fail("NoSuchAlgorithmException expected");
} catch (NoSuchAlgorithmException e) {
// expected
}
Provider[] pp = Security.getProviders();
for (int i = 0; i < pp.length; i++) {
try {
Signature.getInstance("DSA", pp[i].toString());
fail("NoSuchProviderException expected");
} catch (NoSuchProviderException e) {
// expected
}
}
String[] sp = {null, ""};
for (int i = 0; i < sp.length; i++) {
try {
Signature.getInstance("DSA", sp[i]);
fail("IllegalArgumentException was not throw for " + sp[i]);
} catch (IllegalArgumentException e) {
// expected
}
}
}
/**
* @tests java.security.Signature#getParameters()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getParameters",
args = {}
)
public void test_getParameters() throws Exception {
Signature sig = Signature.getInstance("DSA");
try {
sig.getParameters();
} catch (UnsupportedOperationException e) {
// Could be that the operation is not supported
}
try {
MySignature sig2 = new MySignature("test");
sig2.getParameters();
fail("expected UnsupportedOperationException");
} catch (UnsupportedOperationException e) {
// ok
}
try {
MySignature sig2 = new MySignature("ABC");
sig2.getParameters();
} catch (UnsupportedOperationException e) {
fail("unexpected: " + e);
}
}
/**
* @tests java.security.Signature#getParameter(java.lang.String)
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Just exception case was tested",
method = "getParameter",
args = {java.lang.String.class}
)
@SuppressWarnings("deprecation")
public void test_getParameterLjava_lang_String() throws Exception {
Signature sig = Signature.getInstance("DSA");
try {
sig.getParameter("r");
sig.getParameter("s");
} catch (UnsupportedOperationException e) {
}
}
/**
* @tests java.security.Signature#getProvider()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getProvider",
args = {}
)
public void test_getProvider() throws Exception {
Provider p = Signature.getInstance("DSA").getProvider();
assertNotNull("provider is null", p);
}
/**
* @tests java.security.Signature#initSign(java.security.PrivateKey)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "initSign",
args = {java.security.PrivateKey.class}
)
public void test_initSignLjava_security_PrivateKey() throws Exception {
try {
Signature.getInstance("DSA").initSign(dsaKeys.getPrivate());
} catch (InvalidKeyException e) {
fail("unexpected: " + e);
}
try {
Signature.getInstance("DSA").initSign(rsaKeys.getPrivate());
fail("expected InvalidKeyException");
} catch (InvalidKeyException e) {
// ok
}
}
@TestTargetNew (
level=TestLevel.COMPLETE,
method="initSign",
args={PrivateKey.class, SecureRandom.class}
)
public void test_initSignLjava_security_PrivateKeyLjava_security_SecureRandom() {
try {
Signature sig = Signature.getInstance("DSA");
sig.initSign(dsaKeys.getPrivate(), new SecureRandom());
} catch (NoSuchAlgorithmException e) {
fail("unexpected: " + e);
} catch (InvalidKeyException e) {
fail("unexpected: " + e);
}
try {
Signature sig = Signature.getInstance("DSA");
sig.initSign(rsaKeys.getPrivate(), new SecureRandom());
fail("expected InvalidKeyException");
} catch (InvalidKeyException e) {
// ok
} catch (NoSuchAlgorithmException e) {
fail("unexpected: " + e);
}
}
/**
* @tests java.security.Signature#initVerify(java.security.PublicKey)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "initVerify",
args = {java.security.PublicKey.class}
)
public void test_initVerifyLjava_security_PublicKey() throws Exception {
Signature.getInstance("DSA").initVerify(dsaKeys.getPublic());
try {
Signature.getInstance("DSA").initVerify(rsaKeys.getPublic());
fail("expected InvalidKeyException");
} catch (InvalidKeyException e) {
// ok
}
}
/**
* @tests java.security.Signature#initVerify(java.security.cert.Certificate)
*/
@TestTargetNew(
level = TestLevel.PARTIAL,
notes = "InvalidKeyException checking missed",
method = "initVerify",
args = {java.security.cert.Certificate.class}
)
public void test_initVerifyLjava_security_Certificate() throws Exception {
Provider p = new MyProvider();
p.put("DSA", "tests.java.security.support.cert.MyCertificate$1");
Provider myProvider = new MyProvider();
Security.addProvider(myProvider);
try {
Provider[] pp = Security.getProviders();
if (pp == null) {
return;
}
try {
Signature.getInstance("DSA").initVerify((Certificate) null);
fail("NullPointerException expected");
} catch (NullPointerException e) {
// fail
}
} finally {
Security.removeProvider(myProvider.getName());
}
}
/**
* @tests java.security.Signature#setParameter(java.lang.String,
* java.lang.Object)
*/
@TestTargetNew(
level = TestLevel.PARTIAL,
notes = "Just exception case was tested",
method = "setParameter",
args = {java.lang.String.class, java.lang.Object.class}
)
@SuppressWarnings("deprecation")
public void test_setParameterLjava_lang_StringLjava_lang_Object()
throws Exception {
Signature sig = Signature.getInstance("DSA");
try {
sig.setParameter("r", BigInteger.ONE);
sig.setParameter("s", BigInteger.ONE);
} catch (InvalidParameterException e) {
// Could be that it's an invalid param for the found algorithm
} catch (UnsupportedOperationException e) {
// Could be that the operation is not supported
}
}
/**
* @tests java.security.Signature#setParameter(java.security.spec.AlgorithmParameterSpec)
*/
@TestTargetNew(
level = TestLevel.PARTIAL,
notes = "Just exception case was tested",
method = "setParameter",
args = {java.security.spec.AlgorithmParameterSpec.class}
)
public void test_setParameterLjava_security_spec_AlgorithmParameterSpec()
throws Exception {
Signature sig = Signature.getInstance("DSA");
try {
DSAParameterSpec spec = new DSAParameterSpec(BigInteger.ONE,
BigInteger.ONE, BigInteger.ONE);
sig.setParameter(spec);
} catch (InvalidParameterException e) {
// Could be that it's an invalid param for the found algorithm
} catch (UnsupportedOperationException e) {
// Could be that the operation is not supported
}
}
/**
* @tests java.security.Signature#sign()
*/
@TestTargetNew(
level = TestLevel.SUFFICIENT,
notes = "Verification of returned value missed. SignatureException checking missed.",
method = "sign",
args = {}
)
public void test_sign() throws Exception {
Signature sig = Signature.getInstance("DSA");
sig.initSign(dsaKeys.getPrivate());
sig.update(MESSAGE.getBytes());
sig.sign();
}
/**
* @tests java.security.Signature#toString()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "toString",
args = {}
)
public void test_toString() throws Exception {
String str = Signature.getInstance("DSA").toString();
assertNotNull("toString is null", str);
}
/**
* @tests java.security.Signature#update(byte[])
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "SignatureException checking missed",
method = "update",
args = {byte[].class}
)
public void test_update$B() throws Exception {
Signature sig = Signature.getInstance("DSA");
sig.initSign(dsaKeys.getPrivate());
byte[] bytes = MESSAGE.getBytes();
sig.update(bytes);
try {
Signature sig2 = Signature.getInstance("DSA");
sig2.update(MESSAGE.getBytes());
fail("expected SignatureException");
} catch (SignatureException e) {
// ok
}
}
/**
* @tests java.security.Signature#update(byte[], int, int)
*/
@TestTargetNew(
level = TestLevel.PARTIAL,
notes = "SignatureException checking missed. Verification of different values off and len missed.",
method = "update",
args = {byte[].class, int.class, int.class}
)
public void test_update$BII() throws Exception {
Signature sig = Signature.getInstance("DSA");
byte[] bytes = MESSAGE.getBytes();
try {
sig.update(bytes, 0, bytes.length);
fail("expected SignatureException");
} catch (SignatureException e) {
// ok;
}
sig.initSign(dsaKeys.getPrivate());
sig.update(bytes, 0, bytes.length);
sig.update(bytes, bytes.length - 2, 2);
try {
sig.update(bytes, bytes.length -3, 4);
fail("expected IllegalArgumentException");
} catch (IllegalArgumentException e) {
// ok
}
try {
sig.update(null, 0, 5);
fail("expected IllegalArgumentException");
} catch (IllegalArgumentException e) {
// ok
}
}
/**
* @tests java.security.Signature#update(byte)
*/
@TestTargetNew(
level = TestLevel.PARTIAL,
notes = "SignatureException checking missed",
method = "update",
args = {byte.class}
)
public void test_updateB() throws Exception {
Signature sig = Signature.getInstance("DSA");
sig.initSign(dsaKeys.getPrivate());
sig.update(MESSAGE.getBytes()[0]);
}
/**
* @tests java.security.Signature#update(ByteBuffer data)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "update",
args = {java.nio.ByteBuffer.class}
)
public void test_updateLjava_nio_ByteBuffer() throws Exception {
Signature sig = Signature.getInstance("DSA");
ByteBuffer buffer = ByteBuffer.allocate(10);
try {
sig.update(buffer);
fail("SignatureException expected");
} catch (SignatureException e) {
// expected
}
try {
sig.initSign(dsaKeys.getPrivate());
sig.update(buffer);
} catch (Exception e) {
fail("Unexpected exception " + e.getMessage());
}
}
/**
* @tests java.security.Signature#verify(byte[])
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "verify",
args = {byte[].class}
)
public void test_verify$B() throws Exception {
Signature sig = Signature.getInstance("DSA");
try {
sig.verify(new byte[] { 0,1,2,3 });
fail("expected SignatureException");
} catch (SignatureException e) {
// ok
}
sig.initSign(dsaKeys.getPrivate());
sig.update(MESSAGE.getBytes());
byte[] signature = sig.sign();
sig.initVerify(dsaKeys.getPublic());
sig.update(MESSAGE.getBytes());
assertTrue("Sign/Verify does not pass", sig.verify(signature));
}
/**
* @tests java.security.Signature#verify(byte[], int, int)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "verify",
args = {byte[].class, int.class, int.class}
)
public void test_verify$BII() throws Exception {
Signature sig = Signature.getInstance("DSA");
sig.initSign(dsaKeys.getPrivate());
sig.update(MESSAGE.getBytes());
byte[] signature = sig.sign();
sig.initVerify(dsaKeys.getPublic());
sig.update(MESSAGE.getBytes());
assertTrue("Sign/Verify does not pass", sig.verify(signature, 0,
signature.length));
try {
sig.verify(null, 0, signature.length);
fail("IllegalArgumentException expected");
} catch (IllegalArgumentException e) {
// expected
}
try {
sig.verify(signature, -5, signature.length);
fail("IllegalArgumentException expected");
} catch (IllegalArgumentException e) {
// expected
}
try {
sig.verify(signature, signature.length, 0);
fail("SignatureException expected");
} catch (SignatureException e) {
// expected
}
try {
sig.verify(signature, 0, signature.length * 2);
fail("IllegalArgumentException expected");
} catch (IllegalArgumentException e) {
// expected
}
}
class MyProvider extends Provider {
private Set<Provider.Service> services = null;
MyProvider() {
super("MyProvider", 1.0, "Provider for testing");
put("MessageDigest.SHA-1", "SomeClassName");
put("MessageDigest.abc", "SomeClassName");
put("Alg.Alias.MessageDigest.SHA1", "SHA-1");
if (services != null) {
services.clear();
} else {
services = new HashSet<Service>();
}
}
MyProvider(String name, double version, String info) {
super(name, version, info);
if (services != null) {
services.clear();
} else {
services = new HashSet<Service>();
}
}
public void putService(Provider.Service s) {
super.putService(s);
services.add(s);
}
public void removeService(Provider.Service s) {
super.removeService(s);
services.remove(s);
}
public int getNumServices() {
return services.size();
}
}
@SuppressWarnings("unused")
private class MySignature extends Signature {
protected MySignature(String algorithm) {
super(algorithm);
}
@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;
}
@Override
protected AlgorithmParameters engineGetParameters() {
if (this.getAlgorithm().equals("test")) {
return super.engineGetParameters();
} else {
return null;
}
}
}
}
|
