张 涛 (zzhangt@cn.ibm.com), 软件工程师, IBM
王 秉坤 (wangbk@cn.ibm.com), 软件工程师, IBM

2008 年 4 月 10 日

单点登录（Single Sign On , 简称 SSO ）是目前比较流行的服务于企业业务整合的解决方案之一， SSO 使得在多个应用系统中，用户只需要登录一次就可以访问所有相互信任的应用系统。CAS(Central Authentication Service)是一款不错的针对 Web 应用的单点登录框架，本文介绍了 CAS 的原理、协议、在 Tomcat 中的配置和使用，对于采用 CAS 实现轻量级单点登录解决方案的入门读者具有一定指导作用。

CAS 介绍

CAS 是 Yale 大学发起的一个开源项目，旨在为 Web 应用系统提供一种可靠的单点登录方法，CAS 在 2004 年 12 月正式成为 JA-SIG 的一个项目。CAS 具有以下特点：

• 开源的企业级单点登录解决方案。
• CAS Server 为需要独立部署的 Web 应用。
• CAS Client 支持非常多的客户端(这里指单点登录系统中的各个 Web 应用)，包括 Java, .Net, PHP, Perl, Apache, uPortal, Ruby 等。

CAS 原理和协议

从结构上看，CAS 包含两个部分： CAS Server 和 CAS Client。CAS Server 需要独立部署，主要负责对用户的认证工作；CAS Client 负责处理对客户端受保护资源的访问请求，需要登录时，重定向到 CAS Server。图1 是 CAS 最基本的协议过程：

CAS Client 与受保护的客户端应用部署在一起，以 Filter 方式保护受保护的资源。对于访问受保护资源的每个 Web 请求，CAS Client 会分析该请求的 Http 请求中是否包含 Service Ticket，如果没有，则说明当前用户尚未登录，于是将请求重定向到指定好的 CAS Server 登录地址，并传递 Service （也就是要访问的目的资源地址），以便登录成功过后转回该地址。用户在第 3 步中输入认证信息，如果登录成功，CAS Server 随机产生一个相当长度、唯一、不可伪造的 Service Ticket，并缓存以待将来验证，之后系统自动重定向到 Service 所在地址，并为客户端浏览器设置一个 Ticket Granted Cookie（TGC），CAS Client 在拿到 Service 和新产生的 Ticket 过后，在第 5，6 步中与 CAS Server 进行身份合适，以确保 Service Ticket 的合法性。

在该协议中，所有与 CAS 的交互均采用 SSL 协议，确保，ST 和 TGC 的安全性。协议工作过程中会有 2 次重定向的过程，但是 CAS Client 与 CAS Server 之间进行 Ticket 验证的过程对于用户是透明的。

另外，CAS 协议中还提供了 Proxy （代理）模式，以适应更加高级、复杂的应用场景，具体介绍可以参考 CAS 官方网站上的相关文档。

准备工作

本文中的例子以 tomcat5.5 为例进行讲解，下载地址：

http://tomcat.apache.org/download-55.cgi

到 CAS 官方网站下载 CAS Server 和 Client，地址分别为：

http://www.ja-sig.org/downloads/cas/cas-server-3.1.1-release.zip

http://www.ja-sig.org/downloads/cas-clients/cas-client-java-2.1.1.zip

回页首

部署 CAS Server

CAS Server 是一套基于 Java 实现的服务，该服务以一个 Java Web Application 单独部署在与 servlet2.3 兼容的 Web 服务器上，另外，由于 Client 与 CAS Server 之间的交互采用 Https 协议，因此部署 CAS Server 的服务器还需要支持 SSL 协议。当 SSL 配置成功过后，像普通 Web 应用一样将 CAS Server 部署在服务器上就能正常运行了，不过，在真正使用之前，还需要扩展验证用户的接口。

在 Tomcat 上部署一个完整的 CAS Server 主要按照以下几个步骤：

配置 Tomcat 使用 Https 协议

如果希望 Tomcat 支持 Https，主要的工作是配置 SSL 协议，其配置过程和配置方法可以参考 Tomcat 的相关文档。不过在生成证书的过程中，会有需要用到主机名的地方，CAS 建议不要使用 IP 地址，而要使用机器名或域名。

部署 CAS Server

CAS Server 是一个 Web 应用包，将前面下载的 cas-server-3.1.1-release.zip 解开，把其中的 cas-server-webapp-3.1.1.war 拷贝到 tomcat的 webapps 目录，并更名为 cas.war。由于前面已配置好 tomcat 的 https 协议，可以重新启动 tomcat，然后访问：https://localhost:8443/cas ，如果能出现正常的 CAS 登录页面，则说明 CAS Server 已经部署成功。

虽然 CAS Server 已经部署成功，但这只是一个缺省的实现，在实际使用的时候，还需要根据实际概况做扩展和定制，最主要的是扩展认证 (Authentication) 接口和 CAS Server 的界面。

扩展认证接口

CAS Server 负责完成对用户的认证工作，它会处理登录时的用户凭证 (Credentials) 信息，用户名/密码对是最常见的凭证信息。CAS Server 可能需要到数据库检索一条用户帐号信息，也可能在 XML 文件中检索用户名/密码，还可能通过 LDAP Server 获取等，在这种情况下，CAS 提供了一种灵活但统一的接口和实现分离的方式，实际使用中 CAS 采用哪种方式认证是与 CAS 的基本协议分离开的，用户可以根据认证的接口去定制和扩展。

扩展 AuthenticationHandler

CAS 提供扩展认证的核心是 AuthenticationHandler 接口，该接口定义如清单 1 下：

            public interface AuthenticationHandler {
            /**
            * Method to determine if the credentials supplied are valid.
            * @param credentials The credentials to validate.
            * @return true if valid, return false otherwise.
            * @throws AuthenticationException An AuthenticationException can contain
            * details about why a particular authentication request failed.
            */
            boolean authenticate(Credentials credentials) throws AuthenticationException;
            /**
            * Method to check if the handler knows how to handle the credentials
            * provided. It may be a simple check of the Credentials class or something
            * more complicated such as scanning the information contained in the
            * Credentials object.
            * @param credentials The credentials to check.
            * @return true if the handler supports the Credentials, false othewrise.
            */
            boolean supports(Credentials credentials);
            }
            

该接口定义了 2 个需要实现的方法，supports ()方法用于检查所给的包含认证信息的Credentials 是否受当前 AuthenticationHandler 支持；而 authenticate() 方法则担当验证认证信息的任务，这也是需要扩展的主要方法，根据情况与存储合法认证信息的介质进行交互，返回 boolean 类型的值，true 表示验证通过，false 表示验证失败。

CAS3中还提供了对AuthenticationHandler 接口的一些抽象实现，比如，可能需要在执行authenticate() 方法前后执行某些其他操作，那么可以让自己的认证类扩展自清单 2 中的抽象类：

            public abstract class AbstractPreAndPostProcessingAuthenticationHandler
            implements AuthenticateHandler{
            protected Log log = LogFactory.getLog(this.getClass());
            protected boolean preAuthenticate(final Credentials credentials) {
            return true;
            }
            protected boolean postAuthenticate(final Credentials credentials,
            final boolean authenticated) {
            return authenticated;
            }
            public final boolean authenticate(final Credentials credentials)
            throws AuthenticationException {
            if (!preAuthenticate(credentials)) {
            return false;
            }
            final boolean authenticated = doAuthentication(credentials);
            return postAuthenticate(credentials, authenticated);
            }
            protected abstract boolean doAuthentication(final Credentials credentials)
            throws AuthenticationException;
            }
            

AbstractPreAndPostProcessingAuthenticationHandler 类新定义了 preAuthenticate() 方法和 postAuthenticate() 方法，而实际的认证工作交由 doAuthentication() 方法来执行。因此，如果需要在认证前后执行一些额外的操作，可以分别扩展 preAuthenticate()和 ppstAuthenticate() 方法，而 doAuthentication() 取代 authenticate() 成为了子类必须要实现的方法。

由于实际运用中，最常用的是用户名和密码方式的认证，CAS3 提供了针对该方式的实现，如清单 3 所示：

            public abstract class AbstractUsernamePasswordAuthenticationHandler extends
            AbstractPreAndPostProcessingAuthenticationHandler{
            ...
            protected final boolean doAuthentication(final Credentials credentials)
            throws AuthenticationException {
            return authenticateUsernamePasswordInternal((UsernamePasswordCredentials) credentials);
            }
            protected abstract boolean authenticateUsernamePasswordInternal(
            final UsernamePasswordCredentials credentials) throws AuthenticationException;
            protected final PasswordEncoder getPasswordEncoder() {
            return this.passwordEncoder;
            }
            public final void setPasswordEncoder(final PasswordEncoder passwordEncoder) {
            this.passwordEncoder = passwordEncoder;
            }
            ...
            }
            

基于用户名密码的认证方式可直接扩展自 AbstractUsernamePasswordAuthenticationHandler，验证用户名密码的具体操作通过实现 authenticateUsernamePasswordInternal() 方法达到，另外，通常情况下密码会是加密过的，setPasswordEncoder() 方法就是用于指定适当的加密器。

从以上清单中可以看到，doAuthentication() 方法的参数是 Credentials 类型，这是包含用户认证信息的一个接口，对于用户名密码类型的认证信息，可以直接使用 UsernamePasswordCredentials，如果需要扩展其他类型的认证信息，需要实现Credentials接口，并且实现相应的 CredentialsToPrincipalResolver 接口，其具体方法可以借鉴 UsernamePasswordCredentials 和 UsernamePasswordCredentialsToPrincipalResolver。

JDBC 认证方法

用户的认证信息通常保存在数据库中，因此本文就选用这种情况来介绍。将前面下载的 cas-server-3.1.1-release.zip 包解开后，在 modules 目录下可以找到包 cas-server-support-jdbc-3.1.1.jar，其提供了通过 JDBC 连接数据库进行验证的缺省实现，基于该包的支持，我们只需要做一些配置工作即可实现 JDBC 认证。

JDBC 认证方法支持多种数据库，DB2, Oracle, MySql, Microsoft SQL Server 等均可，这里以 DB2 作为例子介绍。并且假设DB2数据库名： CASTest，数据库登录用户名： db2user，数据库登录密码： db2password，用户信息表为： userTable，该表包含用户名和密码的两个数据项分别为 userName 和 password。

1. 配置 DataStore

打开文件 %CATALINA_HOME%/webapps/cas/WEB-INF/deployerConfigContext.xml，添加一个新的 bean 标签，对于 DB2，内容如清单 4 所示：

            <bean id="casDataSource" class="org.apache.commons.dbcp.BasicDataSource">
            <property name="driverClassName">
            <value>com.ibm.db2.jcc.DB2Driver</value>
            </property>
            <property name="url">
            <value>jdbc:db2://9.125.65.134:50000/CASTest</value>
            </property>
            <property name="username">
            <value>db2user</value>
            </property>
            <property name="password">
            <value>db2password</value>
            </property>
            </bean>
            

其中 id 属性为该 DataStore 的标识，在后面配置 AuthenticationHandler 会被引用，另外，需要提供 DataStore 所必需的数据库驱动程序、连接地址、数据库登录用户名以及登录密码。

2. 配置 AuthenticationHandler

在 cas-server-support-jdbc-3.1.1.jar 包中，提供了 3 个基于 JDBC 的 AuthenticationHandler，分别为 BindModeSearchDatabaseAuthenticationHandler, QueryDatabaseAuthenticationHandler, SearchModeSearchDatabaseAuthenticationHandler。其中 BindModeSearchDatabaseAuthenticationHandler 是用所给的用户名和密码去建立数据库连接，根据连接建立是否成功来判断验证成功与否；QueryDatabaseAuthenticationHandler 通过配置一个 SQL 语句查出密码，与所给密码匹配；SearchModeSearchDatabaseAuthenticationHandler 通过配置存放用户验证信息的表、用户名字段和密码字段，构造查询语句来验证。

使用哪个 AuthenticationHandler，需要在 deployerConfigContext.xml 中设置，默认情况下，CAS 使用一个简单的 username=password 的 AuthenticationHandler，在文件中可以找到如下一行：<bean class="org.jasig.cas.authentication.handler.support.SimpleTestUsernamePassword
AuthenticationHandler" />，我们可以将其注释掉，换成我们希望的一个 AuthenticationHandler，比如，使用QueryDatabaseAuthenticationHandler 或 SearchModeSearchDatabaseAuthenticationHandler 可以分别选取清单 5 或清单 6 的配置。

            <bean class="org.jasig.cas.adaptors.jdbc.QueryDatabaseAuthenticationHandler">
            <property name="dataSource" ref=" casDataSource " />
            <property name="sql"
            value="select password from userTable where lower(userName) = lower(?)" />
            </bean>
            

            <bean id="SearchModeSearchDatabaseAuthenticationHandler"
            class="org.jasig.cas.adaptors.jdbc.SearchModeSearchDatabaseAuthenticationHandler"
            abstract="false" singleton="true" lazy-init="default"
            autowire="default" dependency-check="default">
            <property  name="tableUsers">
            <value>userTable</value>
            </property>
            <property name="fieldUser">
            <value>userName</value>
            </property>
            <property name="fieldPassword">
            <value>password</value>
            </property>
            <property name="dataSource" ref=" casDataSource " />
            </bean>
            

另外，由于存放在数据库中的密码通常是加密过的，所以 AuthenticationHandler 在匹配时需要知道使用的加密方法，在 deployerConfigContext.xml 文件中我们可以为具体的 AuthenticationHandler 类配置一个 property，指定加密器类，比如对于 QueryDatabaseAuthenticationHandler，可以修改如清单7所示：

            <bean class="org.jasig.cas.adaptors.jdbc.QueryDatabaseAuthenticationHandler">
            <property name="dataSource" ref=" casDataSource " />
            <property name="sql"
            value="select password from userTable where lower(userName) = lower(?)" />
            <property  name="passwordEncoder"  ref="myPasswordEncoder"/>
            </bean>
            

其中 myPasswordEncoder 是对清单 8 中设置的实际加密器类的引用：

            <bean id="passwordEncoder"
            class="org.jasig.cas.authentication.handler.MyPasswordEncoder"/>
            

这里 MyPasswordEncoder 是根据实际情况自己定义的加密器，实现 PasswordEncoder 接口及其 encode() 方法。

3. 部署依赖包

在以上配置完成以后，需要拷贝几个依赖的包到 cas 应用下，包括：

• 将 cas-server-support-jdbc-3.1.1.jar 拷贝到 %CATALINA_HOME%/webapps/cas/ WEB-INF/lib 目录。
• 数据库驱动，由于这里使用 DB2，将 %DB2_HOME%/java 目录下的 db2java.zip （更名为 db2java.jar）, db2jcc.jar, db2jcc_license_cu.jar 拷贝到 %CATALINA_HOME%/webapps/cas/WEB-INF/lib 目录。对于其他数据库，同样将相应数据库驱动程序拷贝到该目录。
• DataStore 依赖于 commons-collections-3.2.jar, commons-dbcp-1.2.1.jar, commons-pool-1.3.jar，需要到 apache 网站的 Commons 项目下载以上 3 个包放进 %CATALINA_HOME%/webapps/cas/WEB-INF/lib 目录。

扩展 CAS Server 界面

CAS 提供了 2 套默认的页面，分别为“ default ”和“ simple ”，分别在目录“ cas/WEB-INF/view/jsp/default ”和“ cas/WEB-INF/view/jsp/simple ”下。其中 default 是一个稍微复杂一些的页面，使用 CSS，而 simple 则是能让 CAS 正常工作的最简化的页面。

在部署 CAS 之前，我们可能需要定制一套新的 CAS Server 页面，添加一些个性化的内容。最简单的方法就是拷贝一份 default 或 simple 文件到“ cas/WEB-INF/view/jsp ”目录下，比如命名为 newUI，接下来是实现和修改必要的页面，有 4 个页面是必须的：

• casConfirmView.jsp: 当用户选择了“ warn ”时会看到的确认界面
• casGenericSuccess.jsp: 在用户成功通过认证而没有目的Service时会看到的界面
• casLoginView.jsp: 当需要用户提供认证信息时会出现的界面
• casLogoutView.jsp: 当用户结束 CAS 单点登录系统会话时出现的界面

CAS 的页面采用 Spring 框架编写，对于不熟悉 Spring 的使用者，在修改之前需要熟悉该框架。

页面定制完过后，还需要做一些配置从而让 CAS 找到新的页面，拷贝“ cas/WEB-INF/classes/default_views.properties ”，重命名为“ cas/WEB-INF/classes/ newUI_views.properties ”，并修改其中所有的值到相应新页面。最后是更新“ cas/WEB-INF/cas-servlet.xml ”文件中的 viewResolver，将其修改为如清单 9 中的内容。

            <bean id="viewResolver"
            class="org.springframework.web.servlet.view.ResourceBundleViewResolver" p:order="0">
            <property name="basenames">
            <list>
            <value>${cas.viewResolver.basename}</value>
            <value> newUI_views</value>
            </list>
            </property>
            </bean>
            

回页首

部署客户端应用

单点登录的目的是为了让多个相关联的应用使用相同的登录过程，本文在讲解过程中构造 2个简单的应用，分别以 casTest1 和 casTest2 来作为示例，它们均只有一个页面，显示欢迎信息和当前登录用户名。这 2 个应用使用同一套登录信息，并且只有登录过的用户才能访问，通过本文的配置，实现单点登录，即只需登录一次就可以访问这两个应用。

与 CAS Server 建立信任关系

假设 CAS Server 单独部署在一台机器 A，而客户端应用部署在机器 B 上，由于客户端应用与 CAS Server 的通信采用 SSL，因此，需要在 A 与 B 的 JRE 之间建立信任关系。

首先与 A 机器一样，要生成 B 机器上的证书，配置 Tomcat 的 SSL 协议。其次，下载http://blogs.sun.com/andreas/entry/no_more_unable_to_find 的 InstallCert.java，运行“ java InstallCert compA:8443 ”命令，并且在接下来出现的询问中输入 1。这样，就将 A 添加到了 B 的 trust store 中。如果多个客户端应用分别部署在不同机器上，那么每个机器都需要与 CAS Server 所在机器建立信任关系。

配置 CAS Filter

准备好应用 casTest1 和 casTest2 过后，分别部署在 B 和 C 机器上，由于 casTest1 和casTest2，B 和 C 完全等同，我们以 casTest1 在 B 机器上的配置做介绍，假设 A 和 B 的域名分别为 domainA 和 domainB。

将 cas-client-java-2.1.1.zip 改名为 cas-client-java-2.1.1.jar 并拷贝到 casTest1/WEB-INF/lib目录下，修改 web.xml 文件，添加 CAS Filter，如清单 10 所示：

            <web-app>
            ...
            <filter>
            <filter-name>CAS Filter</filter-name>
            <filter-class>edu.yale.its.tp.cas.client.filter.CASFilter</filter-class>
            <init-param>
            <param-name>edu.yale.its.tp.cas.client.filter.loginUrl</param-name>
            <param-value>https://domainA:8443/cas/login</param-value>
            </init-param>
            <init-param>
            <param-name>edu.yale.its.tp.cas.client.filter.validateUrl</param-name>
            <param-value>https://domainA:8443/cas/serviceValidate</param-value>
            </init-param>
            <init-param>
            <param-name>edu.yale.its.tp.cas.client.filter.serverName</param-name>
            <param-value>domainB:8080</param-value>
            </init-param>
            </filter>
            <filter-mapping>
            <filter-name>CAS Filter</filter-name>
            <url-pattern>/protected-pattern/*</url-pattern>
            </filter-mapping>
            ...
            </web-app>
            

对于所有访问满足 casTest1/protected-pattern/ 路径的资源时，都要求到 CAS Server 登录，如果需要整个 casTest1 均受保护，可以将 url-pattern 指定为“/*”。

从清单 10 可以看到，我们可以为 CASFilter 指定一些参数，并且有些是必须的，表格 1 和表格 2 中分别是必需和可选的参数：

传递登录用户名

CAS 在登录成功过后，会给浏览器回传 Cookie，设置新的到的 Service Ticket。但客户端应用拥有各自的 Session，我们要怎么在各个应用中获取当前登录用户的用户名呢？CAS Client 的 Filter 已经做好了处理，在登录成功后，就可以直接从 Session 的属性中获取，如清单 11 所示：

            // 以下两者都可以
            session.getAttribute(CASFilter.CAS_FILTER_USER);
            session.getAttribute("edu.yale.its.tp.cas.client.filter.user");
            

在 JSTL 中获取用户名的方法如清单 12 所示：

            <c:out value="${sessionScope[CAS:'edu.yale.its.tp.cas.client.filter.user']}"/>
            

另外，CAS 提供了一个 CASFilterRequestWrapper 类，该类继承自HttpServletRequestWrapper，主要是重写了 getRemoteUser() 方法，只要在前面配置 CASFilter 的时候为其设置“ edu.yale.its.tp.cas.client.filter.wrapRequest ”参数为 true，就可以通过 getRemoteUser（） 方法来获取登录用户名，具体方法如清单 13 所示：

            CASFilterRequestWrapper  reqWrapper=new CASFilterRequestWrapper(request);
            out.println("The logon user:" + reqWrapper.getRemoteUser());
            

回页首

效果

在 casTest1 和 casTest2 中，都有一个简单 Servlet 作为欢迎页面 WelcomPage，且该页面必须登录过后才能访问，页面代码如清单 14 所示：

            public class WelcomePage extends HttpServlet {
            public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws IOException, ServletException
            {
            response.setContentType("text/html");
            PrintWriter out = response.getWriter();
            out.println("<html>");
            out.println("<head>");
            out.println("<title>Welcome to casTest2 sample System!</title>");
            out.println("</head>");
            out.println("<body>");
            out.println("<h1>Welcome to casTest1 sample System!</h1>");
            CASFilterRequestWrapper  reqWrapper=new CASFilterRequestWrapper(request);
            out.println("<p>The logon user:" + reqWrapper.getRemoteUser() + "</p>");
            HttpSession session=request.getSession();
            out.println("<p>The logon user:" +
            session.getAttribute(CASFilter.CAS_FILTER_USER)  + "</p>");
            out.println("<p>The logon user:" +
            session.getAttribute("edu.yale.its.tp.cas.client.filter.user") + "</p>");
            out.println("</body>");
            out.println("</html>");
            }
            }
            

在上面所有配置结束过后，分别在 A， B， C上启动 cas， casTest1 和 casTest2，按照下面步骤来访问 casTest1 和 casTest2：

1. 打开浏览器，访问 http://domainB:8080/casTest1/WelcomePage ，浏览器会弹出安全提示，接受后即转到 CAS 的登录页面，如图 2 所示：

1. 登录成功后，再重定向到 casTest1 的 WelcomePage 页面，如图 所示：

可以看到图 中地址栏里的地址多出了一个 ticket 参数，这就是 CAS 分配给当前应用的 ST(Service Ticket)。

1. 再在同一个浏览器的地址栏中输入 http://domainC:8080/casTest2/WelcomePage ，系统不再提示用户登录，而直接出现如图 4 所示的页面，并且显示在 casTest1 中已经登录过的用户。

1. 重新打开一个浏览器窗口，先输入 http://domainC:8080/casTest2/WelcomePage ，系统要求登录，在登录成功过后，正确显示 casTest2 的页面。之后再在地址栏重新输入 http://domainB:8080/casTest1/WelcomePage ，会直接显示 casTest1 的页面而无需再次登录。

回页首

结束语

本文介绍了 CAS 单点登录解决方案的原理，并结合实例讲解了在 Tomcat 中使用 CAS 的配置、部署方法以及效果。CAS 是作为开源单点登录解决方案的一个不错选择，更多的使用细节可以参考 CAS 官方网站。

参考资料

• 有关 CAS 方面的信息， 请参考CAS 官方网站。
  
  
• 浏览JA-SIG 社区，与社区分享 Java 技术。

作者简介

		张涛，IBM 中国软件开发实验室工程师，目前主要致力于基于 Rational 平台解决方案的开发。

		王秉坤，IBM 中国软件开发实验室工程师，目前主要致力于基于 Rational 平台解决方案的开发。

由于CAS使用Https协议，所以首先要知道如何在容器中配置SSL。Tomcat的SSL配置相对其它的容器较为简单，SSL配置完成后CAS服务器一般都能正常运行了。

CAS的客户端以一个Web应用的Filter运行。当Web应用的某个功能被请求时，Filter就会拦截应用的URL，从而迫使用户到CAS服务器进行登陆。在所有不同的Web应用中，使用同一个CAS服务器进行登陆，即可达到单点登陆之目的。

本文使用同一个Tomcat（版本Tomcat5.0.30）配置CAS服务器及客户端，分别在8443端口及8080端口。下面是在Tomcat中使用Yale CAS实现单点登陆的详细步骤：

<!--[if !supportLists]-->1. <!--[endif]-->安装CAS服务器

<!--[if !supportLists]-->1.1. <!--[endif]-->下载CAS发行包，下载地址：

CAS 服务器： http://www.yale.edu/tp/cas/cas-server-2.0.12.zip 或
https://clearinghouse.ja-sig.org/wiki/download/attachments/924/cas-server-2.0.12.zip
CAS 客户端： http://www.yale.edu/tp/cas/cas-client-2.0.11.zip 或
https://clearinghouse.ja-sig.org/wiki/download/attachments/827/cas-client-2.0.11.zip

<!--[if !supportLists]-->1.2.     <!--[endif]-->将cas-server-2.0.12.zip解压，并将lib/cas.war拷贝到Tomcat的webapps下，测试CAS服务器是否发布正常，可以访问http://localhost:8080/cas/login出现登陆窗口。输入用户名密码（用户名＝密码），出现登陆成功页面说明发布正常。

<!--[if !supportLists]-->2.   <!--[endif]-->配置Tomcat使用https协议

<!--[if !supportLists]-->2.1.     <!--[endif]-->使用Java自带的keytool命令，产生SERVER的证书

D:"> keytool -genkey -alias my-alias-name -keyalg RSA -keystore keystore-file

其中 my-alias-name 为别名，这行命令的作用是产生一个新的公共 / 私有钥匙对。 keystore-file 为存储钥匙和证书的文件。

命令运行后，根据提示回答。注意在开始问“你的名字”或“DName”的时候，必须填写你服务器所在域名（在局域网中测试时，使用主机名或hosts文件中注册的域名,本机可以使用localhost）。

<!--[if !supportLists]-->2.2.     <!--[endif]-->在Tomcat的8443端口配置SSL

在 Tomcat_Path"conf"server.xml 文件中配置 SSL 的地方，增加如下配置：

    <Connector className="org.apache.coyote.tomcat5.CoyoteConnector"

    port="8443" minProcessors="5" maxProcessors="75"

    enableLookups="true" disableUploadTimeout="true"

    acceptCount="100" debug="0" scheme="https"

    secure="true">

    <Factory className="org.apache.coyote.tomcat5.CoyoteServerSocketFactory"

    keystoreFile="D:/keystore-file"

    keystorePass="password" clientAuth="false" protocol="TLS" />

    </Connector>

其中，keystoreFile使用绝对路径，keystorePass为第3点输入的keystore密码。配置完成后，启动Tomcat,访问https://localhost:8443 ，访问成功说明SSL配置成功。也可以访问https://localhost:8443/cas/login 。

<!--[if !supportLists]-->3.      <!--[endif]-->配置 CAS客户端

以Tomcat中自带的Servlet examples应用为例，在Web应用中使用配置CAS客户端。

<!--[if !supportLists]-->3.1.        <!--[endif]-->在Servlet examples应用里配置CAS客户端，需修改servlets-examples/WEB-INF/web.xml，在web.xml文件中,加入如下Filter配置：

    <filter>

        <filter-name>CASFilter</filter-name>

    <filter-class>edu.yale.its.tp.cas.client.filter.CASFilter</filter-class>

        <init-param>

        <param-name>edu.yale.its.tp.cas.client.filter.loginUrl</param-name>

        <param-value>https://localhost:8443/cas/login</param-value>

        </init-param>

        <init-param>

        <param-name>edu.yale.its.tp.cas.client.filter.validateUrl</param-name>

        <param-value>https://localhost:8443/cas/proxyValidate</param-value>

        </init-param>

        <init-param>         <param-name>edu.yale.its.tp.cas.client.filter.serverName</param-name>

            <param-value>localhost:8080</param-value>

        </init-param>

    </filter>

    <filter-mapping>

        <filter-name>CASFilter</filter-name>

        <url-pattern>/servlet/*</url-pattern>

    </filter-mapping>

其中，第一，二个localhost都改成CAS服务器域名或主机名，第三个改成你servelt example应用域名或主机名，由于本文中CAS服务器与客户端在同一主机同一Tomcat上，所以都为localhost。若不在同一主机，则分别使用两主机的域名或主机名。

<!--[if !supportLists]-->3.2.     <!--[endif]-->将cas-client-2.0.11.zip解压，把java/lib/casclient.jar拷贝到Tomcat的
webapps/servlets-examples/WEB-INF/lib目录下（如果没有就建一个）
<!--[if !supportLineBreakNewLine]-->
<!--[endif]-->

<!--[if !supportLists]-->3.3.     <!--[endif]-->导出SERVER的证书，用来给所有需要用到的客户端导入

D:"> keytool -export -file myserver.cert -alias my-alias-name -keystore keystore-file

<!--[if !supportLists]-->3.4.     <!--[endif]-->在客户端的JVM里导入信任的SERVER的证书，输入keystore密码时，注意现在的keystore为cacerts，而cacerts的初密码为changeit，而不是前面keystore-file的密码，所以要是没有改过cacerts密码应该输入changeit.

D:"> keytool -import -keystore $JAVA_HOME/jre/lib/security/cacerts -file myserver.cert -alias my-alias-name

其中，$JAVA_HOME改成JDK的绝对路径。

<!--[if !supportLists]-->4.         <!--[endif]-->测试SSO

启动Tomcat，访问 http://localhost:8080/servlets-examples/ ，随便执行一个servlet，系统会自动跳转到一个验证页面，随便输入一个相同的账号,密码，认证通过之后，就会访问到你点击的servlet了。

CAS (Central Authentication Service)是Yale大学的ITS开发的一套JAVA实现的开源
的SSO(single sign-on)的服务。

这里用一个简单的例子来说明用CAS来实现单点登陆(SSO)。

Yale CAS Server 的配置过程

CAS (Central Authentication Service)是Yale大学的ITS开发的一套JAVA实现的开源
的SSO(single sign-on)的服务。该服务是以一个java web app(eg:cas.war)来进行服务的，
使用时需要将cas.war发布到一个servlet2.3兼容的服务器上，并且服务器需要支持SSL，
在需要使用该服务的其他服务器（客户），只要进行简单的配置就可以实现SSO了。

CAS 的客户端可以有很多种，因为验证的结果是以XML的格式返回的，CAS的客户端已
打包进去的有java,perl,python,asp,apache module等好几种客户端示例，你还可以根据
需要实现一个自己的客户端，非常简单!~

下面我们以tomcat 5.0 作为CAS Server(server1)，另外一台tomcat5.0 为client(client1)
为例进行说明。

1.下载cas-server和cas-client(可选，建议使用）
http://www.yale.edu/tp/cas/cas-server-2.0.12.zip
http://www.yale.edu/tp/cas/cas-client-2.0.11.zip

2.将cas-server-2.0.12.zip解压，并将lib/cas.war拷贝到server1的webapps下

3.产生SERVER的证书
keytool -genkey -alias my-alias-name -keyalg RSA -keystore keystore-file

4.在server1配置tomcat使用HTTPS

$CATALINA_HOME/conf/server.xml里

<Connector className="org.apache.coyote.tomcat5.CoyoteConnector"
port="8443" minProcessors="5" maxProcessors="75"
enableLookups="true" disableUploadTimeout="true"
acceptCount="100" debug="0" scheme="https"
secure="true">
<Factory className="org.apache.coyote.tomcat5.CoyoteServerSocketFactory"
keystoreFile="/path/to/your/keystore-file"
keystorePass="your-password" clientAuth="false" protocol="TLS" />
</Connector>

5.在要使用CAS的客户端client1里设置（以servlets-examples这个APP为例），我们使用
ServletFilter(CAS client里提供的)来实现SSO的检查。

修改servlets-examples/WEB-INF/web.xml

<filter>
<filter-name>CASFilter</filter-name>
<filter-class>edu.yale.its.tp.cas.client.filter.CASFilter</filter-class>
<init-param>
<param-name>edu.yale.its.tp.cas.client.filter.loginUrl</param-name>
<param-value>https://your.cas.server.name(eg:server1):port/cas/login</param-value>
</init-param>
<init-param>
<param-name>edu.yale.its.tp.cas.client.filter.validateUrl</param-name>
<param-value>https://your.cas.server.name(eg:server1):port/cas/proxyValidate</param-value>
</init-param>

<init-param>
<param-name>edu.yale.its.tp.cas.client.filter.serverName</param-name>
<param-value>your.client.server.name(eg:client1):port</param-value>
</init-param>

</filter>

<filter-mapping>
<filter-name>CASFilter</filter-name>
<url-pattern>/servlet/*</url-pattern>
</filter-mapping>

6.将cas-client-2.0.11.zip解压，把java/lib/casclient.jar拷贝到client1服务器上的
webapps/servlets-examples/WEB-INF/lib目录下（如果没有就建一个）

7.导出SERVER的证书，用来给所有需要用到的客户端导入
keytool -export -file myserver.cert -alias my-alias-name -keystore keystore-file

8.在客户端的JVM里导入信任的SERVER的证书(根据情况有可能需要管理员权限)
keytool -import -keystore $JAVA_HOME/jre/lib/security/cacerts -file myserver.cert -alias my-alias-name

9.test & done.
把server1和client1分别起来，检查启动的LOG是否正常，如果一切OK，就访问
http://client1:8080/servlets-examples/servlet/HelloWorldExample
系统会自动跳转到一个验证页面，随便输入一个相同的账号,密码，严正通过之后就会访问
到真正的HelloWorldExample这个servlet了

CAS java client2.1.1 在Tomcat5.5.16下bug的解决

     最近在项目中集成了CAS 结合Acegi来作单点登陆。感觉CAS虽然简单，用起来还是很爽的。不过前几天发布一个子系统的时候出现了下面的问题。

edu.yale.its.tp.cas.client.CASAuthenticationException: Unable to validate ProxyTicketValidator
     < cas:authenticationFailure code = ' INVALID_SERVICE ' >
        ticket  ' ST-74-yBBJRjb3qnFle0Ynhq7sgUsdaox9nPoFbGu-20 '  does not match supplied service
     </ cas:authenticationFailure >

     经排查，发现是CAS java client2.1.1 与Tomcat 5.5.16配合有问题。查看log，发现Cas Server端解析出的service URL前后相差了一个“?”，怀疑是cas client在新版tomcat下生成 service URL时出现问题，检查client代码，定位到edu.yale.its.tp.cas.client.Util的getService方法，跟踪了一下，发现

if  (request.getQueryString()  !=   null ) 
         {
             //  first, see whether we've got a 'ticket' at all
             int  ticketLoc  =  request.getQueryString().indexOf( " ticket= " );

             //  if ticketLoc == 0, then it's the only parameter and we ignore
             //  the whole query string

             //  if no ticket is present, we use the query string wholesale
             if  (ticketLoc  ==   - 1 )
                sb.append( " ? "   +  request.getQueryString());
             else   if  (ticketLoc  >   0 ) 
{
                ticketLoc  =  request.getQueryString().indexOf( " &ticket= " );
                 if  (ticketLoc  ==   - 1 ) 
                 {
                     //  there was a 'ticket=' unrelated to a parameter named
                     //  'ticket'
                    sb.append( " ? "   +  request.getQueryString());
                }   else   if  (ticketLoc  >   0 ) 
                 {
                     //  otherwise, we use the query string up to "&ticket="
                    sb.append( " ? "
                             +  request.getQueryString().substring( 0 , ticketLoc));
                }
            }
        }

发现对于没有参数的http请求，request.getQueryString()函数在Tomcat5.5.15中是返回null，而5.5.16中是返回""。到这里问题就清楚了，看来yale的这帮学生代码写得还是有点业余呀，直接加上对空string判断的逻辑，问题解决。
       这个bug我已经提交到cas的jira上了，应该很快可以fix了，在新版本client没有发布前，可以使用附件压缩包中的jar替换casclient.jar。
casclient.zip

Yale CAS项目总结

SSO总会有一个结束的时候，我最终把CAS Server 2.0放到Weblogic Portal上，并实现了到其他WebApp的单点登陆。困难比我原先想象的要大，总结几点，希望对来者有所帮助。
1，搞SSO前请先熟悉SSL/PKI，因为，CAS的安全性很大程度依赖于SSL，没有安全性，不敢想象SSO有何作为。
2，因为我们的环境是在Weblogic Portal上，Portal环境上，调试CAS费了我好大力气，加之我重写了CAS的LoginModule(CAS不提供J_Security_check登陆方式)，中途抛出的错误很多，访问BEA Support网站是家常便饭了。
3，CAS需要配置信任证书，如果象我那样一步一步地创建根CA，ServerCA，恐怕会比较辛苦，但证书的确让我高枕无忧，从CAS Server和各个Web应用之间建立一种更松耦合的信任关系。
4，IE端到CAS Server的双向SSL虽是画蛇添足，但是在一些高安全性的SSO环境，如网上付费，付出少许的计算代价，即让身份欺诈无所遁形。

冷静下来，想了一下SSO的用处，看来在互连星空中会有卖点，事实上，电信已经使用了SSO了，联通在信平台也在各SP与MISC之间部署SSO，随着B2B，B2C的发展，相信SSO会有很不错的前途。

我个人对CAS的评价是，
PureJava Impl，OpenSource，能轻松在各种WebServer间移植，协议并没有Kerberos那么复杂(当然Kerberos更安全)，所以使用和调试起来，没有Kerberos那么痛苦。实战中，本人更倾向使用CAS 3.0，基于Spring的一种实现方式，将来有空必为此写一Blog.

使用cas实现sso

CAS (Central Authentication Service)是Yale大学的ITS开发的一套JAVA实现的开源 的SSO(single sign-on)的服务,http://www.yale.edu/tp/cas/ cas分为服务端和客户端，在服务端开启SSL，服务器下发证书安装到各个客户端中，客户端在与服务器进行通讯验证时，将检验二者的证书是否一致。 1、服务器中生成证书：keytool -genkey -alias cnc -keystore c:"mykeystore 导出证书，由客户端安装： keytool -export -alias -keystore c:"mykeystore -file c:"mycerts.cer 注：生成证书时，CN要和服务器的域名相同，如果在本地测试，则使用localhost 2、客户端配置：（注：使用client2.0.11版本稳定些，2.0.10总报异常） 将服务器下发的证书导入到JVM中 keytool -import -trustcacerts -alias cnc -keystore $JAVA_HOME/JRE/LIB/SECURITY/CACERTS -file c:"mycert.cer （如果这样不行，则到JAVA_HOME/JRE/LIB/SECURITY/下进行） 配置web.xml： <filter> <filter-name>CASFilter</filter-name> <filter-class>edu.yale.its.tp.cas.client.filter.CASFilter</filter-class> <init-param> <param-name>edu.yale.its.tp.cas.client.filter.loginUrl</param-name> <param-value>https://localhost:8443/cas/login</param-value> </init-param> <init-param> <param-name>edu.yale.its.tp.cas.client.filter.validateUrl</param-name> <param-value>https://localhost:8443/cas/proxyValidate</param-value> </init-param> <init-param> <param-name>edu.yale.its.tp.cas.client.filter.serverName</param-name> <param-value>localhost</param-value> </init-param> </filter> <filter-mapping> <filter-name>CASFilter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping> 　当前CAS默认的用户名和密码判断是，只要用户名和密码相同即可。使用的类为SampleHandler,一般的是与数据库进行匹配，这样我们可以实现PasswordHandler接口， 在authenticate（）方法中进行验证。可以在容器中配置数据源，使用容器提供的数据源。 　　同时修改服务器下ＣＡＳ的web.xml中的配置，使用自己的类。 <context-param> <param-name>edu.yale.its.tp.cas.authHandler</param-name> <param-value>edu.yale.its.tp.cas.auth.provider.MyDBHandler</param-value> </context-param> 　　然后重新BUILD，将类打包，替换服务器CAS/WEB-INF/LIB下原来的包。 　CAS只能提供SSO，对于角色，授权，则要在web.xml进行相应的配置<security-constraint>，也可以使用filter。 常出现的异常：“未找到可信任的证书”--主要原因为在客户端未将服务器下发的证书导入到JVM中，可以用keytool -list -alias cnc -keystore $JAVA_HOME/JRE/LIB/SECURITY/CACERTS 来查看证书是否真的导入到JVM中。 “https hostname must be www.xx.com“---主要原因为在创建keystore是，CN没设置成为服务器的域名，例如 www.auth.com.cn

一．环境

a)         Windows 2003 sp1

b)        JDK1.5.0_11

c)        Tomcat 5.5.23

d)        MySql5.0

二．准备

a)         cas-server-3.0.6.zip 下载地址：http://www.ja-sig.org/products/cas/index.html

b)        cas-client-java-2.1.1.zip 下载地址：同上

c)        安装完jdk和jre后，需要配置JAVA_HOME和PATH=%JAVA_HOME%\bin

三．步骤

a)        配置Tomcat使用SSL安全认证

                         i.              使用命令提示符进入到Tomcat安装目录

                       ii.              生成服务端密匙，执行以下命令

                     keytool -genkey -alias 别名keyalg RSA -keypass changeit -storepass changeit                           -keystore server.keystore

例：keytool -genkey -alias casserver -keyalg RSA -keypass changeit -storepass changeit -keystore server.keystore

运行后出现提示信息：

输入keystore密码：changeit      这里也填入主机名

您的名字与姓氏是什么？

 [Unknown]： localhost           这里一定要填写正确的主机名

您的组织单位名称是什么？

 [Unknown]： oksonic

您的组织名称是什么？

 [Unknown]： oksonic

您所在的城市或区域名称是什么？

 [Unknown]： kunming

您所在的州或省份名称是什么？

 [Unknown]： yunnan

该单位的两字母国家代码是什么

 [Unknown]： cn

CN=localhost, OU=oksonic, O=oksonic, L=kunming, ST=yunnan, C=cn 正确吗？

 [否]： y

完成后会在Tomcat目录生成一个名为casserver的文件

                      iii.              生成服务端证书，执行以下命令

                            keytool -export -alias casserver -storepass changeit -file server.cer                                     -keystore server.keystore

                            命令执行后生成一个server.cer的证书文件

                     iv.              生成客户端密匙，执行以下命令

                            keytool -genkey -alias casclient -keyalg RSA -keypass changeit -storepass                                  changeit -keystore client.keystore

                       v.              生成客户端证书，执行以下命令

                            keytool -export -alias casclient -storepass changeit -file client.cer                                        -keystore client.keystore

                            命令执行后生成一个server.cer的证书文件

                     vi.              导入证书文件到cacerts 文件中，执行以下命令

                            keytool -import -trustcacerts -alias server -file server.cer -keystore                                      cacerts -storepass changeit

                            keytool -import -trustcacerts -alias client -file client.cer -keystore                                        cacerts -storepass changeit

                            把cacerts文件，拷贝到<JAVA_HOME>\jre\lib\security目录下

                    vii.              拷贝cas-server-3.0.6.zip包内的target目录下的cas.war文件到Tomcat目录下的webapps目录下

                  viii.              修改Tomcat的配置文件server.xml把以下补注释的内容打开

<Connector port="8443" maxHttpHeaderSize="8192"

               maxThreads="150" minSpareThreads="25" maxSpareThreads="75"

               enableLookups="false" disableUploadTimeout="true"

               acceptCount="100" scheme="https" secure="true"

               clientAuth="false" sslProtocol="TLS" />

加入红字部份后的内容如下：

         <Connector port="8443" maxHttpHeaderSize="8192"

keystorePass="changeit" keystoreFile="/server.keystore"

               maxThreads="150" minSpareThreads="25" maxSpareThreads="75"

               enableLookups="false" disableUploadTimeout="true"

               acceptCount="100" scheme="https" secure="true"

               clientAuth="false" sslProtocol="TLS" />

b)        配置客户端应用

                         i.              使用Tomcat的例子jsp-examples来做客户端

                       ii.              打开项目中的web.xml文件，加入以下配置信息

                     <filter>
                             <filter-name>CASFilter</filter-name>
                              <filter-class>
                                    edu.yale.its.tp.cas.client.filter.CASFilter
                             </filter-class>
                             <init-param>
                             <param-name>
                                    edu.yale.its.tp.cas.client.filter.loginUrl
                            </param-name>
                             <param-value>https://localhost:8443/cas/login</param-value>
                            </init-param> 
                            <init-param>
                               <param-name>
                                          edu.yale.its.tp.cas.client.filter.validateUrl
                                   </param-name>
                            <param-value>
                                   https://localhost:8443/cas/proxyValidate
                            </param-value>
                     </init-param>
                     <init-param>
                            <param-name>
                                    edu.yale.its.tp.cas.client.filter.serverName
                            </param-name>
                                   <param-value>localhost:8080</param-value>
                      </init-param>
              </filter>

              <filter-mapping>
              <filter-name>CASFilter</filter-name>
                     <url-pattern>/ *</url-pattern>
               </filter-mapping>

              拷贝cas-client-java-2.1.1.zip包中的casclient.jar到项目的lib目录下

              现在可以启动Tomcat来测试一下是否能够进入到登录页

c)         配置CAS使用数据库进行验证

                         i.              在MySql中的Test库中新建app_user表

       CREATE TABLE `app_user` (
                  `username` varchar(30) NOT NULL default '',
                  `password` varchar(45) NOT NULL default '',
                  PRIMARY KEY  (`username`)
         ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
添加以下用户：
         INSERT INTO `app_user` (`username`,`password`) VALUES

                    ('oksonic','oksonic'),

                    ('oksonic1','oksonic1');

                      ii.              修改cas项目中的deployerConfigContext.xml文件

<bean class="org.jasig.cas.authentication.handler.support.SimpleTestUsernamePasswordAuthenticationHandler" />
注释掉该行，在其下加入：
<bean class="org.jasig.cas.adaptors.jdbc.QueryDatabaseAuthenticationHandler">
                            <property name="sql" value="select password from app_user where username=?" />
                            <property name="dataSource" ref="dataSource" />
                     </bean>
并添加一个bean：
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource" destroy-method="close">
       <property name="driverClassName"><value>com.mysql.jdbc.Driver</value></property>
       <property name="url"><value>jdbc:mysql://localhost:3306/test</value></property>
       <property name="username"><value>test</value></property>
       <property name="password"><value>test</value></property>
    </bean>
拷贝cas-server-jdbc-3.0.6.jar和mysql-connector-java-3.1.11-bin.jar到webapps/cas/WEB-INF/lib下

2.生成安全证书
在命令行中：切换到
%java_home%\bin\keytool -genkey -alias tomcat -keyalg RSA
密码是:changeit
姓名是:localhost
其他随便写的
之后是
%java_home%\bin\keytool -export -alias tomcat -file server.crt
和
%java_home%\bin\keytool -import -file server.crt -keystore %java_home%/jre/lib/security/cacerts
-----------------------------------------

Yale CAS Server 的配置过程

CAS (Central Authentication Service)是Yale大学的ITS开发的一套JAVA实现的开源
的SSO(single sign-on)的服务。该服务是以一个java web app(eg:cas.war)来进行服务的，
使用时需要将cas.war发布到一个servlet2.3兼容的服务器上，并且服务器需要支持SSL，
在需要使用该服务的其他服务器（客户），只要进行简单的配置就可以实现SSO了。

CAS 的客户端可以有很多种，因为验证的结果是以XML的格式返回的，CAS的客户端已
打包进去的有java,perl,python,asp,apache module等好几种客户端示例，你还可以根据
需要实现一个自己的客户端，非常简单!~

下面我们以tomcat 5.0 作为CAS Server(server1)，另外一台tomcat5.0 为client(client1)
为例进行说明。

1.下载cas-server和cas-client(可选，建议使用）
http://www.yale.edu/tp/cas/cas-server-2.0.12.zip
http://www.yale.edu/tp/cas/cas-client-2.0.11.zip

2.将cas-server-2.0.12.zip解压，并将lib/cas.war拷贝到server1的webapps下

3.产生SERVER的证书
keytool -genkey -alias my-alias-name -keyalg RSA -keystore keystore-file

4.在server1配置tomcat使用HTTPS

$CATALINA_HOME/conf/server.xml里

<Connector className="org.apache.coyote.tomcat5.CoyoteConnector"
port="8443" minProcessors="5" maxProcessors="75"
enableLookups="true" disableUploadTimeout="true"
acceptCount="100" debug="0" scheme="https"
secure="true">
<Factory className="org.apache.coyote.tomcat5.CoyoteServerSocketFactory"
keystoreFile="/path/to/your/keystore-file"
keystorePass="your-password" clientAuth="false" protocol="TLS" />
</Connector>

5.在要使用CAS的客户端client1里设置（以servlets-examples这个APP为例），我们使用
ServletFilter(CAS client里提供的)来实现SSO的检查。

修改servlets-examples/WEB-INF/web.xml

<filter>
<filter-name>CASFilter</filter-name>
<filter-class>edu.yale.its.tp.cas.client.filter.CASFilter</filter-class>
<init-param>
<param-name>edu.yale.its.tp.cas.client.filter.loginUrl</param-name>
<param-value>https://your.cas.server.name(eg:server1):port/cas/login</param-value>
</init-param>
<init-param>
<param-name>edu.yale.its.tp.cas.client.filter.validateUrl</param-name>
<param-value>https://your.cas.server.name(eg:server1):port/cas/proxyValidate</param-value>
</init-param>

<init-param>
<param-name>edu.yale.its.tp.cas.client.filter.serverName</param-name>
<param-value>your.client.server.name(eg:client1):port</param-value>
</init-param>

</filter>

<filter-mapping>
<filter-name>CASFilter</filter-name>
<url-pattern>/servlet/*</url-pattern>
</filter-mapping>

6.将cas-client-2.0.11.zip解压，把java/lib/casclient.jar拷贝到client1服务器上的
webapps/servlets-examples/WEB-INF/lib目录下（如果没有就建一个）

7.导出SERVER的证书，用来给所有需要用到的客户端导入
keytool -export -file myserver.cert -alias my-alias-name -keystore keystore-file

8.在客户端的JVM里导入信任的SERVER的证书(根据情况有可能需要管理员权限)
keytool -import -keystore $JAVA_HOME/jre/lib/security/cacerts -file myserver.cert -alias my-alias-name

9.test & done.
把server1和client1分别起来，检查启动的LOG是否正常，如果一切OK，就访问
http://client1:8080/servlets-examples/servlet/HelloWorldExample
系统会自动跳转到一个验证页面，随便输入一个相同的账号,密码，严正通过之后就会访问
到真正的HelloWorldExample这个servlet了

更多信息请参考
http://www.yale.edu/tp/cas/
http://www-106.ibm.com/developerworks/web/library/wa-singlesign/
 

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1558776

首先需要做以下准备工作

 1、安装好 Tomcat 和 IIS6 ，并且都能正常运行

 2、Tomcat的端口没做任何修改

 3、下载好 集成需要的 isapi_redirector2.dll 文件

    http://archive.apache.org/dist/tomcat/tomcat-connectors/jk2/binaries/win32/jakarta-tomcat-connectors-jk2.0.4-win32-IIS.zip 

集成步骤

 1、配置环境变量 JAVA_HOME 和 TOMCAT_HOME

 2、将 isapi_redirector2.dll 文件拷贝到 TOMCAT_HOME 中的任意一个目录中，如：TOMCAT_HOME/iis 此目录需要新建

 3、新建一个目录存放站点，如：d:"web 并在其中新建一个 ROOT 目录，此目录作为站点的默认起始目录

 4、打开 IIS 控制台，新建一个站点，如果自己有域名的话可以在主机头中输入自己的域名，

     如： www.oksonic.cn 这样就不会和原来的默认网站冲突了，现在需要将默认网关停止后再新建

 5、新建一个虚拟目录，名称为：jakarta 这个名称不能改变，路径为 TOMCAT_HOME/iis ，也就是放 dll 文件的 目录

     打开站点属性窗口，进入 ISAPI 筛选器，点击添加铵钮，在筛选器名称中输入 jakarta ，这个名字也不能修改，所以要注意是否正确，

     在可执行文件中选择 TOMCAT_HOME/iis/isapi_redirector2.dll 文件

     进入主目录选项卡，在弹出窗口中选择添加，这里对 jsp 文件和 struts 的 do 访问方式进行映射配置，点击添加铵钮，

     可执行文件选择 TOMCAT_HOME/iis/isapi_redirector2.dll ，扩展名为 jsp ，同样对 do 也进行配置

 6、新增一个 Web 服务扩展，扩展名随意填，如： Tomcat ，要求的文件选择 TOMCAT_HOME/iis/isapi_redirector2.dll ，

     选中设置扩展状态为充许项，然后确定

 7、拷贝 jk2.properties 、 workers2.properties 两个文件到 TOMCAT_HOME/conf 目录中

jk2.properties 文件内容如下：

request.tomcatAuthentication=false

workers2.properties 文件内容如下：( 以下第二行的文件路径需要根据自己的配置进行修改 )

[shm]

file= d:/Tomcat/logs/jk2.log

size=1048576

# Example socket channel, override port and host.

[channel.socket:localhost:8009]

port=8009

host=127.0.0.1

# define the worker

[ajp13:localhost:8009]

channel=channel.socket:localhost:8009

# Uri mapping

[uri:/*.jsp]

[uri:/*.do]

[uri:/do/*]

worker=ajp13:localhost:8009

# define the worker

[status:status]

# Uri mapping

[uri:/jkstatus/*]

worker=status:status

注意 # Uri mapping 部份，现在已经开通了对jsp文件和struts的两种访问方式，如果还有其它的文件访问需要转到Tomcat来处理的话都在此进行配置

 8、现打开注册表文件， 修改绿色字体部份，注意路径表示符

文件内容如下：

Windows Registry Editor Version 5.00

[HKEY_LOCAL_MACHINE"SOFTWARE"Apache Software Foundation"Jakarta Isapi Redirector"2.0]

"serverRoot"=" D:""Tomcat "

"extensionUri"="/jakarta/isapi_redirector2.dll"

"workersFile"=" D:""Tomcat""conf""workers2.properties "

"logLevel"="DEBUG"

    修改完成后将导入注册表（双击此文件）

 9、修改 tomcat 的配置文件 server.xml

    使用以下内容替换原来的 <host>...</host> 内容， 绿色字体为需要修改的内容

<Host name=" localhost " debug="0" appBase=" d:"web " unpackWARs="true" autoDeploy="true">

       <Logger className="org.apache.catalina.logger.FileLogger" directory="logs" prefix=" oksonic_log. " suffix=".txt" timestamp="true"/>

       <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs" prefix=" oksonic_access_log. " suffix=".txt" pattern="common" resolveHosts="false"/>

    </Host>

 拷贝 Tomcat_Home/webapps/ROOT 下的文件到 web/ROOT 中

重启IIS和Tomcat服务

   打开浏览器输入 http://localhost/index.jsp 进行测试，正常的话可以显示 Tomcat 默认的首页

   这时再进入到 IIS 的管理工具中查看ISAPI筛选器，这时应该显示一个绿色向上的箭头，如果没有绿色箭头的话应该是有一个红色的向下的箭头，这表明是配置有问题，请检查，如果一个箭头也没有的话应该是没有使用浏览进行测试，只要有一遍测试的话就应该有箭头了

   这里配置完成后有一个问题，就是无法使用 http://localhost 直接打开 index.jsp ，

   即使是配置了IIS6的默认首页也不行，我采用的方法是使用一个 index.htm 文件来进行跳转，文件内容如下：

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

"http://www.w3.org/TR/html4/loose.dtd";>

<html>

<head>

<meta http-equiv="refresh" content="0; url=/index.jsp">

</head>

<body>

</body>

</html>

整个配置基本完成，现在需要解决乱码的问题，如果有遇到乱码问题的话

这里使用的全是 UTF-8

在项目中要使用 UTF-8 的编码，并配置了过滤器，过滤编码也是 UTF-8

修改 Tomcat 的配置文件 server.xml ，在端器配置的地方加入 URIEncoding="UTF-8"

如：

<Connector URIEncoding="UTF-8"

port="8080"               maxHttpHeaderSize="8192"

               maxThreads="150" minSpareThreads="25" maxSpareThreads="75"

               enableLookups="false" redirectPort="8443" acceptCount="100"

               connectionTimeout="20000" disableUploadTimeout="true" />

这里是Tomcat使用的编码，还要配置集成时使用的编码，因为集成时使用的端口为 8009 所以在配置8009端口的地方也要加入 URIEncoding="UTF-8"

如：

<Connector URIEncoding="UTF-8"

port="8009"

               enableLookups="false" redirectPort="8443" protocol="AJP/1.3" />

好了，重启 IIS 服务和 Tomcat 服务，整个集成工作就完成了

在这里我无法对乱码问题进行测试，这是我在开发时所发现并已经解决的方法，希望对大家有用。

整合步骤：

1、 确保IIS和Tomcat能独立运行。(设Tomcat安装在D:\Tomcat5.5)

2、 为要整合进IIS的Web应用建立网站(以zjt.costnet.cn为例)

在IIS管理器左侧网站一栏新建网站zjt.costnet.cn，其目录指向要整合进IIS的Web应用，与Tomcat中部署的Web应用最好保持一致，让网站有执行(如ISAPI应用程序或CGI)的权限。

3、 为jk建立物理目录

到Apache下载Tomcat Connector JK1.2.20,在这里只需要下载isapi_redirect.dll即可。在目录D:\Tomcat5.5\bin下新建名为jakarta的目录，将isapi_redirect.dll复制过去。

4、 为jk建立虚拟目录

选中网站zjt.costnet.cn,新建虚拟目录，别名为jakarta，路径为D:\Tomcat5.5\bin\jakarta，使其有执行(如ISAPI应用程序或CGI)的权限。

5、 新建Web服务扩展
在IIS管理器左侧网站下面选中Web服务扩展，添加一个新的Web服务扩展，扩展名为jakarta,添加要求的文件为D:\Tomcat5.5\bin\jakarta\isapi_redirect.dll,并设置扩展状态为允许。

6、 设置筛选器

在网站zjt.costnet.cn上右键选择属性,在ISAPI筛选器标签页添加筛选器，名字为jakarta，路径为isapi_redirect.dll的路径名，即D:\Tomcat5.5\bin\jakarta\isapi_redirect.dll。重新进入属性页，如果成功则该新建的筛选器会有一个绿色向上箭头，优先级为高，这说明jk模块加载成功。

7、 在网站zjt.costnet.cn上右键选择属性-主目录-配置-映射-添加-可执行文件D:\Tomcat5.5\bin\jakarta\isapi_redirect.dll,扩展名：.jsp.

8、 为IIS写注册表

新建文本文件,输入以下内容,保存并更名为jakarta.reg文件,双击导入注册表

Windows Registry Editor Version 5.00

[HKEY_LOCAL_MACHINE"SOFTWARE"Apache Software Foundation]

[HKEY_LOCAL_MACHINE"SOFTWARE"Apache Software Foundation"Jakarta Isapi Redirector]

[HKEY_LOCAL_MACHINE"SOFTWARE"Apache Software Foundation"Jakarta Isapi Redirector"1.0]

"extension_uri"="/jakarta/isapi_redirect.dll"

"worker_file"=" D:\\Tomcat5.5\\conf\\workers.properties"

"worker_mount_file"=" D:\\Tomcat5.5\\conf\\uriworkermap.properties"

"log_file"=" D:\\Tomcat5.5\\logs\\isapi.log"

"log_level"="info"

 9、建立配置文件

按照注册表里所写的，在D:\\Tomcat5.5\\conf目录下建立两个配置文件，workers.properties和uriworkermap.properties其内容分别为:

========================================================================

workers.properties的内容：

========================================================================

worker.list=ajp13

worker.ajp13.type=ajp13

worker.ajp13.host=zjt.costnet.cn

worker.ajp13.port=8009

========================================================================

uriworkermap.properties的内容：

=========================================================================

/*.jsp=ajp13

/*.do=ajp13

10、测试
在此提供详细文档和相关文件打包下载：IIS与Tomcat的整合