java中RSA加解密的实现

最新推荐文章于 2024-07-17 14:16:50 发布
最新推荐文章于 2024-07-17 14:16:50 发布
阅读量636 收藏
点赞数

  1. 关于加密数据长度和解密数据长度大家可以看一下我前一篇文章内的介绍：

    关于RSA算法密钥长度/密文长度/明文长度的介绍


  2. public static void main(String[] args) throws Exception {  
  3.         // TODO Auto-generated method stub  
  4.         HashMap<String, Object> map = RSAUtils.getKeys();  
  5.         //生成公钥和私钥  
  6.         RSAPublicKey publicKey = (RSAPublicKey) map.get("public");  
  7.         RSAPrivateKey privateKey = (RSAPrivateKey) map.get("private");  
  8.           
  9.         //模  
  10.         String modulus = publicKey.getModulus().toString();  
  11.         //公钥指数  
  12.         String public_exponent = publicKey.getPublicExponent().toString();  
  13.         //私钥指数  
  14.         String private_exponent = privateKey.getPrivateExponent().toString();  
  15.         //明文  
  16.         String ming = "123456789";  
  17.         //使用模和指数生成公钥和私钥  
  18.         RSAPublicKey pubKey = RSAUtils.getPublicKey(modulus, public_exponent);  
  19.         RSAPrivateKey priKey = RSAUtils.getPrivateKey(modulus, private_exponent);  
  20.         //加密后的密文  
  21.         String mi = RSAUtils.encryptByPublicKey(ming, pubKey);  
  22.         System.err.println(mi);  
  23.         //解密后的明文  
  24.         ming = RSAUtils.decryptByPrivateKey(mi, priKey);  
  25.         System.err.println(ming);  
  26.     }  
  27. RSAUtils.java
  28. package yyy.test.rsa;  
  
import java.math.BigInteger;  
import java.security.KeyFactory;  
import java.security.KeyPair;  
import java.security.KeyPairGenerator;  
import java.security.NoSuchAlgorithmException;  
import java.security.interfaces.RSAPrivateKey;  
import java.security.interfaces.RSAPublicKey;  
import java.security.spec.RSAPrivateKeySpec;  
import java.security.spec.RSAPublicKeySpec;  
import java.util.HashMap;  
  
import javax.crypto.Cipher;  
  
public class RSAUtils {  
  
    /** 
     * 生成公钥和私钥 
     * @throws NoSuchAlgorithmException  
     * 
     */  
    public static HashMap<String, Object> getKeys() throws NoSuchAlgorithmException{  
        HashMap<String, Object> map = new HashMap<String, Object>();  
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");  
        keyPairGen.initialize(1024);  
        KeyPair keyPair = keyPairGen.generateKeyPair();  
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();  
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();  
        map.put("public", publicKey);  
        map.put("private", privateKey);  
        return map;  
    }  
    /** 
     * 使用模和指数生成RSA公钥 
     * 注意：【此代码用了默认补位方式，为RSA/None/PKCS1Padding，不同JDK默认的补位方式可能不同，如Android默认是RSA 
     * /None/NoPadding】 
     *  
     * @param modulus 
     *            模 
     * @param exponent 
     *            指数 
     * @return 
     */  
    public static RSAPublicKey getPublicKey(String modulus, String exponent) {  
        try {  
            BigInteger b1 = new BigInteger(modulus);  
            BigInteger b2 = new BigInteger(exponent);  
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");  
            RSAPublicKeySpec keySpec = new RSAPublicKeySpec(b1, b2);  
            return (RSAPublicKey) keyFactory.generatePublic(keySpec);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return null;  
        }  
    }  
  
    /** 
     * 使用模和指数生成RSA私钥 
     * 注意：【此代码用了默认补位方式，为RSA/None/PKCS1Padding，不同JDK默认的补位方式可能不同，如Android默认是RSA 
     * /None/NoPadding】 
     *  
     * @param modulus 
     *            模 
     * @param exponent 
     *            指数 
     * @return 
     */  
    public static RSAPrivateKey getPrivateKey(String modulus, String exponent) {  
        try {  
            BigInteger b1 = new BigInteger(modulus);  
            BigInteger b2 = new BigInteger(exponent);  
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");  
            RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(b1, b2);  
            return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return null;  
        }  
    }  
  
    /** 
     * 公钥加密 
     *  
     * @param data 
     * @param publicKey 
     * @return 
     * @throws Exception 
     */  
    public static String encryptByPublicKey(String data, RSAPublicKey publicKey)  
            throws Exception {  
        Cipher cipher = Cipher.getInstance("RSA");  
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);  
        // 模长  
        int key_len = publicKey.getModulus().bitLength() / 8;  
        // 加密数据长度 <= 模长-11  
        String[] datas = splitString(data, key_len - 11);  
        String mi = "";  
        //如果明文长度大于模长-11则要分组加密  
        for (String s : datas) {  
            mi += bcd2Str(cipher.doFinal(s.getBytes()));  
        }  
        return mi;  
    }  
  
    /** 
     * 私钥解密 
     *  
     * @param data 
     * @param privateKey 
     * @return 
     * @throws Exception 
     */  
    public static String decryptByPrivateKey(String data, RSAPrivateKey privateKey)  
            throws Exception {  
        Cipher cipher = Cipher.getInstance("RSA");  
        cipher.init(Cipher.DECRYPT_MODE, privateKey);  
        //模长  
        int key_len = privateKey.getModulus().bitLength() / 8;  
        byte[] bytes = data.getBytes();  
        byte[] bcd = ASCII_To_BCD(bytes, bytes.length);  
        System.err.println(bcd.length);  
        //如果密文长度大于模长则要分组解密  
        String ming = "";  
        byte[][] arrays = splitArray(bcd, key_len);  
        for(byte[] arr : arrays){  
            ming += new String(cipher.doFinal(arr));  
        }  
        return ming;  
    }  
    /** 
     * ASCII码转BCD码 
     *  
     */  
    public static byte[] ASCII_To_BCD(byte[] ascii, int asc_len) {  
        byte[] bcd = new byte[asc_len / 2];  
        int j = 0;  
        for (int i = 0; i < (asc_len + 1) / 2; i++) {  
            bcd[i] = asc_to_bcd(ascii[j++]);  
            bcd[i] = (byte) (((j >= asc_len) ? 0x00 : asc_to_bcd(ascii[j++])) + (bcd[i] << 4));  
        }  
        return bcd;  
    }  
    public static byte asc_to_bcd(byte asc) {  
        byte bcd;  
  
        if ((asc >= '0') && (asc <= '9'))  
            bcd = (byte) (asc - '0');  
        else if ((asc >= 'A') && (asc <= 'F'))  
            bcd = (byte) (asc - 'A' + 10);  
        else if ((asc >= 'a') && (asc <= 'f'))  
            bcd = (byte) (asc - 'a' + 10);  
        else  
            bcd = (byte) (asc - 48);  
        return bcd;  
    }  
    /** 
     * BCD转字符串 
     */  
    public static String bcd2Str(byte[] bytes) {  
        char temp[] = new char[bytes.length * 2], val;  
  
        for (int i = 0; i < bytes.length; i++) {  
            val = (char) (((bytes[i] & 0xf0) >> 4) & 0x0f);  
            temp[i * 2] = (char) (val > 9 ? val + 'A' - 10 : val + '0');  
  
            val = (char) (bytes[i] & 0x0f);  
            temp[i * 2 + 1] = (char) (val > 9 ? val + 'A' - 10 : val + '0');  
        }  
        return new String(temp);  
    }  
    /** 
     * 拆分字符串 
     */  
    public static String[] splitString(String string, int len) {  
        int x = string.length() / len;  
        int y = string.length() % len;  
        int z = 0;  
        if (y != 0) {  
            z = 1;  
        }  
        String[] strings = new String[x + z];  
        String str = "";  
        for (int i=0; i<x+z; i++) {  
            if (i==x+z-1 && y!=0) {  
                str = string.substring(i*len, i*len+y);  
            }else{  
                str = string.substring(i*len, i*len+len);  
            }  
            strings[i] = str;  
        }  
        return strings;  
    }  
    /** 
     *拆分数组  
     */  
    public static byte[][] splitArray(byte[] data,int len){  
        int x = data.length / len;  
        int y = data.length % len;  
        int z = 0;  
        if(y!=0){  
            z = 1;  
        }  
        byte[][] arrays = new byte[x+z][];  
        byte[] arr;  
        for(int i=0; i<x+z; i++){  
            arr = new byte[len];  
            if(i==x+z-1 && y!=0){  
                System.arraycopy(data, i*len, arr, 0, y);  
            }else{  
                System.arraycopy(data, i*len, arr, 0, len);  
            }  
            arrays[i] = arr;  
        }  
        return arrays;  
    }  
}  
  29. java  
Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");  
android  
Cipher cipher = Cipher.getInstance("RSA/ECB/NoPadding");  
  
参考:  
http://stackoverflow.com/questions/6069369/rsa-encryption-difference-between-java-and-android  
http://stackoverflow.com/questions/2956647/rsa-encrypt-with-base64-encoded-public-key-in-android  http://blog.csdn.net/ye1992/article/details/12496237



ghxmyway
关注
Java实现的RSA加密解密算法示例
08-28
在Java中，可以使用Java Cryptography Architecture（JCA）来实现RSA加密解密算法。JCA提供了一个完整的加密解决方案，包括密钥对生成、加密和解密等功能。 知识点3：密钥对生成 在RSA加密解密算法中，密钥对的...
Java实现加密（二）RSA加解密
ACGkaka的博客
09-19 1万+
RSA是一种应用比较广泛的非对称加密算法，是由MIT工作的三人姓名首字母命名的。RSA算法主要依靠分解大素数的复杂性来实现其安全性，由于大素数之积难被分解，因此该密码就难被破解。（素数：质数的别称，一个大于1的自然数，除了1和它自身外，不能被其他自然数整除的数叫做质数；否则成为合数，规定1既不是质数也不是合数。）从1977年提出到现在已经四十余年，经历了各种攻击的考验，普遍认为是目前最优秀的公钥方案之一。
RSA 加解密（Java 实现）
热门推荐
长安明月的博客
08-03 3万+
RSA 算法是一种非对称加解密算法。服务方生成一对 RSA 密钥，即公钥 + 私钥，将公钥提供给调用方，调用方使用公钥对数据进行加密后，服务方根据私钥进行解密。
【Java】使用RSA进行加密解密（代码实现）
最新发布
m0_64210833的博客
07-17 1039
使用RSA进行加密解密（代码实现）
Java - 实现RSA加解密
LinTa0的博客
08-01 1万+
Java - 实现RSA加解密
RSA加密与解密(Java实现)
Mr朱鹏的博客
03-15 3524
RSA加密与解密(Java实现)
从加密到签名：如何使用Java实现高效、安全的RSA加解密算法？
m0_63300795的博客
06-19 1万+
我们为什么要使用RSA算法来进行加解密？RSA 加密算法是一种非对称加密算法，也是目前广泛使用的加密技术之一。RSA 算法的安全性基于大素数分解的困难性问题，其主要特点是安全性高、密钥管理简单等。RSA 算法采用非对称加密的方式，即加密和解密使用不同的密钥进行操作。算法的安全性基于两个大素数相乘难以分解的数学问题，保证了密钥的安全性和机密性。在 RSA 算法中，公钥用于加密，私钥用于解密。
Java中RSA加密解密的实现方法分析
08-30
在本文中，我们将深入探讨如何在Java中实现RSA加密和解密，以及相关的关键概念。 首先，RSA加密涉及两个密钥：公钥和私钥。公钥用于加密数据，而私钥用于解密数据。在Java中，这两个密钥由`java.security....
java_RSA加解密+RSA分段加解密.zip
06-13
使用RSA非对称加密完成Java后端RSA加密和分段加解密,最近研究了RSA非对称加密，关于什么是RSA，网上各种文章一搜一大把，由于RSA的特性，一个1024位的密钥只能加密117位...下面就给出如何完成后端RSA加解密和分段加解密
RSA加解密的JAVA实现
07-16
在Java中实现RSA加解密，主要涉及到Java的`java.security`和`javax.crypto`这两个包。首先，我们需要生成一对公钥和私钥，这通常通过`KeyPairGenerator`类来完成。以下是一段创建RSA密钥对的示例代码： ```java ...
Java实现RSA加解密工具类Demo
11-08
Java实现RSA加解密工具类Demo是一个典型的非对称加密技术的应用示例，RSA是一种广泛使用的公开密钥加密算法，由Ron Rivest、Adi Shamir和Leonard Adleman在1977年提出。它基于大数因子分解的困难性，提供了安全的...
RSA 公私钥加解密Java实现
qq_28600087的博客
10-09 7321
RSA加解密
Java代码实现RSA算法加密解密文件功能
RAGACM的博客
11-17 4160
Java实现RSA算法加密解密文件
JAVA实现RSA加密解密，RSA分段加密解密，直接用
m0_70962382的博客
10-10 4912
RSA加密方式是一种非对称加密算法，与对称加密算法不同的是，RSA算法有两个不同的密钥，一个是公钥，一个是私钥。RSA算法常用于非对称加密，非对称加密流程如下甲方生成一对密钥(公钥和私钥)。乙方获取甲方的公钥，然后用它对信息加密。乙方再使用自己保存的私钥对信息进行解密。
Java RSA 加解密及签名验证
guokm的博客
10-13 1814
RSA算法是目前非常常见的加密算法，他对应的加解密、签名验签的场景非常常见。因其特性对大字符串加解密效率较低，曾经想对较长字符串加解密，而因其解密过程为分段解密而捣鼓过；这里贴一下代码。
java RSA加解密
m0_72642319的博客
06-13 533
java RSA加解密工具类
Java最全RSA加密解密算法原理以及实现_rsa简介及源码实现，java算法基础面试题
ghfgjfg679的博客
05-10 1710
为了应付面试也刷了很多的面试题与资料，现在就分享给有需要的读者朋友，资料我只截取出来一部分哦φ(n)，k为任意整数，d便是e的模反元素。同时也可得到，e的模反元素d并不是唯一的。例如，e=3，φn11φ(n)=11，则d=4±\pm±k·11。至此，公钥，私钥便都已经得到。
java中RSA的加密与解密
胡云峰的博客
12-05 850
RSA简介与用法
Java RSA加解密实现及注意事项
在Java中实现RSA加密解密，通常需要以下步骤： 1. 生成密钥对：使用`KeyPairGenerator`类，通过`KeyPairGenerator.getInstance("RSA")`获取实例，然后调用`generateKeyPair()`生成公钥和私钥。 2. 将密钥转换为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值