提前声明：
你不会写这加密算法没关系啊，你会用就行。
要求就是：你可以不会写这个加密算法，但是你要知道加密流程，你要会用。
@Service
public class PasswordEncryptor{}
很好，请在service层中创建一个名字为PasswordEncryptor的服务类，用来负责密码的加密。
加密的方法有很多。
简单一点的，直接加密为MD5，或者使用base64进行编码到达伪加密的效果（毕竟base64编码是可以解码的）
在这里，用一种比较通常的方式进行加密
这种加密方式是一种结合了哈希函数和“盐”（Salt）的密码存储策略。以下是该加密方式的详细介绍：
-
哈希函数（Hashing Function）
哈希函数是一种从任何大小的数据（通常是字符串）生成固定长度字符串的方法。在这个例子中，使用了SHA-256，它是一种常用的加密哈希函数。SHA-256生成的哈希值总是256位（32字节）长。哈希函数有一个重要的特性，那就是它们是单向的。这意味着，虽然从原始数据很容易生成哈希值，但从哈希值反向推导出原始数据却几乎是不可能的。 -
盐（Salt）
“盐”是一个随机生成的数据，它与原始密码一起哈希处理。在这个例子中，盐的长度是16字节。盐的主要目的是防止所谓的“彩虹表”攻击。彩虹表是一种预先计算好的、从原始密码到其哈希值的映射。通过使用盐，即使两个用户使用了相同的密码，他们的哈希值也会是不同的，因为每个用户的盐都是不同的。这使得攻击者无法简单地使用预先计算好的彩虹表来查找原始密码。 -
加密过程
在hashPassword方法中，首先生成一个新的随机盐。然后，将这个盐和密码一起哈希处理。最后，将盐和哈希值合并，并使用Base64编码以便于存储和传输。 -
验证过程
在verifyPassword方法中，首先从存储的Base64编码字符串中解码出盐和哈希值。然后，使用相同的盐对用户输入的密码进行哈希处理。最后，比较计算出的哈希值和存储的哈希值是否相同。如果相同，那么密码就是正确的。 -
安全性
这种加密方式提供了相当高的安全性。由于哈希函数的单向性，攻击者无法从哈希值中直接获取原始密码。同时，由于使用了盐，攻击者也无法使用彩虹表来查找原始密码。然而，需要注意的是，没有任何加密方式是绝对安全的。例如，如果攻击者能够获取到足够多的哈希值和对应的原始密码（这通常是通过某种形式的“钓鱼”攻击或恶意软件实现的），那么他们可能会使用这些信息来尝试“破解”哈希函数，尽管这在实践中是非常困难的。
代码如下：
package cc.xrilang.serversystem.service;
import org.springframework.stereotype.Service;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Base64;
@Service
public class PasswordEncryptor {
// 盐的长度，这里设置为16字节
private static final int SALT_LENGTH = 16;
// SecureRandom用于生成安全的随机数
private final SecureRandom secureRandom;
// 构造函数，初始化SecureRandom实例
public PasswordEncryptor() {
this.secureRandom = new SecureRandom();
}
// 生成随机的盐
private byte[] generateSalt() {
byte[] salt = new byte[SALT_LENGTH];
secureRandom.nextBytes(salt);
return salt;
}
// 哈希密码并附带盐一起存储
public String hashPassword(String password) throws NoSuchAlgorithmException {
// 生成随机的盐
byte[] salt = generateSalt();
// 使用盐对密码进行哈希处理
byte[] hash = hash(password.getBytes(StandardCharsets.UTF_8), salt);
// 将盐和哈希值合并存储
byte[] saltedHash = new byte[salt.length + hash.length];
System.arraycopy(salt, 0, saltedHash, 0, salt.length);
System.arraycopy(hash, 0, saltedHash, salt.length, hash.length);
// 使用Base64对合并后的数据进行编码，便于存储和传输
return Base64.getEncoder().encodeToString(saltedHash);
}
// 使用SHA-256算法和盐对输入数据进行哈希处理
private byte[] hash(byte[] input, byte[] salt) throws NoSuchAlgorithmException {
MessageDigest md = MessageDigest.getInstance("SHA-256");
md.update(salt);
return md.digest(input);
}
// 验证密码是否正确
public boolean verifyPassword(String storedSaltedHash, String passwordToVerify) throws NoSuchAlgorithmException {
// 对存储的Base64编码的盐和哈希值进行解码
byte[] saltedHash = Base64.getDecoder().decode(storedSaltedHash);
// 从解码后的数据中提取盐
byte[] salt = new byte[SALT_LENGTH];
System.arraycopy(saltedHash, 0, salt, 0, salt.length);
// 从解码后的数据中提取哈希值
byte[] hash = new byte[saltedHash.length - salt.length];
System.arraycopy(saltedHash, salt.length, hash, 0, hash.length);
// 使用提取的盐对用户输入的密码进行哈希处理
byte[] computedHash = hash(passwordToVerify.getBytes(StandardCharsets.UTF_8), salt);
// 比较计算出的哈希值与存储的哈希值是否一致
return MessageDigest.isEqual(computedHash, hash);
}
// 主函数，用于测试
public static void main(String[] args) {
PasswordEncryptor encryptor = new PasswordEncryptor();
String password = "userPassword123";
try {
// 对密码进行哈希处理并附带盐一起存储
String encryptedPassword = encryptor.hashPassword(password);
System.out.println("加密后的密码（包含盐）: " + encryptedPassword);
// 验证密码是否正确
boolean isVerified = encryptor.verifyPassword(encryptedPassword, password);
System.out.println("密码验证结果: " + isVerified);
// 使用错误的密码进行验证
boolean isWrongPasswordVerified = encryptor.verifyPassword(encryptedPassword, "wrongPassword");
System.out.println("错误密码验证结果: " + isWrongPasswordVerified);
} catch (NoSuchAlgorithmException e) {
System.err.println("找不到哈希算法: " + e.getMessage());
}
}
}
接下来，我们在新增用户的时候，就要应用上这个加密
// 增加用户
@PostMapping
public ResponseEntity<?> createUser(@RequestBody Users user) {
if (usersService.selectUserAccount(user.getUserAccount()) != null) {
return ResponseEntity.error("该账号已注册");
}
String password = user.getUserPassword();
//对密码进行加密
String plainPassword = user.getUserPassword();
String encryptedPassword = null;
try {
encryptedPassword = passwordEncryptor.hashPassword(plainPassword);
} catch (NoSuchAlgorithmException e) {
// 处理加密异常，这里可以记录日志并返回错误信息
return ResponseEntity.error("密码加密失败");
}
// 设置加密后的密码到用户对象
user.setUserPassword(encryptedPassword);
user.setUserStatus(1);
user.setUserRegTime(new Timestamp(System.currentTimeMillis()));
Users createdUser = usersService.createUser(user);
return ResponseEntity.success(createdUser);
}
那么，我们再编写一个登录接口吧。
// 登录接口
@PostMapping("/login")
public ResponseEntity<?> login(@RequestParam String userAccount,@RequestParam String userPassword) {
// 从登录请求中获取用户名和密码
// System.out.println(userAccount);
// System.out.println(userPassword);
// 尝试从数据库中查找用户
Users user = usersService.selectUserAccount(userAccount);
// 验证用户是否存在
if (user == null) {
return ResponseEntity.error("用户不存在");
}
try {
// 验证密码是否正确
boolean passwordMatches = passwordEncryptor.verifyPassword(user.getUserPassword(),userPassword);
if (!passwordMatches) {
// 密码不匹配
return ResponseEntity.error("密码错误");
}
}catch (NoSuchAlgorithmException e){
return ResponseEntity.error("密码验证失败");
}catch (Exception e){
return ResponseEntity.error(e.getMessage());
}
return ResponseEntity.success(user);
}
验证密码的时候，首先根据账号去获取数据里面加密的密码
加密的密码包括 盐值+哈希值
对存储的Base64编码的盐和哈希值进行解码
从解码后的数据中分别提取盐和哈市值
使用提取的盐对用户输入的密码进行哈希处理
比较计算出的哈希值与存储的哈希值是否一致
这就是判断流程了
当然不要忘记了修改密码的时候，也要对密码进行加密哦
// 更新用户
@PutMapping
public ResponseEntity<Users> updateUser(@RequestBody Users user) {
//获取参数的内容
String userNickname = user.getUserNickname();
String userPassword = user.getUserPassword();
String userIdentity = user.getUserIdentity();
Timestamp userLoginTime = user.getUserLastLoginTime();
String remarks = user.getRemarks();
long userStatus = user.getUserStatus();
long userId = user.getUserId();
//根据ID查出原本的数据
Users u = usersService.readUser(user.getUserId());
if (u == null) {
return ResponseEntity.error("用户不存在");
}
// 更新用户信息（此处代码保持不变）
//将需要修改的内容替换进去
if (userNickname != null) {
u.setUserNickname(userNickname);
}
if (userPassword != null) {
//密码要加密后存储
//对密码进行加密
String encryptedPassword = null;
try {
encryptedPassword = passwordEncryptor.hashPassword(userPassword);
} catch (NoSuchAlgorithmException e) {
// 处理加密异常，这里可以记录日志并返回错误信息
return ResponseEntity.error("密码加密失败");
}
// 设置加密后的密码到用户对象
u.setUserPassword(encryptedPassword);
}
if (userIdentity != null) {
u.setUserIdentity(userIdentity);
}
if (userLoginTime != null) {
u.setUserLastLoginTime(userLoginTime);
}
if (remarks != null) {
u.setRemarks(remarks);
}
if (userStatus != 0) {
u.setUserStatus(userStatus);
}
Users updatedUser = usersService.updateUser(u);
return ResponseEntity.success(updatedUser);
}
登录试试看
故意输错密码：
故意输错账号
