1 /*
2 * Copyright (c) 1997, 2013, 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. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package sun.security.tools.policytool;
27
28 import java.io.*;
29 import java.util.LinkedList;
30 import java.util.ListIterator;
31 import java.util.Vector;
32 import java.util.Enumeration;
33 import java.net.URL;
34 import java.net.MalformedURLException;
35 import java.lang.reflect.*;
36 import java.text.Collator;
37 import java.text.MessageFormat;
38 import sun.security.util.PropertyExpander;
39 import sun.security.util.PropertyExpander.ExpandException;
40 import java.awt.Component;
41 import java.awt.Container;
42 import java.awt.Dimension;
43 import java.awt.FileDialog;
44 import java.awt.GridBagConstraints;
45 import java.awt.GridBagLayout;
46 import java.awt.Insets;
47 import java.awt.Point;
48 import java.awt.Toolkit;
49 import java.awt.Window;
50 import java.awt.event.*;
51 import java.security.cert.Certificate;
52 import java.security.cert.CertificateException;
53 import java.security.*;
54 import sun.security.provider.*;
55 import sun.security.util.PolicyUtil;
56 import javax.security.auth.x500.X500Principal;
57 import javax.swing.*;
58 import javax.swing.border.EmptyBorder;
59
60 /**
61 * PolicyTool may be used by users and administrators to configure the
62 * overall java security policy (currently stored in the policy file).
63 * Using PolicyTool administrators may add and remove policies from
64 * the policy file. <p>
65 *
66 * @see java.security.Policy
67 * @since 1.2
68 */
69
70 public class PolicyTool {
71
72 // for i18n
73 static final java.util.ResourceBundle rb =
74 java.util.ResourceBundle.getBundle(
75 "sun.security.tools.policytool.Resources");
76 static final Collator collator = Collator.getInstance();
77 static {
78 // this is for case insensitive string comparisons
79 collator.setStrength(Collator.PRIMARY);
80
81 // Support for Apple menu bar
82 if (System.getProperty("apple.laf.useScreenMenuBar") == null) {
83 System.setProperty("apple.laf.useScreenMenuBar", "true");
84 }
85 System.setProperty("apple.awt.application.name", getMessage("Policy.Tool"));
86
87 // Apply the system L&F if not specified with a system property.
88 if (System.getProperty("swing.defaultlaf") == null) {
89 try {
90 UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
91 } catch (Exception e) {
92 // ignore
93 }
94 }
95 }
96
97 // anyone can add warnings
98 Vector<String> warnings;
99 boolean newWarning = false;
100
101 // set to true if policy modified.
102 // this way upon exit we know if to ask the user to save changes
103 boolean modified = false;
104
105 private static final boolean testing = false;
106 private static final Class<?>[] TWOPARAMS = { String.class, String.class };
107 private static final Class<?>[] ONEPARAMS = { String.class };
108 private static final Class<?>[] NOPARAMS = {};
109 /*
110 * All of the policy entries are read in from the
111 * policy file and stored here. Updates to the policy entries
112 * using addEntry() and removeEntry() are made here. To ultimately save
113 * the policy entries back to the policy file, the SavePolicy button
114 * must be clicked.
115 **/
116 private static String policyFileName = null;
117 private Vector<PolicyEntry> policyEntries = null;
118 private PolicyParser parser = null;
119
120 /* The public key alias information is stored here. */
121 private KeyStore keyStore = null;
122 private String keyStoreName = " ";
123 private String keyStoreType = " ";
124 private String keyStoreProvider = " ";
125 private String keyStorePwdURL = " ";
126
127 /* standard PKCS11 KeyStore type */
128 private static final String P11KEYSTORE = "PKCS11";
129
130 /* reserved word for PKCS11 KeyStores */
131 private static final String NONE = "NONE";
132
133 /**
134 * default constructor
135 */
136 private PolicyTool() {
137 policyEntries = new Vector<PolicyEntry>();
138 parser = new PolicyParser();
139 warnings = new Vector<String>();
140 }
141
142 /**
143 * get the PolicyFileName
144 */
145 String getPolicyFileName() {
146 return policyFileName;
147 }
148
149 /**
150 * set the PolicyFileName
151 */
152 void setPolicyFileName(String policyFileName) {
153 PolicyTool.policyFileName = policyFileName;
154 }
155
156 /**
157 * clear keyStore info
158 */
159 void clearKeyStoreInfo() {
160 this.keyStoreName = null;
161 this.keyStoreType = null;
162 this.keyStoreProvider = null;
163 this.keyStorePwdURL = null;
164
165 this.keyStore = null;
166 }
167
168 /**
169 * get the keyStore URL name
170 */
171 String getKeyStoreName() {
172 return keyStoreName;
173 }
174
175 /**
176 * get the keyStore Type
177 */
178 String getKeyStoreType() {
179 return keyStoreType;
180 }
181
182 /**
183 * get the keyStore Provider
184 */
185 String getKeyStoreProvider() {
186 return keyStoreProvider;
187 }
188
189 /**
190 * get the keyStore password URL
191 */
192 String getKeyStorePwdURL() {
193 return keyStorePwdURL;
194 }
195
196 /**
197 * Open and read a policy file
198 */
199 void openPolicy(String filename) throws FileNotFoundException,
200 PolicyParser.ParsingException,
201 KeyStoreException,
202 CertificateException,
203 InstantiationException,
204 MalformedURLException,
205 IOException,
206 NoSuchAlgorithmException,
207 IllegalAccessException,
208 NoSuchMethodException,
209 UnrecoverableKeyException,
210 NoSuchProviderException,
211 ClassNotFoundException,
212 PropertyExpander.ExpandException,
213 InvocationTargetException {
214
215 newWarning = false;
216
217 // start fresh - blow away the current state
218 policyEntries = new Vector<PolicyEntry>();
219 parser = new PolicyParser();
220 warnings = new Vector<String>();
221 setPolicyFileName(null);
222 clearKeyStoreInfo();
223
224 // see if user is opening a NEW policy file
225 if (filename == null) {
226 modified = false;
227 return;
228 }
229
230 // Read in the policy entries from the file and
231 // populate the parser vector table. The parser vector
232 // table only holds the entries as strings, so it only
233 // guarantees that the policies are syntactically
234 // correct.
235 setPolicyFileName(filename);
236 parser.read(new FileReader(filename));
237
238 // open the keystore
239 openKeyStore(parser.getKeyStoreUrl(), parser.getKeyStoreType(),
240 parser.getKeyStoreProvider(), parser.getStorePassURL());
241
242 // Update the local vector with the same policy entries.
243 // This guarantees that the policy entries are not only
244 // syntactically correct, but semantically valid as well.
245 Enumeration<PolicyParser.GrantEntry> enum_ = parser.grantElements();
246 while (enum_.hasMoreElements()) {
247 PolicyParser.GrantEntry ge = enum_.nextElement();
248
249 // see if all the signers have public keys
250 if (ge.signedBy != null) {
251
252 String signers[] = parseSigners(ge.signedBy);
253 for (int i = 0; i < signers.length; i++) {
254 PublicKey pubKey = getPublicKeyAlias(signers[i]);
255 if (pubKey == null) {
256 newWarning = true;
257 MessageFormat form = new MessageFormat(getMessage
258 ("Warning.A.public.key.for.alias.signers.i.does.not.exist.Make.sure.a.KeyStore.is.properly.configured."));
259 Object[] source = {signers[i]};
260 warnings.addElement(form.format(source));
261 }
262 }
263 }
264
265 // check to see if the Principals are valid
266 ListIterator<PolicyParser.PrincipalEntry> prinList =
267 ge.principals.listIterator(0);
268 while (prinList.hasNext()) {
269 PolicyParser.PrincipalEntry pe = prinList.next();
270 try {
271 verifyPrincipal(pe.getPrincipalClass(),
272 pe.getPrincipalName());
273 } catch (ClassNotFoundException fnfe) {
274 newWarning = true;
275 MessageFormat form = new MessageFormat(getMessage
276 ("Warning.Class.not.found.class"));
277 Object[] source = {pe.getPrincipalClass()};
278 warnings.addElement(form.format(source));
279 }
280 }
281
282 // check to see if the Permissions are valid
283 Enumeration<PolicyParser.PermissionEntry> perms =
284 ge.permissionElements();
285 while (perms.hasMoreElements()) {
286 PolicyParser.PermissionEntry pe = perms.nextElement();
287 try {
288 verifyPermission(pe.permission, pe.name, pe.action);
289 } catch (ClassNotFoundException fnfe) {
290 newWarning = true;
291 MessageFormat form = new MessageFormat(getMessage
292 ("Warning.Class.not.found.class"));
293 Object[] source = {pe.permission};
294 warnings.addElement(form.format(source));
295 } catch (InvocationTargetException ite) {
296 newWarning = true;
297 MessageFormat form = new MessageFormat(getMessage
298 ("Warning.Invalid.argument.s.for.constructor.arg"));
299 Object[] source = {pe.permission};
300 warnings.addElement(form.format(source));
301 }
302
303 // see if all the permission signers have public keys
304 if (pe.signedBy != null) {
305
306 String signers[] = parseSigners(pe.signedBy);
307
308 for (int i = 0; i < signers.length; i++) {
309 PublicKey pubKey = getPublicKeyAlias(signers[i]);
310 if (pubKey == null) {
311 newWarning = true;
312 MessageFormat form = new MessageFormat(getMessage
313 ("Warning.A.public.key.for.alias.signers.i.does.not.exist.Make.sure.a.KeyStore.is.properly.configured."));
314 Object[] source = {signers[i]};
315 warnings.addElement(form.format(source));
316 }
317 }
318 }
319 }
320 PolicyEntry pEntry = new PolicyEntry(this, ge);
321 policyEntries.addElement(pEntry);
322 }
323
324 // just read in the policy -- nothing has been modified yet
325 modified = false;
326 }
327
328
329 /**
330 * Save a policy to a file
331 */
332 void savePolicy(String filename)
333 throws FileNotFoundException, IOException {
334 // save the policy entries to a file
335 parser.setKeyStoreUrl(keyStoreName);
336 parser.setKeyStoreType(keyStoreType);
337 parser.setKeyStoreProvider(keyStoreProvider);
338 parser.setStorePassURL(keyStorePwdURL);
339 parser.write(new FileWriter(filename));
340 modified = false;
341 }
342
343 /**
344 * Open the KeyStore
345 */
346 void openKeyStore(String name,
347 String type,
348 String provider,
349 String pwdURL) throws KeyStoreException,
350 NoSuchAlgorithmException,
351 UnrecoverableKeyException,
352 IOException,
353 CertificateException,
354 NoSuchProviderException,
355 ExpandException {
356
357 if (name == null && type == null &&
358 provider == null && pwdURL == null) {
359
360 // policy did not specify a keystore during open
361 // or use wants to reset keystore values
362
363 this.keyStoreName = null;
364 this.keyStoreType = null;
365 this.keyStoreProvider = null;
366 this.keyStorePwdURL = null;
367
368 // caller will set (tool.modified = true) if appropriate
369
370 return;
371 }
372
373 URL policyURL = null;
374 if (policyFileName != null) {
375 File pfile = new File(policyFileName);
376 policyURL = new URL("file:" + pfile.getCanonicalPath());
377 }
378
379 // although PolicyUtil.getKeyStore may properly handle
380 // defaults and property expansion, we do it here so that
381 // if the call is successful, we can set the proper values
382 // (PolicyUtil.getKeyStore does not return expanded values)
383
384 if (name != null && name.length() > 0) {
385 name = PropertyExpander.expand(name).replace
386 (File.separatorChar, '/');
387 }
388 if (type == null || type.length() == 0) {
389 type = KeyStore.getDefaultType();
390 }
391 if (pwdURL != null && pwdURL.length() > 0) {
392 pwdURL = PropertyExpander.expand(pwdURL).replace
393 (File.separatorChar, '/');
394 }
395
396 try {
397 this.keyStore = PolicyUtil.getKeyStore(policyURL,
398 name,
399 type,
400 provider,
401 pwdURL,
402 null);
403 } catch (IOException ioe) {
404
405 // copied from sun.security.pkcs11.SunPKCS11
406 String MSG = "no password provided, and no callback handler " +
407 "available for retrieving password";
408
409 Throwable cause = ioe.getCause();
410 if (cause != null &&
411 cause instanceof javax.security.auth.login.LoginException &&
412 MSG.equals(cause.getMessage())) {
413
414 // throw a more friendly exception message
415 throw new IOException(MSG);
416 } else {
417 throw ioe;
418 }
419 }
420
421 this.keyStoreName = name;
422 this.keyStoreType = type;
423 this.keyStoreProvider = provider;
424 this.keyStorePwdURL = pwdURL;
425
426 // caller will set (tool.modified = true)
427 }
428
429 /**
430 * Add a Grant entry to the overall policy at the specified index.
431 * A policy entry consists of a CodeSource.
432 */
433 boolean addEntry(PolicyEntry pe, int index) {
434
435 if (index < 0) {
436 // new entry -- just add it to the end
437 policyEntries.addElement(pe);
438 parser.add(pe.getGrantEntry());
439 } else {
440 // existing entry -- replace old one
441 PolicyEntry origPe = policyEntries.elementAt(index);
442 parser.replace(origPe.getGrantEntry(), pe.getGrantEntry());
443 policyEntries.setElementAt(pe, index);
444 }
445 return true;
446 }
447
448 /**
449 * Add a Principal entry to an existing PolicyEntry at the specified index.
450 * A Principal entry consists of a class, and name.
451 *
452 * If the principal already exists, it is not added again.
453 */
454 boolean addPrinEntry(PolicyEntry pe,
455 PolicyParser.PrincipalEntry newPrin,
456 int index) {
457
458 // first add the principal to the Policy Parser entry
459 PolicyParser.GrantEntry grantEntry = pe.getGrantEntry();
460 if (grantEntry.contains(newPrin) == true)
461 return false;
462
463 LinkedList<PolicyParser.PrincipalEntry> prinList =
464 grantEntry.principals;
465 if (index != -1)
466 prinList.set(index, newPrin);
467 else
468 prinList.add(newPrin);
469
470 modified = true;
471 return true;
472 }
473
474 /**
475 * Add a Permission entry to an existing PolicyEntry at the specified index.
476 * A Permission entry consists of a permission, name, and actions.
477 *
478 * If the permission already exists, it is not added again.
479 */
480 boolean addPermEntry(PolicyEntry pe,
481 PolicyParser.PermissionEntry newPerm,
482 int index) {
483
484 // first add the permission to the Policy Parser Vector
485 PolicyParser.GrantEntry grantEntry = pe.getGrantEntry();
486 if (grantEntry.contains(newPerm) == true)
487 return false;
488
489 Vector<PolicyParser.PermissionEntry> permList =
490 grantEntry.permissionEntries;
491 if (index != -1)
492 permList.setElementAt(newPerm, index);
493 else
494 permList.addElement(newPerm);
495
496 modified = true;
497 return true;
498 }
499
500 /**
501 * Remove a Permission entry from an existing PolicyEntry.
502 */
503 boolean removePermEntry(PolicyEntry pe,
504 PolicyParser.PermissionEntry perm) {
505
506 // remove the Permission from the GrantEntry
507 PolicyParser.GrantEntry ppge = pe.getGrantEntry();
508 modified = ppge.remove(perm);
509 return modified;
510 }
511
512 /**
513 * remove an entry from the overall policy
514 */
515 boolean removeEntry(PolicyEntry pe) {
516
517 parser.remove(pe.getGrantEntry());
518 modified = true;
519 return (policyEntries.removeElement(pe));
520 }
521
522 /**
523 * retrieve all Policy Entries
524 */
525 PolicyEntry[] getEntry() {
526
527 if (policyEntries.size() > 0) {
528 PolicyEntry entries[] = new PolicyEntry[policyEntries.size()];
529 for (int i = 0; i < policyEntries.size(); i++)
530 entries[i] = policyEntries.elementAt(i);
531 return entries;
532 }
533 return null;
534 }
535
536 /**
537 * Retrieve the public key mapped to a particular name.
538 * If the key has expired, a KeyException is thrown.
539 */
540 PublicKey getPublicKeyAlias(String name) throws KeyStoreException {
541 if (keyStore == null) {
542 return null;
543 }
544
545 Certificate cert = keyStore.getCertificate(name);
546 if (cert == null) {
547 return null;
548 }
549 PublicKey pubKey = cert.getPublicKey();
550 return pubKey;
551 }
552
553 /**
554 * Retrieve all the alias names stored in the certificate database
555 */
556 String[] getPublicKeyAlias() throws KeyStoreException {
557
558 int numAliases = 0;
559 String aliases[] = null;
560
561 if (keyStore == null) {
562 return null;
563 }
564 Enumeration<String> enum_ = keyStore.aliases();
565
566 // first count the number of elements
567 while (enum_.hasMoreElements()) {
568 enum_.nextElement();
569 numAliases++;
570 }
571
572 if (numAliases > 0) {
573 // now copy them into an array
574 aliases = new String[numAliases];
575 numAliases = 0;
576 enum_ = keyStore.aliases();
577 while (enum_.hasMoreElements()) {
578 aliases[numAliases] = new String(enum_.nextElement());
579 numAliases++;
580 }
581 }
582 return aliases;
583 }
584
585 /**
586 * This method parses a single string of signers separated by commas
587 * ("jordan, duke, pippen") into an array of individual strings.
588 */
589 String[] parseSigners(String signedBy) {
590
591 String signers[] = null;
592 int numSigners = 1;
593 int signedByIndex = 0;
594 int commaIndex = 0;
595 int signerNum = 0;
596
597 // first pass thru "signedBy" counts the number of signers
598 while (commaIndex >= 0) {
599 commaIndex = signedBy.indexOf(',', signedByIndex);
600 if (commaIndex >= 0) {
601 numSigners++;
602 signedByIndex = commaIndex + 1;
603 }
604 }
605 signers = new String[numSigners];
606
607 // second pass thru "signedBy" transfers signers to array
608 commaIndex = 0;
609 signedByIndex = 0;
610 while (commaIndex >= 0) {
611 if ((commaIndex = signedBy.indexOf(',', signedByIndex)) >= 0) {
612 // transfer signer and ignore trailing part of the string
613 signers[signerNum] =
614 signedBy.substring(signedByIndex, commaIndex).trim();
615 signerNum++;
616 signedByIndex = commaIndex + 1;
617 } else {
618 // we are at the end of the string -- transfer signer
619 signers[signerNum] = signedBy.substring(signedByIndex).trim();
620 }
621 }
622 return signers;
623 }
624
625 /**
626 * Check to see if the Principal contents are OK
627 */
628 void verifyPrincipal(String type, String name)
629 throws ClassNotFoundException,
630 InstantiationException
631 {
632 if (type.equals(PolicyParser.PrincipalEntry.WILDCARD_CLASS) ||
633 type.equals(PolicyParser.PrincipalEntry.REPLACE_NAME)) {
634 return;
635 }
636 Class<?> PRIN = Class.forName("java.security.Principal");
637 Class<?> pc = Class.forName(type, true,
638 Thread.currentThread().getContextClassLoader());
639 if (!PRIN.isAssignableFrom(pc)) {
640 MessageFormat form = new MessageFormat(getMessage
641 ("Illegal.Principal.Type.type"));
642 Object[] source = {type};
643 throw new InstantiationException(form.format(source));
644 }
645
646 if (ToolDialog.X500_PRIN_CLASS.equals(pc.getName())) {
647 // PolicyParser checks validity of X500Principal name
648 // - PolicyTool needs to as well so that it doesn't store
649 // an invalid name that can't be read in later
650 //
651 // this can throw an IllegalArgumentException
652 X500Principal newP = new X500Principal(name);
653 }
654 }
655
656 /**
657 * Check to see if the Permission contents are OK
658 */
659 @SuppressWarnings("fallthrough")
660 void verifyPermission(String type,
661 String name,
662 String actions)
663 throws ClassNotFoundException,
664 InstantiationException,
665 IllegalAccessException,
666 NoSuchMethodException,
667 InvocationTargetException
668 {
669
670 //XXX we might want to keep a hash of created factories...
671 Class<?> pc = Class.forName(type, true,
672 Thread.currentThread().getContextClassLoader());
673 Constructor<?> c = null;
674 Vector<String> objects = new Vector<>(2);
675 if (name != null) objects.add(name);
676 if (actions != null) objects.add(actions);
677 switch (objects.size()) {
678 case 0:
679 try {
680 c = pc.getConstructor(NOPARAMS);
681 break;
682 } catch (NoSuchMethodException ex) {
683 // proceed to the one-param constructor
684 objects.add(null);
685 }
686 /* fall through */
687 case 1:
688 try {
689 c = pc.getConstructor(ONEPARAMS);
690 break;
691 } catch (NoSuchMethodException ex) {
692 // proceed to the two-param constructor
693 objects.add(null);
694 }
695 /* fall through */
696 case 2:
697 c = pc.getConstructor(TWOPARAMS);
698 break;
699 }
700 Object parameters[] = objects.toArray();
701 Permission p = (Permission)c.newInstance(parameters);
702 }
703
704 /*
705 * Parse command line arguments.
706 */
707 static void parseArgs(String args[]) {
708 /* parse flags */
709 int n = 0;
710
711 for (n=0; (n < args.length) && args[n].startsWith("-"); n++) {
712
713 String flags = args[n];
714
715 if (collator.compare(flags, "-file") == 0) {
716 if (++n == args.length) usage();
717 policyFileName = args[n];
718 } else {
719 MessageFormat form = new MessageFormat(getMessage
720 ("Illegal.option.option"));
721 Object[] source = { flags };
722 System.err.println(form.format(source));
723 usage();
724 }
725 }
726 }
727
728 static void usage() {
729 System.out.println(getMessage("Usage.policytool.options."));
730 System.out.println();
731 System.out.println(getMessage
732 (".file.file.policy.file.location"));
733 System.out.println();
734
735 System.exit(1);
736 }
737
738 /**
739 * run the PolicyTool
740 */
741 public static void main(String args[]) {
742 parseArgs(args);
743 SwingUtilities.invokeLater(new Runnable() {
744 public void run() {
745 ToolWindow tw = new ToolWindow(new PolicyTool());
746 tw.displayToolWindow(args);
747 }
748 });
749 }
750
751 // split instr to words according to capitalization,
752 // like, AWTControl -> A W T Control
753 // this method is for easy pronounciation
754 static String splitToWords(String instr) {
755 return instr.replaceAll("([A-Z])", " $1");
756 }
757
758 /**
759 * Returns the message corresponding to the key in the bundle.
760 * This is preferred over {@link #getString} because it removes
761 * any mnemonic '&' character in the string.
762 *
763 * @param key the key
764 *
765 * @return the message
766 */
767 static String getMessage(String key) {
768 return removeMnemonicAmpersand(rb.getString(key));
769 }
770
771
772 /**
773 * Returns the mnemonic for a message.
774 *
775 * @param key the key
776 *
777 * @return the mnemonic <code>int</code>
778 */
779 static int getMnemonicInt(String key) {
780 String message = rb.getString(key);
781 return (findMnemonicInt(message));
782 }
783
784 /**
785 * Returns the mnemonic display index for a message.
786 *
787 * @param key the key
788 *
789 * @return the mnemonic display index
790 */
791 static int getDisplayedMnemonicIndex(String key) {
792 String message = rb.getString(key);
793 return (findMnemonicIndex(message));
794 }
795
796 /**
797 * Finds the mnemonic character in a message.
798 *
799 * The mnemonic character is the first character followed by the first
800 * <code>&</code> that is not followed by another <code>&</code>.
801 *
802 * @return the mnemonic as an <code>int</code>, or <code>0</code> if it
803 * can't be found.
804 */
805 private static int findMnemonicInt(String s) {
806 for (int i = 0; i < s.length() - 1; i++) {
807 if (s.charAt(i) == '&') {
808 if (s.charAt(i + 1) != '&') {
809 return KeyEvent.getExtendedKeyCodeForChar(s.charAt(i + 1));
810 } else {
811 i++;
812 }
813 }
814 }
815 return 0;
816 }
817
818 /**
819 * Finds the index of the mnemonic character in a message.
820 *
821 * The mnemonic character is the first character followed by the first
822 * <code>&</code> that is not followed by another <code>&</code>.
823 *
824 * @return the mnemonic character index as an <code>int</code>, or <code>-1</code> if it
825 * can't be found.
826 */
827 private static int findMnemonicIndex(String s) {
828 for (int i = 0; i < s.length() - 1; i++) {
829 if (s.charAt(i) == '&') {
830 if (s.charAt(i + 1) != '&') {
831 // Return the index of the '&' since it will be removed
832 return i;
833 } else {
834 i++;
835 }
836 }
837 }
838 return -1;
839 }
840
841 /**
842 * Removes the mnemonic identifier (<code>&</code>) from a string unless
843 * it's escaped by <code>&&</code> or placed at the end.
844 *
845 * @param message the message
846 *
847 * @return a message with the mnemonic identifier removed
848 */
849 private static String removeMnemonicAmpersand(String message) {
850 StringBuilder s = new StringBuilder();
851 for (int i = 0; i < message.length(); i++) {
852 char current = message.charAt(i);
853 if (current != '&' || i == message.length() - 1
854 || message.charAt(i + 1) == '&') {
855 s.append(current);
856 }
857 }
858 return s.toString();
859 }
860 }
861
862 /**
863 * Each entry in the policy configuration file is represented by a
864 * PolicyEntry object.
865 *
866 * A PolicyEntry is a (CodeSource,Permission) pair. The
867 * CodeSource contains the (URL, PublicKey) that together identify
868 * where the Java bytecodes come from and who (if anyone) signed
869 * them. The URL could refer to localhost. The URL could also be
870 * null, meaning that this policy entry is given to all comers, as
871 * long as they match the signer field. The signer could be null,
872 * meaning the code is not signed.
873 *
874 * The Permission contains the (Type, Name, Action) triplet.
875 *
876 */
877 class PolicyEntry {
878
879 private CodeSource codesource;
880 private PolicyTool tool;
881 private PolicyParser.GrantEntry grantEntry;
882 private boolean testing = false;
883
884 /**
885 * Create a PolicyEntry object from the information read in
886 * from a policy file.
887 */
888 PolicyEntry(PolicyTool tool, PolicyParser.GrantEntry ge)
889 throws MalformedURLException, NoSuchMethodException,
890 ClassNotFoundException, InstantiationException, IllegalAccessException,
891 InvocationTargetException, CertificateException,
892 IOException, NoSuchAlgorithmException, UnrecoverableKeyException {
893
894 this.tool = tool;
895
896 URL location = null;
897
898 // construct the CodeSource
899 if (ge.codeBase != null)
900 location = new URL(ge.codeBase);
901 this.codesource = new CodeSource(location,
902 (java.security.cert.Certificate[]) null);
903
904 if (testing) {
905 System.out.println("Adding Policy Entry:");
906 System.out.println(" CodeBase = " + location);
907 System.out.println(" Signers = " + ge.signedBy);
908 System.out.println(" with " + ge.principals.size() +
909 " Principals");
910 }
911
912 this.grantEntry = ge;
913 }
914
915 /**
916 * get the codesource associated with this PolicyEntry
917 */
918 CodeSource getCodeSource() {
919 return codesource;
920 }
921
922 /**
923 * get the GrantEntry associated with this PolicyEntry
924 */
925 PolicyParser.GrantEntry getGrantEntry() {
926 return grantEntry;
927 }
928
929 /**
930 * convert the header portion, i.e. codebase, signer, principals, of
931 * this policy entry into a string
932 */
933 String headerToString() {
934 String pString = principalsToString();
935 if (pString.length() == 0) {
936 return codebaseToString();
937 } else {
938 return codebaseToString() + ", " + pString;
939 }
940 }
941
942 /**
943 * convert the Codebase/signer portion of this policy entry into a string
944 */
945 String codebaseToString() {
946
947 String stringEntry = new String();
948
949 if (grantEntry.codeBase != null &&
950 grantEntry.codeBase.equals("") == false)
951 stringEntry = stringEntry.concat
952 ("CodeBase \"" +
953 grantEntry.codeBase +
954 "\"");
955
956 if (grantEntry.signedBy != null &&
957 grantEntry.signedBy.equals("") == false)
958 stringEntry = ((stringEntry.length() > 0) ?
959 stringEntry.concat(", SignedBy \"" +
960 grantEntry.signedBy +
961 "\"") :
962 stringEntry.concat("SignedBy \"" +
963 grantEntry.signedBy +
964 "\""));
965
966 if (stringEntry.length() == 0)
967 return new String("CodeBase <ALL>");
968 return stringEntry;
969 }
970
971 /**
972 * convert the Principals portion of this policy entry into a string
973 */
974 String principalsToString() {
975 String result = "";
976 if ((grantEntry.principals != null) &&
977 (!grantEntry.principals.isEmpty())) {
978 StringBuilder sb = new StringBuilder(200);
979 ListIterator<PolicyParser.PrincipalEntry> list =
980 grantEntry.principals.listIterator();
981 while (list.hasNext()) {
982 PolicyParser.PrincipalEntry pppe = list.next();
983 sb.append(" Principal " + pppe.getDisplayClass() + " " +
984 pppe.getDisplayName(true));
985 if (list.hasNext()) sb.append(", ");
986 }
987 result = sb.toString();
988 }
989 return result;
990 }
991
992 /**
993 * convert this policy entry into a PolicyParser.PermissionEntry
994 */
995 PolicyParser.PermissionEntry toPermissionEntry(Permission perm) {
996
997 String actions = null;
998
999 // get the actions
1000 if (perm.getActions() != null &&
1001 perm.getActions().trim() != "")
1002 actions = perm.getActions();
1003
1004 PolicyParser.PermissionEntry pe = new PolicyParser.PermissionEntry
1005 (perm.getClass().getName(),
1006 perm.getName(),
1007 actions);
1008 return pe;
1009 }
1010 }
1011
1012 /**
1013 * The main window for the PolicyTool
1014 */
1015 class ToolWindow extends JFrame {
1016 // use serialVersionUID from JDK 1.2.2 for interoperability
1017 private static final long serialVersionUID = 5682568601210376777L;
1018
1019 /* ESCAPE key */
1020 static final KeyStroke escKey = KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0);
1021
1022 /* external paddings */
1023 public static final Insets TOP_PADDING = new Insets(25,0,0,0);
1024 public static final Insets BOTTOM_PADDING = new Insets(0,0,25,0);
1025 public static final Insets LITE_BOTTOM_PADDING = new Insets(0,0,10,0);
1026 public static final Insets LR_PADDING = new Insets(0,10,0,10);
1027 public static final Insets TOP_BOTTOM_PADDING = new Insets(15, 0, 15, 0);
1028 public static final Insets L_TOP_BOTTOM_PADDING = new Insets(5,10,15,0);
1029 public static final Insets LR_TOP_BOTTOM_PADDING = new Insets(15, 4, 15, 4);
1030 public static final Insets LR_BOTTOM_PADDING = new Insets(0,10,5,10);
1031 public static final Insets L_BOTTOM_PADDING = new Insets(0,10,5,0);
1032 public static final Insets R_BOTTOM_PADDING = new Insets(0, 0, 25, 5);
1033 public static final Insets R_PADDING = new Insets(0, 0, 0, 5);
1034
1035 /* buttons and menus */
1036 public static final String NEW_POLICY_FILE = "New";
1037 public static final String OPEN_POLICY_FILE = "Open";
1038 public static final String SAVE_POLICY_FILE = "Save";
1039 public static final String SAVE_AS_POLICY_FILE = "Save.As";
1040 public static final String VIEW_WARNINGS = "View.Warning.Log";
1041 public static final String QUIT = "Exit";
1042 public static final String ADD_POLICY_ENTRY = "Add.Policy.Entry";
1043 public static final String EDIT_POLICY_ENTRY = "Edit.Policy.Entry";
1044 public static final String REMOVE_POLICY_ENTRY = "Remove.Policy.Entry";
1045 public static final String EDIT_KEYSTORE = "Edit";
1046 public static final String ADD_PUBKEY_ALIAS = "Add.Public.Key.Alias";
1047 public static final String REMOVE_PUBKEY_ALIAS = "Remove.Public.Key.Alias";
1048
1049 /* gridbag index for components in the main window (MW) */
1050 public static final int MW_FILENAME_LABEL = 0;
1051 public static final int MW_FILENAME_TEXTFIELD = 1;
1052 public static final int MW_PANEL = 2;
1053 public static final int MW_ADD_BUTTON = 0;
1054 public static final int MW_EDIT_BUTTON = 1;
1055 public static final int MW_REMOVE_BUTTON = 2;
1056 public static final int MW_POLICY_LIST = 3; // follows MW_PANEL
1057
1058 /* The preferred height of JTextField should match JComboBox. */
1059 static final int TEXTFIELD_HEIGHT = new JComboBox<>().getPreferredSize().height;
1060
1061 private PolicyTool tool;
1062
1063 /**
1064 * Constructor
1065 */
1066 ToolWindow(PolicyTool tool) {
1067 this.tool = tool;
1068 }
1069
1070 /**
1071 * Don't call getComponent directly on the window
1072 */
1073 public Component getComponent(int n) {
1074 Component c = getContentPane().getComponent(n);
1075 if (c instanceof JScrollPane) {
1076 c = ((JScrollPane)c).getViewport().getView();
1077 }
1078 return c;
1079 }
1080
1081 /**
1082 * Initialize the PolicyTool window with the necessary components
1083 */
1084 private void initWindow() {
1085 // The ToolWindowListener will handle closing the window.
1086 setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
1087
1088 // create the top menu bar
1089 JMenuBar menuBar = new JMenuBar();
1090
1091 // create a File menu
1092 JMenu menu = new JMenu();
1093 configureButton(menu, "File");
1094 ActionListener actionListener = new FileMenuListener(tool, this);
1095 addMenuItem(menu, NEW_POLICY_FILE, actionListener, "N");
1096 addMenuItem(menu, OPEN_POLICY_FILE, actionListener, "O");
1097 addMenuItem(menu, SAVE_POLICY_FILE, actionListener, "S");
1098 addMenuItem(menu, SAVE_AS_POLICY_FILE, actionListener, null);
1099 addMenuItem(menu, VIEW_WARNINGS, actionListener, null);
1100 addMenuItem(menu, QUIT, actionListener, null);
1101 menuBar.add(menu);
1102
1103 // create a KeyStore menu
1104 menu = new JMenu();
1105 configureButton(menu, "KeyStore");
1106 actionListener = new MainWindowListener(tool, this);
1107 addMenuItem(menu, EDIT_KEYSTORE, actionListener, null);
1108 menuBar.add(menu);
1109 setJMenuBar(menuBar);
1110
1111 // Create some space around components
1112 ((JPanel)getContentPane()).setBorder(new EmptyBorder(6, 6, 6, 6));
1113
1114 // policy entry listing
1115 JLabel label = new JLabel(PolicyTool.getMessage("Policy.File."));
1116 addNewComponent(this, label, MW_FILENAME_LABEL,
1117 0, 0, 1, 1, 0.0, 0.0, GridBagConstraints.BOTH,
1118 LR_TOP_BOTTOM_PADDING);
1119 JTextField tf = new JTextField(50);
1120 tf.setPreferredSize(new Dimension(tf.getPreferredSize().width, TEXTFIELD_HEIGHT));
1121 tf.getAccessibleContext().setAccessibleName(
1122 PolicyTool.getMessage("Policy.File."));
1123 tf.setEditable(false);
1124 addNewComponent(this, tf, MW_FILENAME_TEXTFIELD,
1125 1, 0, 1, 1, 0.0, 0.0, GridBagConstraints.BOTH,
1126 LR_TOP_BOTTOM_PADDING);
1127
1128
1129 // add ADD/REMOVE/EDIT buttons in a new panel
1130 JPanel panel = new JPanel();
1131 panel.setLayout(new GridBagLayout());
1132
1133 JButton button = new JButton();
1134 configureButton(button, ADD_POLICY_ENTRY);
1135 button.addActionListener(new MainWindowListener(tool, this));
1136 addNewComponent(panel, button, MW_ADD_BUTTON,
1137 0, 0, 1, 1, 0.0, 0.0, GridBagConstraints.BOTH,
1138 LR_PADDING);
1139
1140 button = new JButton();
1141 configureButton(button, EDIT_POLICY_ENTRY);
1142 button.addActionListener(new MainWindowListener(tool, this));
1143 addNewComponent(panel, button, MW_EDIT_BUTTON,
1144 1, 0, 1, 1, 0.0, 0.0, GridBagConstraints.BOTH,
1145 LR_PADDING);
1146
1147 button = new JButton();
1148 configureButton(button, REMOVE_POLICY_ENTRY);
1149 button.addActionListener(new MainWindowListener(tool, this));
1150 addNewComponent(panel, button, MW_REMOVE_BUTTON,
1151 2, 0, 1, 1, 0.0, 0.0, GridBagConstraints.BOTH,
1152 LR_PADDING);
1153
1154 addNewComponent(this, panel, MW_PANEL,
1155 0, 2, 2, 1, 0.0, 0.0, GridBagConstraints.BOTH,
1156 BOTTOM_PADDING);
1157
1158
1159 String policyFile = tool.getPolicyFileName();
1160 if (policyFile == null) {
1161 String userHome;
1162 userHome = java.security.AccessController.doPrivileged(
1163 (PrivilegedAction<String>) () -> System.getProperty("user.home"));
1164 policyFile = userHome + File.separatorChar + ".java.policy";
1165 }
1166
1167 try {
1168 // open the policy file
1169 tool.openPolicy(policyFile);
1170
1171 // display the policy entries via the policy list textarea
1172 DefaultListModel<String> listModel = new DefaultListModel<>();
1173 JList<String> list = new JList<>(listModel);
1174 list.setVisibleRowCount(15);
1175 list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
1176 list.addMouseListener(new PolicyListListener(tool, this));
1177 PolicyEntry entries[] = tool.getEntry();
1178 if (entries != null) {
1179 for (int i = 0; i < entries.length; i++) {
1180 listModel.addElement(entries[i].headerToString());
1181 }
1182 }
1183 JTextField newFilename = (JTextField)
1184 getComponent(MW_FILENAME_TEXTFIELD);
1185 newFilename.setText(policyFile);
1186 initPolicyList(list);
1187
1188 } catch (FileNotFoundException fnfe) {
1189 // add blank policy listing
1190 JList<String> list = new JList<>(new DefaultListModel<>());
1191 list.setVisibleRowCount(15);
1192 list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
1193 list.addMouseListener(new PolicyListListener(tool, this));
1194 initPolicyList(list);
1195 tool.setPolicyFileName(null);
1196 tool.modified = false;
1197
1198 // just add warning
1199 tool.warnings.addElement(fnfe.toString());
1200
1201 } catch (Exception e) {
1202 // add blank policy listing
1203 JList<String> list = new JList<>(new DefaultListModel<>());
1204 list.setVisibleRowCount(15);
1205 list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
1206 list.addMouseListener(new PolicyListListener(tool, this));
1207 initPolicyList(list);
1208 tool.setPolicyFileName(null);
1209 tool.modified = false;
1210
1211 // display the error
1212 MessageFormat form = new MessageFormat(PolicyTool.getMessage
1213 ("Could.not.open.policy.file.policyFile.e.toString."));
1214 Object[] source = {policyFile, e.toString()};
1215 displayErrorDialog(null, form.format(source));
1216 }
1217 }
1218
1219
1220 // Platform specific modifier (control / command).
1221 private int shortCutModifier = Toolkit.getDefaultToolkit().getMenuShortcutKeyMask();
1222
1223 private void addMenuItem(JMenu menu, String key, ActionListener actionListener, String accelerator) {
1224 JMenuItem menuItem = new JMenuItem();
1225 configureButton(menuItem, key);
1226
1227 if (PolicyTool.rb.containsKey(key + ".accelerator")) {
1228 // Accelerator from resources takes precedence
1229 accelerator = PolicyTool.getMessage(key + ".accelerator");
1230 }
1231
1232 if (accelerator != null && !accelerator.isEmpty()) {
1233 KeyStroke keyStroke;
1234 if (accelerator.length() == 1) {
1235 keyStroke = KeyStroke.getKeyStroke(KeyEvent.getExtendedKeyCodeForChar(accelerator.charAt(0)),
1236 shortCutModifier);
1237 } else {
1238 keyStroke = KeyStroke.getKeyStroke(accelerator);
1239 }
1240 menuItem.setAccelerator(keyStroke);
1241 }
1242
1243 menuItem.addActionListener(actionListener);
1244 menu.add(menuItem);
1245 }
1246
1247 static void configureButton(AbstractButton button, String key) {
1248 button.setText(PolicyTool.getMessage(key));
1249 button.setActionCommand(key);
1250
1251 int mnemonicInt = PolicyTool.getMnemonicInt(key);
1252 if (mnemonicInt > 0) {
1253 button.setMnemonic(mnemonicInt);
1254 button.setDisplayedMnemonicIndex(PolicyTool.getDisplayedMnemonicIndex(key));
1255 }
1256 }
1257
1258 static void configureLabelFor(JLabel label, JComponent component, String key) {
1259 label.setText(PolicyTool.getMessage(key));
1260 label.setLabelFor(component);
1261
1262 int mnemonicInt = PolicyTool.getMnemonicInt(key);
1263 if (mnemonicInt > 0) {
1264 label.setDisplayedMnemonic(mnemonicInt);
1265 label.setDisplayedMnemonicIndex(PolicyTool.getDisplayedMnemonicIndex(key));
1266 }
1267 }
1268
1269
1270 /**
1271 * Add a component to the PolicyTool window
1272 */
1273 void addNewComponent(Container container, JComponent component,
1274 int index, int gridx, int gridy, int gridwidth, int gridheight,
1275 double weightx, double weighty, int fill, Insets is) {
1276
1277 if (container instanceof JFrame) {
1278 container = ((JFrame)container).getContentPane();
1279 } else if (container instanceof JDialog) {
1280 container = ((JDialog)container).getContentPane();
1281 }
1282
1283 // add the component at the specified gridbag index
1284 container.add(component, index);
1285
1286 // set the constraints
1287 GridBagLayout gbl = (GridBagLayout)container.getLayout();
1288 GridBagConstraints gbc = new GridBagConstraints();
1289 gbc.gridx = gridx;
1290 gbc.gridy = gridy;
1291 gbc.gridwidth = gridwidth;
1292 gbc.gridheight = gridheight;
1293 gbc.weightx = weightx;
1294 gbc.weighty = weighty;
1295 gbc.fill = fill;
1296 if (is != null) gbc.insets = is;
1297 gbl.setConstraints(component, gbc);
1298 }
1299
1300
1301 /**
1302 * Add a component to the PolicyTool window without external padding
1303 */
1304 void addNewComponent(Container container, JComponent component,
1305 int index, int gridx, int gridy, int gridwidth, int gridheight,
1306 double weightx, double weighty, int fill) {
1307
1308 // delegate with "null" external padding
1309 addNewComponent(container, component, index, gridx, gridy,
1310 gridwidth, gridheight, weightx, weighty,
1311 fill, null);
1312 }
1313
1314
1315 /**
1316 * Init the policy_entry_list TEXTAREA component in the
1317 * PolicyTool window
1318 */
1319 void initPolicyList(JList<String> policyList) {
1320
1321 // add the policy list to the window
1322 //policyList.setPreferredSize(new Dimension(500, 350));
1323 JScrollPane scrollPane = new JScrollPane(policyList);
1324 addNewComponent(this, scrollPane, MW_POLICY_LIST,
1325 0, 3, 2, 1, 1.0, 1.0, GridBagConstraints.BOTH);
1326 }
1327
1328 /**
1329 * Replace the policy_entry_list TEXTAREA component in the
1330 * PolicyTool window with an updated one.
1331 */
1332 void replacePolicyList(JList<String> policyList) {
1333
1334 // remove the original list of Policy Entries
1335 // and add the new list of entries
1336 @SuppressWarnings("unchecked")
1337 JList<String> list = (JList<String>)getComponent(MW_POLICY_LIST);
1338 list.setModel(policyList.getModel());
1339 }
1340
1341 /**
1342 * display the main PolicyTool window
1343 */
1344 void displayToolWindow(String args[]) {
1345
1346 setTitle(PolicyTool.getMessage("Policy.Tool"));
1347 setResizable(true);
1348 addWindowListener(new ToolWindowListener(tool, this));
1349 //setBounds(135, 80, 500, 500);
1350 getContentPane().setLayout(new GridBagLayout());
1351
1352 initWindow();
1353 pack();
1354 setLocationRelativeTo(null);
1355
1356 // display it
1357 setVisible(true);
1358
1359 if (tool.newWarning == true) {
1360 displayStatusDialog(this, PolicyTool.getMessage
1361 ("Errors.have.occurred.while.opening.the.policy.configuration.View.the.Warning.Log.for.more.information."));
1362 }
1363 }
1364
1365 /**
1366 * displays a dialog box describing an error which occurred.
1367 */
1368 void displayErrorDialog(Window w, String error) {
1369 ToolDialog ed = new ToolDialog
1370 (PolicyTool.getMessage("Error"), tool, this, true);
1371
1372 // find where the PolicyTool gui is
1373 Point location = ((w == null) ?
1374 getLocationOnScreen() : w.getLocationOnScreen());
1375 //ed.setBounds(location.x + 50, location.y + 50, 600, 100);
1376 ed.setLayout(new GridBagLayout());
1377
1378 JLabel label = new JLabel(error);
1379 addNewComponent(ed, label, 0,
1380 0, 0, 1, 1, 0.0, 0.0, GridBagConstraints.BOTH);
1381
1382 JButton okButton = new JButton(PolicyTool.getMessage("OK"));
1383 ActionListener okListener = new ErrorOKButtonListener(ed);
1384 okButton.addActionListener(okListener);
1385 addNewComponent(ed, okButton, 1,
1386 0, 1, 1, 1, 0.0, 0.0, GridBagConstraints.VERTICAL);
1387
1388 ed.getRootPane().setDefaultButton(okButton);
1389 ed.getRootPane().registerKeyboardAction(okListener, escKey, JComponent.WHEN_IN_FOCUSED_WINDOW);
1390
1391 ed.pack();
1392 ed.setLocationRelativeTo(w);
1393 ed.setVisible(true);
1394 }
1395
1396 /**
1397 * displays a dialog box describing an error which occurred.
1398 */
1399 void displayErrorDialog(Window w, Throwable t) {
1400 if (t instanceof NoDisplayException) {
1401 return;
1402 }
1403 displayErrorDialog(w, t.toString());
1404 }
1405
1406 /**
1407 * displays a dialog box describing the status of an event
1408 */
1409 void displayStatusDialog(Window w, String status) {
1410 ToolDialog sd = new ToolDialog
1411 (PolicyTool.getMessage("Status"), tool, this, true);
1412
1413 // find the location of the PolicyTool gui
1414 Point location = ((w == null) ?
1415 getLocationOnScreen() : w.getLocationOnScreen());
1416 //sd.setBounds(location.x + 50, location.y + 50, 500, 100);
1417 sd.setLayout(new GridBagLayout());
1418
1419 JLabel label = new JLabel(status);
1420 addNewComponent(sd, label, 0,
1421 0, 0, 1, 1, 0.0, 0.0, GridBagConstraints.BOTH);
1422
1423 JButton okButton = new JButton(PolicyTool.getMessage("OK"));
1424 ActionListener okListener = new StatusOKButtonListener(sd);
1425 okButton.addActionListener(okListener);
1426 addNewComponent(sd, okButton, 1,
1427 0, 1, 1, 1, 0.0, 0.0, GridBagConstraints.VERTICAL);
1428
1429 sd.getRootPane().setDefaultButton(okButton);
1430 sd.getRootPane().registerKeyboardAction(okListener, escKey, JComponent.WHEN_IN_FOCUSED_WINDOW);
1431
1432 sd.pack();
1433 sd.setLocationRelativeTo(w);
1434 sd.setVisible(true);
1435 }
1436
1437 /**
1438 * display the warning log
1439 */
1440 void displayWarningLog(Window w) {
1441
1442 ToolDialog wd = new ToolDialog
1443 (PolicyTool.getMessage("Warning"), tool, this, true);
1444
1445 // find the location of the PolicyTool gui
1446 Point location = ((w == null) ?
1447 getLocationOnScreen() : w.getLocationOnScreen());
1448 //wd.setBounds(location.x + 50, location.y + 50, 500, 100);
1449 wd.setLayout(new GridBagLayout());
1450
1451 JTextArea ta = new JTextArea();
1452 ta.setEditable(false);
1453 for (int i = 0; i < tool.warnings.size(); i++) {
1454 ta.append(tool.warnings.elementAt(i));
1455 ta.append(PolicyTool.getMessage("NEWLINE"));
1456 }
1457 addNewComponent(wd, ta, 0,
1458 0, 0, 1, 1, 0.0, 0.0, GridBagConstraints.BOTH,
1459 BOTTOM_PADDING);
1460 ta.setFocusable(false);
1461
1462 JButton okButton = new JButton(PolicyTool.getMessage("OK"));
1463 ActionListener okListener = new CancelButtonListener(wd);
1464 okButton.addActionListener(okListener);
1465 addNewComponent(wd, okButton, 1,
1466 0, 1, 1, 1, 0.0, 0.0, GridBagConstraints.VERTICAL,
1467 LR_PADDING);
1468
1469 wd.getRootPane().setDefaultButton(okButton);
1470 wd.getRootPane().registerKeyboardAction(okListener, escKey, JComponent.WHEN_IN_FOCUSED_WINDOW);
1471
1472 wd.pack();
1473 wd.setLocationRelativeTo(w);
1474 wd.setVisible(true);
1475 }
1476
1477 char displayYesNoDialog(Window w, String title, String prompt, String yes, String no) {
1478
1479 final ToolDialog tw = new ToolDialog
1480 (title, tool, this, true);
1481 Point location = ((w == null) ?
1482 getLocationOnScreen() : w.getLocationOnScreen());
1483 //tw.setBounds(location.x + 75, location.y + 100, 400, 150);
1484 tw.setLayout(new GridBagLayout());
1485
1486 JTextArea ta = new JTextArea(prompt, 10, 50);
1487 ta.setEditable(false);
1488 ta.setLineWrap(true);
1489 ta.setWrapStyleWord(true);
1490 JScrollPane scrollPane = new JScrollPane(ta,
1491 JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,
1492 JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
1493 addNewComponent(tw, scrollPane, 0,
1494 0, 0, 1, 1, 0.0, 0.0, GridBagConstraints.BOTH);
1495 ta.setFocusable(false);
1496
1497 JPanel panel = new JPanel();
1498 panel.setLayout(new GridBagLayout());
1499
1500 // StringBuffer to store button press. Must be final.
1501 final StringBuffer chooseResult = new StringBuffer();
1502
1503 JButton button = new JButton(yes);
1504 button.addActionListener(new ActionListener() {
1505 public void actionPerformed(ActionEvent e) {
1506 chooseResult.append('Y');
1507 tw.setVisible(false);
1508 tw.dispose();
1509 }
1510 });
1511 addNewComponent(panel, button, 0,
1512 0, 0, 1, 1, 0.0, 0.0, GridBagConstraints.VERTICAL,
1513 LR_PADDING);
1514
1515 button = new JButton(no);
1516 button.addActionListener(new ActionListener() {
1517 public void actionPerformed(ActionEvent e) {
1518 chooseResult.append('N');
1519 tw.setVisible(false);
1520 tw.dispose();
1521 }
1522 });
1523 addNewComponent(panel, button, 1,
1524 1, 0, 1, 1, 0.0, 0.0, GridBagConstraints.VERTICAL,
1525 LR_PADDING);
1526
1527 addNewComponent(tw, panel, 1,
1528 0, 1, 1, 1, 0.0, 0.0, GridBagConstraints.VERTICAL);
1529
1530 tw.pack();
1531 tw.setLocationRelativeTo(w);
1532 tw.setVisible(true);
1533 if (chooseResult.length() > 0) {
1534 return chooseResult.charAt(0);
1535 } else {
1536 // I did encounter this once, don't why.
1537 return 'N';
1538 }
1539 }
1540
1541 }
1542
1543 /**
1544 * General dialog window
1545 */
1546 class ToolDialog extends JDialog {
1547 // use serialVersionUID from JDK 1.2.2 for interoperability
1548 private static final long serialVersionUID = -372244357011301190L;
1549
1550 /* ESCAPE key */
1551 static final KeyStroke escKey = KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0);
1552
1553 /* necessary constants */
1554 public static final int NOACTION = 0;
1555 public static final int QUIT = 1;
1556 public static final int NEW = 2;
1557 public static final int OPEN = 3;
1558
1559 public static final String ALL_PERM_CLASS =
1560 "java.security.AllPermission";
1561 public static final String FILE_PERM_CLASS =
1562 "java.io.FilePermission";
1563
1564 public static final String X500_PRIN_CLASS =
1565 "javax.security.auth.x500.X500Principal";
1566
1567 /* popup menus */
1568 public static final String PERM =
1569 PolicyTool.getMessage
1570 ("Permission.");
1571
1572 public static final String PRIN_TYPE =
1573 PolicyTool.getMessage("Principal.Type.");
1574 public static final String PRIN_NAME =
1575 PolicyTool.getMessage("Principal.Name.");
1576
1577 /* more popu menus */
1578 public static final String PERM_NAME =
1579 PolicyTool.getMessage
1580 ("Target.Name.");
1581
1582 /* and more popup menus */
1583 public static final String PERM_ACTIONS =
1584 PolicyTool.getMessage
1585 ("Actions.");
1586
1587 /* gridbag index for display PolicyEntry (PE) components */
1588 public static final int PE_CODEBASE_LABEL = 0;
1589 public static final int PE_CODEBASE_TEXTFIELD = 1;
1590 public static final int PE_SIGNEDBY_LABEL = 2;
1591 public static final int PE_SIGNEDBY_TEXTFIELD = 3;
1592
1593 public static final int PE_PANEL0 = 4;
1594 public static final int PE_ADD_PRIN_BUTTON = 0;
1595 public static final int PE_EDIT_PRIN_BUTTON = 1;
1596 public static final int PE_REMOVE_PRIN_BUTTON = 2;
1597
1598 public static final int PE_PRIN_LABEL = 5;
1599 public static final int PE_PRIN_LIST = 6;
1600
1601 public static final int PE_PANEL1 = 7;
1602 public static final int PE_ADD_PERM_BUTTON = 0;
1603 public static final int PE_EDIT_PERM_BUTTON = 1;
1604 public static final int PE_REMOVE_PERM_BUTTON = 2;
1605
1606 public static final int PE_PERM_LIST = 8;
1607
1608 public static final int PE_PANEL2 = 9;
1609 public static final int PE_CANCEL_BUTTON = 1;
1610 public static final int PE_DONE_BUTTON = 0;
1611
1612 /* the gridbag index for components in the Principal Dialog (PRD) */
1613 public static final int PRD_DESC_LABEL = 0;
1614 public static final int PRD_PRIN_CHOICE = 1;
1615 public static final int PRD_PRIN_TEXTFIELD = 2;
1616 public static final int PRD_NAME_LABEL = 3;
1617 public static final int PRD_NAME_TEXTFIELD = 4;
1618 public static final int PRD_CANCEL_BUTTON = 6;
1619 public static final int PRD_OK_BUTTON = 5;
1620
1621 /* the gridbag index for components in the Permission Dialog (PD) */
1622 public static final int PD_DESC_LABEL = 0;
1623 public static final int PD_PERM_CHOICE = 1;
1624 public static final int PD_PERM_TEXTFIELD = 2;
1625 public static final int PD_NAME_CHOICE = 3;
1626 public static final int PD_NAME_TEXTFIELD = 4;
1627 public static final int PD_ACTIONS_CHOICE = 5;
1628 public static final int PD_ACTIONS_TEXTFIELD = 6;
1629 public static final int PD_SIGNEDBY_LABEL = 7;
1630 public static final int PD_SIGNEDBY_TEXTFIELD = 8;
1631 public static final int PD_CANCEL_BUTTON = 10;
1632 public static final int PD_OK_BUTTON = 9;
1633
1634 /* modes for KeyStore */
1635 public static final int EDIT_KEYSTORE = 0;
1636
1637 /* the gridbag index for components in the Change KeyStore Dialog (KSD) */
1638 public static final int KSD_NAME_LABEL = 0;
1639 public static final int KSD_NAME_TEXTFIELD = 1;
1640 public static final int KSD_TYPE_LABEL = 2;
1641 public static final int KSD_TYPE_TEXTFIELD = 3;
1642 public static final int KSD_PROVIDER_LABEL = 4;
1643 public static final int KSD_PROVIDER_TEXTFIELD = 5;
1644 public static final int KSD_PWD_URL_LABEL = 6;
1645 public static final int KSD_PWD_URL_TEXTFIELD = 7;
1646 public static final int KSD_CANCEL_BUTTON = 9;
1647 public static final int KSD_OK_BUTTON = 8;
1648
1649 /* the gridbag index for components in the User Save Changes Dialog (USC) */
1650 public static final int USC_LABEL = 0;
1651 public static final int USC_PANEL = 1;
1652 public static final int USC_YES_BUTTON = 0;
1653 public static final int USC_NO_BUTTON = 1;
1654 public static final int USC_CANCEL_BUTTON = 2;
1655
1656 /* gridbag index for the ConfirmRemovePolicyEntryDialog (CRPE) */
1657 public static final int CRPE_LABEL1 = 0;
1658 public static final int CRPE_LABEL2 = 1;
1659 public static final int CRPE_PANEL = 2;
1660 public static final int CRPE_PANEL_OK = 0;
1661 public static final int CRPE_PANEL_CANCEL = 1;
1662
1663 /* some private static finals */
1664 private static final int PERMISSION = 0;
1665 private static final int PERMISSION_NAME = 1;
1666 private static final int PERMISSION_ACTIONS = 2;
1667 private static final int PERMISSION_SIGNEDBY = 3;
1668 private static final int PRINCIPAL_TYPE = 4;
1669 private static final int PRINCIPAL_NAME = 5;
1670
1671 /* The preferred height of JTextField should match JComboBox. */
1672 static final int TEXTFIELD_HEIGHT = new JComboBox<>().getPreferredSize().height;
1673
1674 public static java.util.ArrayList<Perm> PERM_ARRAY;
1675 public static java.util.ArrayList<Prin> PRIN_ARRAY;
1676 PolicyTool tool;
1677 ToolWindow tw;
1678
1679 static {
1680
1681 // set up permission objects
1682
1683 PERM_ARRAY = new java.util.ArrayList<Perm>();
1684 PERM_ARRAY.add(new AllPerm());
1685 PERM_ARRAY.add(new AudioPerm());
1686 PERM_ARRAY.add(new AuthPerm());
1687 PERM_ARRAY.add(new AWTPerm());
1688 PERM_ARRAY.add(new DelegationPerm());
1689 PERM_ARRAY.add(new FilePerm());
1690 PERM_ARRAY.add(new URLPerm());
1691 PERM_ARRAY.add(new InqSecContextPerm());
1692 PERM_ARRAY.add(new LogPerm());
1693 PERM_ARRAY.add(new MgmtPerm());
1694 PERM_ARRAY.add(new MBeanPerm());
1695 PERM_ARRAY.add(new MBeanSvrPerm());
1696 PERM_ARRAY.add(new MBeanTrustPerm());
1697 PERM_ARRAY.add(new NetPerm());
1698 PERM_ARRAY.add(new PrivCredPerm());
1699 PERM_ARRAY.add(new PropPerm());
1700 PERM_ARRAY.add(new ReflectPerm());
1701 PERM_ARRAY.add(new RuntimePerm());
1702 PERM_ARRAY.add(new SecurityPerm());
1703 PERM_ARRAY.add(new SerialPerm());
1704 PERM_ARRAY.add(new ServicePerm());
1705 PERM_ARRAY.add(new SocketPerm());
1706 PERM_ARRAY.add(new SQLPerm());
1707 PERM_ARRAY.add(new SSLPerm());
1708 PERM_ARRAY.add(new SubjDelegPerm());
1709
1710 // set up principal objects
1711
1712 PRIN_ARRAY = new java.util.ArrayList<Prin>();
1713 PRIN_ARRAY.add(new KrbPrin());
1714 PRIN_ARRAY.add(new X500Prin());
1715 }
1716
1717 ToolDialog(String title, PolicyTool tool, ToolWindow tw, boolean modal) {
1718 super(tw, modal);
1719 setTitle(title);
1720 this.tool = tool;
1721 this.tw = tw;
1722 addWindowListener(new ChildWindowListener(this));
1723
1724 // Create some space around components
1725 ((JPanel)getContentPane()).setBorder(new EmptyBorder(6, 6, 6, 6));
1726 }
1727
1728 /**
1729 * Don't call getComponent directly on the window
1730 */
1731 public Component getComponent(int n) {
1732 Component c = getContentPane().getComponent(n);
1733 if (c instanceof JScrollPane) {
1734 c = ((JScrollPane)c).getViewport().getView();
1735 }
1736 return c;
1737 }
1738
1739 /**
1740 * get the Perm instance based on either the (shortened) class name
1741 * or the fully qualified class name
1742 */
1743 static Perm getPerm(String clazz, boolean fullClassName) {
1744 for (int i = 0; i < PERM_ARRAY.size(); i++) {
1745 Perm next = PERM_ARRAY.get(i);
1746 if (fullClassName) {
1747 if (next.FULL_CLASS.equals(clazz)) {
1748 return next;
1749 }
1750 } else {
1751 if (next.CLASS.equals(clazz)) {
1752 return next;
1753 }
1754 }
1755 }
1756 return null;
1757 }
1758
1759 /**
1760 * get the Prin instance based on either the (shortened) class name
1761 * or the fully qualified class name
1762 */
1763 static Prin getPrin(String clazz, boolean fullClassName) {
1764 for (int i = 0; i < PRIN_ARRAY.size(); i++) {
1765 Prin next = PRIN_ARRAY.get(i);
1766 if (fullClassName) {
1767 if (next.FULL_CLASS.equals(clazz)) {
1768 return next;
1769 }
1770 } else {
1771 if (next.CLASS.equals(clazz)) {
1772 return next;
1773 }
1774 }
1775 }
1776 return null;
1777 }
1778
1779 /**
1780 * pop up a dialog so the user can enter info to add a new PolicyEntry
1781 * - if edit is TRUE, then the user is editing an existing entry
1782 * and we should display the original info as well.
1783 *
1784 * - the other reason we need the 'edit' boolean is we need to know
1785 * when we are adding a NEW policy entry. in this case, we can
1786 * not simply update the existing entry, because it doesn't exist.
1787 * we ONLY update the GUI listing/info, and then when the user
1788 * finally clicks 'OK' or 'DONE', then we can collect that info
1789 * and add it to the policy.
1790 */
1791 void displayPolicyEntryDialog(boolean edit) {
1792
1793 int listIndex = 0;
1794 PolicyEntry entries[] = null;
1795 TaggedList prinList = new TaggedList(3, false);
1796 prinList.getAccessibleContext().setAccessibleName(
1797 PolicyTool.getMessage("Principal.List"));
1798 prinList.addMouseListener
1799 (new EditPrinButtonListener(tool, tw, this, edit));
1800 TaggedList permList = new TaggedList(10, false);
1801 permList.getAccessibleContext().setAccessibleName(
1802 PolicyTool.getMessage("Permission.List"));
1803 permList.addMouseListener
1804 (new EditPermButtonListener(tool, tw, this, edit));
1805
1806 // find where the PolicyTool gui is
1807 Point location = tw.getLocationOnScreen();
1808 //setBounds(location.x + 75, location.y + 200, 650, 500);
1809 setLayout(new GridBagLayout());
1810 setResizable(true);
1811
1812 if (edit) {
1813 // get the selected item
1814 entries = tool.getEntry();
1815 @SuppressWarnings("unchecked")
1816 JList<String> policyList = (JList<String>)tw.getComponent(ToolWindow.MW_POLICY_LIST);
1817 listIndex = policyList.getSelectedIndex();
1818
1819 // get principal list
1820 LinkedList<PolicyParser.PrincipalEntry> principals =
1821 entries[listIndex].getGrantEntry().principals;
1822 for (int i = 0; i < principals.size(); i++) {
1823 String prinString = null;
1824 PolicyParser.PrincipalEntry nextPrin = principals.get(i);
1825 prinList.addTaggedItem(PrincipalEntryToUserFriendlyString(nextPrin), nextPrin);
1826 }
1827
1828 // get permission list
1829 Vector<PolicyParser.PermissionEntry> permissions =
1830 entries[listIndex].getGrantEntry().permissionEntries;
1831 for (int i = 0; i < permissions.size(); i++) {
1832 String permString = null;
1833 PolicyParser.PermissionEntry nextPerm =
1834 permissions.elementAt(i);
1835 permList.addTaggedItem(ToolDialog.PermissionEntryToUserFriendlyString(nextPerm), nextPerm);
1836 }
1837 }
1838
1839 // codebase label and textfield
1840 JLabel label = new JLabel();
1841 tw.addNewComponent(this, label, PE_CODEBASE_LABEL,
1842 0, 0, 1, 1, 0.0, 0.0, GridBagConstraints.BOTH,
1843 ToolWindow.R_PADDING);
1844 JTextField tf;
1845 tf = (edit ?
1846 new JTextField(entries[listIndex].getGrantEntry().codeBase) :
1847 new JTextField());
1848 ToolWindow.configureLabelFor(label, tf, "CodeBase.");
1849 tf.setPreferredSize(new Dimension(tf.getPreferredSize().width, TEXTFIELD_HEIGHT));
1850 tf.getAccessibleContext().setAccessibleName(
1851 PolicyTool.getMessage("Code.Base"));
1852 tw.addNewComponent(this, tf, PE_CODEBASE_TEXTFIELD,
1853 1, 0, 1, 1, 1.0, 0.0, GridBagConstraints.BOTH);
1854
1855 // signedby label and textfield
1856 label = new JLabel();
1857 tw.addNewComponent(this, label, PE_SIGNEDBY_LABEL,
1858 0, 1, 1, 1, 0.0, 0.0, GridBagConstraints.BOTH,
1859 ToolWindow.R_PADDING);
1860 tf = (edit ?
1861 new JTextField(entries[listIndex].getGrantEntry().signedBy) :
1862 new JTextField());
1863 ToolWindow.configureLabelFor(label, tf, "SignedBy.");
1864 tf.setPreferredSize(new Dimension(tf.getPreferredSize().width, TEXTFIELD_HEIGHT));
1865 tf.getAccessibleContext().setAccessibleName(
1866 PolicyTool.getMessage("Signed.By."));
1867 tw.addNewComponent(this, tf, PE_SIGNEDBY_TEXTFIELD,
1868 1, 1, 1, 1, 1.0, 0.0, GridBagConstraints.BOTH);
1869
1870 // panel for principal buttons
1871 JPanel panel = new JPanel();
1872 panel.setLayout(new GridBagLayout());
1873
1874 JButton button = new JButton();
1875 ToolWindow.configureButton(button, "Add.Principal");
1876 button.addActionListener
1877 (new AddPrinButtonListener(tool, tw, this, edit));
1878 tw.addNewComponent(panel, button, PE_ADD_PRIN_BUTTON,
1879 0, 0, 1, 1, 100.0, 0.0, GridBagConstraints.HORIZONTAL);
1880
1881 button = new JButton();
1882 ToolWindow.configureButton(button, "Edit.Principal");
1883 button.addActionListener(new EditPrinButtonListener
1884 (tool, tw, this, edit));
1885 tw.addNewComponent(panel, button, PE_EDIT_PRIN_BUTTON,
1886 1, 0, 1, 1, 100.0, 0.0, GridBagConstraints.HORIZONTAL);
1887
1888 button = new JButton();
1889 ToolWindow.configureButton(button, "Remove.Principal");
1890 button.addActionListener(new RemovePrinButtonListener
1891 (tool, tw, this, edit));
1892 tw.addNewComponent(panel, button, PE_REMOVE_PRIN_BUTTON,
1893 2, 0, 1, 1, 100.0, 0.0, GridBagConstraints.HORIZONTAL);
1894
1895 tw.addNewComponent(this, panel, PE_PANEL0,
1896 1, 2, 1, 1, 0.0, 0.0, GridBagConstraints.HORIZONTAL,
1897 ToolWindow.LITE_BOTTOM_PADDING);
1898
1899 // principal label and list
1900 label = new JLabel();
1901 tw.addNewComponent(this, label, PE_PRIN_LABEL,
1902 0, 3, 1, 1, 0.0, 0.0, GridBagConstraints.BOTH,
1903 ToolWindow.R_BOTTOM_PADDING);
1904 JScrollPane scrollPane = new JScrollPane(prinList);
1905 ToolWindow.configureLabelFor(label, scrollPane, "Principals.");
1906 tw.addNewComponent(this, scrollPane, PE_PRIN_LIST,
1907 1, 3, 3, 1, 0.0, prinList.getVisibleRowCount(), GridBagConstraints.BOTH,
1908 ToolWindow.BOTTOM_PADDING);
1909
1910 // panel for permission buttons
1911 panel = new JPanel();
1912 panel.setLayout(new GridBagLayout());
1913
1914 button = new JButton();
1915 ToolWindow.configureButton(button, ".Add.Permission");
1916 button.addActionListener(new AddPermButtonListener
1917 (tool, tw, this, edit));
1918 tw.addNewComponent(panel, button, PE_ADD_PERM_BUTTON,
1919 0, 0, 1, 1, 100.0, 0.0, GridBagConstraints.HORIZONTAL);
1920
1921 button = new JButton();
1922 ToolWindow.configureButton(button, ".Edit.Permission");
1923 button.addActionListener(new EditPermButtonListener
1924 (tool, tw, this, edit));
1925 tw.addNewComponent(panel, button, PE_EDIT_PERM_BUTTON,
1926 1, 0, 1, 1, 100.0, 0.0, GridBagConstraints.HORIZONTAL);
1927
1928
1929 button = new JButton();
1930 ToolWindow.configureButton(button, "Remove.Permission");
1931 button.addActionListener(new RemovePermButtonListener
1932 (tool, tw, this, edit));
1933 tw.addNewComponent(panel, button, PE_REMOVE_PERM_BUTTON,
1934 2, 0, 1, 1, 100.0, 0.0, GridBagConstraints.HORIZONTAL);
1935
1936 tw.addNewComponent(this, panel, PE_PANEL1,
1937 0, 4, 2, 1, 0.0, 0.0, GridBagConstraints.HORIZONTAL,
1938 ToolWindow.LITE_BOTTOM_PADDING);
1939
1940 // permission list
1941 scrollPane = new JScrollPane(permList);
1942 tw.addNewComponent(this, scrollPane, PE_PERM_LIST,
1943 0, 5, 3, 1, 0.0, permList.getVisibleRowCount(), GridBagConstraints.BOTH,
1944 ToolWindow.BOTTOM_PADDING);
1945
1946
1947 // panel for Done and Cancel buttons
1948 panel = new JPanel();
1949 panel.setLayout(new GridBagLayout());
1950
1951 // Done Button
1952 JButton okButton = new JButton(PolicyTool.getMessage("Done"));
1953 okButton.addActionListener
1954 (new AddEntryDoneButtonListener(tool, tw, this, edit));
1955 tw.addNewComponent(panel, okButton, PE_DONE_BUTTON,
1956 0, 0, 1, 1, 0.0, 0.0, GridBagConstraints.VERTICAL,
1957 ToolWindow.LR_PADDING);
1958
1959 // Cancel Button
1960 JButton cancelButton = new JButton(PolicyTool.getMessage("Cancel"));
1961 ActionListener cancelListener = new CancelButtonListener(this);
1962 cancelButton.addActionListener(cancelListener);
1963 tw.addNewComponent(panel, cancelButton, PE_CANCEL_BUTTON,
1964 1, 0, 1, 1, 0.0, 0.0, GridBagConstraints.VERTICAL,
1965 ToolWindow.LR_PADDING);
1966
1967 // add the panel
1968 tw.addNewComponent(this, panel, PE_PANEL2,
1969 0, 6, 2, 1, 0.0, 0.0, GridBagConstraints.VERTICAL);
1970
1971 getRootPane().setDefaultButton(okButton);
1972 getRootPane().registerKeyboardAction(cancelListener, escKey, JComponent.WHEN_IN_FOCUSED_WINDOW);
1973
1974 pack();
1975 setLocationRelativeTo(tw);
1976 setVisible(true);
1977 }
1978
1979 /**
1980 * Read all the Policy information data in the dialog box
1981 * and construct a PolicyEntry object with it.
1982 */
1983 PolicyEntry getPolicyEntryFromDialog()
1984 throws InvalidParameterException, MalformedURLException,
1985 NoSuchMethodException, ClassNotFoundException, InstantiationException,
1986 IllegalAccessException, InvocationTargetException,
1987 CertificateException, IOException, Exception {
1988
1989 // get the Codebase
1990 JTextField tf = (JTextField)getComponent(PE_CODEBASE_TEXTFIELD);
1991 String codebase = null;
1992 if (tf.getText().trim().equals("") == false)
1993 codebase = new String(tf.getText().trim());
1994
1995 // get the SignedBy
1996 tf = (JTextField)getComponent(PE_SIGNEDBY_TEXTFIELD);
1997 String signedby = null;
1998 if (tf.getText().trim().equals("") == false)
1999 signedby = new String(tf.getText().trim());
2000
2001 // construct a new GrantEntry
2002 PolicyParser.GrantEntry ge =
2003 new PolicyParser.GrantEntry(signedby, codebase);
2004
2005 // get the new Principals
2006 LinkedList<PolicyParser.PrincipalEntry> prins = new LinkedList<>();
2007 TaggedList prinList = (TaggedList)getComponent(PE_PRIN_LIST);
2008 for (int i = 0; i < prinList.getModel().getSize(); i++) {
2009 prins.add((PolicyParser.PrincipalEntry)prinList.getObject(i));
2010 }
2011 ge.principals = prins;
2012
2013 // get the new Permissions
2014 Vector<PolicyParser.PermissionEntry> perms = new Vector<>();
2015 TaggedList permList = (TaggedList)getComponent(PE_PERM_LIST);
2016 for (int i = 0; i < permList.getModel().getSize(); i++) {
2017 perms.addElement((PolicyParser.PermissionEntry)permList.getObject(i));
2018 }
2019 ge.permissionEntries = perms;
2020
2021 // construct a new PolicyEntry object
2022 PolicyEntry entry = new PolicyEntry(tool, ge);
2023
2024 return entry;
2025 }
2026
2027 /**
2028 * display a dialog box for the user to enter KeyStore information
2029 */
2030 void keyStoreDialog(int mode) {
2031
2032 // find where the PolicyTool gui is
2033 Point location = tw.getLocationOnScreen();
2034 //setBounds(location.x + 25, location.y + 100, 500, 300);
2035 setLayout(new GridBagLayout());
2036
2037 if (mode == EDIT_KEYSTORE) {
2038
2039 // KeyStore label and textfield
2040 JLabel label = new JLabel();
2041 tw.addNewComponent(this, label, KSD_NAME_LABEL,
2042 0, 0, 1, 1, 0.0, 0.0, GridBagConstraints.BOTH,
2043 ToolWindow.R_BOTTOM_PADDING);
2044 JTextField tf = new JTextField(tool.getKeyStoreName(), 30);
2045 ToolWindow.configureLabelFor(label, tf, "KeyStore.URL.");
2046 tf.setPreferredSize(new Dimension(tf.getPreferredSize().width, TEXTFIELD_HEIGHT));
2047
2048 // URL to U R L, so that accessibility reader will pronounce well
2049 tf.getAccessibleContext().setAccessibleName(
2050 PolicyTool.getMessage("KeyStore.U.R.L."));
2051 tw.addNewComponent(this, tf, KSD_NAME_TEXTFIELD,
2052 1, 0, 1, 1, 1.0, 0.0, GridBagConstraints.BOTH,
2053 ToolWindow.BOTTOM_PADDING);
2054
2055 // KeyStore type and textfield
2056 label = new JLabel();
2057 tw.addNewComponent(this, label, KSD_TYPE_LABEL,
2058 0, 1, 1, 1, 0.0, 0.0, GridBagConstraints.BOTH,
2059 ToolWindow.R_BOTTOM_PADDING);
2060 tf = new JTextField(tool.getKeyStoreType(), 30);
2061 ToolWindow.configureLabelFor(label, tf, "KeyStore.Type.");
2062 tf.setPreferredSize(new Dimension(tf.getPreferredSize().width, TEXTFIELD_HEIGHT));
2063 tf.getAccessibleContext().setAccessibleName(
2064 PolicyTool.getMessage("KeyStore.Type."));
2065 tw.addNewComponent(this, tf, KSD_TYPE_TEXTFIELD,
2066 1, 1, 1, 1, 1.0, 0.0, GridBagConstraints.BOTH,
2067 ToolWindow.BOTTOM_PADDING);
2068
2069 // KeyStore provider and textfield
2070 label = new JLabel();
2071 tw.addNewComponent(this, label, KSD_PROVIDER_LABEL,
2072 0, 2, 1, 1, 0.0, 0.0, GridBagConstraints.BOTH,
2073 ToolWindow.R_BOTTOM_PADDING);
2074 tf = new JTextField(tool.getKeyStoreProvider(), 30);
2075 ToolWindow.configureLabelFor(label, tf, "KeyStore.Provider.");
2076 tf.setPreferredSize(new Dimension(tf.getPreferredSize().width, TEXTFIELD_HEIGHT));
2077 tf.getAccessibleContext().setAccessibleName(
2078 PolicyTool.getMessage("KeyStore.Provider."));
2079 tw.addNewComponent(this, tf, KSD_PROVIDER_TEXTFIELD,
2080 1, 2, 1, 1, 1.0, 0.0, GridBagConstraints.BOTH,
2081 ToolWindow.BOTTOM_PADDING);
2082
2083 // KeyStore password URL and textfield
2084 label = new JLabel();
2085 tw.addNewComponent(this, label, KSD_PWD_URL_LABEL,
2086 0, 3, 1, 1, 0.0, 0.0, GridBagConstraints.BOTH,
2087 ToolWindow.R_BOTTOM_PADDING);
2088 tf = new JTextField(tool.getKeyStorePwdURL(), 30);
2089 ToolWindow.configureLabelFor(label, tf, "KeyStore.Password.URL.");
2090 tf.setPreferredSize(new Dimension(tf.getPreferredSize().width, TEXTFIELD_HEIGHT));
2091 tf.getAccessibleContext().setAccessibleName(
2092 PolicyTool.getMessage("KeyStore.Password.U.R.L."));
2093 tw.addNewComponent(this, tf, KSD_PWD_URL_TEXTFIELD,
2094 1, 3, 1, 1, 1.0, 0.0, GridBagConstraints.BOTH,
2095 ToolWindow.BOTTOM_PADDING);
2096
2097 // OK button
2098 JButton okButton = new JButton(PolicyTool.getMessage("OK"));
2099 okButton.addActionListener
2100 (new ChangeKeyStoreOKButtonListener(tool, tw, this));
2101 tw.addNewComponent(this, okButton, KSD_OK_BUTTON,
2102 0, 4, 1, 1, 0.0, 0.0, GridBagConstraints.VERTICAL);
2103
2104 // cancel button
2105 JButton cancelButton = new JButton(PolicyTool.getMessage("Cancel"));
2106 ActionListener cancelListener = new CancelButtonListener(this);
2107 cancelButton.addActionListener(cancelListener);
2108 tw.addNewComponent(this, cancelButton, KSD_CANCEL_BUTTON,
2109 1, 4, 1, 1, 0.0, 0.0, GridBagConstraints.VERTICAL);
2110
2111 getRootPane().setDefaultButton(okButton);
2112 getRootPane().registerKeyboardAction(cancelListener, escKey, JComponent.WHEN_IN_FOCUSED_WINDOW);
2113 }
2114
2115 pack();
2116 setLocationRelativeTo(tw);
2117 setVisible(true);
2118 }
2119
2120 /**
2121 * display a dialog box for the user to input Principal info
2122 *
2123 * if editPolicyEntry is false, then we are adding Principals to
2124 * a new PolicyEntry, and we only update the GUI listing
2125 * with the new Principal.
2126 *
2127 * if edit is true, then we are editing an existing Policy entry.
2128 */
2129 void displayPrincipalDialog(boolean editPolicyEntry, boolean edit) {
2130
2131 PolicyParser.PrincipalEntry editMe = null;
2132
2133 // get the Principal selected from the Principal List
2134 TaggedList prinList = (TaggedList)getComponent(PE_PRIN_LIST);
2135 int prinIndex = prinList.getSelectedIndex();
2136
2137 if (edit) {
2138 editMe = (PolicyParser.PrincipalEntry)prinList.getObject(prinIndex);
2139 }
2140
2141 ToolDialog newTD = new ToolDialog
2142 (PolicyTool.getMessage("Principals"), tool, tw, true);
2143 newTD.addWindowListener(new ChildWindowListener(newTD));
2144
2145 // find where the PolicyTool gui is
2146 Point location = getLocationOnScreen();
2147 //newTD.setBounds(location.x + 50, location.y + 100, 650, 190);
2148 newTD.setLayout(new GridBagLayout());
2149 newTD.setResizable(true);
2150
2151 // description label
2152 JLabel label = (edit ?
2153 new JLabel(PolicyTool.getMessage(".Edit.Principal.")) :
2154 new JLabel(PolicyTool.getMessage(".Add.New.Principal.")));
2155 tw.addNewComponent(newTD, label, PRD_DESC_LABEL,
2156 0, 0, 1, 1, 0.0, 0.0, GridBagConstraints.BOTH,
2157 ToolWindow.TOP_BOTTOM_PADDING);
2158
2159 // principal choice
2160 JComboBox<String> choice = new JComboBox<>();
2161 choice.addItem(PRIN_TYPE);
2162 choice.getAccessibleContext().setAccessibleName(PRIN_TYPE);
2163 for (int i = 0; i < PRIN_ARRAY.size(); i++) {
2164 Prin next = PRIN_ARRAY.get(i);
2165 choice.addItem(next.CLASS);
2166 }
2167
2168 if (edit) {
2169 if (PolicyParser.PrincipalEntry.WILDCARD_CLASS.equals
2170 (editMe.getPrincipalClass())) {
2171 choice.setSelectedItem(PRIN_TYPE);
2172 } else {
2173 Prin inputPrin = getPrin(editMe.getPrincipalClass(), true);
2174 if (inputPrin != null) {
2175 choice.setSelectedItem(inputPrin.CLASS);
2176 }
2177 }
2178 }
2179 // Add listener after selected item is set
2180 choice.addItemListener(new PrincipalTypeMenuListener(newTD));
2181
2182 tw.addNewComponent(newTD, choice, PRD_PRIN_CHOICE,
2183 0, 1, 1, 1, 0.0, 0.0, GridBagConstraints.BOTH,
2184 ToolWindow.LR_PADDING);
2185
2186 // principal textfield
2187 JTextField tf;
2188 tf = (edit ?
2189 new JTextField(editMe.getDisplayClass(), 30) :
2190 new JTextField(30));
2191 tf.setPreferredSize(new Dimension(tf.getPreferredSize().width, TEXTFIELD_HEIGHT));
2192 tf.getAccessibleContext().setAccessibleName(PRIN_TYPE);
2193 tw.addNewComponent(newTD, tf, PRD_PRIN_TEXTFIELD,
2194 1, 1, 1, 1, 1.0, 0.0, GridBagConstraints.BOTH,
2195 ToolWindow.LR_PADDING);
2196
2197 // name label and textfield
2198 label = new JLabel(PRIN_NAME);
2199 tf = (edit ?
2200 new JTextField(editMe.getDisplayName(), 40) :
2201 new JTextField(40));
2202 tf.setPreferredSize(new Dimension(tf.getPreferredSize().width, TEXTFIELD_HEIGHT));
2203 tf.getAccessibleContext().setAccessibleName(PRIN_NAME);
2204
2205 tw.addNewComponent(newTD, label, PRD_NAME_LABEL,
2206 0, 2, 1, 1, 0.0, 0.0, GridBagConstraints.BOTH,
2207 ToolWindow.LR_PADDING);
2208 tw.addNewComponent(newTD, tf, PRD_NAME_TEXTFIELD,
2209 1, 2, 1, 1, 1.0, 0.0, GridBagConstraints.BOTH,
2210 ToolWindow.LR_PADDING);
2211
2212 // OK button
2213 JButton okButton = new JButton(PolicyTool.getMessage("OK"));
2214 okButton.addActionListener(
2215 new NewPolicyPrinOKButtonListener
2216 (tool, tw, this, newTD, edit));
2217 tw.addNewComponent(newTD, okButton, PRD_OK_BUTTON,
2218 0, 3, 1, 1, 0.0, 0.0, GridBagConstraints.VERTICAL,
2219 ToolWindow.TOP_BOTTOM_PADDING);
2220 // cancel button
2221 JButton cancelButton = new JButton(PolicyTool.getMessage("Cancel"));
2222 ActionListener cancelListener = new CancelButtonListener(newTD);
2223 cancelButton.addActionListener(cancelListener);
2224 tw.addNewComponent(newTD, cancelButton, PRD_CANCEL_BUTTON,
2225 1, 3, 1, 1, 0.0, 0.0, GridBagConstraints.VERTICAL,
2226 ToolWindow.TOP_BOTTOM_PADDING);
2227
2228 newTD.getRootPane().setDefaultButton(okButton);
2229 newTD.getRootPane().registerKeyboardAction(cancelListener, escKey, JComponent.WHEN_IN_FOCUSED_WINDOW);
2230
2231 newTD.pack();
2232 newTD.setLocationRelativeTo(tw);
2233 newTD.setVisible(true);
2234 }
2235
2236 /**
2237 * display a dialog box for the user to input Permission info
2238 *
2239 * if editPolicyEntry is false, then we are adding Permissions to
2240 * a new PolicyEntry, and we only update the GUI listing
2241 * with the new Permission.
2242 *
2243 * if edit is true, then we are editing an existing Permission entry.
2244 */
2245 void displayPermissionDialog(boolean editPolicyEntry, boolean edit) {
2246
2247 PolicyParser.PermissionEntry editMe = null;
2248
2249 // get the Permission selected from the Permission List
2250 TaggedList permList = (TaggedList)getComponent(PE_PERM_LIST);
2251 int permIndex = permList.getSelectedIndex();
2252
2253 if (edit) {
2254 editMe = (PolicyParser.PermissionEntry)permList.getObject(permIndex);
2255 }
2256
2257 ToolDialog newTD = new ToolDialog
2258 (PolicyTool.getMessage("Permissions"), tool, tw, true);
2259 newTD.addWindowListener(new ChildWindowListener(newTD));
2260
2261 // find where the PolicyTool gui is
2262 Point location = getLocationOnScreen();
2263 //newTD.setBounds(location.x + 50, location.y + 100, 700, 250);
2264 newTD.setLayout(new GridBagLayout());
2265 newTD.setResizable(true);
2266
2267 // description label
2268 JLabel label = (edit ?
2269 new JLabel(PolicyTool.getMessage(".Edit.Permission.")) :
2270 new JLabel(PolicyTool.getMessage(".Add.New.Permission.")));
2271 tw.addNewComponent(newTD, label, PD_DESC_LABEL,
2272 0, 0, 1, 1, 0.0, 0.0, GridBagConstraints.BOTH,
2273 ToolWindow.TOP_BOTTOM_PADDING);
2274
2275 // permission choice (added in alphabetical order)
2276 JComboBox<String> choice = new JComboBox<>();
2277 choice.addItem(PERM);
2278 choice.getAccessibleContext().setAccessibleName(PERM);
2279 for (int i = 0; i < PERM_ARRAY.size(); i++) {
2280 Perm next = PERM_ARRAY.get(i);
2281 choice.addItem(next.CLASS);
2282 }
2283 tw.addNewComponent(newTD, choice, PD_PERM_CHOICE,
2284 0, 1, 1, 1, 0.0, 0.0, GridBagConstraints.BOTH,
2285 ToolWindow.LR_BOTTOM_PADDING);
2286
2287 // permission textfield
2288 JTextField tf;
2289 tf = (edit ? new JTextField(editMe.permission, 30) : new JTextField(30));
2290 tf.setPreferredSize(new Dimension(tf.getPreferredSize().width, TEXTFIELD_HEIGHT));
2291 tf.getAccessibleContext().setAccessibleName(PERM);
2292 if (edit) {
2293 Perm inputPerm = getPerm(editMe.permission, true);
2294 if (inputPerm != null) {
2295 choice.setSelectedItem(inputPerm.CLASS);
2296 }
2297 }
2298 tw.addNewComponent(newTD, tf, PD_PERM_TEXTFIELD,
2299 1, 1, 1, 1, 1.0, 0.0, GridBagConstraints.BOTH,
2300 ToolWindow.LR_BOTTOM_PADDING);
2301 choice.addItemListener(new PermissionMenuListener(newTD));
2302
2303 // name label and textfield
2304 choice = new JComboBox<>();
2305 choice.addItem(PERM_NAME);
2306 choice.getAccessibleContext().setAccessibleName(PERM_NAME);
2307 tf = (edit ? new JTextField(editMe.name, 40) : new JTextField(40));
2308 tf.setPreferredSize(new Dimension(tf.getPreferredSize().width, TEXTFIELD_HEIGHT));
2309 tf.getAccessibleContext().setAccessibleName(PERM_NAME);
2310 if (edit) {
2311 setPermissionNames(getPerm(editMe.permission, true), choice, tf);
2312 }
2313 tw.addNewComponent(newTD, choice, PD_NAME_CHOICE,
2314 0, 2, 1, 1, 0.0, 0.0, GridBagConstraints.BOTH,
2315 ToolWindow.LR_BOTTOM_PADDING);
2316 tw.addNewComponent(newTD, tf, PD_NAME_TEXTFIELD,
2317 1, 2, 1, 1, 1.0, 0.0, GridBagConstraints.BOTH,
2318 ToolWindow.LR_BOTTOM_PADDING);
2319 choice.addItemListener(new PermissionNameMenuListener(newTD));
2320
2321 // actions label and textfield
2322 choice = new JComboBox<>();
2323 choice.addItem(PERM_ACTIONS);
2324 choice.getAccessibleContext().setAccessibleName(PERM_ACTIONS);
2325 tf = (edit ? new JTextField(editMe.action, 40) : new JTextField(40));
2326 tf.setPreferredSize(new Dimension(tf.getPreferredSize().width, TEXTFIELD_HEIGHT));
2327 tf.getAccessibleContext().setAccessibleName(PERM_ACTIONS);
2328 if (edit) {
2329 setPermissionActions(getPerm(editMe.permission, true), choice, tf);
2330 }
2331 tw.addNewComponent(newTD, choice, PD_ACTIONS_CHOICE,
2332 0, 3, 1, 1, 0.0, 0.0, GridBagConstraints.BOTH,
2333 ToolWindow.LR_BOTTOM_PADDING);
2334 tw.addNewComponent(newTD, tf, PD_ACTIONS_TEXTFIELD,
2335 1, 3, 1, 1, 1.0, 0.0, GridBagConstraints.BOTH,
2336 ToolWindow.LR_BOTTOM_PADDING);
2337 choice.addItemListener(new PermissionActionsMenuListener(newTD));
2338
2339 // signedby label and textfield
2340 label = new JLabel(PolicyTool.getMessage("Signed.By."));
2341 tw.addNewComponent(newTD, label, PD_SIGNEDBY_LABEL,
2342 0, 4, 1, 1, 0.0, 0.0, GridBagConstraints.BOTH,
2343 ToolWindow.LR_BOTTOM_PADDING);
2344 tf = (edit ? new JTextField(editMe.signedBy, 40) : new JTextField(40));
2345 tf.setPreferredSize(new Dimension(tf.getPreferredSize().width, TEXTFIELD_HEIGHT));
2346 tf.getAccessibleContext().setAccessibleName(
2347 PolicyTool.getMessage("Signed.By."));
2348 tw.addNewComponent(newTD, tf, PD_SIGNEDBY_TEXTFIELD,
2349 1, 4, 1, 1, 1.0, 0.0, GridBagConstraints.BOTH,
2350 ToolWindow.LR_BOTTOM_PADDING);
2351
2352 // OK button
2353 JButton okButton = new JButton(PolicyTool.getMessage("OK"));
2354 okButton.addActionListener(
2355 new NewPolicyPermOKButtonListener
2356 (tool, tw, this, newTD, edit));
2357 tw.addNewComponent(newTD, okButton, PD_OK_BUTTON,
2358 0, 5, 1, 1, 0.0, 0.0, GridBagConstraints.VERTICAL,
2359 ToolWindow.TOP_BOTTOM_PADDING);
2360
2361 // cancel button
2362 JButton cancelButton = new JButton(PolicyTool.getMessage("Cancel"));
2363 ActionListener cancelListener = new CancelButtonListener(newTD);
2364 cancelButton.addActionListener(cancelListener);
2365 tw.addNewComponent(newTD, cancelButton, PD_CANCEL_BUTTON,
2366 1, 5, 1, 1, 0.0, 0.0, GridBagConstraints.VERTICAL,
2367 ToolWindow.TOP_BOTTOM_PADDING);
2368
2369 newTD.getRootPane().setDefaultButton(okButton);
2370 newTD.getRootPane().registerKeyboardAction(cancelListener, escKey, JComponent.WHEN_IN_FOCUSED_WINDOW);
2371
2372 newTD.pack();
2373 newTD.setLocationRelativeTo(tw);
2374 newTD.setVisible(true);
2375 }
2376
2377 /**
2378 * construct a Principal object from the Principal Info Dialog Box
2379 */
2380 PolicyParser.PrincipalEntry getPrinFromDialog() throws Exception {
2381
2382 JTextField tf = (JTextField)getComponent(PRD_PRIN_TEXTFIELD);
2383 String pclass = new String(tf.getText().trim());
2384 tf = (JTextField)getComponent(PRD_NAME_TEXTFIELD);
2385 String pname = new String(tf.getText().trim());
2386 if (pclass.equals("*")) {
2387 pclass = PolicyParser.PrincipalEntry.WILDCARD_CLASS;
2388 }
2389 if (pname.equals("*")) {
2390 pname = PolicyParser.PrincipalEntry.WILDCARD_NAME;
2391 }
2392
2393 PolicyParser.PrincipalEntry pppe = null;
2394
2395 if ((pclass.equals(PolicyParser.PrincipalEntry.WILDCARD_CLASS)) &&
2396 (!pname.equals(PolicyParser.PrincipalEntry.WILDCARD_NAME))) {
2397 throw new Exception
2398 (PolicyTool.getMessage("Cannot.Specify.Principal.with.a.Wildcard.Class.without.a.Wildcard.Name"));
2399 } else if (pname.equals("")) {
2400 throw new Exception
2401 (PolicyTool.getMessage("Cannot.Specify.Principal.without.a.Name"));
2402 } else if (pclass.equals("")) {
2403 // make this consistent with what PolicyParser does
2404 // when it sees an empty principal class
2405 pclass = PolicyParser.PrincipalEntry.REPLACE_NAME;
2406 tool.warnings.addElement(
2407 "Warning: Principal name '" + pname +
2408 "' specified without a Principal class.\n" +
2409 "\t'" + pname + "' will be interpreted " +
2410 "as a key store alias.\n" +
2411 "\tThe final principal class will be " +
2412 ToolDialog.X500_PRIN_CLASS + ".\n" +
2413 "\tThe final principal name will be " +
2414 "determined by the following:\n" +
2415 "\n" +
2416 "\tIf the key store entry identified by '"
2417 + pname + "'\n" +
2418 "\tis a key entry, then the principal name will be\n" +
2419 "\tthe subject distinguished name from the first\n" +
2420 "\tcertificate in the entry's certificate chain.\n" +
2421 "\n" +
2422 "\tIf the key store entry identified by '" +
2423 pname + "'\n" +
2424 "\tis a trusted certificate entry, then the\n" +
2425 "\tprincipal name will be the subject distinguished\n" +
2426 "\tname from the trusted public key certificate.");
2427 tw.displayStatusDialog(this,
2428 "'" + pname + "' will be interpreted as a key " +
2429 "store alias. View Warning Log for details.");
2430 }
2431 return new PolicyParser.PrincipalEntry(pclass, pname);
2432 }
2433
2434
2435 /**
2436 * construct a Permission object from the Permission Info Dialog Box
2437 */
2438 PolicyParser.PermissionEntry getPermFromDialog() {
2439
2440 JTextField tf = (JTextField)getComponent(PD_PERM_TEXTFIELD);
2441 String permission = new String(tf.getText().trim());
2442 tf = (JTextField)getComponent(PD_NAME_TEXTFIELD);
2443 String name = null;
2444 if (tf.getText().trim().equals("") == false)
2445 name = new String(tf.getText().trim());
2446 if (permission.equals("") ||
2447 (!permission.equals(ALL_PERM_CLASS) && name == null)) {
2448 throw new InvalidParameterException(PolicyTool.getMessage
2449 ("Permission.and.Target.Name.must.have.a.value"));
2450 }
2451
2452 // When the permission is FilePermission, we need to check the name
2453 // to make sure it's not escaped. We believe --
2454 //
2455 // String name.lastIndexOf("\\\\")
2456 // ---------------- ------------------------
2457 // c:\foo\bar -1, legal
2458 // c:\\foo\\bar 2, illegal
2459 // \\server\share 0, legal
2460 // \\\\server\share 2, illegal
2461
2462 if (permission.equals(FILE_PERM_CLASS) && name.lastIndexOf("\\\\") > 0) {
2463 char result = tw.displayYesNoDialog(this,
2464 PolicyTool.getMessage("Warning"),
2465 PolicyTool.getMessage(
2466 "Warning.File.name.may.include.escaped.backslash.characters.It.is.not.necessary.to.escape.backslash.characters.the.tool.escapes"),
2467 PolicyTool.getMessage("Retain"),
2468 PolicyTool.getMessage("Edit")
2469 );
2470 if (result != 'Y') {
2471 // an invisible exception
2472 throw new NoDisplayException();
2473 }
2474 }
2475 // get the Actions
2476 tf = (JTextField)getComponent(PD_ACTIONS_TEXTFIELD);
2477 String actions = null;
2478 if (tf.getText().trim().equals("") == false)
2479 actions = new String(tf.getText().trim());
2480
2481 // get the Signed By
2482 tf = (JTextField)getComponent(PD_SIGNEDBY_TEXTFIELD);
2483 String signedBy = null;
2484 if (tf.getText().trim().equals("") == false)
2485 signedBy = new String(tf.getText().trim());
2486
2487 PolicyParser.PermissionEntry pppe = new PolicyParser.PermissionEntry
2488 (permission, name, actions);
2489 pppe.signedBy = signedBy;
2490
2491 // see if the signers have public keys
2492 if (signedBy != null) {
2493 String signers[] = tool.parseSigners(pppe.signedBy);
2494 for (int i = 0; i < signers.length; i++) {
2495 try {
2496 PublicKey pubKey = tool.getPublicKeyAlias(signers[i]);
2497 if (pubKey == null) {
2498 MessageFormat form = new MessageFormat
2499 (PolicyTool.getMessage
2500 ("Warning.A.public.key.for.alias.signers.i.does.not.exist.Make.sure.a.KeyStore.is.properly.configured."));
2501 Object[] source = {signers[i]};
2502 tool.warnings.addElement(form.format(source));
2503 tw.displayStatusDialog(this, form.format(source));
2504 }
2505 } catch (Exception e) {
2506 tw.displayErrorDialog(this, e);
2507 }
2508 }
2509 }
2510 return pppe;
2511 }
2512
2513 /**
2514 * confirm that the user REALLY wants to remove the Policy Entry
2515 */
2516 void displayConfirmRemovePolicyEntry() {
2517
2518 // find the entry to be removed
2519 @SuppressWarnings("unchecked")
2520 JList<String> list = (JList<String>)tw.getComponent(ToolWindow.MW_POLICY_LIST);
2521 int index = list.getSelectedIndex();
2522 PolicyEntry entries[] = tool.getEntry();
2523
2524 // find where the PolicyTool gui is
2525 Point location = tw.getLocationOnScreen();
2526 //setBounds(location.x + 25, location.y + 100, 600, 400);
2527 setLayout(new GridBagLayout());
2528
2529 // ask the user do they really want to do this?
2530 JLabel label = new JLabel
2531 (PolicyTool.getMessage("Remove.this.Policy.Entry."));
2532 tw.addNewComponent(this, label, CRPE_LABEL1,
2533 0, 0, 2, 1, 0.0, 0.0, GridBagConstraints.BOTH,
2534 ToolWindow.BOTTOM_PADDING);
2535
2536 // display the policy entry
2537 label = new JLabel(entries[index].codebaseToString());
2538 tw.addNewComponent(this, label, CRPE_LABEL2,
2539 0, 1, 2, 1, 0.0, 0.0, GridBagConstraints.BOTH);
2540 label = new JLabel(entries[index].principalsToString().trim());
2541 tw.addNewComponent(this, label, CRPE_LABEL2+1,
2542 0, 2, 2, 1, 0.0, 0.0, GridBagConstraints.BOTH);
2543 Vector<PolicyParser.PermissionEntry> perms =
2544 entries[index].getGrantEntry().permissionEntries;
2545 for (int i = 0; i < perms.size(); i++) {
2546 PolicyParser.PermissionEntry nextPerm = perms.elementAt(i);
2547 String permString = ToolDialog.PermissionEntryToUserFriendlyString(nextPerm);
2548 label = new JLabel(" " + permString);
2549 if (i == (perms.size()-1)) {
2550 tw.addNewComponent(this, label, CRPE_LABEL2 + 2 + i,
2551 1, 3 + i, 1, 1, 0.0, 0.0,
2552 GridBagConstraints.BOTH,
2553 ToolWindow.BOTTOM_PADDING);
2554 } else {
2555 tw.addNewComponent(this, label, CRPE_LABEL2 + 2 + i,
2556 1, 3 + i, 1, 1, 0.0, 0.0,
2557 GridBagConstraints.BOTH);
2558 }
2559 }
2560
2561
2562 // add OK/CANCEL buttons in a new panel
2563 JPanel panel = new JPanel();
2564 panel.setLayout(new GridBagLayout());
2565
2566 // OK button
2567 JButton okButton = new JButton(PolicyTool.getMessage("OK"));
2568 okButton.addActionListener
2569 (new ConfirmRemovePolicyEntryOKButtonListener(tool, tw, this));
2570 tw.addNewComponent(panel, okButton, CRPE_PANEL_OK,
2571 0, 0, 1, 1, 0.0, 0.0,
2572 GridBagConstraints.VERTICAL, ToolWindow.LR_PADDING);
2573
2574 // cancel button
2575 JButton cancelButton = new JButton(PolicyTool.getMessage("Cancel"));
2576 ActionListener cancelListener = new CancelButtonListener(this);
2577 cancelButton.addActionListener(cancelListener);
2578 tw.addNewComponent(panel, cancelButton, CRPE_PANEL_CANCEL,
2579 1, 0, 1, 1, 0.0, 0.0,
2580 GridBagConstraints.VERTICAL, ToolWindow.LR_PADDING);
2581
2582 tw.addNewComponent(this, panel, CRPE_LABEL2 + 2 + perms.size(),
2583 0, 3 + perms.size(), 2, 1, 0.0, 0.0,
2584 GridBagConstraints.VERTICAL, ToolWindow.TOP_BOTTOM_PADDING);
2585
2586 getRootPane().setDefaultButton(okButton);
2587 getRootPane().registerKeyboardAction(cancelListener, escKey, JComponent.WHEN_IN_FOCUSED_WINDOW);
2588
2589 pack();
2590 setLocationRelativeTo(tw);
2591 setVisible(true);
2592 }
2593
2594 /**
2595 * perform SAVE AS
2596 */
2597 void displaySaveAsDialog(int nextEvent) {
2598
2599 // pop up a dialog box for the user to enter a filename.
2600 FileDialog fd = new FileDialog
2601 (tw, PolicyTool.getMessage("Save.As"), FileDialog.SAVE);
2602 fd.addWindowListener(new WindowAdapter() {
2603 public void windowClosing(WindowEvent e) {
2604 e.getWindow().setVisible(false);
2605 }
2606 });
2607 fd.setVisible(true);
2608
2609 // see if the user hit cancel
2610 if (fd.getFile() == null ||
2611 fd.getFile().equals(""))
2612 return;
2613
2614 // get the entered filename
2615 File saveAsFile = new File(fd.getDirectory(), fd.getFile());
2616 String filename = saveAsFile.getPath();
2617 fd.dispose();
2618
2619 try {
2620 // save the policy entries to a file
2621 tool.savePolicy(filename);
2622
2623 // display status
2624 MessageFormat form = new MessageFormat(PolicyTool.getMessage
2625 ("Policy.successfully.written.to.filename"));
2626 Object[] source = {filename};
2627 tw.displayStatusDialog(null, form.format(source));
2628
2629 // display the new policy filename
2630 JTextField newFilename = (JTextField)tw.getComponent
2631 (ToolWindow.MW_FILENAME_TEXTFIELD);
2632 newFilename.setText(filename);
2633 tw.setVisible(true);
2634
2635 // now continue with the originally requested command
2636 // (QUIT, NEW, or OPEN)
2637 userSaveContinue(tool, tw, this, nextEvent);
2638
2639 } catch (FileNotFoundException fnfe) {
2640 if (filename == null || filename.equals("")) {
2641 tw.displayErrorDialog(null, new FileNotFoundException
2642 (PolicyTool.getMessage("null.filename")));
2643 } else {
2644 tw.displayErrorDialog(null, fnfe);
2645 }
2646 } catch (Exception ee) {
2647 tw.displayErrorDialog(null, ee);
2648 }
2649 }
2650
2651 /**
2652 * ask user if they want to save changes
2653 */
2654 void displayUserSave(int select) {
2655
2656 if (tool.modified == true) {
2657
2658 // find where the PolicyTool gui is
2659 Point location = tw.getLocationOnScreen();
2660 //setBounds(location.x + 75, location.y + 100, 400, 150);
2661 setLayout(new GridBagLayout());
2662
2663 JLabel label = new JLabel
2664 (PolicyTool.getMessage("Save.changes."));
2665 tw.addNewComponent(this, label, USC_LABEL,
2666 0, 0, 3, 1, 0.0, 0.0, GridBagConstraints.BOTH,
2667 ToolWindow.L_TOP_BOTTOM_PADDING);
2668
2669 JPanel panel = new JPanel();
2670 panel.setLayout(new GridBagLayout());
2671
2672 JButton yesButton = new JButton();
2673 ToolWindow.configureButton(yesButton, "Yes");
2674 yesButton.addActionListener
2675 (new UserSaveYesButtonListener(this, tool, tw, select));
2676 tw.addNewComponent(panel, yesButton, USC_YES_BUTTON,
2677 0, 0, 1, 1, 0.0, 0.0,
2678 GridBagConstraints.VERTICAL,
2679 ToolWindow.LR_BOTTOM_PADDING);
2680 JButton noButton = new JButton();
2681 ToolWindow.configureButton(noButton, "No");
2682 noButton.addActionListener
2683 (new UserSaveNoButtonListener(this, tool, tw, select));
2684 tw.addNewComponent(panel, noButton, USC_NO_BUTTON,
2685 1, 0, 1, 1, 0.0, 0.0,
2686 GridBagConstraints.VERTICAL,
2687 ToolWindow.LR_BOTTOM_PADDING);
2688 JButton cancelButton = new JButton();
2689 ToolWindow.configureButton(cancelButton, "Cancel");
2690 ActionListener cancelListener = new CancelButtonListener(this);
2691 cancelButton.addActionListener(cancelListener);
2692 tw.addNewComponent(panel, cancelButton, USC_CANCEL_BUTTON,
2693 2, 0, 1, 1, 0.0, 0.0,
2694 GridBagConstraints.VERTICAL,
2695 ToolWindow.LR_BOTTOM_PADDING);
2696
2697 tw.addNewComponent(this, panel, USC_PANEL,
2698 0, 1, 1, 1, 0.0, 0.0, GridBagConstraints.BOTH);
2699
2700 getRootPane().registerKeyboardAction(cancelListener, escKey, JComponent.WHEN_IN_FOCUSED_WINDOW);
2701
2702 pack();
2703 setLocationRelativeTo(tw);
2704 setVisible(true);
2705 } else {
2706 // just do the original request (QUIT, NEW, or OPEN)
2707 userSaveContinue(tool, tw, this, select);
2708 }
2709 }
2710
2711 /**
2712 * when the user sees the 'YES', 'NO', 'CANCEL' buttons on the
2713 * displayUserSave dialog, and the click on one of them,
2714 * we need to continue the originally requested action
2715 * (either QUITting, opening NEW policy file, or OPENing an existing
2716 * policy file. do that now.
2717 */
2718 @SuppressWarnings("fallthrough")
2719 void userSaveContinue(PolicyTool tool, ToolWindow tw,
2720 ToolDialog us, int select) {
2721
2722 // now either QUIT, open a NEW policy file, or OPEN an existing policy
2723 switch(select) {
2724 case ToolDialog.QUIT:
2725
2726 tw.setVisible(false);
2727 tw.dispose();
2728 System.exit(0);
2729
2730 case ToolDialog.NEW:
2731
2732 try {
2733 tool.openPolicy(null);
2734 } catch (Exception ee) {
2735 tool.modified = false;
2736 tw.displayErrorDialog(null, ee);
2737 }
2738
2739 // display the policy entries via the policy list textarea
2740 JList<String> list = new JList<>(new DefaultListModel<>());
2741 list.setVisibleRowCount(15);
2742 list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
2743 list.addMouseListener(new PolicyListListener(tool, tw));
2744 tw.replacePolicyList(list);
2745
2746 // display null policy filename and keystore
2747 JTextField newFilename = (JTextField)tw.getComponent(
2748 ToolWindow.MW_FILENAME_TEXTFIELD);
2749 newFilename.setText("");
2750 tw.setVisible(true);
2751 break;
2752
2753 case ToolDialog.OPEN:
2754
2755 // pop up a dialog box for the user to enter a filename.
2756 FileDialog fd = new FileDialog
2757 (tw, PolicyTool.getMessage("Open"), FileDialog.LOAD);
2758 fd.addWindowListener(new WindowAdapter() {
2759 public void windowClosing(WindowEvent e) {
2760 e.getWindow().setVisible(false);
2761 }
2762 });
2763 fd.setVisible(true);
2764
2765 // see if the user hit 'cancel'
2766 if (fd.getFile() == null ||
2767 fd.getFile().equals(""))
2768 return;
2769
2770 // get the entered filename
2771 String policyFile = new File(fd.getDirectory(), fd.getFile()).getPath();
2772
2773 try {
2774 // open the policy file
2775 tool.openPolicy(policyFile);
2776
2777 // display the policy entries via the policy list textarea
2778 DefaultListModel<String> listModel = new DefaultListModel<>();
2779 list = new JList<>(listModel);
2780 list.setVisibleRowCount(15);
2781 list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
2782 list.addMouseListener(new PolicyListListener(tool, tw));
2783 PolicyEntry entries[] = tool.getEntry();
2784 if (entries != null) {
2785 for (int i = 0; i < entries.length; i++) {
2786 listModel.addElement(entries[i].headerToString());
2787 }
2788 }
2789 tw.replacePolicyList(list);
2790 tool.modified = false;
2791
2792 // display the new policy filename
2793 newFilename = (JTextField)tw.getComponent(
2794 ToolWindow.MW_FILENAME_TEXTFIELD);
2795 newFilename.setText(policyFile);
2796 tw.setVisible(true);
2797
2798 // inform user of warnings
2799 if (tool.newWarning == true) {
2800 tw.displayStatusDialog(null, PolicyTool.getMessage
2801 ("Errors.have.occurred.while.opening.the.policy.configuration.View.the.Warning.Log.for.more.information."));
2802 }
2803
2804 } catch (Exception e) {
2805 // add blank policy listing
2806 list = new JList<>(new DefaultListModel<>());
2807 list.setVisibleRowCount(15);
2808 list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
2809 list.addMouseListener(new PolicyListListener(tool, tw));
2810 tw.replacePolicyList(list);
2811 tool.setPolicyFileName(null);
2812 tool.modified = false;
2813
2814 // display a null policy filename
2815 newFilename = (JTextField)tw.getComponent(
2816 ToolWindow.MW_FILENAME_TEXTFIELD);
2817 newFilename.setText("");
2818 tw.setVisible(true);
2819
2820 // display the error
2821 MessageFormat form = new MessageFormat(PolicyTool.getMessage
2822 ("Could.not.open.policy.file.policyFile.e.toString."));
2823 Object[] source = {policyFile, e.toString()};
2824 tw.displayErrorDialog(null, form.format(source));
2825 }
2826 break;
2827 }
2828 }
2829
2830 /**
2831 * Return a Menu list of names for a given permission
2832 *
2833 * If inputPerm's TARGETS are null, then this means TARGETS are
2834 * not allowed to be entered (and the TextField is set to be
2835 * non-editable).
2836 *
2837 * If TARGETS are valid but there are no standard ones
2838 * (user must enter them by hand) then the TARGETS array may be empty
2839 * (and of course non-null).
2840 */
2841 void setPermissionNames(Perm inputPerm, JComboBox<String> names, JTextField field) {
2842 names.removeAllItems();
2843 names.addItem(PERM_NAME);
2844
2845 if (inputPerm == null) {
2846 // custom permission
2847 field.setEditable(true);
2848 } else if (inputPerm.TARGETS == null) {
2849 // standard permission with no targets
2850 field.setEditable(false);
2851 } else {
2852 // standard permission with standard targets
2853 field.setEditable(true);
2854 for (int i = 0; i < inputPerm.TARGETS.length; i++) {
2855 names.addItem(inputPerm.TARGETS[i]);
2856 }
2857 }
2858 }
2859
2860 /**
2861 * Return a Menu list of actions for a given permission
2862 *
2863 * If inputPerm's ACTIONS are null, then this means ACTIONS are
2864 * not allowed to be entered (and the TextField is set to be
2865 * non-editable). This is typically true for BasicPermissions.
2866 *
2867 * If ACTIONS are valid but there are no standard ones
2868 * (user must enter them by hand) then the ACTIONS array may be empty
2869 * (and of course non-null).
2870 */
2871 void setPermissionActions(Perm inputPerm, JComboBox<String> actions, JTextField field) {
2872 actions.removeAllItems();
2873 actions.addItem(PERM_ACTIONS);
2874
2875 if (inputPerm == null) {
2876 // custom permission
2877 field.setEditable(true);
2878 } else if (inputPerm.ACTIONS == null) {
2879 // standard permission with no actions
2880 field.setEditable(false);
2881 } else {
2882 // standard permission with standard actions
2883 field.setEditable(true);
2884 for (int i = 0; i < inputPerm.ACTIONS.length; i++) {
2885 actions.addItem(inputPerm.ACTIONS[i]);
2886 }
2887 }
2888 }
2889
2890 static String PermissionEntryToUserFriendlyString(PolicyParser.PermissionEntry pppe) {
2891 String result = pppe.permission;
2892 if (pppe.name != null) {
2893 result += " " + pppe.name;
2894 }
2895 if (pppe.action != null) {
2896 result += ", \"" + pppe.action + "\"";
2897 }
2898 if (pppe.signedBy != null) {
2899 result += ", signedBy " + pppe.signedBy;
2900 }
2901 return result;
2902 }
2903
2904 static String PrincipalEntryToUserFriendlyString(PolicyParser.PrincipalEntry pppe) {
2905 StringWriter sw = new StringWriter();
2906 PrintWriter pw = new PrintWriter(sw);
2907 pppe.write(pw);
2908 return sw.toString();
2909 }
2910 }
2911
2912 /**
2913 * Event handler for the PolicyTool window
2914 */
2915 class ToolWindowListener implements WindowListener {
2916
2917 private PolicyTool tool;
2918 private ToolWindow tw;
2919
2920 ToolWindowListener(PolicyTool tool, ToolWindow tw) {
2921 this.tool = tool;
2922 this.tw = tw;
2923 }
2924
2925 public void windowOpened(WindowEvent we) {
2926 }
2927
2928 public void windowClosing(WindowEvent we) {
2929 // Closing the window acts the same as choosing Menu->Exit.
2930
2931 // ask user if they want to save changes
2932 ToolDialog td = new ToolDialog(PolicyTool.getMessage("Save.Changes"), tool, tw, true);
2933 td.displayUserSave(ToolDialog.QUIT);
2934
2935 // the above method will perform the QUIT as long as the
2936 // user does not CANCEL the request
2937 }
2938
2939 public void windowClosed(WindowEvent we) {
2940 System.exit(0);
2941 }
2942
2943 public void windowIconified(WindowEvent we) {
2944 }
2945
2946 public void windowDeiconified(WindowEvent we) {
2947 }
2948
2949 public void windowActivated(WindowEvent we) {
2950 }
2951
2952 public void windowDeactivated(WindowEvent we) {
2953 }
2954 }
2955
2956 /**
2957 * Event handler for the Policy List
2958 */
2959 class PolicyListListener extends MouseAdapter implements ActionListener {
2960
2961 private PolicyTool tool;
2962 private ToolWindow tw;
2963
2964 PolicyListListener(PolicyTool tool, ToolWindow tw) {
2965 this.tool = tool;
2966 this.tw = tw;
2967
2968 }
2969
2970 public void actionPerformed(ActionEvent e) {
2971
2972 // display the permission list for a policy entry
2973 ToolDialog td = new ToolDialog
2974 (PolicyTool.getMessage("Policy.Entry"), tool, tw, true);
2975 td.displayPolicyEntryDialog(true);
2976 }
2977
2978 public void mouseClicked(MouseEvent evt) {
2979 if (evt.getClickCount() == 2) {
2980 actionPerformed(null);
2981 }
2982 }
2983 }
2984
2985 /**
2986 * Event handler for the File Menu
2987 */
2988 class FileMenuListener implements ActionListener {
2989
2990 private PolicyTool tool;
2991 private ToolWindow tw;
2992
2993 FileMenuListener(PolicyTool tool, ToolWindow tw) {
2994 this.tool = tool;
2995 this.tw = tw;
2996 }
2997
2998 public void actionPerformed(ActionEvent e) {
2999
3000 if (PolicyTool.collator.compare(e.getActionCommand(),
3001 ToolWindow.QUIT) == 0) {
3002
3003 // ask user if they want to save changes
3004 ToolDialog td = new ToolDialog
3005 (PolicyTool.getMessage("Save.Changes"), tool, tw, true);
3006 td.displayUserSave(ToolDialog.QUIT);
3007
3008 // the above method will perform the QUIT as long as the
3009 // user does not CANCEL the request
3010
3011 } else if (PolicyTool.collator.compare(e.getActionCommand(),
3012 ToolWindow.NEW_POLICY_FILE) == 0) {
3013
3014 // ask user if they want to save changes
3015 ToolDialog td = new ToolDialog
3016 (PolicyTool.getMessage("Save.Changes"), tool, tw, true);
3017 td.displayUserSave(ToolDialog.NEW);
3018
3019 // the above method will perform the NEW as long as the
3020 // user does not CANCEL the request
3021
3022 } else if (PolicyTool.collator.compare(e.getActionCommand(),
3023 ToolWindow.OPEN_POLICY_FILE) == 0) {
3024
3025 // ask user if they want to save changes
3026 ToolDialog td = new ToolDialog
3027 (PolicyTool.getMessage("Save.Changes"), tool, tw, true);
3028 td.displayUserSave(ToolDialog.OPEN);
3029
3030 // the above method will perform the OPEN as long as the
3031 // user does not CANCEL the request
3032
3033 } else if (PolicyTool.collator.compare(e.getActionCommand(),
3034 ToolWindow.SAVE_POLICY_FILE) == 0) {
3035
3036 // get the previously entered filename
3037 String filename = ((JTextField)tw.getComponent(
3038 ToolWindow.MW_FILENAME_TEXTFIELD)).getText();
3039
3040 // if there is no filename, do a SAVE_AS
3041 if (filename == null || filename.length() == 0) {
3042 // user wants to SAVE AS
3043 ToolDialog td = new ToolDialog
3044 (PolicyTool.getMessage("Save.As"), tool, tw, true);
3045 td.displaySaveAsDialog(ToolDialog.NOACTION);
3046 } else {
3047 try {
3048 // save the policy entries to a file
3049 tool.savePolicy(filename);
3050
3051 // display status
3052 MessageFormat form = new MessageFormat
3053 (PolicyTool.getMessage
3054 ("Policy.successfully.written.to.filename"));
3055 Object[] source = {filename};
3056 tw.displayStatusDialog(null, form.format(source));
3057 } catch (FileNotFoundException fnfe) {
3058 if (filename == null || filename.equals("")) {
3059 tw.displayErrorDialog(null, new FileNotFoundException
3060 (PolicyTool.getMessage("null.filename")));
3061 } else {
3062 tw.displayErrorDialog(null, fnfe);
3063 }
3064 } catch (Exception ee) {
3065 tw.displayErrorDialog(null, ee);
3066 }
3067 }
3068 } else if (PolicyTool.collator.compare(e.getActionCommand(),
3069 ToolWindow.SAVE_AS_POLICY_FILE) == 0) {
3070
3071 // user wants to SAVE AS
3072 ToolDialog td = new ToolDialog
3073 (PolicyTool.getMessage("Save.As"), tool, tw, true);
3074 td.displaySaveAsDialog(ToolDialog.NOACTION);
3075
3076 } else if (PolicyTool.collator.compare(e.getActionCommand(),
3077 ToolWindow.VIEW_WARNINGS) == 0) {
3078 tw.displayWarningLog(null);
3079 }
3080 }
3081 }
3082
3083 /**
3084 * Event handler for the main window buttons and Edit Menu
3085 */
3086 class MainWindowListener implements ActionListener {
3087
3088 private PolicyTool tool;
3089 private ToolWindow tw;
3090
3091 MainWindowListener(PolicyTool tool, ToolWindow tw) {
3092 this.tool = tool;
3093 this.tw = tw;
3094 }
3095
3096 public void actionPerformed(ActionEvent e) {
3097
3098 if (PolicyTool.collator.compare(e.getActionCommand(),
3099 ToolWindow.ADD_POLICY_ENTRY) == 0) {
3100
3101 // display a dialog box for the user to enter policy info
3102 ToolDialog td = new ToolDialog
3103 (PolicyTool.getMessage("Policy.Entry"), tool, tw, true);
3104 td.displayPolicyEntryDialog(false);
3105
3106 } else if (PolicyTool.collator.compare(e.getActionCommand(),
3107 ToolWindow.REMOVE_POLICY_ENTRY) == 0) {
3108
3109 // get the selected entry
3110 @SuppressWarnings("unchecked")
3111 JList<String> list = (JList<String>)tw.getComponent(ToolWindow.MW_POLICY_LIST);
3112 int index = list.getSelectedIndex();
3113 if (index < 0) {
3114 tw.displayErrorDialog(null, new Exception
3115 (PolicyTool.getMessage("No.Policy.Entry.selected")));
3116 return;
3117 }
3118
3119 // ask the user if they really want to remove the policy entry
3120 ToolDialog td = new ToolDialog(PolicyTool.getMessage
3121 ("Remove.Policy.Entry"), tool, tw, true);
3122 td.displayConfirmRemovePolicyEntry();
3123
3124 } else if (PolicyTool.collator.compare(e.getActionCommand(),
3125 ToolWindow.EDIT_POLICY_ENTRY) == 0) {
3126
3127 // get the selected entry
3128 @SuppressWarnings("unchecked")
3129 JList<String> list = (JList<String>)tw.getComponent(ToolWindow.MW_POLICY_LIST);
3130 int index = list.getSelectedIndex();
3131 if (index < 0) {
3132 tw.displayErrorDialog(null, new Exception
3133 (PolicyTool.getMessage("No.Policy.Entry.selected")));
3134 return;
3135 }
3136
3137 // display the permission list for a policy entry
3138 ToolDialog td = new ToolDialog
3139 (PolicyTool.getMessage("Policy.Entry"), tool, tw, true);
3140 td.displayPolicyEntryDialog(true);
3141
3142 } else if (PolicyTool.collator.compare(e.getActionCommand(),
3143 ToolWindow.EDIT_KEYSTORE) == 0) {
3144
3145 // display a dialog box for the user to enter keystore info
3146 ToolDialog td = new ToolDialog
3147 (PolicyTool.getMessage("KeyStore"), tool, tw, true);
3148 td.keyStoreDialog(ToolDialog.EDIT_KEYSTORE);
3149 }
3150 }
3151 }
3152
3153 /**
3154 * Event handler for AddEntryDoneButton button
3155 *
3156 * -- if edit is TRUE, then we are EDITing an existing PolicyEntry
3157 * and we need to update both the policy and the GUI listing.
3158 * if edit is FALSE, then we are ADDing a new PolicyEntry,
3159 * so we only need to update the GUI listing.
3160 */
3161 class AddEntryDoneButtonListener implements ActionListener {
3162
3163 private PolicyTool tool;
3164 private ToolWindow tw;
3165 private ToolDialog td;
3166 private boolean edit;
3167
3168 AddEntryDoneButtonListener(PolicyTool tool, ToolWindow tw,
3169 ToolDialog td, boolean edit) {
3170 this.tool = tool;
3171 this.tw = tw;
3172 this.td = td;
3173 this.edit = edit;
3174 }
3175
3176 public void actionPerformed(ActionEvent e) {
3177
3178 try {
3179 // get a PolicyEntry object from the dialog policy info
3180 PolicyEntry newEntry = td.getPolicyEntryFromDialog();
3181 PolicyParser.GrantEntry newGe = newEntry.getGrantEntry();
3182
3183 // see if all the signers have public keys
3184 if (newGe.signedBy != null) {
3185 String signers[] = tool.parseSigners(newGe.signedBy);
3186 for (int i = 0; i < signers.length; i++) {
3187 PublicKey pubKey = tool.getPublicKeyAlias(signers[i]);
3188 if (pubKey == null) {
3189 MessageFormat form = new MessageFormat
3190 (PolicyTool.getMessage
3191 ("Warning.A.public.key.for.alias.signers.i.does.not.exist.Make.sure.a.KeyStore.is.properly.configured."));
3192 Object[] source = {signers[i]};
3193 tool.warnings.addElement(form.format(source));
3194 tw.displayStatusDialog(td, form.format(source));
3195 }
3196 }
3197 }
3198
3199 // add the entry
3200 @SuppressWarnings("unchecked")
3201 JList<String> policyList = (JList<String>)tw.getComponent(ToolWindow.MW_POLICY_LIST);
3202 if (edit) {
3203 int listIndex = policyList.getSelectedIndex();
3204 tool.addEntry(newEntry, listIndex);
3205 String newCodeBaseStr = newEntry.headerToString();
3206 if (PolicyTool.collator.compare
3207 (newCodeBaseStr, policyList.getModel().getElementAt(listIndex)) != 0)
3208 tool.modified = true;
3209 ((DefaultListModel<String>)policyList.getModel()).set(listIndex, newCodeBaseStr);
3210 } else {
3211 tool.addEntry(newEntry, -1);
3212 ((DefaultListModel<String>)policyList.getModel()).addElement(newEntry.headerToString());
3213 tool.modified = true;
3214 }
3215 td.setVisible(false);
3216 td.dispose();
3217
3218 } catch (Exception eee) {
3219 tw.displayErrorDialog(td, eee);
3220 }
3221 }
3222 }
3223
3224 /**
3225 * Event handler for ChangeKeyStoreOKButton button
3226 */
3227 class ChangeKeyStoreOKButtonListener implements ActionListener {
3228
3229 private PolicyTool tool;
3230 private ToolWindow tw;
3231 private ToolDialog td;
3232
3233 ChangeKeyStoreOKButtonListener(PolicyTool tool, ToolWindow tw,
3234 ToolDialog td) {
3235 this.tool = tool;
3236 this.tw = tw;
3237 this.td = td;
3238 }
3239
3240 public void actionPerformed(ActionEvent e) {
3241
3242 String URLString = ((JTextField)td.getComponent(
3243 ToolDialog.KSD_NAME_TEXTFIELD)).getText().trim();
3244 String type = ((JTextField)td.getComponent(
3245 ToolDialog.KSD_TYPE_TEXTFIELD)).getText().trim();
3246 String provider = ((JTextField)td.getComponent(
3247 ToolDialog.KSD_PROVIDER_TEXTFIELD)).getText().trim();
3248 String pwdURL = ((JTextField)td.getComponent(
3249 ToolDialog.KSD_PWD_URL_TEXTFIELD)).getText().trim();
3250
3251 try {
3252 tool.openKeyStore
3253 ((URLString.length() == 0 ? null : URLString),
3254 (type.length() == 0 ? null : type),
3255 (provider.length() == 0 ? null : provider),
3256 (pwdURL.length() == 0 ? null : pwdURL));
3257 tool.modified = true;
3258 } catch (Exception ex) {
3259 MessageFormat form = new MessageFormat(PolicyTool.getMessage
3260 ("Unable.to.open.KeyStore.ex.toString."));
3261 Object[] source = {ex.toString()};
3262 tw.displayErrorDialog(td, form.format(source));
3263 return;
3264 }
3265
3266 td.dispose();
3267 }
3268 }
3269
3270 /**
3271 * Event handler for AddPrinButton button
3272 */
3273 class AddPrinButtonListener implements ActionListener {
3274
3275 private PolicyTool tool;
3276 private ToolWindow tw;
3277 private ToolDialog td;
3278 private boolean editPolicyEntry;
3279
3280 AddPrinButtonListener(PolicyTool tool, ToolWindow tw,
3281 ToolDialog td, boolean editPolicyEntry) {
3282 this.tool = tool;
3283 this.tw = tw;
3284 this.td = td;
3285 this.editPolicyEntry = editPolicyEntry;
3286 }
3287
3288 public void actionPerformed(ActionEvent e) {
3289
3290 // display a dialog box for the user to enter principal info
3291 td.displayPrincipalDialog(editPolicyEntry, false);
3292 }
3293 }
3294
3295 /**
3296 * Event handler for AddPermButton button
3297 */
3298 class AddPermButtonListener implements ActionListener {
3299
3300 private PolicyTool tool;
3301 private ToolWindow tw;
3302 private ToolDialog td;
3303 private boolean editPolicyEntry;
3304
3305 AddPermButtonListener(PolicyTool tool, ToolWindow tw,
3306 ToolDialog td, boolean editPolicyEntry) {
3307 this.tool = tool;
3308 this.tw = tw;
3309 this.td = td;
3310 this.editPolicyEntry = editPolicyEntry;
3311 }
3312
3313 public void actionPerformed(ActionEvent e) {
3314
3315 // display a dialog box for the user to enter permission info
3316 td.displayPermissionDialog(editPolicyEntry, false);
3317 }
3318 }
3319
3320 /**
3321 * Event handler for AddPrinOKButton button
3322 */
3323 class NewPolicyPrinOKButtonListener implements ActionListener {
3324
3325 private PolicyTool tool;
3326 private ToolWindow tw;
3327 private ToolDialog listDialog;
3328 private ToolDialog infoDialog;
3329 private boolean edit;
3330
3331 NewPolicyPrinOKButtonListener(PolicyTool tool,
3332 ToolWindow tw,
3333 ToolDialog listDialog,
3334 ToolDialog infoDialog,
3335 boolean edit) {
3336 this.tool = tool;
3337 this.tw = tw;
3338 this.listDialog = listDialog;
3339 this.infoDialog = infoDialog;
3340 this.edit = edit;
3341 }
3342
3343 public void actionPerformed(ActionEvent e) {
3344
3345 try {
3346 // read in the new principal info from Dialog Box
3347 PolicyParser.PrincipalEntry pppe =
3348 infoDialog.getPrinFromDialog();
3349 if (pppe != null) {
3350 try {
3351 tool.verifyPrincipal(pppe.getPrincipalClass(),
3352 pppe.getPrincipalName());
3353 } catch (ClassNotFoundException cnfe) {
3354 MessageFormat form = new MessageFormat
3355 (PolicyTool.getMessage
3356 ("Warning.Class.not.found.class"));
3357 Object[] source = {pppe.getPrincipalClass()};
3358 tool.warnings.addElement(form.format(source));
3359 tw.displayStatusDialog(infoDialog, form.format(source));
3360 }
3361
3362 // add the principal to the GUI principal list
3363 TaggedList prinList =
3364 (TaggedList)listDialog.getComponent(ToolDialog.PE_PRIN_LIST);
3365
3366 String prinString = ToolDialog.PrincipalEntryToUserFriendlyString(pppe);
3367 if (edit) {
3368 // if editing, replace the original principal
3369 int index = prinList.getSelectedIndex();
3370 prinList.replaceTaggedItem(prinString, pppe, index);
3371 } else {
3372 // if adding, just add it to the end
3373 prinList.addTaggedItem(prinString, pppe);
3374 }
3375 }
3376 infoDialog.dispose();
3377 } catch (Exception ee) {
3378 tw.displayErrorDialog(infoDialog, ee);
3379 }
3380 }
3381 }
3382
3383 /**
3384 * Event handler for AddPermOKButton button
3385 */
3386 class NewPolicyPermOKButtonListener implements ActionListener {
3387
3388 private PolicyTool tool;
3389 private ToolWindow tw;
3390 private ToolDialog listDialog;
3391 private ToolDialog infoDialog;
3392 private boolean edit;
3393
3394 NewPolicyPermOKButtonListener(PolicyTool tool,
3395 ToolWindow tw,
3396 ToolDialog listDialog,
3397 ToolDialog infoDialog,
3398 boolean edit) {
3399 this.tool = tool;
3400 this.tw = tw;
3401 this.listDialog = listDialog;
3402 this.infoDialog = infoDialog;
3403 this.edit = edit;
3404 }
3405
3406 public void actionPerformed(ActionEvent e) {
3407
3408 try {
3409 // read in the new permission info from Dialog Box
3410 PolicyParser.PermissionEntry pppe =
3411 infoDialog.getPermFromDialog();
3412
3413 try {
3414 tool.verifyPermission(pppe.permission, pppe.name, pppe.action);
3415 } catch (ClassNotFoundException cnfe) {
3416 MessageFormat form = new MessageFormat(PolicyTool.getMessage
3417 ("Warning.Class.not.found.class"));
3418 Object[] source = {pppe.permission};
3419 tool.warnings.addElement(form.format(source));
3420 tw.displayStatusDialog(infoDialog, form.format(source));
3421 }
3422
3423 // add the permission to the GUI permission list
3424 TaggedList permList =
3425 (TaggedList)listDialog.getComponent(ToolDialog.PE_PERM_LIST);
3426
3427 String permString = ToolDialog.PermissionEntryToUserFriendlyString(pppe);
3428 if (edit) {
3429 // if editing, replace the original permission
3430 int which = permList.getSelectedIndex();
3431 permList.replaceTaggedItem(permString, pppe, which);
3432 } else {
3433 // if adding, just add it to the end
3434 permList.addTaggedItem(permString, pppe);
3435 }
3436 infoDialog.dispose();
3437
3438 } catch (InvocationTargetException ite) {
3439 tw.displayErrorDialog(infoDialog, ite.getTargetException());
3440 } catch (Exception ee) {
3441 tw.displayErrorDialog(infoDialog, ee);
3442 }
3443 }
3444 }
3445
3446 /**
3447 * Event handler for RemovePrinButton button
3448 */
3449 class RemovePrinButtonListener implements ActionListener {
3450
3451 private PolicyTool tool;
3452 private ToolWindow tw;
3453 private ToolDialog td;
3454 private boolean edit;
3455
3456 RemovePrinButtonListener(PolicyTool tool, ToolWindow tw,
3457 ToolDialog td, boolean edit) {
3458 this.tool = tool;
3459 this.tw = tw;
3460 this.td = td;
3461 this.edit = edit;
3462 }
3463
3464 public void actionPerformed(ActionEvent e) {
3465
3466 // get the Principal selected from the Principal List
3467 TaggedList prinList = (TaggedList)td.getComponent(
3468 ToolDialog.PE_PRIN_LIST);
3469 int prinIndex = prinList.getSelectedIndex();
3470
3471 if (prinIndex < 0) {
3472 tw.displayErrorDialog(td, new Exception
3473 (PolicyTool.getMessage("No.principal.selected")));
3474 return;
3475 }
3476 // remove the principal from the display
3477 prinList.removeTaggedItem(prinIndex);
3478 }
3479 }
3480
3481 /**
3482 * Event handler for RemovePermButton button
3483 */
3484 class RemovePermButtonListener implements ActionListener {
3485
3486 private PolicyTool tool;
3487 private ToolWindow tw;
3488 private ToolDialog td;
3489 private boolean edit;
3490
3491 RemovePermButtonListener(PolicyTool tool, ToolWindow tw,
3492 ToolDialog td, boolean edit) {
3493 this.tool = tool;
3494 this.tw = tw;
3495 this.td = td;
3496 this.edit = edit;
3497 }
3498
3499 public void actionPerformed(ActionEvent e) {
3500
3501 // get the Permission selected from the Permission List
3502 TaggedList permList = (TaggedList)td.getComponent(
3503 ToolDialog.PE_PERM_LIST);
3504 int permIndex = permList.getSelectedIndex();
3505
3506 if (permIndex < 0) {
3507 tw.displayErrorDialog(td, new Exception
3508 (PolicyTool.getMessage("No.permission.selected")));
3509 return;
3510 }
3511 // remove the permission from the display
3512 permList.removeTaggedItem(permIndex);
3513
3514 }
3515 }
3516
3517 /**
3518 * Event handler for Edit Principal button
3519 *
3520 * We need the editPolicyEntry boolean to tell us if the user is
3521 * adding a new PolicyEntry at this time, or editing an existing entry.
3522 * If the user is adding a new PolicyEntry, we ONLY update the
3523 * GUI listing. If the user is editing an existing PolicyEntry, we
3524 * update both the GUI listing and the actual PolicyEntry.
3525 */
3526 class EditPrinButtonListener extends MouseAdapter implements ActionListener {
3527
3528 private PolicyTool tool;
3529 private ToolWindow tw;
3530 private ToolDialog td;
3531 private boolean editPolicyEntry;
3532
3533 EditPrinButtonListener(PolicyTool tool, ToolWindow tw,
3534 ToolDialog td, boolean editPolicyEntry) {
3535 this.tool = tool;
3536 this.tw = tw;
3537 this.td = td;
3538 this.editPolicyEntry = editPolicyEntry;
3539 }
3540
3541 public void actionPerformed(ActionEvent e) {
3542
3543 // get the Principal selected from the Principal List
3544 TaggedList list = (TaggedList)td.getComponent(
3545 ToolDialog.PE_PRIN_LIST);
3546 int prinIndex = list.getSelectedIndex();
3547
3548 if (prinIndex < 0) {
3549 tw.displayErrorDialog(td, new Exception
3550 (PolicyTool.getMessage("No.principal.selected")));
3551 return;
3552 }
3553 td.displayPrincipalDialog(editPolicyEntry, true);
3554 }
3555
3556 public void mouseClicked(MouseEvent evt) {
3557 if (evt.getClickCount() == 2) {
3558 actionPerformed(null);
3559 }
3560 }
3561 }
3562
3563 /**
3564 * Event handler for Edit Permission button
3565 *
3566 * We need the editPolicyEntry boolean to tell us if the user is
3567 * adding a new PolicyEntry at this time, or editing an existing entry.
3568 * If the user is adding a new PolicyEntry, we ONLY update the
3569 * GUI listing. If the user is editing an existing PolicyEntry, we
3570 * update both the GUI listing and the actual PolicyEntry.
3571 */
3572 class EditPermButtonListener extends MouseAdapter implements ActionListener {
3573
3574 private PolicyTool tool;
3575 private ToolWindow tw;
3576 private ToolDialog td;
3577 private boolean editPolicyEntry;
3578
3579 EditPermButtonListener(PolicyTool tool, ToolWindow tw,
3580 ToolDialog td, boolean editPolicyEntry) {
3581 this.tool = tool;
3582 this.tw = tw;
3583 this.td = td;
3584 this.editPolicyEntry = editPolicyEntry;
3585 }
3586
3587 public void actionPerformed(ActionEvent e) {
3588
3589 // get the Permission selected from the Permission List
3590 @SuppressWarnings("unchecked")
3591 JList<String> list = (JList<String>)td.getComponent(ToolDialog.PE_PERM_LIST);
3592 int permIndex = list.getSelectedIndex();
3593
3594 if (permIndex < 0) {
3595 tw.displayErrorDialog(td, new Exception
3596 (PolicyTool.getMessage("No.permission.selected")));
3597 return;
3598 }
3599 td.displayPermissionDialog(editPolicyEntry, true);
3600 }
3601
3602 public void mouseClicked(MouseEvent evt) {
3603 if (evt.getClickCount() == 2) {
3604 actionPerformed(null);
3605 }
3606 }
3607 }
3608
3609 /**
3610 * Event handler for Principal Popup Menu
3611 */
3612 class PrincipalTypeMenuListener implements ItemListener {
3613
3614 private ToolDialog td;
3615
3616 PrincipalTypeMenuListener(ToolDialog td) {
3617 this.td = td;
3618 }
3619
3620 public void itemStateChanged(ItemEvent e) {
3621 if (e.getStateChange() == ItemEvent.DESELECTED) {
3622 // We're only interested in SELECTED events
3623 return;
3624 }
3625
3626 @SuppressWarnings("unchecked")
3627 JComboBox<String> prin = (JComboBox<String>)td.getComponent(ToolDialog.PRD_PRIN_CHOICE);
3628 JTextField prinField = (JTextField)td.getComponent(
3629 ToolDialog.PRD_PRIN_TEXTFIELD);
3630 JTextField nameField = (JTextField)td.getComponent(
3631 ToolDialog.PRD_NAME_TEXTFIELD);
3632
3633 prin.getAccessibleContext().setAccessibleName(
3634 PolicyTool.splitToWords((String)e.getItem()));
3635 if (((String)e.getItem()).equals(ToolDialog.PRIN_TYPE)) {
3636 // ignore if they choose "Principal Type:" item
3637 if (prinField.getText() != null &&
3638 prinField.getText().length() > 0) {
3639 Prin inputPrin = ToolDialog.getPrin(prinField.getText(), true);
3640 prin.setSelectedItem(inputPrin.CLASS);
3641 }
3642 return;
3643 }
3644
3645 // if you change the principal, clear the name
3646 if (prinField.getText().indexOf((String)e.getItem()) == -1) {
3647 nameField.setText("");
3648 }
3649
3650 // set the text in the textfield and also modify the
3651 // pull-down choice menus to reflect the correct possible
3652 // set of names and actions
3653 Prin inputPrin = ToolDialog.getPrin((String)e.getItem(), false);
3654 if (inputPrin != null) {
3655 prinField.setText(inputPrin.FULL_CLASS);
3656 }
3657 }
3658 }
3659
3660 /**
3661 * Event handler for Permission Popup Menu
3662 */
3663 class PermissionMenuListener implements ItemListener {
3664
3665 private ToolDialog td;
3666
3667 PermissionMenuListener(ToolDialog td) {
3668 this.td = td;
3669 }
3670
3671 public void itemStateChanged(ItemEvent e) {
3672 if (e.getStateChange() == ItemEvent.DESELECTED) {
3673 // We're only interested in SELECTED events
3674 return;
3675 }
3676
3677 @SuppressWarnings("unchecked")
3678 JComboBox<String> perms = (JComboBox<String>)td.getComponent(
3679 ToolDialog.PD_PERM_CHOICE);
3680 @SuppressWarnings("unchecked")
3681 JComboBox<String> names = (JComboBox<String>)td.getComponent(
3682 ToolDialog.PD_NAME_CHOICE);
3683 @SuppressWarnings("unchecked")
3684 JComboBox<String> actions = (JComboBox<String>)td.getComponent(
3685 ToolDialog.PD_ACTIONS_CHOICE);
3686 JTextField nameField = (JTextField)td.getComponent(
3687 ToolDialog.PD_NAME_TEXTFIELD);
3688 JTextField actionsField = (JTextField)td.getComponent(
3689 ToolDialog.PD_ACTIONS_TEXTFIELD);
3690 JTextField permField = (JTextField)td.getComponent(
3691 ToolDialog.PD_PERM_TEXTFIELD);
3692 JTextField signedbyField = (JTextField)td.getComponent(
3693 ToolDialog.PD_SIGNEDBY_TEXTFIELD);
3694
3695 perms.getAccessibleContext().setAccessibleName(
3696 PolicyTool.splitToWords((String)e.getItem()));
3697
3698 // ignore if they choose the 'Permission:' item
3699 if (PolicyTool.collator.compare((String)e.getItem(),
3700 ToolDialog.PERM) == 0) {
3701 if (permField.getText() != null &&
3702 permField.getText().length() > 0) {
3703
3704 Perm inputPerm = ToolDialog.getPerm(permField.getText(), true);
3705 if (inputPerm != null) {
3706 perms.setSelectedItem(inputPerm.CLASS);
3707 }
3708 }
3709 return;
3710 }
3711
3712 // if you change the permission, clear the name, actions, and signedBy
3713 if (permField.getText().indexOf((String)e.getItem()) == -1) {
3714 nameField.setText("");
3715 actionsField.setText("");
3716 signedbyField.setText("");
3717 }
3718
3719 // set the text in the textfield and also modify the
3720 // pull-down choice menus to reflect the correct possible
3721 // set of names and actions
3722
3723 Perm inputPerm = ToolDialog.getPerm((String)e.getItem(), false);
3724 if (inputPerm == null) {
3725 permField.setText("");
3726 } else {
3727 permField.setText(inputPerm.FULL_CLASS);
3728 }
3729 td.setPermissionNames(inputPerm, names, nameField);
3730 td.setPermissionActions(inputPerm, actions, actionsField);
3731 }
3732 }
3733
3734 /**
3735 * Event handler for Permission Name Popup Menu
3736 */
3737 class PermissionNameMenuListener implements ItemListener {
3738
3739 private ToolDialog td;
3740
3741 PermissionNameMenuListener(ToolDialog td) {
3742 this.td = td;
3743 }
3744
3745 public void itemStateChanged(ItemEvent e) {
3746 if (e.getStateChange() == ItemEvent.DESELECTED) {
3747 // We're only interested in SELECTED events
3748 return;
3749 }
3750
3751 @SuppressWarnings("unchecked")
3752 JComboBox<String> names = (JComboBox<String>)td.getComponent(ToolDialog.PD_NAME_CHOICE);
3753 names.getAccessibleContext().setAccessibleName(
3754 PolicyTool.splitToWords((String)e.getItem()));
3755
3756 if (((String)e.getItem()).indexOf(ToolDialog.PERM_NAME) != -1)
3757 return;
3758
3759 JTextField tf = (JTextField)td.getComponent(ToolDialog.PD_NAME_TEXTFIELD);
3760 tf.setText((String)e.getItem());
3761 }
3762 }
3763
3764 /**
3765 * Event handler for Permission Actions Popup Menu
3766 */
3767 class PermissionActionsMenuListener implements ItemListener {
3768
3769 private ToolDialog td;
3770
3771 PermissionActionsMenuListener(ToolDialog td) {
3772 this.td = td;
3773 }
3774
3775 public void itemStateChanged(ItemEvent e) {
3776 if (e.getStateChange() == ItemEvent.DESELECTED) {
3777 // We're only interested in SELECTED events
3778 return;
3779 }
3780
3781 @SuppressWarnings("unchecked")
3782 JComboBox<String> actions = (JComboBox<String>)td.getComponent(
3783 ToolDialog.PD_ACTIONS_CHOICE);
3784 actions.getAccessibleContext().setAccessibleName((String)e.getItem());
3785
3786 if (((String)e.getItem()).indexOf(ToolDialog.PERM_ACTIONS) != -1)
3787 return;
3788
3789 JTextField tf = (JTextField)td.getComponent(
3790 ToolDialog.PD_ACTIONS_TEXTFIELD);
3791 if (tf.getText() == null || tf.getText().equals("")) {
3792 tf.setText((String)e.getItem());
3793 } else {
3794 if (tf.getText().indexOf((String)e.getItem()) == -1)
3795 tf.setText(tf.getText() + ", " + (String)e.getItem());
3796 }
3797 }
3798 }
3799
3800 /**
3801 * Event handler for all the children dialogs/windows
3802 */
3803 class ChildWindowListener implements WindowListener {
3804
3805 private ToolDialog td;
3806
3807 ChildWindowListener(ToolDialog td) {
3808 this.td = td;
3809 }
3810
3811 public void windowOpened(WindowEvent we) {
3812 }
3813
3814 public void windowClosing(WindowEvent we) {
3815 // same as pressing the "cancel" button
3816 td.setVisible(false);
3817 td.dispose();
3818 }
3819
3820 public void windowClosed(WindowEvent we) {
3821 }
3822
3823 public void windowIconified(WindowEvent we) {
3824 }
3825
3826 public void windowDeiconified(WindowEvent we) {
3827 }
3828
3829 public void windowActivated(WindowEvent we) {
3830 }
3831
3832 public void windowDeactivated(WindowEvent we) {
3833 }
3834 }
3835
3836 /**
3837 * Event handler for CancelButton button
3838 */
3839 class CancelButtonListener implements ActionListener {
3840
3841 private ToolDialog td;
3842
3843 CancelButtonListener(ToolDialog td) {
3844 this.td = td;
3845 }
3846
3847 public void actionPerformed(ActionEvent e) {
3848 td.setVisible(false);
3849 td.dispose();
3850 }
3851 }
3852
3853 /**
3854 * Event handler for ErrorOKButton button
3855 */
3856 class ErrorOKButtonListener implements ActionListener {
3857
3858 private ToolDialog ed;
3859
3860 ErrorOKButtonListener(ToolDialog ed) {
3861 this.ed = ed;
3862 }
3863
3864 public void actionPerformed(ActionEvent e) {
3865 ed.setVisible(false);
3866 ed.dispose();
3867 }
3868 }
3869
3870 /**
3871 * Event handler for StatusOKButton button
3872 */
3873 class StatusOKButtonListener implements ActionListener {
3874
3875 private ToolDialog sd;
3876
3877 StatusOKButtonListener(ToolDialog sd) {
3878 this.sd = sd;
3879 }
3880
3881 public void actionPerformed(ActionEvent e) {
3882 sd.setVisible(false);
3883 sd.dispose();
3884 }
3885 }
3886
3887 /**
3888 * Event handler for UserSaveYes button
3889 */
3890 class UserSaveYesButtonListener implements ActionListener {
3891
3892 private ToolDialog us;
3893 private PolicyTool tool;
3894 private ToolWindow tw;
3895 private int select;
3896
3897 UserSaveYesButtonListener(ToolDialog us, PolicyTool tool,
3898 ToolWindow tw, int select) {
3899 this.us = us;
3900 this.tool = tool;
3901 this.tw = tw;
3902 this.select = select;
3903 }
3904
3905 public void actionPerformed(ActionEvent e) {
3906
3907 // first get rid of the window
3908 us.setVisible(false);
3909 us.dispose();
3910
3911 try {
3912 String filename = ((JTextField)tw.getComponent(
3913 ToolWindow.MW_FILENAME_TEXTFIELD)).getText();
3914 if (filename == null || filename.equals("")) {
3915 us.displaySaveAsDialog(select);
3916
3917 // the above dialog will continue with the originally
3918 // requested command if necessary
3919 } else {
3920 // save the policy entries to a file
3921 tool.savePolicy(filename);
3922
3923 // display status
3924 MessageFormat form = new MessageFormat
3925 (PolicyTool.getMessage
3926 ("Policy.successfully.written.to.filename"));
3927 Object[] source = {filename};
3928 tw.displayStatusDialog(null, form.format(source));
3929
3930 // now continue with the originally requested command
3931 // (QUIT, NEW, or OPEN)
3932 us.userSaveContinue(tool, tw, us, select);
3933 }
3934 } catch (Exception ee) {
3935 // error -- just report it and bail
3936 tw.displayErrorDialog(null, ee);
3937 }
3938 }
3939 }
3940
3941 /**
3942 * Event handler for UserSaveNoButton
3943 */
3944 class UserSaveNoButtonListener implements ActionListener {
3945
3946 private PolicyTool tool;
3947 private ToolWindow tw;
3948 private ToolDialog us;
3949 private int select;
3950
3951 UserSaveNoButtonListener(ToolDialog us, PolicyTool tool,
3952 ToolWindow tw, int select) {
3953 this.us = us;
3954 this.tool = tool;
3955 this.tw = tw;
3956 this.select = select;
3957 }
3958
3959 public void actionPerformed(ActionEvent e) {
3960 us.setVisible(false);
3961 us.dispose();
3962
3963 // now continue with the originally requested command
3964 // (QUIT, NEW, or OPEN)
3965 us.userSaveContinue(tool, tw, us, select);
3966 }
3967 }
3968
3969 /**
3970 * Event handler for UserSaveCancelButton
3971 */
3972 class UserSaveCancelButtonListener implements ActionListener {
3973
3974 private ToolDialog us;
3975
3976 UserSaveCancelButtonListener(ToolDialog us) {
3977 this.us = us;
3978 }
3979
3980 public void actionPerformed(ActionEvent e) {
3981 us.setVisible(false);
3982 us.dispose();
3983
3984 // do NOT continue with the originally requested command
3985 // (QUIT, NEW, or OPEN)
3986 }
3987 }
3988
3989 /**
3990 * Event handler for ConfirmRemovePolicyEntryOKButtonListener
3991 */
3992 class ConfirmRemovePolicyEntryOKButtonListener implements ActionListener {
3993
3994 private PolicyTool tool;
3995 private ToolWindow tw;
3996 private ToolDialog us;
3997
3998 ConfirmRemovePolicyEntryOKButtonListener(PolicyTool tool,
3999 ToolWindow tw, ToolDialog us) {
4000 this.tool = tool;
4001 this.tw = tw;
4002 this.us = us;
4003 }
4004
4005 public void actionPerformed(ActionEvent e) {
4006 // remove the entry
4007 @SuppressWarnings("unchecked")
4008 JList<String> list = (JList<String>)tw.getComponent(ToolWindow.MW_POLICY_LIST);
4009 int index = list.getSelectedIndex();
4010 PolicyEntry entries[] = tool.getEntry();
4011 tool.removeEntry(entries[index]);
4012
4013 // redraw the window listing
4014 DefaultListModel<String> listModel = new DefaultListModel<>();
4015 list = new JList<>(listModel);
4016 list.setVisibleRowCount(15);
4017 list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
4018 list.addMouseListener(new PolicyListListener(tool, tw));
4019 entries = tool.getEntry();
4020 if (entries != null) {
4021 for (int i = 0; i < entries.length; i++) {
4022 listModel.addElement(entries[i].headerToString());
4023 }
4024 }
4025 tw.replacePolicyList(list);
4026 us.setVisible(false);
4027 us.dispose();
4028 }
4029 }
4030
4031 /**
4032 * Just a special name, so that the codes dealing with this exception knows
4033 * it's special, and does not pop out a warning box.
4034 */
4035 class NoDisplayException extends RuntimeException {
4036 private static final long serialVersionUID = -4611761427108719794L;
4037 }
4038
4039 /**
4040 * This is a java.awt.List that bind an Object to each String it holds.
4041 */
4042 class TaggedList extends JList<String> {
4043 private static final long serialVersionUID = -5676238110427785853L;
4044
4045 private java.util.List<Object> data = new LinkedList<>();
4046 public TaggedList(int i, boolean b) {
4047 super(new DefaultListModel<>());
4048 setVisibleRowCount(i);
4049 setSelectionMode(b ? ListSelectionModel.MULTIPLE_INTERVAL_SELECTION : ListSelectionModel.SINGLE_SELECTION);
4050 }
4051
4052 public Object getObject(int index) {
4053 return data.get(index);
4054 }
4055
4056 public void addTaggedItem(String string, Object object) {
4057 ((DefaultListModel<String>)getModel()).addElement(string);
4058 data.add(object);
4059 }
4060
4061 public void replaceTaggedItem(String string, Object object, int index) {
4062 ((DefaultListModel<String>)getModel()).set(index, string);
4063 data.set(index, object);
4064 }
4065
4066 public void removeTaggedItem(int index) {
4067 ((DefaultListModel<String>)getModel()).remove(index);
4068 data.remove(index);
4069 }
4070 }
4071
4072 /**
4073 * Convenience Principal Classes
4074 */
4075
4076 class Prin {
4077 public final String CLASS;
4078 public final String FULL_CLASS;
4079
4080 public Prin(String clazz, String fullClass) {
4081 this.CLASS = clazz;
4082 this.FULL_CLASS = fullClass;
4083 }
4084 }
4085
4086 class KrbPrin extends Prin {
4087 public KrbPrin() {
4088 super("KerberosPrincipal",
4089 "javax.security.auth.kerberos.KerberosPrincipal");
4090 }
4091 }
4092
4093 class X500Prin extends Prin {
4094 public X500Prin() {
4095 super("X500Principal",
4096 "javax.security.auth.x500.X500Principal");
4097 }
4098 }
4099
4100 /**
4101 * Convenience Permission Classes
4102 */
4103
4104 class Perm {
4105 public final String CLASS;
4106 public final String FULL_CLASS;
4107 public final String[] TARGETS;
4108 public final String[] ACTIONS;
4109
4110 public Perm(String clazz, String fullClass,
4111 String[] targets, String[] actions) {
4112
4113 this.CLASS = clazz;
4114 this.FULL_CLASS = fullClass;
4115 this.TARGETS = targets;
4116 this.ACTIONS = actions;
4117 }
4118 }
4119
4120 class AllPerm extends Perm {
4121 public AllPerm() {
4122 super("AllPermission", "java.security.AllPermission", null, null);
4123 }
4124 }
4125
4126 class AudioPerm extends Perm {
4127 public AudioPerm() {
4128 super("AudioPermission",
4129 "javax.sound.sampled.AudioPermission",
4130 new String[] {
4131 "play",
4132 "record"
4133 },
4134 null);
4135 }
4136 }
4137
4138 class AuthPerm extends Perm {
4139 public AuthPerm() {
4140 super("AuthPermission",
4141 "javax.security.auth.AuthPermission",
4142 new String[] {
4143 "doAs",
4144 "doAsPrivileged",
4145 "getSubject",
4146 "getSubjectFromDomainCombiner",
4147 "setReadOnly",
4148 "modifyPrincipals",
4149 "modifyPublicCredentials",
4150 "modifyPrivateCredentials",
4151 "refreshCredential",
4152 "destroyCredential",
4153 "createLoginContext.<" + PolicyTool.getMessage("name") + ">",
4154 "getLoginConfiguration",
4155 "setLoginConfiguration",
4156 "createLoginConfiguration.<" +
4157 PolicyTool.getMessage("configuration.type") + ">",
4158 "refreshLoginConfiguration"
4159 },
4160 null);
4161 }
4162 }
4163
4164 class AWTPerm extends Perm {
4165 public AWTPerm() {
4166 super("AWTPermission",
4167 "java.awt.AWTPermission",
4168 new String[] {
4169 "accessClipboard",
4170 "accessEventQueue",
4171 "accessSystemTray",
4172 "createRobot",
4173 "fullScreenExclusive",
4174 "listenToAllAWTEvents",
4175 "readDisplayPixels",
4176 "replaceKeyboardFocusManager",
4177 "setAppletStub",
4178 "setWindowAlwaysOnTop",
4179 "showWindowWithoutWarningBanner",
4180 "toolkitModality",
4181 "watchMousePointer"
4182 },
4183 null);
4184 }
4185 }
4186
4187 class DelegationPerm extends Perm {
4188 public DelegationPerm() {
4189 super("DelegationPermission",
4190 "javax.security.auth.kerberos.DelegationPermission",
4191 new String[] {
4192 // allow user input
4193 },
4194 null);
4195 }
4196 }
4197
4198 class FilePerm extends Perm {
4199 public FilePerm() {
4200 super("FilePermission",
4201 "java.io.FilePermission",
4202 new String[] {
4203 "<<ALL FILES>>"
4204 },
4205 new String[] {
4206 "read",
4207 "write",
4208 "delete",
4209 "execute"
4210 });
4211 }
4212 }
4213
4214 class URLPerm extends Perm {
4215 public URLPerm() {
4216 super("URLPermission",
4217 "java.net.URLPermission",
4218 new String[] {
4219 "<"+ PolicyTool.getMessage("url") + ">",
4220 },
4221 new String[] {
4222 "<" + PolicyTool.getMessage("method.list") + ">:<"
4223 + PolicyTool.getMessage("request.headers.list") + ">",
4224 });
4225 }
4226 }
4227
4228 class InqSecContextPerm extends Perm {
4229 public InqSecContextPerm() {
4230 super("InquireSecContextPermission",
4231 "com.sun.security.jgss.InquireSecContextPermission",
4232 new String[] {
4233 "KRB5_GET_SESSION_KEY",
4234 "KRB5_GET_TKT_FLAGS",
4235 "KRB5_GET_AUTHZ_DATA",
4236 "KRB5_GET_AUTHTIME"
4237 },
4238 null);
4239 }
4240 }
4241
4242 class LogPerm extends Perm {
4243 public LogPerm() {
4244 super("LoggingPermission",
4245 "java.util.logging.LoggingPermission",
4246 new String[] {
4247 "control"
4248 },
4249 null);
4250 }
4251 }
4252
4253 class MgmtPerm extends Perm {
4254 public MgmtPerm() {
4255 super("ManagementPermission",
4256 "java.lang.management.ManagementPermission",
4257 new String[] {
4258 "control",
4259 "monitor"
4260 },
4261 null);
4262 }
4263 }
4264
4265 class MBeanPerm extends Perm {
4266 public MBeanPerm() {
4267 super("MBeanPermission",
4268 "javax.management.MBeanPermission",
4269 new String[] {
4270 // allow user input
4271 },
4272 new String[] {
4273 "addNotificationListener",
4274 "getAttribute",
4275 "getClassLoader",
4276 "getClassLoaderFor",
4277 "getClassLoaderRepository",
4278 "getDomains",
4279 "getMBeanInfo",
4280 "getObjectInstance",
4281 "instantiate",
4282 "invoke",
4283 "isInstanceOf",
4284 "queryMBeans",
4285 "queryNames",
4286 "registerMBean",
4287 "removeNotificationListener",
4288 "setAttribute",
4289 "unregisterMBean"
4290 });
4291 }
4292 }
4293
4294 class MBeanSvrPerm extends Perm {
4295 public MBeanSvrPerm() {
4296 super("MBeanServerPermission",
4297 "javax.management.MBeanServerPermission",
4298 new String[] {
4299 "createMBeanServer",
4300 "findMBeanServer",
4301 "newMBeanServer",
4302 "releaseMBeanServer"
4303 },
4304 null);
4305 }
4306 }
4307
4308 class MBeanTrustPerm extends Perm {
4309 public MBeanTrustPerm() {
4310 super("MBeanTrustPermission",
4311 "javax.management.MBeanTrustPermission",
4312 new String[] {
4313 "register"
4314 },
4315 null);
4316 }
4317 }
4318
4319 class NetPerm extends Perm {
4320 public NetPerm() {
4321 super("NetPermission",
4322 "java.net.NetPermission",
4323 new String[] {
4324 "setDefaultAuthenticator",
4325 "requestPasswordAuthentication",
4326 "specifyStreamHandler",
4327 "setProxySelector",
4328 "getProxySelector",
4329 "setCookieHandler",
4330 "getCookieHandler",
4331 "setResponseCache",
4332 "getResponseCache"
4333 },
4334 null);
4335 }
4336 }
4337
4338 class PrivCredPerm extends Perm {
4339 public PrivCredPerm() {
4340 super("PrivateCredentialPermission",
4341 "javax.security.auth.PrivateCredentialPermission",
4342 new String[] {
4343 // allow user input
4344 },
4345 new String[] {
4346 "read"
4347 });
4348 }
4349 }
4350
4351 class PropPerm extends Perm {
4352 public PropPerm() {
4353 super("PropertyPermission",
4354 "java.util.PropertyPermission",
4355 new String[] {
4356 // allow user input
4357 },
4358 new String[] {
4359 "read",
4360 "write"
4361 });
4362 }
4363 }
4364
4365 class ReflectPerm extends Perm {
4366 public ReflectPerm() {
4367 super("ReflectPermission",
4368 "java.lang.reflect.ReflectPermission",
4369 new String[] {
4370 "suppressAccessChecks"
4371 },
4372 null);
4373 }
4374 }
4375
4376 class RuntimePerm extends Perm {
4377 public RuntimePerm() {
4378 super("RuntimePermission",
4379 "java.lang.RuntimePermission",
4380 new String[] {
4381 "createClassLoader",
4382 "getClassLoader",
4383 "setContextClassLoader",
4384 "enableContextClassLoaderOverride",
4385 "setSecurityManager",
4386 "createSecurityManager",
4387 "getenv.<" +
4388 PolicyTool.getMessage("environment.variable.name") + ">",
4389 "exitVM",
4390 "shutdownHooks",
4391 "setFactory",
4392 "setIO",
4393 "modifyThread",
4394 "stopThread",
4395 "modifyThreadGroup",
4396 "getProtectionDomain",
4397 "readFileDescriptor",
4398 "writeFileDescriptor",
4399 "loadLibrary.<" +
4400 PolicyTool.getMessage("library.name") + ">",
4401 "accessClassInPackage.<" +
4402 PolicyTool.getMessage("package.name")+">",
4403 "defineClassInPackage.<" +
4404 PolicyTool.getMessage("package.name")+">",
4405 "accessDeclaredMembers",
4406 "queuePrintJob",
4407 "getStackTrace",
4408 "setDefaultUncaughtExceptionHandler",
4409 "preferences",
4410 "usePolicy",
4411 // "inheritedChannel"
4412 },
4413 null);
4414 }
4415 }
4416
4417 class SecurityPerm extends Perm {
4418 public SecurityPerm() {
4419 super("SecurityPermission",
4420 "java.security.SecurityPermission",
4421 new String[] {
4422 "createAccessControlContext",
4423 "getDomainCombiner",
4424 "getPolicy",
4425 "setPolicy",
4426 "createPolicy.<" +
4427 PolicyTool.getMessage("policy.type") + ">",
4428 "getProperty.<" +
4429 PolicyTool.getMessage("property.name") + ">",
4430 "setProperty.<" +
4431 PolicyTool.getMessage("property.name") + ">",
4432 "insertProvider.<" +
4433 PolicyTool.getMessage("provider.name") + ">",
4434 "removeProvider.<" +
4435 PolicyTool.getMessage("provider.name") + ">",
4436 //"setSystemScope",
4437 //"setIdentityPublicKey",
4438 //"setIdentityInfo",
4439 //"addIdentityCertificate",
4440 //"removeIdentityCertificate",
4441 //"printIdentity",
4442 "clearProviderProperties.<" +
4443 PolicyTool.getMessage("provider.name") + ">",
4444 "putProviderProperty.<" +
4445 PolicyTool.getMessage("provider.name") + ">",
4446 "removeProviderProperty.<" +
4447 PolicyTool.getMessage("provider.name") + ">",
4448 //"getSignerPrivateKey",
4449 //"setSignerKeyPair"
4450 },
4451 null);
4452 }
4453 }
4454
4455 class SerialPerm extends Perm {
4456 public SerialPerm() {
4457 super("SerializablePermission",
4458 "java.io.SerializablePermission",
4459 new String[] {
4460 "enableSubclassImplementation",
4461 "enableSubstitution"
4462 },
4463 null);
4464 }
4465 }
4466
4467 class ServicePerm extends Perm {
4468 public ServicePerm() {
4469 super("ServicePermission",
4470 "javax.security.auth.kerberos.ServicePermission",
4471 new String[] {
4472 // allow user input
4473 },
4474 new String[] {
4475 "initiate",
4476 "accept"
4477 });
4478 }
4479 }
4480
4481 class SocketPerm extends Perm {
4482 public SocketPerm() {
4483 super("SocketPermission",
4484 "java.net.SocketPermission",
4485 new String[] {
4486 // allow user input
4487 },
4488 new String[] {
4489 "accept",
4490 "connect",
4491 "listen",
4492 "resolve"
4493 });
4494 }
4495 }
4496
4497 class SQLPerm extends Perm {
4498 public SQLPerm() {
4499 super("SQLPermission",
4500 "java.sql.SQLPermission",
4501 new String[] {
4502 "setLog",
4503 "callAbort",
4504 "setSyncFactory",
4505 "setNetworkTimeout",
4506 },
4507 null);
4508 }
4509 }
4510
4511 class SSLPerm extends Perm {
4512 public SSLPerm() {
4513 super("SSLPermission",
4514 "javax.net.ssl.SSLPermission",
4515 new String[] {
4516 "setHostnameVerifier",
4517 "getSSLSessionContext"
4518 },
4519 null);
4520 }
4521 }
4522
4523 class SubjDelegPerm extends Perm {
4524 public SubjDelegPerm() {
4525 super("SubjectDelegationPermission",
4526 "javax.management.remote.SubjectDelegationPermission",
4527 new String[] {
4528 // allow user input
4529 },
4530 null);
4531 }
4532 }