package org.apache.harmony.security.tests.java.security;
import dalvik.annotation.TestLevel;
import dalvik.annotation.TestTargetClass;
import dalvik.annotation.TestTargetNew;
import junit.framework.TestCase;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyFactorySpi;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.PrivateKey;
import java.security.Provider;
import java.security.PublicKey;
import java.security.Security;
import java.security.spec.DSAPublicKeySpec;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.KeySpec;
import java.util.Arrays;
@TestTargetClass(KeyFactory.class)
public class KeyFactoryTest extends TestCase {
Provider provider;
boolean exceptionThrown;
Provider existingProvider;
@Override
protected void setUp() throws Exception {
super.setUp();
exceptionThrown = false;
Provider[] providers = Security.getProviders();
if (providers.length == 0) {
fail("no providers found");
}
existingProvider = providers[0];
provider = new TestKeyFactoryProvider();
Security.addProvider(provider);
}
@Override
protected void tearDown() throws Exception {
super.tearDown();
Security.removeProvider(provider.getName());
}
@SuppressWarnings("unchecked")
@TestTargetNew(
level=TestLevel.COMPLETE,
method="getInstance",
args={String.class}
)
public void testGetInstanceString() {
try {
KeyFactory factory = KeyFactory.getInstance(TEST_KEYFACTORY_NAME);
assertNotNull(factory);
} catch (NoSuchAlgorithmException e) {
fail("unexpected exception: " + e);
}
String[] parameters = {
"UnknownKeyFactory",
null
};
Class[] exceptions = {
NoSuchAlgorithmException.class,
NullPointerException.class
};
for (int i = 0; i < parameters.length; i++) {
String algorithm = parameters[i];
exceptionThrown = false;
String message = "getInstance(" + (algorithm == null ? "null" : "\"" + algorithm + "\"") + ")";
try {
KeyFactory.getInstance(algorithm);
} catch (Exception e) {
checkException(message, e, exceptions[i]);
} finally {
checkException(message, null, exceptions[i]);
}
}
}
@SuppressWarnings("unchecked")
@TestTargetNew(
level=TestLevel.COMPLETE,
method="getInstance",
args={String.class, String.class}
)
public void testGetInstanceStringString() {
try {
KeyFactory factory = KeyFactory.getInstance(TEST_KEYFACTORY_NAME, TEST_PROVIDER_NAME);
assertNotNull(factory);
} catch (NoSuchAlgorithmException e) {
fail("unexpected exception: " + e);
} catch (NoSuchProviderException e) {
fail("unexpected exception: " + e);
}
String[][] combinations = {
{ "UnknownKeyFactory", TEST_PROVIDER_NAME},
{ TEST_KEYFACTORY_NAME, "UnknownProvider"},
{ TEST_KEYFACTORY_NAME, existingProvider.getName() },
{ null, TEST_PROVIDER_NAME },
{ TEST_KEYFACTORY_NAME, null },
{ null, null}
};
Class[] exceptions = {
NoSuchAlgorithmException.class,
NoSuchProviderException.class,
NoSuchAlgorithmException.class,
NullPointerException.class,
IllegalArgumentException.class,
IllegalArgumentException.class
};
for (int i = 0; i < combinations.length; i++) {
String[] combination = combinations[i];
String message = "getInstance(\"" + combination[0] + "\", \"" + combination[1] + "\")";
exceptionThrown = false;
try {
KeyFactory.getInstance(combination[0], combination[1]);
} catch (Exception e) {
checkException(message, e, exceptions[i]);
} finally {
checkException(message, null, exceptions[i]);
}
}
}
@SuppressWarnings("unchecked")
@TestTargetNew(
level=TestLevel.COMPLETE,
method="getInstance",
args={String.class, Provider.class}
)
public void testGetInstanceStringProvider() {
try {
KeyFactory factory = KeyFactory.getInstance(TEST_KEYFACTORY_NAME, provider);
assertNotNull(factory);
} catch (NoSuchAlgorithmException e) {
fail("unexpected exception: " + e);
}
String[] algorithms = {
"UnknownKeyFactory",
null,
TEST_KEYFACTORY_NAME,
TEST_KEYFACTORY_NAME
};
Provider[] providers = {
provider,
provider,
existingProvider,
null
};
Class[] exceptions = {
NoSuchAlgorithmException.class,
NullPointerException.class,
NoSuchAlgorithmException.class,
IllegalArgumentException.class
};
for (int i = 0; i < algorithms.length; i++) {
String algorithm = algorithms[i];
Provider provider = providers[i];
String message = "getInstance(" +
(algorithm == null ? "null" : "\"" + algorithm + "\"") +
", " +
(provider == null ? "null" : "provider");
exceptionThrown = false;
try {
KeyFactory.getInstance(algorithm, provider);
} catch (Exception e) {
checkException(message, e, exceptions[i]);
} finally {
checkException(message, null, exceptions[i]);
}
}
}
@SuppressWarnings("unchecked")
@TestTargetNew(
level=TestLevel.COMPLETE,
method="generatePublic",
args={KeySpec.class}
)
public void testGeneratePublic() {
KeyFactory factory = null;
try {
factory = KeyFactory.getInstance(TEST_KEYFACTORY_NAME);
} catch (NoSuchAlgorithmException e) {
fail("unexpected exception: " + e);
}
assertNotNull(factory);
try {
TestPublicKey key = new TestPublicKey();
TestPublicKeySpec keySpec = new TestPublicKeySpec(key);
PublicKey publicKey = factory.generatePublic(keySpec);
assertNotNull(publicKey);
assertTrue(Arrays.equals(key.encoded, publicKey.getEncoded()));
} catch (InvalidKeySpecException e) {
fail("unexpected exception: " + e);
}
KeySpec[] keySpecs = {
new TestPrivateKeySpec(new TestPrivateKey()),
null,
new DSAPublicKeySpec(null, null, null, null)
};
Class[] exceptions = {
InvalidKeySpecException.class,
NullPointerException.class,
InvalidKeySpecException.class
};
for (int i = 0; i < keySpecs.length; i++) {
KeySpec keySpec = keySpecs[i];
String message = "generatePublic(" +
(keySpec == null ? "null" : keySpec.toString()) + ")";
try {
PublicKey generatePublic = factory.generatePublic(keySpec);
assertNotNull(generatePublic);
} catch (Exception e) {
checkException(message, e, exceptions[i]);
} finally {
checkException(message, null, exceptions[i]);
}
}
}
@SuppressWarnings("unchecked")
@TestTargetNew(
level=TestLevel.COMPLETE,
method="generatePrivate",
args={KeySpec.class}
)
public void testGeneratePrivate() {
KeyFactory factory = null;
try {
factory = KeyFactory.getInstance(TEST_KEYFACTORY_NAME);
} catch (NoSuchAlgorithmException e) {
fail("unexpected exception: " + e);
}
assertNotNull(factory);
try {
TestPrivateKey key = new TestPrivateKey();
TestPrivateKeySpec keySpec = new TestPrivateKeySpec(key);
PrivateKey privateKey = factory.generatePrivate(keySpec);
assertNotNull(privateKey);
assertTrue(Arrays.equals(key.getEncoded(), privateKey.getEncoded()));
} catch (InvalidKeySpecException e) {
fail("unexpected exception: " + e);
}
KeySpec[] keySpecs = {
new TestPublicKeySpec(new TestPublicKey()),
null,
new DSAPublicKeySpec(null, null, null, null)
};
Class[] exceptions = {
InvalidKeySpecException.class,
NullPointerException.class,
InvalidKeySpecException.class
};
for (int i = 0; i < keySpecs.length; i++) {
KeySpec keySpec = keySpecs[i];
exceptionThrown = false;
String message = "generatePrivate(" +
(keySpec == null ? "null" : keySpec.toString()) + ")";
try {
factory.generatePrivate(keySpec);
} catch (Exception e) {
checkException(message, e, exceptions[i]);
} finally {
checkException(message, null, exceptions[i]);
}
}
}
@SuppressWarnings("unchecked")
@TestTargetNew(
level=TestLevel.COMPLETE,
method="getKeySpec",
args={Key.class, Class.class}
)
public void testGetKeySpec() {
KeyFactory factory = null;
try {
factory = KeyFactory.getInstance(TEST_KEYFACTORY_NAME);
} catch (NoSuchAlgorithmException e) {
fail("unexpected exception: " + e);
}
assertNotNull(factory);
{
Key[] keys = {
new TestPrivateKey(),
new TestPublicKey(),
new TestPrivateKey(new byte[] { 42, 41, 40 }),
new TestPublicKey(new byte[] { 40, 41, 42 })
};
Class[] keySpecs = {
TestPrivateKeySpec.class,
TestPublicKeySpec.class,
TestPrivateKeySpec.class,
TestPublicKeySpec.class,
};
for (int i = 0; i < keys.length; i++) {
Key key = keys[i];
Class keySpec = keySpecs[i];
String message = "getKeySpec(" + key.toString() + ", " + keySpec.toString() + ")";
try {
KeySpec spec = factory.getKeySpec(key, keySpec);
assertNotNull(spec);
assertTrue(spec.getClass() == keySpec);
} catch (InvalidKeySpecException e) {
fail("unexpected exception: " + e);
}
}
}
{
Key[] keys = {
new AnotherKey(),
null,
new TestPrivateKey(),
null,
};
Class[] keySpecs = {
KeySpec.class,
TestPrivateKeySpec.class,
null,
null,
};
Class[] exceptions = {
InvalidKeySpecException.class,
NullPointerException.class,
InvalidKeySpecException.class,
NullPointerException.class
};
for (int i = 0; i < keys.length; i++) {
Key key = keys[i];
Class keySpec = keySpecs[i];
exceptionThrown = false;
String message = "getKeySpec(" +
(key == null ? "null" : key.toString()) +
", " +
(keySpec == null ? "null" : keySpec.toString()) + ")";
try {
factory.getKeySpec(key, keySpec);
} catch (Exception e) {
checkException(message, e, exceptions[i]);
} finally {
checkException(message, null, exceptions[i]);
}
}
}
}
@SuppressWarnings("unchecked")
@TestTargetNew(
level=TestLevel.COMPLETE,
method="translateKey",
args={Key.class}
)
public void testTranslateKey() {
KeyFactory factory = null;
try {
factory = KeyFactory.getInstance(TEST_KEYFACTORY_NAME);
} catch (NoSuchAlgorithmException e) {
fail("unexpected exception: " + e);
}
assertNotNull(factory);
{
Key[] keys = {
new TestPrivateKey(),
new TestPublicKey()
};
Class[] translated = {
TestPublicKey.class,
TestPrivateKey.class
};
for (int i = 0; i < keys.length; i++) {
Key key = keys[i];
Class translate = translated[i];
try {
Key translateKey = factory.translateKey(key);
assertNotNull(translateKey);
assertEquals(translate, translateKey.getClass());
} catch (InvalidKeyException e) {
fail("unexpected exception: " + e);
}
}
}
{
Key[] keys = {
new AnotherKey(),
null
};
Class[] exceptions = {
InvalidKeyException.class,
NullPointerException.class
};
for (int i = 0; i < keys.length; i++) {
Key key = keys[i];
String message = "translateKey(" +
(key == null ? "null" : key.toString()) + ")";
exceptionThrown = false;
try {
factory.translateKey(key);
} catch (Exception e) {
checkException(message, e, exceptions[i]);
} finally {
checkException(message, null, exceptions[i]);
}
}
}
}
private static final String TEST_PROVIDER_NAME = "TestKeyFactoryProvider";
private static final String TEST_KEYFACTORY_NAME = "TestKeyFactory";
static class TestKeyFactoryProvider extends Provider {
protected TestKeyFactoryProvider() {
super(TEST_PROVIDER_NAME, 1.1, "Test KeyFactory Provider");
put("KeyFactory." + TEST_KEYFACTORY_NAME, TestKeyFactorySpi.class.getName());
}
}
public static class TestKeyFactorySpi extends KeyFactorySpi {
@Override
protected PrivateKey engineGeneratePrivate(KeySpec keySpec)
throws InvalidKeySpecException {
if (TestPrivateKeySpec.class == keySpec.getClass()) {
return new TestPrivateKey(((TestPrivateKeySpec)keySpec).encoded);
}
throw new InvalidKeySpecException();
}
@Override
protected PublicKey engineGeneratePublic(KeySpec keySpec)
throws InvalidKeySpecException {
if (TestPublicKeySpec.class == keySpec.getClass()) {
return new TestPublicKey(((TestPublicKeySpec)keySpec).encoded);
}
throw new InvalidKeySpecException();
}
@Override
protected <T extends KeySpec> T engineGetKeySpec(Key key,
Class<T> keySpec) throws InvalidKeySpecException {
if (key == null) {
throw new NullPointerException();
}
Constructor<T> constructor = null;
if (TestPrivateKeySpec.class == keySpec) {
try {
constructor = keySpec.getConstructor(TestPrivateKey.class);
} catch (SecurityException e) {
throw new InvalidKeySpecException(e);
} catch (NoSuchMethodException e) {
throw new InvalidKeySpecException(e);
}
} else if (TestPublicKeySpec.class == keySpec) {
try {
constructor = keySpec.getConstructor(TestPublicKey.class);
} catch (SecurityException e) {
throw new InvalidKeySpecException(e);
} catch (NoSuchMethodException e) {
throw new InvalidKeySpecException(e);
}
}
if (constructor == null) {
throw new InvalidKeySpecException();
}
try {
return constructor.newInstance(key);
} catch (IllegalArgumentException e) {
throw new InvalidKeySpecException(e);
} catch (InstantiationException e) {
throw new InvalidKeySpecException(e);
} catch (IllegalAccessException e) {
throw new InvalidKeySpecException(e);
} catch (InvocationTargetException e) {
throw new InvalidKeySpecException(e);
}
}
@Override
protected Key engineTranslateKey(Key key) throws InvalidKeyException {
if (TestPrivateKey.class == key.getClass()) {
return new TestPublicKey();
} else if (TestPublicKey.class == key.getClass()) {
return new TestPrivateKey();
}
throw new InvalidKeyException();
}
}
static class TestPrivateKeySpec implements KeySpec {
@SuppressWarnings("unused")
private final byte[] encoded;
public TestPrivateKeySpec(TestPrivateKey key) {
this.encoded = key.getEncoded();
}
}
static class TestPublicKeySpec implements KeySpec {
@SuppressWarnings("unused")
private final byte[] encoded;
public TestPublicKeySpec(TestPublicKey key) {
this.encoded = key.getEncoded();
}
}
static class TestPrivateKey implements PrivateKey {
private final byte[] encoded;
public TestPrivateKey() {
encoded = new byte[] {3, 4, 5};
}
public TestPrivateKey(byte[] encoded) {
this.encoded = encoded;
}
public String getAlgorithm() {
return "TestPrivateKey";
}
public byte[] getEncoded() {
return encoded;
}
public String getFormat() {
return "TestFormat";
}
}
static class TestPublicKey implements PublicKey {
private final byte[] encoded;
public TestPublicKey() {
encoded = new byte[] {3, 4, 5};
}
public TestPublicKey(byte[] encoded) {
this.encoded = encoded;
}
public String getAlgorithm() {
return "TestPublicKey";
}
public byte[] getEncoded() {
return encoded;
}
public String getFormat() {
return "TestFormat";
}
}
static class AnotherKey implements Key {
public String getAlgorithm() {
return "AnotherKey";
}
public byte[] getEncoded() {
return null;
}
public String getFormat() {
return "AnotherFormat";
}
}
private void checkException(String message, Exception thrown, Class<? extends Exception> expected) {
if (thrown == null) {
if (!exceptionThrown) {
fail(message + ", expected " + expected.getName());
}
} else if (expected == thrown.getClass()) {
exceptionThrown = true;
// ok
} else {
exceptionThrown = true;
fail(message + ", unexpected exception: " + thrown + ", expected: " + expected.getName());
}
}
}
|
