数字时代的密码守护者：从哈希到国密算法

本文链接：https://blog.csdn.net/2401_89221867/article/details/145591967

前言

在数字化时代，密码安全已经成为我们每个人都无法忽视的重要问题。无论是社交平台、电子邮件，还是银行账户、智能设备，密码就像一把“钥匙”，保护着我们的个人信息。而加密技术，则是这把钥匙的“防护罩”，为我们的数据安全提供了坚实的保障。

今天，我们将深入探讨常见的加密方式、它们的应用场景、实际案例以及优缺点。

常见加密方式

1.哈希加密：不可逆的安全守护

原理：哈希加密是一种单向加密方式，它使用哈希函数将任意长度的数据映射为固定长度的哈希值。哈希函数具有确定性、快速计算、抗碰撞性等特点，即相同的输入总会得到相同的输出，计算速度快，并且很难找到两个不同的输入产生相同的哈希值。
常用算法：常见的哈希算法有MD5、SHA-1、SHA-256、BCrypt等。其中，MD5和SHA-1由于存在安全性缺陷，逐渐被弃用，SHA-256和BCrypt等更安全的算法应用更为广泛。例如，BCrypt算法还引入了加盐（salt）机制，增加了密码的安全性。
应用场景：主要用于密码存储和文件完整性验证。将用户输入的密码通过哈希算法处理后存储在数据库中，用户登录时，系统将用户输入的密码再次进行哈希计算，与数据库中存储的哈希值进行比对，若一致则验证通过。

2.对称加密：高效的数据保护

原理：对称加密使用同一个密钥对数据进行加密和解密操作。加密方使用密钥将明文加密成密文，接收方使用相同的密钥将密文还原为明文。
常用算法：常见的对称加密算法有DES、3DES、AES等。AES算法由于其高效性和安全性，被广泛应用于各种领域。
应用场景：适用于对大量数据进行快速加密和解密的场景，如在网络通信中对数据进行加密传输，或者在本地对文件进行加密存储等，AES 等对称加密算法就能满足需求。

3.非对称加密：双钥匙的安全保障

原理：非对称加密使用一对密钥，即公钥和私钥。公钥可以公开，用于加密数据；私钥由用户自己保存，用于解密数据。用公钥加密的数据只能用对应的私钥解密，反之亦然。
常用算法：常见的非对称加密算法有RSA、ECC等。RSA算法基于大整数分解难题，ECC算法基于椭圆曲线离散对数问题，它们都具有较高的安全性。
应用场景：常用于身份认证、数字签名和密钥交换等场景。例如，在SSL/TLS协议中，服务器使用非对称加密算法来验证客户端的身份，并进行密钥交换，以建立安全的通信通道。

4.组合加密：强强联手，双重防护

原理：将对称加密和非对称加密结合使用，充分发挥两者的优势。例如，在实际应用中，可以使用非对称加密算法来交换对称加密算法的密钥，然后使用对称加密算法对大量数据进行加密传输。这种方式既保证了安全性，又兼顾了效率。
应用场景：在一些对安全性要求较高的系统中，如金融系统、电子商务平台等，常采用组合加密方式来保障数据的安全传输和存储。

5.国密算法：中国自主研发的安全之盾

国密算法即国家密码管理局认定的国产商用密码算法，是我国自主研发创新的一系列密码算法，在保障国家信息安全、满足各行业对信息安全的自主可控需求等方面发挥着重要作用。

SM1 算法
- 加密原理：SM1 是对称加密算法，分组长度和密钥长度均为 128 位。不过该算法不公开，具体实现细节由国家密码管理局指定单位掌握，一般以加密芯片等硬件形式提供服务。
- 应用场景：常用于金融支付领域，如银行卡的芯片加密，保障交易数据在传输和存储过程中的安全性；也应用于电子政务、门禁系统等对数据安全有较高要求的场景。
SM2 算法
- 原理：一种基于椭圆曲线密码（ECC）的非对称加密算法。它利用椭圆曲线上的点构成的离散对数问题的困难性，来实现加密、解密、数字签名和密钥交换等功能。相较于传统的基于大整数分解的 RSA 算法，椭圆曲线密码体制在相同的安全强度下，密钥长度更短，计算效率更高。
- 应用场景：常用于数字证书、电子签名、身份认证、密钥交换等场景。在金融领域，用于保障网上银行、电子支付等业务的安全；在政务领域，用于电子政务系统中的文件加密、身份认证等，确保政务数据的安全传输和处理。
SM3 算法
- 原理：是一种哈希算法，用于将任意长度的数据转换为固定长度（256 位）的哈希值。它具有单向性、抗碰撞性等哈希函数的典型特性，能够快速计算出数据的哈希值，并且很难找到两个不同的数据产生相同的哈希值。
- 应用场景：主要用于数据完整性验证、数字签名中的消息摘要计算等。在文件传输中，接收方可以通过计算接收到文件的 SM3 哈希值，并与发送方提供的哈希值进行比对，来确保文件在传输过程中未被篡改；在区块链技术中，也可用于计算区块的哈希值，保证区块链数据的完整性和不可篡改。
SM4 算法
- 原理：属于对称加密算法，使用 128 位密钥对 128 位的数据块进行加密和解密操作。它采用了迭代的 Feistel 结构，通过多轮的加密变换来实现数据的加密，具有较高的加密效率和安全性。
- 应用场景：适用于大量数据的加密场景，如通信加密、存储加密等。在物联网设备通信中，利用 SM4 算法对设备之间传输的数据进行加密，防止数据被窃取或篡改；在数据库中，对敏感数据字段进行加密存储，保障数据的安全性。

在实际应用中，国密算法被广泛应用于金融、政务、电力、交通等关键领域，以满足国家对信息安全自主可控的要求。同时，随着国家对信息安全重视程度的不断提高，国密算法的应用范围也在不断扩大

具体案例

哈希加密案例

在存储用户上传的代码文件时，会计算文件的 SHA-256 哈希值。当用户再次下载文件时，可以通过对比哈希值来验证文件是否与上传时一致。

SHA-256

java

代码解读

复制代码

import java.nio.charset.StandardCharsets; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; public class SHA256Example { public static String sha256(String input) { try { MessageDigest digest = MessageDigest.getInstance("SHA-256"); byte[] encodedHash = digest.digest(input.getBytes(StandardCharsets.UTF_8)); StringBuilder hexString = new StringBuilder(2 * encodedHash.length); for (byte b : encodedHash) { String hex = Integer.toHexString(0xff & b); if (hex.length() == 1) { hexString.append('0'); } hexString.append(hex); } return hexString.toString(); } catch (NoSuchAlgorithmException e) { e.printStackTrace(); return null; } } public static void main(String[] args) { // 待计算哈希值的字符串 String password = "这是一段代码"; String hashedPassword = sha256(password); System.out.println("SHA-256哈希值: " + hashedPassword); } }

BCrypt

BCrypt也是一种常用的哈希算法，尤其在密码存储中表现出色。使用BCrypt时，通常需要导入第三方依赖，因为Java标准库中并未提供BCrypt的相关实现。

pom.xml

xml

代码解读

复制代码

<dependency> <groupId>org.mindrot</groupId> <artifactId>jbcrypt</artifactId> <version>0.4</version> </dependency>  

BCryptExample

java

代码解读

复制代码

import org.mindrot.jbcrypt.BCrypt; public class BCryptExample { public static void main(String[] args) { // 原始密码 String originalPassword = "userPassword123"; // 生成盐值并对密码进行哈希处理，strength为工作因子，取值范围通常是4 - 31，数值越大，计算越复杂，安全性越高，但耗时也越长 String hashedPassword = BCrypt.hashpw(originalPassword, BCrypt.gensalt(12)); System.out.println("哈希密码: " + hashedPassword); // 模拟用户登录时验证密码 String inputPassword = "userPassword123"; boolean isPasswordMatch = BCrypt.checkpw(inputPassword, hashedPassword); if (isPasswordMatch) { System.out.println("密码正确"); } else { System.out.println("密码错误"); } } }

对称加密案例

某电商公司在用户下单后，会将订单信息使用 AES 加密后存储在数据库中。当需要查询订单时，再使用相同的密钥进行解密，确保用户订单信息的安全。

java

代码解读

复制代码

import javax.crypto.Cipher; import javax.crypto.KeyGenerator; import javax.crypto.SecretKey; import java.util.Base64; public class AESExample { public static void main(String[] args) throws Exception { // 生成密钥 KeyGenerator keyGenerator = KeyGenerator.getInstance("AES"); keyGenerator.init(128); SecretKey secretKey = keyGenerator.generateKey(); // 创建Cipher对象并初始化为加密模式 Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding"); cipher.init(Cipher.ENCRYPT_MODE, secretKey); // 待加密的字符串 String originalMessage = "这是一个订单信息"; byte[] encryptedBytes = cipher.doFinal(originalMessage.getBytes()); String encryptedMessage = Base64.getEncoder().encodeToString(encryptedBytes); System.out.println("加密后的信息: " + encryptedMessage); // 创建Cipher对象并初始化为解密模式 cipher.init(Cipher.DECRYPT_MODE, secretKey); byte[] decryptedBytes = cipher.doFinal(Base64.getDecoder().decode(encryptedMessage)); String decryptedMessage = new String(decryptedBytes); System.out.println("解密后的信息: " + decryptedMessage); } }

非对称加密案例

在电子邮件通信中，发件人使用收件人的公钥对邮件内容进行加密，收件人收到邮件后，使用自己的私钥进行解密。这样可以保证邮件内容只有收件人能够查看。

java

代码解读

复制代码

import java.security.KeyPair; import java.security.KeyPairGenerator; import java.security.PrivateKey; import java.security.PublicKey; import javax.crypto.Cipher; import java.util.Base64; public class RSAExample { public static void main(String[] args) throws Exception { // 生成密钥对 KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA"); keyPairGenerator.initialize(2048); KeyPair keyPair = keyPairGenerator.generateKeyPair(); // 获取公钥和私钥 PublicKey publicKey = keyPair.getPublic(); PrivateKey privateKey = keyPair.getPrivate(); // 创建Cipher对象并初始化为加密模式 Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding"); // 使用公钥加密 cipher.init(Cipher.ENCRYPT_MODE, publicKey); // 待加密的字符串 String originalMessage = "这是一封重要邮件"; byte[] encryptedBytes = cipher.doFinal(originalMessage.getBytes()); String encryptedMessage = Base64.getEncoder().encodeToString(encryptedBytes); System.out.println("加密后的信息: " + encryptedMessage); // 创建Cipher对象并初始化为解密模式 // 使用私钥解密 cipher.init(Cipher.DECRYPT_MODE, privateKey); byte[] decryptedBytes = cipher.doFinal(Base64.getDecoder().decode(encryptedMessage)); String decryptedMessage = new String(decryptedBytes); System.out.println("解密后的信息: " + decryptedMessage); } }

组合加密方式

java

代码解读

复制代码

import javax.crypto.Cipher; import javax.crypto.KeyGenerator; import javax.crypto.SecretKey; import java.nio.charset.StandardCharsets; import java.security.*; import java.util.Base64; public class CombinedEncryptionExample { public static KeyPair generateRSAKeyPair() throws NoSuchAlgorithmException { KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA"); keyPairGenerator.initialize(2048); return keyPairGenerator.generateKeyPair(); } public static SecretKey generateAESKey() throws NoSuchAlgorithmException { KeyGenerator keyGenerator = KeyGenerator.getInstance("AES"); keyGenerator.init(128); return keyGenerator.generateKey(); } public static String encryptAESKeyWithRSA(SecretKey aesKey, PublicKey rsaPublicKey) throws Exception { Cipher cipher = Cipher.getInstance("RSA"); cipher.init(Cipher.ENCRYPT_MODE, rsaPublicKey); byte[] encryptedAESKey = cipher.doFinal(aesKey.getEncoded()); return Base64.getEncoder().encodeToString(encryptedAESKey); } public static SecretKey decryptAESKeyWithRSA(String encryptedAESKey, PrivateKey rsaPrivateKey) throws Exception { Cipher cipher = Cipher.getInstance("RSA"); cipher.init(Cipher.DECRYPT_MODE, rsaPrivateKey); byte[] decryptedAESKeyBytes = cipher.doFinal(Base64.getDecoder().decode(encryptedAESKey)); return new javax.crypto.spec.SecretKeySpec(decryptedAESKeyBytes, "AES"); } public static String encryptDataWithAES(String plainText, SecretKey aesKey) throws Exception { Cipher cipher = Cipher.getInstance("AES"); cipher.init(Cipher.ENCRYPT_MODE, aesKey); byte[] encryptedBytes = cipher.doFinal(plainText.getBytes(StandardCharsets.UTF_8)); return Base64.getEncoder().encodeToString(encryptedBytes); } public static String decryptDataWithAES(String cipherText, SecretKey aesKey) throws Exception { Cipher cipher = Cipher.getInstance("AES"); cipher.init(Cipher.DECRYPT_MODE, aesKey); byte[] decodedBytes = Base64.getDecoder().decode(cipherText); byte[] decryptedBytes = cipher.doFinal(decodedBytes); return new String(decryptedBytes, StandardCharsets.UTF_8); } public static void main(String[] args) throws Exception { // 生成RSA密钥对 KeyPair rsaKeyPair = generateRSAKeyPair(); PublicKey rsaPublicKey = rsaKeyPair.getPublic(); PrivateKey rsaPrivateKey = rsaKeyPair.getPrivate(); // 生成AES密钥 SecretKey aesKey = generateAESKey(); // 使用RSA公钥加密AES密钥 String encryptedAESKey = encryptAESKeyWithRSA(aesKey, rsaPublicKey); // 使用RSA私钥解密AES密钥 SecretKey decryptedAESKey = decryptAESKeyWithRSA(encryptedAESKey, rsaPrivateKey); // 使用AES密钥加密数据 String plainText = "Large amount of sensitive data"; String encryptedData = encryptDataWithAES(plainText, decryptedAESKey); // 使用AES密钥解密数据 String decryptedData = decryptDataWithAES(encryptedData, decryptedAESKey); System.out.println("Original Data: " + plainText); System.out.println("Encrypted Data: " + encryptedData); System.out.println("Decrypted Data: " + decryptedData); } }

国密算法加密案例

需在 Maven 项目的 pom.xml 中添加 Bouncy Castle 库的依赖：

xml

代码解读

复制代码

<dependency> <groupId>org.bouncycastle</groupId> <artifactId>bcprov-jdk15on</artifactId> <version>1.70</version> </dependency>

对称加密算法

SM4 算法

java

代码解读

复制代码

import org.bouncycastle.crypto.engines.SM4Engine; import org.bouncycastle.crypto.modes.CBCBlockCipher; import org.bouncycastle.crypto.paddings.PaddedBufferedBlockCipher; import org.bouncycastle.crypto.params.KeyParameter; import org.bouncycastle.crypto.params.ParametersWithIV; import org.bouncycastle.jce.provider.BouncyCastleProvider; import org.bouncycastle.util.encoders.Hex; import java.security.Security; public class SM4Example { static { // 添加 Bouncy Castle 安全提供者 Security.addProvider(new BouncyCastleProvider()); } /** * SM4 加密方法 * @param plainText 待加密的明文 * @param key 加密使用的密钥 * @param iv 初始化向量 * @return 加密后的密文 * @throws Exception 加密过程中可能抛出的异常 */ public static byte[] encrypt(String plainText, byte[] key, byte[] iv) throws Exception { // 创建 SM4 引擎并使用 CBC 模式 PaddedBufferedBlockCipher cipher = new PaddedBufferedBlockCipher(new CBCBlockCipher(new SM4Engine())); // 初始化加密模式 cipher.init(true, new ParametersWithIV(new KeyParameter(key), iv)); // 将明文转换为字节数组 byte[] inputBytes = plainText.getBytes("UTF-8"); // 创建存储加密结果的字节数组 byte[] output = new byte[cipher.getOutputSize(inputBytes.length)]; // 处理输入字节数组 int length = cipher.processBytes(inputBytes, 0, inputBytes.length, output, 0); // 完成加密操作 length += cipher.doFinal(output, length); // 截取实际加密后的有效数据 byte[] encrypted = new byte[length]; System.arraycopy(output, 0, encrypted, 0, length); return encrypted; } /** * SM4 解密方法 * @param cipherText 待解密的密文 * @param key 解密使用的密钥 * @param iv 初始化向量 * @return 解密后的明文 * @throws Exception 解密过程中可能抛出的异常 */ public static byte[] decrypt(byte[] cipherText, byte[] key, byte[] iv) throws Exception { // 创建 SM4 引擎并使用 CBC 模式 PaddedBufferedBlockCipher cipher = new PaddedBufferedBlockCipher(new CBCBlockCipher(new SM4Engine())); // 初始化解密模式 cipher.init(false, new ParametersWithIV(new KeyParameter(key), iv)); // 创建存储解密结果的字节数组 byte[] output = new byte[cipher.getOutputSize(cipherText.length)]; // 处理输入字节数组 int length = cipher.processBytes(cipherText, 0, cipherText.length, output, 0); // 完成解密操作 length += cipher.doFinal(output, length); // 截取实际解密后的有效数据 byte[] decrypted = new byte[length]; System.arraycopy(output, 0, decrypted, 0, length); return decrypted; } public static void main(String[] args) { try { // 示例密钥，长度为 128 位（16 字节） byte[] key = Hex.decode("0123456789abcdeffedcba9876543210"); // 示例初始化向量，长度为 128 位（16 字节） byte[] iv = Hex.decode("0123456789abcdeffedcba9876543210"); // 待加密的明文 String plainText = "Hello, SM4!"; // 调用加密方法进行加密 byte[] encrypted = encrypt(plainText, key, iv); // 调用解密方法进行解密 byte[] decrypted = decrypt(encrypted, key, iv); System.out.println("原始明文: " + plainText); System.out.println("加密后的密文: " + Hex.toHexString(encrypted)); System.out.println("解密后的明文: " + new String(decrypted, "UTF-8")); } catch (Exception e) { e.printStackTrace(); } } }

非对称加密算法

SM2 算法

java

代码解读

复制代码

import org.bouncycastle.asn1.gm.GMNamedCurves; import org.bouncycastle.asn1.x9.X9ECParameters; import org.bouncycastle.crypto.AsymmetricCipherKeyPair; import org.bouncycastle.crypto.engines.SM2Engine; import org.bouncycastle.crypto.generators.ECKeyPairGenerator; import org.bouncycastle.crypto.params.*; import org.bouncycastle.jce.provider.BouncyCastleProvider; import org.bouncycastle.util.encoders.Hex; import java.security.*; public class SM2Example { static { // 添加 Bouncy Castle 安全提供者 Security.addProvider(new BouncyCastleProvider()); } /** * 生成 SM2 密钥对 * @return 生成的密钥对 * @throws NoSuchAlgorithmException 若指定的算法不可用 * @throws InvalidAlgorithmParameterException 若算法参数无效 */ public static AsymmetricCipherKeyPair generateKeyPair() throws NoSuchAlgorithmException, InvalidAlgorithmParameterException { // 获取 SM2 曲线的参数 X9ECParameters sm2Parameters = GMNamedCurves.getByName("sm2p256v1"); // 定义椭圆曲线域参数 ECDomainParameters domainParameters = new ECDomainParameters( sm2Parameters.getCurve(), sm2Parameters.getG(), sm2Parameters.getN(), sm2Parameters.getH() ); // 创建椭圆曲线密钥对生成器 ECKeyPairGenerator keyPairGenerator = new ECKeyPairGenerator(); // 初始化密钥对生成器 keyPairGenerator.init(new ECKeyGenerationParameters(domainParameters, new SecureRandom())); // 生成密钥对 return keyPairGenerator.generateKeyPair(); } /** * SM2 加密方法 * @param plainText 待加密的明文 * @param publicKey 加密使用的公钥 * @return 加密后的密文 * @throws Exception 加密过程中可能抛出的异常 */ public static byte[] encrypt(String plainText, ECPublicKeyParameters publicKey) throws Exception { // 创建 SM2 引擎 SM2Engine sm2Engine = new SM2Engine(); // 初始化加密模式，并使用随机数 sm2Engine.init(true, new ParametersWithRandom(publicKey, new SecureRandom())); // 处理明文并返回加密结果 return sm2Engine.processBlock(plainText.getBytes("UTF-8"), 0, plainText.getBytes("UTF-8").length); } /** * SM2 解密方法 * @param cipherText 待解密的密文 * @param privateKey 解密使用的私钥 * @return 解密后的明文 * @throws Exception 解密过程中可能抛出的异常 */ public static byte[] decrypt(byte[] cipherText, ECPrivateKeyParameters privateKey) throws Exception { // 创建 SM2 引擎 SM2Engine sm2Engine = new SM2Engine(); // 初始化解密模式 sm2Engine.init(false, privateKey); // 处理密文并返回解密结果 return sm2Engine.processBlock(cipherText, 0, cipherText.length); } public static void main(String[] args) { try { // 生成 SM2 密钥对 AsymmetricCipherKeyPair keyPair = generateKeyPair(); // 获取公钥参数 ECPublicKeyParameters publicKey = (ECPublicKeyParameters) keyPair.getPublic(); // 获取私钥参数 ECPrivateKeyParameters privateKey = (ECPrivateKeyParameters) keyPair.getPrivate(); // 待加密的明文 String plainText = "Hello, SM2!"; // 调用加密方法进行加密 byte[] encrypted = encrypt(plainText, publicKey); // 调用解密方法进行解密 byte[] decrypted = decrypt(encrypted, privateKey); System.out.println("原始明文: " + plainText); System.out.println("加密后的密文: " + Hex.toHexString(encrypted)); System.out.println("解密后的明文: " + new String(decrypted, "UTF-8")); } catch (Exception e) { e.printStackTrace(); } } }

哈希算法

SM3 算法

java

代码解读

复制代码

public class SM3Example { static { // 添加 Bouncy Castle 安全提供者 Security.addProvider(new BouncyCastleProvider()); } /** * 计算 SM3 哈希值 * @param input 输入的字符串 * @return 计算得到的 SM3 哈希值（十六进制字符串） */ public static String hash(String input) { // 创建 SM3 摘要对象 SM3Digest digest = new SM3Digest(); // 将输入字符串转换为字节数组 byte[] inputBytes = input.getBytes(); // 更新摘要对象的输入 digest.update(inputBytes, 0, inputBytes.length); // 创建存储哈希结果的字节数组 byte[] hashBytes = new byte[digest.getDigestSize()]; // 完成哈希计算 digest.doFinal(hashBytes, 0); // 将哈希结果转换为十六进制字符串 return Hex.toHexString(hashBytes); } public static void main(String[] args) { // 待计算哈希值的输入字符串 String input = "Hello, SM3!"; // 调用哈希计算方法 String hashValue = hash(input); System.out.println("输入字符串: " + input); System.out.println("SM3 哈希值: " + hashValue); } }

如何选择合适的加密方式？

在实际应用中，我们需要根据具体需求选择合适的加密方式：

密码存储 ：优先选择哈希加密（如 SHA-256、BCrypt）。
数据传输与存储 ：对称加密（如 AES）效率更高。
身份认证与密钥交换 ：非对称加密（如 RSA、ECC）更为适合。
高安全性需求 ：组合加密方式能提供更全面的保护。

此外，开源工具包（如 Hutool）提供了丰富的加密工具类，可以帮助我们轻松实现各种加密功能。

额外策略：构建全方位密码安全体系

为了进一步保障密码安全，我们可以采取以下策略，并给出相应的 Java 实例代码。

1. 强密码策略

要求密码具备一定的复杂度，必须包含大写字母、小写字母、数字和特殊字符，且达到规定的长度。例如，规定密码长度至少为 8 位，包含至少 1 个大写字母、1 个小写字母、1 个数字和 1 个特殊字符。这样可以大大增加密码被破解的难度。

1. 避免常见密码

常见密码不仅包括简单的 “123456”“password”“admin” 等，还涵盖密码包含连续的斜向键盘输入（如 “qazwsx”）、常用的数据库或操作系统等词组（如 “mysql”“windows”）、连续的横向键盘输入（如 “asdfgh”）、连续的数字和字母（如 “abc123”）以及重复的字符输入（如 “aaaaaa”）等情况。通过详细的规则检查，可以有效避免用户设置容易被破解的密码。

1. 限制登录尝试次数

为防止暴力破解，当用户连续输入错误密码达到一定次数后，暂时锁定该账号一段时间。例如，连续 5 次输入错误密码，账号锁定 15 分钟。

1. 多因素认证

除了传统的密码认证外，引入其他认证因素，如短信验证码、硬件令牌、指纹识别、面部识别等。多因素认证大大提高了账号的安全性，即使密码泄露，没有其他认证因素也无法登录系统。

1. 定期更新密码

提醒用户定期更换密码，如每 3 - 6 个月更换一次。可以在系统中设置密码过期提醒功能，当密码即将过期时，及时通知用户进行更换。

1. 密码找回安全验证

在用户忘记密码进行找回操作时，增加额外的安全验证步骤，如验证注册时的手机号码、电子邮箱等预留信息，确保是账号本人在操作。

1. 密码安全审计

定期对系统中的密码使用情况进行审计，检查是否存在弱密码、异常的密码修改行为等。可以通过编写脚本或使用专业的安全审计工具来实现。

示例代码：密码安全工具类

java

代码解读

复制代码

import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.util.regex.Pattern; /** * 密码工具类 */ class PasswordSecurityUtil { private static final Logger LOGGER = LoggerFactory.getLogger(PasswordSecurityUtil.class); // 强密码正则表达式 private static final String STRONG_PASSWORD_REGEX = "^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=!])(?=\S+$).{8,}$"; private static final Pattern PASSWORD_PATTERN = Pattern.compile(STRONG_PASSWORD_REGEX); // 常见密码词组 private static final String[] COMMON_WORDS = {"mysql", "windows", "oracle", "password", "admin"}; // 横向键盘输入 private static final String[] ROWS = {"qwertyuiop", "asdfghjkl", "zxcvbnm"}; // 斜向键盘输入 private static final String[] DIAGONALS = {"qaz", "wsx", "edc", "rfv", "tgb", "yhn", "ujm", "ik,", "ol.", "p;/"}; /** * 检查密码是否符合强密码策略 * @param password 要检查的密码字符串。 * @return 如果密码符合强密码策略，则返回true；否则返回false。 */ public static boolean isStrongPassword(String password) { boolean matches = PASSWORD_PATTERN.matcher(password).matches(); LOGGER.info("密码是否符合强密码策略：{}", matches); return matches; } /** * 检查是否包含常见词组 * @param password 要检查的密码字符串。 * @return 如果密码包含常见词组，则返回true；否则返回false。 */ public static boolean containsCommonWords(String password) { for (String word : COMMON_WORDS) { if (password.toLowerCase().contains(word)) { LOGGER.info("密码包含常见词组"); return true; } } return false; } /** * 用于检查密码中是否存在连续的横向键盘输入，通过传入 consecutiveLength 参数来动态控制连续字符的位数。 * @param password 要检查的密码字符串。 * @param consecutiveLength 连续字符的位数，例如设置为3时将检查是否存在三个连续的横向键盘输入。 * @return */ public static boolean hasConsecutiveHorizontalKeys(String password, int consecutiveLength) { password = password.toLowerCase(); for (String row : ROWS) { for (int i = 0; i <= row.length() - consecutiveLength; i++) { String seq = row.substring(i, i + consecutiveLength); if (password.contains(seq) || password.contains(new StringBuilder(seq).reverse().toString())) { LOGGER.info("存在连续的横向键盘输入: {}", seq); return true; } } } return false; } /** * 检查是否有连续的斜向键盘输入 * @param password 要检查的密码字符串。 * @param consecutiveLength 连续字符的位数，例如设置为3时将检查是否存在三个连续的斜向键盘输入。 * @return 如果密码中存在连续的斜向键盘输入，则返回true，否则返回false。 */ public static boolean hasConsecutiveDiagonalKeys(String password, int consecutiveLength) { password = password.toLowerCase(); for (String diag : DIAGONALS) { if (diag.length() >= consecutiveLength) { for (int i = 0; i <= diag.length() - consecutiveLength; i++) { String seq = diag.substring(i, i + consecutiveLength); if (password.contains(seq) || password.contains(new StringBuilder(seq).reverse().toString())) { LOGGER.info("存在连续的斜向键盘输入: {}", seq); return true; } } } } return false; } /** * 检查密码中是否存在连续的数字或字母 * @param password 要检查的密码字符串。 * @param consecutiveLength 连续字符的位数，例如设置为3时将检查是否存在三个连续的数字或字母。 * @return 如果密码中存在连续的数字或字母，则返回true，否则返回false。 */ public static boolean hasConsecutiveChars(String password, int consecutiveLength) { password = password.toLowerCase(); for (int i = 0; i <= password.length() - consecutiveLength; i++) { boolean isConsecutive = true; for (int j = 0; j < consecutiveLength - 1; j++) { char c1 = password.charAt(i + j); char c2 = password.charAt(i + j + 1); if (!((Character.isLetterOrDigit(c1) && Character.isLetterOrDigit(c2)) && (c2 - c1 == 1 || c1 - c2 == 1))) { isConsecutive = false; break; } } if (isConsecutive) { LOGGER.info("存在连续的数字或字母"); return true; } } return false; } /** * 检查密码中是否存在重复的字符 * @param password 要检查的密码字符串。 * @param consecutiveLength 连续字符的位数，例如设置为3时将检查是否存在三个重复的字符。 * @return 如果密码中存在重复的字符，则返回true，否则返回false。 */ public static boolean hasRepeatedChars(String password, int consecutiveLength) { for (int i = 0; i <= password.length() - consecutiveLength; i++) { boolean isRepeated = true; char firstChar = password.charAt(i); for (int j = 1; j < consecutiveLength; j++) { if (password.charAt(i + j) != firstChar) { isRepeated = false; break; } } if (isRepeated) { LOGGER.info("存在重复的字符"); return true; } } return false; } /** * 综合检查密码是否规范 * @param password 要检查的密码字符串。 * @param consecutiveLength 连续字符的位数，例如设置为3时将检查是否存在三个重复的字符。 * @return 如果密码规范，则返回true；否则返回false。 */ public static boolean isPasswordValid(String password, int consecutiveLength) { return isStrongPassword(password) && !containsCommonWords(password) && !hasConsecutiveHorizontalKeys(password, consecutiveLength) && !hasConsecutiveDiagonalKeys(password, consecutiveLength) && !hasConsecutiveChars(password, consecutiveLength) && !hasRepeatedChars(password, consecutiveLength); } } // 测试类 public class PasswordSecurityTest { public static void main(String[] args) { String validPassword = "Abc@123456"; String invalidPassword1 = "qazwsx123"; String invalidPassword2 = "Acc@1222.213"; String invalidPassword3 = "Acc@122.213"; int consecutiveLength = 3; // 测试密码有效性 System.out.println("密码有效: " + PasswordSecurityUtil.isPasswordValid(validPassword, consecutiveLength)); System.out.println("密码有效: " + PasswordSecurityUtil.isPasswordValid(invalidPassword1, consecutiveLength)); System.out.println("密码有效: " + PasswordSecurityUtil.isPasswordValid(invalidPassword2, consecutiveLength)); System.out.println("密码有效: " + PasswordSecurityUtil.isPasswordValid(invalidPassword3, consecutiveLength)); } }