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}