1 /*

     2  * Copyright (c) 1997, 2009, 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;

    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.*;

    41 import java.awt.event.*;

    42 import java.security.cert.Certificate;

    43 import java.security.cert.CertificateException;

    44 import java.security.*;

    45 import sun.security.provider.*;

    46 import sun.security.util.PolicyUtil;

    47 import javax.security.auth.x500.X500Principal;

    48 

    49 /**

    50  * PolicyTool may be used by users and administrators to configure the

    51  * overall java security policy (currently stored in the policy file).

    52  * Using PolicyTool administators may add and remove policies from

    53  * the policy file. <p>

    54  *

    55  * @see java.security.Policy

    56  * @since   1.2

    57  */

    58 

    59 public class PolicyTool {

    60 

    61     // for i18n

    62     static final java.util.ResourceBundle rb =

    63         java.util.ResourceBundle.getBundle("sun.security.util.Resources");

    64     static final Collator collator = Collator.getInstance();

    65     static {

    66         // this is for case insensitive string comparisons

    67         collator.setStrength(Collator.PRIMARY);

    68     };

    69 

    70     // anyone can add warnings

    71     Vector<String> warnings;

    72     boolean newWarning = false;

    73 

    74     // set to true if policy modified.

    75     // this way upon exit we know if to ask the user to save changes

    76     boolean modified = false;

    77 

    78     private static final boolean testing = false;

    79     private static final Class[] TWOPARAMS = { String.class, String.class };

    80     private static final Class[] ONEPARAMS = { String.class };

    81     private static final Class[] NOPARAMS  = {};

    82     /*

    83      * All of the policy entries are read in from the

    84      * policy file and stored here.  Updates to the policy entries

    85      * using addEntry() and removeEntry() are made here.  To ultimately save

    86      * the policy entries back to the policy file, the SavePolicy button

    87      * must be clicked.

    88      **/

    89     private static String policyFileName = null;

    90     private Vector<PolicyEntry> policyEntries = null;

    91     private PolicyParser parser = null;

    92 

    93     /* The public key alias information is stored here.  */

    94     private KeyStore keyStore = null;

    95     private String keyStoreName = " ";

    96     private String keyStoreType = " ";

    97     private String keyStoreProvider = " ";

    98     private String keyStorePwdURL = " ";

    99 

   100     /* standard PKCS11 KeyStore type */

   101     private static final String P11KEYSTORE = "PKCS11";

   102 

   103     /* reserved word for PKCS11 KeyStores */

   104     private static final String NONE = "NONE";

   105 

   106     /**

   107      * default constructor

   108      */

   109     private PolicyTool() {

   110         policyEntries = new Vector<PolicyEntry>();

   111         parser = new PolicyParser();

   112         warnings = new Vector<String>();

   113     }

   114 

   115     /**

   116      * get the PolicyFileName

   117      */

   118     String getPolicyFileName() {

   119         return policyFileName;

   120     }

   121 

   122     /**

   123      * set the PolicyFileName

   124      */

   125     void setPolicyFileName(String policyFileName) {

   126         this.policyFileName = policyFileName;

   127     }

   128 

   129    /**

   130     * clear keyStore info

   131     */

   132     void clearKeyStoreInfo() {

   133         this.keyStoreName = null;

   134         this.keyStoreType = null;

   135         this.keyStoreProvider = null;

   136         this.keyStorePwdURL = null;

   137 

   138         this.keyStore = null;

   139     }

   140 

   141     /**

   142      * get the keyStore URL name

   143      */

   144     String getKeyStoreName() {

   145         return keyStoreName;

   146     }

   147 

   148     /**

   149      * get the keyStore Type

   150      */

   151     String getKeyStoreType() {

   152         return keyStoreType;

   153     }

   154 

   155     /**

   156      * get the keyStore Provider

   157      */

   158     String getKeyStoreProvider() {

   159         return keyStoreProvider;

   160     }

   161 

   162     /**

   163      * get the keyStore password URL

   164      */

   165     String getKeyStorePwdURL() {

   166         return keyStorePwdURL;

   167     }

   168 

   169     /**

   170      * Open and read a policy file

   171      */

   172     void openPolicy(String filename) throws FileNotFoundException,

   173                                         PolicyParser.ParsingException,

   174                                         KeyStoreException,

   175                                         CertificateException,

   176                                         InstantiationException,

   177                                         MalformedURLException,

   178                                         IOException,

   179                                         NoSuchAlgorithmException,

   180                                         IllegalAccessException,

   181                                         NoSuchMethodException,

   182                                         UnrecoverableKeyException,

   183                                         NoSuchProviderException,

   184                                         ClassNotFoundException,

   185                                         PropertyExpander.ExpandException,

   186                                         InvocationTargetException {

   187 

   188         newWarning = false;

   189 

   190         // start fresh - blow away the current state

   191         policyEntries = new Vector<PolicyEntry>();

   192         parser = new PolicyParser();

   193         warnings = new Vector<String>();

   194         setPolicyFileName(null);

   195         clearKeyStoreInfo();

   196 

   197         // see if user is opening a NEW policy file

   198         if (filename == null) {

   199             modified = false;

   200             return;

   201         }

   202 

   203         // Read in the policy entries from the file and

   204         // populate the parser vector table.  The parser vector

   205         // table only holds the entries as strings, so it only

   206         // guarantees that the policies are syntactically

   207         // correct.

   208         setPolicyFileName(filename);

   209         parser.read(new FileReader(filename));

   210 

   211         // open the keystore

   212         openKeyStore(parser.getKeyStoreUrl(), parser.getKeyStoreType(),

   213                 parser.getKeyStoreProvider(), parser.getStorePassURL());

   214 

   215         // Update the local vector with the same policy entries.

   216         // This guarantees that the policy entries are not only

   217         // syntactically correct, but semantically valid as well.

   218         Enumeration<PolicyParser.GrantEntry> enum_ = parser.grantElements();

   219         while (enum_.hasMoreElements()) {

   220             PolicyParser.GrantEntry ge = enum_.nextElement();

   221 

   222             // see if all the signers have public keys

   223             if (ge.signedBy != null) {

   224 

   225                 String signers[] = parseSigners(ge.signedBy);

   226                 for (int i = 0; i < signers.length; i++) {

   227                     PublicKey pubKey = getPublicKeyAlias(signers[i]);

   228                     if (pubKey == null) {

   229                         newWarning = true;

   230                         MessageFormat form = new MessageFormat(rb.getString

   231                             ("Warning: A public key for alias " +

   232                             "'signers[i]' does not exist.  " +

   233                             "Make sure a KeyStore is properly configured."));

   234                         Object[] source = {signers[i]};

   235                         warnings.addElement(form.format(source));

   236                     }

   237                 }

   238             }

   239 

   240             // check to see if the Principals are valid

   241             ListIterator<PolicyParser.PrincipalEntry> prinList =

   242                                                 ge.principals.listIterator(0);

   243             while (prinList.hasNext()) {

   244                 PolicyParser.PrincipalEntry pe = prinList.next();

   245                 try {

   246                     verifyPrincipal(pe.getPrincipalClass(),

   247                                 pe.getPrincipalName());

   248                 } catch (ClassNotFoundException fnfe) {

   249                     newWarning = true;

   250                     MessageFormat form = new MessageFormat(rb.getString

   251                                 ("Warning: Class not found: class"));

   252                     Object[] source = {pe.getPrincipalClass()};

   253                     warnings.addElement(form.format(source));

   254                 }

   255             }

   256 

   257             // check to see if the Permissions are valid

   258             Enumeration<PolicyParser.PermissionEntry> perms =

   259                                                 ge.permissionElements();

   260             while (perms.hasMoreElements()) {

   261                 PolicyParser.PermissionEntry pe = perms.nextElement();

   262                 try {

   263                     verifyPermission(pe.permission, pe.name, pe.action);

   264                 } catch (ClassNotFoundException fnfe) {

   265                     newWarning = true;

   266                     MessageFormat form = new MessageFormat(rb.getString

   267                                 ("Warning: Class not found: class"));

   268                     Object[] source = {pe.permission};

   269                     warnings.addElement(form.format(source));

   270                 } catch (InvocationTargetException ite) {

   271                     newWarning = true;

   272                     MessageFormat form = new MessageFormat(rb.getString

   273                         ("Warning: Invalid argument(s) for constructor: arg"));

   274                     Object[] source = {pe.permission};

   275                     warnings.addElement(form.format(source));

   276                 }

   277 

   278                 // see if all the permission signers have public keys

   279                 if (pe.signedBy != null) {

   280 

   281                     String signers[] = parseSigners(pe.signedBy);

   282 

   283                     for (int i = 0; i < signers.length; i++) {

   284                         PublicKey pubKey = getPublicKeyAlias(signers[i]);

   285                         if (pubKey == null) {

   286                             newWarning = true;

   287                             MessageFormat form = new MessageFormat(rb.getString

   288                                 ("Warning: A public key for alias " +

   289                                 "'signers[i]' does not exist.  " +

   290                                "Make sure a KeyStore is properly configured."));

   291                             Object[] source = {signers[i]};

   292                             warnings.addElement(form.format(source));

   293                         }

   294                     }

   295                 }

   296             }

   297             PolicyEntry pEntry = new PolicyEntry(this, ge);

   298             policyEntries.addElement(pEntry);

   299         }

   300 

   301         // just read in the policy -- nothing has been modified yet

   302         modified = false;

   303     }

   304 

   305 

   306     /**

   307      * Save a policy to a file

   308      */

   309     void savePolicy(String filename)

   310     throws FileNotFoundException, IOException {

   311         // save the policy entries to a file

   312         parser.setKeyStoreUrl(keyStoreName);

   313         parser.setKeyStoreType(keyStoreType);

   314         parser.setKeyStoreProvider(keyStoreProvider);

   315         parser.setStorePassURL(keyStorePwdURL);

   316         parser.write(new FileWriter(filename));

   317         modified = false;

   318     }

   319 

   320     /**

   321      * Open the KeyStore

   322      */

   323     void openKeyStore(String name,

   324                 String type,

   325                 String provider,

   326                 String pwdURL) throws   KeyStoreException,

   327                                         NoSuchAlgorithmException,

   328                                         UnrecoverableKeyException,

   329                                         IOException,

   330                                         CertificateException,

   331                                         NoSuchProviderException,

   332                                         ExpandException {

   333 

   334         if (name == null && type == null &&

   335             provider == null && pwdURL == null) {

   336 

   337             // policy did not specify a keystore during open

   338             // or use wants to reset keystore values

   339 

   340             this.keyStoreName = null;

   341             this.keyStoreType = null;

   342             this.keyStoreProvider = null;

   343             this.keyStorePwdURL = null;

   344 

   345             // caller will set (tool.modified = true) if appropriate

   346 

   347             return;

   348         }

   349 

   350         URL policyURL = null;

   351         if (policyFileName != null) {

   352             File pfile = new File(policyFileName);

   353             policyURL = new URL("file:" + pfile.getCanonicalPath());

   354         }

   355 

   356         // although PolicyUtil.getKeyStore may properly handle

   357         // defaults and property expansion, we do it here so that

   358         // if the call is successful, we can set the proper values

   359         // (PolicyUtil.getKeyStore does not return expanded values)

   360 

   361         if (name != null && name.length() > 0) {

   362             name = PropertyExpander.expand(name).replace

   363                                         (File.separatorChar, '/');

   364         }

   365         if (type == null || type.length() == 0) {

   366             type = KeyStore.getDefaultType();

   367         }

   368         if (pwdURL != null && pwdURL.length() > 0) {

   369             pwdURL = PropertyExpander.expand(pwdURL).replace

   370                                         (File.separatorChar, '/');

   371         }

   372 

   373         try {

   374             this.keyStore = PolicyUtil.getKeyStore(policyURL,

   375                                                 name,

   376                                                 type,

   377                                                 provider,

   378                                                 pwdURL,

   379                                                 null);

   380         } catch (IOException ioe) {

   381 

   382             // copied from sun.security.pkcs11.SunPKCS11

   383             String MSG = "no password provided, and no callback handler " +

   384                         "available for retrieving password";

   385 

   386             Throwable cause = ioe.getCause();

   387             if (cause != null &&

   388                 cause instanceof javax.security.auth.login.LoginException &&

   389                 MSG.equals(cause.getMessage())) {

   390 

   391                 // throw a more friendly exception message

   392                 throw new IOException(MSG);

   393             } else {

   394                 throw ioe;

   395             }

   396         }

   397 

   398         this.keyStoreName = name;

   399         this.keyStoreType = type;

   400         this.keyStoreProvider = provider;

   401         this.keyStorePwdURL = pwdURL;

   402 

   403         // caller will set (tool.modified = true)

   404     }

   405 

   406     /**

   407      * Add a Grant entry to the overall policy at the specified index.

   408      * A policy entry consists of a CodeSource.

   409      */

   410     boolean addEntry(PolicyEntry pe, int index) {

   411 

   412         if (index < 0) {

   413             // new entry -- just add it to the end

   414             policyEntries.addElement(pe);

   415             parser.add(pe.getGrantEntry());

   416         } else {

   417             // existing entry -- replace old one

   418             PolicyEntry origPe = policyEntries.elementAt(index);

   419             parser.replace(origPe.getGrantEntry(), pe.getGrantEntry());

   420             policyEntries.setElementAt(pe, index);

   421         }

   422         return true;

   423     }

   424 

   425     /**

   426      * Add a Principal entry to an existing PolicyEntry at the specified index.

   427      * A Principal entry consists of a class, and name.

   428      *

   429      * If the principal already exists, it is not added again.

   430      */

   431     boolean addPrinEntry(PolicyEntry pe,

   432                         PolicyParser.PrincipalEntry newPrin,

   433                         int index) {

   434 

   435         // first add the principal to the Policy Parser entry

   436         PolicyParser.GrantEntry grantEntry = pe.getGrantEntry();

   437         if (grantEntry.contains(newPrin) == true)

   438             return false;

   439 

   440         LinkedList<PolicyParser.PrincipalEntry> prinList =

   441                                                 grantEntry.principals;

   442         if (index != -1)

   443             prinList.set(index, newPrin);

   444         else

   445             prinList.add(newPrin);

   446 

   447         modified = true;

   448         return true;

   449     }

   450 

   451     /**

   452      * Add a Permission entry to an existing PolicyEntry at the specified index.

   453      * A Permission entry consists of a permission, name, and actions.

   454      *

   455      * If the permission already exists, it is not added again.

   456      */

   457     boolean addPermEntry(PolicyEntry pe,

   458                         PolicyParser.PermissionEntry newPerm,

   459                         int index) {

   460 

   461         // first add the permission to the Policy Parser Vector

   462         PolicyParser.GrantEntry grantEntry = pe.getGrantEntry();

   463         if (grantEntry.contains(newPerm) == true)

   464             return false;

   465 

   466         Vector<PolicyParser.PermissionEntry> permList =

   467                                                 grantEntry.permissionEntries;

   468         if (index != -1)

   469             permList.setElementAt(newPerm, index);

   470         else

   471             permList.addElement(newPerm);

   472 

   473         modified = true;

   474         return true;

   475     }

   476 

   477     /**

   478      * Remove a Permission entry from an existing PolicyEntry.

   479      */

   480     boolean removePermEntry(PolicyEntry pe,

   481                         PolicyParser.PermissionEntry perm) {

   482 

   483         // remove the Permission from the GrantEntry

   484         PolicyParser.GrantEntry ppge = pe.getGrantEntry();

   485         modified = ppge.remove(perm);

   486         return modified;

   487     }

   488 

   489     /**

   490      * remove an entry from the overall policy

   491      */

   492     boolean removeEntry(PolicyEntry pe) {

   493 

   494         parser.remove(pe.getGrantEntry());

   495         modified = true;

   496         return (policyEntries.removeElement(pe));

   497     }

   498 

   499     /**

   500      * retrieve all Policy Entries

   501      */

   502     PolicyEntry[] getEntry() {

   503 

   504         if (policyEntries.size() > 0) {

   505             PolicyEntry entries[] = new PolicyEntry[policyEntries.size()];

   506             for (int i = 0; i < policyEntries.size(); i++)

   507                 entries[i] = policyEntries.elementAt(i);

   508             return entries;

   509         }

   510         return null;

   511     }

   512 

   513     /**

   514      * Retrieve the public key mapped to a particular name.

   515      * If the key has expired, a KeyException is thrown.

   516      */

   517     PublicKey getPublicKeyAlias(String name) throws KeyStoreException {

   518         if (keyStore == null) {

   519             return null;

   520         }

   521 

   522         Certificate cert = keyStore.getCertificate(name);

   523         if (cert == null) {

   524             return null;

   525         }

   526         PublicKey pubKey = cert.getPublicKey();

   527         return pubKey;

   528     }

   529 

   530     /**

   531      * Retrieve all the alias names stored in the certificate database

   532      */

   533     String[] getPublicKeyAlias() throws KeyStoreException {

   534 

   535         int numAliases = 0;

   536         String aliases[] = null;

   537 

   538         if (keyStore == null) {

   539             return null;

   540         }

   541         Enumeration<String> enum_ = keyStore.aliases();

   542 

   543         // first count the number of elements

   544         while (enum_.hasMoreElements()) {

   545             enum_.nextElement();

   546             numAliases++;

   547         }

   548 

   549         if (numAliases > 0) {

   550             // now copy them into an array

   551             aliases = new String[numAliases];

   552             numAliases = 0;

   553             enum_ = keyStore.aliases();

   554             while (enum_.hasMoreElements()) {

   555                 aliases[numAliases] = new String(enum_.nextElement());

   556                 numAliases++;

   557             }

   558         }

   559         return aliases;

   560     }

   561 

   562     /**

   563      * This method parses a single string of signers separated by commas

   564      * ("jordan, duke, pippen") into an array of individual strings.

   565      */

   566     String[] parseSigners(String signedBy) {

   567 

   568         String signers[] = null;

   569         int numSigners = 1;

   570         int signedByIndex = 0;

   571         int commaIndex = 0;

   572         int signerNum = 0;

   573 

   574         // first pass thru "signedBy" counts the number of signers

   575         while (commaIndex >= 0) {

   576             commaIndex = signedBy.indexOf(',', signedByIndex);

   577             if (commaIndex >= 0) {

   578                 numSigners++;

   579                 signedByIndex = commaIndex + 1;

   580             }

   581         }

   582         signers = new String[numSigners];

   583 

   584         // second pass thru "signedBy" transfers signers to array

   585         commaIndex = 0;

   586         signedByIndex = 0;

   587         while (commaIndex >= 0) {

   588             if ((commaIndex = signedBy.indexOf(',', signedByIndex)) >= 0) {

   589                 // transfer signer and ignore trailing part of the string

   590                 signers[signerNum] =

   591                         signedBy.substring(signedByIndex, commaIndex).trim();

   592                 signerNum++;

   593                 signedByIndex = commaIndex + 1;

   594             } else {

   595                 // we are at the end of the string -- transfer signer

   596                 signers[signerNum] = signedBy.substring(signedByIndex).trim();

   597             }

   598         }

   599         return signers;

   600     }

   601 

   602     /**

   603      * Check to see if the Principal contents are OK

   604      */

   605     void verifyPrincipal(String type, String name)

   606         throws ClassNotFoundException,

   607                InstantiationException

   608     {

   609         if (type.equals(PolicyParser.PrincipalEntry.WILDCARD_CLASS) ||

   610             type.equals(PolicyParser.REPLACE_NAME)) {

   611             return;

   612         };

   613         Class<?> PRIN = Class.forName("java.security.Principal");

   614         Class<?> pc = Class.forName(type, true,

   615                 Thread.currentThread().getContextClassLoader());

   616         if (!PRIN.isAssignableFrom(pc)) {

   617             MessageFormat form = new MessageFormat(rb.getString

   618                         ("Illegal Principal Type: type"));

   619             Object[] source = {type};

   620             throw new InstantiationException(form.format(source));

   621         }

   622 

   623         if (ToolDialog.X500_PRIN_CLASS.equals(pc.getName())) {

   624             // PolicyParser checks validity of X500Principal name

   625             // - PolicyTool needs to as well so that it doesn't store

   626             //   an invalid name that can't be read in later

   627             //

   628             // this can throw an IllegalArgumentException

   629             X500Principal newP = new X500Principal(name);

   630         }

   631     }

   632 

   633     /**

   634      * Check to see if the Permission contents are OK

   635      */

   636     void verifyPermission(String type,

   637                                     String name,

   638                                     String actions)

   639         throws ClassNotFoundException,

   640                InstantiationException,

   641                IllegalAccessException,

   642                NoSuchMethodException,

   643                InvocationTargetException

   644     {

   645 

   646         //XXX we might want to keep a hash of created factories...

   647         Class<?> pc = Class.forName(type, true,

   648                 Thread.currentThread().getContextClassLoader());

   649         Constructor<?> c = null;

   650         Vector<String> objects = new Vector<String>(2);

   651         if (name != null) objects.add(name);

   652         if (actions != null) objects.add(actions);

   653         switch (objects.size()) {

   654         case 0:

   655             try {

   656                 c = pc.getConstructor(NOPARAMS);

   657                 break;

   658             } catch (NoSuchMethodException ex) {

   659                 // proceed to the one-param constructor

   660                 objects.add(null);

   661             }

   662         case 1:

   663             try {

   664                 c = pc.getConstructor(ONEPARAMS);

   665                 break;

   666             } catch (NoSuchMethodException ex) {

   667                 // proceed to the two-param constructor

   668                 objects.add(null);

   669             }

   670         case 2:

   671             c = pc.getConstructor(TWOPARAMS);

   672             break;

   673         }

   674         Object parameters[] = objects.toArray();

   675         Permission p = (Permission)c.newInstance(parameters);

   676     }

   677 

   678     /*

   679      * Parse command line arguments.

   680      */

   681     static void parseArgs(String args[]) {

   682         /* parse flags */

   683         int n = 0;

   684 

   685         for (n=0; (n < args.length) && args[n].startsWith("-"); n++) {

   686 

   687             String flags = args[n];

   688 

   689             if (collator.compare(flags, "-file") == 0) {

   690                 if (++n == args.length) usage();

   691                 policyFileName = args[n];

   692             } else {

   693                 MessageFormat form = new MessageFormat(rb.getString

   694                                 ("Illegal option: option"));

   695                 Object[] source = { flags };

   696                 System.err.println(form.format(source));

   697                 usage();

   698             }

   699         }

   700     }

   701 

   702     static void usage() {

   703         System.out.println(rb.getString("Usage: policytool [options]"));

   704         System.out.println();

   705         System.out.println(rb.getString

   706                 ("  [-file <file>]    policy file location"));

   707         System.out.println();

   708 

   709         System.exit(1);

   710     }

   711 

   712     /**

   713      * run the PolicyTool

   714      */

   715     public static void main(String args[]) {

   716         parseArgs(args);

   717         ToolWindow tw = new ToolWindow(new PolicyTool());

   718         tw.displayToolWindow(args);

   719     }

   720 

   721     // split instr to words according to capitalization,

   722     // like, AWTControl -> A W T Control

   723     // this method is for easy pronounciation

   724     static String splitToWords(String instr) {

   725         return instr.replaceAll("([A-Z])", " $1");

   726     }

   727 

   728 }

   729 

   730 /**

   731  * Each entry in the policy configuration file is represented by a

   732  * PolicyEntry object.

   733  *

   734  * A PolicyEntry is a (CodeSource,Permission) pair.  The

   735  * CodeSource contains the (URL, PublicKey) that together identify

   736  * where the Java bytecodes come from and who (if anyone) signed

   737  * them.  The URL could refer to localhost.  The URL could also be

   738  * null, meaning that this policy entry is given to all comers, as

   739  * long as they match the signer field.  The signer could be null,

   740  * meaning the code is not signed.

   741  *

   742  * The Permission contains the (Type, Name, Action) triplet.

   743  *

   744  */

   745 class PolicyEntry {

   746 

   747     private CodeSource codesource;

   748     private PolicyTool tool;

   749     private PolicyParser.GrantEntry grantEntry;

   750     private boolean testing = false;

   751 

   752     /**

   753      * Create a PolicyEntry object from the information read in

   754      * from a policy file.

   755      */

   756     PolicyEntry(PolicyTool tool, PolicyParser.GrantEntry ge)

   757     throws MalformedURLException, NoSuchMethodException,

   758     ClassNotFoundException, InstantiationException, IllegalAccessException,

   759     InvocationTargetException, CertificateException,

   760     IOException, NoSuchAlgorithmException, UnrecoverableKeyException {

   761 

   762         this.tool = tool;

   763 

   764         URL location = null;

   765 

   766         // construct the CodeSource

   767         if (ge.codeBase != null)

   768             location = new URL(ge.codeBase);

   769         this.codesource = new CodeSource(location,

   770             (java.security.cert.Certificate[]) null);

   771 

   772         if (testing) {

   773             System.out.println("Adding Policy Entry:");

   774             System.out.println("    CodeBase = " + location);

   775             System.out.println("    Signers = " + ge.signedBy);

   776             System.out.println("    with " + ge.principals.size() +

   777                     " Principals");

   778         }

   779 

   780         this.grantEntry = ge;

   781     }

   782 

   783     /**

   784      * get the codesource associated with this PolicyEntry

   785      */

   786     CodeSource getCodeSource() {

   787         return codesource;

   788     }

   789 

   790     /**

   791      * get the GrantEntry associated with this PolicyEntry

   792      */

   793     PolicyParser.GrantEntry getGrantEntry() {

   794         return grantEntry;

   795     }

   796 

   797     /**

   798      * convert the header portion, i.e. codebase, signer, principals, of

   799      * this policy entry into a string

   800      */

   801     String headerToString() {

   802         String pString = principalsToString();

   803         if (pString.length() == 0) {

   804             return codebaseToString();

   805         } else {

   806             return codebaseToString() + ", " + pString;

   807         }

   808     }

   809 

   810     /**

   811      * convert the Codebase/signer portion of this policy entry into a string

   812      */

   813     String codebaseToString() {

   814 

   815         String stringEntry = new String();

   816 

   817         if (grantEntry.codeBase != null &&

   818             grantEntry.codeBase.equals("") == false)

   819             stringEntry = stringEntry.concat

   820                                 ("CodeBase \"" +

   821                                 grantEntry.codeBase +

   822                                 "\"");

   823 

   824         if (grantEntry.signedBy != null &&

   825             grantEntry.signedBy.equals("") == false)

   826             stringEntry = ((stringEntry.length() > 0) ?

   827                 stringEntry.concat(", SignedBy \"" +

   828                                 grantEntry.signedBy +

   829                                 "\"") :

   830                 stringEntry.concat("SignedBy \"" +

   831                                 grantEntry.signedBy +

   832                                 "\""));

   833 

   834         if (stringEntry.length() == 0)

   835             return new String("CodeBase <ALL>");

   836         return stringEntry;

   837     }

   838 

   839     /**

   840      * convert the Principals portion of this policy entry into a string

   841      */

   842     String principalsToString() {

   843         String result = "";

   844         if ((grantEntry.principals != null) &&

   845             (!grantEntry.principals.isEmpty())) {

   846             StringBuffer buffer = new StringBuffer(200);

   847             ListIterator<PolicyParser.PrincipalEntry> list =

   848                                 grantEntry.principals.listIterator();

   849             while (list.hasNext()) {

   850                 PolicyParser.PrincipalEntry pppe = list.next();

   851                 buffer.append(" Principal " + pppe.getDisplayClass() + " " +

   852                     pppe.getDisplayName(true));

   853                 if (list.hasNext()) buffer.append(", ");

   854             }

   855             result = buffer.toString();

   856         }

   857         return result;

   858     }

   859 

   860     /**

   861      * convert this policy entry into a PolicyParser.PermissionEntry

   862      */

   863     PolicyParser.PermissionEntry toPermissionEntry(Permission perm) {

   864 

   865         String actions = null;

   866 

   867         // get the actions

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

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

   870                 actions = perm.getActions();

   871 

   872         PolicyParser.PermissionEntry pe = new PolicyParser.PermissionEntry

   873                         (perm.getClass().getName(),

   874                         perm.getName(),

   875                         actions);

   876         return pe;

   877     }

   878 }

   879 

   880 /**

   881  * The main window for the PolicyTool

   882  */

   883 class ToolWindow extends Frame {

   884     // use serialVersionUID from JDK 1.2.2 for interoperability

   885     private static final long serialVersionUID = 5682568601210376777L;

   886 

   887     /* external paddings */

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

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

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

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

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

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

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

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

   896     public static final Insets R_BOTTOM_PADDING = new Insets(0,0,5,10);

   897 

   898     /* buttons and menus */

   899     public static final String NEW_POLICY_FILE          =

   900                         PolicyTool.rb.getString("New");

   901     public static final String OPEN_POLICY_FILE         =

   902                         PolicyTool.rb.getString("Open");

   903     public static final String SAVE_POLICY_FILE         =

   904                         PolicyTool.rb.getString("Save");

   905     public static final String SAVE_AS_POLICY_FILE      =

   906                         PolicyTool.rb.getString("Save As");

   907     public static final String VIEW_WARNINGS            =

   908                         PolicyTool.rb.getString("View Warning Log");

   909     public static final String QUIT                     =

   910                         PolicyTool.rb.getString("Exit");

   911     public static final String ADD_POLICY_ENTRY         =

   912                         PolicyTool.rb.getString("Add Policy Entry");

   913     public static final String EDIT_POLICY_ENTRY        =

   914                         PolicyTool.rb.getString("Edit Policy Entry");

   915     public static final String REMOVE_POLICY_ENTRY      =

   916                         PolicyTool.rb.getString("Remove Policy Entry");

   917     public static final String EDIT_KEYSTORE            =

   918                         PolicyTool.rb.getString("Edit");

   919     public static final String ADD_PUBKEY_ALIAS         =

   920                         PolicyTool.rb.getString("Add Public Key Alias");

   921     public static final String REMOVE_PUBKEY_ALIAS      =

   922                         PolicyTool.rb.getString("Remove Public Key Alias");

   923 

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

   925     public static final int MW_FILENAME_LABEL           = 0;

   926     public static final int MW_FILENAME_TEXTFIELD       = 1;

   927     public static final int MW_PANEL                    = 2;

   928     public static final int MW_ADD_BUTTON               = 0;

   929     public static final int MW_EDIT_BUTTON              = 1;

   930     public static final int MW_REMOVE_BUTTON            = 2;

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

   932 

   933     private PolicyTool tool;

   934 

   935     /**

   936      * Constructor

   937      */

   938     ToolWindow(PolicyTool tool) {

   939         this.tool = tool;

   940     }

   941 

   942     /**

   943      * Initialize the PolicyTool window with the necessary components

   944      */

   945     private void initWindow() {

   946 

   947         // create the top menu bar

   948         MenuBar menuBar = new MenuBar();

   949 

   950         // create a File menu

   951         Menu menu = new Menu(PolicyTool.rb.getString("File"));

   952         menu.add(NEW_POLICY_FILE);

   953         menu.add(OPEN_POLICY_FILE);

   954         menu.add(SAVE_POLICY_FILE);

   955         menu.add(SAVE_AS_POLICY_FILE);

   956         menu.add(VIEW_WARNINGS);

   957         menu.add(QUIT);

   958         menu.addActionListener(new FileMenuListener(tool, this));

   959         menuBar.add(menu);

   960         setMenuBar(menuBar);

   961 

   962         // create a KeyStore menu

   963         menu = new Menu(PolicyTool.rb.getString("KeyStore"));

   964         menu.add(EDIT_KEYSTORE);

   965         menu.addActionListener(new MainWindowListener(tool, this));

   966         menuBar.add(menu);

   967         setMenuBar(menuBar);

   968 

   969 

   970         // policy entry listing

   971         Label label = new Label(PolicyTool.rb.getString("Policy File:"));

   972         addNewComponent(this, label, MW_FILENAME_LABEL,

   973                         0, 0, 1, 1, 0.0, 0.0, GridBagConstraints.BOTH,

   974                         TOP_BOTTOM_PADDING);

   975         TextField tf = new TextField(50);

   976         tf.getAccessibleContext().setAccessibleName(

   977                 PolicyTool.rb.getString("Policy File:"));

   978         tf.setEditable(false);

   979         addNewComponent(this, tf, MW_FILENAME_TEXTFIELD,

   980                         1, 0, 1, 1, 0.0, 0.0, GridBagConstraints.BOTH,

   981                         TOP_BOTTOM_PADDING);

   982 

   983 

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

   985         Panel panel = new Panel();

   986         panel.setLayout(new GridBagLayout());

   987 

   988         Button button = new Button(ADD_POLICY_ENTRY);

   989         button.addActionListener(new MainWindowListener(tool, this));

   990         addNewComponent(panel, button, MW_ADD_BUTTON,

   991                         0, 0, 1, 1, 0.0, 0.0, GridBagConstraints.BOTH,

   992                         LR_PADDING);

   993 

   994         button = new Button(EDIT_POLICY_ENTRY);

   995         button.addActionListener(new MainWindowListener(tool, this));

   996         addNewComponent(panel, button, MW_EDIT_BUTTON,

   997                         1, 0, 1, 1, 0.0, 0.0, GridBagConstraints.BOTH,

   998                         LR_PADDING);

   999 

  1000         button = new Button(REMOVE_POLICY_ENTRY);

  1001         button.addActionListener(new MainWindowListener(tool, this));

  1002         addNewComponent(panel, button, MW_REMOVE_BUTTON,

  1003                         2, 0, 1, 1, 0.0, 0.0, GridBagConstraints.BOTH,

  1004                         LR_PADDING);

  1005 

  1006         addNewComponent(this, panel, MW_PANEL,

  1007                         0, 2, 2, 1, 0.0, 0.0, GridBagConstraints.BOTH,

  1008                         BOTTOM_PADDING);

  1009 

  1010 

  1011         String policyFile = tool.getPolicyFileName();

  1012         if (policyFile == null) {

  1013             String userHome;

  1014             userHome = java.security.AccessController.doPrivileged(

  1015                     new sun.security.action.GetPropertyAction("user.home"));

  1016             policyFile = userHome + File.separatorChar + ".java.policy";

  1017         }

  1018 

  1019         try {

  1020             // open the policy file

  1021             tool.openPolicy(policyFile);

  1022 

  1023             // display the policy entries via the policy list textarea

  1024             List list = new List(40, false);

  1025             list.addActionListener(new PolicyListListener(tool, this));

  1026             PolicyEntry entries[] = tool.getEntry();

  1027             if (entries != null) {

  1028                 for (int i = 0; i < entries.length; i++)

  1029                     list.add(entries[i].headerToString());

  1030             }

  1031             TextField newFilename = (TextField)

  1032                                 getComponent(MW_FILENAME_TEXTFIELD);

  1033             newFilename.setText(policyFile);

  1034             initPolicyList(list);

  1035 

  1036         } catch (FileNotFoundException fnfe) {

  1037             // add blank policy listing

  1038             List list = new List(40, false);

  1039             list.addActionListener(new PolicyListListener(tool, this));

  1040             initPolicyList(list);

  1041             tool.setPolicyFileName(null);

  1042             tool.modified = false;

  1043             setVisible(true);

  1044 

  1045             // just add warning

  1046             tool.warnings.addElement(fnfe.toString());

  1047 

  1048         } catch (Exception e) {

  1049             // add blank policy listing

  1050             List list = new List(40, false);

  1051             list.addActionListener(new PolicyListListener(tool, this));

  1052             initPolicyList(list);

  1053             tool.setPolicyFileName(null);

  1054             tool.modified = false;

  1055             setVisible(true);

  1056 

  1057             // display the error

  1058             MessageFormat form = new MessageFormat(PolicyTool.rb.getString

  1059                 ("Could not open policy file: policyFile: e.toString()"));

  1060             Object[] source = {policyFile, e.toString()};

  1061             displayErrorDialog(null, form.format(source));

  1062         }

  1063     }

  1064 

  1065 

  1066     /**

  1067      * Add a component to the PolicyTool window

  1068      */

  1069     void addNewComponent(Container container, Component component,

  1070         int index, int gridx, int gridy, int gridwidth, int gridheight,

  1071         double weightx, double weighty, int fill, Insets is) {

  1072 

  1073         // add the component at the specified gridbag index

  1074         container.add(component, index);

  1075 

  1076         // set the constraints

  1077         GridBagLayout gbl = (GridBagLayout)container.getLayout();

  1078         GridBagConstraints gbc = new GridBagConstraints();

  1079         gbc.gridx = gridx;

  1080         gbc.gridy = gridy;

  1081         gbc.gridwidth = gridwidth;

  1082         gbc.gridheight = gridheight;

  1083         gbc.weightx = weightx;

  1084         gbc.weighty = weighty;

  1085         gbc.fill = fill;

  1086         if (is != null) gbc.insets = is;

  1087         gbl.setConstraints(component, gbc);

  1088     }

  1089 

  1090 

  1091     /**

  1092      * Add a component to the PolicyTool window without external padding

  1093      */

  1094     void addNewComponent(Container container, Component component,

  1095         int index, int gridx, int gridy, int gridwidth, int gridheight,

  1096         double weightx, double weighty, int fill) {

  1097 

  1098         // delegate with "null" external padding

  1099         addNewComponent(container, component, index, gridx, gridy,

  1100                         gridwidth, gridheight, weightx, weighty,

  1101                         fill, null);

  1102     }

  1103 

  1104 

  1105     /**

  1106      * Init the policy_entry_list TEXTAREA component in the

  1107      * PolicyTool window

  1108      */

  1109     void initPolicyList(List policyList) {

  1110 

  1111         // add the policy list to the window

  1112         addNewComponent(this, policyList, MW_POLICY_LIST,

  1113                         0, 3, 2, 1, 1.0, 1.0, GridBagConstraints.BOTH);

  1114     }

  1115 

  1116     /**

  1117      * Replace the policy_entry_list TEXTAREA component in the

  1118      * PolicyTool window with an updated one.

  1119      */

  1120     void replacePolicyList(List policyList) {

  1121 

  1122         // remove the original list of Policy Entries

  1123         // and add the new list of entries

  1124         List list = (List)getComponent(MW_POLICY_LIST);

  1125         list.removeAll();

  1126         String newItems[] = policyList.getItems();

  1127         for (int i = 0; i < newItems.length; i++)

  1128             list.add(newItems[i]);

  1129     }

  1130 

  1131     /**

  1132      * display the main PolicyTool window

  1133      */

  1134     void displayToolWindow(String args[]) {