用实例给新手讲解RSA加密算法

最新推荐文章于 2025-07-09 15:59:43 发布
转载 最新推荐文章于 2025-07-09 15:59:43 发布 · 251 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：https://my.oschina.net/547217475/blog/1559371
文章标签：

#java #python

本文提供了一个Java实现的RSA加密与解密的完整示例，包括密钥生成、公钥加密、私钥解密等多个操作步骤，并通过具体的数据加密过程展示了RSA的工作原理。

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

http://www.cfca.com.cn/20150811/101230806.html

 

package com.rong.financeserver.utils;

import sun.misc.BASE64Decoder;

import javax.crypto.Cipher;
import java.io.ByteArrayOutputStream;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
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;

public class RSAUtils {
    public static final String KEY_ALGORITHM = "RSA";
    public static final String ECB_PKCS1_PADDING = "RSA/ECB/PKCS1Padding";//加密填充方式

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

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

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

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

    public static void main(String[] args) {
        try {
            String info = "待加密数据9876543210";
            System.out.println("info： " + info);
            Map<String, Object> keyMap = initKey();

            System.out.println("PUBLIC_KEY： " + getPublicKey(keyMap));
            System.out.println("PRIVATE_KEY:  " + getPrivateKey(keyMap));
            byte[] infoByte = info.getBytes();

            //公钥加密
            byte[] encryptByte = encryptByPublicKey(infoByte, getPublicKey(keyMap));
            System.out.println("公钥加密： " + Utils.bytesToHex(encryptByte));
            //私钥解密
            byte[] decryptByte = decryptByPrivateKey(encryptByte, getPrivateKey(keyMap));
            System.out.println("私钥解密： " + new String(decryptByte));

            //---------------------------------------------------------------------------

            //私钥加密
            byte[] encryptByte1 = encryptByPrivateKey(infoByte, getPrivateKey(keyMap));
            System.out.println("私钥加密： " + Utils.bytesToHex(encryptByte1));
            //公钥解密
            byte[] decryptByte1 = decryptByPublicKey(encryptByte1, getPublicKey(keyMap));
            System.out.println("公钥解密： " + new String(decryptByte1));

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 初始化密钥
     *
     * @return
     * @throws Exception
     */
    public static Map<String, Object> initKey() throws Exception {
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        keyPairGen.initialize(1024);

        KeyPair keyPair = keyPairGen.generateKeyPair();

        // 公钥
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        System.out.println("公钥  Modulus： " + publicKey.getModulus().toString(10));
        System.out.println("公钥  Exponent： " + publicKey.getPublicExponent().toString(10));

        // 私钥
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        System.out.println("私钥  Modulus： " + privateKey.getModulus().toString(10));
        System.out.println("私钥  Exponent： " + privateKey.getPrivateExponent().toString(10));

        Map<String, Object> keyMap = new HashMap<String, Object>(2);

        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);
        return keyMap;
    }

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

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

    /**
     * 解密<br>
     * 用私钥解密
     *
     * @param data
     * @param key
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPrivateKey(byte[] data, String key) throws Exception {
        // 对密钥解密
        byte[] keyBytes = Utils.hexStr2Bytes(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[] decryptByPublicKey(byte[] data, String key) throws Exception {
        // 对密钥解密
        byte[] keyBytes = Utils.hexStr2Bytes(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(byte[] data, String key)
            throws Exception {

        // 对公钥解密
        byte[] keyBytes = Utils.hexStr2Bytes(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);
    }

    /**
     * 加密<br>
     * 用私钥加密
     *
     * @param data
     * @param key
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPrivateKey(byte[] data, String key)
            throws Exception {
        // 对密钥解密
        byte[] keyBytes = Utils.hexStr2Bytes(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);
    }

/** */
    /**
     * <P>
     * 私钥解密
     * </p>
     *
     * @param encryptedData 已加密数据
     * @param privateKey    私钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPrivateKeySort(byte[] encryptedData, String privateKey)
            throws Exception {
        byte[] keyBytes = (new BASE64Decoder()).decodeBuffer(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_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 decryptedData;
    }
/** */
    /**
     * <p>
     * 公钥解密
     * </p>
     *
     * @param
     * @param publicKey 公钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPublicKeySort(byte[] encryptedData1, String publicKey)
            throws Exception {
        byte[] encryptedData = encryptedData1;
        byte[] keyBytes = publicKey.trim().getBytes();
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key publicK = keyFactory.generatePublic(x509KeySpec);
        Cipher cipher = Cipher.getInstance(ECB_PKCS1_PADDING);
        //
        cipher.init(Cipher.DECRYPT_MODE, publicK);
        int inputLen = encryptedData.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        byte[] temp = new byte[MAX_DECRYPT_BLOCK];
        // cache = cipher.doFinal(encryptedData);
        // 对数据分段解密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                System.arraycopy(encryptedData, offSet, temp, 0, MAX_DECRYPT_BLOCK);
//                cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
                cache = cipher.doFinal(temp);
            } else {
                byte[] temp1 = new byte[inputLen - offSet];
                System.arraycopy(encryptedData, offSet, temp1, 0, inputLen - offSet);
//                cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
                cache = cipher.doFinal(temp1);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_DECRYPT_BLOCK;
        }
        byte[] decryptedData = out.toByteArray();
        out.close();
        return decryptedData;
    }

    /** */
    /**
     * <p>
     * 公钥加密
     * </p>
     *
     * @param data      源数据
     * @param publicKey 公钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPublicKeySort(byte[] data, String publicKey)
            throws Exception {
        byte[] keyBytes = Utils.hexStr2Bytes(publicKey);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_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 encryptedData;
    }

    /** */
    /**
     * <p>
     * 私钥加密
     * </p>
     *
     * @param data       源数据
     * @param privateKey 私钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPrivateKeySort(byte[] data, String privateKey)
            throws Exception {
        byte[] keyBytes = Utils.hexStr2Bytes(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, privateK);
        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 encryptedData;
    }


}

 

转载于:https://my.oschina.net/547217475/blog/1559371

RSA加密算法小例子
pcl1056239206的博客
02-16 782
RSA加密算法简单应用 最近工作要用到rsa加密算法，现在简单把做的实现介绍下，具体算法原理等自行搜索 代码实例 准备工作 // 加载密钥库keystore private static KeyStore loadKeyStore(String keystorePath, String keystorePass) throws KeyStoreException
数字签名验证及加解密中的一些概念
WJ S的专栏
05-20 4062
名词解释对称加密通信双方使用同一个密钥( secret )加密解密密钥(Secret)对称加密中双方共同使用的密码非对称加密通信中的密钥是成对的：公钥A和私钥B。用A加密的密文只能用B解密，同样，用B加密的密文也只能用A解密公钥(Public Key) & 私钥(Private Key)公钥与私钥一一对应。公钥自由发布给外部通信方。私钥需要自己秘密存储，一旦泄漏则可能导致身份被伪造，机密信息泄漏。数
用实例讲解RSA加密算法(精)
05-03
用实例讲解RSA加密算法(精)
用实例给新手讲解易懂的RSA加密解密算法_rsa算法加密和解密举例
m0_60388216的博客
04-16 961
素数是这样的整数，它除了能表示为它自己和1的乘积以外，不能表示为任何其它两个整数的乘积。例如，15＝3＊5，所以15不是素数；又如，12＝6＊2＝4＊3，所以12也不是素数。另一方面，13除了等于13＊1以外，不能表示为其它任何两个整数的乘积，所以13是一个素数。素数也称为“质数”。小学数学教材对互质数是这样定义的：“公约数只有1的两个数，叫做互质数。”这里所说的“两个数”是指自然数。判别方法主要有以下几种（不限于此）：（1）两个质数一定是互质数。例如，2与7、13与19。
JS前端使用RSA RSA/ECB/PKCS1Padding的时候，加密Unicode（中文）失败
最新发布
Y_L_John的博客
07-09 426
console.warn("强制处理单个宽字符:", segment.charCodeAt(0).toString(16));`范围[${currentPos-segment.length}-${currentPos-1}]`);console.debug(`分段加密: ${segment.length}字符/${bitCount}字节`,throw new Error("加密失败于位置 " + currentPos +// 移动到下一个字符。// 确保至少处理一个字符（防止死循环）
用实例给新手讲解易懂的RSA加密解密算法_rsa算法加密和解密举例(1)
weixin_58134620的博客
04-12 557
素数是这样的整数，它除了能表示为它自己和1的乘积以外，不能表示为任何其它两个整数的乘积。例如，15＝3＊5，所以15不是素数；又如，12＝6＊2＝4＊3，所以12也不是素数。另一方面，13除了等于13＊1以外，不能表示为其它任何两个整数的乘积，所以13是一个素数。素数也称为“质数”。小学数学教材对互质数是这样定义的：“公约数只有1的两个数，叫做互质数。”这里所说的“两个数”是指自然数。判别方法主要有以下几种（不限于此）：（1）两个质数一定是互质数。例如，2与7、13与19。
RSA密码原理详解及算法实现(六步即可掌握)
热门推荐
weixin_62387234的博客
11-26 1万+
小白也能快速理解的RSA算法原理讲解，附python代码
Python编程：探索加密算法入門指南
书名中的"密码学编程"强调了它不仅讲解Python语言的基础，还深入探讨了如何利用Python实现加密算法，这对于网络安全和信息安全相关的专业人员，或者对加密技术感兴趣的学生来说是一本极具价值的资源。 作者通过实例...
免费开源的CTF入门教程，针对0基础新手编写
06-06
4. **逆向工程**：通过实例教学如何分析二进制代码，识别和利用软件漏洞，使用调试器（如GDB）进行动态分析，以及如何反汇编和理解汇编语言。 5. **网络取证**：讲解如何收集、分析和解释网络日志，以及如何利用...
Ubuntu使用全攻略：从新手到专家的版本选择与部署秘籍
[Ubuntu使用全攻略：从新手到专家的版本选择与部署秘籍](https://img1.mydrivers.com/img/20201026/85aedb24-f05b-44bf-8084-03ec713482e2.jpg) # 1. Ubuntu概述及其版本选择 ## 1.1 Ubuntu简介 Ubuntu 是一个基于 ...
与Java的RSA加解密兼容的Python加解密库m2crypto（Windows下免编译）
09-02
由于Java的RSA加解密一般都是用RSA/ECB/PKCS1PADDING，导致Python一般的RSA加密库的加解密结果与Java的不兼容，Python下目前能与之兼容的RSA的库目前发现的只有一个，就是m2crypto。 这个库目前的问题是在windows系统下不能直接pip安装，需要自己编译，相当复杂。我提供的这个是已经编译好的，带安装文件，可以直接安装使用。 注意：这个编译好的m2crypto库目前只支持python3.8
Python3加密解密库Crypto的RSA加解密和签名/验签实现方法实例
09-17
主要介绍了Python3加密解密库Crypto的RSA加解密和签名/验签实现方法实例,需要的朋友可以参考下
python RSA加密最新(RSA/ECB/PKCS1Padding)
西山枫叶
06-02 8314
遇到一个 java 的RSA/ECB/PKCS1Padding 加密 要改成python的 网上搜一堆不靠谱的，没办法只能自己动手写一份了 中间遇到一个ERROR： OverflowError: 458 bytes needed for message, but there is only space for 117 遇到问题解决它 上代码： import rsa import base64 from Crypto.PublicKey import RSA from Crypto.Cipher im
Python rsa加密与填充
qq_38493182的博客
06-14 1667
rsa加密填充
python-RSA加密与java-Cipher加密适配
hapenl的博客
06-25 4735
开发语言不同，对于加密的处理方式也不一样，这中间对使用python语言的产生了一定的困惑。在使用python的rsa第三库来处理rsa加密和java Cipher类的处理，对于不同的padding填充的理解有助于程序的编写...
事关rsa加密
yanhuo0414的博客
03-05 174
事关RSA加密 事情是这样的，这几天在搞rsa加密， 于是研究了一下。本本将介绍rsa加密、python实现rsa加解密的方法、rsa的填充方法 非对称加密 相对比较安全，rsa 加密是非对称加密的一种。 原理：非对称加密依赖与明文经过与公钥进行数学运算可得出密文，而密文经过与密钥进行数学运算又可得到明文。 用途：非对称加密算法的优点是密钥分发简单，但缺点也是很明显的，其加解密过程依赖于数学运算运算量大所以加解密速度慢（另外同样的密钥强度其安全性弱于对...
python、java RSA公私钥加密解密
whatzhang007的博客
01-12 1365
java RSA私钥加密、解密 public static final String RSA = "RSA"; public static final String RSA_ECB_NO_PADDING = "RSA/ECB/PKCS1Padding"; public static final String AES_ECB_PKCS_5_PADDING = "AES/ECB/PKCS5Padding"; public static final String AES = "AES"; public stat
Python 多种方法实现 RSA 加密/解密，签名/验签
Herishwater的博客
06-13 5550
继上篇对 RSA 公钥模数和指数的学习，这次我们针对实际应用中 RSA 加密/解密，签名/验签 的使用，利用 Python 进行具体实现。经过查询整理，发现有三种实现方法，下面我们一一展示。 一、rsa 包的实现 首先需要安装 rsa，pip install rsa import rsa import base64 def rsaEncrypt(content, pubkey): '''...
RSA加密算法的多种实现实例解析
为了提高效率，实际应用中通常会使用加密和解密的变种算法。 在编程实现上，有多种库可以帮助我们快速地使用RSA算法，例如在文件信息中提及的Crypto++库和OpenSSL库。Crypto++是一个专注于加密技术的C++库，它提供...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值