RSA加密

最新推荐文章于 2022-03-02 23:26:42 发布
最新推荐文章于 2022-03-02 23:26:42 发布
阅读量584 收藏
点赞数
分类专栏： java 文章标签： java RSA加密
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010323779/article/details/52709146
版权
RSA加密用的是双方密钥进行加密的方式
1、输出方：用对方的公钥对参数加密，用本方的私钥对参数加签；

2、接收方：用本方的私钥解密，用对方的公钥对参数验签

不多说直接上代码，一看就懂！

RSAUtil类：

package com.wolf.pc.RSA;

import javax.crypto.Cipher;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

public class RSAUtil extends CoderUtil {

    public final static String UTF8 = "UTF-8";
    public final static String LOCAL_PUBLICKEY = "LOCAL_PUBLICKEY";  //替换成本方的公钥
    public final static String LOCAL_PRIVATEKEY = "LOCAL_PRIVATEKEY"; //替换成本方的私钥

    public final static String OTHER_PUBLICKEY = "";  //替换成对方的公钥
    public final static String OTHER_PRIVATEKEY = "OTHER_PRIVATEKEY"; //替换成对方的私钥

    /*************************************用本方的私钥解密，用对方的公钥解签start**********************************************/
    /**
     * 用本方私钥解密
     * @param data
     * @param privateKey
     * @param charset
     * @return
     * @throws Exception
     */
    public static String decrypt(String data, String privateKey, String charset) throws Exception {
        byte[] byte64 = Base64Util.base64ToByteArray(data);
        byte[] encryptedBytes = decryptByPrivateKey(byte64, privateKey);
        return new String(encryptedBytes, charset);
    }
    public static byte[] decryptByPrivateKey(byte[] data, String key) throws Exception {
        byte[] keyBytes = decryptBASE64(key);

        PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        Key privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);

        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(2, privateKey);

        byte[] dataReturn = null;
        for (int i = 0; i < data.length; i += 128) {
            byte[] doFinal = cipher.doFinal(subarray(data, i, i + 128));
            dataReturn = addAll(dataReturn, doFinal);
        }
        return dataReturn;
    }

    /**
     * 用对方公钥解签
     * @param params    需要解签的字符串
     * @param publicKey 公钥
     * @param charset   编码
     * @param sign
     * @return
     * @throws Exception
     */
    public static boolean verifySign(String params, String publicKey, String charset,String sign) throws Exception {
        return verify(params.getBytes(charset), publicKey, sign);
    }

    public static boolean verify(byte[] data, String publicKey, String sign) throws Exception {
        byte[] keyBytes = decryptBASE64(publicKey);

        X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(keyBytes);

        KeyFactory keyFactory = KeyFactory.getInstance("RSA");

        PublicKey publicKey2 = keyFactory.generatePublic(x509EncodedKeySpec);

        Signature signature = Signature.getInstance("SHA1WithRSA");
        signature.initVerify(publicKey2);
        signature.update(data);

        return signature.verify(decryptBASE64(sign));
    }
    /*************************************用本方的私钥加密，用对方的公钥解签end**********************************************/

    /*************************************用本方的私钥加签，用对方的公钥加密start**********************************************/
    /**
    * 公钥加密
     * @param paramsString
     * @param charset
     * @param publicKey
     * @return
     * @throws Exception
     */
    public static String encrypt(String paramsString, String charset, String publicKey) throws Exception {
        byte[] encryptedResult = encryptByPublicKey(paramsString.getBytes(charset), publicKey);

        return Base64Util.byteArrayToBase64(encryptedResult);
    }

    public static byte[] encryptByPublicKey(byte[] data, String publicKey) throws Exception {
        byte[] keyBytes = decryptBASE64(publicKey);

        X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        Key publicKeyObj = keyFactory.generatePublic(x509EncodedKeySpec);

        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(1, publicKeyObj);

        byte[] dataReturn = null;
        for (int i = 0; i < data.length; i += 117) {
            byte[] doFinal = cipher.doFinal(subarray(data, i, i + 117));
            dataReturn = addAll(dataReturn, doFinal);
        }

        return dataReturn;
    }

    /**
     * 私钥加签
     * @param data
     * @param charset
     * @param privateKey
     * @return
     * @throws Exception
     */
    public static String sign(String data, String charset, String privateKey) throws Exception {
        byte[] dataInBytes = data.getBytes(charset);
        String signParams = sign(dataInBytes, privateKey);
        return signParams;
    }

    public static String sign(byte[] data, String privateKey) throws Exception {
        byte[] keyBytes = decryptBASE64(privateKey);

        PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(keyBytes);

        KeyFactory keyFactory = KeyFactory.getInstance("RSA");

        PrivateKey privateKey2 = keyFactory.generatePrivate(pkcs8EncodedKeySpec);

        Signature signature = Signature.getInstance("SHA1withRSA");
        signature.initSign(privateKey2);
        signature.update(data);

        return encryptBASE64(signature.sign());
    }
    /*************************************用本方的私钥加签，用对方的公钥加密end**********************************************/

    public static byte[] subarray(byte[] array, int startIndexInclusive, int endIndexExclusive) {
        if (array == null) {
            return null;
        }
        if (startIndexInclusive < 0) {
            startIndexInclusive = 0;
        }
        if (endIndexExclusive > array.length) {
            endIndexExclusive = array.length;
        }
        int newSize = endIndexExclusive - startIndexInclusive;
        if (newSize <= 0) {
            return new byte[0];
        }

        byte[] subarray = new byte[newSize];
        System.arraycopy(array, startIndexInclusive, subarray, 0, newSize);
        return subarray;
    }

    public static byte[] addAll(byte[] array1, byte[] array2) {
        if (array1 == null)
            return clone(array2);
        if (array2 == null) {
            return clone(array1);
        }
        byte[] joinedArray = new byte[array1.length + array2.length];
        System.arraycopy(array1, 0, joinedArray, 0, array1.length);
        System.arraycopy(array2, 0, joinedArray, array1.length, array2.length);
        return joinedArray;
    }

    public static byte[] clone(byte[] array) {
        if (array == null) {
            return null;
        }
        return (byte[]) (byte[]) array.clone();
    }

    public static void main(String[] args) {
        try {
            String paramsEncoder= URLEncoder.encode("userId=1111111&userName=张三&idcardNo=4524021998542365",RSAUtil.UTF8);
            System.out.println("paramsEncoder :　"+paramsEncoder);

            String enParams = RSAUtil.encrypt(paramsEncoder, RSAUtil.UTF8, OTHER_PUBLICKEY);
            System.out.println("enParams : " + enParams);
            String sign = RSAUtil.sign(paramsEncoder, RSAUtil.UTF8, LOCAL_PRIVATEKEY);
            System.out.println(sign);

            System.out.println("---------------------------------------------encrypt end------------------------------------------------");
            String deParams = RSAUtil.decrypt(enParams,RSAUtil.OTHER_PRIVATEKEY, RSAUtil.UTF8);
            System.out.println("deParams : "+deParams);
            boolean isSign = RSAUtil.verifySign(deParams, LOCAL_PUBLICKEY, UTF8, sign);
            System.out.println(isSign + "| sign : " + sign);
            System.out.println(URLDecoder.decode(deParams, RSAUtil.UTF8));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
CoderUtil.java 

package com.wolf.pc.RSA;

import java.security.MessageDigest;

public class CoderUtil {
	public static final String KEY_SHA = "SHA";
	public static final String KEY_MD5 = "MD5";

	public static byte[] decryptBASE64(String key) {
		return Base64Util.base64ToByteArray(key);
	}

	public static String encryptBASE64(byte[] key) throws Exception {
		return Base64Util.byteArrayToBase64(key);
	}

	public static byte[] encryptMD5(byte[] data) throws Exception {
		MessageDigest md5 = MessageDigest.getInstance(KEY_MD5);
		md5.update(data);
		return md5.digest();
	}

	public static byte[] encryptSHA(byte[] data) throws Exception {
		MessageDigest sha = MessageDigest.getInstance(KEY_SHA);
		sha.update(data);
		return sha.digest();
	}
}
Base64Util.javai
package com.wolf.pc.RSA;

public class Base64Util extends CoderUtil {
	private static final char[] intToBase64 = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd',
			'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/' };

	private static final char[] intToAltBase64 = { '!', '"', '#', '$', '%', '&', '\'', '(', ')', ',', '-', '.', ':', ';', '<', '>', '@', '[', ']', '^', '`', '_', '{', '|', '}', '~', 'a', 'b', 'c',
			'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '?' };

	private static final byte[] base64ToInt = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
			-1, -1, -1, -1, -1, 62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
			22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51 };

	private static final byte[] altBase64ToInt = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4,
			5, 6, 7, 8, -1, 62, 9, 10, 11, -1, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 12, 13, 14, -1, 15, 63, 16, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
			-1, -1, -1, -1, -1, 17, -1, 18, 19, 21, 20, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 22, 23, 24, 25 };

	public static String byteArrayToBase64(byte[] a) {
		return byteArrayToBase64(a, false);
	}

	public static String byteArrayToAltBase64(byte[] a) {
		return byteArrayToBase64(a, true);
	}

	private static String byteArrayToBase64(byte[] a, boolean alternate) {
		int aLen = a.length;
		int numFullGroups = aLen / 3;
		int numBytesInPartialGroup = aLen - 3 * numFullGroups;
		int resultLen = 4 * ((aLen + 2) / 3);
		StringBuffer result = new StringBuffer(resultLen);
		char[] intToAlpha = (alternate) ? intToAltBase64 : intToBase64;

		int inCursor = 0;
		for (int i = 0; i < numFullGroups; ++i) {
			int byte0 = a[(inCursor++)] & 0xFF;
			int byte1 = a[(inCursor++)] & 0xFF;
			int byte2 = a[(inCursor++)] & 0xFF;
			result.append(intToAlpha[(byte0 >> 2)]);
			result.append(intToAlpha[(byte0 << 4 & 0x3F | byte1 >> 4)]);
			result.append(intToAlpha[(byte1 << 2 & 0x3F | byte2 >> 6)]);
			result.append(intToAlpha[(byte2 & 0x3F)]);
		}

		if (numBytesInPartialGroup != 0) {
			int byte0 = a[(inCursor++)] & 0xFF;
			result.append(intToAlpha[(byte0 >> 2)]);
			if (numBytesInPartialGroup == 1) {
				result.append(intToAlpha[(byte0 << 4 & 0x3F)]);
				result.append("==");
			} else {
				int byte1 = a[(inCursor++)] & 0xFF;
				result.append(intToAlpha[(byte0 << 4 & 0x3F | byte1 >> 4)]);
				result.append(intToAlpha[(byte1 << 2 & 0x3F)]);
				result.append('=');
			}

		}

		return result.toString();
	}

	public static byte[] base64ToByteArray(String s) {
		return base64ToByteArray(s, false);
	}

	public static byte[] altBase64ToByteArray(String s) {
		return base64ToByteArray(s, true);
	}

	private static byte[] base64ToByteArray(String s, boolean alternate) {
		byte[] alphaToInt = (alternate) ? altBase64ToInt : base64ToInt;
		int sLen = s.length();
		int numGroups = sLen / 4;
		if (4 * numGroups != sLen) {
			throw new IllegalArgumentException("String length must be a multiple of four.");
		}
		int missingBytesInLastGroup = 0;
		int numFullGroups = numGroups;
		if (sLen != 0) {
			if (s.charAt(sLen - 1) == '=') {
				++missingBytesInLastGroup;
				--numFullGroups;
			}
			if (s.charAt(sLen - 2) == '=') {
				++missingBytesInLastGroup;
			}
		}
		byte[] result = new byte[3 * numGroups - missingBytesInLastGroup];

		int inCursor = 0;
		int outCursor = 0;
		for (int i = 0; i < numFullGroups; ++i) {
			int ch0 = base64toInt(s.charAt(inCursor++), alphaToInt);
			int ch1 = base64toInt(s.charAt(inCursor++), alphaToInt);
			int ch2 = base64toInt(s.charAt(inCursor++), alphaToInt);
			int ch3 = base64toInt(s.charAt(inCursor++), alphaToInt);
			result[(outCursor++)] = (byte) (ch0 << 2 | ch1 >> 4);
			result[(outCursor++)] = (byte) (ch1 << 4 | ch2 >> 2);
			result[(outCursor++)] = (byte) (ch2 << 6 | ch3);
		}

		if (missingBytesInLastGroup != 0) {
			int ch0 = base64toInt(s.charAt(inCursor++), alphaToInt);
			int ch1 = base64toInt(s.charAt(inCursor++), alphaToInt);
			result[(outCursor++)] = (byte) (ch0 << 2 | ch1 >> 4);

			if (missingBytesInLastGroup == 1) {
				int ch2 = base64toInt(s.charAt(inCursor++), alphaToInt);
				result[(outCursor++)] = (byte) (ch1 << 4 | ch2 >> 2);
			}

		}

		return result;
	}

	private static int base64toInt(char c, byte[] alphaToInt) {
		int result = alphaToInt[c];
		if (result < 0) {
			throw new IllegalArgumentException("Illegal character " + c);
		}
		return result;
	}
}



wolf_bin
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RSAEncrypt加密解密类文件
04-30
RSAEncrypt加密，解密 类资源文件，此文件内有加密和解密代码，包括默认配置公钥和私钥
java 私钥签名公钥认证
zhao_963084302的博客
09-09 1778
  Java实现私钥签名公钥认证demo package com.ibs.clearing.sign.demo; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.FileReader; import java.io.FileWriter; import java.io.IO...
使用openssl命令剖析RSA私钥文件格式
热门推荐
hang
06-22 2万+
Openssl提供了强大证书功能，生成密钥对、证书，颁发证书、生成crl、验证证书、销毁证书等。本文将j介绍如何利用openssl的命令分析RSA私钥文件格式，同时也将简单介绍几种常见的私钥文件格式。   1 生成私钥文件 openssl有多种方法生成私钥： genrsa生成RSA密钥。req在生成req证书请求时同时产生密钥。genpkey除了可以生成RSA密钥外，还可以生成DS
RSAEncrypt&RSAEncrypt
ALEX_wxy的博客
06-18 614
public static String encryptString(String input, String channel) throws Exception { if (StringUtils.isBlank(channel)) { throw new BusinessException("缺少channel"); } Cipher cipher = Cipher.getInstance("RSA"); RSAPublicKey pubKey = (R.
RSA ENCRYPT
E_T_Fang的专栏
07-30 539
依稀记得本科是学过加密的。作为近期中过HELP DECRYPT的毒的用户来讲，好歹要了解一下这么时尚的破坏神。 根据其提示表示使用的是RSA-2048进行加密，根据wiki上的说明，公钥和私钥是如下产生的： 选择两个不同的素数pp和qq. 计算n=pqn = pq.nn的二进制长度视为秘钥长度。 计算欧拉函数φ(n)=φ(p)φ(q)=(p−1)(q−1)=n−(p+q−1)\varphi(n)=
RSA加密算法c++实现
04-07
RSA加密算法的实现，使用c++语言编程，使用dev c++平台编码，文件为cpp格式。经过反复测试代码正确，可搭配RSA讲解教程一起使用，讲解教程点击我的个人主页即可查看，希望能够对你有帮助，谢谢。
加密RSA加密
05-03
java 语音 RSA加密DEMO源代码，本人亲测 可以正常运行！
RSA.rar_RSA加密解密和
09-21
RSA算法是最著名的公开密码体制。基于大数分解的难度。其公开密钥和私人密钥是一对大素数的函数，从一个公开密钥和密文中恢复出明文的难度等价于...算法过程：首先是设计密钥，然后是对消息加密，最后是对密文解密。
C#RSA加密DEMO
03-25
根据JAVA提供的公钥，进行RSA加密示例
创建RSA共私钥
u012864294的博客
06-28 573
import java.security.Key; import java.security.KeyPair; import java.security.KeyPairGenerator; import java.security.NoSuchAlgorithmException; import java.security.interfaces.RSAPrivateKey; import java...
rsa加密(一)
Koow的博客
01-18 1302
第一步：使用Openssl生成私钥跟公钥  由于笔者使用阿里云服务器ubuntu 16.04，自带Openssl，跳过 输入命令：openssl version -a   查询是否安装Openssl 生成1024位私钥：openssl genrsa -out rsa_private_key.pem 1024 查看生成的私钥：cat rsa_private_key.pem
RSA加密 — 详解
赵彦军
09-15 1万+
文章目录RSA 简介实际运用注意事项实战 RSA 简介 RSA——非对称加密，会产生公钥和私钥，公钥在客户端，私钥在服务端。公钥用于加密，私钥用于解密。 实际运用注意事项 1、一般由服务器创建秘钥对，私钥保存在服务器，公钥下发至客户端 2、公钥是二进制数据，怎么下发给客户端呢？ 第一种方式：服务器把二进制数据写入文件，然后把文件传给客户端。由客户端从文件读取二进制数据。 第二种方式：服务器把二进制数据转成 base64 字符串，客户端获取到 base64 字符串后，再转码为二进制数据。 实战 我们封存一
RSA
f543711700的专栏
10-21 189
[code="java"]package com.ghca.roam.sync; import java.io.ByteArrayOutputStream; import java.security.Key; import java.security.KeyFactory; import java.security.KeyPair; import java.security.KeyP...
rsa encrypt and decrypt arithmetic source code
玄冰幽阁
01-31 2971
#include "rsaeuro.h"#include "r_random.h"#include "rsa.h"#include "nn.h"static int rsapublicfunc PROTO_LIST((unsigned char *, unsigned int *, unsigned char *, unsigned int, R_RSA_PUBLIC_KEY *));static
RSA生成公钥私钥
默默无闻的黄先生的博客
11-13 2699
public static void genKeyPair() { // KeyPairGenerator类用于生成公钥和私钥对，基于RSA算法生成对象 KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA"); // 初始化密钥对生成器，密钥大小为96-1024位 keyPairGen.initialize(1024,new SecureRandom()); // 生成一个密钥对，保存在keyPair中 KeyPair
RSA加密算法
王斯的博客
03-02 1万+
前言 公钥加密算法（RSA）是首个适用以签名作为加密的算法。被用于银行网上支付、电商交易。 RSA是Rivest、Shamir、Adleman三位数学家的缩写。其数学原理是大整数因数分解极其苦难的原因设计的一种算法。 蒙哥马利幂运算 蒙哥马利幂运算是为了快速计算abmod(c)a^bmod(c)abmod(c)的一种算法，是RSA加密算法核心之一，用于求私钥值d(d=abmod(c))d(d=a^b mod (c))d(d=abmod(c))，其中mod求余符号等价于python里面的%符号。 abmod(
RSA 的加密 解密
baipingsong1086的博客
11-07 171
RSA加密解密类： 1 package me.hao0.trace.order; 2 3 import java.io.BufferedReader; 4 import java.io.BufferedWriter; 5 import java.io.FileReader; 6 import java.io.FileWriter; 7 im...
rsa 加密 delphi
最新发布
11-24
RSA 加密是一种非对称加密算法，广泛应用于数据加密和数字签名领域。RSA 加密的原理是基于大素数的乘法和取模运算，利用一对公钥和私钥来进行加密和解密操作。 在 Delphi 中实现 RSA 加密可以通过使用现成的加密算法库，比如 Indy 以及第三方的加密组件等。首先需要生成一对 RSA 密钥，然后将公钥和私钥保存到文件或者数据库中。 在 Delphi 中，通过调用相应的函数或方法，可以使用公钥对数据进行加密，而使用私钥对加密后的数据进行解密。需要注意的是，RSA 加密算法对要加密的数据长度有要求，通常情况下需要将数据进行分块处理，然后分别对每个块进行加密。 另外，RSA 加密算法的安全性与密钥的长度密切相关，通常情况下推荐使用较长的密钥长度以提高加密的安全性。在 Delphi 中，可以通过相应的函数或方法来设置密钥的长度和其他加密参数。 总之，通过在 Delphi 中实现 RSA 加密，可以保护数据的安全性，防止数据被非法获取和篡改，同时也能够实现数字签名等功能，为应用程序的安全提供有效保障。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值