上一篇文章我介绍了在Java EE环境中配置Shiro的基本方法, 但是在真正的开发过程中我们基本上不
会使用基于配置文件的用户角色配置, 大多数情况下我们会将用户, 角色和权限存储在数据库中, 然后我们告诉Shiro去数据库中取数据, 这样的配置更灵活且功能更强大.
这样使Shiro能读数据库(或LDAP, 文件系统等)的组件叫做Realm, 可以把Realm看作是一个安全专用的DAO, 下面我详细介绍一下如何配置Realm:
(所用到的技术和上一篇文章中的类似, 此外, 我们用到了JPA, 项目源码参考我的Github)
添加依赖
在上一篇文章所用的依赖基础上, 我们还需要添加:
<dependency>
<groupId>org.hibernate.javax.persistence</groupId>
<artifactId>hibernate-jpa-2.1-api</artifactId>
<version>1.0.0.Final</version>
</dependency>
<dependency>
<groupId>org.jboss.spec.javax.ejb</groupId>
<artifactId>jboss-ejb-api_3.2_spec</artifactId>
<version>1.0.0.Final</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.7</version>
</dependency>
添加用户等实体
ER图
这里我将用户(User), 角色(Role), 权限(Permission)的关系定义为:
为简单起见, ER图省略了表的字段, 这里仅说明表之间的关系: 一个用户可以有多个角色, 一个角色有多个权限.
JPA实体
src/main/java/com/github/holyloop/entity/User.java:
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(unique = true, nullable = false)
private Long id;
@Column(nullable = false, unique = true)
private String username;
@Column(nullable = false)
private String password;
@Column(nullable = false)
private String salt;
@OneToMany(mappedBy = "user")
private Set<UserRoleRel> userRoleRels = new HashSet<>(0);
这里的 password 为密文密码, salt 为哈希加密用到的盐, 我们让每个用户都有一个随机盐.
src/main/java/com/github/holyloop/entity/Role.java:
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(unique = true, nullable = false)
private Long id;
@Column(name = "role_name", nullable = false, unique = true)
private String roleName;
@OneToMany(mappedBy = "role")
private Set<UserRoleRel> userRoleRels = new HashSet<>(0);
@OneToMany(mappedBy = "role")
private Set<RolePermissionRel> rolePermissionRels = new HashSet<>(0);
roleName 如名字所述, 为权限名.
src/main/java/com/github/holyloop/entity/Permission.java:
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(unique = true, nullable = false)
private Long id;
@Column(name = "permission_str", nullable = false)
private String permissionStr;
permissionStr 为权限字符串, 我一般偏爱将权限字符串定义为 resource-type:operation:instance , 意为操作(operation)资源(resource-type)实例(instance)的权限, 例如: org:update:1 即为"更新id为1的组织"权限. 这种组织权限的方式较灵活, 能精确到资源实例, 在对权限要求教高的系统中可以使用这种方式, 一般对于权限不要求精确到资源实例的系统用传统的RBAC即可满足要求. 关于权限的详细定义可参考Shiro的这个文档.
剩下的两个中间关系表较简单, 这里不详细说明.
修改shiro.ini
src/main/webapp/WEB-INF/shiro.ini:
[main]
authc.loginUrl = /login
credentialsMatcher = org.apache.shiro.authc.credential.Sha256CredentialsMatcher
credentialsMatcher.storedCredentialsHexEncoded = false
credentialsMatcher.hashIterations = 1024
dbRealm = com.github.holyloop.secure.shiro.realm.DBRealm
dbRealm.credentialsMatcher = $credentialsMatcher
securityManager.realms = $dbRealm
[urls]
/index.html = anon
/login = authc
比较之前的配置, 我删掉了 [users] 和 [roles] 块, 因为这些数据我们将从数据库中加载. 此外, 我配置了Shiro的密码匹配器 credentialsMatcher , 它将用sha256来做密码匹配; 然后还有我们这篇文章的重点 dbRealm , 这个Realm将由我们自己来实现.
实现Realm
我们的 DBRealm 将继承AuthorizingRealm, 然后覆盖它的 doGetAuthorizationInfo 和 doGetAuthenticationInfo 方法, 这两个方法分别用来获取权限信息和认证信息:
src/main/java/com/github/holyloop/secure/shiro/realm/DBRealm.java:
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
String username = StringUtils.trim((String) principals.getPrimaryPrincipal());
Set<String> roles = userService.listRolesByUsername(username);
Set<String> permissions = userService.listPermissionsByUsername(username);
SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
authorizationInfo.setRoles(roles);
authorizationInfo.setStringPermissions(permissions);
return authorizationInfo;
}
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
String username = StringUtils.trim((String) token.getPrincipal());
if (StringUtils.isEmpty(username)) {
throw new AuthenticationException();
}
User user = userService.getOneByUsername(username);
if (user == null) {
throw new AuthenticationException();
}
SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(
username,
user.getPassword(),
new SimpleByteSource(Base64.decode(user.getSalt())),
getName());
return authenticationInfo;
}
doGetAuthorizationInfo 将加载用户的角色和权限数据, doGetAuthenticationInfo 根据用户输入的口令查找对应用户的认证数据(密文密码+盐).
此外, 这两个方法都用到了 UserService , 它的实现比较简单, 如 getOneByUsername :
public User getOneByUsername(String username) {
if (StringUtils.isEmpty(username)) {
throw new IllegalArgumentException("username must not be null");
}
try {
return userRepository.getOneByUsername(username);
} catch (NoResultException e) {
return null;
}
}
UserService 则依赖 UserRepository , 它是基于JPA的数据库访问接口, 具体的实现细节可以参考我的Github上的源码.
添加用户
到上面为止, 用户认证及鉴权的部分已经基本完成了. 但只有鉴权功能对一个系统来说是不完整的, 我们还需要能添加新的用户. 我们给 UserService 添加一个添加新用户的接口:
public void addUser(UserDTO user) throws UsernameExistedException {
if (user == null) {
throw new IllegalArgumentException("user must not be null");
}
try {
User duplicateUser = userRepository.getOneByUsername(user.getUsername());
if (duplicateUser != null) {
throw new UsernameExistedException();
}
} catch (NoResultException e) {}
TwoTuple<String, String> hashAndSalt = CredentialEncrypter.saltedHash(user.getPassword());
User entity = new User();
entity.setUsername(user.getUsername());
entity.setPassword(hashAndSalt.t1);
entity.setSalt(hashAndSalt.t2);
userRepository.save(entity);
}
UsernameExistedException 如该异常名所描述, 当新用户输入的用户名与已有的用户重复时抛出该异常. UserDTO 结构如下:
src/main/java/com/github/holyloop/dto/UserDTO.java :
private String username;
private String password;
这里我将它定义得很简单, 实际项目开发时它肯定会有更多的属性, 比如邮箱, 生日, 手机号等等.
此外很重要的一个功能是密码加密, 这里我实现了 CredentialEncrypter 这个加密器:
src/main/java/com/github/holyloop/secure/shiro/util/CredentialEncrypter.java :
private static RandomNumberGenerator rng = new SecureRandomNumberGenerator();
/**
* hash + salt
*
* @param plainTextPassword
* 明文密码
* @return
*/
public static TwoTuple<String, String> saltedHash(String plainTextPassword) {
if (StringUtils.isEmpty(plainTextPassword)) {
throw new IllegalArgumentException("plainTextPassword must not be null");
}
Object salt = rng.nextBytes();
String hash = new Sha256Hash(plainTextPassword, salt, 1024).toBase64();
return new TwoTuple<>(hash, salt.toString());
}
为了更高的安全性, 我们为每个用户都生成一个随机盐 RandomNumberGenerator , saltedHash 将明文密码和随机盐Sha256加密然后base64编码. 方法将返回密文密码和随机盐.
到这里, 整个系统的加密和解密功能就算基本完成了, 接下来我们进行一个简单的应用.
基本应用
添加REST接口
这里我们实现一个添加新用户的接口:
src/main/java/com/github/holyloop/rest/controller/UserController.java:
@RequiresPermissions("user:insert")
@POST
@Consumes(MediaType.APPLICATION_JSON)
@Produces(MediaType.APPLICATION_JSON)
public Response addUser(UserDTO user) {
if (user == null || StringUtils.isEmpty(user.getUsername()) || StringUtils.isEmpty(user.getPassword())) {
return Response.status(Status.BAD_REQUEST).entity("username or password must not be null").build();
}
user.setUsername(StringUtils.trim(user.getUsername()));
user.setPassword(StringUtils.trim(user.getPassword()));
try {
userService.addUser(user);
} catch (UsernameExistedException e) {
return Response.status(Status.BAD_REQUEST).entity("username existed").build();
}
return Response.status(Status.OK).build();
}
我这里以jax-rs的风格实现了这个接口, 实现逻辑很简单: 校验用户输入是否合法, 合法则调用 UserService.addUser() 添加该用户, 添加成功时返回200; 需要注意的是我在该接口上添加一个 @RequiresPermissions("user:insert") 注解, 这个注解说明接口的调用者需要有 user-insert 的权限.
部署测试
接下来我们将应用部署并用curl进行几个简单的测试.
- 测试定义的
@RequiresPermissions("user:insert")权限要求:
curl -i -d "username=guest&password=guest" -c cookies "localhost:8080/shiro-db/login"
curl -i -X POST -H "content-type:application/json" -b cookies \\
> -d \'{"username":"newuser", "password":"123"}\' \\
> localhost:8080/shiro-db/api/user
这里我以guest用户登录, 该用户没有 "user:insert" 的权限, 可以看到请求添加用户接口响应为403, :
然后换一个拥有 "user:insert" 权限的用户登录:
curl -i -d "username=root&password=secret" -c cookies "localhost:8080/shiro-db/login"
curl -i -X POST -H "content-type:application/json" -b cookies \\
> -d \'{"username":"newuser", "password":"123"}\' \\
> localhost:8080/shiro-db/api/user
可以看到响应为200, 然后我们去数据库中看一下有没有新添加的 "newuser" 用户:
可以看到用户添加成功, 并且密码为密文存储
- 测试新用户登录
curl -i -d "username=newuser&password=123" -c cookies "localhost:8080/shiro-db/login"
登录成功.
- 重复添加该新用户
我们在添加用户的逻辑里面定义了如果用户名重复, 则新用户应添加失败:
如我们所期望的, 服务器响应为400并提示我们"username existed".
以上就是Shiro基于数据库的用户,角色,权限配置的方法, 核心的地方在于Realm的配置, Realm负责获取用户的认证和鉴权信息; 为了提高认证信息的存储安全性, 我们还进行了密码的加密处理(对于一个完备的系统来说这必不可少); 对于规模稍大的系统来说, 纯基于数据库的认证/鉴权机制是不够的, 为了提高效率还需要添加一些缓存机制, 这篇文章暂时说到这里, 关于缓存, 我们后面再聊.