Spring Security使用单向密码转换存储密码，也就是加密后的用户密码无法恢复成明文，只能用作密码比较。另外随着计算机性能的提升，传统的SHA-256哈希加密方式不再安全。Spring Security采用了自适应单向加密方式，它通过刻意消耗计算机计算能力来加强密码被破解的难度，比如一个密码加密一次需要100毫秒，可能破解整个系统的密码只需要几小时，如果一个密码加密一次需要1秒那么破解整个系统的密码就需要几天。以BCryptPasswordEncoder为例，它内部有一个叫strength的工作因素，其值范围是4~31，值越大其循环加密的次数就越多。

    public String encode(CharSequence rawPassword) {
        if (rawPassword == null) {
            throw new IllegalArgumentException("rawPassword cannot be null");
        }

        String salt;
        if (random != null) {
            salt = BCrypt.gensalt(version.getVersion(), strength, random);
        } else {
            salt = BCrypt.gensalt(version.getVersion(), strength);
        }
        return BCrypt.hashpw(rawPassword.toString(), salt);
    }

当通过BCryptPasswordEncoder.encode进行加密的时候，strength这个参数会被附加到salt中，BCrypt.hashpw通过salt获取strength，然后通过BCrypt.crypt_raw来使用。

private byte[] crypt_raw(byte password[], byte salt[], int log_rounds,
                            boolean sign_ext_bug, int safety) {
        int rounds, i, j;
        int cdata[] =  bf_crypt_ciphertext.clone();
        int clen = cdata.length;
        byte ret[];

        if (log_rounds < 4 || log_rounds > 31)
            throw new IllegalArgumentException ("Bad number of rounds");
        rounds = 1 << log_rounds;
        if (salt.length != BCRYPT_SALT_LEN)
            throw new IllegalArgumentException ("Bad salt length");

        init_key();
        ekskey(salt, password, sign_ext_bug, safety);
        for (i = 0; i < rounds; i++) {
            key(password, sign_ext_bug, safety);
            key(salt, false, safety);
        }

        for (i = 0; i < 64; i++) {
            for (j = 0; j < (clen >> 1); j++)
                encipher(cdata, j << 1);
        }

        ret = new byte[clen * 4];
        for (i = 0, j = 0; i < clen; i++) {
            ret[j++] = (byte) ((cdata[i] >> 24) & 0xff);
            ret[j++] = (byte) ((cdata[i] >> 16) & 0xff);
            ret[j++] = (byte) ((cdata[i] >> 8) & 0xff);
            ret[j++] = (byte) (cdata[i] & 0xff);
        }
        return ret;
    }

在BCrypt.crypt_raw中的入参log_rounds就是之前提到的strength，它通过rounds = 1 << log_rounds;左移获得一个循环数，最终通过该循环数提高整个加密过程的计算能力消耗。

for (i = 0; i < rounds; i++) {
    key(password, sign_ext_bug, safety);
    key(salt, false, safety);
}

PasswordEncoder接口

String encode(CharSequence rawPassword);
boolean matches(CharSequence rawPassword, String encodedPassword);

PasswordEncoder接口是Spring Security提供的统一密码接口，主要为整个安全框架提供一个统一的加密过程。其主要的实现类如下:

• DelegatingPasswordEncoder
• BCryptPasswordEncoder
• Argon2PasswordEncoder
• Pbkdf2PasswordEncoder
• SCryptPasswordEncoder
• Other PasswordEncoders
  除了其它加密算法，以上所列的加密算法都是Spring Security所推荐的，而其它算法主要是为了系统兼容性而存在，但是不再推荐使用。

DelegatingPasswordEncoder

DelegatingPasswordEncoder是Spring Security默认使用的加密算法。我们从它的名称其实可以猜测出来它本身并不是一个具体的算法实现类，而是一个算法代理类。这个类主要目的是兼容老旧系统，方便老旧系统的升级改造。

PasswordEncoder passwordEncoder =
    PasswordEncoderFactories.createDelegatingPasswordEncoder();

DelegatingPasswordEncoder可以通PasswordEncoderFactories.createDelegatingPasswordEncoder()来创建一个默认的实现方式。

public static PasswordEncoder createDelegatingPasswordEncoder() {
        String encodingId = "bcrypt";
        Map<String, PasswordEncoder> encoders = new HashMap<>();
        encoders.put(encodingId, new BCryptPasswordEncoder());
        encoders.put("ldap", new org.springframework.security.crypto.password.LdapShaPasswordEncoder());
        encoders.put("MD4", new org.springframework.security.crypto.password.Md4PasswordEncoder());
        encoders.put("MD5", new org.springframework.security.crypto.password.MessageDigestPasswordEncoder("MD5"));
        encoders.put("noop", org.springframework.security.crypto.password.NoOpPasswordEncoder.getInstance());
        encoders.put("pbkdf2", new Pbkdf2PasswordEncoder());
        encoders.put("scrypt", new SCryptPasswordEncoder());
        encoders.put("SHA-1", new org.springframework.security.crypto.password.MessageDigestPasswordEncoder("SHA-1"));
        encoders.put("SHA-256", new org.springframework.security.crypto.password.MessageDigestPasswordEncoder("SHA-256"));
        encoders.put("sha256", new org.springframework.security.crypto.password.StandardPasswordEncoder());
        encoders.put("argon2", new Argon2PasswordEncoder());

        return new DelegatingPasswordEncoder(encodingId, encoders);
    }

PasswordEncoderFactories.createDelegatingPasswordEncoder()会首先创建一个Map，然后将各种PasswordEncoder的具体算法对象存入Map中。那么如何使用DelegatingPasswordEncoder呢？

{bcrypt}$2a$10$dXJ3SW6G7P50lGmMkkmwe.20cQQubK3.HZWzG3YB1tlRy.fqvM/BG 
{noop}password 
{pbkdf2}5d923b44a6d129f3ddf3e3c8d29412723dcbde72445e8ef6bf3b508fbf17fa4ed4d6b99ca763d8dc 
{scrypt}$e0801$8bWJaSu2IKSn9Z9kM+TPXfOc/9bdYSrN1oD9qfVThWEwdRTnO7re7Ei+fUZRJ68k9lTyuTeUp4of4g24hHnazw==$OAOec05+bXxvuu/1qZ6NUR+xQYvYv7BeL1QxwRpY5Pc=  
{sha256}97cde38028ad898ebc02e690819fa220e88c62e0699403e94fff291cfffaf8410849f27605abcbc0

以上就是DelegatingPasswordEncoder所存储的密码例子，其具体格式如下

{id}encodedPassword

其中{id}就是所使用的加密算法，encodedPassword就是{id}所对应的具体加密算法加密后的值。

{bcrypt}$2a$10$dXJ3SW6G7P50lGmMkkmwe.20cQQubK3.HZWzG3YB1tlRy.fqvM/BG

以{bcrypt}为例，DelegatingPasswordEncoder会首先解析出{bcrypt}，然后在Map中查找具体的实现算法，最终由BCryptPasswordEncoder来完成加密或匹配过程。

参考资源

• Spring Security加密官方文档