RSA加密解密&DES加密解密&AES

已于 2023-05-23 21:53:31 修改
阅读量3.2k 收藏 2
点赞数 1
分类专栏： # Spring security # 工具类 文章标签： java java-ee 开发语言
于 2022-03-14 15:31:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_16992475/article/details/123479725
版权

文章目录

RSA

java

依赖

<dependency>
    <groupId>commons-codec</groupId>
    <artifactId>commons-codec</artifactId>
    <version>1.15</version>
</dependency>

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>

RSACoder

package com.zzhua.rsa2;

import org.apache.commons.codec.binary.Base64;

import javax.crypto.Cipher;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

public class RSACoder {

    public static final String KEY_ALGORITHM = "RSA";
    public static final String SIGNATURE_ALGORITHM = "MD5withRSA";

    private static final String PUBLIC_KEY = "RSAPublicKey";
    private static final String PRIVATE_KEY = "RSAPrivateKey";

    public static byte[] decryptBASE64(String key) {
        return Base64.decodeBase64(key);
    }

    public static String encryptBASE64(byte[] bytes) {
        return Base64.encodeBase64String(bytes);
    }

    /**
     * 用私钥对信息生成数字签名
     *
     * @param data    加密数据
     * @param privateKey 私钥
     * @return
     * @throws Exception
     */
    public static String sign(byte[] data, String privateKey) throws Exception {
        // 解密由base64编码的私钥
        byte[] keyBytes = decryptBASE64(privateKey);
        // 构造PKCS8EncodedKeySpec对象
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        // KEY_ALGORITHM 指定的加密算法
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        // 取私钥匙对象
        PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);
        // 用私钥对信息生成数字签名
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initSign(priKey);
        signature.update(data);
        return encryptBASE64(signature.sign());
    }

    /**
     * 校验数字签名
     *
     * @param data   加密数据
     * @param publicKey 公钥
     * @param sign   数字签名
     * @return 校验成功返回true 失败返回false
     * @throws Exception
     */
    public static boolean verify(byte[] data, String publicKey, String sign)
            throws Exception {
        // 解密由base64编码的公钥
        byte[] keyBytes = decryptBASE64(publicKey);
        // 构造X509EncodedKeySpec对象
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        // KEY_ALGORITHM 指定的加密算法
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        // 取公钥匙对象
        PublicKey pubKey = keyFactory.generatePublic(keySpec);
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initVerify(pubKey);
        signature.update(data);
        // 验证签名是否正常
        return signature.verify(decryptBASE64(sign));
    }

    public static byte[] decryptByPrivateKey(byte[] data, String key) throws Exception{
        // 对密钥解密
        byte[] keyBytes = decryptBASE64(key);
        // 取得私钥
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
        // 对数据解密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        return cipher.doFinal(data);
    }

    /**
     * 解密<br>
     * 用私钥解密
     *
     * @param data
     * @param key
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPrivateKey(String data, String key)
            throws Exception {
        return decryptByPrivateKey(decryptBASE64(data),key);
    }

    /**
     * 解密<br>
     * 用公钥解密
     *
     * @param data
     * @param key
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPublicKey(byte[] data, String key)
            throws Exception {
        // 对密钥解密
        byte[] keyBytes = decryptBASE64(key);
        // 取得公钥
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key publicKey = keyFactory.generatePublic(x509KeySpec);
        // 对数据解密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, publicKey);
        return cipher.doFinal(data);
    }

    /**
     * 加密<br>
     * 用公钥加密
     *
     * @param data
     * @param key
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPublicKey(String data, String key)
            throws Exception {
        // 对公钥解密
        byte[] keyBytes = decryptBASE64(key);
        // 取得公钥
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key publicKey = keyFactory.generatePublic(x509KeySpec);
        // 对数据加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        return cipher.doFinal(data.getBytes());
    }

    /**
     * 加密<br>
     * 用私钥加密
     *
     * @param data
     * @param key
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPrivateKey(byte[] data, String key)
            throws Exception {
        // 对密钥解密
        byte[] keyBytes = decryptBASE64(key);
        // 取得私钥
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
        // 对数据加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, privateKey);
        return cipher.doFinal(data);
    }

    /**
     * 取得私钥
     *
     * @param keyMap
     * @return
     * @throws Exception
     */
    public static String getPrivateKey(Map<String, Key> keyMap)
            throws Exception {
        Key key = (Key) keyMap.get(PRIVATE_KEY);
        return encryptBASE64(key.getEncoded());
    }

    /**
     * 取得公钥
     *
     * @param keyMap
     * @return
     * @throws Exception
     */
    public static String getPublicKey(Map<String, Key> keyMap)
            throws Exception {
        Key key = keyMap.get(PUBLIC_KEY);
        return encryptBASE64(key.getEncoded());
    }

    /**
     * 初始化密钥
     *
     * @return
     * @throws Exception
     */
    public static Map<String, Key> initKey() throws Exception {
        KeyPairGenerator keyPairGen = KeyPairGenerator
                .getInstance(KEY_ALGORITHM);
        keyPairGen.initialize(1024);
        KeyPair keyPair = keyPairGen.generateKeyPair();
        Map<String, Key> keyMap = new HashMap(2);
        keyMap.put(PUBLIC_KEY, keyPair.getPublic());// 公钥
        keyMap.put(PRIVATE_KEY, keyPair.getPrivate());// 私钥
        return keyMap;
    }
}

RSACoderTest

package com.zzhua.rsa2;

import org.junit.Before;
import org.junit.Test;

import java.security.Key;
import java.util.Map;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

public class RSACoderTest {

  private String publicKey;
  private String privateKey;

  @Before
  public void setUp() throws Exception {
    Map<String, Key> keyMap = RSACoder.initKey();
    publicKey = RSACoder.getPublicKey(keyMap);
    privateKey = RSACoder.getPrivateKey(keyMap);
    System.err.println("公钥: \n\r" + publicKey);
    System.err.println("私钥： \n\r" + privateKey);
  }

  @Test
  public void test() throws Exception {
    System.err.println("公钥加密——私钥解密");
    String inputStr = "abc";
    byte[] encodedData = RSACoder.encryptByPublicKey(inputStr, publicKey);
    byte[] decodedData = RSACoder.decryptByPrivateKey(encodedData,privateKey);
    String outputStr = new String(decodedData);
    System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);
    assertEquals(inputStr, outputStr);
  }

  @Test
  public void testSign() throws Exception {
    System.err.println("私钥加密——公钥解密");
    String inputStr = "sign";
    byte[] data = inputStr.getBytes();
    byte[] encodedData = RSACoder.encryptByPrivateKey(data, privateKey);
    byte[] decodedData = RSACoder.decryptByPublicKey(encodedData, publicKey);
    String outputStr = new String(decodedData);
    System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);
    assertEquals(inputStr, outputStr);
    System.err.println("私钥签名——公钥验证签名");
    // 产生签名
    String sign = RSACoder.sign(encodedData, privateKey);
    System.err.println("签名:" + sign);
    // 验证签名
    boolean status = RSACoder.verify(encodedData, publicKey, sign);
    System.err.println("状态:" + status);
    assertTrue(status);
  }
}

js示例

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>使用jsencrypt执行OpenSSL的RSA加密，解密</title>
</head>
<!--引入jsencrypt.js-->
<script src="https://cdn.bootcss.com/jsencrypt/3.0.0-beta.1/jsencrypt.js"></script>
<script type="text/javascript">
    /*//公钥
    var PUBLIC_KEY = 'MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDpznfYaSCz50hEp28u3BWR23MMLcpfH3TVmcRbHz9J6xgmDbhP5erjs7qkSbcHNo2EtNzTiBO7wD6JaOHVSBKsuNXqVoNZT2sYvrNCJAT79rm9qKGh1yjBf0soLuHiBYYxOi2G2aY1AUr8MIzjFEsagIUnN/Rhdo4YKc45tSi3+QIDAQAB';
    //私钥
    var PRIVATE_KEY = 'MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAOnOd9hpILPnSESnby7cFZHbcwwtyl8fdNWZxFsfP0nrGCYNuE/l6uOzuqRJtwc2jYS03NOIE7vAPolo4dVIEqy41epWg1lPaxi+s0IkBPv2ub2ooaHXKMF/Sygu4eIFhjE6LYbZpjUBSvwwjOMUSxqAhSc39GF2jhgpzjm1KLf5AgMBAAECgYEA5Boc7jNSRnIEHYbEgBETsiNJEL6zyy3jTGkiGkxX8IO+IZINGVYUXWYBVzrbp9vfIXNaZb1Ck0+xM1nxyaTxIVewXHdSeoWpqMb+0Gt6HApLr3b7dWTlcTGm8AEnniL6thpE5NCuUoLPxJPjAnCxMVZzivDg3TyDNhEnBMGecckCQQD/4XQlMhog2NEa3AXRjBacQw6cU3yUAntRo3r3eqzzdX+QE84Um73AEeS/BE2WtFjSoPpeLNY9WInlwk9N/jJLAkEA6ephGfqemAJCMS3n61J8ENVYLV+kGINKuOzlpY8zbTTDvfa3K3rFFeyIJ3B8v3AqxDiu+Z580/ksxyUsJvJ0SwJAA2KVKcTO6a5UndlZTltfFTQh5lmIZWDfBsZ14v5BeXsNc/d/G3CwAvF5qDlDWYILRsYQadyH/QnF0T9P00VQnwJANJ4KVaOwhRUM+q8O2jplugujmCFJclImPs7bIZDCyq/x0AttTJSDPNlGD0kYZp++nwD5KyFhhvUoA2vzMJedXQJBAKNWvohLKS+BuuwjOIRJ7sFLnaXxlShp7GcTVs1cJ5krN9beHNzaZPtjDBKlDyvd3GxH/cFdy+F5WChMNsO0j6I=';
    //使用公钥加密
    var encrypt = new JSEncrypt();
    encrypt.setPublicKey( PUBLIC_KEY );
    var str = 'device001'
    var encrypted = encrypt.encrypt(str);
    console.log('加密前数据:%o', str);
    console.log('加密后数据:%o', encrypted);
    //使用私钥解密
    var decrypt = new JSEncrypt();
    decrypt.setPrivateKey(PRIVATE_KEY);
    var uncrypted = decrypt.decrypt(encrypted);
    console.log('解密后数据:%o', uncrypted);*/

    var PUBLIC_KEY = 'MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCLVWtmmXadwWbKAuvXWLzCY3A844s6eJ1I19JTEmMrbmaQP4hC6/4ks6Ix+BJPF/ikpVDie6gBg4qsSbrBjckA8AvflYU0ixw0rEzd+tv2o0d+afZEJdIW2SL/+78FUuGdu7ChYeUX9DLEM8dScIdWYoVREey0ei+H9dIQcLyiswIDAQAB';

    var PRIVATE_KEY = 'MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAItVa2aZdp3BZsoC69dYvMJjcDzjizp4nUjX0lMSYytuZpA/iELr/iSzojH4Ek8X+KSlUOJ7qAGDiqxJusGNyQDwC9+VhTSLHDSsTN362/ajR35p9kQl0hbZIv/7vwVS4Z27sKFh5Rf0MsQzx1Jwh1ZihVER7LR6L4f10hBwvKKzAgMBAAECgYAPXWURlFzDOr+WCUpuned63DJVVJZW5VQa40nbRUzQTkVbJNZm4tVMwM5jCkMim7ccmOpZf19gg1v4ccz5aSRAHpZ4ZwbUI4D1eHUygXeiWkGsY4oPfRiMRB/Rv3Fsd4HlaMt4Cxkg0cxvg4FwknoPGHsUBDBWXntiQhtuO9BtOQJBAOp9TuFi2B+vo6YU4YtLfk27C6tORknV0sDicbkvp+NQCez0bU4oaHiooz5uIt/YL1ofbdb03AFJcfR0a2JkCi0CQQCYHX8Lp9P1o9y+SXNlrSs5CExx/Ev1/AFVov/+OThZxVU5/93WjlHvC0TX/A6Ey5Oep6934fhS3Q/3URfRJcxfAkA2J/qv00RXDRmeofP1V9oz2Z84UTuqkde69JGPU5JSzYl9UHZuNqbqNwh8wrMLP8Kv7dJQcvzczzmiW8DxWGmBAkBWx50O/TPC0zS/qg+XVe9unflendyH/LiWLmN0mRg4vocci4f3O0Iq6Xbg8P8nayxQOsGz1spgG5VcNnsr6jBpAkEA5VwKRVtRxr5ibHZEHL6vHyhvnaXQaTNOjZiAdjt5iG67PX93+nvHHhmwOrvGrsQizznbe+HwrEWPIdI0jYQSvw==';

    var encrypt = new JSEncrypt();
    encrypt.setPublicKey(PUBLIC_KEY);

    console.log(encrypt.encrypt('device002'))
	// 加密结果如：QoDEtpouVY+6F309w6NBlnSEXvFMtwPyFMk77I6RvtN8GL1fxWf1ZDt9r2QVgVHJLAZ4PkzfNIxzsbseD8PyNYIogVTC43LjIeVJklVAIjBvIr3IW28GcFAzEqGKR/WuubxFXmqmER/ixVJyYBuEuGMYPklrqAq5ZHC5YF7eN9Q=
	
	// 解密：System.out.println(new String(RSACoder.decryptByPrivateKey(
	// "QoDEtpouVY+6F309w6NBlnSEXvFMtwPyFMk77I6RvtN8GL1fxWf1ZDt9r2QVgVHJLAZ4PkzfNIxzsbseD8PyNYIogVTC43LjIeVJklVAIjBvIr3IW28GcFAzEqGKR/WuubxFXmqmER/ixVJyYBuEuGMYPklrqAq5ZHC5YF7eN9Q=", 
	// "MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAItVa2aZdp3BZsoC69dYvMJjcDzjizp4nUjX0lMSYytuZpA/iELr/iSzojH4Ek8X+KSlUOJ7qAGDiqxJusGNyQDwC9+VhTSLHDSsTN362/ajR35p9kQl0hbZIv/7vwVS4Z27sKFh5Rf0MsQzx1Jwh1ZihVER7LR6L4f10hBwvKKzAgMBAAECgYAPXWURlFzDOr+WCUpuned63DJVVJZW5VQa40nbRUzQTkVbJNZm4tVMwM5jCkMim7ccmOpZf19gg1v4ccz5aSRAHpZ4ZwbUI4D1eHUygXeiWkGsY4oPfRiMRB/Rv3Fsd4HlaMt4Cxkg0cxvg4FwknoPGHsUBDBWXntiQhtuO9BtOQJBAOp9TuFi2B+vo6YU4YtLfk27C6tORknV0sDicbkvp+NQCez0bU4oaHiooz5uIt/YL1ofbdb03AFJcfR0a2JkCi0CQQCYHX8Lp9P1o9y+SXNlrSs5CExx/Ev1/AFVov/+OThZxVU5/93WjlHvC0TX/A6Ey5Oep6934fhS3Q/3URfRJcxfAkA2J/qv00RXDRmeofP1V9oz2Z84UTuqkde69JGPU5JSzYl9UHZuNqbqNwh8wrMLP8Kv7dJQcvzczzmiW8DxWGmBAkBWx50O/TPC0zS/qg+XVe9unflendyH/LiWLmN0mRg4vocci4f3O0Iq6Xbg8P8nayxQOsGz1spgG5VcNnsr6jBpAkEA5VwKRVtRxr5ibHZEHL6vHyhvnaXQaTNOjZiAdjt5iG67PX93+nvHHhmwOrvGrsQizznbe+HwrEWPIdI0jYQSvw=="))
	// );


</script>

</html>

DES

示例一

js

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <!-- vue项目中引入var CryptoJS = require("crypto-js"); -->
    <script src="https://cdn.bootcdn.net/ajax/libs/crypto-js/4.1.1/core.min.js"></script>
    <script src="https://cdn.bootcdn.net/ajax/libs/crypto-js/4.1.1/cipher-core.min.js"></script>
    <script src="https://cdn.bootcdn.net/ajax/libs/crypto-js/4.1.1/mode-ecb.min.js"></script>
    <script src="https://cdn.bootcdn.net/ajax/libs/crypto-js/4.1.1/tripledes.min.js"></script>
</head>
<body>



</body>
<script>
    //加密的私钥
    var key = '1qaz@WSX';//自定义

    // DES加密
    function encryptByDES(message) {//传入加密的内容
        //把私钥转换成16进制的字符串
        var keyHex = CryptoJS.enc.Utf8.parse(key);
        //模式为ECB padding为Pkcs7
        var encrypted = CryptoJS.DES.encrypt(message, keyHex, {
            mode: CryptoJS.mode.ECB,
            padding: CryptoJS.pad.Pkcs7
        });
        //加密出来是一个16进制的字符串
        return encrypted.ciphertext.toString();
    }

    console.log(encryptByDES("device001")) // 2c9a133b2f5deb4adde2ca280a464ee8
    // 解密：System.out.println(DESUtils.decryption("2c9a133b2f5deb4adde2ca280a464ee8", "1qaz@WSX"));
</script>
</html>

java

package com.zzhua.des;

import java.security.NoSuchAlgorithmException;
import java.security.spec.InvalidKeySpecException;
import java.util.Locale;

import javax.crypto.Cipher;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;


public class DESUtils {

    /**
     * DES解密
     *
     * @param secretData 密码字符串
     * @param secretKey  解密密钥
     * @return 原始字符串
     * @throws Exception
     */
    private static final String DES_ALGORITHM = "DES";

    public static String decryption(String secretData, String secretKey) throws Exception {
        Cipher cipher = null;
        try {
            cipher = Cipher.getInstance("DES/ECB/NoPadding");
            cipher.init(Cipher.DECRYPT_MODE, generateKey(secretKey));
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
            throw new Exception("NoSuchAlgorithmException", e);
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
            throw new Exception("NoSuchPaddingException", e);
        } catch (Exception e) {
            e.printStackTrace();
        }

        try {

            byte[] buf = cipher.doFinal(hexStr2Bytes(secretData));
            int num = 0;
            for (byte b: buf) {
                String name = b+"";
                if (name.length() == 1) {
                    num++;
                }
            }

            byte[] bytes = new byte[buf.length-num];
            for (int i =0; i < buf.length; i++) {
                String name = buf[i]+"";
                if (name.length() != 1) {
                    bytes[i] = buf[i];
                }
            }

            return new String(bytes, "utf-8");

        } catch (Exception e) {
            e.printStackTrace();
            throw new Exception("IllegalBlockSizeException", e);
        }
    }

    public static byte[] hexStr2Bytes(String src) {
        /*对输入值进行规范化整理*/
        src = src.trim().replace(" ", "").toUpperCase(Locale.US);
        //处理值初始化
        int m = 0, n = 0;
        int iLen = src.length() / 2; //计算长度
        byte[] ret = new byte[iLen]; //分配存储空间

        for (int i = 0; i < iLen; i++) {
            m = i * 2 + 1;
            n = m + 1;
            ret[i] = (byte) (Integer.decode("0X" + src.substring(i * 2, m) + src.substring(m, n)) & 0xFF);
        }
        return ret;
    }

    /**
     * 获得秘密密钥
     *
     * @param secretKey
     * @return
     * @throws NoSuchAlgorithmException
     * @throws InvalidKeySpecException
     */
    private static SecretKey generateKey(String secretKey)
            throws Exception {
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES_ALGORITHM);
        DESKeySpec keySpec = new DESKeySpec(secretKey.getBytes());
        keyFactory.generateSecret(keySpec);
        return keyFactory.generateSecret(keySpec);
    }
}

示例2

参照：https://www.jianshu.com/p/24691c8d722c

js

var CryptoJS = require("crypto-js");

    const secretKey = "q9rx*a.SjzH"; 

    var afterEncrypt = CryptoJS.DES.encrypt(
      "device_001",
      CryptoJS.enc.Utf8.parse(secretKey),
      {
        mode: CryptoJS.mode.ECB,
        padding: CryptoJS.pad.Pkcs7,
      }
    ).toString();

    console.log(afterEncrypt); // 1XyZG40XBRbt/9HGiyAPaUcVfFa7SJ+c

    var afterDecrypt = CryptoJS.DES.decrypt(
      afterEncrypt,
      CryptoJS.enc.Utf8.parse(secretKey),
      {
        mode: CryptoJS.mode.ECB,
        padding: CryptoJS.pad.Pkcs7,
      }
    ).toString(CryptoJS.enc.Utf8);

    console.log(afterDecrypt); //device_001
  },

java

package com.zzhua.des2;


import org.bouncycastle.jce.provider.BouncyCastleProvider;

import javax.crypto.*;
import javax.crypto.spec.DESKeySpec;
import java.nio.charset.Charset;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.Security;
import java.security.spec.InvalidKeySpecException;
import java.util.Base64;

public class DesCipherUtil {

    private DesCipherUtil() {
        throw new AssertionError("No DesCipherUtil instances for you!");
    }

    static {
        // add BC provider
        Security.addProvider(new BouncyCastleProvider());
    }

    /**
     * 加密
     *
     * @param encryptText 需要加密的信息
     * @param key 加密密钥
     * @return 加密后Base64编码的字符串
     */
    public static String encrypt(String encryptText, String key) {

        if (encryptText == null || key == null) {
            throw new IllegalArgumentException("encryptText or key must not be null");
        }

        try {
            DESKeySpec desKeySpec = new DESKeySpec(key.getBytes());
            SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance("DES");
            SecretKey secretKey = secretKeyFactory.generateSecret(desKeySpec);

            Cipher cipher = Cipher.getInstance("DES/ECB/PKCS7Padding", "BC");
            cipher.init(Cipher.ENCRYPT_MODE, secretKey);
            byte[] bytes = cipher.doFinal(encryptText.getBytes(Charset.forName("UTF-8")));
            return Base64.getEncoder().encodeToString(bytes);

        } catch (NoSuchAlgorithmException | InvalidKeyException | InvalidKeySpecException | NoSuchPaddingException
            | BadPaddingException | NoSuchProviderException | IllegalBlockSizeException e) {
            throw new RuntimeException("encrypt failed", e);
        }

    }

    /**
     * 解密
     *
     * @param decryptText 需要解密的信息
     * @param key 解密密钥，经过Base64编码
     * @return 解密后的字符串
     */
    public static  String decrypt(String decryptText, String key) {

        if (decryptText == null || key == null) {
            throw new IllegalArgumentException("decryptText or key must not be null");
        }

        try {
            DESKeySpec desKeySpec = new DESKeySpec(key.getBytes());
            SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance("DES");
            SecretKey secretKey = secretKeyFactory.generateSecret(desKeySpec);

            Cipher cipher = Cipher.getInstance("DES/ECB/PKCS7Padding", "BC");
            cipher.init(Cipher.DECRYPT_MODE, secretKey);
            byte[] bytes = cipher.doFinal(Base64.getDecoder().decode(decryptText));
            return new String(bytes, Charset.forName("UTF-8"));

        } catch (NoSuchAlgorithmException | InvalidKeyException | InvalidKeySpecException | NoSuchPaddingException
            | BadPaddingException | NoSuchProviderException | IllegalBlockSizeException e) {
            throw new RuntimeException("decrypt failed", e);
        }
    }

    public static void main(String[] args) {
        String fromWeb = "7aokwkzN+gxMdyOFAUEBVg==";
        String key = "q9rx*a.SjzH";
        String afterDecrypt = DesCipherUtil.decrypt(fromWeb, key);
        System.out.println(afterDecrypt);//q9rx*a.SjzH

        System.out.println(DesCipherUtil.encrypt("device_001", key));

    }
}

AES

AesUtil

import org.apache.commons.codec.binary.Base64;
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;

/*
 测试 网站 http://tool.chacuo.net/cryptaes
 */
public class AesUtil {
    private static final String ALGORITHMSTR = "AES/ECB/PKCS5Padding";

    /**
     *  加密  key 需 16位
     * @param content
     * @param key
     * @return
     */
    public static String encrypt(String content, String key) {
        try {
            //获得密码的字节数组
            byte[] raw = key.getBytes();
            //根据密码生成AES密钥
            SecretKeySpec skey = new SecretKeySpec(raw, "AES");
            //根据指定算法ALGORITHM自成密码器
            Cipher cipher = Cipher.getInstance(ALGORITHMSTR);
            //初始化密码器，第一个参数为加密(ENCRYPT_MODE)或者解密(DECRYPT_MODE)操作，第二个参数为生成的AES密钥 16位
            cipher.init(Cipher.ENCRYPT_MODE, skey);
            //获取加密内容的字节数组(设置为utf-8)不然内容中如果有中文和英文混合中文就会解密为乱码
            byte [] byte_content = content.getBytes("utf-8");
            //密码器加密数据
            byte [] encode_content = cipher.doFinal(byte_content);
            //将加密后的数据转换为Base64编码的字符串返回
            return Base64.encodeBase64String(encode_content);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 解密  key 需 16位
     * @param encryptStr
     * @param decryptKey
     * @return
     */
    public static String decrypt(String encryptStr, String decryptKey) {
        try {
            //获得密码的字节数组
            byte[] raw = decryptKey.getBytes();
            //根据密码生成AES密钥
            SecretKeySpec skey = new SecretKeySpec(raw, "AES");
            //根据指定算法ALGORITHM自成密码器
            Cipher cipher = Cipher.getInstance(ALGORITHMSTR);
            //初始化密码器，第一个参数为加密(ENCRYPT_MODE)或者解密(DECRYPT_MODE)操作，第二个参数为生成的AES密钥
            cipher.init(Cipher.DECRYPT_MODE, skey);
            //把密文字符串Base64转回密文字节数组
            byte [] encode_content = Base64.decodeBase64(encryptStr);
            //密码器解密数据
            byte [] byte_content = cipher.doFinal(encode_content);
            //将解密后的数据转换为字符串返回
            return new String(byte_content,"utf-8");
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

   public static void main(String[] args) {
       String str = encrypt("12345678", "abgfderfgt326854");
       System.out.println(str);


       String str2 = decrypt(str, "abgfderfgt326854");
       System.out.println(str2);

   }


}
ps酷教程
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
pycryptodome des加解密学习记录
qq_30769517的博客
07-25 912
pycryptodome DES加解密举例，留存
encrypted:AES 和 RSA 加密
06-25
{ messages: [{ data: 'AES string', key: 'RSA encrypted AES key', iv: 'RSA encrypted AES iv' }], signature: .... }
Java加密技术（四）
狂徒技术分享
05-26 117
    接下来我们介绍典型的非对称加密算法——RSA RSA     这种算法1978年就出现了，它是第一个既能用于数据加密也能用于数字签名的算法。它易于理解和操作，也很流行。算法的名字以发明者的名字命名：Ron Rivest, AdiShamir 和Leonard Adleman。     这种加密算法的特点主要是密钥的变化，上文我们看到DES只有一个密钥。相当于只有一把钥匙，如果这把钥匙丢了，...
RSA 加密和解密介绍
KevinSwift的博客
02-24 5100
RSA加密和解密的一些简单介绍和实现
微信小程序encryptedData解密工具类
林一天的博客
05-24 8990
微信小程序开发，很多情况都会使用openid，另外小程序关联公众号使用公众号模板消息做消息提示时，由于此时的unionid是一致的，可以通过微信小程序的unionid间接获取到公众号模板消息发送时需要使用到的openid，所以，unionid也同样经常获取。但是微信小程序调用getUserinfo接口的时候，不会直接返回openid以及unionid，这些私密的信息一般会保存在加密字段encryp...
RSA算法以及DES算法对文件加密
qq_37657601的博客
03-29 1389
通过RSA算法加密以及DES算法对文件加密 --python 原理：python 利用迭代器读取大文件，然后通过rsa和des混合加密算法对数据进行加密。des是对称性加密算法，rsa是非对称性加密算法。des对文件加密，通过rsa对des的key进行加密。解密时用rsa解密key，然后key解密文件内容。 希望对大家有所帮助。 RSA算法利用python的M2Crypto模块。...
ios常见加密解密方法（RSA、DES 、AES、MD5）
08-31
在iOS端，可以使用系统提供的SecKey API来实现RSA加密解密，但需要注意的是，iOS不支持私钥加密公钥解密，这主要是为了防止客户端数据的安全性降低。在iOS和Java之间进行加密解密时，可能会遇到兼容性问题，如错误...
php+uni-app AES加密解密.rar
05-20
在uni-app中，可以使用JavaScript的crypto-js库来实现AES加密解密。首先，你需要通过HBuilderX引入该库，然后在uni-app代码中使用： ```javascript const CryptoJS = require('crypto-js'); const key = 'your_...
纯C++简易加密库，含Aes、Des、Rsa、MD5加密解密
最新发布
02-27
对于需要快速实现数据加密解密功能的开发者来说，这是一个非常实用的资源。 总的来说，这个C++加密库涵盖了对称加密（AES、DES）和非对称加密（RSA），以及哈希算法（MD5），覆盖了信息安全中的基础需求。开发者...
vue项目中使用AES实现密码加密解密（ECB和CBC两种模式）
10-16
总之，在Vue项目中实现AES加密解密可以有效保护用户数据，ECB模式简单但可能存在模式可预测性，而CBC模式通过引入初始向量提高了安全性。正确理解和运用这些加密技术，有助于构建更加安全的Web应用。在开发过程中，...
des_encrypt.java
04-06
des 压缩加密算法 是一个神奇的算法 java进行了实现
创建第一个区块001
梨子社区
11-27 1697
package main import ( "crypto/sha256" "fmt" ) //定义结构 type Block struct { //定义前区块哈希 Prevhash []byte //定义当前区块哈希 Hash []byte //数据 Data []byte } //2 创建区块 创建需要的数据和前区块的哈希 func NewBlock(data string,prevBlcokHash []byte) *Block { block:=Bl...
爬虫基础（4）发送请求之requests库的使用
Python达人
03-21 2272
文章目录一. 什么是Requests库二. 安装Requests库三. Requests库的基本应用（一）发送请求1. 实例引入2. GET请求（1）最基本的GET请求（2）带参数的GET请求（3）解析JSON（4）抓取二进制数据（5）添加headers3. POST请求（二）接收响应1. 响应信息2. 响应状态码四. Requests库的高级应用（一）文件上传（二）Cookies1. 获取 Cookies2. 应用实例（三）维持会话、模拟登录（四）SSL证书验证（五）代理设置（六）超时设置（七）身份认证（
Oracle数据库中 DECRYPT_DES 加密解密对应JAVA类
NuoleAQ的博客
02-18 2603
import javax.crypto.Cipher; import javax.crypto.SecretKey; import javax.crypto.SecretKeyFactory; import javax.crypto.spec.DESKeySpec; import javax.crypto.spec.IvParameterSpec; import javax.xml.bind.Da...
ace加密和解密（encrypt、decrypt）
weixin_44134816的博客
02-21 1317
【代码】ace加密和解密（encrypt、decrypt）
程序人生-Hello’s P2P
weixin_45707270的博客
06-27 566
计算机系统 大作业 题目程序人生-Hello’s P2P 专业计算机类 学  号1190201802 班  级1903012 学生张靓雯  指导教师史先俊 计算机科学与技术学院 2021年5月 摘...
linux ctg重装,Linux 下从头再走 GTK+-3.0 (五)
热门推荐
weixin_31749207的博客
05-15 1万+
实践中表明，纯粹利用 gtk 函数来创建 UI 是很繁琐的事，需要编写很多代码。怎样才能快速统一的建立 UI 布局呢？可喜的是 GTK 提供了一个 GtkBuilder 用于快速创建界面。它读取一个 xml 文件。按照 xml 文件中所描述的来创建界面。因此我们需要编写 xml 文件。创建example.ui ，内容如下：TrueGtkBuilder30TrueTrueButton 100True...
解密chrome cookies文件的encrypted_value
wherwh的专栏
06-23 7260
1.环境 .windows 8 (x64) .chrome cookies文件(sqlite 3):%USERPROFILE%\AppData\Local\Google\Chrome\User Data\Default\Cookies   2.事由 解密chrome cookies数据的场景. 一个后台程序需要从3个平台抓取数据,每个平台的用户验证方式各不相同.利用浏览器登录后导出cooki...
简单粗暴的前端加解密方法
zhengxiaocai的博客
02-07 3076
这里的加密的key值是写死的。也是该加密方法的局限处。 加密方法： function Encrypt(word){ var key = CryptoJS.enc.Utf8.parse("HubbleStarMetaGT"); var iv = CryptoJS.enc.Utf8.parse("0102030405060708"); var srcs = C
AES、DES与RSA加密算法深度解析
总结来说，本文详细解释了AES、DES和RSA加密算法的基本原理、密钥长度选择、加密流程以及它们在实际中的应用场景。对称加密算法因其效率高，广泛应用于大量数据的加密，而非对称加密算法则因其安全性强，适用于关键...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值