Question

使用 DelegatingPasswordEncoder 的另外一个好处就是会自动进行密码加密方案升级，这个功能在整合一些“老破旧”系统时非常有用。接下来，我们通过一个案例展示如何进行加密方案升级。

我们在 5.4 节的案例上继续完善。

首先创建一个 security05 数据库，向数据库中添加一张 user 表，并添加一条用户数据，在添加的用户数据中，用户密码是{noop}123：

    DROP TABLE IF EXISTS `user`;
 
    CREATE TABLE `user` (
     `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
     `username` varchar(255) COLLATE utf8mb4_unicode_ci DEFAULT NULL,
     `password` varchar(255) COLLATE utf8mb4_unicode_ci DEFAULT NULL,
     PRIMARY KEY (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
 
    INSERT INTO `user` (`id`, `username`, `password`)
    VALUES (1,'javaboy','{noop}123');

接下来，在项目中添加 MyBatis 依赖和 MySQL 数据库驱动依赖：

    <dependency>
       <groupId>org.mybatis.spring.boot</groupId>
       <artifactId>mybatis-spring-boot-starter</artifactId>
       <version>2.1.3</version>
    </dependency>
    <dependency>
       <groupId>mysql</groupId>
       <artifactId>mysql-connector-java</artifactId>
    </dependency>

然后在 application.properties 中配置数据库连接信息：

    spring.datasource.username=root
    spring.datasource.password=123
    spring.datasource.url=jdbc:mysql:///security05?useUnicode=true&characterEncod
ing=UTF-8&serverTimezone=Asia/Shanghai

接下来创建 User 实体类，为了方便，这里只创建三个属性 id、username 以及 password，其他方法默认都返回 true 即可，代码如下：

    public class User implements UserDetails {
       private Long id;
       private String username;
       private String password;
       @Override
       public Collection<? extends GrantedAuthority> getAuthorities() {
           return null;
       }
       @Override
       public String getPassword() {
           return password;
       }
       @Override
       public String getUsername() {
           return username;
       }
       @Override
       public boolean isAccountNonExpired() {
           return true;
       }
       @Override
       public boolean isAccountNonLocked() {
           return true;
       }
       @Override
       public boolean isCredentialsNonExpired() {
           return true;
       }
       @Override
       public boolean isEnabled() {
           return true;
       }
       //省略其他 get/set
    }

创建 UserService，代码如下：

    @Configuration
    public class UserService implements UserDetailsService,
                                                        UserDetailsPasswordService {
       @Autowired
       UserMapper userMapper;
       @Override
       public UserDetails updatePassword(UserDetails user, String newPassword) {
           Integer result = userMapper
                               .updatePassword(user.getUsername(), newPassword);
           if (result == 1) {
               ((User) user).setPassword(newPassword);
           }
           return user;
       }
       @Override
       public UserDetails loadUserByUsername(String username)
                                                  throws UsernameNotFoundException {
           return userMapper.loadUserByUsername(username);
       }
    }

和前面第 2 章中定义的 UserService 不同，这里的 UserService 多实现了一个接口 UserDetails PasswordService，并实现了该接口中的 updatePassword 方法。当系统判断密码加密方案需要升级的时候，就会自动调用 updatePassword 方法去修改数据库中的密码。当数据库中的密码修改成功后，修改 user 对象中的 password 属性，并将 user 对象返回（回顾 3.1.2 小节中关于 DaoAuthenticationProvider 的讲解，在其 createSuccessAuthentication 方法中触发了密码加密方案自动升级）。

接下来在 UserMapper 中定义相关方法，代码如下：

    @Mapper
    public interface UserMapper {
       User loadUserByUsername(String username);
       Integer updatePassword(@Param("username") String username,
                                       @Param("newPassword") String newPassword);
    }

UserMapper.xml 定义如下：

    <!DOCTYPE mapper
           PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
           "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="org.javaboy.passwordencoder.mapper.UserMapper">
       <select id="loadUserByUsername"
                           resultType="org.javaboy.passwordencoder.model.User">
           select * from user where username=#{username};
       </select>
       <update id="updatePassword">
           update user set password = #{newPassword} where username=#{username};
       </update>
    </mapper>

最后，在 SecurityConfig 中配置 UserService 实例：

    @Configuration
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
       @Autowired
       UserService userService;
       @Override
       protected void configure(AuthenticationManagerBuilder auth)
                                                                   throws Exception {
           auth.userDetailsService(userService);
       }
       @Override
       protected void configure(HttpSecurity http) throws Exception {
           http.authorizeRequests()
                   .anyRequest().authenticated()
                   .and()
                   .formLogin()
                   .and()
                   .csrf().disable();
       }
    }

配置完成后，我们启动项目。

在登录之前，数据库中用户信息如图 5-1 所示。

图 5-1 登录之前用户信息

接下来访问 http://localhost:8080/login 进行登录，登录成功之后，再去查看数据库，此时用户密码已经自动更新了，如图 5-2 所示。

图 5-2 自动更新后的用户信息

如果开发者使用了 DelegatingPasswordEncoder，只要数据库中存储的密码加密方案不是 DelegatingPasswordEncoder 中默认的 BCryptPasswordEncoder，在登录成功之后，都会自动升级为 BCryptPasswordEncoder 加密。

这就是加密方案的升级。

在同一种密码加密方案中，也有可能存在升级的情况。例如，开发者在创建 BcryptPassword Encoder 实例时有一个强度参数 strength，该参数取值在 4～31 之间，默认值为 10。在图 5-2 中大家看到的加密字符串就是 strength 为 10 时生成的加密字符串。我们可以自己来修改 strength 参数，配置如下：

    @Configuration
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
       @Autowired
       UserService userService;
       @Bean
       PasswordEncoder passwordEncoder() {
           String encodingId = "bcrypt";
           Map<String, PasswordEncoder> encoders = new HashMap<>();
           encoders.put(encodingId, new BCryptPasswordEncoder(31));
           encoders.put("ldap", new LdapShaPasswordEncoder());
           encoders.put("MD4", new Md4PasswordEncoder());
           encoders.put("MD5", new MessageDigestPasswordEncoder("MD5"));
           encoders.put("noop", NoOpPasswordEncoder.getInstance());
           encoders.put("pbkdf2", new Pbkdf2PasswordEncoder());
           encoders.put("scrypt", new SCryptPasswordEncoder());
           encoders.put("SHA-1", new MessageDigestPasswordEncoder("SHA-1"));
           encoders.put("SHA-256", new MessageDigestPasswordEncoder("SHA-256"));
           encoders.put("sha256", new StandardPasswordEncoder());
           encoders.put("argon2", new Argon2PasswordEncoder());
           return new DelegatingPasswordEncoder(encodingId, encoders);
       }
       @Override
       protected void configure(AuthenticationManagerBuilder auth)
                                                                   throws Exception {
           auth.userDetailsService(userService);
       }
       @Override
       protected void configure(HttpSecurity http) throws Exception {
           http.authorizeRequests()
          .anyRequest().authenticated()
          .and()
          .formLogin()
          .and()
          .csrf().disable();
       }
    }

这里我们自己来提供一个 DelegatingPasswordEncoder 实例，同时在构建 BcryptPassword Encoder 实例时，传入一个 strength 参数为 31，配置完成后，重启项目。

项目启动成功之后，再次进行登录操作，登录成功后，我们发现数据库中保存的用户密码从图 5-2 变为图 5-3，完成了升级操作。

图 5-3 修改密码加密强度 strength 参数之后，密码再次进行加密升级

这就是 Spring Security 中提供的密码升级功能。在升级一些“老破旧”系统时，这个功能非常好用。