1 /*
2  * Copyright (c) 2003, 2019, Oracle and/or its affiliates. All rights reserved.
3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4  *
5  * This code is free software; you can redistribute it and/or modify it
6  * under the terms of the GNU General Public License version 2 only, as
7  * published by the Free Software Foundation.
8  *
9  * This code is distributed in the hope that it will be useful, but WITHOUT
10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12  * version 2 for more details (a copy is included in the LICENSE file that
13  * accompanied this code).
14  *
15  * You should have received a copy of the GNU General Public License version
16  * 2 along with this work; if not, write to the Free Software Foundation,
17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18  *
19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20  * or visit www.oracle.com if you need additional information or have any
21  * questions.
22  */
23 
24 import java.io.*;
25 import java.util.*;
26 
27 import java.security.KeyStore;
28 import java.security.KeyStoreException;
29 import java.security.KeyFactory;
30 import java.security.KeyPairGenerator;
31 import java.security.KeyPair;
32 import java.security.SecureRandom;
33 import java.security.AuthProvider;
34 import java.security.PrivateKey;
35 import java.security.Provider;
36 import java.security.ProviderException;
37 import java.security.Signature;
38 import java.security.Security;
39 
40 import java.security.cert.*;
41 import java.security.spec.*;
42 import java.security.interfaces.*;
43 
44 import javax.crypto.SecretKey;
45 
46 import javax.security.auth.Subject;
47 import javax.security.auth.login.LoginException;
48 
49 import com.sun.security.auth.module.*;
50 import com.sun.security.auth.callback.*;
51 
52 
53 public class Basic extends PKCS11Test {
54 
55     private static final char SEP = File.separatorChar;
56 
57     private static String DIR = System.getProperty("DIR");
58     private static char[] tokenPwd;
59     private static final char[] ibuttonPwd =
60                         new char[0];
61     private static final char[] activcardPwd =
62                         new char[] { '1', '1', '2', '2', '3', '3' };
63     private static final char[] nssPwd =
64                         new char[] { 't', 'e', 's', 't', '1', '2' };
65     private static final char[] solarisPwd =
66                         new char[] { 'p', 'i', 'n' };
67     private static final char[] sca1000Pwd =
68                         new char[] { 'p', 'a', 's', 's', 'w', 'o', 'r', 'd' };
69     private static final char[] sPwd = { 'f', 'o', 'o' };
70 
71     private static SecretKey sk1;
72     private static SecretKey sk2;
73     private static SecretKey sk3;
74     private static SecretKey sk4;
75 
76     private static RSAPrivateCrtKey pk1;
77     private static PrivateKey pk2;
78     private static PrivateKey pk3;
79 
80     private static Certificate[] chain1;
81     private static Certificate[] chain2;
82     private static Certificate[] chain3;
83     private static Certificate[] chain4;
84 
85     private static X509Certificate randomCert;
86 
87     private static KeyStore ks;
88     private static final String KS_TYPE = "PKCS11";
89     private static Provider provider;
90 
91     private static class FooEntry implements KeyStore.Entry { }
92 
93     private static class P11SecretKey implements SecretKey {
94         String alg;
95         int length;
P11SecretKey(String alg, int length)96         public P11SecretKey(String alg, int length) {
97             this.alg = alg;
98             this.length = length;
99         }
getAlgorithm()100         public String getAlgorithm() { return alg; }
getFormat()101         public String getFormat() { return "raw"; }
getEncoded()102         public byte[] getEncoded() { return new byte[length/8]; }
103     }
104 
main(String[] args)105     public static void main(String[] args) throws Exception {
106         main(new Basic(), args);
107     }
108 
main(Provider p)109     public void main(Provider p) throws Exception {
110 
111         this.provider = p;
112 
113         // get private keys
114         KeyFactory kf = KeyFactory.getInstance("RSA");
115         KeyFactory dsaKf = KeyFactory.getInstance("DSA", "SUN");
116 
117         ObjectInputStream ois1 = new ObjectInputStream
118                         (new FileInputStream(new File(DIR, "pk1.key")));
119         byte[] keyBytes = (byte[])ois1.readObject();
120         ois1.close();
121         PrivateKey tmpKey =
122                 kf.generatePrivate(new PKCS8EncodedKeySpec(keyBytes));
123         pk1 = (RSAPrivateCrtKey)tmpKey;
124 
125         ObjectInputStream ois2 = new ObjectInputStream
126                         (new FileInputStream(new File(DIR, "pk2.key")));
127         keyBytes = (byte[])ois2.readObject();
128         ois2.close();
129         pk2 = kf.generatePrivate(new PKCS8EncodedKeySpec(keyBytes));
130 
131         ObjectInputStream ois3 = new ObjectInputStream
132                         (new FileInputStream(new File(DIR, "pk3.key")));
133         keyBytes = (byte[])ois3.readObject();
134         pk3 = kf.generatePrivate(new PKCS8EncodedKeySpec(keyBytes));
135         ois3.close();
136 
137         // get cert chains for private keys
138         CertificateFactory cf = CertificateFactory.getInstance("X.509", "SUN");
139         Certificate caCert = (X509Certificate)cf.generateCertificate
140                         (new FileInputStream(new File(DIR, "ca.cert")));
141         Certificate ca2Cert = (X509Certificate)cf.generateCertificate
142                         (new FileInputStream(new File(DIR, "ca2.cert")));
143         Certificate pk1cert = (X509Certificate)cf.generateCertificate
144                         (new FileInputStream(new File(DIR, "pk1.cert")));
145         Certificate pk1cert2 = (X509Certificate)cf.generateCertificate
146                         (new FileInputStream(new File(DIR, "pk1.cert2")));
147         Certificate pk2cert = (X509Certificate)cf.generateCertificate
148                         (new FileInputStream(new File(DIR, "pk2.cert")));
149         Certificate pk3cert = (X509Certificate)cf.generateCertificate
150                         (new FileInputStream(new File(DIR, "pk3.cert")));
151         chain1 = new Certificate[] { pk1cert, caCert };
152         chain2 = new Certificate[] { pk2cert, caCert };
153         chain3 = new Certificate[] { pk3cert, caCert };
154         chain4 = new Certificate[] { pk1cert2, ca2Cert };
155 
156         // create secret keys
157         sk1 = new P11SecretKey("DES", 64);
158         sk2 = new P11SecretKey("DESede", 192);
159         sk3 = new P11SecretKey("AES", 128);
160         sk4 = new P11SecretKey("RC4", 128);
161 
162         // read randomCert
163         randomCert = (X509Certificate)cf.generateCertificate
164                         (new FileInputStream(new File(DIR, "random.cert")));
165 
166         doTest();
167     }
168 
doTest()169     private static void doTest() throws Exception {
170 
171         String token = System.getProperty("TOKEN");
172         String test = System.getProperty("TEST");
173 
174         if (token == null || token.length() == 0) {
175             throw new Exception("token arg required");
176         }
177         if (test == null || test.length() == 0) {
178             throw new Exception("test arg required");
179         }
180 
181         if ("ibutton".equals(token)) {
182             tokenPwd = ibuttonPwd;
183         } else if ("activcard".equals(token)) {
184             tokenPwd = activcardPwd;
185         } else if ("nss".equals(token)) {
186             tokenPwd = nssPwd;
187         } else if ("sca1000".equals(token)) {
188             tokenPwd = sca1000Pwd;
189         } else if ("solaris".equals(token)) {
190             tokenPwd = solarisPwd;
191         }
192 
193         if ("list".equals(test)) {
194             Basic.list();
195         } else if ("basic".equals(test)) {
196 
197             int testnum = 1;
198 
199             if ("ibutton".equals(token)) {
200                 // pkey and setAttribute
201                 testnum = Basic.pkey(testnum);
202                 testnum = Basic.setAttribute(testnum);
203             } else if ("activcard".equals(token)) {
204                 // sign
205                 testnum = Basic.signAlias(testnum, null);
206             } else if ("nss".equals(token)) {
207                 // setAttribute, pkey, sign
208                 testnum = Basic.setAttribute(testnum);
209                 testnum = Basic.pkey(testnum);
210                 testnum = Basic.sign(testnum);
211                 testnum = Basic.copy(testnum);
212             } else if ("solaris".equals(token)) {
213                 testnum = Basic.setAttribute(testnum);
214                 testnum = Basic.pkey(testnum);
215                 testnum = Basic.sign(testnum);
216                 testnum = Basic.skey(testnum);
217                 testnum = Basic.copy(testnum);
218             } else if ("sca1000".equals(token)) {
219                 // setAttribute, pkey, sign, skey, copy
220                 testnum = Basic.setAttribute(testnum);
221                 testnum = Basic.pkey(testnum);
222                 testnum = Basic.sign(testnum);
223                 testnum = Basic.skey(testnum);
224                 testnum = Basic.copy(testnum);
225             }
226 
227         } else if ("pkey".equals(test)) {
228             Basic.pkey(1);
229         } else if ("skey".equals(test)) {
230             Basic.skey(1);
231         } else if ("setAttribute".equals(test)) {
232             Basic.setAttribute(1);
233         } else if ("copy".equals(test)) {
234             Basic.copy(1);
235         } else if ("sign".equals(test)) {
236             Basic.sign(1);
237         } else if ("module".equals(test)) {
238             Basic.module();
239         } else if ("nss-extended".equals(test)) {
240 
241             // this only works if NSS_TEST is set to true in P11KeyStore.java
242 
243             int testnum = 1;
244             testnum = Basic.setAttribute(testnum);
245             testnum = Basic.pkey(testnum);
246             testnum = Basic.sign(testnum);
247             testnum = Basic.extended(testnum);
248         } else {
249             System.out.println("unrecognized command");
250         }
251     }
252 
sign(int testnum)253     private static int sign(int testnum) throws Exception {
254         if (ks == null) {
255             ks = KeyStore.getInstance(KS_TYPE, provider);
256             ks.load(null, tokenPwd);
257         }
258         if (!ks.containsAlias("pk1")) {
259             ks.setKeyEntry("pk1", pk1, null, chain1);
260         }
261         System.out.println("test " + testnum++ + " passed");
262 
263         return signAlias(testnum, "pk1");
264     }
265 
signAlias(int testnum, String alias)266     private static int signAlias(int testnum, String alias) throws Exception {
267 
268         if (ks == null) {
269             ks = KeyStore.getInstance(KS_TYPE, provider);
270             ks.load(null, tokenPwd);
271         }
272 
273         if (alias == null) {
274             Enumeration enu = ks.aliases();
275             if (enu.hasMoreElements()) {
276                 alias = (String)enu.nextElement();
277             }
278         }
279 
280         PrivateKey pkey = (PrivateKey)ks.getKey(alias, null);
281         if ("RSA".equals(pkey.getAlgorithm())) {
282             System.out.println("got [" + alias + "] signing key: " + pkey);
283         } else {
284             throw new SecurityException
285                 ("expected RSA, got " + pkey.getAlgorithm());
286         }
287 
288         Signature s = Signature.getInstance("MD5WithRSA", ks.getProvider());
289         s.initSign(pkey);
290         System.out.println("initialized signature object with key");
291         s.update("hello".getBytes());
292         System.out.println("signature object updated with [hello] bytes");
293 
294         byte[] signed = s.sign();
295         System.out.println("received signature " + signed.length +
296                         " bytes in length");
297 
298         Signature v = Signature.getInstance("MD5WithRSA", ks.getProvider());
299         v.initVerify(ks.getCertificate(alias));
300         v.update("hello".getBytes());
301         v.verify(signed);
302         System.out.println("signature verified");
303         System.out.println("test " + testnum++ + " passed");
304 
305         return testnum;
306     }
307 
copy(int testnum)308     private static int copy(int testnum) throws Exception {
309 
310         if (ks == null) {
311             ks = KeyStore.getInstance(KS_TYPE, provider);
312             ks.load(null, tokenPwd);
313         }
314 
315         KeyFactory kf = KeyFactory.getInstance("RSA", provider);
316         PrivateKey pkSession = (PrivateKey)kf.translateKey(pk3);
317         System.out.println("pkSession = " + pkSession);
318         ks.setKeyEntry("pkSession", pkSession, null, chain3);
319 
320         KeyStore.PrivateKeyEntry pke =
321                 (KeyStore.PrivateKeyEntry)ks.getEntry("pkSession", null);
322         System.out.println("pkSession = " + pke.getPrivateKey());
323         Certificate[] chain = pke.getCertificateChain();
324         if (chain.length != chain3.length) {
325             throw new SecurityException("received chain not correct length");
326         }
327         for (int i = 0; i < chain.length; i++) {
328             if (!chain[i].equals(chain3[i])) {
329                 throw new SecurityException("received chain not equal");
330             }
331         }
332 
333         System.out.println("test " + testnum++ + " passed");
334 
335         return testnum;
336     }
337 
list()338     private static void list() throws Exception {
339         int testnum = 1;
340 
341         ks = KeyStore.getInstance(KS_TYPE, provider);
342 
343         // check instance
344         if (ks.getProvider() instanceof java.security.AuthProvider) {
345             System.out.println("keystore provider instance of AuthProvider");
346             System.out.println("test " + testnum++ + " passed");
347         } else {
348             throw new SecurityException("did not get AuthProvider KeyStore");
349         }
350 
351         // load
352         ks.load(null, tokenPwd);
353         System.out.println("test " + testnum++ + " passed");
354 
355         // aliases
356         Enumeration enu = ks.aliases();
357         int count = 0;
358         while (enu.hasMoreElements()) {
359             count++;
360             System.out.println("alias " +
361                                 count +
362                                 " = " +
363                                 (String)enu.nextElement());
364         }
365     }
366 
module()367     private static void module() throws Exception {
368 
369         // perform Security.addProvider of P11 provider
370         Security.addProvider(getSunPKCS11(System.getProperty("CUSTOM_P11_CONFIG")));
371 
372         String KS_PROVIDER = "SunPKCS11-" + System.getProperty("TOKEN");
373 
374         KeyStoreLoginModule m = new KeyStoreLoginModule();
375         Subject s = new Subject();
376         Map options = new HashMap();
377         options.put("keyStoreURL", "NONE");
378         options.put("keyStoreType", KS_TYPE);
379         options.put("keyStoreProvider", KS_PROVIDER);
380         options.put("debug", "true");
381         m.initialize(s, new TextCallbackHandler(), new HashMap(), options);
382         m.login();
383         m.commit();
384         System.out.println("authenticated subject = " + s);
385         m.logout();
386         System.out.println("authenticated subject = " + s);
387     }
388 
389     /**
390      * SCA1000 does not handle extended secret key tests
391      * . Blowfish (CKR_TEMPLATE_INCOMPLETE)
392      * . AES (CKR_TEMPLATE_INCOMPLETE)
393      * . RC4 (CKR_ATTRIBUTE_TYPE_INVALID)
394      * so do this instead
395      */
skey(int testnum)396     private static int skey(int testnum) throws Exception {
397         if (ks == null) {
398             ks = KeyStore.getInstance(KS_TYPE, provider);
399             ks.load(null, tokenPwd);
400         }
401 
402         // delete all old aliases
403         Enumeration enu = ks.aliases();
404         int count = 0;
405         while (enu.hasMoreElements()) {
406             String next = (String)enu.nextElement();
407             ks.deleteEntry(next);
408             System.out.println("deleted entry for: " + next);
409         }
410 
411         // set good ske 1
412         ks.setKeyEntry("sk1", sk1, null, null);
413         System.out.println("test " + testnum++ + " passed");
414 
415         // set good ske 2
416         ks.setKeyEntry("sk2", sk2, null, null);
417         System.out.println("test " + testnum++ + " passed");
418 
419         // getEntry good ske 1
420         KeyStore.SecretKeyEntry ske =
421                 (KeyStore.SecretKeyEntry)ks.getEntry("sk1", null);
422         if ("DES".equals(ske.getSecretKey().getAlgorithm())) {
423             System.out.println("test " + testnum++ + " passed");
424         } else {
425             throw new SecurityException
426                 ("expected DES, got " + ske.getSecretKey().getAlgorithm());
427         }
428 
429         // getEntry good ske 2
430         ske = (KeyStore.SecretKeyEntry)ks.getEntry("sk2", null);
431         if ("DESede".equals(ske.getSecretKey().getAlgorithm())) {
432             System.out.println("test " + testnum++ + " passed");
433         } else {
434             throw new SecurityException
435                 ("expected DESede, got " + ske.getSecretKey().getAlgorithm());
436         }
437 
438         // getKey good ske 1
439         SecretKey skey = (SecretKey)ks.getKey("sk1", null);
440         if ("DES".equals(skey.getAlgorithm())) {
441             System.out.println("test " + testnum++ + " passed");
442         } else {
443             throw new SecurityException
444                 ("expected DES, got " + skey.getAlgorithm());
445         }
446 
447         // getKey good ske 2
448         skey = (SecretKey)ks.getKey("sk2", null);
449         if ("DESede".equals(skey.getAlgorithm())) {
450             System.out.println("test " + testnum++ + " passed");
451         } else {
452             throw new SecurityException
453                 ("expected DESede, got " + skey.getAlgorithm());
454         }
455 
456         // aliases
457         enu = ks.aliases();
458         count = 0;
459         while (enu.hasMoreElements()) {
460             count++;
461             System.out.println("alias " +
462                                 count +
463                                 " = " +
464                                 (String)enu.nextElement());
465         }
466         if (count == 2) {
467             System.out.println("test " + testnum++ + " passed");
468         } else {
469             throw new SecurityException("expected 2 aliases");
470         }
471 
472         // size
473         if (ks.size() == 2) {
474             System.out.println("test " + testnum++ + " passed");
475         } else {
476             throw new SecurityException("expected size 2");
477         }
478 
479         // isCertificateEntry sk1
480         if (!ks.isCertificateEntry("sk1")) {
481             System.out.println("test " + testnum++ + " passed");
482         } else {
483             throw new SecurityException("expected ske");
484         }
485 
486         // isKeyEntry sk1
487         if (ks.isKeyEntry("sk1")) {
488             System.out.println("test " + testnum++ + " passed");
489         } else {
490             throw new SecurityException("expected ske");
491         }
492 
493         // entryInstanceOf sk2
494         if (ks.entryInstanceOf("sk2", KeyStore.SecretKeyEntry.class)) {
495             System.out.println("test " + testnum++ + " passed");
496         } else {
497             throw new SecurityException("expected ske");
498         }
499 
500         return testnum;
501     }
502 
setAttribute(int testnum)503     private static int setAttribute(int testnum) throws Exception {
504 
505         if (ks == null) {
506             ks = KeyStore.getInstance(KS_TYPE, provider);
507             ks.load(null, tokenPwd);
508         }
509 
510         if (!ks.containsAlias("pk1")) {
511             // set good pke 1
512             ks.setKeyEntry("pk1", pk1, null, chain1);
513             System.out.println("test " + testnum++ + " passed");
514         }
515 
516         // delete all old aliases except pk1
517         Enumeration enu = ks.aliases();
518         int count = 0;
519         while (enu.hasMoreElements()) {
520             String next = (String)enu.nextElement();
521             if (!"pk1".equals(next)) {
522                 ks.deleteEntry(next);
523                 System.out.println("deleted entry for: " + next);
524             }
525         }
526 
527         KeyStore.PrivateKeyEntry pke =
528                 (KeyStore.PrivateKeyEntry)ks.getEntry("pk1", null);
529         System.out.println("pk1 = " + pke.getPrivateKey());
530         Certificate[] chain = pke.getCertificateChain();
531         if (chain.length != chain1.length) {
532             throw new SecurityException("received chain not correct length");
533         }
534         for (int i = 0; i < chain.length; i++) {
535             if (!chain[i].equals(chain1[i])) {
536                 throw new SecurityException("received chain not equal");
537             }
538         }
539         System.out.println("test " + testnum++ + " passed");
540 
541         /**
542          * test change alias only
543          */
544 
545         // test C_SetAttribute
546         PrivateKey pkey = pke.getPrivateKey();
547         ks.setEntry("pk1SA",
548                 new KeyStore.PrivateKeyEntry(pkey, chain1),
549                 null);
550         System.out.println("test " + testnum++ + " passed");
551 
552         // aliases
553         enu = ks.aliases();
554         count = 0;
555         String newAlias = null;
556         while (enu.hasMoreElements()) {
557             count++;
558             newAlias = (String)enu.nextElement();
559             System.out.println("alias " +
560                                 count +
561                                 " = " +
562                                 newAlias);
563         }
564         if (count == 1 && "pk1SA".equals(newAlias)) {
565             System.out.println("test " + testnum++ + " passed");
566         } else {
567             throw new SecurityException("expected 1 alias");
568         }
569 
570         // size
571         if (ks.size() == 1) {
572             System.out.println("test " + testnum++ + " passed");
573         } else {
574             throw new SecurityException("expected size 1");
575         }
576 
577         pke = (KeyStore.PrivateKeyEntry)ks.getEntry("pk1", null);
578         if (pke != null) {
579             throw new SecurityException("expected not to find pk1");
580         }
581         System.out.println("test " + testnum++ + " passed");
582 
583         pke = (KeyStore.PrivateKeyEntry)ks.getEntry("pk1SA", null);
584         System.out.println("pk1SA = " + pke.getPrivateKey());
585         chain = pke.getCertificateChain();
586         if (chain.length != chain1.length) {
587             throw new SecurityException("received chain not correct length");
588         }
589         for (int i = 0; i < chain.length; i++) {
590             if (!chain[i].equals(chain1[i])) {
591                 throw new SecurityException("received chain not equal");
592             }
593         }
594         System.out.println("test " + testnum++ + " passed");
595 
596         /**
597          * test change cert chain
598          */
599 
600         pkey = pke.getPrivateKey();
601         ks.setEntry("pk1SA-2",
602                 new KeyStore.PrivateKeyEntry(pkey, chain4),
603                 null);
604         System.out.println("test " + testnum++ + " passed");
605 
606         // aliases
607         enu = ks.aliases();
608         count = 0;
609         newAlias = null;
610         while (enu.hasMoreElements()) {
611             count++;
612             newAlias = (String)enu.nextElement();
613             System.out.println("alias " +
614                                 count +
615                                 " = " +
616                                 newAlias);
617         }
618         if (count == 1 && "pk1SA-2".equals(newAlias)) {
619             System.out.println("test " + testnum++ + " passed");
620         } else {
621             throw new SecurityException("expected 1 alias");
622         }
623 
624         // size
625         if (ks.size() == 1) {
626             System.out.println("test " + testnum++ + " passed");
627         } else {
628             throw new SecurityException("expected size 1");
629         }
630 
631         pke = (KeyStore.PrivateKeyEntry)ks.getEntry("pk1SA", null);
632         if (pke != null) {
633             throw new SecurityException("expected not to find pk1SA");
634         }
635         System.out.println("test " + testnum++ + " passed");
636 
637         pke = (KeyStore.PrivateKeyEntry)ks.getEntry("pk1SA-2", null);
638         System.out.println("pk1SA-2 = " + pke.getPrivateKey());
639         chain = pke.getCertificateChain();
640         if (chain.length != chain4.length) {
641             throw new SecurityException("received chain not correct length");
642         }
643         for (int i = 0; i < chain.length; i++) {
644             if (!chain[i].equals(chain4[i])) {
645                 throw new SecurityException("received chain not equal");
646             }
647         }
648         System.out.println("test " + testnum++ + " passed");
649 
650         return testnum;
651     }
652 
pkey(int testnum)653     private static int pkey(int testnum) throws Exception {
654 
655         if (ks == null) {
656             ks = KeyStore.getInstance(KS_TYPE, provider);
657             ks.load(null, tokenPwd);
658             System.out.println("test " + testnum++ + " passed");
659         }
660 
661         // check instance
662         if (ks.getProvider() instanceof java.security.AuthProvider) {
663             System.out.println("keystore provider instance of AuthProvider");
664             System.out.println("test " + testnum++ + " passed");
665         } else {
666             throw new SecurityException("did not get AuthProvider KeyStore");
667         }
668 
669         // delete all old aliases
670         Enumeration enu = ks.aliases();
671         int count = 0;
672         while (enu.hasMoreElements()) {
673             String next = (String)enu.nextElement();
674             ks.deleteEntry(next);
675             System.out.println("deleted entry for: " + next);
676         }
677 
678         // set good pke 1
679         ks.setKeyEntry("pk1", pk1, null, chain1);
680         System.out.println("test " + testnum++ + " passed");
681 
682         // set good pke 2
683         ks.setEntry("pk2",
684                 new KeyStore.PrivateKeyEntry(pk2, chain2),
685                 null);
686         System.out.println("test " + testnum++ + " passed");
687 
688         // getEntry good pke 1
689         KeyStore.PrivateKeyEntry pke =
690                 (KeyStore.PrivateKeyEntry)ks.getEntry("pk1", null);
691         System.out.println("pk1 = " + pke.getPrivateKey());
692         Certificate[] chain = pke.getCertificateChain();
693         if (chain.length != chain1.length) {
694             throw new SecurityException("received chain not correct length");
695         }
696         for (int i = 0; i < chain.length; i++) {
697             if (!chain[i].equals(chain1[i])) {
698                 throw new SecurityException("received chain not equal");
699             }
700         }
701 
702         // getKey good pke 1
703         PrivateKey pkey = (PrivateKey)ks.getKey("pk1", null);
704         System.out.println("pk1 = " + pkey);
705         if ("RSA".equals(pkey.getAlgorithm())) {
706             System.out.println("test " + testnum++ + " passed");
707         } else {
708             throw new SecurityException
709                 ("expected RSA, got " + pkey.getAlgorithm());
710         }
711 
712         // getCertificate chain chain 1
713         chain = ks.getCertificateChain("pk1");
714         if (chain.length != chain1.length) {
715             throw new SecurityException("received chain not correct length");
716         }
717         for (int i = 0; i < chain.length; i++) {
718             if (!chain[i].equals(chain1[i])) {
719                 throw new SecurityException("received chain not equal");
720             }
721         }
722         System.out.println("test " + testnum++ + " passed");
723 
724         // getEntry good pke 2
725         pke = (KeyStore.PrivateKeyEntry)ks.getEntry("pk2", null);
726         if ("RSA".equals(pke.getPrivateKey().getAlgorithm())) {
727             System.out.println("test " + testnum++ + " passed");
728         } else {
729             throw new SecurityException
730                 ("expected RSA, got " + pke.getPrivateKey().getAlgorithm());
731         }
732         System.out.println("pk2 = " + pke.getPrivateKey());
733         chain = pke.getCertificateChain();
734         if (chain.length != chain2.length) {
735             throw new SecurityException("received chain not correct length");
736         }
737         for (int i = 0; i < chain.length; i++) {
738             if (!chain[i].equals(chain2[i])) {
739                 throw new SecurityException("received chain not equal");
740             }
741         }
742 
743         // getKey good pke 2
744         pkey = (PrivateKey)ks.getKey("pk2", null);
745         if ("RSA".equals(pkey.getAlgorithm())) {
746             System.out.println("test " + testnum++ + " passed");
747         } else {
748             throw new SecurityException
749                 ("expected RSA, got " + pkey.getAlgorithm());
750         }
751 
752         // getCertificate chain chain 2
753         chain = ks.getCertificateChain("pk2");
754         if (chain.length != chain2.length) {
755             throw new SecurityException("received chain not correct length");
756         }
757         for (int i = 0; i < chain.length; i++) {
758             if (!chain[i].equals(chain2[i])) {
759                 throw new SecurityException("received chain not equal");
760             }
761         }
762         System.out.println("test " + testnum++ + " passed");
763 
764         // aliases
765         enu = ks.aliases();
766         count = 0;
767         while (enu.hasMoreElements()) {
768             count++;
769             System.out.println("alias " +
770                                 count +
771                                 " = " +
772                                 (String)enu.nextElement());
773         }
774         if (count == 2) {
775             System.out.println("test " + testnum++ + " passed");
776         } else {
777             throw new SecurityException("expected 2 aliases");
778         }
779 
780         // size
781         if (ks.size() == 2) {
782             System.out.println("test " + testnum++ + " passed");
783         } else {
784             throw new SecurityException("expected size 2");
785         }
786 
787         // getCertificate
788         if (ks.getCertificate("pk1").equals(chain1[0])) {
789             System.out.println("test " + testnum++ + " passed");
790         } else {
791             throw new SecurityException("expected certificate pk1 end entity");
792         }
793 
794         // containsAlias
795         if (ks.containsAlias("pk1") && ks.containsAlias("pk2") &&
796             !ks.containsAlias("foobar") &&
797             !ks.containsAlias("pk1.2") && !ks.containsAlias("pk2.2")) {
798             System.out.println("test " + testnum++ + " passed");
799         } else {
800             throw new SecurityException("unexpected aliases encountered");
801         }
802 
803         // isKeyEntry
804         if (ks.isKeyEntry("pk1") && ks.isKeyEntry("pk2") &&
805             !ks.isKeyEntry("foobar")) {
806             System.out.println("test " + testnum++ + " passed");
807         } else {
808             throw new SecurityException("isKeyEntry failed");
809         }
810 
811         // isCertificateEntry
812         if (!ks.isCertificateEntry("foobar") &&
813             !ks.isCertificateEntry("pk1") && !ks.isCertificateEntry("pk2")) {
814             System.out.println("test " + testnum++ + " passed");
815         } else {
816             throw new SecurityException("isCertificateEntry failed");
817         }
818 
819         // getCertificateAlias
820         if (ks.getCertificateAlias(chain1[0]).equals("pk1") &&
821             ks.getCertificateAlias(chain2[0]).equals("pk2") &&
822             ks.getCertificateAlias(randomCert) == null) {
823             System.out.println("test " + testnum++ + " passed");
824         } else {
825             throw new SecurityException("getCertificateAlias failed");
826         }
827 
828         if (ks.entryInstanceOf("pk1", KeyStore.PrivateKeyEntry.class) &&
829             ks.entryInstanceOf("pk2", KeyStore.PrivateKeyEntry.class) &&
830         !ks.entryInstanceOf("pk1", KeyStore.TrustedCertificateEntry.class) &&
831         !ks.entryInstanceOf("pk2", KeyStore.TrustedCertificateEntry.class) &&
832         !ks.entryInstanceOf("foobar", KeyStore.TrustedCertificateEntry.class) &&
833           !ks.entryInstanceOf("foobar", KeyStore.PrivateKeyEntry.class)) {
834             System.out.println("test " + testnum++ + " passed");
835         } else {
836             throw new SecurityException("entryInstanceOf failed");
837         }
838 
839         ks.deleteEntry("pk2");
840         if (ks.containsAlias("pk1") && !ks.containsAlias("pk2")) {
841             System.out.println("test " + testnum++ + " passed");
842         } else {
843             throw new SecurityException("deleteEntry failed");
844         }
845 
846         // getEntry good pke 1
847         pke = (KeyStore.PrivateKeyEntry)ks.getEntry("pk1", null);
848         System.out.println("pk1 = " + pke.getPrivateKey());
849         chain = pke.getCertificateChain();
850         if (chain.length != chain1.length) {
851             throw new SecurityException("received chain not correct length");
852         }
853         for (int i = 0; i < chain.length; i++) {
854             if (!chain[i].equals(chain1[i])) {
855                 throw new SecurityException("received chain not equal");
856             }
857         }
858         System.out.println("test " + testnum++ + " passed");
859 
860         // aliases
861         enu = ks.aliases();
862         count = 0;
863         while (enu.hasMoreElements()) {
864             count++;
865             System.out.println("alias " +
866                                 count +
867                                 " = " +
868                                 (String)enu.nextElement());
869         }
870         if (count == 1) {
871             System.out.println("test " + testnum++ + " passed");
872         } else {
873             throw new SecurityException("expected 1 alias");
874         }
875 
876         // size
877         if (ks.size() == 1) {
878             System.out.println("test " + testnum++ + " passed");
879         } else {
880             throw new SecurityException("expected size 1");
881         }
882 
883         return testnum;
884     }
885 
extended(int testnum)886     private static int extended(int testnum) throws Exception {
887 
888         // setEntry unknown entry type
889         try {
890             ks.setEntry("foo", new FooEntry(), null);
891             throw new SecurityException("setEntry should have failed");
892         } catch (KeyStoreException kse) {
893             System.out.println("test " + testnum++ + " passed");
894         }
895 
896         // getEntry random foo
897         if (ks.getEntry("foo", null) != null) {
898             throw new SecurityException("expected null entry");
899         } else {
900             System.out.println("test " + testnum++ + " passed");
901         }
902 
903         // set good ske 1
904         ks.setKeyEntry("sk1", sk1, null, null);
905         System.out.println("test " + testnum++ + " passed");
906 
907         // set good ske 2
908         ks.setKeyEntry("sk2", sk2, null, null);
909         System.out.println("test " + testnum++ + " passed");
910 
911         // set good ske 3
912         ks.setEntry("sk3",
913                 new KeyStore.SecretKeyEntry(sk3),
914                 null);
915         System.out.println("test " + testnum++ + " passed");
916 
917         // set good ske 4
918         ks.setEntry("sk4",
919                 new KeyStore.SecretKeyEntry(sk4),
920                 null);
921         System.out.println("test " + testnum++ + " passed");
922 
923         // getEntry good ske 1
924         KeyStore.SecretKeyEntry ske =
925                 (KeyStore.SecretKeyEntry)ks.getEntry("sk1", null);
926         if ("DES".equals(ske.getSecretKey().getAlgorithm())) {
927             System.out.println("test " + testnum++ + " passed");
928         } else {
929             throw new SecurityException
930                 ("expected DES, got " + ske.getSecretKey().getAlgorithm());
931         }
932 
933         // getEntry good ske 2
934         ske = (KeyStore.SecretKeyEntry)ks.getEntry("sk2", null);
935         if ("DESede".equals(ske.getSecretKey().getAlgorithm())) {
936             System.out.println("test " + testnum++ + " passed");
937         } else {
938             throw new SecurityException
939                 ("expected DESede, got " + ske.getSecretKey().getAlgorithm());
940         }
941 
942         // getEntry good ske 3
943         ske = (KeyStore.SecretKeyEntry)ks.getEntry("sk3", null);
944         if ("AES".equals(ske.getSecretKey().getAlgorithm())) {
945             System.out.println("test " + testnum++ + " passed");
946         } else {
947             throw new SecurityException
948                 ("expected AES, got " + ske.getSecretKey().getAlgorithm());
949         }
950 
951         // getEntry good ske 4
952         ske = (KeyStore.SecretKeyEntry)ks.getEntry("sk4", null);
953         if ("ARCFOUR".equals(ske.getSecretKey().getAlgorithm())) {
954             System.out.println("test " + testnum++ + " passed");
955         } else {
956             throw new SecurityException
957                 ("expected ARCFOUR, got " + ske.getSecretKey().getAlgorithm());
958         }
959 
960         // getKey good ske 1
961         SecretKey skey = (SecretKey)ks.getKey("sk1", null);
962         if ("DES".equals(skey.getAlgorithm())) {
963             System.out.println("test " + testnum++ + " passed");
964         } else {
965             throw new SecurityException
966                 ("expected DES, got " + skey.getAlgorithm());
967         }
968 
969         // getKey good ske 2
970         skey = (SecretKey)ks.getKey("sk2", null);
971         if ("DESede".equals(skey.getAlgorithm())) {
972             System.out.println("test " + testnum++ + " passed");
973         } else {
974             throw new SecurityException
975                 ("expected DESede, got " + skey.getAlgorithm());
976         }
977 
978         // getKey good ske 3
979         skey = (SecretKey)ks.getKey("sk3", null);
980         if ("AES".equals(skey.getAlgorithm())) {
981             System.out.println("test " + testnum++ + " passed");
982         } else {
983             throw new SecurityException
984                 ("expected AES, got " + skey.getAlgorithm());
985         }
986 
987         // getKey good ske 4
988         skey = (SecretKey)ks.getKey("sk4", null);
989         if ("ARCFOUR".equals(skey.getAlgorithm())) {
990             System.out.println("test " + testnum++ + " passed");
991         } else {
992             throw new SecurityException
993                 ("expected ARCFOUR, got " + skey.getAlgorithm());
994         }
995 
996         // aliases
997         Enumeration enu = ks.aliases();
998         int count = 0;
999         while (enu.hasMoreElements()) {
1000             count++;
1001             System.out.println("alias " +
1002                                 count +
1003                                 " = " +
1004                                 (String)enu.nextElement());
1005         }
1006         if (count == 5) {
1007             System.out.println("test " + testnum++ + " passed");
1008         } else {
1009             throw new SecurityException("expected 5 aliases");
1010         }
1011 
1012         // size
1013         if (ks.size() == 5) {
1014             System.out.println("test " + testnum++ + " passed");
1015         } else {
1016             throw new SecurityException("expected size 5");
1017         }
1018 
1019         // set good pke 2
1020         ks.setEntry("pk2",
1021                 new KeyStore.PrivateKeyEntry(pk2, chain2),
1022                 null);
1023         System.out.println("test " + testnum++ + " passed");
1024 
1025         // set good pke 3
1026         ks.setEntry("pk3",
1027                 new KeyStore.PrivateKeyEntry(pk3, chain3),
1028                 null);
1029         System.out.println("test " + testnum++ + " passed");
1030 
1031         // getEntry good pke 1
1032         KeyStore.PrivateKeyEntry pke =
1033                 (KeyStore.PrivateKeyEntry)ks.getEntry("pk1", null);
1034         System.out.println("pk1 = " + pke.getPrivateKey());
1035         Certificate[] chain = pke.getCertificateChain();
1036         if (chain.length != chain1.length) {
1037             throw new SecurityException("received chain not correct length");
1038         }
1039         for (int i = 0; i < chain.length; i++) {
1040             if (!chain[i].equals(chain1[i])) {
1041                 throw new SecurityException("received chain not equal");
1042             }
1043         }
1044 
1045         // getEntry good pke 2
1046         pke = (KeyStore.PrivateKeyEntry)ks.getEntry("pk2", null);
1047         System.out.println("pk2 = " + pke.getPrivateKey());
1048         chain = pke.getCertificateChain();
1049         if (chain.length != chain2.length) {
1050             throw new SecurityException("received chain not correct length");
1051         }
1052         for (int i = 0; i < chain.length; i++) {
1053             if (!chain[i].equals(chain2[i])) {
1054                 throw new SecurityException("received chain not equal");
1055             }
1056         }
1057 
1058         // getEntry good pke 3
1059         pke = (KeyStore.PrivateKeyEntry)ks.getEntry("pk3", null);
1060         System.out.println("pk3 = " + pke.getPrivateKey());
1061         chain = pke.getCertificateChain();
1062         if (chain.length != chain3.length) {
1063             throw new SecurityException("received chain not correct length");
1064         }
1065         for (int i = 0; i < chain.length; i++) {
1066             if (!chain[i].equals(chain3[i])) {
1067                 throw new SecurityException("received chain not equal");
1068             }
1069         }
1070 
1071         // getKey good pke 1
1072         PrivateKey pkey = (PrivateKey)ks.getKey("pk1", null);
1073         if ("RSA".equals(pkey.getAlgorithm())) {
1074             System.out.println("test " + testnum++ + " passed");
1075         } else {
1076             throw new SecurityException
1077                 ("expected RSA, got " + pkey.getAlgorithm());
1078         }
1079 
1080         // getCertificate chain chain 1
1081         chain = ks.getCertificateChain("pk1");
1082         if (chain.length != chain1.length) {
1083             throw new SecurityException("received chain not correct length");
1084         }
1085         for (int i = 0; i < chain.length; i++) {
1086             if (!chain[i].equals(chain1[i])) {
1087                 throw new SecurityException("received chain not equal");
1088             }
1089         }
1090 
1091         // getKey good pke 2
1092         pkey = (PrivateKey)ks.getKey("pk2", null);
1093         if ("RSA".equals(pkey.getAlgorithm())) {
1094             System.out.println("test " + testnum++ + " passed");
1095         } else {
1096             throw new SecurityException
1097                 ("expected RSA, got " + pkey.getAlgorithm());
1098         }
1099 
1100         // getCertificate chain chain 2
1101         chain = ks.getCertificateChain("pk2");
1102         if (chain.length != chain2.length) {
1103             throw new SecurityException("received chain not correct length");
1104         }
1105         for (int i = 0; i < chain.length; i++) {
1106             if (!chain[i].equals(chain2[i])) {
1107                 throw new SecurityException("received chain not equal");
1108             }
1109         }
1110 
1111         // getKey good pke 3
1112         pkey = (PrivateKey)ks.getKey("pk3", null);
1113         if ("RSA".equals(pkey.getAlgorithm())) {
1114             System.out.println("test " + testnum++ + " passed");
1115         } else {
1116             throw new SecurityException
1117                 ("expected RSA, got " + pkey.getAlgorithm());
1118         }
1119 
1120         // getCertificate chain chain 3
1121         chain = ks.getCertificateChain("pk3");
1122         if (chain.length != chain3.length) {
1123             throw new SecurityException("received chain not correct length");
1124         }
1125         for (int i = 0; i < chain.length; i++) {
1126             if (!chain[i].equals(chain3[i])) {
1127                 throw new SecurityException("received chain not equal");
1128             }
1129         }
1130 
1131         // aliases
1132         enu = ks.aliases();
1133         count = 0;
1134         while (enu.hasMoreElements()) {
1135             count++;
1136             System.out.println("alias " +
1137                                 count +
1138                                 " = " +
1139                                 (String)enu.nextElement());
1140         }
1141         if (count == 7) {
1142             System.out.println("test " + testnum++ + " passed");
1143         } else {
1144             throw new SecurityException("expected 7 aliases");
1145         }
1146 
1147         // size
1148         if (ks.size() == 7) {
1149             System.out.println("test " + testnum++ + " passed");
1150         } else {
1151             throw new SecurityException("expected size 7");
1152         }
1153 
1154         // getCertificate good chain 1
1155         if (ks.getCertificate("pk1").equals(chain1[0])) {
1156             System.out.println("test " + testnum++ + " passed");
1157         } else {
1158             throw new SecurityException("retrieved cert not equal");
1159         }
1160 
1161         // getCertificate good chain 3
1162         if (ks.getCertificate("pk3").equals(chain3[0])) {
1163             System.out.println("test " + testnum++ + " passed");
1164         } else {
1165             throw new SecurityException("retrieved cert not equal");
1166         }
1167 
1168         // getKey good ske 1
1169         skey = (SecretKey)ks.getKey("sk1", null);
1170         if ("DES".equals(skey.getAlgorithm())) {
1171             System.out.println("test " + testnum++ + " passed");
1172         } else {
1173             throw new SecurityException
1174                 ("expected DES, got " + skey.getAlgorithm());
1175         }
1176 
1177         // getKey good ske 4
1178         skey = (SecretKey)ks.getKey("sk4", null);
1179         if ("ARCFOUR".equals(skey.getAlgorithm())) {
1180             System.out.println("test " + testnum++ + " passed");
1181         } else {
1182             throw new SecurityException
1183                 ("expected ARCFOUR, got " + skey.getAlgorithm());
1184         }
1185 
1186         // getKey good pke 1
1187         pkey = (PrivateKey)ks.getKey("pk1", null);
1188         if ("RSA".equals(pkey.getAlgorithm())) {
1189             System.out.println("test " + testnum++ + " passed");
1190         } else {
1191             throw new SecurityException
1192                 ("expected RSA, got " + pkey.getAlgorithm());
1193         }
1194 
1195         // getKey good pke 3
1196         pkey = (PrivateKey)ks.getKey("pk3", null);
1197         if ("RSA".equals(pkey.getAlgorithm())) {
1198             System.out.println("test " + testnum++ + " passed");
1199         } else {
1200             throw new SecurityException
1201                 ("expected RSA, got " + pkey.getAlgorithm());
1202         }
1203 
1204         // contains alias
1205         if (!ks.containsAlias("pk1") ||
1206                 !ks.containsAlias("pk2") ||
1207                 !ks.containsAlias("pk3") ||
1208                 !ks.containsAlias("sk1") ||
1209                 !ks.containsAlias("sk2") ||
1210                 !ks.containsAlias("sk3") ||
1211                 !ks.containsAlias("sk4")) {
1212             throw new SecurityException("did not contain all aliases");
1213         }
1214         System.out.println("test " + testnum++ + " passed");
1215 
1216         // getCertificateAlias pk1
1217         if (ks.getCertificateAlias(chain1[0]).equals("pk1")) {
1218             System.out.println("test " + testnum++ + " passed");
1219         } else {
1220             throw new SecurityException("expected cert pk1");
1221         }
1222 
1223         // getCertificateAlias pk3
1224         if (ks.getCertificateAlias(chain3[0]).equals("pk3")) {
1225             System.out.println("test " + testnum++ + " passed");
1226         } else {
1227             throw new SecurityException("expected cert pk3");
1228         }
1229 
1230         // isCertificateEntry pk1
1231         if (!ks.isCertificateEntry("pk1")) {
1232             System.out.println("test " + testnum++ + " passed");
1233         } else {
1234             throw new SecurityException("expected pke");
1235         }
1236 
1237         // isCertificateEntry pk3
1238         if (!ks.isCertificateEntry("pk3")) {
1239             System.out.println("test " + testnum++ + " passed");
1240         } else {
1241             throw new SecurityException("expected pke");
1242         }
1243 
1244         // isCertificateEntry sk1
1245         if (!ks.isCertificateEntry("sk1")) {
1246             System.out.println("test " + testnum++ + " passed");
1247         } else {
1248             throw new SecurityException("expected ske");
1249         }
1250 
1251         // isCertificateEntry sk4
1252         if (!ks.isCertificateEntry("sk4")) {
1253             System.out.println("test " + testnum++ + " passed");
1254         } else {
1255             throw new SecurityException("expected ske");
1256         }
1257 
1258         // isKeyEntry pk1
1259         if (ks.isKeyEntry("pk1")) {
1260             System.out.println("test " + testnum++ + " passed");
1261         } else {
1262             throw new SecurityException("expected pke");
1263         }
1264 
1265         // isKeyEntry pk3
1266         if (ks.isKeyEntry("pk3")) {
1267             System.out.println("test " + testnum++ + " passed");
1268         } else {
1269             throw new SecurityException("expected pke");
1270         }
1271 
1272         // isKeyEntry sk1
1273         if (ks.isKeyEntry("sk1")) {
1274             System.out.println("test " + testnum++ + " passed");
1275         } else {
1276             throw new SecurityException("expected ske");
1277         }
1278 
1279         // isKeyEntry sk4
1280         if (ks.isKeyEntry("sk4")) {
1281             System.out.println("test " + testnum++ + " passed");
1282         } else {
1283             throw new SecurityException("expected ske");
1284         }
1285 
1286         // isCertificateEntry random foo
1287         if (!ks.isCertificateEntry("foo")) {
1288             System.out.println("test " + testnum++ + " passed");
1289         } else {
1290             throw new SecurityException("expected foo");
1291         }
1292 
1293         // isKeyEntry random foo
1294         if (!ks.isKeyEntry("foo")) {
1295             System.out.println("test " + testnum++ + " passed");
1296         } else {
1297             throw new SecurityException("expected foo");
1298         }
1299 
1300         // entryInstanceOf pk1
1301         if (!ks.entryInstanceOf
1302                 ("pk1", KeyStore.TrustedCertificateEntry.class)) {
1303             System.out.println("test " + testnum++ + " passed");
1304         } else {
1305             throw new SecurityException("expected tce");
1306         }
1307 
1308         // entryInstanceOf pk3
1309         if (!ks.entryInstanceOf
1310                 ("pk3", KeyStore.TrustedCertificateEntry.class)) {
1311             System.out.println("test " + testnum++ + " passed");
1312         } else {
1313             throw new SecurityException("expected tce");
1314         }
1315 
1316         // entryInstanceOf sk1
1317         if (!ks.entryInstanceOf
1318                 ("sk1", KeyStore.TrustedCertificateEntry.class)) {
1319             System.out.println("test " + testnum++ + " passed");
1320         } else {
1321             throw new SecurityException("expected tce");
1322         }
1323 
1324         // entryInstanceOf sk4
1325         if (!ks.entryInstanceOf
1326                 ("sk4", KeyStore.TrustedCertificateEntry.class)) {
1327             System.out.println("test " + testnum++ + " passed");
1328         } else {
1329             throw new SecurityException("expected tce");
1330         }
1331 
1332         // entryInstanceOf pk1
1333         if (ks.entryInstanceOf("pk1", KeyStore.PrivateKeyEntry.class)) {
1334             System.out.println("test " + testnum++ + " passed");
1335         } else {
1336             throw new SecurityException("expected pke");
1337         }
1338 
1339         // entryInstanceOf pk3
1340         if (ks.entryInstanceOf("pk3", KeyStore.PrivateKeyEntry.class)) {
1341             System.out.println("test " + testnum++ + " passed");
1342         } else {
1343             throw new SecurityException("expected pke");
1344         }
1345 
1346         // entryInstanceOf sk1
1347         if (!ks.entryInstanceOf("sk1", KeyStore.PrivateKeyEntry.class)) {
1348             System.out.println("test " + testnum++ + " passed");
1349         } else {
1350             throw new SecurityException("expected pke");
1351         }
1352 
1353         // entryInstanceOf sk4
1354         if (!ks.entryInstanceOf("sk4", KeyStore.PrivateKeyEntry.class)) {
1355             System.out.println("test " + testnum++ + " passed");
1356         } else {
1357             throw new SecurityException("expected pke");
1358         }
1359 
1360         // entryInstanceOf sk1
1361         if (ks.entryInstanceOf("sk1", KeyStore.SecretKeyEntry.class)) {
1362             System.out.println("test " + testnum++ + " passed");
1363         } else {
1364             throw new SecurityException("expected ske");
1365         }
1366 
1367         // entryInstanceOf sk4
1368         if (ks.entryInstanceOf("sk4", KeyStore.SecretKeyEntry.class)) {
1369             System.out.println("test " + testnum++ + " passed");
1370         } else {
1371             throw new SecurityException("expected ske");
1372         }
1373 
1374         // entryInstanceOf pk1
1375         if (!ks.entryInstanceOf("pk1", KeyStore.SecretKeyEntry.class)) {
1376             System.out.println("test " + testnum++ + " passed");
1377         } else {
1378             throw new SecurityException("expected ske");
1379         }
1380 
1381         // entryInstanceOf pk3
1382         if (!ks.entryInstanceOf("pk3", KeyStore.SecretKeyEntry.class)) {
1383             System.out.println("test " + testnum++ + " passed");
1384         } else {
1385             throw new SecurityException("expected ske");
1386         }
1387 
1388         // getEntry random foobar
1389         if (ks.getEntry("foobar", null) != null) {
1390             throw new SecurityException("expected null entry");
1391         } else {
1392             System.out.println("test " + testnum++ + " passed");
1393         }
1394 
1395         // deleteEntry
1396         ks.deleteEntry("pk1");
1397         ks.deleteEntry("pk3");
1398         ks.deleteEntry("sk2");
1399         ks.deleteEntry("sk3");
1400         System.out.println("test " + testnum++ + " passed");
1401 
1402         // aliases
1403         enu = ks.aliases();
1404         count = 0;
1405         while (enu.hasMoreElements()) {
1406             count++;
1407             System.out.println("alias " +
1408                                 count +
1409                                 " = " +
1410                                 (String)enu.nextElement());
1411         }
1412         if (count == 3) {
1413             System.out.println("test " + testnum++ + " passed");
1414         } else {
1415             throw new SecurityException("expected 3 aliases");
1416         }
1417 
1418         // size
1419         if (ks.size() == 3) {
1420             System.out.println("test " + testnum++ + " passed");
1421         } else {
1422             throw new SecurityException("expected size 6");
1423         }
1424 
1425         // entryInstanceOf sk1
1426         if (!ks.entryInstanceOf("sk1", KeyStore.PrivateKeyEntry.class)) {
1427             System.out.println("test " + testnum++ + " passed");
1428         } else {
1429             throw new SecurityException("expected pke");
1430         }
1431 
1432         // entryInstanceOf sk4
1433         if (!ks.entryInstanceOf("sk4", KeyStore.PrivateKeyEntry.class)) {
1434             System.out.println("test " + testnum++ + " passed");
1435         } else {
1436             throw new SecurityException("expected pke");
1437         }
1438 
1439         // entryInstanceOf pk2
1440         if (ks.entryInstanceOf("pk2", KeyStore.PrivateKeyEntry.class)) {
1441             System.out.println("test " + testnum++ + " passed");
1442         } else {
1443             throw new SecurityException("expected pke");
1444         }
1445         System.out.println("test " + testnum++ + " passed");
1446 
1447         return testnum;
1448     }
1449 }
1450