/*
* 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.TestLevel;
import dalvik.annotation.TestTargetNew;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyFactorySpi;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.PrivateKey;
import java.security.Provider;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.Security;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.KeySpec;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.Vector;
@TestTargetClass(KeyFactory.class)
public class KeyFactory2Test extends junit.framework.TestCase {
private static final String KEYFACTORY_ID = "KeyFactory.";
private String[] keyfactAlgs = null;
private String providerName = null;
static class KeepAlive extends Thread {
int sleepTime, iterations;
public KeepAlive(int sleepTime, int iterations) {
this.sleepTime = sleepTime;
this.iterations = iterations;
}
public void run() {
synchronized (this) {
this.notify();
}
for (int i = 0; i < iterations; i++) {
try {
Thread.sleep(sleepTime);
} catch (InterruptedException e) {
break;
}
}
}
}
private KeepAlive createKeepAlive(String alg) {
if (alg.equals("RSA")) {
// 32 minutes
KeepAlive keepalive = new KeepAlive(240000, 8);
synchronized (keepalive) {
keepalive.start();
try {
keepalive.wait();
} catch (InterruptedException e) {
// ignore
}
}
return keepalive;
}
return null;
}
/**
* @tests java.security.KeyFactory#KeyFactory(java.security.KeyFactorySpi,
* java.security.Provider, java.lang.String)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "KeyFactory",
args = {java.security.KeyFactorySpi.class, java.security.Provider.class, java.lang.String.class}
)
public void test_constructor() {
KeyFactorySpi kfs = new KeyFactorySpiStub();
try {
new KeyFactoryStub(null, null, null);
} catch (Exception e) {
fail("Unexpected exception " + e.getMessage());
}
Provider[] providers = Security.getProviders("KeyFactory.DSA");
if (providers != null) {
for (int i = 0; i < providers.length; i++) {
KeyFactoryStub kf = new KeyFactoryStub(kfs, providers[i],
"algorithm name");
assertEquals("algorithm name", kf.getAlgorithm());
assertEquals(providers[i], kf.getProvider());
}
} else {
fail("No providers support KeyFactory.DSA");
}
}
/**
* @tests java.security.KeyFactory#generatePrivate(java.security.spec.KeySpec)
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "generatePrivate",
args = {java.security.spec.KeySpec.class}
)
public void test_generatePrivateLjava_security_spec_KeySpec() {
// Test for method java.security.PrivateKey
// java.security.KeyFactory.generatePrivate(java.security.spec.KeySpec)
for (int i = 0; i < keyfactAlgs.length; i++) {
try {
KeyFactory fact = KeyFactory.getInstance(keyfactAlgs[i],
providerName);
KeyPairGenerator keyGen = KeyPairGenerator
.getInstance(keyfactAlgs[i]);
SecureRandom random = new SecureRandom(); // We don't use
// getInstance
keyGen.initialize(1024, random);
KeepAlive keepalive = createKeepAlive(keyfactAlgs[i]);
KeyPair keys = keyGen.generateKeyPair();
if (keepalive != null) {
keepalive.interrupt();
}
KeySpec privateKeySpec = fact.getKeySpec(keys.getPrivate(),
getPrivateKeySpecClass(keyfactAlgs[i]));
PrivateKey privateKey = fact.generatePrivate(privateKeySpec);
boolean samePrivate = Arrays.equals(keys.getPrivate()
.getEncoded(), privateKey.getEncoded());
assertTrue(
"generatePrivate generated different key for algorithm "
+ keyfactAlgs[i], samePrivate);
fact.generatePrivate(new PKCS8EncodedKeySpec(keys.getPrivate()
.getEncoded()));
} catch (InvalidKeySpecException e) {
fail("invalid key spec for algorithm " + keyfactAlgs[i]);
} catch (NoSuchAlgorithmException e) {
fail("getInstance did not find algorithm " + keyfactAlgs[i]);
} catch (NoSuchProviderException e) {
fail("getInstance did not find provider " + providerName);
}
}
}
/**
* @tests java.security.KeyFactory#generatePublic(java.security.spec.KeySpec)
*/
@TestTargetNew(
level = TestLevel.PARTIAL,
notes = "InvalidKeySpecException checking missed",
method = "generatePublic",
args = {java.security.spec.KeySpec.class}
)
public void test_generatePublicLjava_security_spec_KeySpec() {
// Test for method java.security.PublicKey
// java.security.KeyFactory.generatePublic(java.security.spec.KeySpec)
for (int i = 0; i < keyfactAlgs.length; i++) {
try {
KeyFactory fact = KeyFactory.getInstance(keyfactAlgs[i],
providerName);
KeyPairGenerator keyGen = KeyPairGenerator
.getInstance(keyfactAlgs[i]);
// We don't use getInstance
SecureRandom random = new SecureRandom();
keyGen.initialize(1024, random);
KeepAlive keepalive = createKeepAlive(keyfactAlgs[i]);
KeyPair keys = keyGen.generateKeyPair();
if (keepalive != null) {
keepalive.interrupt();
}
KeySpec publicKeySpec = fact.getKeySpec(keys.getPublic(),
getPublicKeySpecClass(keyfactAlgs[i]));
PublicKey publicKey = fact.generatePublic(publicKeySpec);
boolean samePublic = Arrays.equals(keys.getPublic()
.getEncoded(), publicKey.getEncoded());
assertTrue(
"generatePublic generated different key for algorithm "
+ keyfactAlgs[i], samePublic);
} catch (NoSuchAlgorithmException e) {
fail("getInstance did not find algorithm " + keyfactAlgs[i]);
} catch (NoSuchProviderException e) {
fail("getInstance did not find provider " + providerName);
} catch (InvalidKeySpecException e) {
fail("invalid key spec for algorithm " + keyfactAlgs[i]);
}
}
}
/**
* @tests java.security.KeyFactory#getAlgorithm()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getAlgorithm",
args = {}
)
public void test_getAlgorithm() {
// Test for method java.lang.String
// java.security.KeyFactory.getAlgorithm()
for (int i = 0; i < keyfactAlgs.length; i++) {
try {
KeyFactory fact = KeyFactory.getInstance(keyfactAlgs[i],
providerName);
assertTrue("getAlgorithm ok for algorithm " + keyfactAlgs[i],
fact.getAlgorithm().equals(keyfactAlgs[i]));
} catch (NoSuchAlgorithmException e) {
fail("getInstance did not find algorithm " + keyfactAlgs[i]);
} catch (NoSuchProviderException e) {
fail("getInstance did not find provider " + providerName);
}
}// end for
}
/**
* @tests java.security.KeyFactory#getInstance(java.lang.String)
*/
@TestTargetNew(
level = TestLevel.PARTIAL,
notes = "NoSuchAlgorithmException checking missed",
method = "getInstance",
args = {java.lang.String.class}
)
public void test_getInstanceLjava_lang_String() {
// Test for method java.security.KeyFactory
// java.security.KeyFactory.getInstance(java.lang.String)
for (int i = 0; i < keyfactAlgs.length; i++) {
try {
assertNotNull(KeyFactory.getInstance(keyfactAlgs[i]));
} catch (NoSuchAlgorithmException e) {
fail("getInstance did not find algorithm " + keyfactAlgs[i]);
}
}// end for
}
/**
* @tests java.security.KeyFactory#getInstance(java.lang.String,
* java.lang.String)
*/
@TestTargetNew(
level = TestLevel.PARTIAL,
notes = "NoSuchAlgorithmException, NoSuchProviderException checking missed",
method = "getInstance",
args = {java.lang.String.class, java.lang.String.class}
)
public void test_getInstanceLjava_lang_StringLjava_lang_String() {
// Test1: Test for method java.security.KeyFactory
// java.security.KeyFactory.getInstance(java.lang.String,
// java.lang.String)
try {
Provider[] providers = Security.getProviders("KeyFactory.DSA");
if (providers != null) {
for (int i = 0; i < providers.length; i++) {
KeyFactory.getInstance("DSA", providers[i].getName());
}// end for
} else {
fail("No providers support KeyFactory.DSA");
}
} catch (NoSuchAlgorithmException e) {
fail("getInstance did not find algorithm");
} catch (NoSuchProviderException e) {
fail("getInstance did not find the provider");
}
// Test2: Test with null provider name
try {
KeyFactory.getInstance("DSA", (String) null);
fail("Expected IllegalArgumentException");
} catch (IllegalArgumentException e) {
// Expected
} catch (Exception e) {
fail("Expected IllegalArgumentException, got " + e);
}
}
/**
* @tests java.security.KeyFactory#getInstance(java.lang.String, Provider)
*/
@TestTargetNew(
level = TestLevel.PARTIAL,
notes = "NoSuchAlgorithmException checking missed",
method = "getInstance",
args = {java.lang.String.class, java.security.Provider.class}
)
public void test_getInstanceLjava_lang_StringLjava_security_Provider() {
// Test1: Test for method java.security.KeyFactory
// java.security.KeyFactory.getInstance(java.lang.String,
// java.security.Provider)
try {
Provider[] providers = Security.getProviders("KeyFactory.DSA");
if (providers != null) {
for (int i = 0; i < providers.length; i++) {
KeyFactory.getInstance("DSA", providers[i]);
}// end for
} else {
fail("No providers support KeyFactory.DSA");
}
} catch (NoSuchAlgorithmException e) {
fail("getInstance did not find algorithm");
} catch (Exception e) {
fail("unexpected exception " + e.getMessage());
}
// Test2: Test with null provider name
try {
KeyFactory.getInstance("DSA", (Provider) null);
fail("Expected IllegalArgumentException");
} catch (IllegalArgumentException e) {
// Expected
} catch (Exception e) {
fail("Expected IllegalArgumentException, got " + e);
}
}
/**
* @tests java.security.KeyFactory#getKeySpec(java.security.Key,
* java.lang.Class)
*/
@TestTargetNew(
level = TestLevel.PARTIAL,
notes = "InvalidKeySpecException checking missed",
method = "getKeySpec",
args = {java.security.Key.class, java.lang.Class.class}
)
public void test_getKeySpecLjava_security_KeyLjava_lang_Class() {
// Test for method java.security.spec.KeySpec
// java.security.KeyFactory.getKeySpec(java.security.Key,
// java.lang.Class)
for (int i = 0; i < keyfactAlgs.length; i++) {
try {
KeyFactory fact = KeyFactory.getInstance(keyfactAlgs[i],
providerName);
KeyPairGenerator keyGen = KeyPairGenerator
.getInstance(keyfactAlgs[i]);
// We don't use getInstance
SecureRandom random = new SecureRandom();
keyGen.initialize(1024, random);
KeepAlive keepalive = createKeepAlive(keyfactAlgs[i]);
KeyPair keys = keyGen.generateKeyPair();
if (keepalive != null) {
keepalive.interrupt();
}
KeySpec privateKeySpec = fact.getKeySpec(keys.getPrivate(),
getPrivateKeySpecClass(keyfactAlgs[i]));
KeySpec publicKeySpec = fact.getKeySpec(keys.getPublic(),
getPublicKeySpecClass(keyfactAlgs[i]));
PrivateKey privateKey = fact.generatePrivate(privateKeySpec);
PublicKey publicKey = fact.generatePublic(publicKeySpec);
boolean samePublic = Arrays.equals(keys.getPublic()
.getEncoded(), publicKey.getEncoded());
boolean samePrivate = Arrays.equals(keys.getPrivate()
.getEncoded(), privateKey.getEncoded());
assertTrue(
"generatePrivate generated different key for algorithm "
+ keyfactAlgs[i], samePrivate);
assertTrue(
"generatePublic generated different key for algorithm "
+ keyfactAlgs[i], samePublic);
KeySpec encodedSpec = fact.getKeySpec(keys.getPublic(),
X509EncodedKeySpec.class);
assertTrue("improper key spec for encoded public key",
encodedSpec.getClass().equals(X509EncodedKeySpec.class));
encodedSpec = fact.getKeySpec(keys.getPrivate(),
PKCS8EncodedKeySpec.class);
assertTrue("improper key spec for encoded private key",
encodedSpec.getClass()
.equals(PKCS8EncodedKeySpec.class));
} catch (NoSuchAlgorithmException e) {
fail("getInstance did not find algorithm " + keyfactAlgs[i]);
} catch (NoSuchProviderException e) {
fail("getInstance did not find provider " + providerName);
} catch (InvalidKeySpecException e) {
fail("invalid key spec for algorithm " + keyfactAlgs[i]);
}
}
}
/**
* @tests java.security.KeyFactory#getProvider()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getProvider",
args = {}
)
public void test_getProvider() {
// Test for method java.security.Provider
// java.security.KeyFactory.getProvider()
for (int i = 0; i < keyfactAlgs.length; i++) {
try {
KeyFactory fact = KeyFactory.getInstance(keyfactAlgs[i]);
Provider p = fact.getProvider();
assertNotNull("provider is null for algorithm "
+ keyfactAlgs[i], p);
} catch (NoSuchAlgorithmException e) {
fail("getInstance did not find algorithm " + keyfactAlgs[i]);
}
}// end for
}
/**
* @tests java.security.KeyFactory#translateKey(java.security.Key)
*/
@TestTargetNew(
level = TestLevel.PARTIAL,
notes = "InvalidKeyException checking missed",
method = "translateKey",
args = {java.security.Key.class}
)
public void test_translateKeyLjava_security_Key() {
// Test for method java.security.Key
// java.security.KeyFactory.translateKey(java.security.Key)
for (int i = 0; i < keyfactAlgs.length; i++) {
try {
KeyFactory fact = KeyFactory.getInstance(keyfactAlgs[i],
providerName);
KeyPairGenerator keyGen = KeyPairGenerator
.getInstance(keyfactAlgs[i]);
// We don't use getInstance
SecureRandom random = new SecureRandom();
keyGen.initialize(1024, random);
KeepAlive keepalive = createKeepAlive(keyfactAlgs[i]);
KeyPair keys = keyGen.generateKeyPair();
if (keepalive != null) {
keepalive.interrupt();
}
fact.translateKey(keys.getPrivate());
} catch (NoSuchAlgorithmException e) {
fail("getInstance did not find algorithm " + keyfactAlgs[i]);
} catch (NoSuchProviderException e) {
fail("getInstance did not find provider " + providerName);
} catch (InvalidKeyException e) {
fail("generatePublic did not generate right spec for algorithm "
+ keyfactAlgs[i]);
}
}
}
protected void setUp() {
if (keyfactAlgs == null) {
Provider[] providers = Security.getProviders();
// Arbitrarily use the first provider that supports
// KeyFactory algorithms
for (Provider provider : providers) {
providerName = provider.getName();
keyfactAlgs = getKeyFactoryAlgorithms(providerName);
if (keyfactAlgs.length != 0) {
break;
}
}
}
}
/*
* Returns the key algorithms that the given provider supports.
*/
private String[] getKeyFactoryAlgorithms(String providerName) {
Vector<String> algs = new Vector<String>();
Provider provider = Security.getProvider(providerName);
if (provider == null)
return new String[0];
Enumeration<Object> e = provider.keys();
while (e.hasMoreElements()) {
String algorithm = (String) e.nextElement();
if (algorithm.startsWith(KEYFACTORY_ID) && !algorithm.contains(" ")) {
algs.addElement(algorithm.substring(KEYFACTORY_ID.length()));
}
}
return algs.toArray(new String[algs.size()]);
}
/**
* Returns the public key spec class for a given algorithm, or null if it is
* not known.
*/
private Class<? extends KeySpec> getPrivateKeySpecClass(String algName) {
if (algName.equals("RSA")) {
return java.security.spec.RSAPrivateCrtKeySpec.class;
}
if (algName.equals("DSA")) {
return java.security.spec.DSAPrivateKeySpec.class;
}
return null;
}
/**
* Returns the private key spec class for a given algorithm, or null if it
* is not known.
*/
private Class<? extends KeySpec> getPublicKeySpecClass(String algName) {
if (algName.equals("RSA")) {
return java.security.spec.RSAPublicKeySpec.class;
}
if (algName.equals("DSA")) {
return java.security.spec.DSAPublicKeySpec.class;
}
return null;
}
public class KeyFactoryStub extends KeyFactory {
public KeyFactoryStub(KeyFactorySpi keyFacSpi, Provider provider,
String algorithm) {
super(keyFacSpi, provider, algorithm);
}
}
public class KeyFactorySpiStub extends KeyFactorySpi {
public KeyFactorySpiStub() {
super();
}
public PrivateKey engineGeneratePrivate(KeySpec keySpec) {
return null;
}
public PublicKey engineGeneratePublic(KeySpec keySpec) {
return null;
}
public <T extends KeySpec> T engineGetKeySpec(Key key, Class<T> keySpec) {
return null;
}
public Key engineTranslateKey(Key key) {
return null;
}
}
}
|
