浅谈Shiro框架中的加密算法，以及校验

时间  2019-11-30
标签 浅谈 shiro 框架 加密 算法 以及 校验 繁體版
原文   原文链接

在涉及到密码存储问题上，应该加密/生成密码摘要存储，而不是存储明文密码。为何要加密：网络安全问题是一个很大的隐患，用户数据泄露事件层出不穷，好比12306帐号泄露。java

 

Shiro提供了base64和16进制字符串编码/解码的API支持，方便一些编码解码操做，想了解本身百度API操做用法。mysql

 

看一张图，了解Shiro提供的加密算法：算法

 

 

 

本文重点讲shiro提供的第二种：不可逆加密。spring

        散列算法通常用于生成数据的摘要信息，是一种不可逆的算法，通常适合存储密码之类的数据，常见的散列算法如MD五、SHA等。通常进行散列时最好提供一salt（盐），好比加密密码“admin”，产生的散列值是“21232f297a57a5a743894a0e4a801fc3”，能够到一些md5解密网站很容易的经过散列值获得密码“admin”，即若是直接对密码进行散列相对来讲破解更容易，此时咱们能够加一些只有系统知道的干扰数据，如用户名和ID（即盐）；这样散列的对象是“密码+用户名+ID”，这样生成的散列值相对来讲更难破解。sql

 

常见的算法有：MD5，SHA算法：数据库

        MD5算法是1991年发布的一项数字签名加密算法，它当时解决了MD4算法的安全性缺陷，成为应用很是普遍的一种算法。做为Hash函数的一个应用实例。apache

        SHA诞生于1993年，全称是安全散列算法(Secure Hash Algorithm)，由美国国家安全局(NSA)设计，以后被美国标准与技术研究院(NIST)收录到美国的联邦信息处理标准(FIPS)中，成为美国国家标准，SHA(后来被称做SHA-0)于1995被SHA-1(RFC3174)替代。SHA-1生成长度为160bit的摘要信息串，虽然以后又出现了SHA-22四、SHA-25六、SHA-384和SHA-512等被统称为“SHA-2”的系列算法，但仍以SHA-1为主流。安全

 

数据库User设计：网络

  1. CREATE TABLE `sys_users` (
  2. `id` bigint(20) NOT NULL AUTO_INCREMENT,
  3. `username` varchar(100) DEFAULT NULL,
  4. `password` varchar(100) DEFAULT NULL,
  5. `salt` varchar(100) DEFAULT NULL,
  6. `locked` tinyint(1) DEFAULT '0',
  7. PRIMARY KEY (`id`),
  8. UNIQUE KEY `idx_sys_users_username` (`username`)
  9. ) ENGINE=InnoDB AUTO_INCREMENT=94 DEFAULT CHARSET=utf8;
  10.  
  11.  
  12. 说明：id主键字段
  13. username 登陆的用户名
  14. passowrd 登陆的密码
  15. salt 盐
  16. locked 锁定 默认为0(false)表示没有锁


用户表User：app

 

  1. package com.lgy.model;
  2.  
  3. import org.springframework.util.CollectionUtils;
  4. import org.springframework.util.StringUtils;
  5.  
  6. import java.io.Serializable;
  7. import java.util.ArrayList;
  8. import java.util.List;
  9.  
  10. public class User implements Serializable {
  11. private static final long serialVersionUID = -651040446077267878L;
  12.  
  13. private Long id; //编号
  14. private Long organizationId; //所属公司
  15. private String username; //用户名
  16. private String password; //密码
  17. private String salt; //加密密码的盐
  18. private List<Long> roleIds; //拥有的角色列表
  19. private Boolean locked = Boolean.FALSE;
  20.  
  21. public User() {
  22. }
  23.  
  24. public User(String username, String password) {
  25. this.username = username;
  26. this.password = password;
  27. }
  28.  
  29. public Long getId() {
  30. return id;
  31. }
  32.  
  33. public void setId(Long id) {
  34. this.id = id;
  35. }
  36.  
  37. public Long getOrganizationId() {
  38. return organizationId;
  39. }
  40.  
  41. public void setOrganizationId(Long organizationId) {
  42. this.organizationId = organizationId;
  43. }
  44.  
  45. public String getUsername() {
  46. return username;
  47. }
  48.  
  49. public void setUsername(String username) {
  50. this.username = username;
  51. }
  52.  
  53. public String getPassword() {
  54. return password;
  55. }
  56.  
  57. public void setPassword(String password) {
  58. this.password = password;
  59. }
  60.  
  61. public String getSalt() {
  62. return salt;
  63. }
  64.  
  65. public void setSalt(String salt) {
  66. this.salt = salt;
  67. }
  68.  
  69. //证书凭证
  70. public String getCredentialsSalt() {
  71. return username + salt;
  72. }
  73.  
  74. public List<Long> getRoleIds() {
  75. if(roleIds == null) {
  76. roleIds = new ArrayList< Long>();
  77. }
  78. return roleIds;
  79. }
  80.  
  81. public void setRoleIds(List<Long> roleIds) {
  82. this.roleIds = roleIds;
  83. }
  84.  
  85.  
  86. public String getRoleIdsStr() {
  87. if(CollectionUtils.isEmpty(roleIds)) {
  88. return "";
  89. }
  90. StringBuilder s = new StringBuilder();
  91. for(Long roleId : roleIds) {
  92. s.append(roleId);
  93. s.append( ",");
  94. }
  95. return s.toString();
  96. }
  97.  
  98. public void setRoleIdsStr(String roleIdsStr) {
  99. if(StringUtils.isEmpty(roleIdsStr)) {
  100. return;
  101. }
  102. String[] roleIdStrs = roleIdsStr.split( ",");
  103. for(String roleIdStr : roleIdStrs) {
  104. if(StringUtils.isEmpty(roleIdStr)) {
  105. continue;
  106. }
  107. getRoleIds().add( Long.valueOf(roleIdStr));
  108. }
  109. }
  110.  
  111. public Boolean getLocked() {
  112. return locked;
  113. }
  114.  
  115. public void setLocked(Boolean locked) {
  116. this.locked = locked;
  117. }
  118.  
  119. @Override
  120. public boolean equals(Object o) {
  121. if (this == o) return true;
  122. if (o == null || getClass() != o.getClass()) return false;
  123.  
  124. User user = (User) o;
  125.  
  126. if (id != null ? !id.equals(user.id) : user.id != null) return false;
  127.  
  128. return true;
  129. }
  130.  
  131. @Override
  132. public int hashCode() {
  133. return id != null ? id.hashCode() : 0;
  134. }
  135.  
  136. @Override
  137. public String toString() {
  138. return "User{" +
  139. "id=" + id +
  140. ", organizationId=" + organizationId +
  141. ", username='" + username + '\'' +
  142. ", password='" + password + '\'' +
  143. ", salt='" + salt + '\'' +
  144. ", roleIds=" + roleIds +
  145. ", locked=" + locked +
  146. '}';
  147. }
  148. }


-------------------------------------------------------------------------------------------加密----------------------------------------------

正如前面散列算法的说法：加密采用的是MD5或者SHA算法和salt盐结合产生不可逆的加密。

什么是盐？

      抛开盐不说： 

     例如用户名admin        密码123，经过md5加密密码获得新的密码值为21232f297a57a5a743894a0e4a801fc3，这样经过数字字典很容易就知道md5加密后的密码为123.

     若加入一些系统已经知道的干扰数据，这些干扰的数据就是盐。则密码就是由  sale(盐) + 经过盐生成的密码组成，这样同一个密码加密生成的密码是各不相同的达到不可逆加密。

 

 

对密码进行盐加密的工具：

这个是jdbc.properties配置文件，里面有shiro加密中须要配的算法名称和迭代次数。算法名称能够为md5,sha-1,sha-256.

若填的算法名称不是加密算法如aaa，则会报错：Caused by: java.security.NoSuchAlgorithmException: abc MessageDigest not available

  1. #dataSource configure
  2. connection.url=jdbc:mysql: //localhost:3306/shiro-demo
  3. connection.username=root
  4. connection.password=
  5.  
  6. #druid datasource
  7. druid.initialSize= 10
  8. druid.minIdle= 10
  9. druid.maxActive= 50
  10. druid.maxWait= 60000
  11. druid.timeBetweenEvictionRunsMillis= 60000
  12. druid.minEvictableIdleTimeMillis= 300000
  13. druid.validationQuery=SELECT 'x'
  14. druid.testWhileIdle= true
  15. druid.testOnBorrow= false
  16. druid.testOnReturn= false
  17. druid.poolPreparedStatements= true
  18. druid.maxPoolPreparedStatementPerConnectionSize= 20
  19. druid.filters=wall,stat
  20.  
  21. #shiro
  22. password.algorithmName=sha -1
  23. password.hashIterations= 2


密码加密工具类：

  1. package com.lgy.service;
  2.  
  3. import org.apache.shiro.crypto.RandomNumberGenerator;
  4. import org.apache.shiro.crypto.SecureRandomNumberGenerator;
  5. import org.apache.shiro.crypto.hash.SimpleHash;
  6. import org.apache.shiro.util.ByteSource;
  7. import org.springframework.beans.factory.annotation.Value;
  8. import org.springframework.stereotype.Service;
  9.  
  10. import com.lgy.model.User;
  11.  
  12. @Service
  13. public class PasswordHelper {
  14.  
  15. private RandomNumberGenerator randomNumberGenerator = new SecureRandomNumberGenerator();
  16.  
  17. @Value("${password.algorithmName}")
  18. private String algorithmName;
  19. @Value("${password.hashIterations}")
  20. private int hashIterations;
  21.  
  22. public void encryptPassword(User user) {
  23.  
  24. user.setSalt(randomNumberGenerator.nextBytes().toHex());
  25.  
  26. String newPassword = new SimpleHash(
  27. algorithmName, //加密算法
  28. user.getPassword(), //密码
  29. ByteSource.Util.bytes(user.getCredentialsSalt()), //salt盐 username + salt
  30. hashIterations //迭代次数
  31. ).toHex();
  32.  
  33. user.setPassword(newPassword);
  34. }
  35. }

 

密码中干扰的值是username+salt组成， salt是用RandomNumberGererator随机生成的值。能够自定义，也能够不须要salt这个字段。这样在数据库中生成的数据有：

一样的密码123456，获得的密码值是不同的！

用户名                                    密码                                                              盐值

admin c4270458aca71740949bead254d6e9fb          228723e1ecce4511f2ff3a02a1a6a57b

feng 2053ad769d326bc6b36f97aac53b72a6a        cf12465e22601b8399439e526499f5c

 

---------------------------------------------------------------------------解密-----------------------------------------------------------------

 

shiro框架的解密是经过：HashedCredentialsMatcher实现密码验证服务

a.首先配置本身的realm：     

  1. <!-- Realm实现 -->
  2. <bean id="userRealm" class="com.lgy.realm.UserRealm">
  3. <!-- 密码验证方式 -->
  4. <property name="credentialsMatcher" ref="credentialsMatcher"/>
  5. <property name="cachingEnabled" value="false"/>
  6. <!--<property name="authenticationCachingEnabled" value="true"/>-->
  7. <!--<property name="authenticationCacheName" value="authenticationCache"/>-->
  8. <!--<property name="authorizationCachingEnabled" value="true"/>-->
  9. <!--<property name="authorizationCacheName" value="authorizationCache"/>-->
  10. </bean>
  1. <!-- 凭证匹配器 -->
  2. <bean id="credentialsMatcher" class="com.lgy.credentials.RetryLimitHashedCredentialsMatcher">
  3. <constructor-arg ref="cacheManager"/>
  4. <property name="hashAlgorithmName" value="sha-1"/>
  5. <property name="hashIterations" value="2"/>
  6. <property name="storedCredentialsHexEncoded" value="true"/>
  7. </bean>


密码验证方式是自定义实现的，RetryLimitHashedCredentialsMatcher实现类以下：

  1. package com.lgy.credentials;
  2.  
  3. import org.apache.shiro.authc.AuthenticationInfo;
  4. import org.apache.shiro.authc.AuthenticationToken;
  5. import org.apache.shiro.authc.ExcessiveAttemptsException;
  6. import org.apache.shiro.authc.credential.HashedCredentialsMatcher;
  7. import org.apache.shiro.cache.Cache;
  8. import org.apache.shiro.cache.CacheManager;
  9.  
  10. import java.util.concurrent.atomic.AtomicInteger;
  11. public class RetryLimitHashedCredentialsMatcher extends HashedCredentialsMatcher {
  12.  
  13. private Cache<String, AtomicInteger> passwordRetryCache;
  14.  
  15. public RetryLimitHashedCredentialsMatcher(CacheManager cacheManager) {
  16. passwordRetryCache = cacheManager.getCache( "passwordRetryCache");
  17. }
  18.  
  19. @Override
  20. public boolean doCredentialsMatch(AuthenticationToken token, AuthenticationInfo info) {
  21. String username = (String)token.getPrincipal();
  22. //retry count + 1
  23. AtomicInteger retryCount = passwordRetryCache.get(username);
  24. if(retryCount == null) {
  25. retryCount = new AtomicInteger(0);
  26. passwordRetryCache.put(username, retryCount);
  27. }
  28. if(retryCount.incrementAndGet() > 5) {
  29. //if retry count > 5 throw
  30. throw new ExcessiveAttemptsException();
  31. }
  32.  
  33. boolean matches = super.doCredentialsMatch(token, info);
  34. if(matches) {
  35. //clear retry count
  36. passwordRetryCache.remove(username);
  37. }
  38. return matches;
  39. }
  40. }


这里要注意认证凭证中的2个参数值的设置要与加密时的一致，分别是算法名称)和迭代次数.

userRealm类以下：

  1. @Override
  2. protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
  3. String username = (String)token.getPrincipal();
  4. User user = userService.findByUsername(username);
  5. if(user == null) {
  6. throw new UnknownAccountException();//没找到账号
  7. }
  8. if(Boolean.TRUE.equals(user.getLocked())) {
  9. throw new LockedAccountException(); //账号锁定
  10. }
  11. //交给AuthenticatingRealm使用CredentialsMatcher进行密码匹配，若是以为人家的很差能够自定义实现
  12. SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(
  13. user.getUsername(), //用户名
  14. user.getPassword(), //密码
  15. ByteSource.Util.bytes(user.getCredentialsSalt()), //salt=username+salt
  16. getName() //realm name
  17. );
  18. return authenticationInfo;
  19. }

经过SimpleAuthenticationInfo将盐值以及用户名和密码信息封装到AuthenticationInfo中，进入证书凭证类中进行校验。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程