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.math.BigInteger; 25import java.security.InvalidKeyException; 26import java.security.KeyFactory; 27import java.security.KeyPair; 28import java.security.KeyPairGenerator; 29import java.security.KeyStore; 30import java.security.KeyStoreException; 31import java.security.NoSuchAlgorithmException; 32import java.security.NoSuchProviderException; 33import java.security.PrivateKey; 34import java.security.Provider; 35import java.security.PublicKey; 36import java.security.Security; 37import java.security.SecureRandom; 38import java.security.SignatureException; 39import java.security.UnrecoverableKeyException; 40import java.security.cert.Certificate; 41import java.security.cert.CertificateEncodingException; 42import java.security.cert.CertificateException; 43import java.security.cert.CertificateFactory; 44import java.security.cert.X509Certificate; 45import java.security.interfaces.DSAPrivateKey; 46import java.security.spec.DSAPrivateKeySpec; 47import java.util.Arrays; 48import java.util.Calendar; 49import java.util.Enumeration; 50import java.util.HashSet; 51import java.util.Set; 52import libcore.java.security.StandardNames; 53import tests.support.Support_TestProvider; 54 55public class KeyStore2Test extends junit.framework.TestCase { 56 57 private static PrivateKey PRIVATE_KEY; 58 59 private static PrivateKey getPrivateKey() throws Exception { 60 if (PRIVATE_KEY == null) { 61 KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("DSA"); 62 keyPairGenerator.initialize(1024, new SecureRandom()); 63 KeyPair keyPair = keyPairGenerator.genKeyPair(); 64 PRIVATE_KEY = keyPair.getPrivate(); 65 } 66 return PRIVATE_KEY; 67 } 68 69 final char[] pssWord = { 'a', 'b', 'c' }; 70 71 final byte[] testEncoding = new byte[] { (byte) 1, (byte) 2, (byte) 3, 72 (byte) 4, (byte) 5 }; 73 74 private Provider support_TestProvider; 75 76 // creating a certificate 77 String certificate = "-----BEGIN CERTIFICATE-----\n" 78 + "MIICZTCCAdICBQL3AAC2MA0GCSqGSIb3DQEBAgUAMF8xCzAJBgNVBAYTAlVTMSAw\n" 79 + "HgYDVQQKExdSU0EgRGF0YSBTZWN1cml0eSwgSW5jLjEuMCwGA1UECxMlU2VjdXJl\n" 80 + "IFNlcnZlciBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw05NzAyMjAwMDAwMDBa\n" 81 + "Fw05ODAyMjAyMzU5NTlaMIGWMQswCQYDVQQGEwJVUzETMBEGA1UECBMKQ2FsaWZv\n" 82 + "cm5pYTESMBAGA1UEBxMJUGFsbyBBbHRvMR8wHQYDVQQKExZTdW4gTWljcm9zeXN0\n" 83 + "ZW1zLCBJbmMuMSEwHwYDVQQLExhUZXN0IGFuZCBFdmFsdWF0aW9uIE9ubHkxGjAY\n" 84 + "BgNVBAMTEWFyZ29uLmVuZy5zdW4uY29tMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCB\n" 85 + "iQKBgQCofmdY+PiUWN01FOzEewf+GaG+lFf132UpzATmYJkA4AEA/juW7jSi+LJk\n" 86 + "wJKi5GO4RyZoyimAL/5yIWDV6l1KlvxyKslr0REhMBaD/3Z3EsLTTEf5gVrQS6sT\n" 87 + "WMoSZAyzB39kFfsB6oUXNtV8+UKKxSxKbxvhQn267PeCz5VX2QIDAQABMA0GCSqG\n" 88 + "SIb3DQEBAgUAA34AXl3at6luiV/7I9MN5CXYoPJYI8Bcdc1hBagJvTMcmlqL2uOZ\n" 89 + "H9T5hNMEL9Tk6aI7yZPXcw/xI2K6pOR/FrMp0UwJmdxX7ljV6ZtUZf7pY492UqwC\n" 90 + "1777XQ9UEZyrKJvF5ntleeO0ayBqLGVKCWzWZX9YsXCpv47FNLZbupE=\n" 91 + "-----END CERTIFICATE-----\n"; 92 93 ByteArrayInputStream certArray = new ByteArrayInputStream(certificate.getBytes()); 94 95 String certificate2 = "-----BEGIN CERTIFICATE-----\n" 96 + "MIICZzCCAdCgAwIBAgIBGzANBgkqhkiG9w0BAQUFADBhMQswCQYDVQQGEwJVUzEY\n" 97 + "MBYGA1UEChMPVS5TLiBHb3Zlcm5tZW50MQwwCgYDVQQLEwNEb0QxDDAKBgNVBAsT\n" 98 + "A1BLSTEcMBoGA1UEAxMTRG9EIFBLSSBNZWQgUm9vdCBDQTAeFw05ODA4MDMyMjAy\n" 99 + "MjlaFw0wODA4MDQyMjAyMjlaMGExCzAJBgNVBAYTAlVTMRgwFgYDVQQKEw9VLlMu\n" 100 + "IEdvdmVybm1lbnQxDDAKBgNVBAsTA0RvRDEMMAoGA1UECxMDUEtJMRwwGgYDVQQD\n" 101 + "ExNEb0QgUEtJIE1lZCBSb290IENBMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKB\n" 102 + "gQDbrM/J9FrJSX+zxFUbsI9Vw5QbguVBIa95rwW/0M8+sM0r5gd+DY6iubm6wnXk\n" 103 + "CSvbfQlFEDSKr4WYeeGp+d9WlDnQdtDFLdA45tCi5SHjnW+hGAmZnld0rz6wQekF\n" 104 + "5xQaa5A6wjhMlLOjbh27zyscrorMJ1O5FBOWnEHcRv6xqQIDAQABoy8wLTAdBgNV\n" 105 + "HQ4EFgQUVrmYR6m9701cHQ3r5kXyG7zsCN0wDAYDVR0TBAUwAwEB/zANBgkqhkiG\n" 106 + "9w0BAQUFAAOBgQDVX1Y0YqC7vekeZjVxtyuC8Mnxbrz6D109AX07LEIRzNYzwZ0w\n" 107 + "MTImSp9sEzWW+3FueBIU7AxGys2O7X0qmN3zgszPfSiocBuQuXIYQctJhKjF5KVc\n" 108 + "VGQRYYlt+myhl2vy6yPzEVCjiKwMEb1Spu0irCf+lFW2hsdjvmSQMtZvOw==\n" 109 + "-----END CERTIFICATE-----\n"; 110 111 ByteArrayInputStream certArray2 = new ByteArrayInputStream(certificate2.getBytes()); 112 113 String certificate3 = "-----BEGIN CERTIFICATE-----\n" 114 + "MIIDXDCCAsWgAwIBAgIBSjANBgkqhkiG9w0BAQUFADBWMQswCQYDVQQGEwJVUzEY\n" 115 + "MBYGA1UEChMPVS5TLiBHb3Zlcm5tZW50MQwwCgYDVQQLEwNEb0QxDDAKBgNVBAsT\n" 116 + "A1BLSTERMA8GA1UEAxMITWVkIENBLTEwHhcNOTgwODAyMTgwMjQwWhcNMDEwODAy\n" 117 + "MTgwMjQwWjB0MQswCQYDVQQGEwJVUzEYMBYGA1UEChMPVS5TLiBHb3Zlcm5tZW50\n" 118 + "MQwwCgYDVQQLEwNEb0QxDDAKBgNVBAsTA1BLSTENMAsGA1UECxMEVVNBRjEgMB4G\n" 119 + "A1UEAxMXR3VtYnkuSm9zZXBoLjAwMDAwMDUwNDQwgZ8wDQYJKoZIhvcNAQEBBQAD\n" 120 + "gY0AMIGJAoGBALT/R7bPqs1c1YqXAg5HNpZLgW2HuAc7RCaP06cE4R44GBLw/fQc\n" 121 + "VRNLn5pgbTXsDnjiZVd8qEgYqjKFQka4/tNhaF7No2tBZB+oYL/eP0IWtP+h/W6D\n" 122 + "KR5+UvIIdgmx7k3t9jp2Q51JpHhhKEb9WN54trCO9Yu7PYU+LI85jEIBAgMBAAGj\n" 123 + "ggEaMIIBFjAWBgNVHSAEDzANMAsGCWCGSAFlAgELAzAfBgNVHSMEGDAWgBQzOhTo\n" 124 + "CWdhiGUkIOx5cELXppMe9jAdBgNVHQ4EFgQUkLBJl+ayKgzOp/wwBX9M1lSkCg4w\n" 125 + "DgYDVR0PAQH/BAQDAgbAMAwGA1UdEwEB/wQCMAAwgZ0GA1UdHwSBlTCBkjCBj6CB\n" 126 + "jKCBiYaBhmxkYXA6Ly9kcy0xLmNoYW1iLmRpc2EubWlsL2NuJTNkTWVkJTIwQ0El\n" 127 + "MmQxJTJjb3UlM2RQS0klMmNvdSUzZERvRCUyY28lM2RVLlMuJTIwR292ZXJubWVu\n" 128 + "dCUyY2MlM2RVUz9jZXJ0aWZpY2F0ZVJldm9jYXRpb25MaXN0JTNiYmluYXJ5MA0G\n" 129 + "CSqGSIb3DQEBBQUAA4GBAFjapuDHMvIdUeYRyEYdShBR1JZC20tJ3MQnyBQveddz\n" 130 + "LGFDGpIkRAQU7T/5/ne8lMexyxViC21xOlK9LdbJCbVyywvb9uEm/1je9wieQQtr\n" 131 + "kjykuB+WB6qTCIslAO/eUmgzfzIENvnH8O+fH7QTr2PdkFkiPIqBJYHvw7F3XDqy\n" 132 + "-----END CERTIFICATE-----\n"; 133 134 ByteArrayInputStream certArray3 = new ByteArrayInputStream(certificate3.getBytes()); 135 136 private byte[] creatCertificate() throws Exception { 137 ByteArrayOutputStream out = null; 138 139 CertificateFactory cf = CertificateFactory.getInstance("X.509"); 140 X509Certificate cert[] = new X509Certificate[2]; 141 cert[0] = (X509Certificate) cf.generateCertificate(certArray); 142 cert[1] = (X509Certificate) cf.generateCertificate(certArray2); 143 KeyStore keyTest = KeyStore.getInstance(KeyStore.getDefaultType()); 144 keyTest.load(null, null); 145 // alias 1 146 keyTest.setCertificateEntry("alias1", cert[0]); 147 148 // alias 2 149 keyTest.setKeyEntry("alias2", getPrivateKey(), pssWord, cert); 150 151 // alias 3 152 keyTest.setCertificateEntry("alias3", cert[1]); 153 154 out = new ByteArrayOutputStream(); 155 keyTest.store(out, pssWord); 156 out.close(); 157 158 return out.toByteArray(); 159 } 160 161 /** 162 * java.security.KeyStore#aliases() 163 */ 164 public void test_aliases() throws Exception { 165 // Test for method java.util.Enumeration 166 // java.security.KeyStore.aliases() 167 // NOT COMPATIBLE WITH PCS#12 168 CertificateFactory cf = CertificateFactory.getInstance("X.509"); 169 X509Certificate cert[] = new X509Certificate[2]; 170 cert[0] = (X509Certificate) cf.generateCertificate(certArray); 171 cert[1] = (X509Certificate) cf.generateCertificate(certArray2); 172 KeyStore keyTest = KeyStore.getInstance(KeyStore.getDefaultType()); 173 174 try { 175 keyTest.aliases(); 176 fail(); 177 } catch (KeyStoreException expected) { 178 } 179 180 keyTest.load(null, null); 181 182 // KeyStore keyTest = 183 // KeyStore.getInstance(KeyStore.getDefaultType()); 184 // alias 1 185 keyTest.setCertificateEntry("alias1", cert[0]); 186 187 // alias 2 188 keyTest.setCertificateEntry("alias2", cert[0]); 189 190 // alias 3 191 keyTest.setCertificateEntry("alias3", cert[0]); 192 193 // obtaining the aliase 194 Enumeration<String> aliase = keyTest.aliases(); 195 Set<String> alia = new HashSet<String>(); 196 int i = 0; 197 while (aliase.hasMoreElements()) { 198 alia.add(aliase.nextElement()); 199 i++; 200 } 201 assertEquals("the wrong aliases were returned", i, 3); 202 assertTrue("the wrong aliases were returned", alia.contains("alias1")); 203 assertTrue("the wrong aliases were returned", alia.contains("alias2")); 204 assertTrue("the wrong aliases were returned", alia.contains("alias3")); 205 } 206 207 /** 208 * java.security.KeyStore#containsAlias(java.lang.String) 209 */ 210 public void test_containsAliasLjava_lang_String() throws Exception { 211 // Test for method boolean 212 // java.security.KeyStore.containsAlias(java.lang.String) 213 CertificateFactory cf = CertificateFactory.getInstance("X.509"); 214 X509Certificate cert[] = new X509Certificate[2]; 215 cert[0] = (X509Certificate) cf.generateCertificate(certArray); 216 cert[1] = (X509Certificate) cf.generateCertificate(certArray2); 217 KeyStore keyTest = KeyStore.getInstance(KeyStore.getDefaultType()); 218 219 try { 220 keyTest.containsAlias("alias1"); 221 fail(); 222 } catch (KeyStoreException expected) { 223 } 224 225 keyTest.load(null, null); 226 227 // alias 1 228 keyTest.setCertificateEntry("alias1", cert[0]); 229 230 // alias 2 231 keyTest.setCertificateEntry("alias2", cert[0]); 232 233 assertTrue("alias1 does not exist", keyTest.containsAlias("alias1")); 234 assertTrue("alias2 does not exist", keyTest.containsAlias("alias2")); 235 assertFalse("alias3 exists", keyTest.containsAlias("alias3")); 236 237 try { 238 keyTest.containsAlias(null); 239 fail(); 240 } catch (NullPointerException expected) { 241 } 242 } 243 244 /** 245 * java.security.KeyStore#getCertificate(java.lang.String) 246 */ 247 public void test_getCertificateLjava_lang_String() throws Exception { 248 // Test for method java.security.cert.Certificate 249 // java.security.KeyStore.getCertificate(java.lang.String) 250 CertificateFactory cf = CertificateFactory.getInstance("X.509"); 251 X509Certificate cert[] = new X509Certificate[2]; 252 cert[0] = (X509Certificate) cf.generateCertificate(certArray); 253 cert[1] = (X509Certificate) cf.generateCertificate(certArray2); 254 KeyStore keyTest = KeyStore.getInstance(KeyStore.getDefaultType()); 255 256 try { 257 keyTest.getCertificate("anAlias"); 258 fail(); 259 } catch (KeyStoreException expected) { 260 } 261 262 keyTest.load(null, null); 263 264 // alias 1 265 PublicKey pub = cert[0].getPublicKey(); 266 keyTest.setCertificateEntry("alias1", cert[0]); 267 268 Certificate certRes = keyTest.getCertificate("alias1"); 269 assertEquals("the public key of the certificate from getCertificate() " 270 + "did not equal the original certificate", 271 pub, certRes.getPublicKey()); 272 273 // alias 2 274 keyTest.setCertificateEntry("alias2", cert[0]); 275 276 // testing for a certificate chain 277 Certificate cert2 = keyTest.getCertificate("alias2"); 278 assertEquals("the certificate for alias2 is supposed to exist", 279 cert2, cert[0]); 280 281 } 282 283 /** 284 * java.security.KeyStore#getCertificateAlias(java.security.cert.Certificate) 285 */ 286 public void test_getCertificateAliasLjava_security_cert_Certificate() 287 throws Exception { 288 // Test for method java.lang.String 289 // java.security.KeyStore.getCertificateAlias(java.security.cert.Certificate) 290 CertificateFactory cf = CertificateFactory.getInstance("X.509"); 291 X509Certificate cert[] = new X509Certificate[2]; 292 cert[0] = (X509Certificate) cf.generateCertificate(certArray); 293 cert[1] = (X509Certificate) cf.generateCertificate(certArray2); 294 KeyStore keyTest = KeyStore.getInstance(KeyStore.getDefaultType()); 295 keyTest.load(null, null); 296 297 // certificate entry 298 keyTest.setCertificateEntry("alias1", cert[1]); 299 String alias = keyTest.getCertificateAlias(cert[1]); 300 assertEquals("certificate entry - the alias returned for this certificate was wrong", 301 "alias1", alias); 302 303 // key entry 304 305 keyTest.setKeyEntry("alias2", getPrivateKey(), pssWord, cert); 306 alias = keyTest.getCertificateAlias(cert[0]); 307 assertEquals("key entry - the alias returned for this certificate was wrong", 308 "alias2", alias); 309 310 // testing case with a nonexistent certificate 311 X509Certificate cert2 = (X509Certificate) cf.generateCertificate(certArray3); 312 String aliasNull = keyTest.getCertificateAlias(cert2); 313 assertNull("the alias returned for the nonexist certificate was NOT null", aliasNull); 314 } 315 316 /** 317 * java.security.KeyStore#getCertificateChain(java.lang.String) 318 */ 319 public void test_getCertificateChainLjava_lang_String() throws Exception { 320 // Test for method java.security.cert.Certificate[] 321 // java.security.KeyStore.getCertificateChain(java.lang.String) 322 // creatCertificate(); 323 CertificateFactory cf = CertificateFactory.getInstance("X.509"); 324 X509Certificate cert[] = new X509Certificate[2]; 325 cert[0] = (X509Certificate) cf.generateCertificate(certArray); 326 cert[1] = (X509Certificate) cf.generateCertificate(certArray2); 327 KeyStore keyTest = KeyStore.getInstance(KeyStore.getDefaultType()); 328 329 try { 330 keyTest.getCertificateChain("anAlias"); 331 fail(); 332 } catch (KeyStoreException expected) { 333 } 334 335 keyTest.load(null, null); 336 337 // alias 1 338 keyTest.setCertificateEntry("alias1", cert[0]); 339 340 // alias 2 341 keyTest.setKeyEntry("alias2", getPrivateKey(), pssWord, cert); 342 343 Certificate[] certRes = keyTest.getCertificateChain("alias2"); 344 assertEquals("there are more than two certificate returned from getCertificateChain", 345 2, certRes.length); 346 assertEquals("the first certificate returned from getCertificateChain is not correct", 347 cert[0].getPublicKey(), certRes[0].getPublicKey()); 348 assertEquals("the second certificate returned from getCertificateChain is not correct", 349 cert[1].getPublicKey(), certRes[1].getPublicKey()); 350 Certificate[] certResNull = keyTest.getCertificateChain("alias1"); 351 assertNull("the certificate chain returned from getCertificateChain is NOT null", 352 certResNull); 353 354 try { 355 keyTest.getCertificateChain(null); 356 fail(); 357 } catch (NullPointerException expected) { 358 } 359 360 } 361 362 /** 363 * java.security.KeyStore#getInstance(java.lang.String) 364 */ 365 public void test_getInstanceLjava_lang_String() throws Exception { 366 // Test for method java.security.KeyStore 367 // java.security.KeyStore.getInstance(java.lang.String) 368 KeyStore keyTest = KeyStore.getInstance(KeyStore.getDefaultType()); 369 assertEquals("the method getInstance did not obtain the correct type", 370 KeyStore.getDefaultType(), keyTest.getType()); 371 } 372 373 /** 374 * java.security.KeyStore#getKey(java.lang.String, char[]) 375 */ 376 public void test_getKeyLjava_lang_String$C() throws Exception { 377 378 // Test for method java.security.Key 379 // java.security.KeyStore.getKey(java.lang.String, char[]) 380 // creatCertificate(); 381 CertificateFactory cf = CertificateFactory.getInstance("X.509"); 382 X509Certificate cert[] = new X509Certificate[2]; 383 cert[0] = (X509Certificate) cf.generateCertificate(certArray); 384 cert[1] = (X509Certificate) cf.generateCertificate(certArray2); 385 KeyStore keyTest = KeyStore.getInstance(KeyStore.getDefaultType()); 386 keyTest.load(null, null); 387 388 keyTest.setKeyEntry("alias2", getPrivateKey(), pssWord, cert); 389 PrivateKey returnedKey = (PrivateKey) keyTest.getKey("alias2", pssWord); 390 byte[] retB = returnedKey.getEncoded(); 391 byte[] priB = getPrivateKey().getEncoded(); 392 assertTrue(Arrays.equals(retB, priB)); 393 assertEquals(getPrivateKey().getAlgorithm(), returnedKey.getAlgorithm()); 394 assertEquals(getPrivateKey().getFormat(), returnedKey.getFormat()); 395 396 try { 397 keyTest.getKey("alias2", "wrong".toCharArray()); 398 fail(); 399 } catch (UnrecoverableKeyException expected) { 400 } 401 402 keyTest.setCertificateEntry("alias1", cert[1]); 403 assertNull("the private key returned from getKey for a certificate entry is not null", 404 keyTest.getKey("alias1", pssWord)); 405 } 406 407 408 /** 409 * java.security.KeyStore#isCertificateEntry(java.lang.String) 410 */ 411 public void test_isCertificateEntryLjava_lang_String() throws Exception { 412 // Test for method boolean 413 // java.security.KeyStore.isCertificateEntry(java.lang.String) 414 CertificateFactory cf = CertificateFactory.getInstance("X.509"); 415 X509Certificate cert[] = new X509Certificate[2]; 416 cert[0] = (X509Certificate) cf.generateCertificate(certArray); 417 cert[1] = (X509Certificate) cf.generateCertificate(certArray2); 418 KeyStore keyTest = KeyStore.getInstance(KeyStore.getDefaultType()); 419 420 try { 421 keyTest.isCertificateEntry("alias"); 422 fail(); 423 } catch (KeyStoreException expected) { 424 } 425 426 keyTest.load(null, null); 427 // alias 1 428 keyTest.setCertificateEntry("alias1", cert[0]); 429 430 // alias 2 431 keyTest.setKeyEntry("alias2", getPrivateKey(), 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 * 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 451 try { 452 keyTest.isKeyEntry("alias"); 453 fail(); 454 } catch (KeyStoreException expected) { 455 } 456 457 keyTest.load(null, null); 458 // alias 1 459 keyTest.setCertificateEntry("alias1", cert[0]); 460 461 // alias 2 462 keyTest.setKeyEntry("alias2", getPrivateKey(), pssWord, cert); 463 464 assertTrue("isKeyEntry method returns false for a certificate", 465 keyTest.isKeyEntry("alias2")); 466 assertFalse("isKeyEntry method returns true for noncertificate", 467 keyTest.isKeyEntry("alias1")); 468 } 469 470 /** 471 * java.security.KeyStore#load(java.io.InputStream, char[]) 472 */ 473 public void test_loadLjava_io_InputStream$C() throws Exception { 474 // Test for method void java.security.KeyStore.load(java.io.InputStream, 475 // char[]) 476 byte[] keyStore = creatCertificate(); 477 KeyStore keyTest = KeyStore.getInstance(KeyStore.getDefaultType()); 478 InputStream in = new ByteArrayInputStream(keyStore); 479 keyTest.load(in, pssWord); 480 in.close(); 481 assertTrue("alias1 is not a certificate", keyTest.isCertificateEntry("alias1")); 482 assertTrue("alias2 is not a keyEntry", keyTest.isKeyEntry("alias2")); 483 assertTrue("alias3 is not a certificate", keyTest.isCertificateEntry("alias3")); 484 485 // test with null password 486 keyTest = KeyStore.getInstance(KeyStore.getDefaultType()); 487 in = new ByteArrayInputStream(keyStore); 488 keyTest.load(in, null); 489 in.close(); 490 assertTrue("alias1 is not a certificate", keyTest.isCertificateEntry("alias1")); 491 assertTrue("alias2 is not a keyEntry", keyTest.isKeyEntry("alias2")); 492 assertTrue("alias3 is not a certificate", keyTest.isCertificateEntry("alias3")); 493 494 } 495 496 /** 497 * java.security.KeyStore#load(KeyStore.LoadStoreParameter param) 498 */ 499 public void test_loadLjava_security_KeyStoreLoadStoreParameter() throws Exception { 500 KeyStore.getInstance(KeyStore.getDefaultType()).load(null); 501 } 502 503 /** 504 * java.security.KeyStore#setCertificateEntry(java.lang.String, 505 * java.security.cert.Certificate) 506 */ 507 public void test_setCertificateEntryLjava_lang_StringLjava_security_cert_Certificate() 508 throws Exception { 509 // Test for method void 510 // java.security.KeyStore.setCertificateEntry(java.lang.String, 511 // java.security.cert.Certificate) 512 CertificateFactory cf = CertificateFactory.getInstance("X.509"); 513 X509Certificate cert = (X509Certificate) cf.generateCertificate(certArray); 514 KeyStore keyTest = KeyStore.getInstance(KeyStore.getDefaultType()); 515 516 try { 517 keyTest.setCertificateEntry("alias", cert); 518 fail(); 519 } catch (KeyStoreException expected) { 520 } 521 522 keyTest.load(null, null); 523 524 PublicKey pub = cert.getPublicKey(); 525 keyTest.setCertificateEntry("alias1", cert); 526 assertTrue("the entry specified by the alias alias1 is not a certificate", 527 keyTest.isCertificateEntry("alias1")); 528 Certificate resultCert = keyTest.getCertificate("alias1"); 529 assertEquals("the public key of the certificate from getCertificate() " 530 + "did not equal the original certificate", 531 pub, resultCert.getPublicKey()); 532 533 534 } 535 536 /** 537 * java.security.KeyStore#setKeyEntry(java.lang.String, 538 * java.security.Key, char[], java.security.cert.Certificate[]) 539 */ 540 public void test_setKeyEntryLjava_lang_StringLjava_security_Key$C$Ljava_security_cert_Certificate() 541 throws Exception { 542 543 // Test for method void 544 // java.security.KeyStore.setKeyEntry(java.lang.String, 545 // java.security.Key, char[], java.security.cert.Certificate[]) 546 547 CertificateFactory cf = CertificateFactory.getInstance("X.509"); 548 X509Certificate cert[] = new X509Certificate[2]; 549 cert[0] = (X509Certificate) cf.generateCertificate(certArray); 550 cert[1] = (X509Certificate) cf.generateCertificate(certArray2); 551 KeyStore keyTest = KeyStore.getInstance(KeyStore.getDefaultType()); 552 553 try { 554 keyTest.setKeyEntry("alias3", getPrivateKey(), pssWord, cert); 555 fail(); 556 } catch (KeyStoreException expected) { 557 } 558 559 keyTest.load(null, null); 560 561 keyTest.setKeyEntry("alias3", getPrivateKey(), pssWord, cert); 562 assertTrue("the entry specified by the alias alias3 is not a keyEntry", 563 keyTest.isKeyEntry("alias3")); 564 565 try { 566 keyTest.setKeyEntry("alias4", getPrivateKey(), pssWord, new Certificate[] {}); 567 fail(); 568 } catch (IllegalArgumentException expected) { 569 } 570 571 } 572 573 /** 574 * java.security.KeyStore#size() 575 */ 576 public void test_size() throws Exception { 577 // Test for method int java.security.KeyStore.size() 578 579 CertificateFactory cf = CertificateFactory.getInstance("X.509"); 580 X509Certificate cert[] = new X509Certificate[2]; 581 cert[0] = (X509Certificate) cf.generateCertificate(certArray); 582 cert[1] = (X509Certificate) cf.generateCertificate(certArray2); 583 KeyStore keyTest = KeyStore.getInstance(KeyStore.getDefaultType()); 584 585 try { 586 keyTest.size(); 587 fail(); 588 } catch (KeyStoreException expected) { 589 } 590 591 keyTest.load(null, null); 592 // alias 1 593 keyTest.setCertificateEntry("alias1", cert[0]); 594 595 // alias 2 596 keyTest.setKeyEntry("alias2", getPrivateKey(), pssWord, cert); 597 598 // alias 3 599 keyTest.setCertificateEntry("alias3", cert[1]); 600 601 assertEquals("the size of the keyStore is not 3", 3, keyTest.size()); 602 } 603 604 public void test_deleteEmptyEntryEmptyAlias() throws Exception { 605 KeyStore keyTest = KeyStore.getInstance(KeyStore.getDefaultType()); 606 keyTest.load(null, null); 607 keyTest.deleteEntry(""); 608 } 609 610 public void test_deleteEmptyEntryBogusAlias() throws Exception { 611 KeyStore keyTest = KeyStore.getInstance(KeyStore.getDefaultType()); 612 keyTest.load(null, null); 613 keyTest.deleteEntry("bogus"); 614 } 615 616 /** 617 * java.security.KeyStore#deleteEntry(String) 618 */ 619 public void test_deleteEntry() throws Exception { 620 try { 621 KeyStore keyTest = KeyStore.getInstance(KeyStore.getDefaultType()); 622 keyTest.load(null, null); 623 keyTest.deleteEntry(null); 624 fail(); 625 } catch (NullPointerException expected) { 626 } 627 628 KeyStore keyTest = KeyStore.getInstance(KeyStore.getDefaultType()); 629 keyTest.load(null, "password".toCharArray()); 630 631 KeyStore.PasswordProtection pp = new KeyStore.PasswordProtection(pssWord); 632 Certificate[] chain = { new MyCertificate("DSA", testEncoding), 633 new MyCertificate("DSA", testEncoding) }; 634 KeyStore.PrivateKeyEntry pkEntry = new KeyStore.PrivateKeyEntry(getPrivateKey(), chain); 635 636 keyTest.setEntry("symKey", pkEntry, pp); 637 638 keyTest.deleteEntry("symKey"); 639 } 640 641 /** 642 * java.security.KeyStore#getCreationDate(String) 643 */ 644 public void test_getCreationDate() throws Exception { 645 String type = "DSA"; 646 647 KeyStore keyTest = KeyStore.getInstance(KeyStore.getDefaultType()); 648 649 try { 650 keyTest.getCreationDate("anAlias"); 651 fail(); 652 } catch (KeyStoreException expected) { 653 } 654 655 keyTest.load(null, pssWord); 656 657 assertNull(keyTest.getCreationDate("")); 658 try { 659 keyTest.getCreationDate(null); 660 fail(); 661 } catch (NullPointerException expected) { 662 } 663 664 Certificate[] chain = { new MyCertificate(type, testEncoding), 665 new MyCertificate(type, testEncoding) }; 666 PrivateKey privateKey1 = KeyFactory.getInstance(type).generatePrivate( 667 new DSAPrivateKeySpec(new BigInteger("0"), new BigInteger("0"), 668 new BigInteger("0"), new BigInteger("0"))); 669 670 KeyStore.PasswordProtection pp = new KeyStore.PasswordProtection( 671 pssWord); 672 KeyStore.PrivateKeyEntry pke = new KeyStore.PrivateKeyEntry(getPrivateKey(), 673 chain); 674 KeyStore.PrivateKeyEntry pke1 = new KeyStore.PrivateKeyEntry( 675 privateKey1, chain); 676 677 keyTest.setEntry("alias1", pke, pp); 678 keyTest.setEntry("alias2", pke1, pp); 679 Calendar.getInstance().get(Calendar.DAY_OF_MONTH); 680 681 int dayExpected = Calendar.getInstance().get(Calendar.DAY_OF_MONTH); 682 int monthExpected = Calendar.getInstance().get(Calendar.MONTH); 683 int yearExpected = Calendar.getInstance().get(Calendar.YEAR); 684 int hourExpected = Calendar.getInstance().get(Calendar.HOUR); 685 int minuteExpected = Calendar.getInstance().get(Calendar.MINUTE); 686 687 Calendar.getInstance().setTimeInMillis(keyTest.getCreationDate("alias1").getTime()); 688 int dayActual1 = Calendar.getInstance().get(Calendar.DAY_OF_MONTH); 689 int monthActual1 = Calendar.getInstance().get(Calendar.MONTH); 690 int yearActual1 = Calendar.getInstance().get(Calendar.YEAR); 691 int hourActual1 = Calendar.getInstance().get(Calendar.HOUR); 692 int minuteActual1 = Calendar.getInstance().get(Calendar.MINUTE); 693 694 assertEquals(dayExpected, dayActual1); 695 assertEquals(monthExpected, monthActual1); 696 assertEquals(yearExpected, yearActual1); 697 assertEquals(hourExpected, hourActual1); 698 assertEquals(minuteExpected, minuteActual1); 699 700 Calendar.getInstance().setTimeInMillis( 701 keyTest.getCreationDate("alias2").getTime()); 702 int dayActual2 = Calendar.getInstance().get(Calendar.DAY_OF_MONTH); 703 int monthActual2 = Calendar.getInstance().get(Calendar.MONTH); 704 int yearActual2 = Calendar.getInstance().get(Calendar.YEAR); 705 int hourActual2 = Calendar.getInstance().get(Calendar.HOUR); 706 int minuteActual2 = Calendar.getInstance().get(Calendar.MINUTE); 707 708 assertEquals(dayExpected, dayActual2); 709 assertEquals(monthExpected, monthActual2); 710 assertEquals(yearExpected, yearActual2); 711 assertEquals(hourExpected, hourActual2); 712 assertEquals(minuteExpected, minuteActual2); 713 714 try { 715 keyTest.getCreationDate(null); 716 fail(); 717 } catch (NullPointerException expected) { 718 } 719 } 720 721 /** 722 * java.security.KeyStore#getEntry(String, 723 * KeyStore.ProtectionParameter) 724 */ 725 public void test_getEntry() throws Exception { 726 String type = "DSA"; 727 728 KeyStore keyTest = KeyStore.getInstance(KeyStore.getDefaultType()); 729 730 try { 731 keyTest.getEntry("anAlias", new KeyStore.PasswordProtection(new char[] {})); 732 fail(); 733 } catch (KeyStoreException expected) { 734 } 735 736 keyTest.load(null, pssWord); 737 738 try { 739 keyTest.getEntry(null, new KeyStore.PasswordProtection(new char[] {})); 740 fail(); 741 } catch (NullPointerException expected) { 742 } 743 744 keyTest.getEntry("anAlias", null); 745 746 try { 747 keyTest.getEntry(null, null); 748 fail(); 749 } catch (NullPointerException expected) { 750 } 751 752 753 assertNull(keyTest.getEntry("alias", null)); 754 755 Certificate[] chain = { new MyCertificate(type, testEncoding), 756 new MyCertificate(type, testEncoding) }; 757 758 DSAPrivateKey privateKey1 = (DSAPrivateKey) 759 KeyFactory.getInstance(type).generatePrivate( 760 new DSAPrivateKeySpec(new BigInteger("1"), 761 new BigInteger("2"), 762 new BigInteger("3"), 763 new BigInteger("4"))); 764 765 KeyStore.PasswordProtection pp = new KeyStore.PasswordProtection(pssWord); 766 assertNull(keyTest.getEntry("alias", pp)); 767 768 KeyStore.PrivateKeyEntry pke1 = new KeyStore.PrivateKeyEntry(getPrivateKey(), chain); 769 KeyStore.PrivateKeyEntry pke2 = new KeyStore.PrivateKeyEntry(privateKey1, chain); 770 771 keyTest.setEntry("alias1", pke1, pp); 772 keyTest.setEntry("alias2", pke2, pp); 773 774 assertNull(keyTest.getEntry("alias", pp)); 775 KeyStore.PrivateKeyEntry pkeActual1 = (KeyStore.PrivateKeyEntry) keyTest.getEntry("alias1", 776 pp); 777 KeyStore.PrivateKeyEntry pkeActual2 = (KeyStore.PrivateKeyEntry) keyTest.getEntry("alias2", 778 pp); 779 780 assertTrue(Arrays.equals(chain, pkeActual1.getCertificateChain())); 781 assertEquals(getPrivateKey(), pkeActual1.getPrivateKey()); 782 assertEquals(new MyCertificate(type, testEncoding), pkeActual1.getCertificate()); 783 assertTrue(keyTest.entryInstanceOf("alias1", KeyStore.PrivateKeyEntry.class)); 784 785 assertTrue(Arrays.equals(chain, pkeActual2.getCertificateChain())); 786 DSAPrivateKey entryPrivateKey = (DSAPrivateKey) pkeActual2.getPrivateKey(); 787 assertEquals(privateKey1.getX(), entryPrivateKey.getX()); 788 assertEquals(privateKey1.getParams().getG(), entryPrivateKey.getParams().getG()); 789 assertEquals(privateKey1.getParams().getP(), entryPrivateKey.getParams().getP()); 790 assertEquals(privateKey1.getParams().getQ(), entryPrivateKey.getParams().getQ()); 791 792 assertEquals(new MyCertificate(type, testEncoding), pkeActual2.getCertificate()); 793 assertTrue(keyTest.entryInstanceOf("alias2", KeyStore.PrivateKeyEntry.class)); 794 } 795 796 /** 797 * java.security.KeyStore#setEntry(String, KeyStore.Entry, 798 * KeyStore.ProtectionParameter) 799 */ 800 public void test_setEntry() throws Exception { 801 String type = "DSA"; 802 803 KeyStore keyTest = KeyStore.getInstance(KeyStore.getDefaultType()); 804 keyTest.load(null, pssWord); 805 806 Certificate[] chain = { new MyCertificate(type, testEncoding), 807 new MyCertificate(type, testEncoding) }; 808 DSAPrivateKey privateKey1 = (DSAPrivateKey) 809 KeyFactory.getInstance(type).generatePrivate( 810 new DSAPrivateKeySpec(new BigInteger("1"), 811 new BigInteger("2"), 812 new BigInteger("3"), 813 new BigInteger("4"))); 814 815 KeyStore.PasswordProtection pp = new KeyStore.PasswordProtection(pssWord); 816 KeyStore.PrivateKeyEntry pke = new KeyStore.PrivateKeyEntry(getPrivateKey(), chain); 817 KeyStore.PrivateKeyEntry pke1 = new KeyStore.PrivateKeyEntry(privateKey1, chain); 818 819 try { 820 keyTest.setEntry("alias", pke, null); 821 assertFalse(StandardNames.IS_RI); // BKS KeyStore does not require a password 822 } catch (KeyStoreException e) { 823 assertTrue(StandardNames.IS_RI); // JKS KeyStore requires a password 824 } 825 826 keyTest.setEntry("alias", pke, pp); 827 828 KeyStore.PrivateKeyEntry pkeActual = (KeyStore.PrivateKeyEntry) 829 keyTest.getEntry("alias",pp); 830 831 assertTrue(Arrays.equals(chain, pkeActual.getCertificateChain())); 832 assertEquals(getPrivateKey(), pkeActual.getPrivateKey()); 833 assertEquals(new MyCertificate(type, testEncoding), pkeActual.getCertificate()); 834 assertTrue(keyTest.entryInstanceOf("alias", KeyStore.PrivateKeyEntry.class)); 835 836 keyTest.setEntry("alias", pke1, pp); 837 pkeActual = (KeyStore.PrivateKeyEntry) keyTest.getEntry("alias", pp); 838 839 assertTrue(Arrays.equals(chain, pkeActual.getCertificateChain())); 840 DSAPrivateKey actualPrivateKey = (DSAPrivateKey) pkeActual.getPrivateKey(); 841 assertEquals(privateKey1.getX(), actualPrivateKey.getX()); 842 assertEquals(privateKey1.getParams().getG(), actualPrivateKey.getParams().getG()); 843 assertEquals(privateKey1.getParams().getP(), actualPrivateKey.getParams().getP()); 844 assertEquals(privateKey1.getParams().getQ(), actualPrivateKey.getParams().getQ()); 845 assertEquals(new MyCertificate(type, testEncoding), pkeActual.getCertificate()); 846 assertTrue(keyTest.entryInstanceOf("alias", KeyStore.PrivateKeyEntry.class)); 847 848 keyTest.setEntry("alias2", pke1, pp); 849 pkeActual = (KeyStore.PrivateKeyEntry) keyTest.getEntry("alias2", pp); 850 851 assertTrue(Arrays.equals(chain, pkeActual.getCertificateChain())); 852 actualPrivateKey = (DSAPrivateKey) pkeActual.getPrivateKey(); 853 assertEquals(privateKey1.getX(), actualPrivateKey.getX()); 854 assertEquals(privateKey1.getParams().getG(), actualPrivateKey.getParams().getG()); 855 assertEquals(privateKey1.getParams().getP(), actualPrivateKey.getParams().getP()); 856 assertEquals(privateKey1.getParams().getQ(), actualPrivateKey.getParams().getQ()); 857 assertEquals(new MyCertificate(type, testEncoding), pkeActual.getCertificate()); 858 assertTrue(keyTest.entryInstanceOf("alias2", KeyStore.PrivateKeyEntry.class)); 859 860 try { 861 keyTest.setEntry(null, null, null); 862 fail(); 863 } catch (NullPointerException expected) { 864 } 865 } 866 867 /* 868 * java.security.KeyStore.entryInstanceOf(String, Class<? extends 869 * Entry>) 870 */ 871 public void test_entryInstanceOf() throws Exception { 872 873 KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType()); 874 875 try { 876 keyStore.entryInstanceOf("anAlias", KeyStore.SecretKeyEntry.class); 877 fail(); 878 } catch (KeyStoreException expected) { 879 } 880 881 keyStore.load(null, "pwd".toCharArray()); 882 883 // put the key into keystore 884 String alias = "alias"; 885 Certificate[] chain = { new MyCertificate("DSA", testEncoding), 886 new MyCertificate("DSA", testEncoding) }; 887 888 keyStore.setKeyEntry(alias, getPrivateKey(), "pwd".toCharArray(), chain); 889 assertTrue(keyStore.entryInstanceOf(alias, KeyStore.PrivateKeyEntry.class)); 890 assertFalse(keyStore.entryInstanceOf(alias, KeyStore.SecretKeyEntry.class)); 891 assertFalse(keyStore.entryInstanceOf(alias, KeyStore.TrustedCertificateEntry.class)); 892 893 try { 894 keyStore.entryInstanceOf(null, KeyStore.SecretKeyEntry.class); 895 } catch (NullPointerException expected) { 896 } 897 898 try { 899 keyStore.entryInstanceOf("anAlias", null); 900 fail(); 901 } catch (NullPointerException expected) { 902 } 903 } 904 905 /** 906 * java.security.KeyStore#store(KeyStore.LoadStoreParameter) 907 */ 908 public void test_store_java_securityKeyStore_LoadStoreParameter() 909 throws Exception { 910 KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType()); 911 keyStore.load(null, "pwd".toCharArray()); 912 try { 913 keyStore.store(null); 914 fail(); 915 } catch (UnsupportedOperationException expected) { 916 } 917 } 918 919 /** 920 * java.security.KeyStore#store(OutputStream, char[]) 921 */ 922 public void test_store_java_io_OutputStream_char() throws Exception { 923 KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType()); 924 925 try { 926 keyStore.store(new ByteArrayOutputStream(), "pwd".toCharArray()); 927 } catch (KeyStoreException expected) { 928 } 929 930 keyStore.load(null, "pwd".toCharArray()); 931 try { 932 keyStore.store(null, "pwd".toCharArray()); 933 fail(); 934 } catch (NullPointerException expected) { 935 } catch (IOException expected) { 936 } 937 } 938 939 /** 940 * Sets up the fixture, for example, open a network connection. This method 941 * is called before a test is executed. 942 */ 943 protected void setUp() throws Exception { 944 super.setUp(); 945 support_TestProvider = new Support_TestProvider(); 946 Security.addProvider(support_TestProvider); 947 } 948 949 protected void tearDown() throws Exception { 950 super.tearDown(); 951 Security.removeProvider(support_TestProvider.getName()); 952 } 953 954 class MyCertificate extends Certificate { 955 956 // MyCertificate encoding 957 private final byte[] encoding; 958 959 public MyCertificate(String type, byte[] encoding) { 960 super(type); 961 // don't copy to allow null parameter in test 962 this.encoding = encoding; 963 } 964 965 public byte[] getEncoded() throws CertificateEncodingException { 966 // do copy to force NPE in test 967 return encoding.clone(); 968 } 969 970 public void verify(PublicKey key) throws CertificateException, 971 NoSuchAlgorithmException, InvalidKeyException, 972 NoSuchProviderException, SignatureException { 973 } 974 975 public void verify(PublicKey key, String sigProvider) 976 throws CertificateException, NoSuchAlgorithmException, 977 InvalidKeyException, NoSuchProviderException, 978 SignatureException { 979 } 980 981 public String toString() { 982 return "[My test Certificate, type: " + getType() + "]"; 983 } 984 985 public PublicKey getPublicKey() { 986 return new PublicKey() { 987 public String getAlgorithm() { 988 return "DSA"; 989 } 990 991 public byte[] getEncoded() { 992 return new byte[] { (byte) 1, (byte) 2, (byte) 3 }; 993 } 994 995 public String getFormat() { 996 return "TEST_FORMAT"; 997 } 998 }; 999 } 1000 1001 } 1002} 1003