一、简介
BCryptPasswordEncoder是Spring Security中推荐的加密器，我很好奇的是它如何验证前端密码的正确性，下面来分析分析。
二、源码分析
1.构造方法
从无参构造方法调用说起…
public BCryptPasswordEncoder() {
this(-1); //strength，密码强度，越大强度越高，范围在[4,31]之间
}
public BCryptPasswordEncoder(int strength) {
//this(-1, null);
this(strength, null); //第二个参数random，随机数生成器实例
}
public BCryptPasswordEncoder(int strength, SecureRandom random) {
//this(BCryptVersion.$2A, -1, null);
this(BCryptVersion.$2A, strength, random); //第一个参数，加密器的版本
}
public BCryptPasswordEncoder(BCryptVersion version, int strength, SecureRandom random) {
if (strength != -1 && (strength < BCrypt.MIN_LOG_ROUNDS || strength > BCrypt.MAX_LOG_ROUNDS)) {
//strength不等于-1时，验证strength的范围必须在[4,31]之间
throw new IllegalArgumentException("Bad strength");
}
//this.version = BCryptVersion.$2A
this.version = version;
//this.strength = 10; //给个默认值
this.strength = strength == -1 ? 10 : strength;
//this.random = null;
this.random = random;
}
- 由上面的代码可知:
PasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
//等价于
PasswordEncoder passwordEncoder = new BCryptPasswordEncoder(BCryptVersion.$2A, 10, null);
2.核心方法之加密
public String encode(CharSequence rawPassword)
这个方法是对明文的加密方法，rawPassword是明文密码，返回的是密文
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);
}
可以看到它通过BCrypt.gensalt()获取了一个盐值，然后调用BCrypt.hashpw()加密并返回结果。
由于random参数是null，获取盐的方法为： BCrypt.gensalt(version.getVersion(), strength)
来康康这个方法：
public static String gensalt(String prefix, int log_rounds)
throws IllegalArgumentException {
//return gensalt("$2a", 10, new SecureRandom());
return gensalt(prefix, log_rounds, new SecureRandom());
}
它采用了默认的随机数生成器SecureRandom来参与盐值的生成。
log_rounds也就是strength，代表密码的强度，由此可见密码强度体现在盐的生成里。
具体怎么生成的咱就不看了，总之这个方法会随机生成一个盐值，参与到后续的加密中。
让我们回到encode方法中接着看，hashpw(String password, String salt)将明文和盐加密，看看源码：
public static String hashpw(String password, String salt) {
byte passwordb[];
//转换为byte
passwordb = password.getBytes(StandardCharsets.UTF_8);
//加密并返回
return hashpw(passwordb, salt);
}
public static String hashpw(byte passwordb[], String salt) {
BCrypt B;
String real_salt;
byte saltb[], hashed[];
char minor = (char) 0;
int rounds, off;
StringBuilder rs = new StringBuilder();
if (salt == null) {
throw new IllegalArgumentException("salt cannot be null");
}
int saltLength = salt.length();
if (saltLength < 28) {
throw new IllegalArgumentException("Invalid salt");
}
if (salt.charAt(0) != '$' || salt.charAt(1) != '2')
throw new IllegalArgumentException ("Invalid salt version");
if (salt.charAt(2) == '$')
off = 3;
else {
minor = salt.charAt(2);
if ((minor != 'a' && minor != 'x' && minor != 'y' && minor != 'b')
|| salt.charAt(3) != '$')
throw new IllegalArgumentException ("Invalid salt revision");
off = 4;
}
// Extract number of rounds
if (salt.charAt(off + 2) > '$')
throw new IllegalArgumentException ("Missing salt rounds");
if (off == 4 && saltLength < 29) {
throw new IllegalArgumentException("Invalid salt");
}
rounds = Integer.parseInt(salt.substring(off, off + 2));
real_salt = salt.substring(off + 3, off + 25);
saltb = decode_base64(real_salt, BCRYPT_SALT_LEN);
if (minor >= 'a') // add null terminator
passwordb = Arrays.copyOf(passwordb, passwordb.length + 1);
B = new BCrypt();
hashed = B.crypt_raw(passwordb, saltb, rounds, minor == 'x', minor == 'a' ? 0x10000 : 0);
rs.append("$2");
if (minor >= 'a')
rs.append(minor);
rs.append("$");
if (rounds < 10)
rs.append("0");
rs.append(rounds);
rs.append("$");
encode_base64(saltb, saltb.length, rs);
encode_base64(hashed, bf_crypt_ciphertext.length * 4 - 1, rs);
return rs.toString();
}
可以看到real_salt才是最终参与加密的盐，其中的算法咱不用关注，总之是一个Hash函数，类似MD5
加密的步骤大概分为：
（明文+salt）-> (明文+real_salt【来自salt】) -> hash(明文+real_salt) -> 密文
3.核心方法之密码校验
public boolean matches(CharSequence rawPassword, String encodedPassword)
rawPassword是前端输入的明文密码，encodedPassword是数据库存放的经过加密的密文。
返回是否匹配成功。
public boolean matches(CharSequence rawPassword, String encodedPassword) {
if (rawPassword == null) {
throw new IllegalArgumentException("rawPassword cannot be null");
}
if (encodedPassword == null || encodedPassword.length() == 0) {
logger.warn("Empty encoded password");
return false;
}
//密文样式校验，检查密文的样式是不是BCrypt加密的密文
if (!BCRYPT_PATTERN.matcher(encodedPassword).matches()) {
logger.warn("Encoded password does not look like BCrypt");
return false;
}
//进入匹配流程
return BCrypt.checkpw(rawPassword.toString(), encodedPassword);
}
public static boolean checkpw(String plaintext, String hashed) {
//可以看到，最终对比的是hashed和hashpw(plaintext, hashed)
//hashpw前面加密方法中已经出现过了，即：hashpw(String password, String salt)
return equalsNoEarlyReturn(hashed, hashpw(plaintext, hashed));
}
//类似与String.equals方法，对比两个字符串是否相等
static boolean equalsNoEarlyReturn(String a, String b) {
return MessageDigest.isEqual(a.getBytes(StandardCharsets.UTF_8), b.getBytes(StandardCharsets.UTF_8));
}
从以上的源码可知，matches对比的到底是什么?
答案是：encodedPassword 和 hashpw(rawPassword, encodedPassword)
由于：encodedPassword = hashpw(rawPassword, salt)
所以：hashpw(rawPassword, salt) = hashpw(rawPassword, encodedPassword)
等式成立的条件是什么呢？
可想而知，salt和encodedPassword必然有某种联系
下面做个测试：
package com.vz.test;
import org.springframework.security.crypto.bcrypt.BCrypt;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
/**
* @author visy.wang
* @description: 测试BCrypt
* @date 2023/6/1 11:16
*/
public class TestBCrypt {
public static void main(String[] args) {
String pass = "123456"; //明文密码
PasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
//等价于: passwordEncoder.encode(pass);
String salt = BCrypt.gensalt(BCryptPasswordEncoder.BCryptVersion.$2A.getVersion(), 10);
String password = BCrypt.hashpw(pass, salt);
//等价于：passwordEncoder.matches(pass, password);
String newPassword = BCrypt.hashpw(pass, password);
boolean isMatch = password.equals(newPassword);
System.out.println("明文: "+ pass);
System.out.println("盐值: "+ salt);
System.out.println("旧密文（明文+盐）: "+ password);
System.out.println("新密文（明文+旧密文）: "+ newPassword);
System.out.println("是否匹配: "+ isMatch);
}
}
打印结果：
明文: 123456
盐值: $2a$10$5DGZIjRc27knvCWFyRa5de
旧密文（明文+盐）: $2a$10$5DGZIjRc27knvCWFyRa5de1bHI.6bNW1HyHhU9guEqRpoXavAGC3C
新密文（明文+旧密文）: $2a$10$5DGZIjRc27knvCWFyRa5de1bHI.6bNW1HyHhU9guEqRpoXavAGC3C
是否匹配: true
可以看到密文中的前缀已经包含了盐值(salt)：$2a$10$5DGZIjRc27knvCWFyRa5de
通过Debug可以看到，真实的盐值(real_salt)为：5DGZIjRc27knvCWFyRa5de， 很明显是从salt提取出来的
那么 $2a$10$ 是什么呢？很明显2a是版本号，10是密码强度，$是分隔符。
而真正的密文是： 1bHI.6bNW1HyHhU9guEqRpoXavAGC3C ，由hash(明文+real_salt)得出
所以，现在可以回答上面的问题，salt和encodedPassword的联系就是：encodedPassword包含了salt
这也是为什么使用BCryptPasswordEncoder时我们数据库不用单独保存盐的原因，因为密文本身就包含了盐值
搞清楚原理后，我们也可以自己用MD5等哈希函数实现一个类似的加密器了。
三、自己写一个？
直接上代码：
package com.vz.utils;
import org.apache.shiro.crypto.SecureRandomNumberGenerator;
import org.apache.shiro.crypto.hash.Md5Hash;
import org.apache.shiro.crypto.hash.Sha256Hash;
/**
* @author visy.wang
* @description: 密码工具
* @date 2023/5/30 18:16
*/
public class PwdUtil {
private static final String SALT_PREFIX = "PS";
private static final SecureRandomNumberGenerator secureRandomNumberGenerator = new SecureRandomNumberGenerator();
/**
* 随机获取一个盐值
* @return 盐值
*/
public static String getSalt(){
return secureRandomNumberGenerator.nextBytes().toHex();
}
/**
* 密码加密（自动加盐）
* @param rawPassword 原密码（明文）
* @return 密文
*/
public static String encode(String rawPassword){
return encode(rawPassword, 10); //默认强度：10
}
/**
* 密码加密（自动加盐）
* @param rawPassword 原密码（明文）
* @param strength 密码强度
* @return 密文
*/
public static String encode(String rawPassword, int strength){
if(strength<4 || strength>31){
throw new RuntimeException("密码强度参数范围：[4,31]");
}
String realSalt = getSalt();
int saltLen = realSalt.length();
if(saltLen<16){
throw new RuntimeException("盐值不低于16位");
}
String saltLenStr = (saltLen>9?"":"0") + saltLen;
String strengthStr = (strength>9?"":"0") + strength;
String salt = SALT_PREFIX + strengthStr + saltLenStr + realSalt;
return hashpwd(rawPassword, salt);
}
private static String hashpwd(String rawPassword, String salt){
String strengthStr = salt.substring(SALT_PREFIX.length(), SALT_PREFIX.length()+2);
String saltLenStr = salt.substring(SALT_PREFIX.length()+2, SALT_PREFIX.length()+4);
int strength = Integer.parseInt(strengthStr), saltLen = Integer.parseInt(saltLenStr);
String realSalt = salt.substring(SALT_PREFIX.length()+4, SALT_PREFIX.length()+4+saltLen);
/*System.out.println("salt: " + salt);
System.out.println("strength: " + strength);
System.out.println("realSalt: " + realSalt);*/
String realPass = new Sha256Hash(new Md5Hash(rawPassword), realSalt, strength).toHex();
return salt.substring(0, SALT_PREFIX.length()+4+saltLen) + realPass;
}
/**
* 密码对比，结合encrypt(String rawPassword, int strength)使用
* @param rawPassword 明文
* @param encodedPassword 密文
* @return 是否匹配
*/
public static boolean matches(String rawPassword, String encodedPassword){
return encodedPassword.equals(hashpwd(rawPassword, encodedPassword));
}
public static void main(String[] args) {
String pass = "123456";
String pass1 = encode(pass);
String pass2 = hashpwd(pass, pass1);
boolean matches = matches(pass, pass1);
System.out.println("pass: "+pass);
System.out.println("pass1: "+pass1);
System.out.println("pass2: "+pass2);
System.out.println("matches: "+matches);
}
}
打印结果：
pass: 123456
pass1: PS10321ab677ad4dfe0d9b61fb205211b96d6c1330c5e90383548059b20fcd1331af45b210232d86a5b23166008ec9c341664a
pass2: PS10321ab677ad4dfe0d9b61fb205211b96d6c1330c5e90383548059b20fcd1331af45b210232d86a5b23166008ec9c341664a
matches: true
2053
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
