1．Java的访问控制机制

2．了解几个主要的API

• javax.security.auth.Subject
      Subject表征系统中一个认证的用户，这个词时而被译为“主题”时而被以为“主体”（下面我要谈到的Principal有时候也被译为“主体”），不管它有几个马甲，反正你就可以看成是在Java中你这个人的影子，你对系统的访问就体现为Subject.doAs()或Subject.doAsPrivileged()方法。
  
  
• java.security.Principal
      Principal代表用户的一种身份对象，一个用户的身份可能不只一个，他所在的组或所担任的角色也是一种身份，“张翠山”可以说“铁划银钩”，可以说“张三丰的徒弟”，可以说“张无忌他老爹”，我说“武当七侠”甚至“武当派”，当然也没错，这是一个组，呵呵。通过一次登录后，可能向Subject插入一个或多个Principal，这时候Subject才有实际意义，而不是一个空壳。
  
  
• javax.security.auth.login.LoginContext
      LoginContext旨在提供一个开放的登录总接口，你只需要用从策略文件中取得的策略名，以及下面介绍的回调对象创建得到一个LoginContext，再调用一次login()方法即可完成登录，登录模块在这里是透明的。
  
  
• javax.security.auth.spi.LoginModule
      登录模块实现了对用户的认证逻辑，它的作用是在登录配置文件中得到体现，在后面的例子里我们会看到怎么编写一个登录配置文件以及上面说过的策略文件。LoginModule接口包括五个主要的方法：
  
      initialize方法，初始化模块，保存当前Subject以及一些参数。
  
      login方法，判断一次登录过程中是否认证通过。
  
      commit方法，是否提交登录结果。咦，login不就行了吗？干吗要来个提交呢？这是因为JAAS采用的是类似于数据库事务处理的过程，将整体登录分为两阶段，尽管你login成功，但系统仍有权力根据你这次login的“地位”来决定究竟要不要接纳你的身份，只有通过commit，用户的Principal才会被真正添加到Subject当中，哼哼，真阴险！这里所说的login的“地位”是指策略文件中登录模块的“控制标记”选项，有点类似于优先级的概念，因为登录一个系统的过程可能会经过不止一个登录模块，譬如我们登录系统输入口令，但这个口令可能保存在一个数据库或LDAP目录中，访问这个数据源也需要经过认证，这就不止一个登录模块了吧？所以我们需要分清哪些认证过程是重要的，哪些又是次要的，系统对用户身份的接收与否是对这些策略综合权衡的结果。
  
      abort方法：哎呀，上面解释得是不是太多了？我们再看看abort，还记得数据库事务处理的回退过程（roll back）吗？abort就有点像roll back，表示系统并不接受你的身份，以前做过的统统作废，现场又恢复到和登录前完全一样。
  
      logout方法：注销过程，清除内部状态，并删除Subject中全部的Principal。
  
  
• javax.security.auth.callback.CallbackHandler
      回调对象是JAAS中用以将交互过程和认证逻辑分离的一种机制，这也是符合OO和松散耦合（loosely coupled是一个时髦词汇 ^_^）精神的。JAAS已经实现了一些常用的回调对象，包括取得用户名的NameCallback，取得口令的PasswordCallback，从终端获得输入文本的TextInputCallback，向终端发出文本消息的TextOutputCallback等等。我们所要做的仅仅是实现一个CallbackHandler接口，根据不同的交互信息类型，把从终端得到的信息填到相应的Callback中去就行了。后面的例子我是用了一个JoptionPane提示文本框来输入用户名和口令的。
  
  
• java.security.PrivilegedAction
      上面说了那么多登录相关的接口，该说说授权了，如果我们只谈写源代码，那么很简单，只要实现一个PrivilegedAction接口，覆盖一个run()方法，把你想要做的事情统统放到这个run中就可以了。但我说的只是写源代码部分，授权方面用得较多的还是在管理方面，譬如如何编写一个策略文件，下面我们就来看看JAAS登录和访问控制的一个完整流程。
  
  

  3．基本流程

  
  
      JAAS被称为是“可插拔的认证框架”（Pluggable Authentication Module，PAMs），其实PAM也不是SUN的专利，Linux上就有这方面的实现，但PAM确实是较早用在了Solaris系统上。我们看看JAAS在认证和授权方面是怎么体现PAM思想的：
  
      主要包括这么几个部分：
      用户的Principal（MyPrincipal.class）
      登录模块（MyLoginModule.class）
      回调对象（MyCallbackHandler.class）
      访问代码（MyAction.class）
      系统入口（JAASTest.class）
      资源（myfile.txt）
      策略配置文件（login.conf）
      登录配置文件（jaas.policy）
      启动脚本（JAASTest.bat）
  
      由于启动java的选项太长，所以写了一个shell，在控制台下运行JAASTest.bat，选项“-Djava.security.manager”指定启用安全管理器，执行的是JAASTest类的main线程，由于shell指定选项“-Djava.security.policy=jaas.policy”，该策略文件允许当前代码创建LoginContext，并授权进行其它一些操作，它首先初始化一个LoginContext，选项“-Djava.security.auth.login.config=login.conf”指定了登录配置文件，所以在当前目录下找到文件login.conf，该文件中指定的登录策略名称为“JAASTest”，所以在LoginCotext中第一个参数也是“JAASTest”，同时使用我们自定义的回调对象MyCallbackHandler。创建LoginContext成功，可以进行登录了，调用LoginContext的login方法，该方法找到login.conf中的登录模块MyLoginModule（当然可以有若干个登录模块，这里我只用了一个），执行该模块的登录过程，MyLoginModule首先初始化：
  
  Login module initializing ...
  
  
  并使用LoginContext所赋予它的回调对象MyCallbackHandler，该回调过程弹出两个图形对话框，要求输入用户名和口令，
  
  
  
  
  我们使用指定的用户名“user”和口令“letmepass”，确定以后分别传给当前的NameCallback和PasswordCallback，然后回到MyLoginModule的login过程，该过程从回调对象处得到NameCallback和PasswordCallback，进行认证（这里仅仅是简单的用户名和口令的对比），
  
  MyLoginModule: Authentication pass!
  
  
  并决定是否commit，由于在login.conf中定义该登录模块是required，所以是一个必须通过才能整体认证成功的模块。
  
  MyLoginModule: Add a new principal to current subject.
  
   
  
  如果整体得到认证通过，那么Subject就可以授权允许MyAction中的代码了，如语句Subject.doAs(…)所示，该代码的动作是读取当前目录下的myfile.txt文件，并将其内容打印到控制台，注意到在策略文件jaas.policy中赋予MyPrincipal身份对myfile.txt的读取权限，所以我们成功看到控制台下出现
  
  Access successfully! Reading file:
  ==================================
  Why?
  Because they care!
  Because they want to know the truth!
  Because they want their country back!
  Because it still belongs to us as long as the people have the guts to fight for what they believe in!
  
  ==================================
   
  
      这是我喜欢的一部经典影片“JFK”中检察官Garrison激情的最后陈词中的一段，呵呵！
      以上过程我们可以用个图表来表示：
  
  
  

  4．简单的例子

  
  
      以上流程中使用到的Java源代码和配置文件如下：
  
  // MyPrincipal.java
  package com.jungleford.auth;
  
  import java.security.Principal;
  
  public class MyPrincipal implements Principal
  { // 一个Principal的例子
    private String name; // Principal的名字
  
    public MyPrincipal(String name)
    {
      this.name = name;
    }
  
    public String getName()
    { //取得Principal的名字
      return this.name;
    }
  
    public boolean equals(Object principal)
    { // 判断两个Pincipal相同的依据
      if (principal instanceof MyPrincipal)
        return this.name.equals(((MyPrincipal)principal).getName());
      else
        return false;
    }
  
    public String toString()
    { // Principal的表示
      return "MyPrincipal: " + this.name;
    }
  
    public int hashCode()
    { // 确定本对象的散列值
      // 用于有基于散列容器的场合，判断在散列容器中是否是同一个对象。
      // 如果对hashCode感兴趣，请参见：
      // http://www-900.ibm.com/developerWorks/cn/java/j-jtp05273/
      return this.name.hashCode();
    }
  }
  
  
  
  // MyLoginModule.java
  package com.jungleford.auth;
  
  import java.util.*;
  import java.io.IOException;
  import java.security.Principal;
  import javax.security.auth.*;
  import javax.security.auth.callback.*;
  import javax.security.auth.login.*;
  import javax.security.auth.spi.*;
  
  public class MyLoginModule implements LoginModule
  { // 一个登录模块的例子
    private Subject subject; // 登录主体的表征
    private CallbackHandler cbHandler; // 回调对象，提供终端下获取用户名、口令的界面
    private Map sharedState; // 用于缓存中间结果的共享区
    private Map options; // 用于保存某些登录模块所需要用到的一些配置选项
  
    private boolean succeeded = false; // 一次login成功的标志
    private boolean cmtSucceeded = false; // 整体登录成功的提交标志
  
    private String username; // 取得用户名
    private char[] password; // 取得口令
  
    private Principal principal; // 取得登录后的身份标志
  
    public void initialize(Subject subject,
                             CallbackHandler cbHandler,
                             Map sharedState,
                             Map options)
    { // 初始化过程
      System.out.println("Login module initializing ...");
      System.out.println();
      this.subject = subject;
      this.cbHandler = cbHandler;
      this.sharedState = sharedState;
      this.options = options;
    }
  
    public boolean login() throws LoginException
    { // 一次登录过程
      if (cbHandler == null) // 尚未配置回调对象
        throw new LoginException("Error: No CallbackHandler available " +
                                    "to garner authentication information from the user");
  
      Callback[] cbs = new Callback[2]; // 仅使用用户名回调和口令回调
      cbs[0] = new NameCallback("Login: ");
      cbs[1] = new PasswordCallback("Password: ", false);
  
      try
      {
        cbHandler.handle(cbs);
        username = ((NameCallback)cbs[0]).getName();
        char[] temp = ((PasswordCallback)cbs[1]).getPassword();
        if (temp == null)
        { // 口令为空
          temp = new char[0];
        }
        password = new char[temp.length];
        System.arraycopy(temp, 0, password, 0, temp.length);
        ((PasswordCallback)cbs[1]).clearPassword(); // 清除内存中的口令痕迹
      }
      catch (IOException ioe)
      {
        throw new LoginException(ioe.toString());
      }
      catch (UnsupportedCallbackException uce)
      {
        throw new LoginException("Error: " + uce.getCallback().toString() +
                                    " not available to garner authentication information " +
                                    "from the user");
      }
  
      boolean usrCorrect = false; // 用户名正确否？
      boolean pwdCorrect = false; // 口令正确否？
      if (username.equals("user")) // 目前仅允许用户名为user的登录
        usrCorrect = true;
      if (usrCorrect &&
          password.length == 9 &&
          password[0] == 'l' &&
          password[1] == 'e' &&
          password[2] == 't' &&
          password[3] == 'm' &&
          password[4] == 'e' &&
          password[5] == 'p' &&
          password[6] == 'a' &&
          password[7] == 's' &&
          password[8] == 's') // user的口令指定为letmepass
      {
        System.out.println("MyLoginModule: Authentication pass!");
        System.out.println();
        pwdCorrect = true;
        succeeded = true;
        return true; // 一次登录成功
      }
      else
      {
        System.out.println("MyLoginModule: Authentication failed!");
        System.out.println();
        succeeded = false;
        username = null;
        for (int i = 0; i < password.length; i++) // 清除内存中的口令痕迹
          password[i] = ' ';
        password = null;
        if (!usrCorrect)
        {
          throw new FailedLoginException("Username incorrect!");
        }
        else
        {
          throw new FailedLoginException("Password incorrect!");
        }
      }
    }
  
    public boolean commit() throws LoginException
    { // 根据登录配置策略判断是否整体登录成功
      if (succeeded == false)
      {
        return false;
      }
      else
      {
        principal = new MyPrincipal(username);
        if (!subject.getPrincipals().contains(principal))
        subject.getPrincipals().add(principal); // 把新的身份添加到subject中
  
        System.out.println("MyLoginModule: Add a new principal to current subject.");
        System.out.println();
  
        username = null;
        for (int i = 0; i < password.length; i++) // 清除内存中的口令痕迹
          password[i] = ' ';
        password = null;
  
        cmtSucceeded = true;
        return true;
      }
    }
  
    public boolean abort() throws LoginException
    { // 放弃登录，将状态复位至登录前
      if (succeeded == false)
      {
        return false;
      }
      else if (succeeded == true && cmtSucceeded == false)
      {
        succeeded = false;
        username = null;
        if (password != null)
        {
          for (int i = 0; i < password.length; i++) // 清除内存中的口令痕迹
            password[i] = ' ';
          password = null;
        }
        principal = null;
      }
      else
      {
        logout();
      }
      return true;
    }
  
    public boolean logout() throws LoginException
    { // 注销，并将状态复位至登录前
      subject.getPrincipals().remove(principal);
      succeeded = false;
      succeeded = cmtSucceeded;
      username = null;
      if (password != null)
      {
        for (int i = 0; i < password.length; i++) // 清除内存中的口令痕迹
          password[i] = ' ';
        password = null;
      }
      principal = null;
      return true;
    }
  }
   
  
  
  
  // MyCallbackHandler.java
  package com.jungleford.auth;
  
  import java.io.IOException;
  import javax.security.auth.callback.*;
  import javax.swing.*;
  import java.awt.*;
  import java.awt.event.*;
  
  public class MyCallbackHandler implements CallbackHandler
  {
    public void handle(Callback[] cbs)
    throws IOException, UnsupportedCallbackException
    {
      String username =
      JOptionPane.showInputDialog(null,
                                    "<html>Available name: " +
                                    "<font color=\"blue\">user</font></html>",
                                    "Enter your name",
      JOptionPane.QUESTION_MESSAGE);
      String password =
      JOptionPane.showInputDialog(null,
                                    "<html>Available password: " +
                                    "<font color=\"blue\">letmepass</font></html>",
                                    "Enter your password",
      JOptionPane.QUESTION_MESSAGE);
      for (int i = 0; i < cbs.length; i++)
      {
        if (cbs[i] instanceof TextOutputCallback)
        {
          TextOutputCallback toc = (TextOutputCallback)cbs[i];
          switch (toc.getMessageType())
          {
            case TextOutputCallback.INFORMATION:
              System.out.println(toc.getMessage());
              break;
            case TextOutputCallback.ERROR:
              System.out.println("Error: " + toc.getMessage());
              break;
            case TextOutputCallback.WARNING:
              System.out.println("Warning: " + toc.getMessage());
              break;
            default:
              throw new IOException("Unsupported message type: " +
                                       toc.getMessageType());
          }
        }
        else if (cbs[i] instanceof NameCallback)
        {
          // prompt the user for a username
          NameCallback nc = (NameCallback)cbs[i];
          //System.err.print(nc.getPrompt());
          //System.err.flush();
          nc.setName(username);
        }
        else if (cbs[i] instanceof PasswordCallback)
        {
          // prompt the user for sensitive information
          PasswordCallback pc = (PasswordCallback)cbs[i];
          //System.err.print(pc.getPrompt());
          //System.err.flush();
          pc.setPassword(password.toCharArray());
        }
        else
        {
          throw new UnsupportedCallbackException(cbs[i], "Unrecognized Callback");
        }
      }
    }
  }
   
  
  
  
  //MyAction.java
  package com.jungleford.auth;
  
  import java.io.*;
  import java.security.*;
  
  public class MyAction implements PrivilegedAction
  { // 对资源的授权访问动作
    public Object run()
    { // run方法是必须overriding的
      // 这里我们假设访问动作是读取当前目录下myfile.txt文件的内容
      File file = new File("myfile.txt");
      String content = "";
      try
      {
        BufferedReader reader =
        new BufferedReader(
        new FileReader(file));
        String line = reader.readLine();
        while (line != null)
        {
          content += line + "\n";
          line = reader.readLine();
        }
      }
      catch (Exception e)
      {
        System.err.println("Error: Reading file failed!");
        System.err.println();
        e.printStackTrace();
      }
      return content;
    }
  }
   
  
  
  
  //JAASTest.java
  package com.jungleford.auth;
  
  import javax.security.auth.Subject;
  import javax.security.auth.login.LoginContext;
  
  public class JAASTest
  { // 测试我们JAAS登录和授权的shell
    public static void main(String[] args)
    {
      LoginContext lc = null;
      try
      {
        // 创建context，使用自定义的回调对象，策略名为JAASTest
        // 简单起见，仅使用一个MyLoginModule模块
        lc = new LoginContext("JAASTest", new MyCallbackHandler());
      }
      catch (Exception e)
      {
        System.err.println("Error: Creating login context failed!");
        System.err.println();
        e.printStackTrace();
        System.exit(-1);
      }
      try
      { // 整体登录
        lc.login();
      }
      catch (Exception e)
      {
        System.err.println("Error: Login failed!");
        System.err.println();
        e.printStackTrace();
        System.exit(-1);
      }
      // 获得授权访问
      Object object = Subject.doAs(lc.getSubject(), new MyAction());
      System.out.println("Access successfully! Reading file:");
      System.out.println("==================================");
      System.out.println(object);
      System.out.println("==================================");
      System.exit(0);
    }
  }
  
   
  
  //login.conf
  JAASTest
  {
      com.jungleford.auth.MyLoginModule required;
  };
   
  
  
  //jaas.policy
  grant
  {
      permission javax.security.auth.AuthPermission "createLoginContext";
      permission javax.security.auth.AuthPermission "doAs";
      permission javax.security.auth.AuthPermission "modifyPrincipals";
      permission javax.security.auth.AuthPermission "getSubject";
  };
  
  grant principal com.jungleford.auth.MyPrincipal "guest"
  {
      permission java.io.FilePermission "myfile.txt","read";
  };
   
  
  
  //JAASTest.bat
  java -Djava.security.manager
       -Djava.security.auth.login.config=login.conf
       -Djava.security.policy=jaas.policy
       com.jungleford.auth.JAASTest
   
  
  
  //myfile.txt
  Why?
  Because they care!
  Because they want to know the truth!
  Because they want their country back!
  Because it still belongs to us as long as the people have the guts to fight for what they believe in!