/*
* 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.
*/
/**
* @author Vera Y. Petrashkova
* @version $Revision$
*/
package org.apache.harmony.security.tests.java.security;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.security.KeyStore;
import java.security.PrivateKey;
import java.security.Provider;
import java.security.Security;
import java.security.cert.Certificate;
import org.apache.harmony.security.tests.support.KeyStoreTestSupport;
import org.apache.harmony.security.tests.support.SpiEngUtils;
import junit.framework.TestCase;
/**
* Tests for <code>KeyStore</code> constructor and methods
*
*/
public class KeyStore_Impl3Test extends TestCase {
private static final String KeyStoreProviderClass = "org.apache.harmony.security.tests.support.MyKeyStore";
private static final String defaultType = "KeyStore";
public static boolean KSSupported = false;
public static String defaultProviderName = null;
public static Provider defaultProvider = null;
private static String NotSupportMsg = "Default KeyStore type is not supported";
Provider mProv;
public KeyStore[] createKS() throws Exception {
assertTrue(NotSupportMsg, KSSupported);
KeyStore[] kpg = new KeyStore[3];
kpg[0] = KeyStore.getInstance(defaultType);
kpg[1] = KeyStore.getInstance(defaultType, defaultProvider);
kpg[2] = KeyStore.getInstance(defaultType, defaultProviderName);
return kpg;
}
protected void setUp() throws Exception {
super.setUp();
mProv = (new SpiEngUtils()).new MyProvider("MyKSProvider",
"Testing provider", KeyStoreTestSupport.srvKeyStore.concat(".")
.concat(defaultType), KeyStoreProviderClass);
Security.insertProviderAt(mProv, 2);
defaultProvider = SpiEngUtils.isSupport(defaultType,
KeyStoreTestSupport.srvKeyStore);
KSSupported = (defaultProvider != null);
defaultProviderName = (KSSupported ? defaultProvider.getName() : null);
}
/*
* @see TestCase#tearDown()
*/
protected void tearDown() throws Exception {
super.tearDown();
Security.removeProvider(mProv.getName());
}
/**
* Test for <code>load(InputStream stream, char[] password)</code>
* <code>store(InputStream stream, char[] password)</code>
* <code>size()</code>
* <code>getCreationDate(String alias)</code>
* methods
* Assertions: store(...) throws NullPointerException when stream or
* password is null;
* getCreationDate(...) throws NullPointerException when alias is null;
* stores KeyStore and then loads it;
* @throws Exception
*/
public void testLoadStore01() throws Exception {
assertTrue(NotSupportMsg, KSSupported);
String tType = "TestType";
KeyStore.TrustedCertificateEntry tCert = new KeyStore.TrustedCertificateEntry(
new KeyStoreTestSupport.MCertificate("type", new byte[0]));
Certificate certs[] = {
new KeyStoreTestSupport.MCertificate(tType, new byte[10]),
new KeyStoreTestSupport.MCertificate(tType, new byte[20]) };
PrivateKey pk = new KeyStoreTestSupport.MyPrivateKey(tType, "", new byte[10]);
KeyStore.PrivateKeyEntry pKey = new KeyStore.PrivateKeyEntry(pk, certs);
char[] pwd = { 'p', 'a', 's', 's', 'w', 'd' };
KeyStore.PasswordProtection pPath = new KeyStore.PasswordProtection(pwd);
String[] aliases = { "Alias1", "Alias2", "Alias3", "Alias4", "Alias5" };
KeyStore[] kss = createKS();
KeyStore[] kss1 = new KeyStore[kss.length];
assertNotNull("KeyStore objects were not created", kss);
for (int i = 0; i < kss.length; i++) {
kss1[i] = kss[i];
kss[i].load(null, null);
kss[i].setEntry(aliases[0], tCert, null);
kss[i].setEntry(aliases[1], pKey, pPath);
kss[i].setEntry(aliases[2], pKey, pPath);
try {
kss[i].getCreationDate(null);
fail("NullPointerException should be thrown when alias is null");
} catch (NullPointerException e) {
}
kss[i].setKeyEntry(aliases[3], pk, pwd, certs);
kss[i].setCertificateEntry(aliases[4], certs[0]);
ByteArrayOutputStream bos = new ByteArrayOutputStream();
try {
kss[i].store(null, pwd);
fail("IOException or NullPointerException should be thrown when stream is null");
} catch (IOException e) {
} catch (NullPointerException e) {
}
//RI does not throw exception while password is null.
kss[i].store(bos, null);
kss[i].store(bos, pwd);
ByteArrayInputStream bis = new ByteArrayInputStream(bos
.toByteArray());
kss1[i].load(bis, pwd);
assertEquals("Incorrect size", kss1[i].size(), kss[i].size());
KeyStore.Entry en, en1;
for (int j = 0; j < 3; j++) {
en = kss[i].getEntry(aliases[j], (j == 0 ? null : pPath));
en1 = kss1[i].getEntry(aliases[j], (j == 0 ? null : pPath));
if (en instanceof KeyStore.TrustedCertificateEntry) {
assertTrue("Incorrect entry 1",
en1 instanceof KeyStore.TrustedCertificateEntry);
assertEquals("Incorrect Certificate",
((KeyStore.TrustedCertificateEntry) en)
.getTrustedCertificate(),
((KeyStore.TrustedCertificateEntry) en1)
.getTrustedCertificate());
} else {
if (en instanceof KeyStore.PrivateKeyEntry) {
assertTrue("Incorrect entry 2",
en1 instanceof KeyStore.PrivateKeyEntry);
assertEquals(
"Incorrect Certificate",
((KeyStore.PrivateKeyEntry) en).getPrivateKey(),
((KeyStore.PrivateKeyEntry) en1)
.getPrivateKey());
} else {
if (en instanceof KeyStore.SecretKeyEntry) {
assertTrue("Incorrect entry 3",
en1 instanceof KeyStore.SecretKeyEntry);
assertEquals("Incorrect Certificate",
((KeyStore.SecretKeyEntry) en)
.getSecretKey(),
((KeyStore.SecretKeyEntry) en1)
.getSecretKey());
}
}
}
assertEquals("Incorrect date", kss[i]
.getCreationDate(aliases[j]), kss1[i]
.getCreationDate(aliases[j]));
}
assertEquals("Incorrect entry", kss[i].getKey(aliases[3], pwd),
kss1[i].getKey(aliases[3], pwd));
assertEquals("Incorrect date", kss[i].getCreationDate(aliases[3]),
kss1[i].getCreationDate(aliases[3]));
assertEquals("Incorrect entry", kss[i].getCertificate(aliases[4]),
kss1[i].getCertificate(aliases[4]));
assertEquals("Incorrect date", kss[i].getCreationDate(aliases[4]),
kss1[i].getCreationDate(aliases[4]));
}
}
}