1/*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements.  See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License.  You may obtain a copy of the License at
8 *
9 *     http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18package org.apache.harmony.security.tests.java.security;
19
20import java.io.ByteArrayInputStream;
21import java.io.ByteArrayOutputStream;
22import java.io.IOException;
23import java.io.InputStream;
24import java.io.OutputStream;
25import java.security.Key;
26import java.security.KeyPair;
27import java.security.KeyPairGenerator;
28import java.security.KeyStore;
29import java.security.KeyStoreException;
30import java.security.KeyStoreSpi;
31import java.security.NoSuchAlgorithmException;
32import java.security.PrivateKey;
33import java.security.Provider;
34import java.security.PublicKey;
35import java.security.SecureRandom;
36import java.security.Security;
37import java.security.UnrecoverableKeyException;
38import java.security.cert.Certificate;
39import java.security.cert.CertificateException;
40import java.security.cert.CertificateFactory;
41import java.security.cert.X509Certificate;
42import java.util.Arrays;
43import java.util.Date;
44import java.util.Enumeration;
45import java.util.HashSet;
46import java.util.Set;
47
48import tests.support.Support_TestProvider;
49import tests.support.resource.Support_Resources;
50
51public class KeyStore2Test extends junit.framework.TestCase {
52    static PrivateKey privateKey;
53    static {
54        try {
55            KeyPairGenerator keyPairGenerator = KeyPairGenerator
56                    .getInstance("DSA");
57
58            SecureRandom secureRandom = new SecureRandom();
59            keyPairGenerator.initialize(1024, secureRandom);
60            KeyPair keyPair = keyPairGenerator.genKeyPair();
61            privateKey = keyPair.getPrivate();
62        } catch (Exception e) {
63            fail("initialization failed: " + e);
64        }
65    }
66
67	final char[] pssWord = { 'a', 'b', 'c' };
68        private Provider support_TestProvider;
69
70	// creating a certificate
71	String certificate = "-----BEGIN CERTIFICATE-----\n"
72			+ "MIICZTCCAdICBQL3AAC2MA0GCSqGSIb3DQEBAgUAMF8xCzAJBgNVBAYTAlVTMSAw\n"
73			+ "HgYDVQQKExdSU0EgRGF0YSBTZWN1cml0eSwgSW5jLjEuMCwGA1UECxMlU2VjdXJl\n"
74			+ "IFNlcnZlciBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw05NzAyMjAwMDAwMDBa\n"
75			+ "Fw05ODAyMjAyMzU5NTlaMIGWMQswCQYDVQQGEwJVUzETMBEGA1UECBMKQ2FsaWZv\n"
76			+ "cm5pYTESMBAGA1UEBxMJUGFsbyBBbHRvMR8wHQYDVQQKExZTdW4gTWljcm9zeXN0\n"
77			+ "ZW1zLCBJbmMuMSEwHwYDVQQLExhUZXN0IGFuZCBFdmFsdWF0aW9uIE9ubHkxGjAY\n"
78			+ "BgNVBAMTEWFyZ29uLmVuZy5zdW4uY29tMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCB\n"
79			+ "iQKBgQCofmdY+PiUWN01FOzEewf+GaG+lFf132UpzATmYJkA4AEA/juW7jSi+LJk\n"
80			+ "wJKi5GO4RyZoyimAL/5yIWDV6l1KlvxyKslr0REhMBaD/3Z3EsLTTEf5gVrQS6sT\n"
81			+ "WMoSZAyzB39kFfsB6oUXNtV8+UKKxSxKbxvhQn267PeCz5VX2QIDAQABMA0GCSqG\n"
82			+ "SIb3DQEBAgUAA34AXl3at6luiV/7I9MN5CXYoPJYI8Bcdc1hBagJvTMcmlqL2uOZ\n"
83			+ "H9T5hNMEL9Tk6aI7yZPXcw/xI2K6pOR/FrMp0UwJmdxX7ljV6ZtUZf7pY492UqwC\n"
84			+ "1777XQ9UEZyrKJvF5ntleeO0ayBqLGVKCWzWZX9YsXCpv47FNLZbupE=\n"
85			+ "-----END CERTIFICATE-----\n";
86
87	ByteArrayInputStream certArray = new ByteArrayInputStream(certificate
88			.getBytes());
89
90	String certificate2 = "-----BEGIN CERTIFICATE-----\n"
91			+ "MIICZzCCAdCgAwIBAgIBGzANBgkqhkiG9w0BAQUFADBhMQswCQYDVQQGEwJVUzEY\n"
92			+ "MBYGA1UEChMPVS5TLiBHb3Zlcm5tZW50MQwwCgYDVQQLEwNEb0QxDDAKBgNVBAsT\n"
93			+ "A1BLSTEcMBoGA1UEAxMTRG9EIFBLSSBNZWQgUm9vdCBDQTAeFw05ODA4MDMyMjAy\n"
94			+ "MjlaFw0wODA4MDQyMjAyMjlaMGExCzAJBgNVBAYTAlVTMRgwFgYDVQQKEw9VLlMu\n"
95			+ "IEdvdmVybm1lbnQxDDAKBgNVBAsTA0RvRDEMMAoGA1UECxMDUEtJMRwwGgYDVQQD\n"
96			+ "ExNEb0QgUEtJIE1lZCBSb290IENBMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKB\n"
97			+ "gQDbrM/J9FrJSX+zxFUbsI9Vw5QbguVBIa95rwW/0M8+sM0r5gd+DY6iubm6wnXk\n"
98			+ "CSvbfQlFEDSKr4WYeeGp+d9WlDnQdtDFLdA45tCi5SHjnW+hGAmZnld0rz6wQekF\n"
99			+ "5xQaa5A6wjhMlLOjbh27zyscrorMJ1O5FBOWnEHcRv6xqQIDAQABoy8wLTAdBgNV\n"
100			+ "HQ4EFgQUVrmYR6m9701cHQ3r5kXyG7zsCN0wDAYDVR0TBAUwAwEB/zANBgkqhkiG\n"
101			+ "9w0BAQUFAAOBgQDVX1Y0YqC7vekeZjVxtyuC8Mnxbrz6D109AX07LEIRzNYzwZ0w\n"
102			+ "MTImSp9sEzWW+3FueBIU7AxGys2O7X0qmN3zgszPfSiocBuQuXIYQctJhKjF5KVc\n"
103			+ "VGQRYYlt+myhl2vy6yPzEVCjiKwMEb1Spu0irCf+lFW2hsdjvmSQMtZvOw==\n"
104			+ "-----END CERTIFICATE-----\n";
105
106	ByteArrayInputStream certArray2 = new ByteArrayInputStream(certificate2
107			.getBytes());
108
109	String certificate3 = "-----BEGIN CERTIFICATE-----\n"
110			+ "MIIDXDCCAsWgAwIBAgIBSjANBgkqhkiG9w0BAQUFADBWMQswCQYDVQQGEwJVUzEY\n"
111			+ "MBYGA1UEChMPVS5TLiBHb3Zlcm5tZW50MQwwCgYDVQQLEwNEb0QxDDAKBgNVBAsT\n"
112			+ "A1BLSTERMA8GA1UEAxMITWVkIENBLTEwHhcNOTgwODAyMTgwMjQwWhcNMDEwODAy\n"
113			+ "MTgwMjQwWjB0MQswCQYDVQQGEwJVUzEYMBYGA1UEChMPVS5TLiBHb3Zlcm5tZW50\n"
114			+ "MQwwCgYDVQQLEwNEb0QxDDAKBgNVBAsTA1BLSTENMAsGA1UECxMEVVNBRjEgMB4G\n"
115			+ "A1UEAxMXR3VtYnkuSm9zZXBoLjAwMDAwMDUwNDQwgZ8wDQYJKoZIhvcNAQEBBQAD\n"
116			+ "gY0AMIGJAoGBALT/R7bPqs1c1YqXAg5HNpZLgW2HuAc7RCaP06cE4R44GBLw/fQc\n"
117			+ "VRNLn5pgbTXsDnjiZVd8qEgYqjKFQka4/tNhaF7No2tBZB+oYL/eP0IWtP+h/W6D\n"
118			+ "KR5+UvIIdgmx7k3t9jp2Q51JpHhhKEb9WN54trCO9Yu7PYU+LI85jEIBAgMBAAGj\n"
119			+ "ggEaMIIBFjAWBgNVHSAEDzANMAsGCWCGSAFlAgELAzAfBgNVHSMEGDAWgBQzOhTo\n"
120			+ "CWdhiGUkIOx5cELXppMe9jAdBgNVHQ4EFgQUkLBJl+ayKgzOp/wwBX9M1lSkCg4w\n"
121			+ "DgYDVR0PAQH/BAQDAgbAMAwGA1UdEwEB/wQCMAAwgZ0GA1UdHwSBlTCBkjCBj6CB\n"
122			+ "jKCBiYaBhmxkYXA6Ly9kcy0xLmNoYW1iLmRpc2EubWlsL2NuJTNkTWVkJTIwQ0El\n"
123			+ "MmQxJTJjb3UlM2RQS0klMmNvdSUzZERvRCUyY28lM2RVLlMuJTIwR292ZXJubWVu\n"
124			+ "dCUyY2MlM2RVUz9jZXJ0aWZpY2F0ZVJldm9jYXRpb25MaXN0JTNiYmluYXJ5MA0G\n"
125			+ "CSqGSIb3DQEBBQUAA4GBAFjapuDHMvIdUeYRyEYdShBR1JZC20tJ3MQnyBQveddz\n"
126			+ "LGFDGpIkRAQU7T/5/ne8lMexyxViC21xOlK9LdbJCbVyywvb9uEm/1je9wieQQtr\n"
127			+ "kjykuB+WB6qTCIslAO/eUmgzfzIENvnH8O+fH7QTr2PdkFkiPIqBJYHvw7F3XDqy\n"
128			+ "-----END CERTIFICATE-----\n";
129
130	ByteArrayInputStream certArray3 = new ByteArrayInputStream(certificate3
131			.getBytes());
132
133	private byte[] creatCertificate() throws Exception {
134		ByteArrayOutputStream out = null;
135
136		CertificateFactory cf = CertificateFactory.getInstance("X.509");
137		X509Certificate cert[] = new X509Certificate[2];
138		cert[0] = (X509Certificate) cf.generateCertificate(certArray);
139		cert[1] = (X509Certificate) cf.generateCertificate(certArray2);
140		KeyStore keyTest = KeyStore.getInstance(KeyStore.getDefaultType());
141		keyTest.load(null, null);
142		// alias 1
143		keyTest.setCertificateEntry("alias1", cert[0]);
144
145		// alias 2
146        keyTest.setKeyEntry("alias2", privateKey, pssWord, cert);
147
148		// alias 3
149		keyTest.setCertificateEntry("alias3", cert[1]);
150
151		out = new ByteArrayOutputStream();
152		keyTest.store(out, pssWord);
153		out.close();
154
155		return out.toByteArray();
156	}
157
158	/**
159	 * @tests java.security.KeyStore#aliases()
160	 */
161	public void test_aliases() throws Exception {
162		// Test for method java.util.Enumeration
163		// java.security.KeyStore.aliases()
164		// NOT COMPATIBLE WITH PCS#12
165		CertificateFactory cf = CertificateFactory.getInstance("X.509");
166		X509Certificate cert[] = new X509Certificate[2];
167		cert[0] = (X509Certificate) cf.generateCertificate(certArray);
168		cert[1] = (X509Certificate) cf.generateCertificate(certArray2);
169		KeyStore keyTest = KeyStore.getInstance(KeyStore.getDefaultType());
170		keyTest.load(null, null);
171
172		// KeyStore keyTest =
173		// KeyStore.getInstance(KeyStore.getDefaultType());
174		// alias 1
175		keyTest.setCertificateEntry("alias1", cert[0]);
176
177		// alias 2
178		keyTest.setCertificateEntry("alias2", cert[0]);
179
180		// alias 3
181		keyTest.setCertificateEntry("alias3", cert[0]);
182
183		// obtaining the aliase
184		Enumeration aliase = keyTest.aliases();
185		Set alia = new HashSet();
186		int i = 0;
187		while (aliase.hasMoreElements()) {
188			alia.add(aliase.nextElement());
189			i++;
190		}
191		assertTrue("the alias names were returned wrong", i == 3
192				&& alia.contains("alias1") && alia.contains("alias2")
193				&& alia.contains("alias3"));
194	}
195
196	/**
197	 * @tests java.security.KeyStore#containsAlias(java.lang.String)
198	 */
199	public void test_containsAliasLjava_lang_String() throws Exception {
200		// Test for method boolean
201		// java.security.KeyStore.containsAlias(java.lang.String)
202		CertificateFactory cf = CertificateFactory.getInstance("X.509");
203		X509Certificate cert[] = new X509Certificate[2];
204		cert[0] = (X509Certificate) cf.generateCertificate(certArray);
205		cert[1] = (X509Certificate) cf.generateCertificate(certArray2);
206		KeyStore keyTest = KeyStore.getInstance(KeyStore.getDefaultType());
207		keyTest.load(null, null);
208
209		// alias 1
210		keyTest.setCertificateEntry("alias1", cert[0]);
211
212		// alias 2
213		keyTest.setCertificateEntry("alias2", cert[0]);
214
215		assertTrue("alias1 does not exist", keyTest.containsAlias("alias1"));
216		assertTrue("alias2 does not exist", keyTest.containsAlias("alias2"));
217		assertFalse("alias3 exists", keyTest.containsAlias("alias3"));
218	}
219
220	/**
221	 * @tests java.security.KeyStore#getCertificate(java.lang.String)
222	 */
223	public void test_getCertificateLjava_lang_String() throws Exception {
224		// Test for method java.security.cert.Certificate
225		// java.security.KeyStore.getCertificate(java.lang.String)
226		CertificateFactory cf = CertificateFactory.getInstance("X.509");
227		X509Certificate cert[] = new X509Certificate[2];
228		cert[0] = (X509Certificate) cf.generateCertificate(certArray);
229		cert[1] = (X509Certificate) cf.generateCertificate(certArray2);
230		KeyStore keyTest = KeyStore.getInstance(KeyStore.getDefaultType());
231		keyTest.load(null, null);
232
233		// alias 1
234		PublicKey pub = cert[0].getPublicKey();
235		keyTest.setCertificateEntry("alias1", cert[0]);
236
237		java.security.cert.Certificate certRes = keyTest
238				.getCertificate("alias1");
239		assertTrue("the public key of the certificate from getCertificate() "
240				+ "did not equal the original certificate", certRes
241				.getPublicKey() == pub);
242
243		// alias 2
244		keyTest.setCertificateEntry("alias2", cert[0]);
245
246		// testing for a certificate chain
247		java.security.cert.Certificate cert2 = keyTest.getCertificate("alias2");
248		assertTrue("the certificate for alias2 is supposed to exist",
249				cert2 != null && cert2.equals(cert[0]));
250
251	}
252
253	/**
254	 * @tests java.security.KeyStore#getCertificateAlias(java.security.cert.Certificate)
255	 */
256	public void test_getCertificateAliasLjava_security_cert_Certificate()
257			throws Exception {
258		// Test for method java.lang.String
259		// java.security.KeyStore.getCertificateAlias(java.security.cert.Certificate)
260		CertificateFactory cf = CertificateFactory.getInstance("X.509");
261		X509Certificate cert[] = new X509Certificate[2];
262		cert[0] = (X509Certificate) cf.generateCertificate(certArray);
263		cert[1] = (X509Certificate) cf.generateCertificate(certArray2);
264		KeyStore keyTest = KeyStore.getInstance(KeyStore.getDefaultType());
265		keyTest.load(null, null);
266
267		// certificate entry
268		keyTest.setCertificateEntry("alias1", cert[1]);
269		String alias = keyTest.getCertificateAlias(cert[1]);
270		assertTrue("certificate entry - the alias returned for this "
271				+ "certificate was wrong", alias.equals("alias1"));
272
273		// key entry
274
275        keyTest.setKeyEntry("alias2", privateKey, pssWord, cert);
276		alias = keyTest.getCertificateAlias(cert[0]);
277		assertTrue("key entry - the alias returned for this "
278				+ "certificate was wrong", alias.equals("alias2"));
279
280		// testing case with a nonexistent certificate
281		X509Certificate cert2 = (X509Certificate) cf
282				.generateCertificate(certArray3);
283		String aliasNull = keyTest.getCertificateAlias(cert2);
284		assertNull("the alias returned for the nonexist certificate "
285				+ "was NOT null", aliasNull);
286	}
287
288	/**
289	 * @tests java.security.KeyStore#getCertificateChain(java.lang.String)
290	 */
291	public void test_getCertificateChainLjava_lang_String() throws Exception {
292		// Test for method java.security.cert.Certificate []
293		// java.security.KeyStore.getCertificateChain(java.lang.String)
294		// creatCertificate();
295		CertificateFactory cf = CertificateFactory.getInstance("X.509");
296		X509Certificate cert[] = new X509Certificate[2];
297		cert[0] = (X509Certificate) cf.generateCertificate(certArray);
298		cert[1] = (X509Certificate) cf.generateCertificate(certArray2);
299		KeyStore keyTest = KeyStore.getInstance(KeyStore.getDefaultType());
300		keyTest.load(null, null);
301
302		// alias 1
303		keyTest.setCertificateEntry("alias1", cert[0]);
304
305		// alias 2
306        keyTest.setKeyEntry("alias2", privateKey, pssWord, cert);
307
308		java.security.cert.Certificate[] certRes = keyTest
309				.getCertificateChain("alias2");
310		assertTrue("there are more than two certificate returned "
311				+ "from getCertificateChain", certRes.length == 2);
312		assertTrue("the certificates returned from getCertificateChain "
313				+ "is not correct", cert[0].getPublicKey() == certRes[0]
314				.getPublicKey()
315				&& cert[1].getPublicKey() == certRes[1].getPublicKey());
316		java.security.cert.Certificate[] certResNull = keyTest
317				.getCertificateChain("alias1");
318		assertNull("the certificate chain returned from "
319				+ "getCertificateChain is NOT null", certResNull);
320	}
321
322	/**
323	 * @tests java.security.KeyStore#getInstance(java.lang.String)
324	 */
325	public void test_getInstanceLjava_lang_String() throws Exception {
326		// Test for method java.security.KeyStore
327		// java.security.KeyStore.getInstance(java.lang.String)
328		KeyStore keyTest = KeyStore.getInstance(KeyStore.getDefaultType());
329		assertTrue("the method getInstance did not obtain "
330				+ "the correct type", keyTest.getType().equals(
331				KeyStore.getDefaultType()));
332	}
333
334	/**
335	 * @tests java.security.KeyStore#getInstance(java.lang.String,
336	 *        java.lang.String)
337	 */
338	public void test_getInstanceLjava_lang_StringLjava_lang_String()
339			throws Exception {
340		// Test for method java.security.KeyStore
341		// java.security.KeyStore.getInstance(java.lang.String,
342		// java.lang.String)
343		KeyStore keyTest = KeyStore.getInstance("PKCS#12/Netscape",
344				"TestProvider");
345		assertTrue("the method getInstance did not obtain the "
346				+ "correct provider and type", keyTest.getProvider().getName()
347				.equals("TestProvider")
348				&& keyTest.getType().equals("PKCS#12/Netscape"));
349	}
350
351	/**
352	 * @tests java.security.KeyStore#getKey(java.lang.String, char[])
353	 */
354	public void test_getKeyLjava_lang_String$C() throws Exception {
355
356		// Test for method java.security.Key
357		// java.security.KeyStore.getKey(java.lang.String, char [])
358		// creatCertificate();
359		CertificateFactory cf = CertificateFactory.getInstance("X.509");
360		X509Certificate cert[] = new X509Certificate[2];
361		cert[0] = (X509Certificate) cf.generateCertificate(certArray);
362		cert[1] = (X509Certificate) cf.generateCertificate(certArray2);
363		KeyStore keyTest = KeyStore.getInstance(KeyStore.getDefaultType());
364		keyTest.load(null, null);
365
366		keyTest.setKeyEntry("alias2", privateKey, pssWord, cert);
367		PrivateKey returnedKey = (PrivateKey) keyTest.getKey("alias2", pssWord);
368		byte[] retB = returnedKey.getEncoded();
369		byte[] priB = privateKey.getEncoded();
370		boolean equality = Arrays.equals(retB, priB);
371		equality &= returnedKey.getAlgorithm()
372				.equals(privateKey.getAlgorithm());
373		equality &= returnedKey.getFormat().equals(privateKey.getFormat());
374		assertTrue("the private key returned from getKey for a "
375				+ "key entry did not equal the original key", equality);
376
377		try {
378			keyTest.getKey("alias2", "wrong".toCharArray());
379			fail("Should have thrown UnrecoverableKeyException");
380		} catch (UnrecoverableKeyException e) {
381			// expected
382		}
383
384		keyTest.setCertificateEntry("alias1", cert[1]);
385		assertNull("the private key returned from getKey for "
386				+ "a certificate entry is not null", keyTest.getKey("alias1",
387				pssWord));
388	}
389
390	/**
391	 * @tests java.security.KeyStore#getProvider()
392	 */
393	public void test_getProvider() throws Exception {
394		// Test for method java.security.Provider
395		// java.security.KeyStore.getProvider()
396		KeyStore keyTest = KeyStore.getInstance("PKCS#12/Netscape",
397				"TestProvider");
398		Provider provKeyStore = keyTest.getProvider();
399		assertEquals("the provider should be TestProvider", "TestProvider",
400				provKeyStore.getName());
401	}
402
403	/**
404	 * @tests java.security.KeyStore#getType()
405	 */
406	public void test_getType() throws Exception {
407		// Test for method java.lang.String java.security.KeyStore.getType()
408		KeyStore keyTest = KeyStore.getInstance("PKCS#12/Netscape",
409				"TestProvider");
410		assertEquals(
411				"type should be PKCS#12/Netscape for provider TestProvider",
412				"PKCS#12/Netscape", keyTest.getType());
413	}
414
415	/**
416	 * @tests java.security.KeyStore#isCertificateEntry(java.lang.String)
417	 */
418	public void test_isCertificateEntryLjava_lang_String() throws Exception {
419		// Test for method boolean
420		// java.security.KeyStore.isCertificateEntry(java.lang.String)
421		CertificateFactory cf = CertificateFactory.getInstance("X.509");
422		X509Certificate cert[] = new X509Certificate[2];
423		cert[0] = (X509Certificate) cf.generateCertificate(certArray);
424		cert[1] = (X509Certificate) cf.generateCertificate(certArray2);
425		KeyStore keyTest = KeyStore.getInstance(KeyStore.getDefaultType());
426		keyTest.load(null, null);
427		// alias 1
428		keyTest.setCertificateEntry("alias1", cert[0]);
429
430		// alias 2
431        keyTest.setKeyEntry("alias2", privateKey, pssWord, cert);
432
433		assertTrue("isCertificateEntry method returns false for a certificate",
434				keyTest.isCertificateEntry("alias1"));
435		assertFalse("isCertificateEntry method returns true for noncertificate",
436				keyTest.isCertificateEntry("alias2"));
437	}
438
439	/**
440	 * @tests java.security.KeyStore#isKeyEntry(java.lang.String)
441	 */
442	public void test_isKeyEntryLjava_lang_String() throws Exception {
443		// Test for method boolean
444		// java.security.KeyStore.isKeyEntry(java.lang.String)
445		CertificateFactory cf = CertificateFactory.getInstance("X.509");
446		X509Certificate cert[] = new X509Certificate[2];
447		cert[0] = (X509Certificate) cf.generateCertificate(certArray);
448		cert[1] = (X509Certificate) cf.generateCertificate(certArray2);
449		KeyStore keyTest = KeyStore.getInstance(KeyStore.getDefaultType());
450		keyTest.load(null, null);
451		// alias 1
452		keyTest.setCertificateEntry("alias1", cert[0]);
453
454		// alias 2
455        keyTest.setKeyEntry("alias2", privateKey, pssWord, cert);
456
457		assertTrue("isKeyEntry method returns false for a certificate", keyTest
458				.isKeyEntry("alias2"));
459		assertFalse("isKeyEntry method returns true for noncertificate", keyTest
460				.isKeyEntry("alias1"));
461	}
462
463	/**
464	 * @tests java.security.KeyStore#load(java.io.InputStream, char[])
465	 */
466	public void test_loadLjava_io_InputStream$C() throws Exception {
467		// Test for method void java.security.KeyStore.load(java.io.InputStream,
468		// char [])
469		byte[] keyStore = creatCertificate();
470		KeyStore keyTest = KeyStore.getInstance(KeyStore.getDefaultType());
471		InputStream in = new ByteArrayInputStream(keyStore);
472		keyTest.load(in, pssWord);
473		in.close();
474		assertTrue("alias1 is not a certificate", keyTest
475				.isCertificateEntry("alias1"));
476		assertTrue("alias2 is not a keyEntry",
477				keyTest.isKeyEntry("alias2"));
478		assertTrue("alias3 is not a certificate", keyTest
479				.isCertificateEntry("alias3"));
480
481		// test with null password
482		keyTest = KeyStore.getInstance(KeyStore.getDefaultType());
483		in = new ByteArrayInputStream(keyStore);
484		keyTest.load(in, null);
485		in.close();
486		assertTrue("alias1 is not a certificate", keyTest
487				.isCertificateEntry("alias1"));
488		assertTrue("alias2 is not a keyEntry",
489				keyTest.isKeyEntry("alias2"));
490		assertTrue("alias3 is not a certificate", keyTest
491				.isCertificateEntry("alias3"));
492
493		keyTest = KeyStore.getInstance(KeyStore.getDefaultType());
494		InputStream v1in = Support_Resources.getStream("hyts_ks.bks");
495		char[] pass = "abcdef".toCharArray();
496		keyTest.load(v1in, pass);
497		v1in.close();
498		keyTest.getKey("mykey", pass);
499	}
500
501	/**
502	 * @tests java.security.KeyStore#setCertificateEntry(java.lang.String,
503	 *        java.security.cert.Certificate)
504	 */
505	public void test_setCertificateEntryLjava_lang_StringLjava_security_cert_Certificate()
506			throws Exception {
507		// Test for method void
508		// java.security.KeyStore.setCertificateEntry(java.lang.String,
509		// java.security.cert.Certificate)
510		CertificateFactory cf = CertificateFactory.getInstance("X.509");
511		X509Certificate cert = (X509Certificate) cf
512				.generateCertificate(certArray);
513		KeyStore keyTest = KeyStore.getInstance(KeyStore.getDefaultType());
514		keyTest.load(null, null);
515
516		PublicKey pub = cert.getPublicKey();
517		keyTest.setCertificateEntry("alias1", cert);
518		assertTrue(
519				"the entry specified by the alias alias1 is not a certificate",
520				keyTest.isCertificateEntry("alias1"));
521		java.security.cert.Certificate resultCert = keyTest
522				.getCertificate("alias1");
523		assertTrue(
524				"the public key of the certificate from getCertificate() did not equal the original certificate",
525				resultCert.getPublicKey() == pub);
526	}
527
528	/**
529	 * @tests java.security.KeyStore#setKeyEntry(java.lang.String, byte[],
530	 *        java.security.cert.Certificate[])
531	 */
532	public void test_setKeyEntryLjava_lang_String$B$Ljava_security_cert_Certificate()
533			throws Exception {
534
535//		fail("Test hangs - requires a full math implementation ??");
536
537		// Test for method void
538		// java.security.KeyStore.setKeyEntry(java.lang.String, byte [],
539		// java.security.cert.Certificate [])
540
541		CertificateFactory cf = CertificateFactory.getInstance("X.509");
542		X509Certificate cert[] = new X509Certificate[2];
543		cert[0] = (X509Certificate) cf.generateCertificate(certArray);
544		cert[1] = (X509Certificate) cf.generateCertificate(certArray2);
545		KeyStore keyTest = KeyStore.getInstance(KeyStore.getDefaultType());
546		keyTest.load(null, null);
547
548		// set the same alias as keyEntry
549		keyTest.setKeyEntry("alias2", privateKey.getEncoded(), cert);
550		assertTrue("the entry specified by the alias alias2 is not a keyEntry",
551				keyTest.isKeyEntry("alias2"));
552	}
553
554	/**
555	 * @tests java.security.KeyStore#setKeyEntry(java.lang.String,
556	 *        java.security.Key, char[], java.security.cert.Certificate[])
557	 */
558	public void test_setKeyEntryLjava_lang_StringLjava_security_Key$C$Ljava_security_cert_Certificate()
559			throws Exception {
560
561		// Test for method void
562		// java.security.KeyStore.setKeyEntry(java.lang.String,
563		// java.security.Key, char [], java.security.cert.Certificate [])
564
565		CertificateFactory cf = CertificateFactory.getInstance("X.509");
566		X509Certificate cert[] = new X509Certificate[2];
567		cert[0] = (X509Certificate) cf.generateCertificate(certArray);
568		cert[1] = (X509Certificate) cf.generateCertificate(certArray2);
569		KeyStore keyTest = KeyStore.getInstance(KeyStore.getDefaultType());
570		keyTest.load(null, null);
571
572		keyTest.setKeyEntry("alias3", privateKey, pssWord, cert);
573		assertTrue("the entry specified by the alias alias3 is not a keyEntry",
574				keyTest.isKeyEntry("alias3"));
575	}
576
577	/**
578	 * @tests java.security.KeyStore#size()
579	 */
580	public void test_size() throws Exception {
581		// Test for method int java.security.KeyStore.size()
582
583		CertificateFactory cf = CertificateFactory.getInstance("X.509");
584		X509Certificate cert[] = new X509Certificate[2];
585		cert[0] = (X509Certificate) cf.generateCertificate(certArray);
586		cert[1] = (X509Certificate) cf.generateCertificate(certArray2);
587		KeyStore keyTest = KeyStore.getInstance(KeyStore.getDefaultType());
588		keyTest.load(null, null);
589		// alias 1
590		keyTest.setCertificateEntry("alias1", cert[0]);
591
592		// alias 2
593        keyTest.setKeyEntry("alias2", privateKey, pssWord, cert);
594
595		// alias 3
596		keyTest.setCertificateEntry("alias3", cert[1]);
597
598		assertEquals("the size of the keyStore is not 3", 3, keyTest.size());
599	}
600
601
602    public void test_Constructor() throws Exception {
603        KeyStore ks = new MockKeyStore(new MockKeyStoreSpi(), null,
604                "MockKeyStore");
605        ks.load(null, null);
606        ks.store(null, null);
607
608        ks = new MockKeyStore(new MockKeyStoreSpi(), null, "MockKeyStore");
609        ks.load(null);
610        try {
611            ks.store(null);
612            fail("should throw UnsupportedOperationException.");
613        } catch (UnsupportedOperationException e) {
614            // expected.
615        }
616    }
617
618    public class MockKeyStore extends KeyStore{
619
620        public MockKeyStore(KeyStoreSpi keyStoreSpi, Provider provider, String type) {
621            super(keyStoreSpi, provider, type);
622        }
623    }
624
625    public class MockKeyStoreSpi extends KeyStoreSpi {
626
627        @Override
628        public Enumeration<String> engineAliases() {
629            return null;
630        }
631
632        @Override
633        public boolean engineContainsAlias(String alias) {
634            return false;
635        }
636
637        @Override
638        public void engineDeleteEntry(String alias) throws KeyStoreException {
639            return;
640        }
641
642        @Override
643        public Certificate engineGetCertificate(String alias) {
644            return null;
645        }
646
647        @Override
648        public String engineGetCertificateAlias(Certificate cert) {
649            return null;
650        }
651
652        @Override
653        public Certificate[] engineGetCertificateChain(String alias) {
654            return null;
655        }
656
657        @Override
658        public Date engineGetCreationDate(String alias) {
659            return null;
660        }
661
662        @Override
663        public Key engineGetKey(String alias, char[] password)
664                throws NoSuchAlgorithmException, UnrecoverableKeyException {
665            return null;
666        }
667
668        @Override
669        public boolean engineIsCertificateEntry(String alias) {
670            return false;
671        }
672
673        @Override
674        public boolean engineIsKeyEntry(String alias) {
675            return false;
676        }
677
678        @Override
679        public void engineLoad(InputStream stream, char[] password)
680                throws IOException, NoSuchAlgorithmException,
681                CertificateException {
682            return;
683        }
684
685        @Override
686        public void engineSetCertificateEntry(String alias, Certificate cert)
687                throws KeyStoreException {
688            return;
689        }
690
691        @Override
692        public void engineSetKeyEntry(String alias, Key key, char[] password,
693                Certificate[] chain) throws KeyStoreException {
694            return;
695        }
696
697        @Override
698        public void engineSetKeyEntry(String alias, byte[] key,
699                Certificate[] chain) throws KeyStoreException {
700            return;
701        }
702
703        @Override
704        public int engineSize() {
705            return 0;
706        }
707
708        @Override
709        public void engineStore(OutputStream stream, char[] password)
710                throws IOException, NoSuchAlgorithmException,
711                CertificateException {
712            return;
713        }
714
715    }
716
717	/**
718	 * Sets up the fixture, for example, open a network connection. This method
719	 * is called before a test is executed.
720	 */
721	protected void setUp() throws Exception {
722        super.setUp();
723        support_TestProvider = new Support_TestProvider();
724        Security.addProvider(support_TestProvider);
725    }
726
727    protected void tearDown() throws Exception {
728        super.tearDown();
729        Security.removeProvider(support_TestProvider.getName());
730    }
731}