常见加密算法与实例

way_more

已于 2023-11-13 16:20:56 修改

阅读量302

点赞数 4

文章标签： java 算法安全密码学

于 2023-11-13 16:20:30 首次发布

本文链接：https://blog.csdn.net/qq_36551991/article/details/134380004

版权

加密算法

常见加密算法有以下三大类

单向加密算法：只能单向对明文进行加密,而不能逆向通过密文得到明文，常见的单向加密算法有MD5、SHA算法

对称加密算法：使用相同的密钥进行加密和解密。也就是说，如果你有密钥K，那么你可以使用K来加密和解密数据。常见的对称加密算法有AES、DES算法

非对称加密算法：使用两个不同的密钥来加解密数据：一个公钥用于加密数据，另一个私钥用于解密数据。常见的非对称加密算法有RSA算法

MD5算法

MD5算法又称为哈希算法、散列算法，输出的消息摘要又称为哈希值、散列值。

MD5可以将任意长度的输入转化为128位长度的输出，MD5是不可逆的，我们无法通过常规方式从MD5值倒推出它的原文，对原文做一丁点儿改动，MD5值就会有巨大的变动，也就是说就算两个MD5值非常相似，你也不能想当然地认为它们俩对应的原文也非常相似

实例

	/**
     * MD5加密
     * @param input
     * @return
     */
    public static String md5Encrypt(String input) {
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
            //获取加密后的byte数组
            byte[] md5Bytes = md.digest(input.getBytes(StandardCharsets.UTF_8));
            // 将处理后的字节转成 16 进制，得到最终 32 个字符
            StringBuilder sb = new StringBuilder();
            for (byte b : md5Bytes) {
                sb.append(String.format("%02x", b));
            }
            return sb.toString();
        }catch (NoSuchAlgorithmException e){
            e.printStackTrace();
        }
        return "";
    }

直接使用MD5加密是不安全的，但是我们可以加盐。加盐是指在密码的任意位置插入一些指定的字符串（即盐值salt），加盐的目的也是为了尽量增强明文密码的复杂度。使用盐值可以进一步提升 MD5 加密算法安全性，降低破解风险。

MD5已经被证明存在安全漏洞，对于需要高安全性的场合，建议使用更安全的算法，如SHA-256

SHA算法

SHA是安全散列算法（Secure Hash Algorithm）的缩写，它是一种密码学方法，用于生成固定长度的散列值。这个散列值是由一个较大的数据块（或消息）通过一系列的散列函数计算得出的。SHA有许多不同的版本，包括SHA-1、SHA-256、SHA-3等等。

SHA-1是最早的SHA算法，它生成一个160位的哈希值。然而，由于其存在一些已知的安全漏洞，现在已经被视为不安全，并且在很多场景中已经不再推荐使用。

SHA-256是SHA-2的一种，它生成一个256位的哈希值。它比SHA-1更安全，因为它的输出长度更长，更难进行暴力破解。SHA-256被广泛用于各种安全性和隐私保护的场景，例如密码存储、数字签名等。

SHA-3则是一个更为现代化的哈希函数，旨在提供更高的安全性和效率。它生成的是256位的哈希值，并且具有更强的抗冲突性。SHA-3在密码学和安全领域中得到了广泛的应用。

比较常用的是SHA-256

实例

	/**
     * SHA256加密
     */
    public static String SHA256Encrypt(String input) {
        try {
            MessageDigest md = MessageDigest.getInstance("SHA-256");
            byte[] messageDigest = md.digest(input.getBytes());
            return bytesToHex(messageDigest);
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 将byte转为十六进制字符
     * @param hash
     * @return
     */
    private static String bytesToHex(byte[] hash) {
        StringBuffer hexString = new StringBuffer();
        for (int i = 0; i < hash.length; i++) {
            String hex = Integer.toHexString(0xff & hash[i]);
            if(hex.length() == 1) hexString.append('0');
            hexString.append(hex);
        }
        return hexString.toString();
    }

AES算法

AES 全称 Advanced Encryption Standard，是一种对称加密算法。AES 的出现主要是用来取代 DES 加密算法，因为 AES 的安全性相对更高。

AES 密钥长度可以是 128、192 或 256 比特（即 16、24 或 32 字节），密钥长度越长，安全性越高，而性能也就越低

AES加密算法的原理包括密钥扩展、初始轮、多轮加密和最终轮。在密钥扩展中，根据AES密钥长度进行密钥扩展，生成多个轮密钥。在初始轮中，将明文数据分成128位块，并与第一个轮密钥进行异或操作。在多轮加密中，重复进行多轮加密操作，每轮操作包括四个步骤：字节替换、行移位、列混淆和轮密钥加。在最终轮中，最后一轮加密后，将128位块与最后一个轮密钥进行异或操作。输出所有块的加密结果作为密文。

实例

	//加密算法/加密模式/填充类型
    private static final String ALGORITHMSTR = "AES/ECB/PKCS5Padding";
    //密钥
    private static String AES_KEY = "1234567891234567";


    /**
     * AES加密
     *
     * @param content 待加密的字符串
     * @return 加密后的byte64字符串
     * @throws Exception
     */
    public static String aesEncryptToString(String content) throws Exception {
        Cipher cipher = Cipher.getInstance(ALGORITHMSTR);
        cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(AES_KEY.getBytes(), "AES"));
        byte[] bytes = cipher.doFinal(content.getBytes("utf-8"));
        return Base64.encodeBase64String(bytes);
    }

    /**
     * AES解密
     *
     * @param encryptStr 待解密的byte64字符串
     * @param decryptKey   解密密钥
     * @return 解密后的字符串
     * @throws Exception
     */
    public static String aesDecryptByString(String encryptStr, String decryptKey) throws Exception {
        byte [] encryptBytes = Base64.decodeBase64(encryptStr);
        Cipher cipher = Cipher.getInstance(ALGORITHMSTR);
        cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(decryptKey.getBytes(), "AES"));
        byte[] decryptBytes = cipher.doFinal(encryptBytes);
        return new String(decryptBytes);
    }

生成AES密钥可以使用以下方法

/**
 * 生成AES密钥
 * @return
 * @throws NoSuchAlgorithmException
 */
public static byte[] generatorSecretKey() throws NoSuchAlgorithmException {
    KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
    // 设置密钥长度为128位
    keyGenerator.init(128);
    // 生成AES密钥
    SecretKey secretKey = keyGenerator.generateKey();
    byte[] secretKeyEncoded = secretKey.getEncoded();
    return secretKeyEncoded;
}

RSA算法

RSA算法是一种非对称加密算法，它使用一对密钥，一个用于加密，另一个用于解密。其中，一个是公钥（PK），可以公开使用；另一个是私钥（SK），需要保密。RSA算法的安全性基于大数因数分解的难度。

在RSA算法中，加密和解密过程都是使用相同的算法，只是密钥的使用顺序不同。具体来说，加密过程使用公钥对数据进行加密，解密过程使用私钥对加密后的数据进行解密。

RSA算法的优点包括安全性高、加密速度快、适用于大量数据的加密和解密。然而，由于RSA算法需要使用较大的密钥长度，因此其计算量较大，可能会影响加密和解密的效率。此外，RSA算法也需要较高的计算资源，因此在某些资源有限的场景下可能不太适用。

RSA加密、签名区别

加密和签名都是为了安全性考虑，但略有不同。简单的说，加密是为了防止信息被泄露，而签名是为了防止信息被篡改。

在RSA加密中，信息发送者使用公钥对数据进行加密，接收者则使用私钥进行解密。公钥是公开的，可以安全地发送给任何人，而私钥必须保密，只能由接收者拥有。RSA签名则是在信息原文后面增加一段强而有力的证明，以证明这段信息的发布者和其有效性完整性。签名通常是将信息原文进行hash，得到一个hash值，再用私钥对hash值进行加密作为签名。

一般步骤为：公钥加密、私钥解密、私钥签名、公钥验签

实例

package com.example.demo.encipher;

import org.apache.tomcat.util.codec.binary.Base64;

import javax.crypto.Cipher;
import java.io.ByteArrayOutputStream;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

/**
 * RSA加解密工具类
 */
public class RSAUtil {

    /**
     * 加密算法RSA
     */
    public static final String ENCRYPT_ALGORITHM = "RSA";

    /**
     * 数字签名算法：将正文通过MD5数字摘要后，将密文再次通过生成的RSA密钥加密，生成数字签名
     */
    public static final String SIGN_ALGORITHM = "MD5withRSA";

    /**
     * RSA最大加密明文大小
     */
    private static final int MAX_ENCRYPT_BLOCK = 117;

    /**
     * RSA最大解密密文大小
     */
    private static final int MAX_DECRYPT_BLOCK = 128;

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

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

    public static void main(String[] args) throws Exception{
        String context = "abc";
        Map<String, Object> keyPair = genKeyPair();
        RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.get(PUBLIC_KEY);
        String publicKey = Base64.encodeBase64String(rsaPublicKey.getEncoded());
        RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.get(PRIVATE_KEY);
        String privateKey = Base64.encodeBase64String(rsaPrivateKey.getEncoded());
        //公钥加密
        String encryptString = encryptByPublicKey(context.getBytes(), publicKey);

        //私钥解密
        String decryptString = decryptByPrivateKey(encryptString, privateKey);
        System.out.println(decryptString);

        //生成签名
        String sign = sign(context, getPrivateKey(privateKey));
        //校验签名
        boolean verify = verify(context, getPublicKey(publicKey), sign);
        System.out.println(verify);
    }


    /**
     * 生成密钥对(公钥和私钥)
     * @return 含有公钥和密钥的map
     * @throws Exception
     */
    public static Map<String, Object> genKeyPair() throws Exception {
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(ENCRYPT_ALGORITHM);
        keyPairGen.initialize(1024);
        KeyPair keyPair = keyPairGen.generateKeyPair();
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        Map<String, Object> keyMap = new HashMap<String, Object>(2);
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);
        return keyMap;
    }


    /**
     * 获取私钥
     * @param privateKey 私钥字符串
     * @return
     * @throws Exception
     */
    public static PrivateKey getPrivateKey(String privateKey)  throws Exception {
        KeyFactory keyFactory = KeyFactory.getInstance(ENCRYPT_ALGORITHM);
        byte[] decodedKey = Base64.decodeBase64(privateKey.getBytes());
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(decodedKey);
        return keyFactory.generatePrivate(keySpec);
    }

    /**
     * 获取公钥
     *
     * @param publicKey 公钥字符串
     * @return
     */
    public static PublicKey getPublicKey(String publicKey) throws Exception {
        KeyFactory keyFactory = KeyFactory.getInstance(ENCRYPT_ALGORITHM);
        byte[] decodedKey = Base64.decodeBase64(publicKey.getBytes());
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(decodedKey);
        return keyFactory.generatePublic(keySpec);
    }

    /**
     * 公钥加密
     * @param data
     *            源数据
     * @param publicKey
     *            公钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static String encryptByPublicKey(byte[] data, String publicKey) throws Exception {
        byte[] keyBytes = decryptBASE64(publicKey);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(ENCRYPT_ALGORITHM);
        Key publicK = keyFactory.generatePublic(x509KeySpec);
        // 对数据加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, publicK);
        int inputLen = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段加密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(data, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_ENCRYPT_BLOCK;
        }
        byte[] encryptedData = out.toByteArray();
        out.close();
        return Base64.encodeBase64String(encryptedData);
    }


    /**
     * 私钥解密
     * @param encrptStr
     *            已加密字符串
     * @param privateKey
     *            私钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static String decryptByPrivateKey(String encrptStr, String privateKey) throws Exception {
        byte[] encryptedData = Base64.decodeBase64(encrptStr);
        byte[] keyBytes = decryptBASE64(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(ENCRYPT_ALGORITHM);
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, privateK);
        int inputLen = encryptedData.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段解密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_DECRYPT_BLOCK;
        }
        byte[] decryptedData = out.toByteArray();
        out.close();
        return new String(decryptedData, "UTF-8");
    }


    /**
     * 签名
     *
     * @param data 待签名数据
     * @param privateKey 私钥
     * @return 签名
     */
    public static String sign(String data, PrivateKey privateKey) throws Exception {
        byte[] keyBytes = privateKey.getEncoded();
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(ENCRYPT_ALGORITHM);
        PrivateKey key = keyFactory.generatePrivate(keySpec);
        Signature signature = Signature.getInstance(SIGN_ALGORITHM);
        signature.initSign(key);
        signature.update(data.getBytes());
        return new String(Base64.encodeBase64(signature.sign()));
    }

    /**
     * 验签
     *
     * @param srcData 原始字符串
     * @param publicKey 公钥
     * @param sign 签名
     * @return 是否验签通过
     */
    public static boolean verify(String srcData, PublicKey publicKey, String sign) throws Exception {
        byte[] keyBytes = publicKey.getEncoded();
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(ENCRYPT_ALGORITHM);
        PublicKey key = keyFactory.generatePublic(keySpec);
        Signature signature = Signature.getInstance(SIGN_ALGORITHM);
        signature.initVerify(key);
        signature.update(srcData.getBytes());
        return signature.verify(Base64.decodeBase64(sign.getBytes()));
    }


    /**
     * BASE64解密
     *
     * @param key
     * @return
     * @throws Exception
     */
    public static byte[] decryptBASE64(String key){
        return Base64.decodeBase64(key.getBytes());
    }

}