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 ").append(pppe.getDisplayClass())

   984                         .append(' ')

   985                         .append(pppe.getDisplayName(true));

   986                 if (list.hasNext()) sb.append(", ");

   987             }

   988             result = sb.toString();

   989         }

   990         return result;

   991     }

   992 

   993     /**

   994      * convert this policy entry into a PolicyParser.PermissionEntry

   995      */

   996     PolicyParser.PermissionEntry toPermissionEntry(Permission perm) {

   997 

   998         String actions = null;

   999 

  1000         // get the actions

  1001         if (perm.getActions() != null &&

  1002             perm.getActions().trim() != "")

  1003                 actions = perm.getActions();

  1004 

  1005         PolicyParser.PermissionEntry pe = new PolicyParser.PermissionEntry

  1006                         (perm.getClass().getName(),

  1007                         perm.getName(),

  1008                         actions);

  1009         return pe;

  1010     }

  1011 }

  1012 

  1013 /**

  1014  * The main window for the PolicyTool

  1015  */

  1016 class ToolWindow extends JFrame {

  1017     // use serialVersionUID from JDK 1.2.2 for interoperability

  1018     private static final long serialVersionUID = 5682568601210376777L;

  1019 

  1020     /* ESCAPE key */

  1021     static final KeyStroke escKey = KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0);

  1022 

  1023     /* external paddings */

  1024     public static final Insets TOP_PADDING = new Insets(25,0,0,0);

  1025     public static final Insets BOTTOM_PADDING = new Insets(0,0,25,0);

  1026     public static final Insets LITE_BOTTOM_PADDING = new Insets(0,0,10,0);

  1027     public static final Insets LR_PADDING = new Insets(0,10,0,10);

  1028     public static final Insets TOP_BOTTOM_PADDING = new Insets(15, 0, 15, 0);

  1029     public static final Insets L_TOP_BOTTOM_PADDING = new Insets(5,10,15,0);

  1030     public static final Insets LR_TOP_BOTTOM_PADDING = new Insets(15, 4, 15, 4);

  1031     public static final Insets LR_BOTTOM_PADDING = new Insets(0,10,5,10);

  1032     public static final Insets L_BOTTOM_PADDING = new Insets(0,10,5,0);

  1033     public static final Insets R_BOTTOM_PADDING = new Insets(0, 0, 25, 5);

  1034     public static final Insets R_PADDING = new Insets(0, 0, 0, 5);

  1035 

  1036     /* buttons and menus */

  1037     public static final String NEW_POLICY_FILE          = "New";

  1038     public static final String OPEN_POLICY_FILE         = "Open";

  1039     public static final String SAVE_POLICY_FILE         = "Save";

  1040     public static final String SAVE_AS_POLICY_FILE      = "Save.As";

  1041     public static final String VIEW_WARNINGS            = "View.Warning.Log";

  1042     public static final String QUIT                     = "Exit";

  1043     public static final String ADD_POLICY_ENTRY         = "Add.Policy.Entry";

  1044     public static final String EDIT_POLICY_ENTRY        = "Edit.Policy.Entry";

  1045     public static final String REMOVE_POLICY_ENTRY      = "Remove.Policy.Entry";

  1046     public static final String EDIT_KEYSTORE            = "Edit";

  1047     public static final String ADD_PUBKEY_ALIAS         = "Add.Public.Key.Alias";

  1048     public static final String REMOVE_PUBKEY_ALIAS      = "Remove.Public.Key.Alias";

  1049 

  1050     /* gridbag index for components in the main window (MW) */

  1051     public static final int MW_FILENAME_LABEL           = 0;

  1052     public static final int MW_FILENAME_TEXTFIELD       = 1;

  1053     public static final int MW_PANEL                    = 2;

  1054     public static final int MW_ADD_BUTTON               = 0;

  1055     public static final int MW_EDIT_BUTTON              = 1;

  1056     public static final int MW_REMOVE_BUTTON            = 2;

  1057     public static final int MW_POLICY_LIST              = 3; // follows MW_PANEL

  1058 

  1059     /* The preferred height of JTextField should match JComboBox. */

  1060     static final int TEXTFIELD_HEIGHT = new JComboBox<>().getPreferredSize().height;

  1061 

  1062     private PolicyTool tool;

  1063 

  1064     /**

  1065      * Constructor

  1066      */

  1067     ToolWindow(PolicyTool tool) {

  1068         this.tool = tool;

  1069     }

  1070 

  1071     /**

  1072      * Don't call getComponent directly on the window

  1073      */

  1074     public Component getComponent(int n) {

  1075         Component c = getContentPane().getComponent(n);

  1076         if (c instanceof JScrollPane) {

  1077             c = ((JScrollPane)c).getViewport().getView();

  1078         }

  1079         return c;

  1080     }

  1081 

  1082     /**

  1083      * Initialize the PolicyTool window with the necessary components

  1084      */

  1085     private void initWindow() {

  1086         // The ToolWindowListener will handle closing the window.

  1087         setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);

  1088 

  1089         // create the top menu bar

  1090         JMenuBar menuBar = new JMenuBar();

  1091 

  1092         // create a File menu

  1093         JMenu menu = new JMenu();

  1094         configureButton(menu, "File");

  1095         ActionListener actionListener = new FileMenuListener(tool, this);

  1096         addMenuItem(menu, NEW_POLICY_FILE, actionListener, "N");

  1097         addMenuItem(menu, OPEN_POLICY_FILE, actionListener, "O");

  1098         addMenuItem(menu, SAVE_POLICY_FILE, actionListener, "S");

  1099         addMenuItem(menu, SAVE_AS_POLICY_FILE, actionListener, null);

  1100         addMenuItem(menu, VIEW_WARNINGS, actionListener, null);

  1101         addMenuItem(menu, QUIT, actionListener, null);

  1102         menuBar.add(menu);

  1103 

  1104         // create a KeyStore menu

  1105         menu = new JMenu();

  1106         configureButton(menu, "KeyStore");

  1107         actionListener = new MainWindowListener(tool, this);

  1108         addMenuItem(menu, EDIT_KEYSTORE, actionListener, null);

  1109         menuBar.add(menu);

  1110         setJMenuBar(menuBar);

  1111 

  1112         // Create some space around components

  1113         ((JPanel)getContentPane()).setBorder(new EmptyBorder(6, 6, 6, 6));

  1114 

  1115         // policy entry listing

  1116         JLabel label = new JLabel(PolicyTool.getMessage("Policy.File."));

  1117         addNewComponent(this, label, MW_FILENAME_LABEL,

  1118                         0, 0, 1, 1, 0.0, 0.0, GridBagConstraints.BOTH,

  1119                         LR_TOP_BOTTOM_PADDING);

  1120         JTextField tf = new JTextField(50);

  1121         tf.setPreferredSize(new Dimension(tf.getPreferredSize().width, TEXTFIELD_HEIGHT));

  1122         tf.getAccessibleContext().setAccessibleName(

  1123                 PolicyTool.getMessage("Policy.File."));

  1124         tf.setEditable(false);

  1125         addNewComponent(this, tf, MW_FILENAME_TEXTFIELD,

  1126                         1, 0, 1, 1, 0.0, 0.0, GridBagConstraints.BOTH,

  1127                         LR_TOP_BOTTOM_PADDING);

  1128 

  1129 

  1130         // add ADD/REMOVE/EDIT buttons in a new panel

  1131         JPanel panel = new JPanel();

  1132         panel.setLayout(new GridBagLayout());

  1133 

  1134         JButton button = new JButton();