Authentication
Authentication是指身份验证的过程:即在应用中能证明他就是他本人.一般需要提供身份标识信息例如:ID,用户名/密码等. 在Shiro中,用户需要提供Principals和Credentials给Shiro,从而来验证用户的身份.
Principals: 身份,即是Subject的标识属性,可以是任何东西,诸如用户名、邮箱等,唯一即可.一个主题可以有多个Principal,但是只有一个Primary principal一般是用户名/密码.
Credentials: 证明/凭据,只有主体才知道的安全值,如密码/数字证书.
principal / credential 配对最常见的就是 用户名 / 密码 .
Demo
在实际研究Shiro身份认证流程之前,先搭建一个架子,进行简单的验证.
Maven构建
添加junit、common-logging以及shiro-core等依赖.
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.lcore.shiro_01</groupId>
<artifactId>shiro_01</artifactId>
<version>0.0.1-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.9</version>
</dependency>
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.1.3</version>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-core</artifactId>
<version>1.2.2</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-nop</artifactId>
<version>1.7.5</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.25</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>0.2.23</version>
</dependency>
</dependencies>
</project>
shiro配置文件ini方式(shiro.ini)
简洁起见,这里仅仅配置一个用户名/密码(principal/credential),其他使用shiro默认配置.
[users]
#用户名及其对应的密码
L.Tao=LCore
之后编写一个简单的测试用例,shiro最简单的身份认证demo就完成了,代码如下:
@Test
public void testHello() {
// 1、通过ini文件获取securityManager工厂
Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro.ini");
// 2、得到securityManager实例,绑定SecurityUtils
SecurityManager manager = factory.getInstance();
SecurityUtils.setSecurityManager(manager);
// 3、得到Subject及创建用户名/密码身份验证Token（即用户身份/凭证）
Subject subject = SecurityUtils.getSubject();
UsernamePasswordToken token = new UsernamePasswordToken("L.Tao", "LCore");
try {
// 4、登录，即身份验证,委托给securityManager
subject.login(token);
} catch (AuthenticationException e) {
// 5、身份验证失败
e.printStackTrace();
}
Assert.assertEquals(true, subject.isAuthenticated()); // 断言用户已经登录
// 6、退出:任何现有的session会清空
subject.logout();
}
关于上述demo的执行过程,注释已经说得很明白了,需要提及的是,在调用subject.login()身份验证失败时,请捕获AuthenticationException或其子类,常见的如DisabledAccountException(禁用的账户)、LockedAccountException(锁定的账户)、UnknowAccountException(错误的账户)等,具体情况如下图:
身份认证流程
demo中可以简单的了解Shiro的认证过程,接下来从shiro内部体系结构了解其认证流程:
流程如下:
1、首先调用Subject.login()方法进行登录,内部会委托给SecurityManager,调用之前需要通过SecurityUtils.setSecurityManager()设置.
2、SecurityManager委托给Authenticator进行身份验证,Authenticator才是真正的身份验证者,也可以扩展实现自己的Authenticator.
3、Authenticator可能会委托给相应的AuthenticationStrategy进行多Realm身份验证,默认为ModularRealmAuthenticator会调用AuthenticationStrategy进行多Realm身份验证.
4、Authenticator会把相应的token传入Realm,从Realm获取身份验证信息,可以配置多个Realm,将按照相应的顺序和策略进行访问,最后完成身份认证.
阅读源码内部的的流程还是比较复杂的,大致的时序图如下:
上述只是一个大致的流程,实际情况复杂的多.
Realm
Realm:安全数据源,用于获取安全数据(用户、角色、权限规则),shiro通过SecurityManager验证用户,必须通过Realm获取相应的用户进行比较以确定用户是否合法.同样也是通过Realm得到用户相应的角色/权限控制用户的访问权限.shiro默认提供的Realm如下图:
上述图中可以知道的是,如果我们实现自定义的Realm一般继承AuthorizingRealm(授权)即可,因为其继承了AuthenticationgRealm和CachingRealm实现了身份验证和缓存.主要实现:
IniRealm: [users]部分指定其用户名/密码及其角色,[roles]部分指定其角色,权限信息.demo中就是使用的此方式.
JdbcRealm: 通过SQL查询相应的信息,其相应的sql可以查阅源码查看,也可以通过api进行自定义SQL.
仔细思考一下可以知道,在实际中我们一般不会使用shiro提供的Realm,前面也说了shiro不维护用户/权限,仅仅通过Realm进行注入.Shiro提供的Realm总归不够灵活,因此正如上述所说,一般我们通过继承AuthorizingRealm实现自定义的Realm(结合自身的dao层,获取安全数据). 接下来了解下Realm如何使用.
单Realm配置
1、 自定义Realm实现:
package com.shiro_01.realm;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.IncorrectCredentialsException;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authc.UnknownAccountException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.realm.Realm;
public class MyRealm1 implements Realm{
public String getName() {
return "myreal1";
}
public boolean supports(AuthenticationToken token) {
return token instanceof UsernamePasswordToken;
}
public AuthenticationInfo getAuthenticationInfo(AuthenticationToken token)
throws AuthenticationException {
String username = token.getPrincipal().toString();
String password = new String((char[])token.getCredentials());
System.out.println("realm1");
//自己实现验证逻辑
if(!username.equals("L.Tao")){
throw new UnknownAccountException("没有该用户");
}
if(!password.equals("LCore")){
throw new IncorrectCredentialsException("密码错误");
}
return new SimpleAuthenticationInfo(username+"1", password, getName());
}
}
2、ini配置文件指定自定义的Realm
#声明一个realm
myRealm1=com.shiro_01.realm.MyRealm1
#指定SecurityManager的realms实现
securityManager.realms=$myRealm1
通过$name来引入之前定义好的realm 3、测试代码:
public void testCustomRealm() {
// 1、获取SecurityManager工厂，此处使用Ini配置文件初始化SecurityManager
Factory<org.apache.shiro.mgt.SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro-realm.ini");
// 2、得到SecurityManager实例 并绑定给SecurityUtils
org.apache.shiro.mgt.SecurityManager securityManager = factory.getInstance();
SecurityUtils.setSecurityManager(securityManager);
// 3、得到Subject及创建用户名/密码身份验证Token（即用户身份/凭证）
Subject subject = SecurityUtils.getSubject();
UsernamePasswordToken token = new UsernamePasswordToken("L.Tao", "LCore");
try {
// 4、登录，即身份验证
subject.login(token);
} catch (AuthenticationException e) {
// 5、身份验证失败
e.printStackTrace();
}
Assert.assertEquals(true, subject.isAuthenticated()); // 断言用户已经登录
// 6、退出
subject.logout();
}
JDBC Realm
Shiro提供的JDBC Realm使用也是比较简单且较为灵活的,使用方法如下:
1、maven添加数据库驱动及druid连接池,参考上述pom.xml
2、建立测试数据库及数据表数据,建表:users、user_roles,roles_permissions,并且添加一个测试用户:
-- ----------------------------
-- Table structure for roles_permissions
-- ----------------------------
DROP TABLE IF EXISTS `roles_permissions`;
CREATE TABLE `roles_permissions` (
`id` bigint(20) NOT NULL auto_increment,
`role_name` varchar(100) default NULL,
`permission` varchar(100) default NULL,
PRIMARY KEY (`id`),
UNIQUE KEY `idx_roles_permissions` (`role_name`,`permission`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- ----------------------------
-- Records of roles_permissions
-- ----------------------------
-- ----------------------------
-- Table structure for users
-- ----------------------------
DROP TABLE IF EXISTS `users`;
CREATE TABLE `users` (
`id` bigint(20) NOT NULL auto_increment,
`username_` varchar(100) default NULL,
`password_` varchar(100) default NULL,
`password_salt` varchar(100) default NULL,
PRIMARY KEY (`id`),
UNIQUE KEY `idx_users_username` (`username_`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
-- ----------------------------
-- Records of users
-- ----------------------------
INSERT INTO `users` VALUES ('1', 'L.Tao', 'LCore', '');
-- ----------------------------
-- Table structure for user_roles
-- ----------------------------
DROP TABLE IF EXISTS `user_roles`;
CREATE TABLE `user_roles` (
`id` bigint(20) NOT NULL auto_increment,
`username` varchar(100) default NULL,
`role_name` varchar(100) default NULL,
PRIMARY KEY (`id`),
UNIQUE KEY `idx_user_roles` (`username`,`role_name`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
之前,也说过Shiro并不维护用户/权限,实际系统的表结构并不像上述的设计,只是shiro的jdbcRealm默认是上述的.不过没关系,我们可以通过相关的接口重新指定验证的SQL,后面会提及. 3、ini配置
jdbcRealm=org.apache.shiro.realm.jdbc.JdbcRealm
dataSource=com.alibaba.druid.pool.DruidDataSource
dataSource.driverClassName=com.mysql.jdbc.Driver
dataSource.url=jdbc:mysql://localhost:3306/shiro
dataSource.username=root
dataSource.password=root
jdbcRealm.dataSource=$dataSource
#权限认证sql,这里我修改了底层user表的两个字段,因此这里要自己重新指定sql,不然报错,默认的为:
#select password from users where username = ?
#同理,角色信息,权限信息也可以自己指定
jdbcRealm.authenticationQuery=select password_ from users where username_ = ?
securityManager.realms=$jdbcRealm
1、变量名=全类名 会自动创建实例
2、变量名.属性=值 自动调用相应的setter方法进行赋值
3、$变量名 引用之前的一个对象实例
4、测试代码
测试代码和上面并无太大区别,主要是初始化SecurityManager使用的配置文件不同
多Realm配置
在进行多Realm配置之前,有必要了解下,shiro是如何进行验证的,在之前的shiro验证流程图中已经了解到Subject.login()会交由DefaultSecurityManager的Authenticator进行验证authenticate().Authenticator的职责是验证用户账号,是Shiro API中身份验证的核心入口点. 跟踪源码,Authenticator还有一个ModularRealmAuthenticator实现,实际上是它委托给多个(也可以是单个)Realm进行验证,多个Realm的验证规则通过AuthenticationStrategy接口指定,阅读源码可知道,ModularRealmAuthenticator构造器默认指定的是AtleastOneSuccessfulStrategy(只要有一个Realm验证成功即可),且返回所有验证成功的认证信息. 具体来说Shiro默认提供的验证规则有如下几个:
1、FirstSuccessfulStrategy:只要有一个Realm验证成功即可,返回第一个Realm验证成功的信息,其余忽略.
2、AtLeastOneSuccessfulStrategy:只要有一个验证成功即可,返回所有验证成功的验证信息.
3、AllSuccessfulStrategy:所有Realm验证成功即可,返回所有验证成功的验证信息.
多Realm的配置也比较容易,ini配置如下:
#authenticator
authenticator=org.apache.shiro.authc.pam.ModularRealmAuthenticator
securityManager.authenticator=$authenticator
allSuccessfulStrategy=org.apache.shiro.authc.pam.AllSuccessfulStrategy
securityManager.authenticator.authenticationStrategy=$allSuccessfulStrategy
myRealm1=com.shiro_01.realm.MyRealm1
myRealm2=com.shiro_01.realm.MyRealm2
myRealm3=com.shiro_01.realm.MyRealm3
securityManager.realms=$myRealm1,$myRealm3
SecurityManager会按照realms指定的顺序进行验证,如果不指定,则会按照声明的顺序进行验证.如果显示指定顺序,声明了但是没有指定的会被忽略.上述3个自定义的Realm和之前并无太大区别,可以调整其验证规则,用于测试Shiro提供的3中验证策略.之后根据如下代码获取验证信息:
Subject subject = SecurityUtils.getSubject();
PrincipalCollection principals = subject.getPrincipals();
Shiro同样可以实现自定义的验证策略,比如我们实现一个OnlyOneAuthenticatorStrategy(只有一个验证通过才验证通过)
1、 实现OnlyOneAuthenticatorStrategy:
package com.shiro_01.strategy;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authc.pam.AbstractAuthenticationStrategy;
import org.apache.shiro.realm.Realm;
import org.apache.shiro.util.CollectionUtils;
import java.util.Collection;
public class OnlyOneAuthenticatorStrategy extends AbstractAuthenticationStrategy {
//所有Realm验证之前
@Override
public AuthenticationInfo beforeAllAttempts(Collection<? extends Realm> realms, AuthenticationToken token)
throws AuthenticationException {
return new SimpleAuthenticationInfo();//返回一个权限的认证信息
}
//每个Realm验证之前
@Override
public AuthenticationInfo beforeAttempt(Realm realm, AuthenticationToken token, AuthenticationInfo aggregate)
throws AuthenticationException {
return aggregate;//返回之前合并的
}
//每个Realm验证之后
@Override
public AuthenticationInfo afterAttempt(Realm realm, AuthenticationToken token,
AuthenticationInfo singleRealmInfo, AuthenticationInfo aggregateInfo, Throwable t)
throws AuthenticationException {
AuthenticationInfo info;
if (singleRealmInfo == null) {
info = aggregateInfo;
} else {
if (aggregateInfo == null) {
info = singleRealmInfo;
} else {
info = merge(singleRealmInfo, aggregateInfo);
if(info.getPrincipals().getRealmNames().size() != 1) {
throw new AuthenticationException("只能有一个验证通过");
}
}
}
return info;
}
//所有realm验证之后
@Override
public AuthenticationInfo afterAllAttempts(AuthenticationToken token, AuthenticationInfo aggregate)
throws AuthenticationException {
return aggregate;
}
}
根据策略,我们需要在每次验证之后,合并验证信息,只要验证信息不等于1(都没有通过/通过多于1次)即是验证失败.之后在ini配置文件中,手动指定验证策略即可 具体就不在测试了,到此,Shiro身份验证OVER了!