密码安全：从哈希到国密算法

最新推荐文章于 2025-03-18 00:58:40 发布
最新推荐文章于 2025-03-18 00:58:40 发布
阅读量1k 收藏 24
点赞数 19
文章标签： 算法 安全 哈希算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43256563/article/details/145591115
版权

日积月累，水滴石穿 😄

前言

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

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

常见加密方式

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
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
<dependency>
    <groupId>org.mindrot</groupId>
    <artifactId>jbcrypt</artifactId>
    <version>0.4</version>
</dependency>

<!--或者加入 spring-security-->
<!--<dependency>
    <groupId>org.springframework.security</groupId>
    <artifactId>spring-security-crypto</artifactId>
    <version>4.2.13.RELEASE</version>
</dependency>-->
  • BCryptExample
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 加密后存储在数据库中。当需要查询订单时，再使用相同的密钥进行解密，确保用户订单信息的安全。

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);
    }
}

非对称加密案例

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

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);
    }
}

组合加密方式

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 库的依赖：

<dependency>
    <groupId>org.bouncycastle</groupId>
    <artifactId>bcprov-jdk15on</artifactId>
    <version>1.70</version>
</dependency>
对称加密算法
SM4 算法
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 算法
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 算法
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. 密码安全审计

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

示例代码：密码安全工具类
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));


    }
}

让密码安全成为一种习惯

密码安全不仅仅是技术问题，更是一种意识和习惯。通过合理选择加密方式、实施额外安全策略，我们可以共同构建一个更加安全的数字世界。

希望这篇文章能为您带来启发，让您在数字时代的旅程中更加安心、从容！

Tire.
关注
《网络安全自学教程》- 对称加密算法、非对称加密算法、哈希算法、国密算法
wangyuxiang946的博客
07-01 1万+
这篇文章为大家讲解密码学有哪几类算法，对称加密算法、非对称加密算法、哈希算法的常见算法有哪些。
保护国家机密：国密算法在信息安全中的应用与挑战（一）
凛鼕将至的博客
01-17 1576
Java国密加解密算法是指基于国家密码管理局（GMC）制定的国家密码算法标准（GB/T 32907）在Java语言中实现的加解密算法。这些算法主要用于保护国家机密信息的安全性。Java国密加解密算法包括对称加密算法、非对称加密算法和哈希算法。其中，对称加密算法主要包括SM1和SM4算法；非对称加密算法主要包括SM2算法；哈希算法主要包括SM3算法。SM1是一种分组密码算法，其密钥长度为128位，使用的是对称密钥加密技术，适用于对大数据进行加密和解密。
【国密算法】深入理解国密算法：原理、实践及注意事项
lmj3732018的博客
02-26 8334
国密算法主要包括对称加密算法、非对称加密算法和哈希算法。其中，对称加密算法包括SM1算法，非对称加密算法包括SM2算法，哈希算法包括SM3算法。这些算法在设计上充分考虑了安全性、效率和国内法律法规的要求。SM1算法：SM1是一种分组密码算法，适用于对称加密。它采用了非线性的S盒和置换运算，具有良好的安全性和高效率。SM2算法：SM2是一种非对称加密算法，适用于数字签名、密钥交换等场景。它基于椭圆曲线密码学，具有与RSA算法相当的安全性，但更加高效。SM3算法。
从古至今数据安全的守护者：哈希算法和加密方法的数据安全进化之旅
Hanko的专栏
06-09 1698
加密算法可以包括数据转换、替换、混淆、扩散和迭代等操作。设计时需要注意算法的复杂度和安全性，确保算法能够抵抗常见的攻击方式。
SM系列算法详解：从国际通用算法到国密算法崛起之路
phyllisyuell的博客
05-23 3714
SM算法学习
SM4分组加密算法原理和c语言实现
热门推荐
快乐时光
11-05 1万+
一、前言 在之前的文章中介绍了《SM3国密杂凑值算法的原理和c语言实现》，这篇文章主要是用c语言撸一个SM4分组加密算法。 随着信息安全的普及以及等级保护等安全政策落地，国密算法越来越频繁的出现在项目开发中，在较新的一些openssl版本中已经有了SM2、SM3、SM4等国密接口，还有Gmssl等开源加密库也均对国密算法进行了支持。 不过在一些底层的开发中，尤其涉及到内核驱动层开发、TCM等密码卡开发，现有的一些加密库由于过多的依赖，是无法直接使用的，这时候恐怕就得要求开发人员......
盐值加密介绍
AndyLizh的专栏
06-03 1万+
简单说就是为了使相同的密码拥有不同的hash值的一种手段 就是盐化 MD5自身是不可逆的 但是目前网路上有很多数据库支持反查询 如果用户密码数据库不小心被泄露 黑客就可以通过反查询方式获得用户密码 或者对于数据库中出现频率较高的hash码(即很多人使用的)进行暴力破解(因为它通常都是弱口令) 盐值就是在密码hash过程中添加的额外的随机值 比如我的id是癫ω倒④ゞ 密码是123456 存在数据
安全密码算法：SM3哈希算法介绍
Angelic_lan的博客
08-16 1780
国密算法之一，哈希算法的一种，也是密码杂凑算法。可以将不定长的输入消息message，经过SM3算法计算后输出为32B固定长度的哈希值（hash value）。哈希算法的实质是单向散列函数（one-way hash function），其特点是，输入数据有1bit的改变都有很大概率会产生不同的散列值，因而很多场景中会使用散列值来验证输入消息的完整性。
西电捷通HUFU CSP：纯软件实现国密算法
HUFU Cipher Service Provider是西电捷通对国密算法的一种创新实现，它填补了CSP领域纯软件实现的空白，提高了国产密码算法在Windows平台上的可用性和易用性，为开发者提供了更灵活的选择，同时也增强了系统的安全性...
手把手教你玩转SM国密算法：从入门到放弃
最新发布
skyksksksksks的博客
03-18 1028
简单来说，国密算法是咱们中国自主研发的一套加密技术，对标国际通用的RSA、AES这些“大牌”。就像你不想天天吃汉堡薯条，偶尔也得来顿火锅一样——信息安全这碗饭，咱得端稳自己的锅！某政务系统升级国密算法后，API响应时间从200ms降到50ms，同时抗住了每秒10万次的攻击——这就是国密的实力！别想歪了，这里的SM不是某字母圈的缩写，而是“商密”的拼音首字母（ShangMi），也就是国家商用密码算法！举个栗子，假设你想给对象发一条加密的“我爱你”，但又怕被隔壁老王截获，这时候SM2就能派上用场！
国密SM4的5种加密模式(ECB CBC CFB OFB CTR XTS)源码及其参考文档.rar
11-13
包含内容：SM4国密加密算法C语言实现 包括 Spec，C代码，测试用例和分组密码有五种工作体制： 1.电码本模式（Electronic Codebook Book (ECB)）； 2.密码分组链接模式（Cipher Block Chaining (CBC)）； 3.计算器模式（Counter (CTR)）； 4.密码反馈模式（Cipher FeedBack (CFB)）； 5.输出反馈模式（Output FeedBack (OFB)）
国密加密解密sm4完整版
05-23
国密加密解密sm4完整版，完善了会出现31位数字的问题。
国密算法及使用场景
understanding___的博客
02-20 2366
原始报文指的是需要加密处理的报文，当原始报文经过了一些 hash 算法处理之后就成为了数字摘要，经过SHA256 （注：SHA256是SHA-2下细分出的一种算法）或者 RSA 处理之后，数字摘要经过密钥加密之后就成为了数字签名。
【数据存储加密】国密算法
weixin_46176823的博客
06-09 1048
某银行，由于行内要求以及系统安全考虑，现需要对数据库存储的敏感信息进行加密存储。
国密算法的应用场景
zntsbkhhh的博客
10-30 6087
国家密码管理局推出的SM系列密码算法是为了从根本上摆脱我国对国外密码技术的依赖,实现从密码算法层面掌控核心的信息安全技术。 随着国密算法推广的延伸，金融领域引入SM2、SM3、SM4等算法逐步替换原有的RSA、ECC等国外算法。现有银联银行卡联网、银联IC两项规范都引入了国密算法相关要求。如下图所示为金融活动中会应用到国密算法的业务。 金融领域的国密算法应用场景 网上证券和基金 身份认证，资用户信...
国密算法与适用范围
zhmmx的专栏
07-01 1631
国密算法与适用范围
高阶数据结构之哈希的应用
蔡欣致的个人博客
02-03 1189
不会数据结构的程序猿不是合格的程序猿，详细总结有关哈希的各种应用（位图和布隆过滤器及其应用、一致性哈希、哈希加密与加盐）~
浅谈国密算法
weixin_33923148的博客
05-08 2340
2019独角兽企业重金招聘Python工程师标准>>> ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值