在上一节中我们使用了CAS的提供的JDBC 方式的登录认证，基本上能够满足我们多种需求的认证。
但是如果CAS框架提供的方案还是不能满足我们的需要，比如我们不仅需要用户名和密码，还要验证其他信息，比如邮箱，手机号，但是邮箱，手机信息在另一个数据库，还有在一段时间内同一IP输入错误次数限制等。这里就需要我们自定义认证策略，自定义CAS的web认证流程。
自定义认证校验策略
我们知道CAS为我们提供了多种认证数据源，我们可以选择JDBC、File、JSON等多种方式，但是如果我想在自己的认证方式中可以根据提交的信息实现不同数据源选择，这种方式就需要我们去实现自定义认证。
自定义策略主要通过现实更改CAS配置，通过AuthenticationHandler在CAS中设计和注册自定义身份验证策略，拦截数据源达到目的。
主要分为下面三个步骤：
- 设计自己的认证处理数据的程序
- 注册认证拦截器到CAS的认证引擎中
- 更改认证配置到CAS中
首先我们还是添加需要的依赖库：
<!-- Custom Authentication -->
<dependency>
<groupId>org.apereo.cas</groupId>
<artifactId>cas-server-core-authentication-api</artifactId>
<version>${cas.version}</version>
</dependency>
<!-- Custom Configuration -->
<dependency>
<groupId>org.apereo.cas</groupId>
<artifactId>cas-server-core-configuration-api</artifactId>
<version>${cas.version}</version>
</dependency>
<!-- SpringSecurity Core -->
<dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-core</artifactId>
<version>5.0.8.RELEASE</version>
</dependency>
如果我们认证的方式仅仅是传统的用户名和密码，实现AbstractUsernamePasswordAuthenticationHandler这个抽象类就可以了，官方
给的实例也是这个。
在编写自定义认证类之前，我们这里说明下为什么选择使用springSecurity提供的加解密工具类:
BCryptPasswordEncoder
BCryptPasswordEncoder相关知识：
用户表的密码通常使用MD5等不可逆算法加密后存储，为防止彩虹表破解更会先使用一个特定的字符串（如域名）加密，然后再使用一个随机的salt（盐值）加密。
特定字符串是程序代码中固定的，salt是每个密码单独随机，一般给用户表加一个字段单独存储，比较麻烦。
BCrypt算法将salt随机并混入最终加密后的密码，验证时也无需单独提供之前的salt，从而无需单独处理salt问题。
补充说明：即使不同的用户注册时输入相同的密码，存入数据库的密文密码也会不同。
官方的实例有一个坑，给出的是5.2.x版本以前的例子，5.3.x版本后的jar包更改了，而且有个地方有坑，在5.2.x版本前的可以，新的5.3.x是不行的。
注意：这里试了很多版本最后 5.3.9这个版本没问题
接着我们自定义我们自己的实现类CustomUsernamePasswordAuthentication，如下：
package com.thtf.cas.config;
import com.thtf.cas.model.User;
import com.thtf.cas.util.SpringSecurityUtil;
import org.apereo.cas.authentication.AuthenticationHandlerExecutionResult;
import org.apereo.cas.authentication.MessageDescriptor;
import org.apereo.cas.authentication.PreventedException;
import org.apereo.cas.authentication.UsernamePasswordCredential;
import org.apereo.cas.authentication.handler.support.AbstractUsernamePasswordAuthenticationHandler;
import org.apereo.cas.authentication.principal.PrincipalFactory;
import org.apereo.cas.services.ServicesManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import javax.security.auth.login.AccountException;
import javax.security.auth.login.FailedLoginException;
import java.security.GeneralSecurityException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
/**
* ========================
* 自定义认证校验策略
* Created with IntelliJ IDEA.
* User：pyy
* Date：2019/6/26
* Time：16:05
* Version: v1.0
* ========================
*/
public class CustomUsernamePasswordAuthentication extends AbstractUsernamePasswordAuthenticationHandler {
private final static Logger logger = LoggerFactory.getLogger(CustomUsernamePasswordAuthentication.class);
private JdbcTemplate jdbcTemplate;
public CustomUsernamePasswordAuthentication(String name, ServicesManager servicesManager,
PrincipalFactory principalFactory, Integer order, JdbcTemplate jdbcTemplate) {
super(name, servicesManager, principalFactory, order);
this.jdbcTemplate = jdbcTemplate;
}
@Override
protected AuthenticationHandlerExecutionResult authenticateUsernamePasswordInternal(
UsernamePasswordCredential credential, String originalPassword)
throws GeneralSecurityException, PreventedException {
String username = credential.getUsername();
String password = credential.getPassword();
logger.info("认证用户 username = {}", username);
String sql = "select id, username, password, expired, disable, email FROM sys_user where username = ?";
User info = (User) jdbcTemplate.queryForObject(sql, new Object[]{username}, new BeanPropertyRowMapper(User.class));
if (info == null) {
logger.info("用户不存在！");
throw new AccountException("用户不存在!");
}
if (!SpringSecurityUtil.checkpassword(password, info.getPassword())) {
logger.info("密码错误!");
throw new FailedLoginException("密码错误!");
} else {
logger.info("校验成功");
//可自定义返回给客户端的多个属性信息
HashMap<String, Object> returnInfo = new HashMap<>();
returnInfo.put("id", info.getId());
returnInfo.put("username", info.getUsername());
returnInfo.put("expired", info.getExpired());
returnInfo.put("disable", info.getDisable());
returnInfo.put("email", info.getEmail());
final List<MessageDescriptor> list = new ArrayList<>();
return createHandlerResult(credential, this.principalFactory.createPrincipal(username, returnInfo), list);
}
}
}
这里给出的与官方实例不同在两个地方:
- 返回的为
AuthenticationHandlerExecutionResult而不是HandlerResult，其实源码是一样的，在新版本重新命名了而已。 -
createHandlerResult传入的warings不能为null，不然程序运行后提交信息始终无法认证成功！！！
代码主要通过拦截传入的Credential，获取用户名和密码，然后再自定义返回给客户端的用户信息。这里便可以通过代码方式自定义返回给客户端多个不同属性信息。
注入配置信息
继承AuthenticationEventExecutionPlanConfigurer
package com.thtf.cas.config;
import org.apereo.cas.authentication.AuthenticationEventExecutionPlan;
import org.apereo.cas.authentication.AuthenticationEventExecutionPlanConfigurer;
import org.apereo.cas.authentication.AuthenticationHandler;
import org.apereo.cas.authentication.principal.DefaultPrincipalFactory;
import org.apereo.cas.configuration.CasConfigurationProperties;
import org.apereo.cas.services.ServicesManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
@Configuration("CustomAuthenticationConfiguration")
@EnableConfigurationProperties({CasConfigurationProperties.class, DataBaseProperties.class})
public class CustomAuthenticationConfiguration implements AuthenticationEventExecutionPlanConfigurer {
@Autowired
private DataBaseProperties databaseProperties;
@Autowired
private JdbcTemplate jdbcTemplate;
@Autowired
private CasConfigurationProperties casProperties;
@Autowired
@Qualifier("servicesManager")
private ServicesManager servicesManager;
@Bean
public AuthenticationHandler myAuthenticationHandler() {
return new CustomUsernamePasswordAuthentication(CustomUsernamePasswordAuthentication.class.getName(), servicesManager, new DefaultPrincipalFactory(), 1, jdbcTemplate);
}
@Override
public void configureAuthenticationExecutionPlan(AuthenticationEventExecutionPlan plan) {
plan.registerAuthenticationHandler(myAuthenticationHandler());
}
@Bean
public JdbcTemplate jdbcTemplate(){
// JDBC模板依赖于连接池来获得数据的连接，所以必须先要构造连接池
DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setDriverClassName(databaseProperties.getDriverClass());
dataSource.setUrl(databaseProperties.getUrl());
dataSource.setUsername(databaseProperties.getUser());
dataSource.setPassword(databaseProperties.getPassword());
// 创建JDBC模板
JdbcTemplate jdbcTemplate = new JdbcTemplate();
jdbcTemplate.setDataSource(dataSource);
return jdbcTemplate;
}
}
这里涉及到JdbcTemplate数据源配置如下：
数据源配置：
########## 用户认证JDBC数据源配置 ############
sso.jdbc.user=root
sso.jdbc.password=123456
sso.jdbc.driverClass=com.mysql.jdbc.Driver
sso.jdbc.url=jdbc:mysql://localhost:3306/sso?characterEncoding=utf8
DataBaseProperties:
package com.thtf.cas.config;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
import java.io.Serializable;
@Component
@ConfigurationProperties(prefix = "sso.jdbc")
@Data
public class DataBaseProperties implements Serializable {
private String user;
private String password;
private String driverClass;
private String url;
}
最后我们我们在src/main/resources目录下新建META-INF目录，同时在下面新建spring.factories文件，将配置指定为我们自己新建的信息。
启动应用，输入用户名和密码，查看控制台我们打印的信息，可以发现我们从登陆页面提交的数据以及从数据库中查询到的数据，匹配信息，登录认证成功！！
从而现实了我们自定义用户名和密码的校验，同时我们还可以选择不同的数据源方式。
补充
可能还有读者提出疑问，我提交的信息不止用户名和密码，那该如何自定义认证？
这里就要我们继承AbstractPreAndPostProcessingAuthenticationHandler这个借口，其实上面的AbstractUsernamePasswordAuthenticationHandler就是继承实现的这个类，它只是用于简单的用户名和密码的校验。我们可以查看源码，如下：
自定义实现：参看https://blog.csdn.net/yelllowcong/article/details/79236360
