常见加密算法介绍

于 2024-07-08 15:37:32 发布
阅读量673 收藏 10
点赞数 22
分类专栏： JAVA 文章标签： 安全 密码学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/progammer10086/article/details/140207841
版权

一、介绍

数据加密是项目中非常常见的业务需求，封装好的三方组件也非常多，自己在工作时也经常会使用到，这次对主流常用的几种加密方式做一个梳理，会分别介绍其使用场景，以及如何使用。

二、对称加密

加密或者解密都需要使用相同的密钥，这意味着只要密钥泄露，数据就可以被随意解密，所以这种加密方式不适用于于三方公司合作或者前后端交互中使用。

一般情况下，对称加密用于数据存储时进行加密，数据在需要使用的时候进行解密，避免在数据库中明文存储的问题。

2.1、AES

2.1.1、 介绍

AES是一个块加密算法，意味着它会将明文数据分成固定大小的块（在AES中，每个块的大小是128位），然后对每个块进行加密。AES支持128位、192位和256位三种长度的密钥，这意味着AES的安全性非常高。

AES的工作过程包括多个加密轮次，每个轮次都包括一系列的操作，包括字节替换（SubBytes）、行移位（ShiftRows）、列混淆（MixColumns）和轮密钥加（AddRoundKey）。这些操作一起确保了AES的高安全性。

AES的一个主要优点是它的效率很高，可以在各种不同的硬件和软件平台上实现，并且可以抵抗各种已知的攻击。因此，AES已经成为了全球最流行的对称加密算法之一，被广泛用于保护敏感的数据。

密钥长度必须是128、192或256位，这对应于16、24或32字节。

2.1.2、 使用

package com.xx.utils;

import lombok.extern.slf4j.Slf4j;
import org.springframework.util.Base64Utils;

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;

@Slf4j
public class AESUtil {

    /**
     * 算法定义
     */
    private static final String AES_ALGORITHM = "AES";
    /**
     * 指定填充方式
     */
    private static final String CIPHER_PADDING = "AES/ECB/PKCS5Padding";

    /**
     * AES加密
     *
     * @param content 待加密内容
     * @param aesKey  密钥key
     * @return 加密后的内容
     */
    public static String encrypt(String content, String aesKey) {
        //判断秘钥是否为16位
        try {
            //设置加密算法，生成秘钥
            SecretKeySpec keySpec = new SecretKeySpec(aesKey.getBytes(StandardCharsets.UTF_8), AES_ALGORITHM);
            // "算法/模式/补码方式"
            Cipher cipher = Cipher.getInstance(CIPHER_PADDING);
            //选择加密
            cipher.init(Cipher.ENCRYPT_MODE, keySpec);
            //根据待加密内容生成字节数组
            byte[] encrypted = cipher.doFinal(content.getBytes(StandardCharsets.UTF_8));
            //返回base64字符串
            return Base64Utils.encodeToString(encrypted);
        } catch (Exception e) {
            log.error("字符串【{}】加密失败：", content, e);
            return null;
        }
    }

    /**
     * 解密
     *
     * @param content 待解密内容
     * @param aesKey  密钥Key
     * @return 密码
     */
    public static String decrypt(String content, String aesKey) {
        try {
            SecretKeySpec keySpec = new SecretKeySpec(aesKey.getBytes(StandardCharsets.UTF_8), AES_ALGORITHM);
            Cipher cipher = Cipher.getInstance(CIPHER_PADDING);
            cipher.init(Cipher.DECRYPT_MODE, keySpec);

            byte[] decodeBase64 = Base64Utils.decodeFromString(content);
            return new String(cipher.doFinal(decodeBase64), StandardCharsets.UTF_8);
        } catch (Exception e) {
            log.error("字符串【{}】加密失败：", content, e);
            return null;
        }
    }

    public static void main(String[] args) {
        String key = "1111111111111111";
        String encrypt = encrypt("hello aes", key);
        String decrypt = decrypt(encrypt, key);

        System.out.println("encrypt:" + encrypt);
        System.out.println("decrypt:" + decrypt);
    }
}

2.1.3、 性能测试

测试代码

public static void main(String[] args) {
        String key_16 = "wakpzJ8dCjWmHSdd";
        String key_24 = "5r0pYWpkdExmhAajYQQhaDAQ";
        String key_32 = "81ZhAiXK1QGzQDGdEekr9JnAbTzC7EfE";
        // 模拟身份证长度
        String content = "123456789012345678";

        test(content, key_16, "16");
        test(content, key_24, "24");
        test(content, key_32, "32");
    }

    private static void test(String content, String key, String len) {
        long start = System.currentTimeMillis();
        for (int i = 0; i < 1000000; i++) {
            encrypt(content, key);
        }
        long end = System.currentTimeMillis();
        System.out.println(len + "位密钥长度耗时：" + (end - start));
    }

16位密钥长度耗时：3595
24位密钥长度耗时：3293
32位密钥长度耗时：3487
  1. 循环10万次（单位：毫秒）
文本16位密钥耗时24位密钥耗时32位密钥耗时
18位数字359532933487
18位随机字符串370535583492
36位随机字符串377837353683
128位随机字符串414536513766
  1. 大文件测试（加密一次，单位：毫秒）
文本16位密钥耗时24位密钥耗时32位密钥耗时
100M文本744879620

从上面的测试可以看到AES的性能非常优秀，在服务器上的性能应该会更加优异。

2.2、SM4

2.2.1、 介绍

SM4是由中国国家密码管理局发布的对称加密密码算法，密钥长度固定为16位

2.2.2、 使用

这里直接使用hutool提供的工具类

package com.xx.utils;

import cn.hutool.crypto.SmUtil;
import cn.hutool.crypto.symmetric.SM4;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

/**
 * @author xx
 * @describe 国密
 * @since 2024/5/6 16:31
 */
@Component
@Slf4j
public class SM4Utils {

    /**
     * sm4加密
     *
     * @param text 待加密文本
     * @return 加密结果
     */
    public static String encrypt(String key, String text) {
        SM4 sm4 = SmUtil.sm4(key.getBytes());
        return sm4.encryptHex(text);
    }

    /**
     * sm4解密
     *
     * @param text 待解密文本
     * @return 解密结果
     */
    public static String decrypt(String key, String text) {
        SM4 sm4 = SmUtil.sm4(key.getBytes());
        return sm4.decryptStr(text);
    }

    public static void main(String[] args) {
        String key = "wakpzJ8dCjWmHSdd";
        String text = "hello sm4";
        String encrypt = encrypt(key, text);
        String decrypt = decrypt(key, encrypt);
        System.out.println("encrypt:" + encrypt);
        System.out.println("decrypt:" + decrypt);
    }

}

2.2.3、 性能测试

文本循环10万次循环100万次执行一次
18位数字5931806
18位随机字符串5931878
36位随机字符串6232217
128位随机字符串7843564
100M文件2140

2.3、总结

AES提出的时间更早，所以其影响范围也更大，而SM4是由我国自主提出的加密算法，出现的更晚，知道的人也更少，但是其性能非常优异，从测试结果来看是AES的6到7倍。

三、非对称加密

非对称加密使用一组密钥对来进行加解密，公钥是公开的，任何人都可以使用公钥来加密信息。然而，只有拥有相应私钥的人才能解密这些信息。

非对称加密的主要优点是安全性高。因为即使攻击者获取到公钥，也无法解密加密的信息，除非他们能够获取到对应的私钥。这大大提高了数据的安全性。

3.1、RSA

3.1.1、 介绍

RSA是目前最为流行的非对称加密方式，常用于客户端向服务端提交敏感数据，或者于三方对接时保护数据安全。

3.1.2、 使用

这里依旧使用hutool工具包来操作

package com.xx.utils;

import cn.hutool.crypto.SecureUtil;
import cn.hutool.crypto.asymmetric.KeyType;
import cn.hutool.crypto.asymmetric.RSA;

import java.security.KeyPair;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;

/**
 * @author xiaxing
 * @describe
 * @since 2024/7/5 16:26
 */
public class RSAUtil {

    public static final String ENCRYPT_TYPE = "RSA";

    /**
     * 获取公钥的key
     */
    private static final String PUBLIC_KEY = "RSAPublicKey";

    /**
     * 获取私钥的key
     */
    private static final String PRIVATE_KEY = "RSAPrivateKey";

    public static Map<String, String> generateKeyPair() {
        try {
            KeyPair pair = SecureUtil.generateKeyPair(ENCRYPT_TYPE);
            PrivateKey privateKey = pair.getPrivate();
            PublicKey publicKey = pair.getPublic();
            // 获取 公钥和私钥 的 编码格式（通过该 编码格式 可以反过来 生成公钥和私钥对象）
            byte[] pubEncBytes = publicKey.getEncoded();
            byte[] priEncBytes = privateKey.getEncoded();

            // 把 公钥和私钥 的 编码格式 转换为 Base64文本 方便保存
            String pubEncBase64 = Base64.getEncoder().encodeToString(pubEncBytes);
            String priEncBase64 = Base64.getEncoder().encodeToString(priEncBytes);

            Map<String, String> map = new HashMap<String, String>(2);
            map.put(PUBLIC_KEY, pubEncBase64);
            map.put(PRIVATE_KEY, priEncBase64);

            return map;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 公钥加密
     *
     * @param content   要加密的内容
     * @param publicKey 公钥
     */
    public static String encrypt(String content, String publicKey) {
        try {
            RSA rsa = new RSA(null, publicKey);
            return rsa.encryptBase64(content, KeyType.PublicKey);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 私钥解密
     *
     * @param content    要解密的内容
     * @param privateKey 私钥
     */
    public static String decrypt(String content, String privateKey) {
        try {
            RSA rsa = new RSA(privateKey, null);
            return rsa.decryptStr(content, KeyType.PrivateKey);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public static void main(String[] args) {
        Map<String, String> keyPair = generateKeyPair();
        String content = "hello rsa";
        String encrypt = encrypt(content, keyPair.get(PUBLIC_KEY));
        String decrypt = decrypt(encrypt, keyPair.get(PRIVATE_KEY));

        System.out.println("encrypt:" + encrypt);
        System.out.println("decrypt:" + decrypt);
    }
}

3.1.3、 性能测试

文本循环10万次循环100万次
18位数字541252093
18位随机字符串548378604
36位随机字符串544962476
128位随机字符串754172679

3.2、SM2

3.2.1、 介绍

SM2是由中国国家密码管理局发布的非对称加密密码算法，其只支持公钥加密，私钥解密，不支持反转。

3.2.2、 使用

package com.xx.utils;

import cn.hutool.crypto.SecureUtil;
import cn.hutool.crypto.asymmetric.KeyType;
import cn.hutool.crypto.asymmetric.SM2;

import java.security.KeyPair;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;

/**
 * @author xiaxing
 * @describe
 * @since 2024/7/5 16:45
 */
public class SM2Util {

    /**
     * 获取公钥的key
     */
    private static final String PUBLIC_KEY = "SM2PublicKey";

    /**
     * 获取私钥的key
     */
    private static final String PRIVATE_KEY = "SM2PrivateKey";

    public static Map<String, String> generateKeyPair() {
        KeyPair pair = SecureUtil.generateKeyPair("SM2");
        byte[] privateKey = pair.getPrivate().getEncoded();
        byte[] publicKey = pair.getPublic().getEncoded();

        Map<String, String> map = new HashMap<>(2);
        map.put(PUBLIC_KEY, Base64.getEncoder().encodeToString(publicKey));
        map.put(PRIVATE_KEY, Base64.getEncoder().encodeToString(privateKey));
        return map;
    }

    /**
     * sm4加密
     *
     * @param text 待加密文本
     * @return 加密结果
     */
    public static String encrypt(String key, String text) {
        SM2 sm2 = new SM2(null, key);
        return sm2.encryptBase64(text, KeyType.PublicKey);
    }

    /**
     * sm4解密
     *
     * @param text 待解密文本
     * @return 解密结果
     */
    public static String decrypt(String key, String text) {
        SM2 sm2 = new SM2(key, null);
        return sm2.decryptStr(text, KeyType.PrivateKey);
    }

    public static void main(String[] args) {
        String text = "hello sm2";
        Map<String, String> keyPair = generateKeyPair();

        String encrypt = encrypt(keyPair.get(PUBLIC_KEY), text);
        String decrypt = decrypt(keyPair.get(PRIVATE_KEY), encrypt);
        System.out.println(encrypt);
        System.out.println(decrypt);
    }
}

3.2.3、 性能测试

100万次的性能实在是太差了，这里不测评了

文本循环10万次
18位数字45992
18位随机字符串47378
36位随机字符串48564
128位随机字符串44770

3.3、总结

RSA和SM2都是最常用的非对称加密方式，常用于客户端和服务端交互，或者和一些不受信的三方交互。

四、摘要加密

摘要加密其加密的过程是不可逆的，一般被用于验证数据的完整性和一致性。

4.1、MD5

4.1.1、 介绍

MD5使用的范围非常广泛，一般的项目中用户密码都会采用MD5来进行加密。目前认为MD5已经不再是安全的，因为已经有多种方法可以快速生成MD5碰撞。但复杂的密码依旧是难以被暴力破解的

4.1.2、 使用

package com.xx.utils;

import cn.hutool.crypto.digest.MD5;
import org.bouncycastle.pqc.math.linearalgebra.ByteUtils;
import org.springframework.util.DigestUtils;

import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

/**
 * @author xiaxing
 * @describe
 * @since 2024/7/8 15:01
 */
public class MD5Util {

    public static String springMD5(String context) {
        return DigestUtils.md5DigestAsHex(context.getBytes(StandardCharsets.UTF_8));
    }

    public static String javaMD5(String context) throws NoSuchAlgorithmException {
        MessageDigest md5 = MessageDigest.getInstance("MD5");
        byte[] digest = md5.digest(context.getBytes(StandardCharsets.UTF_8));
        return ByteUtils.toHexString(digest);
    }

    public static String hutoolMD5(String context) {
        return MD5.create().digestHex(context);
    }

    public static void main(String[] args) throws NoSuchAlgorithmException {
        String context = "123456";
        System.out.println("spring:" + springMD5(context));
        System.out.println("java:" + javaMD5(context));
        System.out.println("hutool:" + hutoolMD5(context));

    }

}

4.1.3、 性能测试

文本循环10万次循环100万次
18位数字4661263
18位随机字符串4701288
36位随机字符串4841427
128位随机字符串5101627

4.2、SM3

4.2.1、 介绍

SM3是中国自主研发的密码哈希函数，它在密码学社区中也得到了广泛的认可。

4.2.2、 使用

package com.xx.utils;

import cn.hutool.crypto.SmUtil;
import org.bouncycastle.crypto.digests.SM3Digest;
import org.bouncycastle.util.encoders.Hex;

/**
 * @author xiaxing
 * @describe
 * @since 2024/7/8 15:22
 */
public class SM3Util {

    public static String hutoolSM3(String context) {
        return SmUtil.sm3(context);
    }

    public static String bcprovSM3(String context) {
        SM3Digest sm3 = new SM3Digest();
        byte[] bytes = context.getBytes();
        sm3.update(bytes, 0, bytes.length);
        byte[] result = new byte[sm3.getDigestSize()];
        sm3.doFinal(result, 0);
        return Hex.toHexString(result);
    }

    public static void main(String[] args) {
        String context = "123456";
        System.out.println(hutoolSM3(context));
        System.out.println(bcprovSM3(context));
    }
}

4.2.3、 性能测试

文本循环10万次循环100万次
18位数字5742195
18位随机字符串6162243
36位随机字符串5722262
128位随机字符串6833081

4.3、总结

MD5目前已经不再安全，但是依旧有一定破解难度，但是如果对密码安全性要求较高，可以使用SM3这种加密方式。

有人看我吗
关注
  • 22
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
web前端常见的加密算法介绍
m0_68271787的博客
05-03 1362
在信息安全越来越受重视的今天，前端的各种加密也变得更加重要。通常跟服务器的交互中，为保障数据传输的安全性，避免被人抓包篡改数据，除了 https 的应用，还需要对传输数据进行加解密。目前常见的加密算法可以分成三类对称加密算法：AES、...非对称加密算法：RSA、...Hash 算法：MD5、...在业务 http 请求中，AES 的密钥在前端随机生成，从服务器获取 RSA 的公钥，对 AES 的密钥进行非对称加密，把加密后的密钥在请求头中传给服务器，用 AES 对 body 进行加密。
常见加密算法
12-23
加密算法在信息技术领域扮演着至关重要的角色，它们用于保护数据的隐私、确保网络通信的安全以及验证数据的完整性和来源。以下是对标题和描述中提到的几种加密算法的详细解释： 1. MD5（Message-Digest Algorithm 5...
常见加密算法介绍与比较
Leeon的博客
04-26 1720
由于计算机软件的非法复制，通信的泄密、数据安全受到威胁，解密及盗版问题日益严重，甚至引发国际争端，所以在信息安全技术中，加密技术占有不可替代的位置，因此对信息加密技术和加密手段的研究与开发，受到各国计算机界的重视，发展日新月异。现在我们就几种常用的加密算法给大家比较一下。 在讲加密算法之前，先了解一个名词，密钥。 密钥是一种参数，它是在明文转换为密文或将密文转换为明文的算法中输入的参数
常见加密算法介绍及比较
M2嵌入式
07-31 3181
常见加密算法 常见的对称加密算法主要有DES、3DES、AES等，常见的非对称算法主要有RSA、DSA等，散列算法主要有SHA-1、MD5等。也有的地方将对称加密和非对称加密归类为双向加密，将散列算法归类为单向加密。 对称算法又可分为两类。一次只对明文中的单个位（有时对字节）运算的算法称为序列算法或序列密码。另一类算法是对明文的一组位进行运算（即运算之前将明文分为若干组，然后分别对每一组进行运...
常见的加密算法分类及介绍
leho666的博客
03-04 1万+
1.加密算法的分类 根本不考虑解密问题； 私用密钥加密技术：对称式加密（Symmetric Key Encryption）：对称式加密方式对加密和解密使用相同的密钥。通常，这种加密方式在应用中难以实施，因为用同一种安全方式共享密钥很难。如：RC4、RC2、DES 和 AES 系列加密算法； 公开密钥加密技术：非对称密钥加密（Asymmetric Key Encryption）：非对称密钥加密使用一组公共/私人密钥系统，加密时使用一种密钥，解密时使用另一种密钥。公共密钥可以广泛的共享和透露。当需要用加密
常见加密算法知识总结
The best are water的博客
07-02 2442
1、加密种类： 1.1、不可逆加密：【Hash加密算法/散列算法/摘要算法】 一旦加密就不能反向解密得到密码原文，一般用来加密用户密码,app的服务器端数据库里一般存储的也都是加密后的用户密码。 在数据传输的过程中，首先把密码类数据经过MD5加密算法加密，然后再在外面使用可逆的加密方式加密一次，这样在数据传输的过程中，即便数据被截获了，但是想要完全破解，还是很难的。 Hash算法特别...
Java中五种最常见加密算法
热门推荐
吴名氏的博客
07-21 8万+
Java中五种最常见加密算法
【前端知识】常见的加密算法介绍
xiaobaizaza_Ry的博客
05-18 1997
略微介绍一下前端中常见的加密算法。前端中常见的加密算法主要形式包括——哈希函数，消息认证码，对称加密和非对称加密算法。包括各类型的定义，优缺点及常见应用场景。
常见的加密算法介绍
qianyiyiding的专栏
09-07 2419
数据加密目前仍是计算机系统对信息进行保护的一种最可靠的办法。它利用密码技术对信息进行加密，实现信息隐蔽，从而起到保护信息的安全的作用。 常见的加密算法常见的加密算法有SHA、MD5、DES、3DES、RC4、RSA、AES等,下面将对这几个常见的算法分类加密的算法： SHA MD5 既能加密又能解密的算法： DES、3DES、RC4、AES、RSA对称加密和非对称加密算法对称加密：即加
常见加密算法常见加密算法
05-29
常见的加密算法主要分为对称加密和非对称加密两种类型。这里我们将深入探讨这两种加密方式及其代表性的算法。 首先，对称加密算法是最早使用的加密技术，其中加密和解密使用的是同一把密钥。这种算法的优点在于其...
常见加密算法讲解.ppt
01-29
常见加密算法讲解
常用的加密算法名称及介绍
06-16
常用的加密算法名称及介绍 在信息安全领域中，加密算法是保护数据安全的重要手段。常用的加密算法有对称加密算法、非对称加密算法、散列算法和Base64加密算法等。 一、对称加密算法 对称加密算法是指加密和解密...
delphi常见加密算法源码
05-27
本文将深入探讨Delphi中常见的加密算法及其源码实现。 首先，让我们了解一下Delphi。Delphi是一种基于Object Pascal语言的快速应用程序开发（RAD）工具，它以其高效的编译器和直观的可视化设计界面而受到程序员的...
POI导出详解
progammer10086的博客
05-28 4642
最为常见的POI导出方式有3种：HSSF，XSSF，SXSSF 其中HSSF操作的是2003版本之前的Excel,扩展名是xls XSSFworkbook：操作Excel2007版本，扩展名为xlsx SXSSFworkbook ：用于大数据量导出 使用HSSF导出的工具类 package com.xx.utils; import com.alibaba.fastjson.JSON; import org.apache.poi.hssf.usermodel.*; import org.apac
SAX解析xml字符串
progammer10086的博客
07-05 1917
最近需要接入微信支付的返回参数，将其入库，微信的返回参数是xml格式的，这里采用sax进行数据解析 package com.xx.utils; import java.io.StringReader; import java.util.List; import org.dom4j.*; import org.dom4j.io.SAXReader; import org.xml.sax.In...
使用fastjson对Json的基本操作
progammer10086的博客
12-18 1853
fastjson是阿里的一款对Json处理的工具，使用前需要引入对应的jar包下载地址 本人感觉还是非常强悍的，比Gson使用起来更加的强大 package json; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import com....
使用HttpClient从服务器获取图片再交给前端展示
progammer10086的博客
09-02 1641
public static void getImage(HttpServletRequest request, HttpServletResponse response){ CloseableHttpClient httpClient = HttpClientBuilder.create().build(); HttpPost httpPost = new Htt...
常见加密算法 使用场景
最新发布
08-03
常见的加密算法在不同的场景中有不同的应用。对称加密算法通常用于保护大量数据的传输和存储，例如在网络通信中使用的SSL/TLS协议中，对称加密算法被用于加密数据传输。非对称加密算法则常用于数字签名、密钥交换和身份验证等场景。例如，公钥基础设施（PKI）中使用的RSA算法就是一种非对称加密算法，用于数字证书的生成和验证。此外，还有一些特定的加密算法被用于特定的应用场景，比如Blowfish算法可以用于加密文件或者保护敏感数据的存储。总的来说，常见的加密算法在保护数据的传输、存储和身份验证等方面发挥着重要的作用。[1][2][3]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值