各大加密算法对比(原理、性能、安全、运用)

最新推荐文章于 2025-07-24 13:44:19 发布

原创最新推荐文章于 2025-07-24 13:44:19 发布 · 1.1k 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#安全

文章详细比较了对称加密（如DES、AES）和非对称加密（如RSA）的原理，以及MD5、SHA-256的不可逆特性。实测结果显示AES和MD5性能相近，RSA相对较慢。还探讨了算法的安全性和适用场景，如MD5用于校验，AES用于加密传输。

原理

按加密可逆可以分为：加密可逆算法和加密不可逆算法。加密可逆算法又可以分为：对称加密和非对称加密。

1、加密不可逆算法：一般采用hash算法加密，其原理一般是将原文长度补位成64的倍数，接着初始化固定长度的缓存值，经过循环与分组后的明文进行与操作、或操作、非操作、异或操作改变缓存值，最后的缓存值就是密文。该算法加密得到的密文是没有解密算法的，是不可逆的。常见的不可逆算法有：MD5，SHA、SM3。

2、对称加密算法：加密解密密钥相同，明文加密成密文后，密文是可以通过解密恢复原文的，其原理一般是将原文分组，经过原文位置调换、密钥生成、原文与密钥进行轮函数(异或运算、多项式运算等)处理、分组单元进行字典表置换或位置换等操作，将明文转化成密文。一般解密使用逆函数、返位移或字典表操作可以将密文转化为原文。常见的对称加密算法有：DES、3DES、AES、SM4、RC4、TEA、IDEA。

3、非对称加密算法：加密解密的密钥不同，其原理一般是用复杂的数学难题来做公钥私钥。即是获取了公钥，也很难计算出私钥。而且这些组成公钥私钥的数字在特定公式下，能将原文(O)和密文©相互转化。比如RSA的公钥（E,N）和私钥（D,N）都由两个数组成，但能通过公式 C= mod N以及 O= mod N 相互转化密文和原文。常见的非对称加密算法有：RSA、ECC。

性能

原理分析：非对称采用原文与缓存值hash函数循环进行与或非等操作，返回值也小，速度应该是最快的。而对称加密需要按位或分组与密钥进行轮函数处理，速度应该慢于不可逆加密算法。非对称加密算法由于计算量巨大，应该是最慢的。

实测：本次实测以Hutool工具的加密算法为准，测试md5、sha-256、des、aes、rsa的性能，分别测试它们在不同数量级原文下的加密速度。测试代码如下：

package com.longqi.bootsecurity;

import cn.hutool.core.util.HexUtil;
import cn.hutool.crypto.SecureUtil;
import cn.hutool.crypto.asymmetric.KeyType;
import cn.hutool.crypto.asymmetric.RSA;
import cn.hutool.crypto.symmetric.AES;
import cn.hutool.crypto.symmetric.DES;
import cn.hutool.crypto.symmetric.SymmetricAlgorithm;
import org.apache.commons.lang3.RandomStringUtils;

import java.security.KeyPair;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.util.ArrayList;
import java.util.List;

/**
 * @author LQ
 * @projectName boot-integration
 * @description: 加密测试
 * @date 2023/3/2 20:35
 */
public class Application {

    public static void main(String[] args) {
        int len = 100;
        // 准备11个原文，每个算法第一次运行时间不记录，运行时间为后10次的平均值。
        List<String> dataList = new ArrayList<>(16);
        for (int i=0;i<11;i++){
            dataList.add(RandomStringUtils.randomAlphanumeric(len));
        }
        System.out.println("原文长度："+len);
        System.out.println("原文："+dataList.get(0));
        // 不可逆加密
        md5(dataList);
        sha256(dataList);
        // 对称加密
        des(dataList);
        aes(dataList);
        // 非对称加密
        rsa(dataList);
    }


    public static void md5(List<String> dataList){
        String encode = SecureUtil.md5(dataList.get(0));
        long startTime = System.nanoTime();
        for(int i=1;i<11;i++){
            SecureUtil.md5(dataList.get(i));
        }
        long endTime = System.nanoTime();
        System.out.println("MD5耗时："+(endTime-startTime)/10+"ns");
        System.out.println("MD5密文："+encode);
    }

    public static void sha256(List<String> dataList){
        String encode = SecureUtil.sha256(dataList.get(0));
        long startTime = System.nanoTime();
        for(int i=1;i<11;i++){
            SecureUtil.sha256(dataList.get(i));
        }
        long endTime = System.nanoTime();
        System.out.println("SHA256耗时："+(endTime-startTime)/10+"ns");
        System.out.println("SHA256密文："+encode);
    }

    public static void des(List<String> dataList){
        byte[] key = SecureUtil.generateKey(SymmetricAlgorithm.DES.getValue()).getEncoded();
        System.out.println("DES密钥："+ HexUtil.encodeHexStr(key));
        DES des = SecureUtil.des(key);
        String encode = des.encryptHex(dataList.get(0));
        long startTime = System.nanoTime();
        for(int i=1;i<11;i++){
            des.encryptHex(dataList.get(i));
        }
        long endTime = System.nanoTime();
        System.out.println("DES耗时："+(endTime-startTime)/10+"ns");
        System.out.println("DES密文："+encode);
    }

    public static void aes(List<String> dataList){
        byte[] key = SecureUtil.generateKey(SymmetricAlgorithm.AES.getValue()).getEncoded();
        System.out.println("AES密钥："+ HexUtil.encodeHexStr(key));
        AES aes = SecureUtil.aes(key);
        String encode = aes.encryptHex(dataList.get(0));
        long startTime = System.nanoTime();
        for(int i=1;i<11;i++){
            aes.encryptHex(dataList.get(i));
        }
        long endTime = System.nanoTime();
        System.out.println("AES耗时："+(endTime-startTime)/10+"ns");
        System.out.println("AES密文："+encode);
    }

    public static void rsa(List<String> dataList){
        KeyPair pair = SecureUtil.generateKeyPair("RSA");
        PrivateKey privateKey = pair.getPrivate();
        PublicKey publicKey = pair.getPublic();
        System.out.println("RSA公钥："+ publicKey.toString());
        System.out.println("RSA私钥："+ privateKey.toString());
        RSA rsa = SecureUtil.rsa(privateKey.getEncoded(),publicKey.getEncoded());
        String encode = rsa.encryptHex(dataList.get(0), KeyType.PublicKey);
        long startTime = System.nanoTime();
        for(int i=1;i<11;i++){
            rsa.encryptHex(dataList.get(i), KeyType.PublicKey);
        }
        long endTime = System.nanoTime();
        System.out.println("RSA耗时："+(endTime-startTime)/10+"ns");
        System.out.println("RSA密文："+encode);
    }


}

运行会打印原文、密文、耗时，密钥，其中的耗时第一次耗时不计算，以各算法后10次平均值打印具体如下：