/*
* 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 java.security.InvalidParameterException;
import java.security.Provider;
import java.security.Security;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import junit.framework.TestCase;
import tests.support.Support_ProviderTrust;
import tests.support.Support_TestProvider;
public class Security2Test extends TestCase {
/**
* java.security.Security#getProviders(java.lang.String)
*/
public void test_getProvidersLjava_lang_String() {
// Test for method void
// java.security.Security.getProviders(java.lang.String)
Map<String, Integer> allSupported = new HashMap<String, Integer>();
Provider[] allProviders = Security.getProviders();
// Add all non-alias entries to allSupported
for (Provider provider : allProviders) {
for (Object k : provider.keySet()) {
String key = (String) k;
// No aliases and no provider data
if (!isAlias(key) && !isProviderData(key)) {
addOrIncrementTable(allSupported, key);
}
}// end while more entries
}// end for all providers
// Now walk through aliases. If an alias has actually been added
// to the allSupported table then increment the count of the
// entry that is being aliased.
for (Provider provider : allProviders) {
for (Map.Entry entry : provider.entrySet()) {
String key = (String) entry.getKey();
if (isAlias(key)) {
String aliasName = key.substring("ALG.ALIAS.".length()).toUpperCase();
String realName = aliasName.substring(0, aliasName.indexOf(".") + 1) + entry.getValue();
// Skip over nonsense alias declarations where alias and
// aliased are identical. Such entries can occur.
if (!aliasName.equalsIgnoreCase(realName)) {
// Has a real entry been added for aliasName ?
if (allSupported.containsKey(aliasName)) {
// Add 1 to the provider count of the thing being aliased
addOrIncrementTable(allSupported, aliasName);
}
}
}
}// end while more entries
}// end for all providers
for (String filterString : allSupported.keySet()) {
try {
Provider[] provTest = Security.getProviders(filterString);
int expected = allSupported.get(filterString);
assertEquals("Unexpected number of providers returned for filter " + filterString
+ ":\n" + allSupported,
expected, provTest.length);
} catch (InvalidParameterException e) {
// NO OP
}
}// end while
// exception
try {
Security.getProviders("Signature.SHA1withDSA :512");
fail("InvalidParameterException should be thrown <Signature.SHA1withDSA :512>");
} catch (InvalidParameterException e) {
// Expected
}
}
private boolean isProviderData(String key) {
return key.toUpperCase().startsWith("PROVIDER.");
}
private boolean isAlias(String key) {
return key.toUpperCase().startsWith("ALG.ALIAS.");
}
private void addOrIncrementTable(Map<String, Integer> table, String k) {
String key = k.toUpperCase();
if (table.containsKey(key)) {
int before = table.get(key);
table.put(key, before + 1);
} else {
table.put(key, 1);
}
}
private int getProvidersCount(Map filterMap) {
int result = 0;
Provider[] allProviders = Security.getProviders();
// for each provider
for (Provider provider : allProviders) {
Set allProviderKeys = provider.keySet();
boolean noMatchFoundForFilterEntry = false;
// for each filter item
for (Object filter : filterMap.keySet()) {
String filterString = (String) filter;
// Remove any "=" characters that may be on the end of the
// map keys (no, I don't know why they might be there either
// but I have seen them)
if (filterString.endsWith("=")) {
filterString = filterString.substring(0, filterString
.length() - 1);
}
if (filterString != null) {
if (filterString.indexOf(" ") == -1) {
// Is this filter string in the keys of the
// current provider ?
if (!allProviderKeys.contains(filterString)) {
// Check that the key is not contained as an
// alias.
if (!allProviderKeys.contains("Alg.Alias."
+ filterString)) {
noMatchFoundForFilterEntry = true;
break; // out of while loop
}
}
} else {
// handle filter strings with attribute names
if (allProviderKeys.contains(filterString)) {
// Does the corresponding values match ?
String filterVal = (String) filterMap
.get(filterString);
String providerVal = (String) provider
.get(filterString);
if (providerVal == null
|| !providerVal.equals(filterVal)) {
noMatchFoundForFilterEntry = true;
break; // out of while loop
}
}// end if filter string with named attribute is
// found
}// end else
}// end if non-null key
}// end while there are more filter strings for current map
if (!noMatchFoundForFilterEntry) {
// Current provider is a match for the filterMap
result++;
}
}// end for each provider
return result;
}
/**
* java.security.Security#getProviders(java.util.Map)
*/
public void test_getProvidersLjava_util_Map() {
// Test for method void
// java.security.Security.getProviders(java.util.Map)
Map<String, String> filter = new HashMap<String, String>();
filter.put("KeyStore.BKS", "");
filter.put("Signature.SHA1withDSA", "");
Provider[] provTest = Security.getProviders(filter);
if (provTest == null) {
assertEquals("Filter : <KeyStore.BKS>,<Signature.SHA1withDSA>",
0, getProvidersCount(filter));
} else {
assertEquals("Filter : <KeyStore.BKS>,<Signature.SHA1withDSA>",
getProvidersCount(filter), provTest.length);
}
filter = new HashMap<String, String>();
filter.put("MessageDigest.SHA-384", "");
filter.put("CertificateFactory.X.509", "");
filter.put("KeyFactory.RSA", "");
provTest = Security.getProviders(filter);
if (provTest == null) {
assertEquals("Filter : <MessageDigest.SHA-384>,<CertificateFactory.X.509>,<KeyFactory.RSA>",
0, getProvidersCount(filter));
} else {
assertEquals(
"Filter : <MessageDigest.SHA-384>,<CertificateFactory.X.509>,<KeyFactory.RSA>",
getProvidersCount(filter), provTest.length);
}
filter = new HashMap<String, String>();
filter.put("MessageDigest.SHA1", "");
filter.put("TrustManagerFactory.X509", "");
provTest = Security.getProviders(filter);
if (provTest == null) {
assertEquals("Filter : <MessageDigest.SHA1><TrustManagerFactory.X509>",
0, getProvidersCount(filter));
} else {
assertEquals(
"Filter : <MessageDigest.SHA1><TrustManagerFactory.X509>",
getProvidersCount(filter), provTest.length);
}
filter = new HashMap<String, String>();
filter.put("CertificateFactory.X509", "");
provTest = Security.getProviders(filter);
if (provTest == null) {
assertEquals("Filter : <CertificateFactory.X509>",
0, getProvidersCount(filter));
} else {
assertEquals("Filter : <CertificateFactory.X509>",
getProvidersCount(filter), provTest.length);
}
filter = new HashMap<String, String>();
filter.put("Provider.id name", "DRLCertFactory");
provTest = Security.getProviders(filter);
assertNull("Filter : <Provider.id name, DRLCertFactory >",
provTest);
// exception - no attribute name after the service.algorithm yet we
// still supply an expected value. This is not valid.
try {
filter = new HashMap<String, String>();
filter.put("Signature.SHA1withDSA", "512");
provTest = Security.getProviders(filter);
fail("InvalidParameterException should be thrown <Signature.SHA1withDSA><512>");
} catch (InvalidParameterException e) {
// Expected
}
// exception - space character in the service.algorithm pair. Not valid.
try {
filter = new HashMap<String, String>();
filter.put("Signature. KeySize", "512");
provTest = Security.getProviders(filter);
fail("InvalidParameterException should be thrown <Signature. KeySize><512>");
} catch (InvalidParameterException e) {
// Expected
}
}
/**
* java.security.Security#removeProvider(java.lang.String)
*/
public void test_removeProviderLjava_lang_String() {
// Test for method void
// java.security.Security.removeProvider(java.lang.String)
Provider test = new Support_TestProvider();
Provider entrust = new Support_ProviderTrust();
try {
// Make sure provider not already loaded. Should do nothing
// if not already loaded.
Security.removeProvider(test.getName());
// Now add it
int addResult = Security.addProvider(test);
assertTrue("Failed to add provider", addResult != -1);
Security.removeProvider(test.getName());
assertNull(
"the provider TestProvider is found after it was removed",
Security.getProvider(test.getName()));
// Make sure entrust provider not already loaded. Should do nothing
// if not already loaded.
Security.removeProvider(entrust.getName());
// Now add entrust
addResult = Security.addProvider(entrust);
assertTrue("Failed to add provider", addResult != -1);
Security.removeProvider(entrust.getName());
for (Provider provider : Security.getProviders()) {
assertTrue("the provider entrust is found after it was removed",
provider.getName() != entrust.getName());
}
} finally {
// Tidy up - the following calls do nothing if the providers were
// already removed above.
Security.removeProvider(test.getName());
Security.removeProvider(entrust.getName());
}
}
}