3.Java开源AES/SM4/3DES对称加密算法的验证说明

置顶 已于 2023-07-02 21:07:39 修改
阅读量780 收藏
点赞数
分类专栏： biuqu项目 加解密组件 文章标签： AES SM4 3DES 加密 JAVA 对称加密 开源
于 2023-05-22 21:39:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dobuy/article/details/130815832
版权

3.开源AES/SM4/3DES对称加密算法的验证说明

前期内容导读：

  1. Java开源RSA/AES/SHA1/PGP/SM2/SM3/SM4加密算法介绍
  2. Java开源AES/SM4/3DES对称加密算法介绍及其实现

  • 在开源加密组件中，介绍了开源AES/SM4/3DES对称加密算法介绍及其实现 ，但是并没有对总结的结论做说明。现在从摘抄的单元测试类中，对对称加密做一轮充分的验证说明，以便加深大家对对称加密的理解；

  • 本文所列举的所有代码均可从bq-encryptor组件 开源代码的单元测试类中获取；

  • 加密组件引入方法：

    <dependency>
    <groupId>com.biuqu</groupId>
    <artifactId>bq-encryptor</artifactId>
    <version>1.0.5</version>
</dependency>

  • bq-encryptor组件 的github地址：https://github.com/woollay/bq-encryptor

1.对称加解密验证设计

  • 在开源AES/SM4/3DES对称加密算法介绍及其实现 中，介绍了对称加密的秘钥长度和分组长度，那就需要验证下，在各种秘钥长度下，对应的秘钥长度是不是固定的；
  • 对称加密有多种工作模式、多种填充算法，它们组合起来会不会有所区别；
  • 对称加密算法支持盐值(加密偏移向量)，盐值对加密上述组合是否有影响；

2.生成秘钥的验证

2.1 AES生成秘钥的验证

2.1.1 从秘钥对象SecretKey生成二进制验证
  • AES加密算法(包括AesEncryption和AesSecureEncryption,二者区别是前者不带盐值，后者带盐值，但是不影响秘钥生成，就不一一列举了)，秘钥长度支持128/192/256(当下没有512的AES加密算法，不信去看下维基百科)，按说生成的秘钥长度都是固定的，如128bit->16byte，192bit->24byte，256bit->32byte；
  • 同理可假定SM4/3DES也是如此；
  • 基于上述分析，可提取对称加密的抽象单元测试基类(BaseSingleEncryptionTest)，其秘钥生成判断逻辑如下：
    //test1:使用任意初始值创建秘钥，秘钥始终是固定长度(和加密算法的长度相同)(3DES除外)
SecretKey key = encryption.createKey(RandomUtils.nextBytes(32));
Assert.assertTrue(key.getEncoded().length == keyLen / 8);
SecretKey key2 = encryption.createKey(RandomUtils.nextBytes(64));
Assert.assertTrue(key2.getEncoded().length == keyLen / 8);
SecretKey key3 = encryption.createKey(RandomUtils.nextBytes(1));
Assert.assertTrue(key3.getEncoded().length == keyLen / 8);
  • AES单元测试类中的完整秘钥生成单元测试方法为：
    @Test
public void createKey()
{
    int[] keyLenList = {128, 192, 256};
    for (int keyLen : keyLenList)
    {
        BaseSingleEncryption encryption = new AesEncryption();
        encryption.setEncryptLen(keyLen);
        super.createKey(encryption, keyLen);
    }
}
2.1.2 从二进制构造SecretKey秘钥对象验证
  • 我们使用加解密时，通常会保存秘钥数据(一般是16进制或者文件保存)，但是在Java语言的使用过程中，只认秘钥对象，所以必须要把秘钥数据反转成秘钥对象；
  • 什么样的秘钥长度数据可以转成合法的秘钥对象呢？
  • 同上节，在BaseSingleEncryptionTest抽象类中的验证代码如下：
    public void toKey(BaseSingleEncryption encryption, int encryptLen)
{
    //test1:可以使用任意长度值获取秘钥对象(仅能生成秘钥)，但是仅合法长度可以加密
    SecretKey secretKey = encryption.toKey(RandomUtils.nextBytes(encryptLen));
    Assert.assertNotNull(secretKey);
    byte[] data1 = RandomUtils.nextBytes(encryptLen - 1);
    byte[] encBytes1 = encryption.encrypt(data1, secretKey.getEncoded(), null);
    System.out.println("data1 len=" + data1.length + ",enc len=" + encBytes1.length);
    Assert.assertTrue(encBytes1.length == encryptLen);
    Assert.assertNotNull(encryption.toKey(RandomUtils.nextBytes(1)));
    Assert.assertNotNull(encryption.toKey(RandomUtils.nextBytes(2 * encryptLen)));
    Assert.assertNotNull(encryption.toKey(RandomUtils.nextBytes(3 * encryptLen + 1)));

    try
    {
        //test2:秘钥长度高于合法秘钥长度会报错
        byte[] key2 = RandomUtils.nextBytes(encryptLen + 1);
        SecretKey secretKey2 = encryption.toKey(key2);
        System.out.println("secretKey2 len=" + secretKey2.getEncoded().length);
        byte[] data2 = RandomUtils.nextBytes(encryptLen);
        byte[] encBytes2 = encryption.encrypt(data2, secretKey2.getEncoded(), null);
        System.out.println("data2 len=" + data2.length + ",enc len=" + encBytes2.length);
        Assert.fail();
    }
    catch (Exception e)
    {
        e.printStackTrace();
        Assert.assertTrue(true);
    }

    try
    {
        //test3:秘钥长度低于合法秘钥长度会报错
        byte[] key3 = RandomUtils.nextBytes(encryptLen - 1);
        SecretKey secretKey3 = encryption.toKey(key3);
        System.out.println("secretKey3 len=" + secretKey3.getEncoded().length);
        byte[] data3 = RandomUtils.nextBytes(encryptLen);
        byte[] encBytes3 = encryption.encrypt(data3, secretKey3.getEncoded(), null);
        System.out.println("data3 len=" + data3.length + ",enc len=" + encBytes3.length);
        Assert.fail();
    }
    catch (Exception e)
    {
        e.printStackTrace();
        Assert.assertTrue(true);
    }
}
  • AES单元测试类中的验证代码如下：
    @Test
public void toKey()
{
    int[] keyLenList = {128, 192, 256};
    for (int keyLen : keyLenList)
    {
        BaseSingleEncryption encryption = new AesEncryption();
        encryption.setEncryptLen(keyLen);
        super.toKey(encryption, 16);
    }
}
    1. 在此次验证中，可根据异常得知：在秘钥长度不为合法值时，会抛出异常:
      Key length not 128/192/256 bits.，这也间接说明秘钥长度最大只有256位；
    2. 在验证过程中，其实还可以发现无论什么长度的秘钥数据反转成秘钥对象，都不会报错，但是在使用对应的加解密方法时就会报错；

2.2 SM4生成秘钥的验证

2.2.1 从秘钥对象SecretKey生成二进制验证
  • 同AES加密算法的单元测试实现相同，仅需要定义测试方法即可：
    @Test
public void createKey()
{
    BaseSingleEncryption encryption = new Sm4Encryption();
    super.createKey(encryption, 128);
}
  • 验证效果也同AES加密算法的单元测试效果相同；
2.2.2 从二进制构造SecretKey秘钥对象验证
  • 同AES加密算法的单元测试实现相同，仅需要定义测试方法即可：
    @Test
public void toKey()
{
    BaseSingleEncryption encryption = new Sm4Encryption();
    super.toKey(encryption, 16);
}
  • 验证效果也同AES加密算法的单元测试效果相同；

2.3 3DES生成秘钥的验证

2.3.1 从秘钥对象SecretKey生成二进制验证
  • 3DES加密算法如上述2个标准的、安全的加密算法不同，它是DES算法的3重叠加，每重秘钥长度是64bit(8byte)，所以总的秘钥长度一定不能低于192bit(24byte)，共用BaseSingleEncryptionTest抽象类后，其单元测试代码如下：
    @Test
public void createKey() throws NoSuchAlgorithmException
{
    BaseSingleEncryption encryption = new Des3Encryption();
    try
    {
        //3DES不允许低于24byte的秘钥,因为无法解析出3个8byte的DES秘钥
        super.createKey(encryption, 192);
    }
    catch (Exception e)
    {
        e.printStackTrace();
    }
}
  • 在秘钥低于192bit(24byte)时，会抛出如下异常：Caused by: java.security.InvalidKeyException: Wrong key size
2.3.2 从二进制构造SecretKey秘钥对象验证
  • 由于3DES加密的秘钥是组合的，比较特殊，无法复用复杂的抽象检测逻辑，故单独设计，代码如下：
    @Test
public void testGetKey()
{
    BaseSingleEncryption encryption = new Des3Encryption();

    byte[] keyBytes = RandomUtils.nextBytes(24);

    //test1: 任意24byte的内容均可以作为3DES的秘钥
    SecretKey secretKey = encryption.toKey(RandomUtils.nextBytes(24));
    System.out.println("init key=" + Hex.toHexString(keyBytes));
    System.out.println("3des key=" + Hex.toHexString(secretKey.getEncoded()));
    Assert.assertTrue(secretKey.getEncoded().length == 24);

    //test2:秘钥对象的二进制和原始秘钥的二进制并不相同
    Assert.assertFalse(Hex.toHexString(secretKey.getEncoded()).equals(Hex.toHexString(keyBytes)));

    byte[] keyBytes2 = RandomUtils.nextBytes(25);
    //test3: 任意大于24byte的内容均可以作为3DES的秘钥，而且只会截取前24byte
    SecretKey secretKey2 = encryption.toKey(keyBytes2);
    Assert.assertTrue(secretKey2.getEncoded().length == 24);
    byte[] subBytes2 = ArrayUtils.subarray(keyBytes2, 0, 24);
    Assert.assertTrue(Hex.toHexString(secretKey2.getEncoded()).equals(Hex.toHexString(encryption.toKey(subBytes2).getEncoded())));
}
  • 从上述可测试通过的用例可知：3DES秘钥是只有前192bit(24byte)有效，且过长的秘钥和截取其192bit的秘钥等同；

3.工作模式和填充模式的组合验证

3.1 AES加解密组合验证

  • AES加密算法的加解密逻辑在抽象后，其测试代码为：
    @Test
public void testEncryptPadding()
{
    int[] keyLenList = {128, 192, 256};
    String[] modes = {"ECB", "CBC", "CTR", "CFB"};
    String[] paddings = {"NoPadding", "PKCS5Padding"};
    for (int keyLen : keyLenList)
    {
        BaseSingleEncryption encryption = new AesEncryption();
        super.doCipher(encryption, keyLen, paddings, modes);
    }
}
  • 在BaseSingleEncryptionTest抽象类的加解密验证逻辑如下：
    public void doCipher(BaseSingleEncryption encryption, int keyLen, String[] paddings, String[] modes)
{
    this.doCipher(encryption, keyLen, 16, paddings, modes);
}

public void doCipher(BaseSingleEncryption encryption, int keyLen, int encGroupLen, String[] paddings,
    String[] modes)
{
    //test1:分段(分组)加密明文长度为n的明文数据，存在填充时，密文长度为(n/encGroupLen+1)*encGroupLen的倍数(除法取整)，无填充时为(n/encGroupLen)*encGroupLen的倍数(除法取整，且n必须为encGroupLen的倍数)
    encryption.setEncryptLen(keyLen);
    SecretKey secretKey = encryption.toKey(RandomUtils.nextBytes(keyLen / 8));
    Assert.assertEquals(secretKey.getEncoded().length, keyLen / 8);
    for (String mode : modes)
    {
        for (String padding : paddings)
        {
            StringBuilder alg = new StringBuilder(encryption.getAlgorithm());
            alg.append("/").append(mode);
            alg.append("/").append(padding);
            encryption.setPaddingMode(alg.toString());

            int paddingLen = 0;
            if (!"NoPadding".equals(padding))
            {
                paddingLen = encGroupLen;
            }
            System.out.println("[" + keyLen + "]padding-1=" + alg);

            byte[] salt = RandomUtils.nextBytes(16);

            if (paddingLen > 0)
            {
                byte[] data1 = RandomUtils.nextBytes(1);
                byte[] encBytes1 = encryption.encrypt(data1, secretKey.getEncoded(), salt);
                byte[] decBytes1 = encryption.decrypt(encBytes1, secretKey.getEncoded(), salt);
                System.out.println("[" + keyLen + "]padding-1=" + alg + ",enc len=" + encBytes1.length);
                System.out.println("[" + keyLen + "]padding-1=" + alg + ",dec len=" + decBytes1.length);
                Assert.assertTrue(encBytes1.length == (data1.length / encGroupLen) * encGroupLen + paddingLen);
                Assert.assertArrayEquals(data1, decBytes1);
            }

            byte[] data2 = RandomUtils.nextBytes(encGroupLen);
            byte[] encBytes2 = encryption.encrypt(data2, secretKey.getEncoded(), salt);
            byte[] decBytes2 = encryption.decrypt(encBytes2, secretKey.getEncoded(), salt);
            System.out.println("[" + keyLen + "]padding-2=" + alg + ",enc len=" + encBytes2.length);
            System.out.println("[" + keyLen + "]padding-2=" + alg + ",dec len=" + decBytes2.length);
            Assert.assertTrue(encBytes2.length == (data2.length / encGroupLen) * encGroupLen + paddingLen);
            Assert.assertArrayEquals(data2, decBytes2);

            byte[] data3 = RandomUtils.nextBytes(keyLen * 2);
            byte[] encBytes3 = encryption.encrypt(data3, secretKey.getEncoded(), salt);
            byte[] decBytes3 = encryption.decrypt(encBytes3, secretKey.getEncoded(), salt);
            System.out.println("[" + keyLen + "]padding-3=" + alg + ",enc len=" + encBytes3.length);
            System.out.println("[" + keyLen + "]padding-3=" + alg + ",dec len=" + decBytes3.length);
            Assert.assertTrue(encBytes3.length == (data3.length / encGroupLen) * encGroupLen + paddingLen);
            Assert.assertArrayEquals(data3, decBytes3);
        }
    }
}
    1. 在验证过程中，会发现NoPadding填充模式下会和其它填充模式的密文不同，非NoPadding下会多一个分组秘钥长度的密文；
    2. 在验证过程中，还会发现ECB模式不支持盐值，后面直接把这个逻辑放到开源源码中去了；

3.2 SM4加解密组合验证

  • SM4密算法的加解密逻辑在抽象后，其测试代码为：
    @Test
public void testEncryptPadding()
{
    int[] keyLenList = {128};
    String[] modes = {"ECB", "CBC", "CTR", "CFB"};
    String[] paddings = {"NoPadding", "PKCS5Padding"};
    //test1:sm4可以分段(分组)加密明文长度为n的明文数据，密文长度为(n/16+1)*16的倍数(除法取整)
    for (int len : keyLenList)
    {
        BaseSingleEncryption encryption = new Sm4Encryption();
        super.doCipher(encryption, len, paddings, modes);
    }
}

3.3 3DES加解密组合验证

  • 3DES密算法的加解密逻辑在抽象后，其测试代码为：
    @Test
public void testEncrypt()
{
    int[] keyLenList = {192};
    String[] modes = {"ECB", "CBC", "CTR", "CFB"};
    String[] paddings = {"NoPadding", "PKCS5Padding"};
    //test1:分段(分组)加密明文长度为n的明文数据，密文长度为(n/encGroupLen+1)*encGroupLen的倍数(除法取整)
    for (int len : keyLenList)
    {
        BaseSingleEncryption encryption = new Des3Encryption();
        super.doCipher(encryption, len, 8, paddings, modes);
    }
}
在编攻城狮
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于Java的SM4（ECB模式，CBC模式）对称加解密实现
wjianwei666的专栏
05-31 1164
加密算法依赖了groupId:org.bouncycastle中的bcprov-jdk，Bouncy Castle (bcprov-jdk15to18)提供了JDK 1.5 to 11 可使用的大量标准加密算法实现，其中包含了SM2，SM3，SM4。* @param key 密钥 (十六进制字符串: B6D8C12920418AFEA57514132E16039A)* @param content 待加密内容（普通字符串: 1234567812345678aa1100）
数据加密算法之国密SM4、SM3、SM2研究及Java实现
热门推荐
gaozhenzhai的博客
09-05 1万+
国密加密算法研究
国密算法 SM4 加解密 java 工具类
李嘉城的博客
07-12 8517
我国国家密码管理局陆续发布了一系列国产加密算法，这其中就包括 SM1、SM2、SM3 、SM4、SM7、SM9、ZUC（祖冲之加密算法）等，SM 代表商密，即商业密码，是指用于商业的、不涉及国家秘密的密码技术。SM1 和 SM7 的算法不公开，其余算法都已成为 ISO/IEC 国际标准
3DES加密java实现
12-22
java实现的3DES加密算法，类中支持多种密钥长度
Java实现sm4加密
weixin_35757531的博客
01-04 4028
Java中可以使用Bouncy Castle库来实现SM4加密。 以下是一个简单的示例代码： import java.security.Security; import org.bouncycastle.jce.provider.BouncyCastleProvider; import org.bouncycastle.util.encoders.Hex; import org.bouncyca...
java sm4 加密&解密
u011504039的博客
08-24 5272
【java代码】java sm4 加密。
java实现国密SM4加密
最新发布
qq_55961709的博客
02-28 4213
最近世界政治影响，我国也开始要求算法的使用，以避免来自外国的黑客入侵。我们在使用加密算法时，有必要选择使用国密算法进行加密SymmetricCrypto 类方法返回类型byte[]byte[]Stringbyte[]byte[]byte[]StringStringStringStringStringStringStringStringStringSymmetricCrypto类的构造方法非常灵活，可以灵活根据自己需要的方式进行构造。
C# 国密SM4/SM3加密算法
07-24
**C# 国密SM4/SM3加密算法详解** 国密SM4和SM3算法是我国自主设计的一系列商用密码标准的重要组成部分，主要用于确保数据安全和通信隐私。这两个算法在.NET环境中同样得到了广泛的应用和实现。 ### SM4算法 SM4是...
sm4算法java源码-gmsm:国密SSL库实现golang国密算法SM2/SM3/SM4
06-18
sm4算法java源码 国密算法库 前言 GM SM2/3/4 library based on Golang 基于Go语言的国密SM2/SM3/SM4加密算法库 说明 1、改造说明 此库主要是开源库（ 1、sm2库中关于默认加密未是使用default_uid进行加解密的。对于...
C++实现3Des算法.zip_3DES算法 C++_3des_C++_visual c_加密算法
07-13
DES是一种对称加密算法，使用56位的密钥对数据进行加密，而3DES是通过三次应用DES算法来提高其安全性，从而提供更强大的加密强度，其密钥长度达到了168位。 在C++中实现3DES算法通常涉及以下几个关键步骤： 1. **...
Win32API 实现 AES/DES/3DES 加密，包括零填充-易语言
06-14
总结一下，使用Win32 API进行AES/DES/3DES加密涉及的关键步骤包括：获取加密上下文、生成或导入密钥、执行加密和解密操作。对于零填充，需要在编码阶段额外处理数据以满足算法要求。易语言提供了与Win32 API交互的...
国密SM系列算法开源工具箱GmSSLJNI Java扩展库Windows x64二进制编译版本
10-09
GmSSL-Java目前提供了随机数生成器、SM3哈希、SM3消息认证码(HMAC-SM3)、SM4加密（包括分组加密和CBC/CTR/GCM加密模式）、ZUC加密、SM2加密/签名、SM9加密/签名、SM2证书解析等功能，可以覆盖目前国密算法主要应用...
通过java实现国密SM4加密解密（笔记）
qq_43712332的博客
10-27 7593
通过java实现SM4加密解密，包含填充与不填充两种模式
国密SM4对称加密Java加解密
wcuu的博客
01-10 8849
SM4.0（原名SMS4.0）是中华人民共和国政府采用的一种分组密码标准，由国家密码管理局于2012年3月21日发布。相关标准为“GM/T 0002-2012《SM4分组密码算法》（原SMS4分组密码算法）”。在密码学中，分组加密（英语：Block cipher），又称分块加密或块密码，是一种对称密钥算法。它将明文分成多个等长的模块（block），使用确定的算法和对称密钥对每组分别加密解密。
SM4算法大文件加密与字符串加密
sky_moon_的博客
02-19 6565
引入包 <!-- 一个开源的加解密算法包 --> <dependency> <groupId>org.bouncycastle</groupId> <artifactId>bcmail-jdk15on</artifactId> <version>1.66</version> </dep
Java封装实现国密SM4对称加解密运算
一切有为法，如梦亦如幻，如露亦如电，应作如是观。
03-11 3072
SM4密码算法是我国自主设计的分组对称密码算法，用于实现数据的加密/解密运算，以保证数据和信息的机密性。 该算法的分组长度为128比特，密钥长度为128比特。（十六进制表示则为32位，明文和密钥等长） 加密算法与密钥扩展算法都采用32轮非线性迭代结构。 密钥扩展算法：将加密密钥变换为轮密钥的运算单元。 数据解密和数据加密的算法结构相同，只是轮密钥的使用顺序相反，解密轮密钥是加密轮密钥的逆序。
SM4加密实现之JAVA方式
liberty888的博客
07-21 2879
SM4加密实现之JAVA方式
国密SM4加解密--Java实现
怪只怪满眼尽是人间烟火
07-26 3391
【代码】国密SM4加解密--Java实现。
使用 Java Bouncy Castle实现国密算法SM4、SM3以及SM2的加密
Rm_mR的博客
06-19 8938
国密算法SM2、SM3、SM4的实现 借助Java库函数 Bouncy Castle
AES、DES与RSA加密算法深度解析
本文将深入解析网络安全中常用的对称加密算法AES（高级加密标准）以及非对称加密算法RSA，同时提及了经典的对称加密算法DES（数据加密标准）及其变体3DES。AES算法以其高效性和安全性而闻名，它支持三种不同密钥长度...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值