六，存取控制器

安全管理器大部分功能都是在存取控制器基础上实现的，可以说存取控制器是可以取代安全管理器的。

一般来说安全管理器是调用存取控制器的功能！

前面章节介绍的沙箱就是说的存取控制器，存取控制器就是沙箱的实现。回顾一下沙箱的基本要素，这些都是建立存取控制的基础

基本要素：

1，代码源

2，权限

3，策略：管理员可以设置策略文件，策略文件上面描述了所有的权限；在安全管理器中，策略对象表示为对所有权限的封装（内存）

4，保护域：利于权限的检索，指对某代码源相应权限的封装

我们先详细解读每一个要素的实现，然后再解释存取控制器是如何工作的

一，CodeSource类（java.security.CodeSource）  —————— 代码源

主要方法：

http://www.yq1012.com/api/java/security/CodeSource.html

二，权限类， Permission类

http://www.yq1012.com/api/java/security/Permission.html

1，权限的三个特性：类型、名、操作

注意：权限是类型的一个实例

如：在策略文件中定义一个权限对象

permission java.util.PropertyPermission "java.version", "read";

上面描述的权限在内存中的表示为：permission p = new java.util.PropertyPermission("java.version", "read");

可以看出对象是java.util.PropertyPermission类型的一个实例，构造时带名和操作参数。

对于我们这些普通java开发者，很少定义权限类，但是我们可以自定义权限类，只不过在实现”名、操作“的通配匹配上算法有点复杂,

另外，BasicPermission类提供了层次式通配匹配操作，我们可以直接继承或依赖他，也可以只继承Permission类来自行完成需要的匹配算法。

以下是参考书籍上的一个例子，

----此例子的名只是一个单值，并不是层次的，所以不需要复杂的匹配，操作只有2个，view和update，操作配置算法用或操作就完成，很简单

----如果名是层次的，要写路径覆盖算法，代码太多，这里只是简单的说明我们如何编写自己的权限类，

----注意equals(Object o)，implies(Permission p) ，getActions() 核心方法的实现细节,他们都是抽象的，要自己实现的匹配逻辑

import java.security.*;
import java.util.*;

public class XYZPayrollPermission extends Permission {

    protected int mask;
    static private int VIEW = 0x01;
    static private int UPDATE = 0x02;

    public XYZPayrollPermission(String name) {
        // Our permission must always have an action, so we
        // choose a default one here.
        this(name, "view");
    }

    public XYZPayrollPermission(String name, String action) {
        // Our superclass, however, does not support actions
        // so we don't provide one to that.
        super(name);
        parse(action);
    }

    private void parse(String action) {
        // Look in the action string for the words view and
        // update, separated by white space or by a comma
        StringTokenizer st = new StringTokenizer(action, ",\t ");

        mask = 0;
        while (st.hasMoreTokens()) {
            String tok = st.nextToken();
            if (tok.equals("view"))
                mask |= VIEW;
            else if (tok.equals("update"))
                mask |= UPDATE;
            else throw new IllegalArgumentException(
                                    "Unknown action " + tok);
        }
    }

    public boolean implies(Permission permission) {
        if (!(permission instanceof XYZPayrollPermission))
            return false;
        
        XYZPayrollPermission p = (XYZPayrollPermission) permission;
        String name = getName();
        // The name must be either the wildcard *, which signifies
        // all possible names, or the name must match our name
        if (!name.equals("*") && !name.equals(p.getName()))
            return false;
        // Similarly, the requested actions must all match actions
        // that we've been constructed with.
        if ((mask & p.mask) != p.mask)
            return false;
        // Only if both the action and name match do we return true.
        return true;
    }

    public boolean equals(Object o) {
        if (!(o instanceof XYZPayrollPermission))
            return false;
        
        // For equality, we check the name and action mask.
        // We must provide a method definition like this, since
        // the security system expects us to do a deep check for
        // equality rather than relying on object reference
        // equality.
        XYZPayrollPermission p = (XYZPayrollPermission) o;
        return ((p.getName().equals(getName())) && (p.mask == mask));
    }

    public int hashCode() {
        // We must always provide a hash code for permissions,
        // because the hashes must match if the permissions compare
        // as equals. The default implementation of this method
        // wouldn't provide that.
        return getName().hashCode() ^ mask;
    }

    public String getActions() {
        // This method must return the same string, no matter how
        // the action list was passed to the constructor.
        if (mask == 0)
            return "";
        else if (mask == VIEW)
            return "view";
        else if (mask == UPDATE)
            return "update";
        else if (mask == (VIEW | UPDATE))
            return "view, update";
        else throw new IllegalArgumentException("Unknown mask");
    }

    public PermissionCollection newPermissionsCollection() {
        // More about this in a later example.
        return new XYZPayrollPermissionCollection();
    }

    public static void main(String[] args) {
        XYZPayrollPermission p1 = new XYZPayrollPermission("sdo", "view");
        XYZPayrollPermission p2 = new XYZPayrollPermission(args[0], args[1]);
        System.out.println("P1 is " + p1);
        System.out.println("P2 is " + p2);
        System.out.println("P1 -> P2 is " + p1.implies(p2));
        System.out.println("P2 -> P1 is " + p2.implies(p1));
    }
}

2，权限集（抽线类）：PermissionCollection类，某一个权限类的所有实例的集合，用途：1-存储权限；2-检查是否包含指定权限

3，权限集集合：Permissions类，他继承权限集PermissionCollection，和权限集表现一样的接口，因此作用一样，只不过他更强，他可以存储多个不同类型的权限集，也可用于不同类型权限的检索

以下是参考书籍上的一个例子，

import java.util.*;
import java.security.*;
import java.util.*;

public class XYZPayrollPermissionCollection extends PermissionCollection {
    private Hashtable permissions;
    // We keep track of whether the * name has been added to make
    // the implies method simpler.
    private boolean addedAdmin;
    private int adminMask;

    XYZPayrollPermissionCollection() {
        permissions = new Hashtable();
        addedAdmin = false;
    }

    public void add(Permission p) {
        // Required test
        if (isReadOnly())
            throw new IllegalArgumentException("Read only collection");

        // This is a homogenous collection, as are all 
        // PermissionCollections that you'll implement.
        if (!(p instanceof XYZPayrollPermission))
            throw new IllegalArgumentException("Wrong permission type");

        XYZPayrollPermission xyz = (XYZPayrollPermission) p;
        String name = xyz.getName();
        XYZPayrollPermission other = 
                       (XYZPayrollPermission) permissions.get(name);
        if (other != null)
            xyz = merge(xyz, other);
        // An administrative permission. The administrative permission
        // may have only view or only update or both, and multiple
        // admin permissions may be added, so the masks are OR-ed
        // together.
        if (name.equals("*")) {
            addedAdmin = true;
            adminMask = xyz.mask | adminMask;
        }
        permissions.put(name, xyz);
    }

    public Enumeration elements() {
        return permissions.elements();
    }

    public boolean implies(Permission p) {
        if (!(p instanceof XYZPayrollPermission))
            return false;
        XYZPayrollPermission xyz = (XYZPayrollPermission) p;
        // If the admin name is present, then all names are implied;
        // we need check only the permissions.
        if (addedAdmin && (adminMask & xyz.mask) == xyz.mask)
            return true;
        // Otherwise, we can just see if the given individual is
        // in our table and if so, see if the permissions match.
        Permission inTable = (Permission) permissions.get(xyz.getName());
        if (inTable == null)
            return false;
        return inTable.implies(xyz);
    }

    // This is called when the same name is added twice to the
    // permissions; we merge the action lists and only store the
    // name once.
    private XYZPayrollPermission merge(XYZPayrollPermission a,
                                       XYZPayrollPermission b) {
        String aAction = a.getActions();
        if (aAction.equals(""))
            return b;
        String bAction = b.getActions();
        if (bAction.equals(""))
            return a;
        return new XYZPayrollPermission(a.getName(), aAction + "," + bAction);
    }
}

三，Policy类  策略

权限集要和代码源相关联，之后我们才能判断出代码具有什么样的权限。策略类定义了这种关联。

如果要自己写策略，

----就需要解读策略文件，或者权限存于数据库，你需要自己的一套解读方式

----需要为代码源关联权限集，注意权限集的创建并不是由策略完成的，策略只是保存数据，创建权限的工作由运行时的类加载器搞定

----策略类需要读文件或网络的权限，往往是特权，特权在本文后面介绍

其实我在读完存取控制后，就开始担心java安全策略的效率，但等到读完类加载器后，这些顾虑都没有了，策略对象里面代码源的权限集并不是启动java的时候就生成的，而是由类加载器实时完成的。

所以我们并不用担心JAVA虚拟机安全的处理速度，更不用担心检索速度（内存速度）

例子：

例子展示了策略对象的主要功能

----存储权限 （具体的权限由类加载器生成，然后抛给策略对象的）

----检索代码基的权限集

import java.security.*;
import java.util.*;

public class MyPolicy extends Policy {

    // This inner class defines a simple set of permissions:
    // either everything is allowed (the implies() method always
    // returns true, and the collection contains an AllPermission
    // object) or everything is prohibited (the implies()
    // method always returns false and the collection is empty).
    static class SimplePermissions extends PermissionCollection {
        boolean allow;
        Permissions perms;

        SimplePermissions(boolean b) {
            allow = b;
            perms = new Permissions();
            if (allow)
                perms.add(new AllPermission());
        }

        public void add(Permission p) {
            if (isReadOnly())
                throw new SecurityException(
                             "Can't add to this collection");
            perms.add(p);
        }

        public Enumeration elements() {
            return perms.elements();
        }

        public boolean implies(Permission p) {
            return allow;
        }
    }

    // We never change the policy
    public void refresh() {}

    //If the code was loaded from a file, return a collection
    // that implies all permissions. Otherwise, return an
    // empty collection (one that implies no permissions).
    public PermissionCollection getPermissions(CodeSource cs) {
        if (cs.getLocation().getProtocol().equals("file"))
            return new SimplePermissions(true);
        return new SimplePermissions(false);
    }
}

在虚拟机中，任何时候只有一个策略对象，

我们可以替换系统的策略类，通过程序化或者管理手段配置

程序化： setPolicy(Policy p)

管理手段：

---java.security中 plicy.provider=sun.security.provider.PolicyFile 替换为自己的类

---把自己的类放如rt.jar中，或者在运行虚拟机时正确适合参数以指定引导路径 java -Xbootclasspath:/files/policyfile  ...

四，保护域 ProtectionDomain

前面谈过Permissions对象——权限集集和，他和某一个代码基关联起来就是保护域

也就是说，他存储了某个代码基的所有权限集集和

具体核心方法请参考API文档 

保护域对开发人员是透明的，我们不需要了解他的API细节，

但我们要知道，每一个java类都属于且仅属于一个保护域，定义类时，保护域可以来自默认的安全模型（策略文件），也可由类加载器拓展（或替换）。

 

五、存取控制器  AccessController

前面介绍了存取控制器的要素，存取控制器没有实例，构造函数私有，有一组静态方法用于确定是否得到权限以实现某个操作

例子演示了他简单的用法

<span style="font-size:12px;">import java.applet.*;
import java.net.*;
import java.security.*;

public class AccessTest extends Applet {
    public void init() {
        SocketPermission sp = new SocketPermission(
                            getParameter("host") + ":6000", "connect");
        try {
            AccessController.checkPermission(sp);
            System.out.println("Ok to open socket");
        } catch (AccessControlException ace) {
            System.out.println(ace);
        }
    }
}</span>

1，存取控制是如何工作的——如何检索权限的

----存取控制器方法调用后，存取控制开始工作

----存取控制器检索堆栈中最后压入栈的类，存取控制类除外，检索类代码基是否有相应权限，以上代码是检索是否有套接字权限，host:6000

----有权限，就检测堆栈前一个类，直到堆栈完毕。

----没有权限，就抛出运行时异常，线程完毕。

来自于不同加载器和不同签名jar包的类，由加载器设置权限集合，所以类加载器为了安全考虑，必须首先检索父加载器是否加载了类，

这里不能画图 唉！

2，特权接口，PrivilegedAction 和 PrivilegedExceptionAction 接口

实现特权接口的类，就是特权类，只有一个方法就是run(); 

如果我们把一段程序封装在特权类中，我们就能让存取控制器网开一面，阻止存取控制递归检索堆栈中的权限

话题：A类有套接字locahost:6000权限，B类没有，如果B调用A，那么网络访问就会失败，但这种情况下，我们希望A能顺利访问网络，怎么办呢？

解答：特权类

           我们改造类A，让A访问网络的代码封装在特权类中，这样不管调用A的类是否具备套接字权限，A的对象都能顺利访问网络

<span style="font-size:12px;">import java.net.*;
import java.io.*;
import java.security.*;

public class A {
    public A() {
        try {
            // This class is used by the doPrivilged() method to
            // open a socket
            class doSocket implements PrivilegedExceptionAction {
                public Object run() throws UnknownHostException,
                                     IOException {
                    return new Socket("localhost", 6000);
                }
            };
            doSocket ds = new doSocket();
            Socket s = (Socket) AccessController.doPrivileged(ds);
        } catch (PrivilegedActionException pae) {
            Exception e = pae.getException();
            if (e instanceof UnknownHostException) {
                // process host exception
            }
            else if (e instanceof IOException) {
                // process IOException
            }
            else {
                // e must be a runtime exception
                throw (RuntimeException) e;
            }
        }
    }
}</span>

我们看看例子堆栈的情况

-----new Socket("localhost",6000) 会在内部调用存取控制器， 存取控制器会递归堆栈检索指定权限 ：new java.net.SocketPermission("localhost",6000)

-----存取控制先检索类核心API  Socket 是否有套接字权限

------有，继续检索doSocket类套接字权限

-----doSocket为特权类，他会设置断点，阻止存取控制继续检索，从而返回，

-----存取控制器返回“真”，套接字访问顺利完成

如果A类的对象，被任何其他类型的对象调用，A都能有特权访问套接字了

例子的分析，大家可能有疑惑，我们更进一步分析下

-----程序执行首先要进堆栈，然后出栈，

-----语句AccessController.doPrivileged(ds)，会让ds.run靠后进栈，之后让new Socket("localhost"，6000)最后进栈，也就是说存取控制器回调run,

-----new Socket("localhost",6000)会进一步让AccessController.checkPermission()方法进栈，checkPermission()才是检索类权限的真正指令流

-----等checkPermission()执行完毕后，知道有权限才让new Socket("localhost",6000)正常返回，否则，如果没有权限，抛出运行时异常，堆栈结束了

-----AccessController.doPrivilleged()是很早进入栈的，但他进栈时，在栈中设置了一个断点，断点会阻止checkPermission()方法中检索代码的执行，

-----因此checkPermission()执行中途，检测到堆栈断点，返回，不会去检索栈中其他类的权限了，从而达到了特权的目的。

没法画图，唉