最后，我们开始讨论本教程最有趣的部分：边学边做。我们从运行比较全面的 JAASExample 应用程序开始，它包含我们已经在教程中讨论过的所有认证和授权机制（和代码）。运行该示例并查看了第一次配置的结果之后，我们将研究一些不同的配置选项并马上检查结果。在本教程的这最后一章结束时，您将初次体验 JAAS 编程的乐趣。

设计 JAASExample 应用程序的目的是为了演示几种认证和授权技术以及一些配置设置的影响。用下列语句开始运行该示例，可以在教程源文件（请参阅参考资料）中的文件 run.bat 中找到这些语句。

				 java -Djava.security.manager
-Djava.security.auth.login.config==login.config
-Djava.security.policy==jaas.policy JAASExample 

		

语句指示系统的缺省安全性管理器使用名为 login.config 的登录配置文件，使用名为 jaas.policy 的安全性策略文件，最后运行主应用程序 JAASExample。注：双等于号（==）表明系统缺省登录配置和策略文件不应该添加到已在这里列出的各项中。一个等于号（=）表明应该将文件与系统缺省值并置。

示例结果和说明

 

下面是运行 JAASExample 的结果：

				
AlwaysLoginModule Login
Username? Brad

Login: AlwaysLoginModule SUCCESS

PasswordLoginModule Login
Username? joeuser
Password? joepw

Login: PasswordLoginModule Username Matches
Login: PasswordLoginModule Password Matches
Login: PasswordLoginModule SUCCESS
Commit: AlwaysLoginModule SUCCESS
Commit: PasswordLoginModule SUCCESS

OVERALL AUTHENTICATION SUCCEEDED

Subject:
           Principal: Brad
           Principal: joeuser

joeuser has Payroll access

Subject has Personnel access

Logout: AlwaysLoginModule SUCCESS
Logout: PassswordLoginModule SUCCESS

		

下面详尽地描述了上面结果中的正常执行情况：

1. login.config 定义两个登录模块；AlwaysLoginModule 是必需的。它先运行。
   
   
2. AlwaysLoginModule 在登录阶段启动，它调用回调处理程序来获取用户名（Brad）。登录成功。
   
   
3. 第二个登录模块 PasswordLoginModule 是可选的。它接下来运行，调用回调处理程序以获取用户名（joeuser）和密码（joepw），两者都是匹配的。该登录也是成功的。
   
   
4. 因为必需的和可选的模块都成功，所以在两个登录模块上同时调用 commit，并且整个认证成功。结果，Subject 同时包含两个 Principal：Brad 和 joeuser。
   
   
5. 使用程序性授权的工资单程序检查 joeuser 是否在 Subject 的 Principal 集中，如果是，授予它访问权。
   
   
6. 使用声明性授权的职员信息程序查看 jaas.policy 文件中是否有授权语句，授予 BradPersonnelPermission 的特权，所以它也成功。
   
   
7. 两个登录模块同时注销。

失败的认证

 

只是为了好玩，让我们看一下当我们出差错时会发生什么情况。在下面的示例中，设置是相同的，但我们将为 joeuser 输入一个错误密码。请亲自检查下面的输出，看一下它与上面的结果有何不同。

				
AlwaysLoginModule Login
Username? Brad

Login: AlwaysLoginModule SUCCESS

PasswordLoginModule Login
Username? joeuser
Password? wrongpw

Login: PasswordLoginModule Username Matches
Login: PasswordLoginModule Password Mismatch
Login: PasswordLoginModule FAIL
Commit: AlwaysLoginModule SUCCESS
Commit: PasswordLoginModule FAIL

OVERALL AUTHENTICATION SUCCEEDED

Subject:
           Principal: Brad

Payroll Access DENIED
Subject has Personnel access

Logout: AlwaysLoginModule SUCCESS
Logout: PasswordLoginModule SUCCESS

		

正如您所看到的那样，PasswordLoginModule 登录已经失败。但是，因为这个模块在 login.config 文件中配置为 optional，所以总体认证仍是成功的。区别在于只有 Brad Principal 被添加到 Subject 中。工资单程序找不到 joeuser Principal，所以访问被拒绝。职员信息程序可以将 Brad Principal 与 Brad 授权语句匹配，所以它被成功添加并授予访问权。

在接下来的几页中，我们将对 login.config 文件的配置作一些修改，然后检查每种新配置的结果。

首先，让我们看一下当我们将 login.config 文件更改为：为了认证成功，两个登录模块都是必需的，会是什么情况。新的 config 文件是：

				
JAASExample {
      AlwaysLoginModule required;
      PasswordLoginModule required;
};

		

这里是结果输出：

				
AlwaysLoginModule Login
Username? Brad

Login: AlwaysLoginModule SUCCESS

PasswordLoginModule Login
Username? joeuser
Password? wrongpw

Login: PasswordLoginModule Username Matches
Login: PasswordLoginModule Password Mismatch
Login: PasswordLoginModule FAIL
Abort: AlwaysLoginModule SUCCESS
Logout: AlwaysLoginModule SUCCESS
Abort: PasswordLoginModule FAIL

OVERALL AUTHENTICATION FAILED

		

当 joeuser 输入错误密码时，PasswordLoginModule 就会象先前那样失败。然而，因为该模块是必需的，所以运行异常终止阶段并且总体认证失败。不执行任何敏感代码。

变体 2：PAM 的能力

该变体是为演示可插入的认证模块的实用程序而设计的。我们回到原始的 login.config 文件，即 AlwaysLoginModule 是必需的，而 PasswordLoginModule 是可选的，然后将 NTLoginModule （或适用于您的平台的任何其它模块）添加到该文件。新模块将是 required。修改后的 login.config 文件应该看起来如下：

				
JAASExample {
      AlwaysLoginModule required;
      PasswordLoginModule optional;
      com.sun.security.auth.module.NTLoginModule required;
};

		

接下来，运行示例。在下面的输出中，您将看到已经添加了一个新的认证方法以及几个全新的 Principal（和一个公用凭证）。

				
AlwaysLoginModule Login
Username? Brad

Login: AlwaysLoginModule SUCCESS

PasswordLoginModule Login
Username? joeuser
Password? joepw

Login: PasswordLoginModule Username Matches
Login: PasswordLoginModule Password Matches
Login: PasswordLoginModule SUCCESS
Commit: AlwaysLoginModule SUCCESS
Commit: PasswordLoginModule SUCCESS

OVERALL AUTHENTICATION SUCCEEDED

Subject:
           Principal: Brad
           Principal: joeuser
           Principal: NTUserPrincipal: Brad
           Principal: NTDomainPrincipal: WORKGROUP
           Principal: NTSidUserPrincipal:
S-1-5-21-2025429265-1580813891-854245398-1004
           Principal: NTSidPrimaryGroupPrincipal: 
S-1-5-21-2025429265-1580418891-85 4245398-513
           Principal: NTSidGroupPrincipal: 
S-1-5-21-2025429265-1580818891-854245398-513
           Principal: NTSidGroupPrincipal: S-1-1-0
           Principal: NTSidGroupPrincipal: S-1-5-32-544
           Principal: NTSidGroupPrincipal: S-1-5-32-545
           Principal: NTSidGroupPrincipal: S-1-5-5-0-49575

           Principal: NTSidGroupPrincipal: S-1-2-0
           Principal: NTSidGroupPrincipal: S-1-5-4
           Principal: NTSidGroupPrincipal: S-1-5-11
           Public Credential: NTNumericCredential: 1240

joeuser has Payroll access

Subject has Personnel access

Logout: AlwaysLoginModule SUCCESS
Logout: PasswordLoginModule SUCCESS

		

更酷的是，我们甚至不必自己改动我们的应用程序代码。上面所有的更改都是由本机 OS 认证机制完成的。这应该向您暗示了 PAM 的能力。

在最后一个变体中，我们将查看当修改访问控制策略时会发生什么情况。我们从修改原始 login.config 中的 grant 文件开始，以便 joeuser（而不是 Brad）有 PersonnelPermission，如下所示：

				
grant Principal PrincipalImpl "joeuser" {
     permission PersonnelPermission "access";
};

		

接下来，运行应用程序，为 joeuser 输入错误密码。结果如下所示：

				
AlwaysLoginModule Login
Username? Brad

Login: AlwaysLoginModule SUCCESS

PasswordLoginModule Login
Username? joeuser
Password? wrongpw


Login: PasswordLoginModule Username Matches
Login: PasswordLoginModule Password Mismatch
Login: PasswordLoginModule FAIL
Commit: AlwaysLoginModule SUCCESS
Commit: PasswordLoginModule FAIL

OVERALL AUTHENTICATION SUCCEEDED

Subject:
           Principal: Brad

Payroll Access DENIED
Personnel Access DENIED
Logout: AlwaysLoginModule SUCCESS
Logout: PasswordLoginModule SUCCESS

		

正如您所看到，Subject 的 Principal 集中只有 Brad。工资单访问和职员信息访问的尝试都已失败。为什么？第一次尝试失败是因为没有名为 joeuser 的 Principal，第二次尝试失败是因为对于 Brad 没有授予权限语句。

在本章中，我们已经将所有 JAAS 认证和授权片段合在一起来说明完整的 JAAS 应用程序的运行情况。我们还对应用程序做了几次改动以观察它实际上发生了什么以及该体系结构在应用程序安全性方面有多灵活。

为了扩展您在这里学到的知识，您应该继续使用 JAAS 并查看当尝试不同的登录配置时会发生什么情况。例如，如果在您的安装中运行着 Kerberos，尝试运行 Kerberos 登录模块。

下载

• 下载本教程中使用的完整源代码和类。
  
  
• 可从 Sun Microsystems 获得 Java 2 平台，标准版（http://java.sun.com/j2se/）。

文章、教程和其它在线参考资料

• 请阅读由 Brad Rubin 编写的本教程系列的第 1 部分，“Crypto basics，”（http://www-106.ibm.com/developerworks/education/r-jsec1.html）。
  
  
• 请参阅 Java 开发人员连接（Java Developer Connection），以获取完整的 Java 权限（http://java.sun.com/j2se/1.4/docs/guide/security/permissions.html）的列表。
  
  
• 虽然本教程中未论及新近与 JDK 1.4 一起提供的 Java 通用安全性服务（Java General Security Service(JGSS)），但它提供了用于在应用程序之间安全地交换消息的通用框架。Sun 最新发布的白皮书（http://java.sun.com/j2se/1.4/docs/guide/security/jgss/single-signon.html）讨论了如何使用 JAAS、JGSS 和 Kerberos 来提供单点登录应用程序安全性。
  
  
• Sun 还拥有几个描述 JAAS 和 JGSS 的不同使用方法和过程的教程和用户指南（http://java.sun.com/j2se/1.4/docs/guide/security/jgss/tutorials/）。有一个极好的参考指南描述了 when to use JGSS versus JSEE（http://java.sun.com/j2se/1.4/docs/guide/security/jgss/tutorials/JGSSvsJSSE.html）。
  
  
• 请参阅 Sun Microsystems 的 Java Security 站点（http://java.sun.com/security），学习更多有关最新 Java 安全性技术的知识。
  
  
• Joseph Sinclair 在系列文章“Securing systems”中，提供了一篇“A three-pronged solution for identifying users”（developerWorks，2001 年 6 月，http://www-106.ibm.com/developerworks/library/j-secure/index.html）。
• 一旦您掌握了基本知识，Carlos Fonseca 将向您展示如何“Extend JAAS for class instance-level authorization”（developerWorks，2002 年 4 月，http://www-106.ibm.com/developerworks/library/j-jaas/）。
  
  
• 在“Enhance Java GSSAPI with a login interface using JAAS”中，Thomas Owusu 提供了有关凭证和秘钥的一些颇有见地的观点（developerWorks，2001 年 11 月，http://www-106.ibm.com/developerworks/library/j-gssapi/）。
  
  
• 查找 WebSphere Portal Server 1.2 如何实现 JAAS 和单点登录安全性（WebSphere 开发者园地，2001 年 10 月）。

书籍

• 有关 Web 安全性和 Java 技术的全面讨论，请参阅由 O'Reilly 于 2002 年出版的 Web Security, Privacy, and Commerce，第二版（由 Simson Garfinkel 和 Gene Spafford 合著）。
  
  
• 如果您想更进一步了解 Java 安全性，请参阅 Wrox Press 于 2001 年出版的 Professional Java Security（http://www.amazon.com/exec/obidos/ASIN/1861004257/104-8739833-1347930）（由 Jess Garms 和 Daniel Somerfield 合著）。
  
  
• 另一本学习 Java 安全性的优秀参考资料是由 O'Reilly & Associates 于 2001 年出版的 Java Security（http://www.amazon.com/exec/obidos/ASIN/0596001576）（Scott Oaks 著）。
  
  
• 从 Secrets and Lies: Digital Security in a Networked World（http://www.counterpane.com/sandl.html，Bruce Schneier 著，2000 年）中可以找到人们为了生存和竞争需要知道哪些安全性方面的知识。
  
• 如果您想着重了解认证技术，请参阅 Authentication: From passwords to public keys （http://www.aw.com/catalog/academic/product/1,4096,0201615991,00.html，Richard E. Smith 著，由 Addison-Wesley 于 2002 年出版）。

其它参考资料

• IBM Java Security Research 页面（http://www.research.ibm.com/javasec/）详细描述了开发中的各种安全性项目。
  
  
• 请访问 Tivoli 开发者园区（http://www-106.ibm.com/developerworks/tivoli/），以帮助您构建和维护电子商务的安全性。
  
  
• developerWorks 的安全性特殊主题为开发人员提供了包含一般安全性主题的实用技术信息。
  
  
• 参与由 Paul Abbott 主管的 developerWorks Java 安全性论坛。
  
  
• 您将在 developerWorksJava 技术专区（http://www-106.ibm.com/developerworks/java/）中找到上百篇有关 Java 编程各个方面的文章。
  
  
• 请参阅 developerWorks 教程页面（http://www-105.ibm.com/developerworks/education.nsf/dw/java-onlinecourse-bytitle），以便从 developerWorks 获取与 Java 技术相关的免费教程的完整列表。

了解 Java 平台如何实现授权的访问控制对于了解我们将在本章中讨论的概念很重要。Java 平台使用访问控制环境（access control context）的概念来确定当前执行线程的权限。从概念上讲，可以将它视作与每个执行线程连接的令牌。在 JAAS 之前，访问控制基于了解当前 Java .class 文件的代码来源或数字签名者的身份。在这种模型下，访问控制是基于了解代码出自于何处。有了 JAAS，我们将模型转了个向。通过将 Subject 添加到访问控制环境，我们可以开始根据谁正在执行（或要求执行）一段给定代码来授予或拒绝访问权。

在本章中，您将了解 JAAS 的用于控制对敏感代码访问的机制。我们将首先描述授权在 JAAS 中是如何工作的，然后继续更深入地描述授权框架的每个组件。在本章的最后，我们将给出在较大型的运行示例中使用的一些代码样本，它们演示了程序性授权和声明性授权技术。读完本章之后，您应该清楚地知道 JAAS 的认证和授权机制如何一起工作来保护基于 Java 的系统。

访问控制和权限
 

因为执行线程可以跨越多个具有不同环境特征的模块，所以 Java 平台实现了最小特权这一概念。在属于给定执行线程的整个调用程序栈中，调用栈的成员具有不同特征，用于确定权限的结果是所有这些特征的交集或最小公分母。例如，如果一段调用代码有受限权限（可能由于未对它签名，所以它不可信），但它调用一段信任度较高的代码（可能有一个签名），则降低被调用代码中的权限来匹配较低的信任度。

将包含在访问控制环境中的权限特征与策略文件中的 Java 权限 grant 语句进行比较，以表明是否允许敏感操作。这是由名为 AccessController 的 Java 实用程序完成的，它的接口用于通过程序检查特权以及将当前的 Subject 与活动的访问控制环境相关联。（较旧的 Java 安全性管理器（Java Security Manager）接口已经过时，所以一定要使用 AccessController 方法。）

将 Subject 绑定到访问控制环境
 

因为可以在应用程序启动之后认证 Subject，所以必须有一个将 Subject 动态绑定到访问控制环境的方法，以创建一个包含代码权限（从何处装入它以及谁对它进行签名）和用户权限（Subject）环境。为此，我们使用方法 Object doAs(Subject subject, PrivilegedAction action)。这个 doAs 方法调用特别为授权设计的类，该类实现 PrivilegedAction 接口。

如果不使用线程的当前方法，则可以使用另一种调用方法 Object doAsPrivileged(Subject, PrivilegedAction action, AccessControlContext acc) 来指定访问控制环境。它的特殊用法是将 AccessControlContext 设置为空，在 doAsPrivileged 调用发生时，可以使调用栈短路，并且在 PrivilegedAction 对象中时，允许增加权限。稍后，当对象返回到调用程序时，将减少权限。本教程稍后将说明这两种技术。

doAs 和 doAsPrivileged 方法形式上都允许抛出 PrivilegedActionException。

权限

 

Java 平台有许多用于控制对系统资源的访问的内置权限。例如：

				
grant signedBy "Brad", codeBase "http://www.bradrubin.com" {
       permission java.io.FilePermission "/tmp/abc", "read";
};


		

允许由“Brad”签名的并从“http://www.bradrubin.com”装入的代码读取 /tmp/abc 目录。有关 Java 权限的完整列表，请参阅参考资料。

创建您自己的权限
 

Java 平台允许您创建自己的权限对象。与正规的权限相似，可以将这些对象放在策略文件中，并在部署时配置它们。为了进行演示，请查看下面的 PersonnelPermission。稍后，我们将使用这些代码以允许访问一些敏感的职员信息操作的代码。

				
import java.security.*;
//
// Implement a user defined permission for access to the personnel //
code for this example public class PersonnelPermission extends
BasicPermission {

     public PersonnelPermission(String name) {
       super(name);
     }

     public PersonnelPermission(String name, String action) {
       super(name);
     }
}

		

对于上面的权限，您应该注意以下几点：第一，构造器使用用户定义的特权名称（在这个示例中，只有一种名为 access 的类型）。另外一个构造器使用名为 action 的附加的改进的参数，虽然这里不使用它。对于这个示例，将使用 BasicPermission 类。如果我们需要更多特性，可以使用 Permission 类。

策略文件

 

策略文件是控制对系统资源（包括敏感代码）访问的主要机制。本示例中的策略文件名为 jaas.policy，并且在 Java 命令行中由特性 -Djava.security.policy==jaas.policy 指定。双等于号（==）表明将替换系统策略文件，而不是添加到系统策略文件权限中。下面是我们正在本教程中使用的 jaas.policy 文件：

				
grant {
     permission javax.security.auth.AuthPermission "createLoginContext";
     permission javax.security.auth.AuthPermission "doAs";
     permission javax.security.auth.AuthPermission "doAsPrivileged";
     permission javax.security.auth.AuthPermission "modifyPrincipals";
     permission javax.security.auth.AuthPermission "getSubject"; };

grant      principal PrincipalImpl "Brad" {
     permission PersonnelPermission "access";
};

		

为了使 JAAS 机制自举，系统必须有某些特权 — 即示例中的前五个。通过这些适当的权限，将访问权 PersonnelPermission（用户定义的权限）授予“Brad”主体。

JAAS 主程序示例

 

下面是这个示例的主应用程序（从命令行调用）。它实例化登录环境、然后登录、尝试执行两个敏感对象（一个对象使用程序性授权，另一个对象使用声明性授权），最后注销。接下来，我们将更深入地研究主程序的两个元素：程序性授权和声明性授权。

				
import java.security.*;
import javax.security.auth.*;
import javax.security.auth.callback.*;
import javax.security.auth.login.*;
//
// This is the main program in the JAAS Example.  It creates a Login  
// Context, logs the user in based on the settings in the Login  
// Configuration file,and calls two sensitive pieces of code, the  
// first using programmatic authorization, and the second using 
// declarative authorization.
public class JAASExample {

     static LoginContext lc = null;

     public static void main( String[] args) {
       //
       // Create a login context
       try {
         lc = new LoginContext("JAASExample",
            new UsernamePasswordCallbackHandler());
       } catch (LoginException le) {
         System.out.println( "Login Context Creation Error" );
         System.exit(1);
       }
       //

       // Login
       try {
         lc.login();
       } catch (LoginException le) {
         System.out.println( "\nOVERALL AUTHENTICATION FAILED\n" );
         System.exit(1);
       }
       System.out.println( "\nOVERALL AUTHENTICATION SUCCEEDED\n" );
       System.out.println( lc.getSubject() );
       //
       // Call the sensitive PayrollAction code, which uses programmatic
       // authorization.
       try {
         Subject.doAs( lc.getSubject(), new PayrollAction() );
       } catch (AccessControlException e) {
         System.out.println( "Payroll Access DENIED" );
       }
       //
       // Call the sensitive PersonnelAction code, which uses declarative
       // authorization.
       try {
         Subject.doAsPrivileged( lc.getSubject(), new PersonnelAction(), null );
       } catch (AccessControlException e) {
         System.out.println( "Personnel Access DENIED" );
       }
       try {
         lc.logout();
       } catch (LoginException le) {
         System.out.println( "Logout FAILED" );
         System.exit(1);
       }
       System.exit(0);

     }
}

		

程序性授权示例
 

在这个示例中，我们将了解如何编码程序权限决定。PrivilegedAction 类由主 JAASExample 程序的 doAs 方法调用，因此当它输入 run 方法时，经认证的 Subject 被绑定到线程上的应用程序环境。

我们从访问控制器检索当前的 Subject，遍历任何包含的经认证的 Principal，以查找“joeuser”。如果找到他，则可以进行敏感的操作并返回。如果找不到，我们抛出一个 AccessControlException。显然，在现实生活中我们应该使用更易于管理且可伸缩的技术，而不是将用户名直接硬编码到应用程序中。

				
import java.io.*;
import java.security.*;
import javax.security.auth.*;
import javax.security.auth.login.*;
import java.util.*;
//
// This class is a sensitive Payroll function that demonstrates the
// use of programmatic authorization which only allows a subject 
// that contains the principal "joeuser" in class PayrollAction
implements PrivilegedAction {
     public Object run() {
       // Get the passed in subject from the DoAs
       AccessControlContext context = AccessController.getContext();
       Subject subject = Subject.getSubject( 
context );
       if (subject == null ) {
         throw new AccessControlException("Denied");
       }
       //
       // Iterate through the principal set looking for joeuser.  If
       // he is not found,
       Set principals = subject.getPrincipals();
       Iterator iterator = principals.iterator();
       while (iterator.hasNext()) {
         PrincipalImpl principal = (PrincipalImpl)iterator.next();
         if (principal.getName().equals( "joeuser" )) {
           System.out.println("joeuser has Payroll access\n");
           return new Integer(0);
         }
       }
       throw new AccessControlException("Denied");
     }
}









声明性授权示例
在这个示例中，我们将通过使用用户定义的权限 PersonnelPermission，来演示如何用策略文件中的权限授予以声明性授权的方式来控制授权检查。我们只询问 AccessController 是否已经授予这个权限，如果没有授予，它抛出一个 AccessControlException，否则，如果已经授予，则保持运行。我们用主 JAASExample 代码中的 doAsPrivileged 调用和空访问控制环境来调用这个 PrivilegedAction，以使调用时调用栈短路。因为在将 Subject 与 doAsPrivileged 调用中的环境结合之前，Subject 不是环境的一部分，也未经 grant 语句授权，而且还因为使用了“最小特权”和权限的交集，所以这是必需的，否则将不允许提高权限的级别。

import java.io.*;
import java.security.*;
//
// This class is a sensitive Personnel function that demonstrates 
// the use of declarative authorization using the user defined 
// permission PersonnelPermission, which throws an exception 
// if it not granted 
class PersonnelAction implements PrivilegedAction {
     public Object run() {
       AccessController.checkPermission(new PersonnelPermission("access"));
       System.out.println( "Subject has Personnel access\n");
       return new Integer(0);
     }
}





		

本章中，我们将集中讨论 JAAS 中的认证元素。我们将从描述简单的登录和认证过程开始，它将为您提供 JAAS 认证体系结构的高级别视图。接着，我们将详细讨论体系结构的每一部分。本章结束时，您将有机会仔细地研究两个登录模块的代码。

如果您还没有下载本教程的源代码，请您现在就开始下载。该源代码能更好地说明后面讨论中概述的步骤。

												
import java.io.Serializable;
import java.security.Principal;

//
// This class defines the principle object, which is just an encapsulated 
// String name 
public class PrincipalImpl implements Principal, Serializable {

     private String name;

     public PrincipalImpl(String n) {
       name = n;
     }

     public boolean equals(Object obj) {
       if (!(obj instanceof PrincipalImpl)) {
         return false;
       }
       PrincipalImpl pobj = (PrincipalImpl)obj;
       if (name.equals(pobj.getName())) {
         return true;
       }
       return false;
     }

     public String getName() {
       return name;
     }

     public int hashCode() {
       return name.hashCode();
     }

     public String toString() {
       return getName();
     }

}
登录配置


JAAS 允许在以下几个方面有极大的灵活性：Subject 需要的认证过程种类、它们的执行顺序以及在 Subject 被认为是已认证的之前要求的认证成功或失败的组合。
JAAS 使用 login.config 文件来指定每个登录模块的认证项。login.config 文件是在 Java 执行命令行上用特性 -Djava.security.auth.login.config==login.config 指定的。Java 有缺省登录配置文件，所以双等于号（==）替换系统登录配置文件。如果使用一个等于号，login.config 文件将被添加到（而不是替换）系统登录配置文件。因为我们不知道您的系统文件中可能会有什么，所以我们这样做来确保对于各种各样的教程用户都可以得到可靠的结果。
login.config 文件包含 LoginContext 构造器中引用的文本字符串和登录过程列表。几个参数用于指定一个给定的登录过程的成功或失败对总体认证过程的影响。有如下参数：
required 表示登录模块必须成功。即使它不成功，还将调用其它登录模块。

optional 表示登录模块可以失败，但如果另一个登录模块成功，总体登录仍可以成功。如果所有登录模块都是可选的，那么要使整个认证成功至少必须有一个模块是成功的。

requisite 表示登录模块必须成功，而且如果它失败，将不调用其它登录模块。

sufficient 表示如果登录模块成功，则总体登录将成功，同时假设没有其它必需或必不可少的登录模块失败。 

示例 login.config 文件


我们将在本教程中使用的 login.config 文件如下：

JAASExample {
      AlwaysLoginModule required;
      PasswordLoginModule optional;
};
正如您看到的那样，AlwaysLoginModule 必须成功，而 PasswordLoginModule 可以成功也可以失败。这不是一种现实的情形，稍后我们将修改这些参数来查看不同的配置如何更改代码行为。
对于这项登录配置技术，应该认识到它将所有主要决定（如所需的认证类型和认证成功或失败的特定标准）都留到建立部署时决定，这很重要。成功的登录将导致新的 Subject 添加到 LoginContext，同时将所有成功认证的 Principal 添加到该 Subject。

登录环境


LoginContext 是一种用于设置登录过程的 Java 类，它进行实际的登录，如果登录成功，获取 Subject。它有如下四种主要方法：
LoginContext("JAASExample", newUsernamePasswoerdCallbackHandler()) 是构造器。它把 login.config 文件中使用的字符串作为其第一个参数，把执行实际任务的回调处理程序作为其第二个参数。（接下来，我们将讨论回调处理程序。）

login()，它根据 login.config 文件中指定的规则实际尝试登录。

getSubject()，如果登录总体成功，它返回经认证的 Subject。

logout()，它向 LoginContext 注销 Subject。 


回调处理程序


JAAS 登录使用回调处理程序来获取用户的认证信息。CallbackHandler 是在 LoginContext 对象的构造函数中指定的。在本教程中，回调处理程序使用几个提示来获取用户的用户名和密码信息。从登录模块调用的处理程序的 handle() 方法将 Callback 数组对象作为其参数。在登录期间，处理程序遍历 Callback 数组。handle() 方法检查 Callback 对象的类型并执行适当的用户操作。Callback 类型如下：
NameCallback
PasswordCallback
TextInputCallback
TextOutputCallback
LanguageCallback
ChoiceCallback
ConfirmationCallback
在某些应用程序中，因为 JAAS 将用于与操作系统的认证机制相互操作，所以不需要任何用户交互。在这种情况下，LoginContext 对象中的 CallbackHandler 参数将是空的。









												

														

																

																		

																				
																						回调处理程序代码
																				
																		
																		

																		
																
														
												
												

												

												
														
下面是本教程中使用的 UsernamePasswordCallbackHandler 的代码。它由 AlwaysLoginModule 调用一次（仅一次回调以获取用户标识），由 PasswordLoginModule 调用一次（两次回调以获取用户标识和密码）。
														
																
import java.io.*;
import java.security.*;
import javax.security.auth.*;
import javax.security.auth.callback.*;
//
// This class implements a username/password callback handler that gets 
// information from the user public class
UsernamePasswordCallbackHandler implements CallbackHandler {
     //
     // The handle method does all the work and iterates through the array
     // of callbacks, examines the type, and takes the appropriate user
     // interaction action.
     public void handle(Callback[] callbacks) throws
         UnsupportedCallbackException, IOException {

       for(int i=0;i<callbacks.length;i++) {
         Callback cb = callbacks[i];
         //
         // Handle username aquisition
         if (cb instanceof NameCallback) {
           NameCallback nameCallback = (NameCallback)cb;
           System.out.print( nameCallback.getPrompt() + "? ");
           System.out.flush();
           String username = new BufferedReader(
               new InputStreamReader(System.in)).readLine();
           nameCallback.setName(username);
           //
           // Handle password aquisition
         } else if (cb instanceof PasswordCallback) {
           PasswordCallback passwordCallback = (PasswordCallback)cb;
           System.out.print( passwordCallback.getPrompt() + "? ");
           System.out.flush();
           String password = new BufferedReader(
               new InputStreamReader(System.in)).readLine();
           passwordCallback.setPassword(password.toCharArray());
           password = null;
           //
           // Other callback types are not handled here
         } else {
           throw new UnsupportedCallbackException(cb, "Unsupported 
Callback Type");
         }
       }
     }
}
登录模块


LoginModule 是参与 JAAS 认证过程所需的方法的接口。因为可能要到执行其它登录过程时才知道特定登录过程是成功还是失败，所以用两阶段提交过程来确定是否成功。下列方法由 LoginModule 对象实现：
initialize( subject, callbackHandler, sharedState, options) 初始化 LoginModule。（注：对 sharedState 和 options 的讨论超出了本教程的范围。）

login() 设置任何必需的回调，调用 CallbackHandler 来处理它们，并将返回的信息（即用户名和密码）与允许值进行比较。如果匹配，则登录模块成功，尽管仍可能因为另一个登录模块不成功而异常终止它，这取决于 login.config 文件中的设置。

commit() 作为两阶段提交过程的一部分被调用以确定是否成功。如果根据 login.config 文件中指定的约束，所有登录模块都是成功的，那么新的 Principal 随同用户名一起创建，并被添加到 Subject 的主体集。

abort()，如果总体登录未成功，则调用它；如果发生异常终止，必须清除内部的 LoginModule 状态。

logout() 被调用以除去 Subject 的主体集中的 Principal 并执行其它内部状态清除。 
下面两页说明了两个登录模块。第一个是 AlwaysLoginModule，它始终是成功的。第二个是 PasswordLoginModule，仅当用户标识和密码与某些硬编码值匹配时，它才会成功。虽然两个示例模块都不是合乎实际的实现，但它们共同演示了各种 JAAS 选项的结果。

AlwaysLoginModule


AlwaysLoginModule 认证将始终成功，所以实际上它仅用于通过 NameCallback 函数获取用户名。假设其它登录模块都成功，AlwaysLoginModule 的 commit() 方法将创建一个带用户名的新 PrincipalImpl 对象并将它添加到 Subject 的 Principal 集中。注销将除去 Subject 的 Principal 集中的 PrincipalImpl。

import java.security.*;
import javax.security.auth.*;
import javax.security.auth.spi.*;
import javax.security.auth.callback.*;
import javax.security.auth.login.*;
import java.io.*;
import java.util.*;

// This is a JAAS Login Module that always succeeds.  While not realistic, 
// it is designed to illustrate the bare bones structure of a Login Module 
// and is used in examples that show the login configuration file 
// operation.

public class AlwaysLoginModule implements LoginModule {

     private Subject subject;
     private Principal principal;
     private CallbackHandler callbackHandler;
     private String username;
     private boolean loginSuccess;
     //
     // Initialize sets up the login module.  sharedState and options are
     // advanced features not used here
     public void initialize(Subject sub, CallbackHandler cbh,
       Map sharedState, Map options) {

       subject = sub;
       callbackHandler = cbh;
       loginSuccess = false;
     }
     //
     // The login phase gets the userid from the user
     public boolean login() throws LoginException {
       //
       // Since we need input from a user, we need a callback handler
       if (callbackHandler == null) {
         throw new LoginException( "No CallbackHandler defined");

       }
       Callback[] callbacks = new Callback[1];
       callbacks[0] = new NameCallback("Username");
       //
       // Call the callback handler to get the username
       try {
         System.out.println( "\nAlwaysLoginModule Login" );
         callbackHandler.handle(callbacks);
         username = ((NameCallback)callbacks[0]).getName();
       } catch (IOException ioe) {
         throw new LoginException(ioe.toString());
       } catch (UnsupportedCallbackException uce) {
         throw new LoginException(uce.toString());
       }
       loginSuccess = true;
       System.out.println();
       System.out.println( "Login: AlwaysLoginModule SUCCESS" );
       return true;
     }
     //
     // The commit phase adds the principal if both the overall authentication
     // succeeds (which is why commit was called) as well as this particular
     // login module
     public boolean commit() throws LoginException {
       //
       // Check to see if this login module succeeded (which it always will

       // in this example)
       if (loginSuccess == false) {
         System.out.println( "Commit: AlwaysLoginModule FAIL" );
         return false;
       }
       //
       // If this login module succeeded too, then add the new principal
       // to the subject (if it does not already exist)
       principal = new PrincipalImpl(username);
       if (!(subject.getPrincipals().contains(principal))) {
         subject.getPrincipals().add(principal);
       }
       System.out.println( "Commit: AlwaysLoginModule SUCCESS" );
       return true;
     }
     //
     // The abort phase is called if the overall authentication fails, so
     // we have to clean up the internal state
     public boolean abort() throws LoginException {

       if (loginSuccess == false) {
         System.out.println( "Abort: AlwaysLoginModule FAIL" );
         principal = null;
         return false;
       }
       System.out.println( "Abort: AlwaysLoginModule SUCCESS" );
       logout();

       return true;
     }
     //
     // The logout phase cleans up the state
     public boolean logout() throws LoginException {

       subject.getPrincipals().remove(principal);
       loginSuccess = false;
       principal = null;
       System.out.println( "Logout: AlwaysLoginModule SUCCESS" );
       return true;
      }
}
PasswordLoginModule


PasswordLoginModule 使用 NameCallback 来获取用户名并使用 PasswordCallback 来获取密码。如果用户名是“joeuser”，密码是“joe”，则该认证将成功。

import java.security.*;
import javax.security.auth.*;
import javax.security.auth.spi.*;
import javax.security.auth.callback.*;
import javax.security.auth.login.*;
import java.io.*;
import java.util.*;
//
// This is a JAAS Login Module that requires both a username and a  
// password. The username must equal the hardcoded "joeuser" and 
// the password must match the hardcoded "joeuserpw". 
public class
PasswordLoginModule implements LoginModule {

     private Subject subject;
     private Principal principal;
     private CallbackHandler callbackHandler;
     private String username;
     private char[] password;
     private boolean loginSuccess;
     //
     // Initialize sets up the login module.  sharedState and options are
     // advanced features not used here
     public void initialize(Subject sub, CallbackHandler cbh,
       Map sharedState,Map options) {

       subject = sub;
       callbackHandler = cbh;
       loginSuccess = false;
       username = null;
       clearPassword();
     }
     //
     // The login phase gets the userid and password from the user and
     // compares them to the hardcoded values "joeuser" and "joeuserpw".
     public boolean login() throws LoginException {
       //
       // Since we need input from a user, we need a callback handler
       if (callbackHandler == null) {
          throw new LoginException("No CallbackHandler defined");
       }
       Callback[] callbacks = new Callback[2];
       callbacks[0] = new NameCallback("Username");
       callbacks[1] = new PasswordCallback("Password", false);
       //
       // Call the callback handler to get the username and password
       try {
         System.out.println( "\nPasswordLoginModule Login" );
         callbackHandler.handle(callbacks);
         username = ((NameCallback)callbacks[0]).getName();
         char[] temp = ((PasswordCallback)callbacks[1]).getPassword();
         password = new char[temp.length];
         System.arraycopy(temp, 0, password, 0, temp.length);
         ((PasswordCallback)callbacks[1]).clearPassword();
       } catch (IOException ioe) {
         throw new LoginException(ioe.toString());
       } catch (UnsupportedCallbackException uce) {
         throw new LoginException(uce.toString());
       }
       System.out.println();
       //
       // If username matches, go on to check password
       if ( "joeuser".equals(username)) {
         System.out.println
           ( "Login: PasswordLoginModule Username Matches" );
         if ( password.length == 5 &&
             password[0] == 'j' &&
             password[1] == 'o' &&
             password[2] == 'e' &&
             password[3] == 'p' &&
             password[4] == 'w' ) {
           //
           //If userid and password match, then login is a success
           System.out.println
             ( "Login: PasswordLoginModule Password Matches" );
           loginSuccess = true;
           System.out.println
             ( "Login: PasswordLoginModule SUCCESS" );
           clearPassword();
           return true;
         } else {
           System.out.println
            ( "Login: PasswordLoginModule Password Mismatch" );
         }
       } else {
         System.out.println( "Login: PasswordLoginModule Username Mismatch" );
       }
       //
       // If either mismatch, then this login module fails

       loginSuccess = false;
       username = null;
       clearPassword();
       System.out.println( "Login: PasswordLoginModule FAIL" );
       throw new FailedLoginException();
     }
     //
     // The commit phase adds the principal if both the overall 
     // authentication succeeds (which is why commit was called) 
     // as well as this particular login module
     public boolean commit() throws LoginException {

       //
       // Check to see if this login module succeeded
       if (loginSuccess == false) {
         System.out.println( "Commit: PasswordLoginModule FAIL" );
         return false;
       }
       // If this login module succeeded too, then add the new principal
       // to the subject (if it does not already exist)
       principal = new PrincipalImpl(username);
       if (!(subject.getPrincipals().contains(principal))) {
         subject.getPrincipals().add(principal);
       }
       username = null;
       System.out.println( "Commit: PasswordLoginModule SUCCESS" );
       return true;
     }
     //
     // The abort phase is called if the overall authentication fails, so
     // we have to cleanup the internal state
     public boolean abort() throws LoginException {

       if (loginSuccess == false) {
         System.out.println( "Abort: PasswordLoginModule FAIL" );
         principal = null;
         username = null;
         return false;
       }
       System.out.println( "Abort: PasswordLoginModule SUCCESS" );
       logout();
       return true;
     }
     //
     // The logout phase cleans up the state
     public boolean logout() throws LoginException {
       subject.getPrincipals().remove(principal);
       loginSuccess = false;
       username = null;
       principal = null;
       System.out.println( "Logout: PasswordLoginModule SUCCESS" );
       return true;
     }
     //
     // Private helper function to clear the password, a good programming
     // practice
     private void clearPassword() {
       if (password == null) {
         return;
       }
       for (int i=0;i<password.length;i++) {
         password[i] = ' ';
       }
       password = null;
     }
}