1 /*
   2  * Copyright (c) 1997, 2019, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  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 java.security;
  27 
  28 import java.io.InvalidObjectException;
  29 import java.io.IOException;
  30 import java.io.ObjectInputStream;
  31 import java.io.ObjectOutputStream;
  32 import java.io.ObjectStreamField;
  33 import java.io.Serializable;
  34 import java.util.Enumeration;
  35 import java.util.HashMap;
  36 import java.util.Hashtable;
  37 import java.util.Iterator;
  38 import java.util.List;
  39 import java.util.Map;
  40 import java.util.NoSuchElementException;
  41 import java.util.concurrent.ConcurrentHashMap;
  42 
  43 /**
  44  * This class represents a heterogeneous collection of Permissions. That is,
  45  * it contains different types of Permission objects, organized into
  46  * PermissionCollections. For example, if any
  47  * {@code java.io.FilePermission} objects are added to an instance of
  48  * this class, they are all stored in a single
  49  * PermissionCollection. It is the PermissionCollection returned by a call to
  50  * the {@code newPermissionCollection} method in the FilePermission class.
  51  * Similarly, any {@code java.lang.RuntimePermission} objects are
  52  * stored in the PermissionCollection returned by a call to the
  53  * {@code newPermissionCollection} method in the
  54  * RuntimePermission class. Thus, this class represents a collection of
  55  * PermissionCollections.
  56  *
  57  * <p>When the {@code add} method is called to add a Permission, the
  58  * Permission is stored in the appropriate PermissionCollection. If no such
  59  * collection exists yet, the Permission object's class is determined and the
  60  * {@code newPermissionCollection} method is called on that class to create
  61  * the PermissionCollection and add it to the Permissions object. If
  62  * {@code newPermissionCollection} returns null, then a default
  63  * PermissionCollection that uses a hashtable will be created and used. Each
  64  * hashtable entry stores a Permission object as both the key and the value.
  65  *
  66  * <p> Enumerations returned via the {@code elements} method are
  67  * not <em>fail-fast</em>.  Modifications to a collection should not be
  68  * performed while enumerating over that collection.
  69  *
  70  * @see Permission
  71  * @see PermissionCollection
  72  * @see AllPermission
  73  *
  74  *
  75  * @author Marianne Mueller
  76  * @author Roland Schemers
  77  * @since 1.2
  78  *
  79  * @serial exclude
  80  */
  81 
  82 public final class Permissions extends PermissionCollection
  83 implements Serializable
  84 {
  85     /**
  86      * Key is permissions Class, value is PermissionCollection for that class.
  87      * Not serialized; see serialization section at end of class.
  88      */
  89     private transient ConcurrentHashMap<Class<?>, PermissionCollection> permsMap;
  90 
  91     // optimization. keep track of whether unresolved permissions need to be
  92     // checked
  93     private transient boolean hasUnresolved = false;
  94 
  95     // optimization. keep track of the AllPermission collection
  96     // - package private for ProtectionDomain optimization
  97     PermissionCollection allPermission;
  98 
  99     /**
 100      * Creates a new Permissions object containing no PermissionCollections.
 101      */
 102     public Permissions() {
 103         permsMap = new ConcurrentHashMap<>(11);
 104         allPermission = null;
 105     }
 106 
 107     /**
 108      * Adds a permission object to the PermissionCollection for the class the
 109      * permission belongs to. For example, if <i>permission</i> is a
 110      * FilePermission, it is added to the FilePermissionCollection stored
 111      * in this Permissions object.
 112      *
 113      * This method creates
 114      * a new PermissionCollection object (and adds the permission to it)
 115      * if an appropriate collection does not yet exist.
 116      *
 117      * @param permission the Permission object to add.
 118      *
 119      * @exception SecurityException if this Permissions object is
 120      * marked as readonly.
 121      *
 122      * @see PermissionCollection#isReadOnly()
 123      */
 124     @Override
 125     public void add(Permission permission) {
 126         if (isReadOnly())
 127             throw new SecurityException(
 128               "attempt to add a Permission to a readonly Permissions object");
 129 
 130         PermissionCollection pc = getPermissionCollection(permission, true);
 131         pc.add(permission);
 132 
 133         // No sync; staleness -> optimizations delayed, which is OK
 134         if (permission instanceof AllPermission) {
 135             allPermission = pc;
 136         }
 137         if (permission instanceof UnresolvedPermission) {
 138             hasUnresolved = true;
 139         }
 140     }
 141 
 142     /**
 143      * Checks to see if this object's PermissionCollection for permissions of
 144      * the specified permission's class implies the permissions
 145      * expressed in the <i>permission</i> object. Returns true if the
 146      * combination of permissions in the appropriate PermissionCollection
 147      * (e.g., a FilePermissionCollection for a FilePermission) together
 148      * imply the specified permission.
 149      *
 150      * <p>For example, suppose there is a FilePermissionCollection in this
 151      * Permissions object, and it contains one FilePermission that specifies
 152      * "read" access for  all files in all subdirectories of the "/tmp"
 153      * directory, and another FilePermission that specifies "write" access
 154      * for all files in the "/tmp/scratch/foo" directory.
 155      * Then if the {@code implies} method
 156      * is called with a permission specifying both "read" and "write" access
 157      * to files in the "/tmp/scratch/foo" directory, {@code true} is
 158      * returned.
 159      *
 160      * <p>Additionally, if this PermissionCollection contains the
 161      * AllPermission, this method will always return true.
 162      *
 163      * @param permission the Permission object to check.
 164      *
 165      * @return true if "permission" is implied by the permissions in the
 166      * PermissionCollection it
 167      * belongs to, false if not.
 168      */
 169     @Override
 170     public boolean implies(Permission permission) {
 171         // No sync; staleness -> skip optimization, which is OK
 172         if (allPermission != null) {
 173             return true; // AllPermission has already been added
 174         } else {
 175             PermissionCollection pc = getPermissionCollection(permission,
 176                 false);
 177             if (pc != null) {
 178                 return pc.implies(permission);
 179             } else {
 180                 // none found
 181                 return false;
 182             }
 183         }
 184     }
 185 
 186     /**
 187      * Returns an enumeration of all the Permission objects in all the
 188      * PermissionCollections in this Permissions object.
 189      *
 190      * @return an enumeration of all the Permissions.
 191      */
 192     @Override
 193     public Enumeration<Permission> elements() {
 194         // go through each Permissions in the hash table
 195         // and call their elements() function.
 196 
 197         return new PermissionsEnumerator(permsMap.values().iterator());
 198     }
 199 
 200     /**
 201      * Gets the PermissionCollection in this Permissions object for
 202      * permissions whose type is the same as that of <i>p</i>.
 203      * For example, if <i>p</i> is a FilePermission,
 204      * the FilePermissionCollection
 205      * stored in this Permissions object will be returned.
 206      *
 207      * If createEmpty is true,
 208      * this method creates a new PermissionCollection object for the specified
 209      * type of permission objects if one does not yet exist.
 210      * To do so, it first calls the {@code newPermissionCollection} method
 211      * on <i>p</i>.  Subclasses of class Permission
 212      * override that method if they need to store their permissions in a
 213      * particular PermissionCollection object in order to provide the
 214      * correct semantics when the {@code PermissionCollection.implies}
 215      * method is called.
 216      * If the call returns a PermissionCollection, that collection is stored
 217      * in this Permissions object. If the call returns null and createEmpty
 218      * is true, then
 219      * this method instantiates and stores a default PermissionCollection
 220      * that uses a hashtable to store its permission objects.
 221      *
 222      * createEmpty is ignored when creating empty PermissionCollection
 223      * for unresolved permissions because of the overhead of determining the
 224      * PermissionCollection to use.
 225      *
 226      * createEmpty should be set to false when this method is invoked from
 227      * implies() because it incurs the additional overhead of creating and
 228      * adding an empty PermissionCollection that will just return false.
 229      * It should be set to true when invoked from add().
 230      */
 231     private PermissionCollection getPermissionCollection(Permission p,
 232                                                          boolean createEmpty) {
 233         Class<?> c = p.getClass();
 234 
 235         if (!hasUnresolved && !createEmpty) {
 236             return permsMap.get(c);
 237         }
 238 
 239         // Create and add permission collection to map if it is absent.
 240         // NOTE: cannot use lambda for mappingFunction parameter until
 241         // JDK-8076596 is fixed.
 242         return permsMap.computeIfAbsent(c,
 243             new java.util.function.Function<>() {
 244                 @Override
 245                 public PermissionCollection apply(Class<?> k) {
 246                     // Check for unresolved permissions
 247                     PermissionCollection pc =
 248                         (hasUnresolved ? getUnresolvedPermissions(p) : null);
 249 
 250                     // if still null, create a new collection
 251                     if (pc == null && createEmpty) {
 252 
 253                         pc = p.newPermissionCollection();
 254 
 255                         // still no PermissionCollection?
 256                         // We'll give them a PermissionsHash.
 257                         if (pc == null) {
 258                             pc = new PermissionsHash();
 259                         }
 260                     }
 261                     return pc;
 262                 }
 263             }
 264         );
 265     }
 266 
 267     /**
 268      * Resolves any unresolved permissions of type p.
 269      *
 270      * @param p the type of unresolved permission to resolve
 271      *
 272      * @return PermissionCollection containing the unresolved permissions,
 273      *  or null if there were no unresolved permissions of type p.
 274      *
 275      */
 276     private PermissionCollection getUnresolvedPermissions(Permission p)
 277     {
 278         UnresolvedPermissionCollection uc =
 279         (UnresolvedPermissionCollection) permsMap.get(UnresolvedPermission.class);
 280 
 281         // we have no unresolved permissions if uc is null
 282         if (uc == null)
 283             return null;
 284 
 285         List<UnresolvedPermission> unresolvedPerms =
 286                                         uc.getUnresolvedPermissions(p);
 287 
 288         // we have no unresolved permissions of this type if unresolvedPerms is null
 289         if (unresolvedPerms == null)
 290             return null;
 291 
 292         java.security.cert.Certificate[] certs = null;
 293 
 294         Object[] signers = p.getClass().getSigners();
 295 
 296         int n = 0;
 297         if (signers != null) {
 298             for (int j=0; j < signers.length; j++) {
 299                 if (signers[j] instanceof java.security.cert.Certificate) {
 300                     n++;
 301                 }
 302             }
 303             certs = new java.security.cert.Certificate[n];
 304             n = 0;
 305             for (int j=0; j < signers.length; j++) {
 306                 if (signers[j] instanceof java.security.cert.Certificate) {
 307                     certs[n++] = (java.security.cert.Certificate)signers[j];
 308                 }
 309             }
 310         }
 311 
 312         PermissionCollection pc = null;
 313         synchronized (unresolvedPerms) {
 314             int len = unresolvedPerms.size();
 315             for (int i = 0; i < len; i++) {
 316                 UnresolvedPermission up = unresolvedPerms.get(i);
 317                 Permission perm = up.resolve(p, certs);
 318                 if (perm != null) {
 319                     if (pc == null) {
 320                         pc = p.newPermissionCollection();
 321                         if (pc == null)
 322                             pc = new PermissionsHash();
 323                     }
 324                     pc.add(perm);
 325                 }
 326             }
 327         }
 328         return pc;
 329     }
 330 
 331     private static final long serialVersionUID = 4858622370623524688L;
 332 
 333     // Need to maintain serialization interoperability with earlier releases,
 334     // which had the serializable field:
 335     // private Hashtable perms;
 336 
 337     /**
 338      * @serialField perms java.util.Hashtable
 339      *     A table of the Permission classes and PermissionCollections.
 340      * @serialField allPermission java.security.PermissionCollection
 341      */
 342     private static final ObjectStreamField[] serialPersistentFields = {
 343         new ObjectStreamField("perms", Hashtable.class),
 344         new ObjectStreamField("allPermission", PermissionCollection.class),
 345     };
 346 
 347     /**
 348      * @serialData Default fields.
 349      */
 350     /*
 351      * Writes the contents of the permsMap field out as a Hashtable for
 352      * serialization compatibility with earlier releases. allPermission
 353      * unchanged.
 354      */
 355     private void writeObject(ObjectOutputStream out) throws IOException {
 356         // Don't call out.defaultWriteObject()
 357 
 358         // Copy perms into a Hashtable
 359         Hashtable<Class<?>, PermissionCollection> perms =
 360             new Hashtable<>(permsMap.size()*2); // no sync; estimate
 361         perms.putAll(permsMap);
 362 
 363         // Write out serializable fields
 364         ObjectOutputStream.PutField pfields = out.putFields();
 365 
 366         pfields.put("allPermission", allPermission); // no sync; staleness OK
 367         pfields.put("perms", perms);
 368         out.writeFields();
 369     }
 370 
 371     /*
 372      * Reads in a Hashtable of Class/PermissionCollections and saves them in the
 373      * permsMap field. Reads in allPermission.
 374      */
 375     private void readObject(ObjectInputStream in) throws IOException,
 376     ClassNotFoundException {
 377         // Don't call defaultReadObject()
 378 
 379         // Read in serialized fields
 380         ObjectInputStream.GetField gfields = in.readFields();
 381 
 382         // Get allPermission
 383         allPermission = (PermissionCollection) gfields.get("allPermission", null);
 384 
 385         // Get permissions
 386         // writeObject writes a Hashtable<Class<?>, PermissionCollection> for
 387         // the perms key, so this cast is safe, unless the data is corrupt.
 388         @SuppressWarnings("unchecked")
 389         Hashtable<Class<?>, PermissionCollection> perms =
 390             (Hashtable<Class<?>, PermissionCollection>)gfields.get("perms", null);
 391         permsMap = new ConcurrentHashMap<>(perms.size()*2);
 392         permsMap.putAll(perms);
 393 
 394         // Check that Class is mapped to PermissionCollection containing
 395         // Permissions of the same class
 396         for (Map.Entry<Class<?>, PermissionCollection> e : perms.entrySet()) {
 397             Class<?> k = e.getKey();
 398             PermissionCollection v = e.getValue();
 399             Enumeration<Permission> en = v.elements();
 400             while (en.hasMoreElements()) {
 401                 Permission p = en.nextElement();
 402                 if (!k.equals(p.getClass())) {
 403                     throw new InvalidObjectException("Permission with class " +
 404                         k + " incorrectly mapped to PermissionCollection " +
 405                         "containing Permission with " + p.getClass());
 406                 }
 407             }
 408         }
 409 
 410         // Set hasUnresolved
 411         UnresolvedPermissionCollection uc =
 412         (UnresolvedPermissionCollection) permsMap.get(UnresolvedPermission.class);
 413         hasUnresolved = (uc != null && uc.elements().hasMoreElements());
 414     }
 415 }
 416 
 417 final class PermissionsEnumerator implements Enumeration<Permission> {
 418 
 419     // all the perms
 420     private Iterator<PermissionCollection> perms;
 421     // the current set
 422     private Enumeration<Permission> permset;
 423 
 424     PermissionsEnumerator(Iterator<PermissionCollection> e) {
 425         perms = e;
 426         permset = getNextEnumWithMore();
 427     }
 428 
 429     // No need to synchronize; caller should sync on object as required
 430     public boolean hasMoreElements() {
 431         // if we enter with permissionimpl null, we know
 432         // there are no more left.
 433 
 434         if (permset == null)
 435             return  false;
 436 
 437         // try to see if there are any left in the current one
 438 
 439         if (permset.hasMoreElements())
 440             return true;
 441 
 442         // get the next one that has something in it...
 443         permset = getNextEnumWithMore();
 444 
 445         // if it is null, we are done!
 446         return (permset != null);
 447     }
 448 
 449     // No need to synchronize; caller should sync on object as required
 450     public Permission nextElement() {
 451 
 452         // hasMoreElements will update permset to the next permset
 453         // with something in it...
 454 
 455         if (hasMoreElements()) {
 456             return permset.nextElement();
 457         } else {
 458             throw new NoSuchElementException("PermissionsEnumerator");
 459         }
 460 
 461     }
 462 
 463     private Enumeration<Permission> getNextEnumWithMore() {
 464         while (perms.hasNext()) {
 465             PermissionCollection pc = perms.next();
 466             Enumeration<Permission> next =pc.elements();
 467             if (next.hasMoreElements())
 468                 return next;
 469         }
 470         return null;
 471 
 472     }
 473 }
 474 
 475 /**
 476  * A PermissionsHash stores a homogeneous set of permissions in a hashtable.
 477  *
 478  * @see Permission
 479  * @see Permissions
 480  *
 481  *
 482  * @author Roland Schemers
 483  *
 484  * @serial include
 485  */
 486 
 487 final class PermissionsHash extends PermissionCollection
 488 implements Serializable
 489 {
 490     /**
 491      * Key and value are (same) permissions objects.
 492      * Not serialized; see serialization section at end of class.
 493      */
 494     private transient ConcurrentHashMap<Permission, Permission> permsMap;
 495 
 496     /**
 497      * Create an empty PermissionsHash object.
 498      */
 499     PermissionsHash() {
 500         permsMap = new ConcurrentHashMap<>(11);
 501     }
 502 
 503     /**
 504      * Adds a permission to the PermissionsHash.
 505      *
 506      * @param permission the Permission object to add.
 507      */
 508     @Override
 509     public void add(Permission permission) {
 510         permsMap.put(permission, permission);
 511     }
 512 
 513     /**
 514      * Check and see if this set of permissions implies the permissions
 515      * expressed in "permission".
 516      *
 517      * @param permission the Permission object to compare
 518      *
 519      * @return true if "permission" is a proper subset of a permission in
 520      * the set, false if not.
 521      */
 522     @Override
 523     public boolean implies(Permission permission) {
 524         // attempt a fast lookup and implies. If that fails
 525         // then enumerate through all the permissions.
 526         Permission p = permsMap.get(permission);
 527 
 528         // If permission is found, then p.equals(permission)
 529         if (p == null) {
 530             for (Permission p_ : permsMap.values()) {
 531                 if (p_.implies(permission))
 532                     return true;
 533             }
 534             return false;
 535         } else {
 536             return true;
 537         }
 538     }
 539 
 540     /**
 541      * Returns an enumeration of all the Permission objects in the container.
 542      *
 543      * @return an enumeration of all the Permissions.
 544      */
 545     @Override
 546     public Enumeration<Permission> elements() {
 547         return permsMap.elements();
 548     }
 549 
 550     private static final long serialVersionUID = -8491988220802933440L;
 551     // Need to maintain serialization interoperability with earlier releases,
 552     // which had the serializable field:
 553     // private Hashtable perms;
 554     /**
 555      * @serialField perms java.util.Hashtable
 556      *     A table of the Permissions (both key and value are same).
 557      */
 558     private static final ObjectStreamField[] serialPersistentFields = {
 559         new ObjectStreamField("perms", Hashtable.class),
 560     };
 561 
 562     /**
 563      * @serialData Default fields.
 564      */
 565     /*
 566      * Writes the contents of the permsMap field out as a Hashtable for
 567      * serialization compatibility with earlier releases.
 568      */
 569     private void writeObject(ObjectOutputStream out) throws IOException {
 570         // Don't call out.defaultWriteObject()
 571 
 572         // Copy perms into a Hashtable
 573         Hashtable<Permission, Permission> perms =
 574                 new Hashtable<>(permsMap.size()*2);
 575         perms.putAll(permsMap);
 576 
 577         // Write out serializable fields
 578         ObjectOutputStream.PutField pfields = out.putFields();
 579         pfields.put("perms", perms);
 580         out.writeFields();
 581     }
 582 
 583     /*
 584      * Reads in a Hashtable of Permission/Permission and saves them in the
 585      * permsMap field.
 586      */
 587     private void readObject(ObjectInputStream in) throws IOException,
 588     ClassNotFoundException {
 589         // Don't call defaultReadObject()
 590 
 591         // Read in serialized fields
 592         ObjectInputStream.GetField gfields = in.readFields();
 593 
 594         // Get permissions
 595         // writeObject writes a Hashtable<Class<?>, PermissionCollection> for
 596         // the perms key, so this cast is safe, unless the data is corrupt.
 597         @SuppressWarnings("unchecked")
 598         Hashtable<Permission, Permission> perms =
 599                 (Hashtable<Permission, Permission>)gfields.get("perms", null);
 600         permsMap = new ConcurrentHashMap<>(perms.size()*2);
 601         permsMap.putAll(perms);
 602 
 603         // check that the Permission key and value are the same object
 604         for (Map.Entry<Permission, Permission> e : perms.entrySet()) {
 605             Permission k = e.getKey();
 606             Permission v = e.getValue();
 607             if (k != v) {
 608                 throw new InvalidObjectException("Permission (" + k +
 609                     ") incorrectly mapped to Permission (" + v + ")");
 610             }
 611         }
 612     }
 613 }