java encrypt 加密种类

最新推荐文章于 2024-05-15 06:11:33 发布

jizhaojian88

最新推荐文章于 2024-05-15 06:11:33 发布

阅读量4k

点赞数 2

分类专栏： JAVA

本文链接：https://blog.csdn.net/jizhaojian88/article/details/104921367

版权

JAVA 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

java encrypt 加密种类

1，pom

        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.1.0</version>
        </dependency>

2,非对称加密

package club.mydlq.encrypt;

import cn.hutool.core.codec.Base64;
import cn.hutool.crypto.SecureUtil;
import cn.hutool.crypto.asymmetric.KeyType;
import cn.hutool.crypto.asymmetric.RSA;
import java.io.UnsupportedEncodingException;
import java.security.KeyPair;
import java.security.PrivateKey;
import java.security.PublicKey;

/**
 * 非对称加密
 */
public class AsymmetricEncryptionExample {

    /**
     * RSA 公钥加密,私钥解密
     *
     * @param data             加密数据
     * @param privateKeyString 私钥字符串
     * @param publicKeyString  公钥字符串
     * @throws UnsupportedEncodingException
     */
    public static void rsaEncrypt1(String data, String privateKeyString, String publicKeyString) throws UnsupportedEncodingException {
        // 将公、私钥字符串转换成公、私钥对象
        PrivateKey privateKey = SecureUtil.generatePrivateKey("RSA", Base64.decode(privateKeyString));
        PublicKey publicKey = SecureUtil.generatePublicKey("RSA", Base64.decode(publicKeyString));
        // 获取字符串byte数组
        byte[] bytes = data.getBytes("UTF-8");
        // 创建 RSA 对象
        RSA rsa = new RSA();
        // 设置公钥,然后执行公钥加密
        rsa.setPublicKey(publicKey);
        byte[] encrypt = rsa.encrypt(bytes, KeyType.PublicKey);
        // 设置私钥，然后执行私钥解密
        rsa.setPrivateKey(privateKey);
        byte[] decrypt = rsa.decrypt(encrypt, KeyType.PrivateKey);
        // 输出解密的内容
        System.out.println("公钥加密,私钥解密，解密内容：" + new String(decrypt));
    }

    /**
     * RSA 私钥加密,公钥解密
     *
     * @param data             加密数据
     * @param privateKeyString 私钥字符串
     * @param publicKeyString  公钥字符串
     * @throws UnsupportedEncodingException
     */
    public static void rsaEncrypt2(String data, String privateKeyString, String publicKeyString) throws UnsupportedEncodingException {
        // 将公、私钥字符串转换成公、私钥对象
        PrivateKey privateKey = SecureUtil.generatePrivateKey("RSA", Base64.decode(privateKeyString));
        PublicKey publicKey = SecureUtil.generatePublicKey("RSA", Base64.decode(publicKeyString));
        // 获取字符串byte数组
        byte[] bytes = data.getBytes("UTF-8");
        // 创建 RSA 对象
        RSA rsa = new RSA();
        // 设置私钥，然后执行私钥加密
        rsa.setPrivateKey(privateKey);
        byte[] encrypt = rsa.encrypt(bytes, KeyType.PrivateKey);
        // 设置公钥，然后执行公钥解密
        rsa.setPublicKey(publicKey);
        byte[] decrypt = rsa.decrypt(encrypt, KeyType.PublicKey);
        // 输出解密的内容
        System.out.println("私钥加密,公钥解密，解密内容：" + new String(decrypt));
    }

    public static void main(String[] args) throws UnsupportedEncodingException {
        /* 生成钥匙对 */
        KeyPair pair = SecureUtil.generateKeyPair("RSA");
        PrivateKey privateKey = pair.getPrivate();
        PublicKey publicKey = pair.getPublic();
        // 将公钥私钥转换成 Base64 字符串
        String privateKeyString = Base64.encode(privateKey.getEncoded());
        String publicKeyString = Base64.encode(publicKey.getEncoded());
        /* 设置要加密的内容 */
        String data = "测试数据";
        /* RSA 公钥加密,私钥解密 */
        rsaEncrypt1(data, privateKeyString, publicKeyString);
        /* RSA 私钥加密,公钥解密 */
        rsaEncrypt2(data, privateKeyString, publicKeyString);
    }

}

3,摘要加密

package club.mydlq.encrypt;

import cn.hutool.crypto.digest.DigestUtil;

/**
 * 摘要加密
 */
public class DigesterEncryption {

    /**
     * MD2 加密
     * @param data 加密内容
     */
    public static void md2Encrypt(String data) {
        String md2String = DigestUtil.md5Hex(data);
        System.out.println("MD2加密后的字符串：" + md2String);
    }

    /**
     * MD5 加密
     * @param data 加密内容
     */
    public static void md5Encrypt(String data) {
        String md5String = DigestUtil.md5Hex(data);
        System.out.println("MD5加密后的字符串：" + md5String);
    }

    /**
     * SHA-1 加密
     * @param data 加密内容
     */
    public static void sha1Encrypt(String data) {
        String sha1String = DigestUtil.sha1Hex(data);
        System.out.println("SHA1加密后的字符串：" + sha1String);
    }

    /**
     * SHA-256 加密
     * @param data 加密内容
     */
    public static void sha256Encrypt(String data) {
        String sha256String = DigestUtil.sha256Hex(data);
        System.out.println("SHA256加密后的字符串：" + sha256String);
    }

    public static void main(String[] args) {
        /* 设置要加密的内容 */
        String data = "测试数据";
        /* MD2加密 */
        md2Encrypt(data);
        /* MD5加密 */
        md5Encrypt(data);
        /* SHA1加密 */
        sha1Encrypt(data);
        /* SHA256加密 */
        sha256Encrypt(data);
    }

}

4,对称加密

package club.mydlq.encrypt;

import cn.hutool.crypto.SecureUtil;
import cn.hutool.crypto.symmetric.SymmetricAlgorithm;
import cn.hutool.crypto.symmetric.SymmetricCrypto;
import java.io.UnsupportedEncodingException;

/**
 * 对称加密
 */
public class SymmetricalEncryptionExample {

    /**
     * AES 加密、解密
     *
     * @param data 加密数据
     */
    public static void aesEncrypt(String data, String secret) {
        // 随机生成密钥
        byte[] key = SecureUtil.generateKey(SymmetricAlgorithm.AES.getValue(), secret.getBytes()).getEncoded();
        // 创建 AES 对象
        SymmetricCrypto aes = new SymmetricCrypto(SymmetricAlgorithm.AES, key);
        // 加密
        String encrypt = aes.encryptHex(data);
        // 解密
        String decrypt = aes.decryptStr(encrypt);
        System.out.println("AES 加密后的串：" + encrypt + "AES 解密的数据：" + decrypt);
    }

    /**
     * DES 加密、解密
     *
     * @param data 加密数据
     */
    public static void desEncrypt(String data, String secret) {
        // 随机生成密钥
        byte[] key = SecureUtil.generateKey(SymmetricAlgorithm.DES.getValue(), secret.getBytes()).getEncoded();
        // 创建 DES 对象
        SymmetricCrypto des = new SymmetricCrypto(SymmetricAlgorithm.DES, key);
        // 加密
        String encrypt = des.encryptHex(data);
        // 解密
        String decrypt = des.decryptStr(encrypt);
        System.out.println("DES 加密后的串：" + encrypt + "DES 解密的数据：" + decrypt);
    }

    /**
     * DESede 加密、解密
     *
     * @param data 加密数据
     */
    public static void desedeEncrypt(String data, String secret) {
        // 随机生成密钥
        byte[] key = SecureUtil.generateKey(SymmetricAlgorithm.DESede.getValue(), secret.getBytes()).getEncoded();
        // 创建 DESede 对象
        SymmetricCrypto desede = new SymmetricCrypto(SymmetricAlgorithm.DESede, key);
        // 加密
        String encrypt = desede.encryptHex(data);
        // 解密
        String decrypt = desede.decryptStr(encrypt);
        System.out.println("DESede 加密后的串：" + encrypt + "DESede 解密的数据：" + decrypt);
    }

    /**
     * Blowfish 加密、解密
     *
     * @param data 加密数据
     */
    public static void blowfishEncrypt(String data, String secret) {
        // 随机生成密钥
        byte[] key = SecureUtil.generateKey(SymmetricAlgorithm.Blowfish.getValue(), secret.getBytes()).getEncoded();
        // 创建 Blowfish 对象
        SymmetricCrypto blowfish = new SymmetricCrypto(SymmetricAlgorithm.Blowfish, key);
        // 加密
        String encrypt = blowfish.encryptHex(data);
        // 解密
        String decrypt = blowfish.decryptStr(encrypt);
        System.out.println("Blowfish 加密后的串：" + encrypt + "Blowfish 解密的数据：" + decrypt);
    }

    /**
     * RC2 加密、解密
     *
     * @param data 加密数据
     */
    public static void rc2Encrypt(String data, String secret) {
        // 随机生成密钥
        byte[] key = SecureUtil.generateKey(SymmetricAlgorithm.RC2.getValue(), secret.getBytes()).getEncoded();
        // 创建 RC2 对象
        SymmetricCrypto rc2 = new SymmetricCrypto(SymmetricAlgorithm.RC2, key);
        // 加密
        String encrypt = rc2.encryptHex(data);
        // 解密
        String decrypt = rc2.decryptStr(encrypt);
        System.out.println("RC2 加密后的串：" + encrypt + "RC2 解密的数据：" + decrypt);
    }

    /**
     * ARCFOUR 加密、解密
     *
     * @param data 加密数据
     */
    public static void arcfourEncrypt(String data, String secret) {
        // 随机生成密钥
        byte[] key = SecureUtil.generateKey(SymmetricAlgorithm.ARCFOUR.getValue(), secret.getBytes()).getEncoded();
        // 创建 ARCFOUR 对象
        SymmetricCrypto arcfour = new SymmetricCrypto(SymmetricAlgorithm.ARCFOUR, key);
        // 加密
        String encrypt = arcfour.encryptHex(data);
        // 解密
        String decrypt = arcfour.decryptStr(encrypt);
        System.out.println("ARCFOUR 加密后的串：" + encrypt + "ARCFOUR 解密的数据：" + decrypt);
    }

    public static void main(String[] args) throws UnsupportedEncodingException {
        /* 设置要加密的内容 */
        String data = "测试数据";
        String secret1 = "abcdefghijklmnop";
        String secret2 = "abcdefghijklmnopqrstuvwx";
        /* AES加密 */
        aesEncrypt(data, secret1);
        /* DES加密 */
        desEncrypt(data, secret1);
        /* RC2加密 */
        rc2Encrypt(data, secret1);
        /* Blowfish加密 */
        blowfishEncrypt(data, secret1);
        /* ARCFOUR加密 */
        arcfourEncrypt(data, secret1);
        /* DESede加密 */
        desedeEncrypt(data, secret2);
    }

}

5,签名

package club.mydlq.encrypt;

import cn.hutool.core.codec.Base64;
import cn.hutool.crypto.SecureUtil;
import cn.hutool.crypto.asymmetric.Sign;
import cn.hutool.crypto.asymmetric.SignAlgorithm;
import java.security.KeyPair;
import java.security.PrivateKey;
import java.security.PublicKey;

/**
 * 签名
 */
public class SignExample {

    /**
     * RSA 私钥签名
     *
     * @param data             签名数据
     * @param privateKeyString 私钥字符串
     */
    public static String rsaSign(String data, String privateKeyString) {
        // 将私钥字符串转换成私钥对象
        PrivateKey privateKey = SecureUtil.generatePrivateKey("RSA", Base64.decode(privateKeyString));
        // 设置签名对象以及加密算法
        Sign sign = SecureUtil.sign(SignAlgorithm.MD5withRSA);
        // 设置私钥，然后执行签名
        sign.setPrivateKey(privateKey);
        byte[] bytes = sign.sign(data.getBytes());
        // 将签名转换为 Base64 字符串，然后返回
        return Base64.encode(bytes);
    }

    /**
     * RSA 公钥验签
     *
     * @param data            签名数据
     * @param publicKeyString 公钥
     * @param signString      签名
     * @return 是否验证成功
     */
    public static boolean rsaSignVerify(String data, String publicKeyString, String signString) {
        // 将公钥字符串转换成公钥对象
        PublicKey publicKey = SecureUtil.generatePublicKey("RSA", Base64.decode(publicKeyString));
        // 设置签名对象以及加密算法
        Sign sign = SecureUtil.sign(SignAlgorithm.MD5withRSA);
        // 将签名字符串转换成 byte 数组
        byte[] bytes = Base64.decode(signString);
        // 设置公钥，然后执行验签
        sign.setPublicKey(publicKey);
        return sign.verify(data.getBytes(), bytes);
    }

    public static void main(String[] args) {
        /* 生成钥匙对 */
        KeyPair pair = SecureUtil.generateKeyPair("RSA");
        PrivateKey privateKey = pair.getPrivate();
        PublicKey publicKey = pair.getPublic();
        // 将公钥私钥转换成 Base64 字符串
        String privateKeyString = Base64.encode(privateKey.getEncoded());
        String publicKeyString = Base64.encode(publicKey.getEncoded());
        /* 设置要加密的内容 */
        String data = "测试数据";
        /* RSA 私钥签名,公钥验签 */
        String sign = rsaSign(data, privateKeyString);
        boolean verify = rsaSignVerify(data, publicKeyString, sign);
        System.out.println("签名验证结果：" + verify);
    }

}