常用加解密算法

最新推荐文章于 2024-03-21 13:36:17 发布
最新推荐文章于 2024-03-21 13:36:17 发布
阅读量926 收藏 2
点赞数
分类专栏： 加密 文章标签： java 安全加密 AES DH RSA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/seantandol/article/details/86712819
版权

文章目录

分类

  • 对称加密：对称式加密方式对加密和解密使用相同的密钥。通常，这种加密方式在应用中难以实施，因为用同一种安全方式共享密钥很难。如：RC4、RC2、DES 和 AES 系列加密算法。
  • 非对称加密：非对称密钥加密（Asymmetric Key Encryption）：非对称密钥加密使用一组公共/私人密钥系统，加密时使用一种密钥，解密时使用另一种密钥。公共密钥可以广泛的共享和透露。当需要用加密方式向服务器外部传送数据时，这种加密方式更方便。如： RSA
  • 签名算法（数字证书）：数字证书是一种非对称密钥加密，但是，一个组织可以使用证书并通过数字签名将一组公钥和私钥与其拥有者相关联。

对称加密之AES

特点：

  • 密钥建立时间短、灵敏性好、内存需求低（不管怎样，反正就是好）
  • 最常用的对称加密算法

以下为AES的实现细节：
AES
AES的常用工作模式有ECB和CTR，其中CTR需要设置IV参数，可参考第八章 对称加密算法–AES，以下代码为ECB模式的实现：

package com.sean.test.security;

import org.apache.xerces.impl.dv.util.Base64;

import javax.crypto.*;
import javax.crypto.spec.SecretKeySpec;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.NoSuchAlgorithmException;

public class AESUtil {

    private static final String SECRET_ALGORITHM = "AES"; //加密算法
    public static final String SECRET_ALGORITHM_TYPE = "AES/ECB/PKCS5Padding"; //转换声明，“算法/模式/填充”
    private static final int SECRET_ALGORITHM_SIZE = 128; //指定随机生成的秘钥的长度

    /**
     * 生成秘钥
     * @return byte[] 二进制秘钥
     * @throws NoSuchAlgorithmException
     */
    public static byte[] initKey() throws NoSuchAlgorithmException {
        // 实例化
        KeyGenerator keyGenerator = KeyGenerator.getInstance(SECRET_ALGORITHM);
        // 设置秘钥长度
        keyGenerator.init(SECRET_ALGORITHM_SIZE);
        // 生成秘钥
        SecretKey secretKey = keyGenerator.generateKey();
        return secretKey.getEncoded();
    }

    /**
     * 将秘钥进行转换
     * @param keyByte
     * @return
     */
    public static Key toKey(byte[] keyByte) {
        return new SecretKeySpec(keyByte, SECRET_ALGORITHM);
    }

    /**
     * 加密
     * @param key
     * @param data
     * @return
     * @throws NoSuchPaddingException
     * @throws NoSuchAlgorithmException
     * @throws InvalidKeyException
     * @throws BadPaddingException
     * @throws IllegalBlockSizeException
     */
    public static byte[] encrypt(byte[] key, byte[] data) throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException {
        // 转换秘钥
        Key toKey = toKey(key);
        // 实例化
        Cipher cipher = Cipher.getInstance(SECRET_ALGORITHM_TYPE);
        // 设置为加密模式
        cipher.init(Cipher.ENCRYPT_MODE, toKey);
        // 执行加密操作
        return cipher.doFinal(data);
    }

    public static byte[] decrypt(byte[] key, byte[] data) throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException {
        // 转换秘钥
        Key toKey = toKey(key);
        // 实例化
        Cipher cipher = Cipher.getInstance(SECRET_ALGORITHM_TYPE);
        // 设置为解密模式
        cipher.init(Cipher.DECRYPT_MODE, toKey);
        // 执行解密操作
        return cipher.doFinal(data);
    }

    public static void main(String[] args) throws Exception {
        String str = "AES";
        System.out.println("原文为：" + str);
        byte[] key = initKey();
        System.out.println("加密秘钥为："+ Base64.encode(key));
        byte[] encryptData = AESUtil.encrypt(key, str.getBytes());
        System.out.println("加密后的内容为："+ Base64.encode(encryptData));
        byte[] decryptData = AESUtil.decrypt(key, encryptData);
        System.out.println("解密后的内容为："+ new String(decryptData));
         /**
         * 运行结果：
             原文为：AES
             加密秘钥为：lTeHhjrBBbHVO3j2MGxEGQ==
             加密后的内容为：7EGu1+m7k9/z60XMoNu1Fw==
             解密后的内容为：AES
         * 
         */
        
    }
}

秘钥交换算法之DH

特点：

  • 发送方和接收方均有一个密钥对（公钥+私钥），其中公钥传播，私钥自己保存，不需要传播
  • 私钥不需要传播的特性解决了对称加密算法中密钥传播的困难（这个困难一般通过线下传递可以解决）
  • 加密安全性极高，只用于一些电子商务网站，加解密速度远低于对称加密
  • 一般情况下，为了解决非对称加密算法加解密速度低的问题，采用非对称加密（使用公钥+私钥对对称加密的密钥进行加解密）+对称加密（加解密数据）相结合的方式。

步骤：

  1. 甲方生成公钥和私钥，并将公钥发送给乙方
  2. 乙方根据甲方公钥生成公钥和私钥，将公钥发给甲方
  3. 甲乙双方拼接各自持有的公钥和私钥生成相同的秘钥，解决秘钥的传输问题
  4. 甲乙双方可根据生成的秘钥加密数据和解密对方加密的数据
package com.sean.test.security;

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

import javax.crypto.*;
import javax.crypto.interfaces.DHPublicKey;
import javax.crypto.spec.DHParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.io.UnsupportedEncodingException;
import java.security.*;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

/**
 * <p></p>
 * 无法保证对称加密算法秘钥的传输问题，可通过DH加密方式进行解决(DH本身无法对数据进行加解密)
 * 步骤：
 * 1.甲方生成公钥和私钥，并将公钥发送给乙方
 * 2.乙方根据甲方公钥生成公钥和私钥，将公钥发给甲方
 * 3.甲乙双方拼接各自持有的公钥和私钥生成相同的秘钥，解决秘钥的传输问题
 * 4.甲乙双方可根据生成的秘钥加密数据和解密对方加密的数据
 *
 * @version V1.0
 * @modificationHistory=========================逻辑或功能性重大变更记录
 * @modify by user: {修改人} 2019/2/13
 * @modify by reason:{方法名}:{原因}
 */
public class DHUtil {
    private static final String ENCODING = "UTF-8";
    private static final String DH_KEY_ALGORITHM = "DH";//非对称加密密钥算法
    private static final String SECRET_ALGORITHM = "AES";//产生本地密钥的算法（对称加密密钥算法）
    private static final String CIPHER_ALGORITHM = "AES/ECB/PKCS5Padding";//加解密算法 格式：算法/工作模式/填充模式 注意：ECB不使用IV参数
    private static final int DH_KEY_SIZE = 512;//非对称密钥长度（512~1024之间的64的整数倍）

    /**
     * 生成甲方密钥对
     */
    public static KeyPair initKey() throws NoSuchAlgorithmException {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(DH_KEY_ALGORITHM);//密钥对生成器
        keyPairGenerator.initialize(DH_KEY_SIZE);//指定密钥长度
        KeyPair keyPair = keyPairGenerator.generateKeyPair();//生成密钥对
        return keyPair;
    }

    /**
     * 生成乙方密钥对
     *
     * @param key 甲方公钥
     */
    public static KeyPair initKey(byte[] key) throws NoSuchAlgorithmException,
            InvalidKeySpecException,
            InvalidAlgorithmParameterException {
        KeyFactory keyFactory = KeyFactory.getInstance(DH_KEY_ALGORITHM);//密钥工厂
        PublicKey publicKey = keyFactory.generatePublic(new X509EncodedKeySpec(key));//还原甲方公钥
        DHParameterSpec dHParameterSpec = ((DHPublicKey) publicKey).getParams();

        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(keyFactory.getAlgorithm());//乙方密钥对生成器
        keyPairGenerator.initialize(dHParameterSpec);//使用甲方公钥参数初始化乙方密钥对生成器
        KeyPair keyPair = keyPairGenerator.generateKeyPair();//生成密钥对
        return keyPair;
    }

    /**
     * 获取公钥
     */
    public static byte[] getPublicKey(KeyPair keyPair) {
        return keyPair.getPublic().getEncoded();
    }

    /**
     * 获取私钥
     */
    public static byte[] getPrivateKey(KeyPair keyPair) {
        return keyPair.getPrivate().getEncoded();
    }

    /**
     * 根据本方私钥与对方公钥构建本地密钥（即对称加密的密钥）
     *
     * @param publicKey  对方公钥
     * @param privateKey 本方私钥
     */
    public static byte[] getSecretKey(byte[] publicKey, byte[] privateKey) throws NoSuchAlgorithmException,
            InvalidKeySpecException,
            InvalidKeyException {
        KeyFactory keyFactory = KeyFactory.getInstance(DH_KEY_ALGORITHM);//密钥工厂
        PublicKey pubkey = keyFactory.generatePublic(new X509EncodedKeySpec(publicKey));//还原公钥
        PrivateKey prikey = keyFactory.generatePrivate(new PKCS8EncodedKeySpec(privateKey));//还原私钥

        KeyAgreement keyAgreement = KeyAgreement.getInstance(keyFactory.getAlgorithm());
        keyAgreement.init(prikey);
        keyAgreement.doPhase(pubkey, true);
        return keyAgreement.generateSecret(SECRET_ALGORITHM).getEncoded();//生成本地密钥（对称加密的密钥）
    }

    /**
     * DH加密
     *
     * @param data    带加密数据
     * @param keyByte 本地密钥，由getSecretKey(byte[] publicKey, byte[] privateKey)产生
     */
    public static byte[] encrypt(String data, byte[] keyByte) throws NoSuchAlgorithmException,
            NoSuchPaddingException,
            InvalidKeyException,
            IllegalBlockSizeException,
            BadPaddingException,
            UnsupportedEncodingException {
        Key key = new SecretKeySpec(keyByte, SECRET_ALGORITHM);//生成本地密钥

        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, key);//设置加密模式并且初始化key
        return cipher.doFinal(data.getBytes(ENCODING));
    }

    /**
     * DH解密
     *
     * @param data    待解密数据为字节数组
     * @param keyByte 本地密钥，由getSecretKey(byte[] publicKey, byte[] privateKey)产生
     */
    public static byte[] decrypt(byte[] data, byte[] keyByte) throws NoSuchAlgorithmException,
            NoSuchPaddingException,
            InvalidKeyException,
            IllegalBlockSizeException,
            BadPaddingException {
        Key key = new SecretKeySpec(keyByte, SECRET_ALGORITHM);//生成本地密钥
        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, key);
        return cipher.doFinal(data);
    }


    /**
     * 测试
     */
    public static void main(String[] args) throws NoSuchAlgorithmException,
            InvalidKeySpecException,
            InvalidAlgorithmParameterException,
            InvalidKeyException,
            NoSuchPaddingException,
            IllegalBlockSizeException,
            BadPaddingException,
            UnsupportedEncodingException {
        byte[] pubKey1;//甲方公钥
        byte[] priKey1;//甲方私钥
        byte[] key1;//甲方本地密钥
        byte[] pubKey2;//乙方公钥
        byte[] priKey2;//乙方私钥
        byte[] key2;//乙方本地密钥

        /*********************测试是否可以正确生成以上6个key，以及key1与key2是否相等*********************/
        KeyPair keyPair1 = DHUtil.initKey();//生成甲方密钥对
        pubKey1 = DHUtil.getPublicKey(keyPair1);
        priKey1 = DHUtil.getPrivateKey(keyPair1);

        KeyPair keyPair2 = DHUtil.initKey(pubKey1);//根据甲方公钥生成乙方密钥对
        pubKey2 = DHUtil.getPublicKey(keyPair2);
        priKey2 = DHUtil.getPrivateKey(keyPair2);

        key1 = DHUtil.getSecretKey(pubKey2, priKey1);//使用对方公钥和自己私钥构建本地密钥
        key2 = DHUtil.getSecretKey(pubKey1, priKey2);//使用对方公钥和自己私钥构建本地密钥

        System.out.println("甲方公钥pubKey1-->" + Base64.encodeBase64String(pubKey1) + "@@pubKey1.length-->" + pubKey1.length);
        System.out.println("甲方私钥priKey1-->" + Base64.encodeBase64String(priKey1) + "@@priKey1.length-->" + priKey1.length);
        System.out.println("乙方公钥pubKey2-->" + Base64.encodeBase64String(pubKey2) + "@@pubKey2.length-->" + pubKey2.length);
        System.out.println("乙方私钥priKey2-->" + Base64.encodeBase64String(priKey2) + "@@priKey2.length-->" + priKey2.length);
        System.out.println("甲方密钥key1-->" + Base64.encodeBase64String(key1));
        System.out.println("乙方密钥key2-->" + Base64.encodeBase64String(key2));

        /*********************测试甲方使用本地密钥加密数据向乙方发送，乙方使用本地密钥解密数据*********************/
        System.out.println("甲方-->乙方");
        String data = "找一个好姑娘啊！";
        byte[] encodeStr = DHUtil.encrypt(data, key1);
        System.out.println("甲方加密后的数据-->" + Base64.encodeBase64String(encodeStr));
        byte[] decodeStr = DHUtil.decrypt(encodeStr, key2);
        System.out.println("乙方解密后的数据-->" + new String(decodeStr, "UTF-8"));

        /*********************测试乙方使用本地密钥加密数据向甲方发送，甲方使用本地密钥解密数据*********************/
        System.out.println("乙方-->甲方");
        String data2 = "找一个好姑娘啊！";
        byte[] encodeStr2 = DHUtil.encrypt(data2, key2);
        System.out.println("乙方加密后的数据-->" + Base64.encodeBase64String(encodeStr2));
        byte[] decodeStr2 = DHUtil.decrypt(encodeStr, key1);
        System.out.println("甲方解密后的数据-->" + new String(decodeStr2, "UTF-8"));
        /**
         * 运行结果:
             甲方公钥pubKey1-->MIHfMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYXrgHzW5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpDTWSGkx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgANDAAJAO88L9b6mwa7WJPuoKq9lb3JFBJ0e8n+f7+d0UimJnJ2G07hs9FS7O0ZY9pfNwfmc+WBocMlNyHYjjrLHcf8tig==@@pubKey1.length-->226
             甲方私钥priKey1-->MIHSAgEAMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYXrgHzW5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpDTWSGkx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgAQzAjEAojcUX/pTYDDxhECpaVdjkehOCNzX4XhgaL1SFCvtmCfWdU1L+33s206giO4eCtsD@@priKey1.length-->213
             乙方公钥pubKey2-->MIHfMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYXrgHzW5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpDTWSGkx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgANDAAJAMmjodn9QSWY58RZuyptvFXu5iykvRPnCcvvhRDc7P7g5U0ytzrYZMt656W2rT4e4KcnyCakdK5Ec+7CbURb27A==@@pubKey2.length-->226
             乙方私钥priKey2-->MIHSAgEAMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYXrgHzW5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpDTWSGkx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgAQzAjEAy3MWvMVmFQGDv6VLtfNUF+gI1x+Y4sKE5uYmC9FFO362rLVNrJtmNkld8mxwl8Ck@@priKey2.length-->213
             甲方密钥key1-->8PDDr3MoPptlybA224G14eufPvvOcNxeaPm6AqJsj5g=
             乙方密钥key2-->8PDDr3MoPptlybA224G14eufPvvOcNxeaPm6AqJsj5g=
             甲方-->乙方
             甲方加密后的数据-->iTZiR+/w/GhzmqQlBfaLWrmK8+0VUJUQIV1WBMrqU20=
             乙方解密后的数据-->找一个好姑娘啊！
             乙方-->甲方
             乙方加密后的数据-->iTZiR+/w/GhzmqQlBfaLWrmK8+0VUJUQIV1WBMrqU20=
             甲方解密后的数据-->找一个好姑娘啊！
         */
    }
}

注：上述代码运行时可能报错：Caused by: java.security.InvalidKeyException: Illegal key size or default parameters
解决：把里面的两个jar包：local_policy.jar 和 US_export_policy.jar 替换掉原来jdk安装目录C:\Program Files\Java\jre6\lib\security 下的两个jar包接可以了（JDK8下载地址）

非对称加密之RSA

特点：

  • 使用一套密钥即可完成加解密（与DH不同）
  • 与DH不同的第二点是，RSA自己可以完成加解密，而DH需要依赖于对称加密算法
  • “私钥加密，公钥解密”或“公钥加密，私钥解密”
  • 公钥长度远小于私钥长度（对下边的代码进行测试，自己比较结果）

加解密流程：

  1. 发送方（假设为甲方）构建密钥对，自己保留私钥，将公钥发送给接收方（假设为乙方）

  2. 甲方使用密钥对消息进行加密，乙方使用公钥对消息解密（“私钥加密，公钥解密”，该方式的应用场景为数字签名）或者乙方使用公钥对消息进行加密，甲方使用私钥对消息解密（“公钥加密，私钥解密”）

注意：公钥加密方式存在安全隐患，如果需要更加安全的方式，就需要甲乙双方均存一份密钥对，仅仅使用“私钥加密，公钥解密”的方式，这种方式与DH类似，但是不同，在DH中甲乙双方各自保留着自己的公钥+私钥，而更安全的RSA是甲乙方法均保存着自己的私钥与对方的公钥，这是RSA与DH的第三点不同。

基于JDK实现RSA加解密代码：

package com.sean.test.security;

import org.apache.xerces.impl.dv.util.Base64;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import java.security.*;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

/**
 * <p></p>
 *  1.生成秘钥对
 *  2.通过秘钥对获取公钥或私钥
 *  3.通过公钥或私钥加密
 *  4.通过私钥或公钥解密
 *
 *
 *  私钥加密公钥解密(可用作加密使用)：
 *      1.接收方将公钥发给发送方
 *      2.发送方通过公钥对数据进行加密后，将数据传给接收方
 *      3.接收方通过私钥进行解密，获取安全的数据
 *  公钥加密私钥解密(可用作签名使用)：
 *      1.发送方将公钥发送给接收方
 *      2.发送方通过私钥对数据进行加密，将加密的数据和原有的数据发送给接收方
 *      3.接收方接受数据，对加密数据通过公钥解密，将解密的数据与原有数据进行对比，若一致，则数据未被他人拦截篡改
 * @version V1.0
 * @modificationHistory=========================逻辑或功能性重大变更记录
 * @modify by user: {修改人} 2019/2/13
 * @modify by reason:{方法名}:{原因}
 */
public class RSAUtil {

    private static final String KEY_ALGORITHM = "RSA";//非对称加密密钥算法
    private static final String CIPHER_ALGORITHM = "RSA/ECB/PKCS1Padding";//加解密算法 格式：算法/工作模式/填充模式
    private static final int KEY_SIZE = 512;//非对称密钥长度（512~1024之间的64的整数倍）

    // 初始化秘钥对
    public static KeyPair initKey() throws NoSuchAlgorithmException {
        // 秘钥对生成器
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        // 指定秘钥长度
        keyPairGenerator.initialize(KEY_SIZE);
        // 生成秘钥对
        return keyPairGenerator.generateKeyPair();
    }

    // 获取公钥
    public static byte[] getPublicKey(KeyPair keyPair){
        return keyPair.getPublic().getEncoded();
    }

    // 获取私钥
    public static byte[] getPrivateKey(KeyPair keyPair){
        return keyPair.getPrivate().getEncoded();
    }

    // 转换公钥
    public static PublicKey toPublicKey(byte[] publicKey) throws InvalidKeySpecException, NoSuchAlgorithmException {
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        return keyFactory.generatePublic(new X509EncodedKeySpec(publicKey));
    }

    // 转换私钥
    public static PrivateKey toPrivateKey(byte[] privateKey) throws InvalidKeySpecException, NoSuchAlgorithmException {
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        return keyFactory.generatePrivate(new PKCS8EncodedKeySpec(privateKey));
    }

    // 公钥加密
    public static byte[] encryptByPublicKey(byte[] publicKey, byte[] data) throws InvalidKeySpecException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException {
        PublicKey pk = toPublicKey(publicKey);
        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
        // 设置模式并初始化key
        cipher.init(Cipher.ENCRYPT_MODE,pk);
        return cipher.doFinal(data);
    }

    // 公钥解密
    public static byte[] decryptByPublicKey(byte[] publicKey, byte[] data) throws InvalidKeySpecException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException {
        PublicKey pk = toPublicKey(publicKey);
        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
        // 设置模式并初始化key
        cipher.init(Cipher.DECRYPT_MODE,pk);
        return cipher.doFinal(data);
    }

    // 私钥加密
    public static byte[] encryptByPrivateKey(byte[] privateKey, byte[] data) throws InvalidKeySpecException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException {
        PrivateKey pk = toPrivateKey(privateKey);
        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
        // 设置模式并初始化key
        cipher.init(Cipher.ENCRYPT_MODE,pk);
        return cipher.doFinal(data);
    }

    // 公钥解密
    public static byte[] decryptByPrivateKey(byte[] privateKey, byte[] data) throws InvalidKeySpecException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException {
        PrivateKey pk = toPrivateKey(privateKey);
        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
        // 设置模式并初始化key
        cipher.init(Cipher.DECRYPT_MODE,pk);
        return cipher.doFinal(data);
    }

    public static void main(String[] args) throws Exception {
        String str = "RSA";
        System.out.println("原文为：" + str);
        byte[] data = str.getBytes();
        KeyPair keyPair = RSAUtil.initKey();
        byte[] publicKey = getPublicKey(keyPair);
        byte[] privateKey = getPrivateKey(keyPair);
        System.out.println("公钥为："+ Base64.encode(publicKey));
        System.out.println("私钥为："+ Base64.encode(privateKey));
        byte[] encryptByPublicKey = encryptByPublicKey(publicKey, data);
        System.out.println("公钥加密结果："+Base64.encode(encryptByPublicKey));
        byte[] decryptByPrivateKey = decryptByPrivateKey(privateKey, encryptByPublicKey);
        System.out.println("私钥解密结果："+new String(decryptByPrivateKey));

        byte[] encryptByPrivateKey = encryptByPrivateKey(privateKey, data);
        System.out.println("私钥加密结果："+Base64.encode(encryptByPrivateKey));
        byte[] decryptByPublicKey = decryptByPublicKey(publicKey, encryptByPrivateKey);
        System.out.println("公钥解密结果："+new String(decryptByPublicKey));
        /**
         * 运行结果： 
             原文为：RSA
             公钥为：MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAI5k6ShF1SVRbKD22g0MEcQwuOQSDE8XPQGJjYMA2tXPHQXY4+wHuNQZr3NPSOfu16RJsqBPcOVJhrfGkag4ZqsCAwEAAQ==
             私钥为：MIIBVAIBADANBgkqhkiG9w0BAQEFAASCAT4wggE6AgEAAkEAjmTpKEXVJVFsoPbaDQwRxDC45BIMTxc9AYmNgwDa1c8dBdjj7Ae41Bmvc09I5+7XpEmyoE9w5UmGt8aRqDhmqwIDAQABAkBwbPwp7/j6He/GpyBCbOUaId3ZNObDC3X/YLt6U5J0fHyroQBoSQlC52uJIXnwFwtZTKvmOloIvMYmLWk+WAMBAiEA8L/zSE4sRlkyxfENyq89M6Hobi7yzpLub9qh2WoYVPUCIQCXagFBA0rQ79D+KqREqkg5OOF6pwAs1aWVWGBUSTOJHwIhAOIwJZ0IPRa3FTndmUyVSdXpxxtGJr+oUjZq3ecLg+LFAiBpJiyIwYiLYH96gpJhPP+6/U1Yp/DvMc8zz5PV9J/dcQIgESXG/w2uDHD9JXOQaAMh/itAD6ZzjJxLKj/wZgAGVPw=
             公钥加密结果：EXkWhouJqBdoFUqp0L0c2mr+/pHgT7da+1hrNPPzmj4+N+TB+rMLO5WWK9CeXLWVMyA4u64CupWQSBZ0PBajcw==
             私钥解密结果：RSA
             私钥加密结果：Go6+TuPIgLnpMHTocVjbsWs7nxxsux4yUSeWP6heyNZQD1eCV02xBm0VB2ozQf9EBVAWmd38supwCJas1+8nxg==
             公钥解密结果：RSA
         */
    }

}
杭州剃须刀
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
300多种加密解密算法（C++）源代码
06-13
300多种加密解密算法（C++）源代码 300多种加密解密算法（C++）源代码
什么是量涨速%？
点知家的博客
06-02 2090
举个例子来说明： 假设某只股票在前一个交易日的交易量为100,000股，而当前交易日的交易量为150,000股。量涨速（Volume Rate of Change）是用来衡量股票交易量变化速度的指标，表示当前交易量与一段时间前的交易量之间的比率关系。再举一个例子： 假设某只股票在前一个交易日的交易量为80,000股，而当前交易日的交易量为60,000股。量涨速的计算方法如下： 量涨速% = （当前交易量 - 前期交易量）/ 前期交易量 × 100%这表示当前交易量相对于前一个交易日增加了50%。
常见加解密算法01 - 初步认识
最新发布
a5right的博客
03-21 726
安全的加密方法会有大量的加密密钥，因此未经授权的人员既无法猜出正确的密钥，也无法使用计算机通过尝试每个可能的组合（称为暴力破解）轻松计算出正确的字符串。了解了BASE64的原理，那BASE32也就好理解了，它就是使用32个可见字符做编码表，然后是5个bit作为一组，也有填充。注意，这里使用 12.8.0 版本的 frida 来执行，15.2.2的在 cli 里面找不到函数，需要再研究研究。so里面方法不多，可以一个一个看过去，看谁比较可疑，也可以直接搜索编码表字符串，当然也有可能遇到字符串加密的情况。
加解密算法概述
码农@攻城狮
02-28 2880
本文概述对称加解密，非对称加解密，以及比较应用
13种加密与解密算法【一】
热门推荐
qq_40687809的博客
04-02 2万+
这15种加密解密算法分别是：散列哈希[MD5、SHA1、CRC32]，对称[DES，3DES（TDEA、Triple DES），AES、，Blowfish，RC4、RC5，IDEA]，Base64、Rabbit、Escape。【三种分类】1、对称加密：密钥只有一个，解密、解密都是这个密码，加解密速度快，典型的对称加密有DES、AES、RC4等2、非对称加密:密钥成对出现，分别为公钥和私钥，从公钥无...
加解密算法
Duck_1024
03-16 372
常见加密算法
易语言常用加解密算法模块
08-15
易语言常用加解密算法模块源码 系统结构:AES_128,AES_192,AES_256,RC6,Blowfish,DESEncrypt,DESDecrypt,RC6Init,RC6Encrypt,RC6Decrypt,BlowfishInit,BlowfishEncrypt,BlowfishDecrypt,RijndaelInit,RijndaelEncrypt...
300常用加解密算法
12-17
加解密算法是计算机比较重要的课题，任何高级的程序都需要算法。
易语言常用加解密算法模块源码
05-27
易语言常用加解密算法模块源码例程程序置入汇编代码多线程实现加解密算法。易语言常用加解密算法模块源码包含对称类DES,RC6,Blowfish,Rijndael(标准AES)等算法。资源作者：。资源界面：。资源下载：。
Python编写的常用加密解密算法 不需要安装包，直接使用就行
02-08
Python编写的常用加密解密算法。压缩包里面有AES、DES、MD5、ECC、RSA、SHA256 等6种算法。算法的实现没有调用第三方库，是通过算法的原理一句句来实现的。作者花费了大量的时间来编写这几种算法的加密、解密过程。...
史上最全常见的加解密实现方式
qq_38759383的博客
10-10 3555
史上最全常见的加解密实现方式
常用加密解密算法【RSA、AES、DES、MD5】介绍和使用
lgxzzz的博客
05-21 5866
为了防止我们的数据泄露，我们往往会对数据进行加密，特别是敏感数据，我们要求的安全性更高。下面将介绍几种常用的加密算法使用。这些算法的加密对象都是基于二进制数据，如果要加密字符串就使用统一编码（如：utf8）进行编码后加密。 1.摘要算法 常用的摘要算法有MD5,SHA1。摘要算法是一个不可逆过程，就是无论多大数据，经过算法运算后都是生成固定长度的数据,一般结果使用16进制进行显示。 MD5和SHA1的区别：...
常见的加解密算法【MD5, AES, RSA等】
柚子君的博客
01-22 4233
1. 摘要算法 常见的摘要算法主要有两种，MD5和SHA1。 摘要算法并不是一种加密算法，因为不可逆，无法从密文还原出明文。 摘要算法主要用途有 消息完整性验证：发送消息时，将发送数据与MD5值一起发送，然后可以从MD5值来验证接收到的消息是否完整。常见的有下载文件等场景，服务端提供一个文件的下载地址和文件的MD5值，客户端再下载完成后验证文件的MD5，如果与服务端的值不同，说明下载出问题了，需要重新下载。 安全访问认证：如数据库存储登录密码的MD5值，这样就可以保证即使管理员也无法查看到常用密码
密码学 - 加解密算法 - 加解密模式
qazw9600的专栏
12-02 2949
对称加密 ， 加密模式
常用加解密算法理解及应用
Tison个人博客
11-21 2650
随着大环境对隐私、数据安全的要求越来越高，我们日常开发工作中遇到数据安全处理的需求也越来越多，多数情况下都会有专门的安全团队提供完整的解决方案，我们按照对应的文档处理就能很好地解决问题。但是有这样的安全团队支持，并不代表我们不需要对安全知识有一定的了解。作为一名优秀的程序员，还是要适当对别人封装好的技术方案有一定的专研精神，一方面是可以拓宽自己的技术边界，另一方面也可以帮助我们在和安全团队对接方案时有更多的共同认知，提高沟通和接入效率。
加解密算法相关技术详解
par@ish的博客
11-14 419
随着网络技术的飞速发展，网络安全问题日益重要，加解密技术是网络安全技术中的核心技术，是最常用的安全保密手段。加密：加密就是对原来为明文的文件或数据按某种算法进行处理，使其成为一段不可读的代码，通常称为 “密文”。从而达到保护数据不被非法窃取的目的。解密：解密就是加密的逆过程，即将密文转化为其原来明文的过程。加密技术分为对称加密和非对称加密。对称加密是指使用同一个密钥对数据进行解密；非对称加密是指用一对公私钥分别对数据进行加解密。
全网最详尽的加密解密算法相关知识总结，附带Java Demo
wybaby168的博客
06-16 2782
密码学是一种通过使用代码保护信息和通信的方案，因此只有信息的预期对象才能阅读和处理它。安全通信。密码学用于保护传输中的数据，例如电子邮件、网页浏览和文件传输。比如https普遍使用的TLS/SSL技术静态数据。密码学用于保护存储在计算机上的数据，例如密码、财务信息和医疗记录。数字签名：密码学用于创建数字签名，可用于验证消息或文档的真实性。不可否认性：密码学可用于提供不可否认性，这意味着发送者不能拒绝发送消息或接收者不能拒绝接收消息。
加解密技术
wlphlj的专栏
07-05 609
加密与解密
简述常用加解密算法
weixin_42579622的博客
09-01 1752
（作为一个刚刚毕业的菜菜程序猿，首次更新博客，欢迎大家多多批评指正） 简述常用加解密算法 一、产生的原因 为确保数据在网络上传输的安全性。 二、使用场景 1、RSA加解密适用场景 RSA主要用于加密和签名，加密过程中，公钥用于加密，私钥用于解密；签名过程中，私钥用于加密，公钥用于解密. 2、MD5加密适用场景 MD5算法主要用于加密应用软件登录密码、进行数字签名、对文件完整性进行验证等方面. 3、通常情况下，对于大数据的加密，使用AES或者DES等对称加密算法对数据进行加密，使用RSA等非对称加密算法对AE
常用加密解密算法java
03-22
常用的加密解密算法有DES、AES、RSA、MD5、SHA等。在Java中，可以使用javax.crypto包中的类来实现这些算法。例如，使用Cipher类来进行DES和AES的加密解密操作，使用KeyPairGenerator和Cipher类来进行RSA的加密解密...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值