当前位置：首页 > 后端开发 > 正文

java怎么对密码加密

admin
后端开发
2025-07-17
3747

va 对密码加密通常使用 `java.

Java中对密码进行加密,通常涉及到将明文密码转换为一种更安全的、难以直接解读的形式，这一过程可以通过多种方式实现，包括但不限于使用哈希算法（如SHA-256）、加盐哈希、以及更复杂的加密算法（如AES），下面将详细介绍几种常见的密码加密方法，并提供相应的代码示例。

使用哈希算法（如SHA-256）

哈希算法是一种单向加密技术，它将任意长度的输入数据转换为固定长度的输出（即哈希值），由于其不可逆性，哈希算法常用于存储密码，而不是用于加密和解密。

示例代码：

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
public class PasswordHasher {
    public static String hashPassword(String password) {
        try {
            MessageDigest md = MessageDigest.getInstance("SHA-256");
            byte[] hashedBytes = md.digest(password.getBytes());
            return bytesToHex(hashedBytes);
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(e);
        }
    }
    private static String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            sb.append(String.format("%02x", b));
        }
        return sb.toString();
    }
    public static void main(String[] args) {
        String password = "mySecurePassword";
        String hashedPassword = hashPassword(password);
        System.out.println("Hashed Password: " + hashedPassword);
    }
}

输出示例：

Hashed Password: e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855

加盐哈希

加盐是一种增强哈希安全性的技术，通过在密码中添加一个随机生成的“盐”，可以防止彩虹表攻击（即预先计算并存储大量密码及其哈希值的攻击方式）。

java怎么对密码加密第1张

示例代码：

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Base64;
public class SaltedPasswordHasher {
    private static final int SALT_LENGTH = 16; // 128 bits
    public static String generateSalt() {
        SecureRandom random = new SecureRandom();
        byte[] salt = new byte[SALT_LENGTH];
        random.nextBytes(salt);
        return Base64.getEncoder().encodeToString(salt);
    }
    public static String hashPassword(String password, String salt) {
        try {
            MessageDigest md = MessageDigest.getInstance("SHA-256");
            md.update(Base64.getDecoder().decode(salt));
            byte[] hashedBytes = md.digest(password.getBytes());
            return Base64.getEncoder().encodeToString(hashedBytes);
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(e);
        }
    }
    public static void main(String[] args) {
        String password = "mySecurePassword";
        String salt = generateSalt();
        String hashedPassword = hashPassword(password, salt);
        System.out.println("Salt: " + salt);
        System.out.println("Hashed Password: " + hashedPassword);
    }
}

输出示例：

Salt: 3Fv8u+dLmZ2f1Q5pGw==
Hashed Password: OpaqueStringHere

使用加密算法（如AES）

与哈希不同,加密算法是可逆的，这意味着你可以用相同的密钥解密数据，对于密码存储，通常不推荐使用加密算法，因为密钥管理复杂且容易出错，但如果有特定需求，可以使用AES等对称加密算法。

示例代码：

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;
public class AESEncryptor {
    private static final String ALGORITHM = "AES";
    public static SecretKey generateKey() throws Exception {
        KeyGenerator keyGen = KeyGenerator.getInstance(ALGORITHM);
        keyGen.init(256); // 256 bits
        return keyGen.generateKey();
    }
    public static String encrypt(String data, SecretKey key) throws Exception {
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, key);
        byte[] encryptedBytes = cipher.doFinal(data.getBytes());
        return Base64.getEncoder().encodeToString(encryptedBytes);
    }
    public static String decrypt(String encryptedData, SecretKey key) throws Exception {
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, key);
        byte[] decryptedBytes = cipher.doFinal(Base64.getDecoder().decode(encryptedData));
        return new String(decryptedBytes);
    }
    public static void main(String[] args) {
        try {
            SecretKey key = generateKey();
            String password = "mySecurePassword";
            String encryptedPassword = encrypt(password, key);
            String decryptedPassword = decrypt(encryptedPassword, key);
            System.out.println("Encrypted Password: " + encryptedPassword);
            System.out.println("Decrypted Password: " + decryptedPassword);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

输出示例：

Encrypted Password: OpaqueStringHere
Decrypted Password: mySecurePassword

使用BCrypt

BCrypt是一种专为密码哈希设计的算法，它内置了加盐机制，并且可以根据需要调整计算成本，以抵御暴力破解攻击。

示例代码：

import org.springframework.security.crypto.bcrypt.BCrypt;
public class BCryptExample {
    public static void main(String[] args) {
        String password = "mySecurePassword";
        // 哈希密码
        String hashed = BCrypt.hashpw(password, BCrypt.gensalt());
        System.out.println("Hashed Password: " + hashed);
        // 验证密码
        boolean matches = BCrypt.checkpw(password, hashed);
        System.out.println("Matches: " + matches);
    }
}

输出示例：

Hashed Password: $2a$10$DowJonesIndex/Vc8eOhWNOXzeIjBpRyleeMk5KQPd0nH/ConqOK1B5n.q
Matches: true

方法比较

方法	可逆性	安全性	适用场景
SHA-256	否	中等，易受彩虹表攻击	基本密码存储，不推荐单独使用
加盐SHA-256	否	较高，防止彩虹表攻击	推荐用于密码存储
AES	是	高，但密钥管理复杂	需要加密和解密的场景
BCrypt	否	高，内置加盐和计算成本调整	推荐用于密码存储，尤其是Web应用