1 /*
   2  * Copyright (c) 1998, 2015, 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.security.*;
  29 import java.util.Enumeration;
  30 import java.util.Hashtable;
  31 import java.util.StringTokenizer;
  32 import sun.security.util.SecurityConstants;
  33 
  34 /**
  35  * The AllPermission is a permission that implies all other permissions.
  36  * <p>
  37  * <b>Note:</b> Granting AllPermission should be done with extreme care,
  38  * as it implies all other permissions. Thus, it grants code the ability
  39  * to run with security
  40  * disabled.  Extreme caution should be taken before granting such
  41  * a permission to code.  This permission should be used only during testing,
  42  * or in extremely rare cases where an application or applet is
  43  * completely trusted and adding the necessary permissions to the policy
  44  * is prohibitively cumbersome.
  45  *
  46  * @see java.security.Permission
  47  * @see java.security.AccessController
  48  * @see java.security.Permissions
  49  * @see java.security.PermissionCollection
  50  * @see java.lang.SecurityManager
  51  *
  52  *
  53  * @author Roland Schemers
  54  *
  55  * @serial exclude
  56  */
  57 
  58 public final class AllPermission extends Permission {
  59 
  60     private static final long serialVersionUID = -2916474571451318075L;
  61 
  62     /**
  63      * Creates a new AllPermission object.
  64      */
  65     public AllPermission() {
  66         super("<all permissions>");
  67     }
  68 
  69 
  70     /**
  71      * Creates a new AllPermission object. This
  72      * constructor exists for use by the {@code Policy} object
  73      * to instantiate new Permission objects.
  74      *
  75      * @param name ignored
  76      * @param actions ignored.
  77      */
  78     public AllPermission(String name, String actions) {
  79         this();
  80     }
  81 
  82     /**
  83      * Checks if the specified permission is "implied" by
  84      * this object. This method always returns true.
  85      *
  86      * @param p the permission to check against.
  87      *
  88      * @return return
  89      */
  90     public boolean implies(Permission p) {
  91          return true;
  92     }
  93 
  94     /**
  95      * Checks two AllPermission objects for equality. Two AllPermission
  96      * objects are always equal.
  97      *
  98      * @param obj the object we are testing for equality with this object.
  99      * @return true if {@code obj} is an AllPermission, false otherwise.
 100      */
 101     public boolean equals(Object obj) {
 102         return (obj instanceof AllPermission);
 103     }
 104 
 105     /**
 106      * Returns the hash code value for this object.
 107      *
 108      * @return a hash code value for this object.
 109      */
 110 
 111     public int hashCode() {
 112         return 1;
 113     }
 114 
 115     /**
 116      * Returns the canonical string representation of the actions.
 117      *
 118      * @return the actions.
 119      */
 120     public String getActions() {
 121         return "<all actions>";
 122     }
 123 
 124     /**
 125      * Returns a new PermissionCollection object for storing AllPermission
 126      * objects.
 127      *
 128      * @return a new PermissionCollection object suitable for
 129      * storing AllPermissions.
 130      */
 131     public PermissionCollection newPermissionCollection() {
 132         return new AllPermissionCollection();
 133     }
 134 
 135 }
 136 
 137 /**
 138  * A AllPermissionCollection stores a collection
 139  * of AllPermission permissions. AllPermission objects
 140  * must be stored in a manner that allows them to be inserted in any
 141  * order, but enable the implies function to evaluate the implies
 142  * method in an efficient (and consistent) manner.
 143  *
 144  * @see java.security.Permission
 145  * @see java.security.Permissions
 146  *
 147  *
 148  * @author Roland Schemers
 149  *
 150  * @serial include
 151  */
 152 
 153 final class AllPermissionCollection
 154     extends PermissionCollection
 155     implements java.io.Serializable
 156 {
 157 
 158     // use serialVersionUID from JDK 1.2.2 for interoperability
 159     private static final long serialVersionUID = -4023755556366636806L;
 160 
 161     private boolean all_allowed; // true if any all permissions have been added
 162 
 163     /**
 164      * Create an empty AllPermissions object.
 165      *
 166      */
 167 
 168     public AllPermissionCollection() {
 169         all_allowed = false;
 170     }
 171 
 172     /**
 173      * Adds a permission to the AllPermissions. The key for the hash is
 174      * permission.path.
 175      *
 176      * @param permission the Permission object to add.
 177      *
 178      * @exception IllegalArgumentException - if the permission is not a
 179      *                                       AllPermission
 180      *
 181      * @exception SecurityException - if this AllPermissionCollection object
 182      *                                has been marked readonly
 183      */
 184 
 185     public void add(Permission permission) {
 186         if (! (permission instanceof AllPermission))
 187             throw new IllegalArgumentException("invalid permission: "+
 188                                                permission);
 189         if (isReadOnly())
 190             throw new SecurityException("attempt to add a Permission to a readonly PermissionCollection");
 191 
 192         all_allowed = true; // No sync; staleness OK
 193     }
 194 
 195     /**
 196      * Check and see if this set of permissions implies the permissions
 197      * expressed in "permission".
 198      *
 199      * @param permission the Permission object to compare
 200      *
 201      * @return always returns true.
 202      */
 203 
 204     public boolean implies(Permission permission) {
 205         return all_allowed; // No sync; staleness OK
 206     }
 207 
 208     /**
 209      * Returns an enumeration of all the AllPermission objects in the
 210      * container.
 211      *
 212      * @return an enumeration of all the AllPermission objects.
 213      */
 214     public Enumeration<Permission> elements() {
 215         return new Enumeration<>() {
 216             private boolean hasMore = all_allowed;
 217 
 218             public boolean hasMoreElements() {
 219                 return hasMore;
 220             }
 221 
 222             public Permission nextElement() {
 223                 hasMore = false;
 224                 return SecurityConstants.ALL_PERMISSION;
 225             }
 226         };
 227     }
 228 }