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 18/** 19* @author Vera Y. Petrashkova 20*/ 21 22package org.apache.harmony.security.tests.java.security; 23 24import java.io.IOException; 25import java.security.KeyStore; 26import java.security.KeyStoreException; 27import java.security.Provider; 28import java.security.Security; 29import java.security.SignatureException; 30import java.security.Principal; 31import java.security.PublicKey; 32import java.security.InvalidKeyException; 33import java.security.NoSuchProviderException; 34import java.security.NoSuchAlgorithmException; 35import java.security.cert.Certificate; 36import java.security.cert.CertificateException; 37import java.security.cert.CertificateEncodingException; 38import java.security.cert.CertificateExpiredException; 39import java.security.cert.CertificateNotYetValidException; 40import java.security.cert.X509Certificate; 41import java.util.Date; 42import java.util.Set; 43import java.math.BigInteger; 44 45import javax.crypto.KeyGenerator; 46import javax.crypto.SecretKey; 47 48import org.apache.harmony.security.tests.support.KeyStoreTestSupport; 49import org.apache.harmony.security.tests.support.MyLoadStoreParams; 50import org.apache.harmony.security.tests.support.SpiEngUtils; 51 52import junit.framework.TestCase; 53 54/** 55 * Tests for <code>KeyStore</code> constructor and methods 56 * 57 */ 58 59public class KeyStoreTest extends TestCase { 60 61 private static final String KeyStoreProviderClass = "org.apache.harmony.security.tests.support.MyKeyStore"; 62 63 private static final String defaultType = "KeyStore"; 64 65 public static boolean KSSupported = false; 66 67 public static String defaultProviderName = null; 68 69 public static Provider defaultProvider = null; 70 71 private static String NotSupportMsg = "Default KeyStore type is not supported"; 72 73 Provider mProv; 74 75 public KeyStore[] createKS() throws Exception { 76 assertTrue(NotSupportMsg, KSSupported); 77 KeyStore[] kpg = new KeyStore[3]; 78 79 kpg[0] = KeyStore.getInstance(defaultType); 80 kpg[1] = KeyStore.getInstance(defaultType, defaultProvider); 81 kpg[2] = KeyStore.getInstance(defaultType, defaultProviderName); 82 return kpg; 83 } 84 85 protected void setUp() throws Exception { 86 super.setUp(); 87 mProv = (new SpiEngUtils()).new MyProvider("MyKSProvider", 88 "Testing provider", KeyStoreTestSupport.srvKeyStore.concat(".") 89 .concat(defaultType), KeyStoreProviderClass); 90 Security.insertProviderAt(mProv, 2); 91 defaultProvider = SpiEngUtils.isSupport(defaultType, 92 KeyStoreTestSupport.srvKeyStore); 93 KSSupported = (defaultProvider != null); 94 defaultProviderName = (KSSupported ? defaultProvider.getName() : null); 95 } 96 97 /* 98 * @see TestCase#tearDown() 99 */ 100 protected void tearDown() throws Exception { 101 super.tearDown(); 102 Security.removeProvider(mProv.getName()); 103 } 104 105 /** 106 * Test for <code>load(LoadStoreParameter param)</code> 107 * <code>store(LoadStoreParameter param)</code> 108 * methods 109 * Assertions: throw IllegalArgumentException if param is null; 110 */ 111 public void testLoadStore02() throws Exception { 112 assertTrue(NotSupportMsg, KSSupported); 113 114 KeyStore[] kss = createKS(); 115 assertNotNull("KeyStore objects were not created", kss); 116 117 for (int i = 0; i < kss.length; i++) { 118 try { 119 kss[i].load(null); 120 fail("IOException or IllegalArgumentException should be thrown for null parameter"); 121 } catch (IOException e) { 122 } catch (IllegalArgumentException e) { 123 } 124 kss[i].load(null, null); 125 try { 126 kss[i].store(null); 127 fail("IOException or IllegalArgumentException should be thrown for null parameter"); 128 } catch (IOException e) { 129 } catch (IllegalArgumentException e) { 130 } 131 } 132 KeyStore.LoadStoreParameter lParam = new MyLoadStoreParams( 133 new KeyStore.PasswordProtection(new char[0])); 134 for (int i = 0; i < kss.length; i++) { 135 kss[i].load(lParam); 136 assertEquals("Incorrect result", kss[i].size(), 0); 137 kss[i].store(lParam); 138 } 139 } 140 141 142 /** 143 * Test for <code>setKeyEntry(String alias, byte[] key, Certificate[] chain)</code> 144 * method 145 * Assertion: stores KeyEntry. 146 */ 147 public void testSetKeyEntry() throws Exception { 148 assertTrue(NotSupportMsg, KSSupported); 149 150 KeyStore[] kss = createKS(); 151 assertNotNull("KeyStore objects were not created", kss); 152 byte[] kk = { (byte) 1, (byte) 2, (byte) 127, (byte) 77 }; 153 String alias = "keyEntry"; 154 char[] pwd = new char[0]; 155 byte[] res; 156 Certificate certs[] = { 157 new KeyStoreTestSupport.MCertificate(alias, kk), 158 new KeyStoreTestSupport.MCertificate(alias, kk) }; 159 for (int i = 0; i < kss.length; i++) { 160 kss[i].load(null, null); 161 try { 162 kss[i].setKeyEntry("proba", null, null); 163 fail("KeyStoreException must be thrown"); 164 } catch (KeyStoreException e) { 165 } 166 kss[i].setKeyEntry(alias, kk, certs); 167 res = kss[i].getKey(alias, pwd).getEncoded(); 168 assertEquals(kk.length, res.length); 169 for (int j = 0; j < res.length; j++) { 170 assertEquals(res[j], kk[j]); 171 } 172 assertEquals(kss[i].getCertificateChain(alias).length, certs.length); 173 kss[i].setKeyEntry(alias, kk, null); 174 res = kss[i].getKey(alias, pwd).getEncoded(); 175 assertEquals(kk.length, res.length); 176 for (int j = 0; j < res.length; j++) { 177 assertEquals(res[j], kk[j]); 178 } 179 assertNull(kss[i].getCertificateChain(alias)); 180 } 181 } 182 183 /** 184 * Test for <code>getDefaultType()</code> method Assertion: returns 185 * default security key store type or "jks" string 186 */ 187 public void testKeyStore01() { 188 String propName = "keystore.type"; 189 String defKSType = Security.getProperty(propName); 190 String dType = KeyStore.getDefaultType(); 191 String resType = defKSType; 192 if (resType == null) { 193 resType = defaultType; 194 } 195 assertNotNull("Default type have not be null", dType); 196 assertEquals("Incorrect default type", dType, resType); 197 198 if (defKSType == null) { 199 Security.setProperty(propName, defaultType); 200 dType = KeyStore.getDefaultType(); 201 resType = Security.getProperty(propName); 202 assertNotNull("Incorrect default type", resType); 203 assertNotNull("Default type have not be null", dType); 204 assertEquals("Incorrect default type", dType, resType); 205 } 206 } 207 208 /** 209 * Test for <code>getInstance(String type)</code> method 210 * Assertion: 211 * throws NullPointerException when type is null 212 * throws KeyStoreException when type is not available 213 * 214 */ 215 public void testKeyStore02() throws KeyStoreException { 216 String[] invalidValues = SpiEngUtils.invalidValues; 217 try { 218 KeyStore.getInstance(null); 219 fail("NullPointerException must be thrown when type is null"); 220 } catch (NullPointerException e) { 221 } 222 for (int i = 0; i < invalidValues.length; i++) { 223 try { 224 KeyStore.getInstance(invalidValues[i]); 225 fail("KeyStoreException must be thrown (type: ".concat( 226 invalidValues[i]).concat(" )")); 227 } catch (KeyStoreException e) { 228 } 229 } 230 } 231 232 /** 233 * @test java.security.KeyStore.PasswordProtection.getPassword() 234 */ 235 public void testKeyStorePPGetPassword() { 236 // Regression for HARMONY-1539 237 // no exception expected 238 assertNull(new KeyStore.PasswordProtection(null).getPassword()); 239 char[] password = new char[] {'a', 'b', 'c'}; 240 KeyStore.PasswordProtection pp = new KeyStore.PasswordProtection(password); 241 assertNotSame(pp.getPassword(), password); 242 assertSame(pp.getPassword(), pp.getPassword()); 243 244 } 245 246 247 /* 248 * @tests java.security.KeyStoreSpi.engineEntryInstanceOf(String, Class<? extends Entry>) 249 */ 250 public void testEngineEntryInstanceOf() throws Exception { 251 //Regression for HARMONY-615 252 253 // create a KeyStore 254 KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType()); 255 keyStore.load(null, "pwd".toCharArray()); 256 257 // generate a key 258 KeyGenerator keyGen = KeyGenerator.getInstance("DES"); 259 keyGen.init(56); 260 SecretKey secretKey = keyGen.generateKey(); 261 262 // put the key into keystore 263 String alias = "alias"; 264 keyStore.setKeyEntry(alias, secretKey, "pwd".toCharArray(), null); 265 266 // check if it is a secret key 267 assertTrue(keyStore.entryInstanceOf(alias, 268 KeyStore.SecretKeyEntry.class)); 269 270 // check if it is NOT a private key 271 assertFalse(keyStore.entryInstanceOf(alias, 272 KeyStore.PrivateKeyEntry.class)); 273 } 274 275 /** 276 * @tests java.security.KeyStore.TrustedCertificateEntry.toString() 277 */ 278 public void testKeyStoreTCToString() { 279 // Regression for HARMONY-1542 280 // no exception expected 281 class TestX509Certificate extends X509Certificate { 282 private static final long serialVersionUID = 1L; 283 public void checkValidity() throws CertificateExpiredException,CertificateNotYetValidException {} 284 public void checkValidity(Date p) throws CertificateExpiredException, CertificateNotYetValidException {} 285 public int getVersion() { 286 return 0; 287 } 288 public BigInteger getSerialNumber() { 289 return null; 290 } 291 public Principal getIssuerDN() { 292 return null; 293 } 294 public Principal getSubjectDN() { 295 return null; 296 } 297 public Date getNotBefore() { 298 return null; 299 } 300 public Date getNotAfter() { 301 return null; 302 } 303 public byte[] getTBSCertificate() throws CertificateEncodingException { 304 return null; 305 } 306 public byte[] getSignature() { 307 return null; 308 } 309 public String getSigAlgName() { 310 return null; 311 } 312 public String getSigAlgOID() { 313 return null; 314 } 315 public byte[] getSigAlgParams() { 316 return null; 317 } 318 public boolean[] getIssuerUniqueID() { 319 return null; 320 } 321 public boolean[] getSubjectUniqueID() { 322 return null; 323 } 324 public boolean[] getKeyUsage() { 325 return null; 326 } 327 public int getBasicConstraints() { 328 return 0; 329 } 330 public byte[] getEncoded() throws CertificateEncodingException { 331 return null; 332 } 333 public void verify(PublicKey p) 334 throws CertificateException, 335 NoSuchAlgorithmException, 336 InvalidKeyException, 337 NoSuchProviderException, 338 SignatureException 339 {} 340 public void verify(PublicKey p0, String p1) 341 throws CertificateException, 342 NoSuchAlgorithmException, 343 InvalidKeyException, 344 NoSuchProviderException, 345 SignatureException 346 {} 347 public String toString() { 348 return null; 349 } 350 public PublicKey getPublicKey() { 351 return null; 352 } 353 public boolean hasUnsupportedCriticalExtension() { 354 return false; 355 } 356 public Set getCriticalExtensionOIDs() { 357 return null; 358 } 359 public Set getNonCriticalExtensionOIDs() { 360 return null; 361 } 362 public byte[] getExtensionValue(String p) { 363 return null; 364 } 365 } 366 assertNotNull(new KeyStore.TrustedCertificateEntry(new TestX509Certificate()).toString()); 367 } 368} 369