grandboy http://grandboy.javaeye.com UTF-8 Copyright 2003-2008, JavaEye.com http://blogs.law.harvard.edu/tech/rss JavaEye - 做最棒的软件开发交流社区 Tomcat远程调试设置 grandboy 作者: grandboy  链接：http://grandboy.javaeye.com/blog/232209  发表时间: 2008年08月25日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

在tomcat/bin/的catalina.bat文件中加入下面的设置，当然SET CATALINA_OPTS 变量应该在使用它之前。这是在tomcat启动时设置一些虚拟机参数，使服务器允许远程连接功能，address=5888表示远程连接的端口号，可以设置成任意其他不冲突端口。其他的应用服务器比如weblogic也应该可以设置这些参数，有兴趣的可以测试。 
    SET CATALINA_OPTS=-server -Xdebug -Xnoagent 
-Djava.compiler=NONE -Xrunjdwp:transport=dt_socket,
server=y,suspend=n,address=5888



这样就Ok了，重启动tomcat,可以直接独立启动，而不用在eclipes的插件中启动。打开eclipse中的debug设置窗口，选择Remote Java Application ，新建一个debug项，输入服务器IP和刚才设置端口号，点ok就可以进入debug状态了。
不过要注意在Linux下，有一点点差异，是要编辑catalina.sh文件。


而且要改成这样： 
     CATALINA_OPTS="-server -Xdebug -Xnoagent 
-Djava.compiler=NONE -Xrunjdwp:transport=dt_socket,
server=y,suspend=n,address=5888"



也就是把SET去掉，后面加双引号引起来，因为在Linux下，是没有SET这个语法的。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Mon, 25 Aug 2008 09:30:28 +0800 http://grandboy.javaeye.com/blog/232209 http://grandboy.javaeye.com/blog/232209 SSL-用Keytool和OpenSSL生成和签发数字证书 grandboy 作者: grandboy  链接：http://grandboy.javaeye.com/blog/179410  发表时间: 2008年04月03日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

转自: http://zhouzhk.javaeye.com/blog/136943
生成server端证书
1)生成KeyPair生成密钥对
keytool -genkey -alias tomcat_server -validity 365 -keyalg RSA -keysize 1024 -keypass 123456 -storepass 123456 -keystore server_keystore
输入common name时，要和服务器的域名保持一致。
2)生成证书签名请求
keytool -certreq -alias tomcat_server -sigalg MD5withRSA -file tomcat_server.csr -keypass 123456 -storepass 123456 -keystore server_keystore
3)用CA私钥进行签名，也可以到权威机构申请CA签名。
openssl ca -in tomcat_server.csr -out tomcat_server.crt -cert ca.crt -keyfile ca.key -notext -config openssl.cnf
其中-notext表示不要把证书文件的明文内容输出到文件中去，否则在后面用keytool导入到keystore时会出错。
4)导入信任的CA根证书到keystore
keytool -import -v -trustcacerts -alias my_ca_root -file ca.crt -storepass 123456 -keystore server_keystore
5)把CA签名后的server端证书导入keystore
keytool -import -v -alias tomcat_server -file tomcat_server.crt -storepass 123456 -keystore server_keystore
6)查看server端证书
keytool -list -v -keystore server_keystore
可以看到tomcat_server的证书链长度是2

生成client端证书
1)生成客户端CSR
openssl genrsa -des3 -out tomcat_client.key 1024
openssl req -new -key tomcat_client.key -out tomcat_client.csr -config openssl.cnf
2)用CA私钥进行签名，也可以到权威机构申请CA签名
openssl ca -in tomcat_client.csr -out tomcat_client.crt -cert ca.crt -keyfile ca.key -notext -config openssl.cnf
3)生成PKCS12格式证书
openssl pkcs12 -export -inkey tomcat_client.key -in tomcat_client.crt -out tomcat_client.p12
4)使用Keytool列出pkcs12证书的内容：
keytool -rfc -list -keystore tomcat_client.p12 -storetype pkcs12
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Thu, 03 Apr 2008 21:39:07 +0800 http://grandboy.javaeye.com/blog/179410 http://grandboy.javaeye.com/blog/179410 [引用] java文件路径 grandboy 作者: grandboy  链接：http://grandboy.javaeye.com/blog/139703  发表时间: 2007年11月10日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

http://blog.csdn.net/laxsong/archive/2006/06/20/816598.aspx

[引自原文]

FileStream file = this.getClass().getClassLoader().getResourceAsStream(String xmlPath);
这个有点复杂，我了解的也不多，这里就说说现在我所了解的吧，以后再补充！
System.out.println(this.getClass().getClassLoader().getResource("/").getPath());
如此就可以看到相对“/”的根路径。
对   FileStream fileStream = this.getClass().getClassLoader().getResourceAsStream(filePath);
这里的filePath似乎只能用相对路径，至少我不知道用绝对路径怎么表示：
下面取个相对路径的例子：
    String filePath = "/../../Resources/XML/navigation.xml"; //表达规则和LINUX一样。

System.out.println(this.getClass().getClassLoader().getResource(".").getPath());
System.out.println(this.getClass().getClassLoader().getResource("/").getPath());
System.out.println(this.getClass().getClassLoader().getResource("").getPath());
System.out.println(this.getClass().getClassLoader().getResource("..").getPath());
相信，看过这四个路径结果就应该知道在哪放置自己的文件了，用什么样的语句能找到。

[补充]

直接取文件流:  
  InputStream   is   =   this.getClass().getClassLoader().getResourceAsStream("test/data.txt");  
    或   
  InputStream   is   =   is.getClass().getResourceAsStream("test/data.txt");

[String 与 InputStream相互转换]

BufferedReader   bf   =   new   BufferedReader(new   InputStreamReader(in));   
String   s   =   null;   
while   ((s=bf.readLine())   !=   null)     System.out.println(s);

InputStream   in   =   new   ByteArrayInputStream("Hello   Java   World!".getBytes());

 


本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Sat, 10 Nov 2007 22:18:27 +0800 http://grandboy.javaeye.com/blog/139703 http://grandboy.javaeye.com/blog/139703 Jboss4.x下第一个EJB2.x程序 grandboy 作者: grandboy  链接：http://grandboy.javaeye.com/blog/73331  发表时间: 2007年04月23日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

Jboss4.x下第一个EJB2.x程序

 


本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Mon, 23 Apr 2007 11:25:29 +0800 http://grandboy.javaeye.com/blog/73331 http://grandboy.javaeye.com/blog/73331 开发 WebLogic Server 的安全提供程序的目录 grandboy 作者: grandboy  链接：http://grandboy.javaeye.com/blog/72179  发表时间: 2007年04月18日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

http://edocs.bea.com.cn/wls/docs92/dvspisec/dvspisecTOC.html

开发 WebLogic Server 的安全提供程序的目录


本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Wed, 18 Apr 2007 13:14:50 +0800 http://grandboy.javaeye.com/blog/72179 http://grandboy.javaeye.com/blog/72179 Tomcat web程序安全机制 (转载) grandboy 作者: grandboy  链接：http://grandboy.javaeye.com/blog/70252  发表时间: 2007年04月12日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

在tomat web服务器中，可以有两种主要的方式来对用户，角色，以及领域进行定义。一种使用简单的xml用户定义的内存realm的验证方式，另外一种是建立数据库连接的jdbc realm验证方式。这两种安全机制定制用户信息来源。
 
一，内存（memoryrealm)验证方式：
web程序的拥护，角色，分组在tomcat的/conf/tomat-users.xml文件中定义。这个xml文件列出web服务器允许的用户名称，密码以及对应的分组等。
例如：
 

<?xml version='1.0' encoding='utf-8'?>
<tomcat-users>
  <role rolename="tomcat"/>
  <role rolename="role1"/>
  <user username="both" password="tomcat" roles="tomcat,role1"/>
  <user username="tomcat" password="tomcat" roles="tomcat"/>
  <user username="role1" password="tomcat" roles="role1"/>
</tomcat-users>


 

这里就定义了两个角色，三个用户以及对应的密码。

要使以上的配置文件作用于定义域，就要在server.xml把这个文件定义成为一个数据资源。其目的就是高速web服务器能够在这个文件中找到相关的用户信息。这个定义在tomcat是默认定义的。定义在<GlobalNamingResources>元素中：

<!-- Global JNDI resources -->
  <GlobalNamingResources>

    <!-- Test entry for demonstration purposes -->
    <Environment name="simpleValue" type="java.lang.Integer" value="30"/>

    <!-- Editable user database that can also be used by
         UserDatabaseRealm to authenticate users -->
    <Resource name="UserDatabase" auth="Container"
              type="org.apache.catalina.UserDatabase"
       description="User database that can be updated and saved"
           factory="org.apache.catalina.users.MemoryUserDatabaseFactory"
          pathname="conf/tomcat-users.xml" />

  </GlobalNamingResources>

可以看到pathname="conf/tomcat-users.xml"调用上面的那个配置好的文件。虽然这种方式比较简单，但存在着一定问题，比如手动输入，一旦数据多了就很麻烦等。而且保密效果不是很好，xml各式的文件谁都可以打开直接看到。

二，JDBC　realm

首先也是在server.xml文件中<Realm>元素中配置一个使用mysql数据库的realm 

在TOMCAT的server.xml中配置JDBC域验证
      <Realm className="org.apache.catalina.realm.JDBCRealm"
             driverName="com.mysql.jdbc.Driver"
          connectionURL="jdbc:mysql://localhost:3306/mydb"
         connectionName="root" connectionPassword="novell"
              userTable="users" userNameCol="user_name" userCredCol="user_pass"
          userRoleTable="user_roles" roleNameCol="role_name" />
<!--当然别望了在Mysql中建立相应的数据表和字段 -->

当中的系数名字不解释了．．．

对应的表格

create table users(user_name varchar(15) null primary key,

                   user_pass varhcar(20) not null);

create tabel user_roles( user_name varchar(15) not null,

                        role_naem varchar(20) not null,

primary key(user_name,role_name));

现在简单介绍一下基本的验证方式

首先我们应该在web.xml文件中对需要保护的资源定义一个＜security-constraint>比如你要限制ｕｒｌ为当前ｗｅｂ目中的所有文件/*

 

 

<security-constraint>
     <web-resource-collection>
         <web-resource-name>BasicLogin</web-resource-name>
                   
         <url-pattern>/*</url-pattern>
        

         <http-method>GET</http-method>
         <http-method>POST</http-method>

     </web-resource-collection>
    <auth-constraint>
        <!-- NOTE: This role is not present in the default users file -->
        <role-name>tomcat</role-name>
    </auth-constraint>
    <user-data-constraint>
    <description> no description</description>
    <transport-guarantee>NONE</transport-guarantee>
    </user-data-constraint>
</security-constraint>
    
<login-config>
      <auth-method>BASIC</auth-method>
      <realm-name>default</realm-name>
</login-config>
   

 其中<web-resource-collection>标记中url-pattern制定保护了url,http-method定义了限定web的请求方法，<auth-constrain>标记了role-name制定了合法用户的角色。<user-data-constraint>中定义了不需要通信的保证。当然了还需要申明使用了基本的验证方式和使用默认的realm.声明部分在上面红色部分给出，即<login-config>.这样的话当浏览器请求


本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Thu, 12 Apr 2007 11:57:40 +0800 http://grandboy.javaeye.com/blog/70252 http://grandboy.javaeye.com/blog/70252 JBoss Hibernate 配置与应用(转载) grandboy 作者: grandboy  链接：http://grandboy.javaeye.com/blog/69995  发表时间: 2007年04月11日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

原文:   http://www.javaeye.com/topic/68868

JBoss Hibernate 配置与应用
作者:萧红叶 2007年4月4日

本文以一个jboss_hibernate为例介绍怎么把hibernate部署成一个jboss的service,然后用hibernate 去操作数据库。

配置开发环境
在进行开发之前，需要首先获得JBoss、MySQL、相应数据库的JDBC驱动类库。JBoss可以从www.jboss.org中下载，MySQL 从www.mysql.org 下载
解压jboss到一个文件夹,我们把mysql的jdbc驱动复制到jboss-4.2.0.CR1\server\default\lib下
然后我们配置一个mysql的数据源,从jboss-4.2.0.CR1\docs\examples\jca目录下复制一份mysql-ds.xml到jboss-4.2.0.CR1\server\default\deploy目录下,接着修改它的内容，我修改的如下：

代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2.   
  3. <datasources>  
  4.   <local-tx-datasource>  
  5.     <jndi-name>MySqlDS</jndi-name>   //jndi名字   
  6.     <use-java-context>false</use-java-context>  
  7.     <connection-url>jdbc:mysql://10.16.175.137:3306/test</connection-url>  //URL地址   
  8.     <driver-class>com.mysql.jdbc.Driver</driver-class>  //驱动   
  9.     <user-name>root</user-name>    //用户名   
  10.     <password>123456</password>  //密码   
  11.     <exception-sorter-class-name>  
  12.        org.jboss.resource.adapter.jdbc.vendor.MySQLExceptionSorter   
  13.     </exception-sorter-class-name>  
  14.     <metadata>  
  15.        <type-mapping>mySQL</type-mapping>  
  16.     </metadata>  
  17.   </local-tx-datasource>  
  18. </datasources>  

 

这样我们的mysql数据源就配置好了，接下来我们来做一个jboss_hibernate.har文件

进入到jboss-4.2.0.CR1\jboss-4.2.0.CR1\server\default\deploy 新建一个jboss_hibernate.har文件夹,该目录下放的将是你的POJO 文件和对应的.hbm.xml文件以及jboss-service.xml文件。

在jboss_hibernate.har目录新建一个文件夹META-INF,在该目录下我们来写一个jboss-service.xml文件，代码如下:

 

代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <server>    
  3.     <mbean code="org.jboss.hibernate.jmx.Hibernate"   name="jboss.har:service=Hibernate">      
  4.          <attribute   name="DatasourceName">MySqlDS</attribute>   //数据源名字   
  5.          <attribute   name="Dialect">org.hibernate.dialect.MySQLDialect</attribute>   //对应hibernate的Dialect   
  6.          <attribute   name="SessionFactoryName">java:/hibernate/SessionFactory</attribute>   //sessionFactory的jndi名字   
  7.          <attribute   name="ShowSqlEnabled">true</attribute>   //在控制台输出sql语句   
  8.          <attribute name="ScanForMappingsEnabled">true</attribute>  //自动搜索mapping文件   
  9.     </mbean>      
  10. </server>  

 

如果有多个数据库，你可以建多个数据源，然后在jboss-service.xml文件里写上多个mbean，我是这样做的，呵呵，不知道有没有更好的办法

接着我们来写我们的hibernate 文件

在jboss-4.2.0.CR1\jboss-4.2.0.CR1\server\default\deploy\jboss_hibernae.har\目录下新建文件夹org.xredleaf,我们写一个对应数据库的User.java文件：

 

代码
  1. package org.xredleaf;   
  2.   
  3. import java.io.Serializable;   
  4.   
  5. public class User implements Serializable   
  6. {   
  7.     private String id;   
  8.     private String name;   
  9.     private int    age;   
  10.     public User(){   
  11.   
  12.     }   
  13.     public void setId(String id){   
  14.         this.id=id;   
  15.     }   
  16.     public String getId(){   
  17.         return id;   
  18.     }   
  19.     public void setName(String name){   
  20.         this.name=name;   
  21.     }   
  22.     public String getName(){   
  23.         return name;   
  24.     }   
  25.     public void setAge(int age){   
  26.         this.age=age;   
  27.     }   
  28.     public int getAge(){   
  29.         return age;   
  30.     }   
  31. }  

然后将它编译成User.class文件
接着我们写XML映射文件User.hbm.xml 文件：

 

 

代码
  1. <?xml version='1.0' encoding='utf-8'?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  3. <hibernate-mapping>    
  4.     <class name="org.xredleaf.User" table="user" >  
  5.       <id name="id" column="id" type="java.lang.String" >  
  6.           <generator class="uuid.hex"/>  
  7.       </id>  
  8.       <property name="name" column="name" type="java.lang.String" />    
  9.       <property name="age" column="age" type="java.lang.Integer" />  
  10.    </class>  
  11. </hibernate-mapping>  

 

好了，这样我们的环境就搭好了!呵呵，喝口茶！

 二、写一个登录页面

进入到jboss-4.2.0.CR1\server\default\deploy\jboss-web.deployer\ROOT.war目录下，新建一个login.jsp,文件如下：

 

代码
  1. <%@page contentType="text/html;charset=GB2312" %>   
  2. <%   
  3. javax.naming.InitialContext ctx = new javax.naming.InitialContext();   
  4. org.hibernate.SessionFactory factory = (org.hibernate.SessionFactory)ctx.lookup("java:/hibernate/SessionFactory"); //之前配置的sessionFactory的名字   
  5. org.hibernate.Session se = factory.openSession();   
  6. org.hibernate.Query query=se.createQuery("from org.xredleaf.User user  where user.id='111' ");    
  7. java.util.List results=query.list();   
  8. java.util.ListIterator iterator=results.listIterator();   
  9. if(iterator.hasNext()){    
  10.     org.xredleaf.User user=(org.xredleaf.User)iterator.next();    
  11.     session.setAttribute("user",user);   
  12.     out.print("Login success");      
  13. }   
  14.   
  15. %>  

好了大功告成，我们来启动一下jboss,运行run.bat
打开http://localhost:8080/login.jsp看一下，是不是显示Login success 啊


本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Wed, 11 Apr 2007 10:54:09 +0800 http://grandboy.javaeye.com/blog/69995 http://grandboy.javaeye.com/blog/69995 JBoss Hibernate 配置与应用(转载) grandboy 作者: grandboy  链接：http://grandboy.javaeye.com/blog/69994  发表时间: 2007年04月11日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

原文:   http://www.javaeye.com/topic/68868

JBoss Hibernate 配置与应用
作者:萧红叶 2007年4月4日

本文以一个jboss_hibernate为例介绍怎么把hibernate部署成一个jboss的service,然后用hibernate 去操作数据库。

配置开发环境
在进行开发之前，需要首先获得JBoss、MySQL、相应数据库的JDBC驱动类库。JBoss可以从www.jboss.org中下载，MySQL 从www.mysql.org 下载
解压jboss到一个文件夹,我们把mysql的jdbc驱动复制到jboss-4.2.0.CR1\server\default\lib下
然后我们配置一个mysql的数据源,从jboss-4.2.0.CR1\docs\examples\jca目录下复制一份mysql-ds.xml到jboss-4.2.0.CR1\server\default\deploy目录下,接着修改它的内容，我修改的如下：

代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2.   
  3. <datasources>  
  4.   <local-tx-datasource>  
  5.     <jndi-name>MySqlDS</jndi-name>   //jndi名字   
  6.     <use-java-context>false</use-java-context>  
  7.     <connection-url>jdbc:mysql://10.16.175.137:3306/test</connection-url>  //URL地址   
  8.     <driver-class>com.mysql.jdbc.Driver</driver-class>  //驱动   
  9.     <user-name>root</user-name>    //用户名   
  10.     <password>123456</password>  //密码   
  11.     <exception-sorter-class-name>  
  12.        org.jboss.resource.adapter.jdbc.vendor.MySQLExceptionSorter   
  13.     </exception-sorter-class-name>  
  14.     <metadata>  
  15.        <type-mapping>mySQL</type-mapping>  
  16.     </metadata>  
  17.   </local-tx-datasource>  
  18. </datasources>  

 

这样我们的mysql数据源就配置好了，接下来我们来做一个jboss_hibernate.har文件

进入到jboss-4.2.0.CR1\jboss-4.2.0.CR1\server\default\deploy 新建一个jboss_hibernate.har文件夹,该目录下放的将是你的POJO 文件和对应的.hbm.xml文件以及jboss-service.xml文件。

在jboss_hibernate.har目录新建一个文件夹META-INF,在该目录下我们来写一个jboss-service.xml文件，代码如下:

 

代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <server>    
  3.     <mbean code="org.jboss.hibernate.jmx.Hibernate"   name="jboss.har:service=Hibernate">      
  4.          <attribute   name="DatasourceName">MySqlDS</attribute>   //数据源名字   
  5.          <attribute   name="Dialect">org.hibernate.dialect.MySQLDialect</attribute>   //对应hibernate的Dialect   
  6.          <attribute   name="SessionFactoryName">java:/hibernate/SessionFactory</attribute>   //sessionFactory的jndi名字   
  7.          <attribute   name="ShowSqlEnabled">true</attribute>   //在控制台输出sql语句   
  8.          <attribute name="ScanForMappingsEnabled">true</attribute>  //自动搜索mapping文件   
  9.     </mbean>      
  10. </server>  

 

如果有多个数据库，你可以建多个数据源，然后在jboss-service.xml文件里写上多个mbean，我是这样做的，呵呵，不知道有没有更好的办法

接着我们来写我们的hibernate 文件

在jboss-4.2.0.CR1\jboss-4.2.0.CR1\server\default\deploy\jboss_hibernae.har\目录下新建文件夹org.xredleaf,我们写一个对应数据库的User.java文件：

 

代码
  1. package org.xredleaf;   
  2.   
  3. import java.io.Serializable;   
  4.   
  5. public class User implements Serializable   
  6. {   
  7.     private String id;   
  8.     private String name;   
  9.     private int    age;   
  10.     public User(){   
  11.   
  12.     }   
  13.     public void setId(String id){   
  14.         this.id=id;   
  15.     }   
  16.     public String getId(){   
  17.         return id;   
  18.     }   
  19.     public void setName(String name){   
  20.         this.name=name;   
  21.     }   
  22.     public String getName(){   
  23.         return name;   
  24.     }   
  25.     public void setAge(int age){   
  26.         this.age=age;   
  27.     }   
  28.     public int getAge(){   
  29.         return age;   
  30.     }   
  31. }  

然后将它编译成User.class文件
接着我们写XML映射文件User.hbm.xml 文件：

 

 

代码
  1. <?xml version='1.0' encoding='utf-8'?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  3. <hibernate-mapping>    
  4.     <class name="org.xredleaf.User" table="user" >  
  5.       <id name="id" column="id" type="java.lang.String" >  
  6.           <generator class="uuid.hex"/>  
  7.       </id>  
  8.       <property name="name" column="name" type="java.lang.String" />    
  9.       <property name="age" column="age" type="java.lang.Integer" />  
  10.    </class>  
  11. </hibernate-mapping>  

 

好了，这样我们的环境就搭好了!呵呵，喝口茶！

 二、写一个登录页面

进入到jboss-4.2.0.CR1\server\default\deploy\jboss-web.deployer\ROOT.war目录下，新建一个login.jsp,文件如下：

 

代码
  1. <%@page contentType="text/html;charset=GB2312" %>   
  2. <%   
  3. javax.naming.InitialContext ctx = new javax.naming.InitialContext();   
  4. org.hibernate.SessionFactory factory = (org.hibernate.SessionFactory)ctx.lookup("java:/hibernate/SessionFactory"); //之前配置的sessionFactory的名字   
  5. org.hibernate.Session se = factory.openSession();   
  6. org.hibernate.Query query=se.createQuery("from org.xredleaf.User user  where user.id='111' ");    
  7. java.util.List results=query.list();   
  8. java.util.ListIterator iterator=results.listIterator();   
  9. if(iterator.hasNext()){    
  10.     org.xredleaf.User user=(org.xredleaf.User)iterator.next();    
  11.     session.setAttribute("user",user);   
  12.     out.print("Login success");      
  13. }   
  14.   
  15. %>  

好了大功告成，我们来启动一下jboss,运行run.bat
打开http://localhost:8080/login.jsp看一下，是不是显示Login success 啊


本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Wed, 11 Apr 2007 10:54:08 +0800 http://grandboy.javaeye.com/blog/69994 http://grandboy.javaeye.com/blog/69994 [J2SE]安全：JAAS LoginModule(转载) grandboy 作者: grandboy  链接：http://grandboy.javaeye.com/blog/69052  发表时间: 2007年04月08日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

Java认证和授权API（JAAS）为应用程序处理用户的认证和授权问题提供了标准方式。很多人在Unix/Linux系统中比较JAAS和PAM模块。
本文不对JAAS进行详细的讨论，但给大家简单的介绍一下。在JAAS架构中，当用户登录系统时，系统给用户一个Subject，Subject中包含有一个或多个Principal。每个Principal给用户提供身份验证，例如用户ID，也可以验证组和角色。Subject也包含公有的和私有的许可证（credential），例如X.509证书、私钥等。JAAS通过公开的Permission进行授权，Permission是在外部Policy 文件里进行维护的。本文也不讨论授权。就像下面所讨论的，实际的登录过程是由LoginModule来处理的。如果你想了解更多的信息，这里有相关 JAAS的详细介绍：http://www.javaworld.com/javaworld/jw-09-2002/jw-0913- jaas.html。
实现Hibernate JAAS LoginModule的第一步是定义一个或多个Principal。下面是一个典型的实例，但是记住你能把你想要的任何事物――用户ID，E-mail 地址，电话号码，公钥――填进Principal中是很重要的，这些事物都能在持久化的User对象中发现。

final public class HibernatePrincipal implements Principal {
private String name;
public HibernatePrincipal() {
name = "";
}
public HibernatePrincipal(String name) {
this.name = name;
}
public String getName() {
return name;
}
public int hashCode() {
return name.hashCode();
}
public boolean equals(Object o) {
if (!(o instanceof HibernatePrincipal)) {
return false;
}
return name.equals(((HibernatePrincipal) o).name);
}
public String toString() {
return name;
}
}

N.B.，你必须小心防止恶意用户通过继承你的类来获取他们所需要的许可证（credential）。解决上述问题的方法一是你可以声明你的Principal是final，二是你总是检查许可证（credential）是否是扩展类型。

public void foo(Principal p) {
// DO NOT USE THIS
if (p instanceof HibernatePrincipal) {
...
}
// use this instead
if (p.getClass().equals(HibernatePrincipal.class)) {
...
}
// or even this
if (p.getClass().getName().equals(HibernatePrincipal.getClass().getName()) {
...
}
}
}

本文也不详细讨论许可证文件（credential），但User属性映射到Subject许可证是很容易的。例如，用户名可以作为公开许可证的一个合理候选。
既然有了Principal，我们可以为JAAS LoginModule包装一些标准的Hibernate代码。
/**
* HibernateLoginModule is a LoginModule that authenticates
* a given username/password credential against a Hibernate
* session.
*
* @see javax.security.auth.spi.LoginModule
*/
public class HibernateLoginModule implements LoginModule {

// initial state
CallbackHandler handler;
Subject subject;
Map sharedState;
Map options;
Digest digest;

// temporary state
Vector principals;

// authentication status
boolean success;

// configurable options
boolean debug;

/** Hibernate session factory */
SessionFactory sf = null;

/** Hibernate query */
private static final String query =
"from u in class " + User.class + " where u.name=?";

public HibernateLoginModule() {
credentials = new Vector();
principals = new Vector();
success = false;
debug = false;
}

/**
* Initialize our state.
*/
public void initialize (Subject subject, CallbackHandler handler,
Map sharedState, Map options) {

this.handler = handler;
this.subject = subject;
this.sharedState = sharedState;
this.options = options;

if (options.containsKey("debug")) {
debug = "true".equalsIgnoreCase((String) options.get("debug"));
}
if (options.containsKey("digest")) {
digest = new Digest((String) options.get("digest"));
} else {
digest = new Digest();
}

// elided: standard code to get Hibernate =SessionFactory=.
}

/**
* First phase of login process.
*/
public boolean login() throws LoginException {
if (handler == null) {
throw new LoginException("Error: no CallbackHandler available");
}

try {
Callback[] callbacks = new Callback[] {
new NameCallback("User: "),
new PasswordCallback("Password: ", false)
};

handler.handle(callbacks);

String username = ((NameCallback) callbacks[0]).getName();
char[] password = ((PasswordCallback) callbacks[1]).getPassword();

((PasswordCallback) callbacks[1]).clearPassword();

success = validate(username, password);

callbacks[0] = null;
callbacks[1] = null;

if (!success) {
throw new LoginException("Authentication failed: Password does not match");
}
return true;
} catch (LoginException e) {
throw e;
} catch (Exception e) {
success = false;
throw new LoginException(e.getMessage());
}
}

/**
* Second phase of login - by now we know user is authenticated
* and we just need to update the subject.
*/
public boolean commit() throws LoginException {
if (success) {
if (subject.isReadOnly()) {
throw new LoginException("Subject is read-only");
}

try {
Iterator i = principals.iterator();
subject.getPrincipals().addAll(principals);
principals.clear();
return true;
} catch (Exception e) {
throw new LoginException(e.getMessage());
}
} else {
principals.clear();
}
return true;
}

/**
* Second phase - somebody else rejected user so we need to
* clear our state.
*/
public boolean abort() throws LoginException {
success = false;
logout();
return true;
}

/**
* User is logging out - clear our information from the subject.
*/
public boolean logout() throws LoginException {
principals.clear();

// remove the principals the login module added
Iterator i = subject.getPrincipals(HibernatePrincipal.class).iterator();
while (i.hasNext()) {
HibernatePrincipal p = (HibernatePrincipal) i.next();
subject.getPrincipals().remove(p);
}

return true;
}

/**
* Validate the user name and password. This is the Hibernate-specific
* code.
*/
private boolean validate(String username, char[] password) throws Exception {
boolean valid = false;
List users = null;

Session s = null;
try {
s = sf.openSession();
users = (List) s.find(query, username, Hibernate.STRING);
} catch (Exception e) {
} finally {
if (s != null) {
try { s.close(); } catch (HibernateException e) { }
}
}

// are there no matching records?...
if (users == null || users.size() == 0) {
return false;
}

// compare passwords...
User user = (User) users.get(0);
String hash = user.getPassword();
if (hash != null && password != null && password.length > 0) {
valid = hash.equals(digest.digest(new String(password)));
}

if (valid) {
this.principals.add(new HibernatePrincipal(user.getId(),
user.getName()));
}
return valid;
}
}
例子中，我们利用了Tomcat类库中密码digest功能（password digest function）（你要为HexUtils类载入catalina.jar文件）。
import org.apache.catalina.util.HexUtils;

/**
* Quick and dirty password digest function. The HexUtils class
* comes from the Tomcat catalina.jar.
*/
public class Digest {

static MessageDigest md = null;

public Digest() {
this("MD5");
}

public Digest(String digest) {
try {
md = MessageDigest.getInstance(digest);
} catch (NoSuchAlgorithmException e) {
try {
md = MessageDigest.getInstance("MD5");
} catch (NoSuchAlgorithmException e) { }
}
}

/**
* Digest function from Tomcat.
*/
public String digest(String credentials) {
if (md == null) {
return credentials;
}

synchronized (this) {
try {
md.reset();
md.update(credentials.getBytes());
return (HexUtils.convert(md.digest()));
} catch (Exception e) {
return credentials;
}
}
}
}
最后一步是为我们的应用程序配置我们的Hibernate登录模块。我们先创建JAAS配置文件，然后通过java.security.auth.login.config参数传给应用程序。在这个例子里我们定义JAAS属性“Example”。
Example {
HibernateLoginModule required debug="true";
};
现在通过我们Hibernate模块可以认证任何基于JAAS的应用程序了。下面是简单的测试程序：
/**
* simple CallbackHandler suitable for testing purposes
*/
public static class Handler implements CallbackHandler {

private Test t;
private String username;
private char[] credentials;

public Handler(Test t, String username, char[] credentials) {
super();
this.t = t;
this.username = username;
this.credentials = credentials;
}

public void handle(Callback callbacks[])
throws IOException, UnsupportedCallbackException {

for (int i = 0; i < callbacks.length; i++) {
if (callbacks[i] instanceof NameCallback) {
((NameCallback) callbacks[i]).setName(username);
}
else if (callbacks[i] instanceof PasswordCallback) {
((PasswordCallback) callbacks[i]).setPassword(credentials);
} else {
throw new UnsupportedCallbackException(callbacks[i]);
}
}
}
}
/**
* Simple JAAS-aware application.
*/
public class Test {

LoginContext l = null;

/**
* attempt to log in as the user, returning the =Subject=
* if successful.
*/
public Subject login(String username, char[] credentials) {
try {
CallbackHandler cb = new Handler(this, username, credentials);
l = new LoginContext("Example", cb);
} catch (LoginException e) {
return null;
}

Subject subject = null;
try {
l.login();
subject = l.getSubject();
if (subject == null) {
return null;
}
} catch (AccountExpiredException e) {
} catch (CredentialExpiredException e) {
} catch (FailedLoginException e) {
} catch (LoginException e) {
}
return subject;
}

/**
* log out of application
*/
public void logout() {
if (l != null) {
try {
l.logout();
} catch (LoginException e) {
}
}
}

public static void main(String[] args) throws Exception {
Test t = new Test();
String username = "test";
String password = "test";

Subject subj = t.login(username, password.toCharArray());
if (subj != null) {
Iterator i = subj.getPrincipals(HibernatePrincipal.class).iterator();
while (i.hasNext()) {
HibernatePrincipal p = (HibernatePrincipal) i.next();
System.out.println("logged in as: " + p.getName());
}
t.logout();
}
else {
System.out.println("unable to log in as user");
}
}
}
正如上文间接提到的，JAAS的真正威力不在于它处理用户登录的灵活性，而是通过Permissions提供的公开的安全模块和处理许可证的机制。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Sun, 08 Apr 2007 21:19:49 +0800 http://grandboy.javaeye.com/blog/69052 http://grandboy.javaeye.com/blog/69052 扩展JAAS (转载) grandboy 作者: grandboy  链接：http://grandboy.javaeye.com/blog/69051  发表时间: 2007年04月08日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

用户认证和访问控制是大多数java应用的重要安全尺度，特别是J2EE应用。Java认证和权限服务(即JAAS)，J2SE1.4和1.5的核心API，描绘表达了新的安全标准。其提供了一个可插拔的(pluggable)和富有弹性的(flexible)框架(framework)允许开发者混合不同的安全机制和丰富的已经存在各种安全方面的资源。
　　伴随着即将来临的J2SE1.5版本的发布，它包含了许多诸如加密技术、XML安全性、公钥机制（PKI）、Kerberos （是一个网络附加系统/协议，可以允许用户通过一个安全伺服器的服务来验证 自己。象远端登陆，远端拷贝，系统间的相互档拷贝和另外高风险任务的服务将被变 得相当安全和可控制。）和结盟认证（the federating identity）的增强！，JAAS将会在J2EE实现中扮演一个更加重要的角色。
　　
　　认证
　　认证就是校验一个用户拥有使用已经被企业用户注册机构证明了的身份鉴定的权限的处理过程。JAAS的认证机制建立于一整套可插拔的模块（参看图1）基础上。JAAS允许不同的验证模型在运行时可被插拔。客户应用总是通过登陆上下文对象和JAAS交互。
　　认证处理过程典型的要经过下面的步骤：
　　1、 生成一个LoginContext对象。这个LoginContext寻找配置文件以决定使用那个LoginModule。同样，可选择的，有可能传递一个CallbackHandler给LoginContext.
　　2、 通过调用LoginContext的login方法执行认证，它会加载预定义的LoginModule去检验是否用户可以被认证。
　　3、 如果用户被认证，那么用规则和标识和其所属项进行关联。
　　4、 或者在登陆失败的情况下跑出一个LoginException
　　5、 使用LoginContext的logout方法进行注销登陆
　　
　　在JAAS中，登陆是一个两阶段(two-phase)的处理过程。第一阶段是“登陆（login）”阶段（就像上面2所描述的）。这个阶段唯一的任务是认证。只要处理过程成功通过这个阶段，认证处理过程就进入了“提交(commit)”阶段（如上步骤3），这一阶段LoginModule的commit方法被调用去关联所属子项相关的规则和标识。
　　在JAAS中一个所属子项表示一个认证实体，比如一个人或者一台设备。它包含了一整套法则和安全相关的属性诸如密码和加密密钥。在JAAS体系结构中，所属子项和其所附属的相关权限，扮演了重要的角色在认证过程当中。所有的认证模块当中，LoginModule是事实上的认证机制的借口。虽然LoginModule决没有得到直接调用客户应用的机会，但是他经由一个可插拔的模块提供了一个认证的具体类型，其实现了认证的算法并且决定实际的认证过程是怎样被执行的。
　　SUN提供了几个默认的LoginModule 实现，在sun.com.security.auth.module包里有诸如JndiLoginModule,Krb2LoginModule,UnixLoginModule和NTLoginModule等几个LoginModule实现。因为JAAS登录结构体系是可扩展的，所以你只要在配置文件中指定使用哪个LoginModule模块就可以几乎全部插入任何LoginModule模块。
　　如下即为一个配置文件的例子：
　　MySample {
　　com.sample.module.MyLoginModule required debug=true;
　　};
　　
　　这里MySample是登录上下文环境(login context)的名字，当你生成一个新的LoginContext开始认证过程时它会被传入LoginContex的构造函数中。依据配置块提示，那个文本块提醒JAAS有关LoginModule在登录过程中应该被用来执行认证。另外，对于LoginModule，任何关于他的选项也可以在这里被指定。在执行登录这一步骤的过程中，CallbackHandler类被LoginModule类用来跟用户通信已便于取得认证信息。CallbackHandler类处理三种类型的回调（Callback）：NameCallback,提示用户输入一个用户名；PasswordCallcack,提示输入密码；TextOutputCallback,报告错误、警告或则发送给用户一些其他信息。
　　
　　授权是决定是否认证的用户可以执行一些动作的工作，例如访问一处资源。因为JAAS建立于已经存在的Java安全模型的基础上，故这个过程时基于策略的。策略配置文件实质上包含了一系列的入口，诸如“Keystore”和/或“grant”.
　　grant入口包含了所有的权限，他是通过认证的代码或则法则被授予可以进行安全敏感的操作，例如，访问一个具体的Web页面或则本地的文件。JAAS支持基于法则的策略入口，赋权入口基本格式如下：
　　grant Codebase “codebase_URL” Signedby “signer_name,”
　　Principal principal_class_name “principal_name”,
　　Principal principal_class_name “principal_name”,
　　… {
　　permission permission_class_name “target_name”, “action”,
　　permission permission_class_name “target_name”, “action”,
　　…
　　}
　　
　　上面格式中“动作（action）”可能是必需的或则可能被忽略依赖于权限类型。在JAAS体系结构中，策略对象表达了一个Java应用环境的系统安全策略和在任何时间事实上只有一个策略对象。依据Java2 SDK文档，默认的策略实现是sun.security.provider.PolicyFile,其中策略被指定在一个或多个策略配置文件里。
　　只要用户被认证，授权经由Subject.doAs方法发生，或者从Subject类的静态方法doAsPrivileged，doAS方法用当前的AccessControlContext动态和子项并且同时调用run方法去执行动作，他导致安全验证。权限验证过程通过下面的步骤在图2:
　　就像LoginModule,策略也是可插拔的模型。你可以挂上其它的策略实现通过在java.security的属性文件中改变“policy.provider=sun.security.provider.PolicyFile”
　　到一个你项使用的策略类。
　　
　　Extend JAAS
　　JAAS建立于已经存在的Java安全模型的顶端，其基于“CodeSource”和平面文本格式策略文件实现。这可能对企业应用是不够用的，你可能想使用可定制的安全仓库。对于JAAS的其它实现,诸如LDAP(轻型目录访问协议)，数据库或者其他文件系统，它可以通过编写你自己的可定制模块被完成，感谢JAAS的可插拔的特性。然而，这需要对模块和JAAS中的处理过程有完善的理解，同时你必须做许多编码去覆写相关的类，并且处理好配置和策略两种文件。
　　理想情况下，我们愿意能够扩展JAAS以一个更加容易的方式以便于无论何时一个可定制的安全知识库或者不同的访问控制机制改变或者必须去增加时，你能够只开发和插入这些不同的小模块（即，适配器）去适应这些新的变化和需求，并且在最好的情况下，不必去理解和熟悉JAAS处理过程的细节，同样，我们也愿意能够去做这些变化仅仅通过改变一个配置文件。另一个目标是我们的JAAS扩展组件能够被使用在不同的J2EE应用中—独立的或者Web上的。图3描述了JAAS扩展组件的设计意图。我们的JAAS扩展组在实现可定制的LoginModule和策略模块时充分件利用了JAAS插拔式的体系结构。这些模块中，我们委派数据请求到适配器。这些适配器的每个对于诸如数据取回的简单任务是隔离的，所以你可以快速地使用不同的安全知识或者算法开发不同的适配器而不是尝试去实现不同的LoginModule或者策略模块，它们更加复杂并且需要更多的努力。
　　你可以从www.sys-con.com/java/sourcec.cfm.下在完整的源玛。
　　
　　实现的AuthLoginModule类
　　AuthLoginModule类是我们定制的LoginModule实现，LoginModule类是在JAAS中是一个可插拔组件并且服务于两个目的：
　　1、鉴定认证用户
　　2、如果认证成公，则用相关的负责人信息或者证书更新主题。
　　
　　LoginModule有5个方法去实现功能，让我们关注一下login()方法。这个方法被调用以认证主题并且主要作两件事情：
　　1、包含用户名和密码，典型地，LoginModule要调用CallbackHandler类的handle方法去得到用户名和密码
　　2、通过和数据源中的比较校验密码。LoginModule从Callbacks取回用户名和密码。(其默认期望用户接口的某种排序)，这一点对于一个简单的演示程序或者就在命令行，可是他对于一个J2EE应用来说不太实用，例如，对于大多数的Web应用，用户名和密码将比较典型的从一个form中读出。在这种情况下，使用JAAS认证会比较困难。考虑我们不直接使用LoginModule,解决方案是实现一个可定制的CallbackHandler类，他会接收用户名和密码然后递交它们给LoginModule，所以他没有必要提示用户输入信息
　　
　　以下示例説明用户信息如何从JSP或者Servlet中传递：
　　String userName = request.getParameter (“user”);
　　String password = request.getParameter(“password”);
　　LoginContext context = new LoginContext (“MySample”,
　　new AuthCallbackHandler (userName, password));
　　
　　一旦拥有了用户名和密码在手，AuthLoginModule类，我们的LoginModule类的定制实现，会经由LoginSourceAdapterFactory实例化LoginSourceAdapter并同时委派实际的认证过程到资源适配器。适配器只不过是一个简单的类，其从一个具体的数据适配器（比如数据库或者LDAP,或者一些别的系统）领取用户信息。在“提交”阶段，AuthLoginModule类从LoginSourceAdapter类取回相关的信息并且把他们和主题相关联。
　　
　　LoginSourceAdapter类
　　LoginSourceAdapter类是一个认证目的的资源适配器的接口，它有4个需要实现的方法：
　　1、void initialize(Hashtable parameters):initialized方法被调用来以相关的参数初始化适配器。此方法在对象生成后立即被调用并且优先于任何对其他方法的调用。
　　2、boolean authenticate(String username,char[] password):此认证方法被调用来认证用户。
　　3. String[] getGroupNames (String userName):getGroupNames方法被调用来在认证成功后得到相关的主要信息。
　　4. void terminate ():这个方法在LoginModule类的logout方法被执行后调用，它给适配器做一些清理工作的机会。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Sun, 08 Apr 2007 21:18:27 +0800 http://grandboy.javaeye.com/blog/69051 http://grandboy.javaeye.com/blog/69051 编写自己的登录与访问控制模块(转载) grandboy 作者: grandboy  链接：http://grandboy.javaeye.com/blog/69049  发表时间: 2007年04月08日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

 原地址: http://www.smth.org/pc/pccon.php?id=3559&nid=74518&s=all

小按：
第一次写心得笔记，手都有点抖，班门弄斧啊，呵呵～～～欢迎各位大侠扔砖！
本文是一篇学习笔记，概要介绍了Java登录与授权机制及其应用。
在一些用到的API关键字上做了链接，可以在线查相应的文档。
=======================================================================================

     安全性是Java鼓吹得最多的特性之一，的确，Java的安全特性涵盖了从应用级别到语言级别乃至JVM本身。以前大家都知道有个Sandbox，但仅有Sandbox尚不能满足，或者说不能很方便地做到我们所需要的全部安全需求，譬如现在一个系统首先起码需要一个登录功能，更进一步的话，还需要对用户访问资源的行为进行约束，下面我想大致讲一下Java是怎样做这些事情的，基本上是一个总结或者说是“读后感”的性质，同时给出一个简单的实现例子，这个例子其实还是模仿人家的，呵呵……

1．Java的访问控制机制

     谈到访问控制，或者说“授权”，这里有两层含义，一是从资源的角度，这个socket端口是否被允许操作？这个文件是可读的？可写的？还是可执行的？还是以上都行？这就是我们在UNIX下用“ls -l”命令列出当前目录下文件时，那些“-rwx-”之类的含义；二是从访问者的角度，我想通过80端口看Web上新浪欧洲杯的新闻，在这个系统中有没有这个资格？我想播放D盘上一个名为“friends.rm”的视频文件，我得到了访问这个文件的权限了吗？我有运行播放器的权限吗？
     Java在访问控制策略上同时考虑了这两方面内容，你说“不对呀，我用FileOutputStream写文件，用Socket类连接远程主机都用得好好的，没什么限制呀”，这我们得先谈谈什么叫做“安全管理器”（SecurityManger）。安全管理器从JDK 1.0就开始有了，多古老啊！Java从设计的那一天开始就考虑了安全因素，安全管理器是Sandbox的最重要的一个部分，也是访问控制的总协调者，我们能够在通常情况下正常使用网络和文件，那是因为当启动application的时候（注意是application，不是applet！），如果你不加“-Djava.security.manager”选项，JVM是不会启动Sandbox的，这时你可以“为所欲为”，而不会碰到SecurityException之类的异常；一旦加入了“-Djava.security.manager”选项，你就会发现有一连串的异常出现喽！

Exception in thread "main" java.security.AccessControlException: access denied (……)
……

Java内置了一个默认的安全策略，这种情况下安全管理器首先装载的是这个默认的策略，不信啊，不信你检查一下你的“%JAVA_HOME%\jre\lib\security\”目录，是不是有个叫“java.policy”的文件？用notepad打开看看：


// Standard extensions get all permissions by default
grant codeBase "file:${java.home}/lib/ext/*" {
    permission java.security.AllPermission;
};
// default permissions granted to all domains
grant { 
    // Allows any thread to stop itself using the java.lang.Thread.stop()
    // method that takes no argument.
    // Note that this permission is granted by default only to remain
    // backwards compatible.
    // It is strongly recommended that you either remove this permission
    // from this policy file or further restrict it to code sources
    // that you specify, because Thread.stop() is potentially unsafe.
    // See "http://java.sun.com/notes" for more information.
    permission java.lang.RuntimePermission "stopThread";
    // allows anyone to listen on un-privileged ports
    permission java.net.SocketPermission "localhost:1024-", "listen";
    // "standard" properies that can be read by anyone
    permission java.util.PropertyPermission "java.version", "read";
    permission java.util.PropertyPermission "java.vendor", "read";
    permission java.util.PropertyPermission "java.vendor.url", "read";
    permission java.util.PropertyPermission "java.class.version", "read";
    permission java.util.PropertyPermission "os.name", "read";
    permission java.util.PropertyPermission "os.version", "read";
    permission java.util.PropertyPermission "os.arch", "read";
    permission java.util.PropertyPermission "file.separator", "read";
    permission java.util.PropertyPermission "path.separator", "read";
    permission java.util.PropertyPermission "line.separator", "read";
    permission java.util.PropertyPermission "java.specification.version", "read";
    permission java.util.PropertyPermission "java.specification.vendor", "read";
    permission java.util.PropertyPermission "java.specification.name", "read";
    permission java.util.PropertyPermission "java.vm.specification.version", "read";
    permission java.util.PropertyPermission "java.vm.specification.vendor", "read";
    permission java.util.PropertyPermission "java.vm.specification.name", "read";
    permission java.util.PropertyPermission "java.vm.version", "read";
    permission java.util.PropertyPermission "java.vm.vendor", "read";
    permission java.util.PropertyPermission "java.vm.name", "read";
};

可以看到，JVM给沙箱内的application分配的权限仅限于中止线程，监听1024以上的TCP端口，以及对一些系统属性的读取权限，像一般的socket操作和文件操作的权限都没有。
     了解了安全管理器的概念以后我们回到授权问题上来。对用户来说，最担心的莫过于机器中病毒，病毒本质上是一种恶意的程序，所以访问控制首先是要对代码的权限进行控制，上面我一直都在谈Sandbox，也就是所谓的“沙箱”，熟悉Java安全性发展历史的朋友大概对它不会陌生，初期的Java是采用这样一种安全策略，即：本地代码是可信的，而远程代码是不可信的，譬如applet是一种从网络上下载到本地并在浏览器上运行的一段远程代码，因而是不可信的，所以早期的applet被完全置于Sandbox当中，得到的权限是非常有限的；在1.0以后，直至Java 2出现之前，安全策略作了一些灵活的改变，applet不再是完全被歧视的“二等公民”了，因为有了签名applet，用户可以选择信任这种经过签名的applet，从而applet也可以做一些以前被认为是“出格”的事情；到了Java 2，情况又变了，以前一向被信任的本地代码似乎也变得不是那么可靠了，这还真说不准，难保谁不会在你出去跟女朋友逛街的时候，偷偷溜进来在你机器上拷个病毒什么的 ^_^ ，这样本地代码就落到了和远程代码相等同的地位了，这是比较符合现实世界场景的，在Java 2中的安全策略被称之为“可配置的安全策略”，任何代码，只要是通过安全管理器访问，就必须为它预先设定好访问权限，在这个之外的资源还是别的什么东东，对不起，java.security.AccessControlException: access denied…… 此路不通！
    简单总结一下Java安全模型的发展史，大概就是下面的几幅图了：






2．了解几个主要的API

     JAAS的API基本上位于javax.security.auth包及其下属子包中，很容易找到的。

  • javax.security.auth.Subject
         Subject表征系统中一个认证的用户，这个词时而被译为“主题”时而被以为“主体”（下面我要谈到的Principal有时候也被译为“主体”），不管它有几个马甲，反正你就可以看成是在Java中你这个人的影子，你对系统的访问就体现为Subject.doAs()或Subject.doAsPrivileged()方法。

     

         由于现在普遍是多用户的系统，所以在实现代码级访问控制之外，我们还希望能够对用户的行为进行约束，因为对系统造成破坏的因素不仅仅是恶意代码，人自身的有意或无意的不当操作也会危及系统，譬如向上面说的你不在的时候别人可以在你机器上拷病毒，如果系统能在你不在的时候也能拒绝这个家伙的登录企图，那样麻烦岂不是少很多？于是在Java安全核心之外，提供了一个名为“Java认证与授权服务”（Java Authentication and Authorization Services，JAAS）东东，专门用来处理对用户的认证和授权，这也就是所谓的“以用户为中心的授权模型”，说白了就是在“以代码为中心的授权模型”上再加一层，首先用户要获得访问权限，然后用户去操纵代码，代码来实行真正的访问操作。下面我主要是讲讲JAAS是如何工作的。

  • 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，向终端发出文本消息的