| /* |
| * 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 |
| */ |
| |
| 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])); |
| } |
| } |
| } |