Rsa使用方法

最新推荐文章于 2024-04-15 17:15:25 发布
最新推荐文章于 2024-04-15 17:15:25 发布
阅读量727 收藏
点赞数
文章标签： java
原文链接：https://my.oschina.net/fangMuboy/blog/833920
版权 
package com.acquirer.test;

import java.io.UnsupportedEncodingException;
import java.math.BigInteger;
import java.security.InvalidKeyException;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.Signature;
import java.security.SignatureException;
import java.security.interfaces.RSAPrivateCrtKey;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.RSAPrivateKeySpec;
import java.security.spec.RSAPublicKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

import com.acquirer.common.util.Base64Helper;
import com.acquirer.common.util.DateUtil;
import com.acquirer.common.util.NumberStringUtil;
import com.acquirer.common.util.RsaUtil;
import com.acquirer.common.util.SignatureUtil;
import com.google.gson.Gson;

public class RsaTest {
	public static final	String modulus = "8B6D8CAE9C9494FC1AE3C90E5869111447FA19F66F62D904787C973862D08B0056CA891ECA0CA7CF5D38407BA7AF8FC9A83624CDC46B9A47B0FEBAD0FC730D80C7C1CA1088731D758C6D26A3A2DF7BD7634EEA107B6D752609A16C9C671758A853135214425C58B0DD25779DFB070B08817F0828C72BEF11A5D7F998D0F81D49";
	public static final	String exponent = "4782B76DF3372DB6A3E00285CE088D4EF69FAAE33F3BD68CB9734568111E5EBC9CC7224EDD58625533BD9F2D0CD3398F372C15F24774DCDB3A475BEFC61B08682A941F8B170B82944FB3CEBBD12E37190853271B88018F55A30E788CA2EF944BB0DDB3BA7D08426D0825A040AF3D082DDCA238EAC5445D372891AE6AF11D7FB5";

	public static String privatekeybase64 = "MIIBOQIBADANBgkqhkiG9w0BAQEFAASCASMwggEfAgEAAoGCAKhqPyOvuSDDKPNF+bxO0+fPvjTz\nREqmfjucqtvakR9xDUJ9KWTiaqOf8riA0yx8LMLwtx7wYKf7WIMhQflERhprdbq/PvJyKgzvG0/V\nfAIQeU28cRko79Ar1O59LhcWl216R/U2IcXYdA5zuGhDu1K3WcRKM4aUc6vvdfghv238jwIBAAKB\nggCborP+sqGOmUv6pSwIzYAetWi9XiViOjGRfVKYIgAC4mKykx/xzxtlYqbXwpVkgsyKyhEwUkvA\ncRJ2/AEP7fwq5KW74a0rEw/8SP3MmrOz/pLotmP0X52/excR6jZkMdxQQN2jbVyK1BTidoO+zBJO\nr8Sb2mOEjEgvHTChqtzF3YECAQACAQACAQACAQACAQA=";
	public static String publickeybase64 = "MIGgMA0GCSqGSIb3DQEBAQUAA4GOADCBigKBggCoaj8jr7kgwyjzRfm8TtPnz74080RKpn47nKrb\n2pEfcQ1CfSlk4mqjn/K4gNMsfCzC8Lce8GCn+1iDIUH5REYaa3W6vz7ycioM7xtP1XwCEHlNvHEZ\nKO/QK9TufS4XFpdtekf1NiHF2HQOc7hoQ7tSt1nESjOGlHOr73X4Ib9t/I8CAwEAAQ==";
//	public static final	String modulus = "8B6D8CAE9C9494FC1AE3C90E5869111447FA19F66F62D904787C973862D08B0056CA891ECA0CA7CF5D38407BA7AF8FC9A83624CDC46B9A47B0FEBAD0FC730D80C7C1CA1088731D758C6D26A3A2DF7BD7634EEA107B6D752609A16C9C671758A853135214425C58B0DD25779DFB070B08817F0828C72BEF11A5D7F998D0F81D49";
//	public static final	String exponent = "4782B76DF3372DB6A3E00285CE088D4EF69FAAE33F3BD68CB9734568111E5EBC9CC7224EDD58625533BD9F2D0CD3398F372C15F24774DCDB3A475BEFC61B08682A941F8B170B82944FB3CEBBD12E37190853271B88018F55A30E788CA2EF944BB0DDB3BA7D08426D0825A040AF3D082DDCA238EAC5445D372891AE6AF11D7FB5";
	/**将生成的java公私钥转成.net要的xml格式
	 * 
	 * @param encodedPrivkey
	 * @return
	 */
	private static String getRSAPrivateKeyAsNetFormat(byte[] encodedPrivkey) {
        try {
            StringBuffer buff = new StringBuffer(1024);

            PKCS8EncodedKeySpec pvkKeySpec = new PKCS8EncodedKeySpec(
                    encodedPrivkey);
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            RSAPrivateCrtKey pvkKey = (RSAPrivateCrtKey) keyFactory
                    .generatePrivate(pvkKeySpec);

            buff.append("<RSAKeyValue>");
            buff.append("<Modulus>"
                    + Base64Helper.encode(removeMSZero(pvkKey.getModulus().toByteArray()))
                    + "</Modulus>");

            buff.append("<Exponent>"
                    + Base64Helper.encode(removeMSZero(pvkKey.getPublicExponent()
                    .toByteArray())) + "</Exponent>");

            buff.append("<P>"
                    + Base64Helper.encode(removeMSZero(pvkKey.getPrimeP().toByteArray()))
                    + "</P>");

            buff.append("<Q>"
                    + Base64Helper.encode(removeMSZero(pvkKey.getPrimeQ().toByteArray()))
                    + "</Q>");

            buff.append("<DP>"
                    + Base64Helper.encode(removeMSZero(pvkKey.getPrimeExponentP()
                    .toByteArray())) + "</DP>");

            buff.append("<DQ>"
                    + Base64Helper.encode(removeMSZero(pvkKey.getPrimeExponentQ()
                    .toByteArray())) + "</DQ>");

            buff.append("<InverseQ>"
                    + Base64Helper.encode(removeMSZero(pvkKey.getCrtCoefficient()
                    .toByteArray())) + "</InverseQ>");

            buff.append("<D>"
                    + Base64Helper.encode(removeMSZero(pvkKey.getPrivateExponent()
                    .toByteArray())) + "</D>");
            buff.append("</RSAKeyValue>");

            return buff.toString().replaceAll("[ \t\n\r]", "");
        } catch (Exception e) {
            System.err.println(e);
            return null;
        }
    }
	/**将生成的java公私钥转成.net要的xml格式
	 * 
	 * @param encodedPrivkey
	 * @return
	 */
	private static String getRSAPublicKeyAsNetFormat(byte[] encodedPublicKey) {
        try {

            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            RSAPublicKey pukKey = (RSAPublicKey) keyFactory.generatePublic(new X509EncodedKeySpec(encodedPublicKey));

            StringBuffer buff = new StringBuffer(1024);
            buff.append("<RSAKeyValue>");
            buff.append("<Modulus>"
                    + Base64Helper.encode(removeMSZero(pukKey.getModulus().toByteArray()))
                    + "</Modulus>");
            buff.append("<Exponent>"
                    + Base64Helper.encode(removeMSZero(pukKey.getPublicExponent().toByteArray())) + "</Exponent>");
            buff.append("</RSAKeyValue>");

            return buff.toString().replaceAll("[ \t\n\r]", "");
        } catch (Exception e) {
            System.err.println(e);
            return null;
        }
    }
	public static void main(String[] args) {
		try {
//			RSAPrivateKey privateKey = RsaUtil.loadPrivateKey(modulus, exponent, 16);
//			
			//生成asp所用的公私钥文件
//			javastr2asp();
			//加密
			Gson gson = new Gson();
		    HashMap<String, Object> map=new HashMap<String,Object>();
		    map.put("instid", "10000001");
		    map.put("mchntid", "jieshun001");
			map.put("psn", "C0001");
			map.put("txntime", "20170207212244");
			map.put("txncode", "monthmealdown");
			map.put("seqid", "50000000000000000");
//			map.put("oprtype", "1");
			String jsonStr;
			jsonStr = gson.toJson(map);
			System.out.println(jsonStr);
			
//			Map<String, Object> keymap = getPublicKey();
//			RSAPrivateKey prikey = (RSAPrivateKey) keymap.get("PRIVATE_KEY");
//			RSAPublicKey pubkey = (RSAPublicKey) keymap.get("PUBLIC_KEY");
//			RSAPrivateKey prikey = getRSAPrivateKeyBybase64(privatekeybase64);
//			RSAPublicKey pubkey = getRSAPublidKeyBybase64(publickeybase64);
//			String signstr = privateKeyEncrypt(jsonStr,prikey);
//			String jsonStr = "123456";
			String signstr ="4C1B4A04A7B3F19F10A75183C1B8562EDC3FEF7EA46AC303C3392DE6BED8A3146CB9C557449A22D727C20B784ED7429848E056DEB95986153267BA1117B09A514CFB1A03A40EB5EB0AF12EE1E463C31BA7873BAA64B4DFEE509BEE07A1C344294DF8EFEB89747D43934A2A81F94DD503BF957E33ACFB12356D5EE90865194CA2";
			RSAPublicKey pubkey = RsaUtil.loadPublicKey(modulus, "10001", 16);
			System.out.println(signVerified("",jsonStr,signstr,pubkey ));
			
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}
	private static void javastr2asp() {
		RSAPrivateKey privatekey = getRSAPrivateKeyBybase64(privatekeybase64);
		RSAPublicKey publickey = getRSAPublidKeyBybase64(publickeybase64);
		System.out.println("it is ok");
		String privatestrxml = getRSAPrivateKeyAsNetFormat(privatekey.getEncoded());
		String publickeystrxml = getRSAPublicKeyAsNetFormat(publickey.getEncoded());
		System.out.println("publickeystrxml="+publickeystrxml);
		System.out.println("privatestrxml="+privatestrxml);
	}
	/**
	 * 除0操作
	 * @param data
	 * @return
	 */
	private static byte[] removeMSZero(byte[] data) {
        byte[] data1;
        int len = data.length;
        if (data[0] == 0) {
            data1 = new byte[data.length - 1];
            System.arraycopy(data, 1, data1, 0, len - 1);
        } else
            data1 = data;

        return data1;
    }
	/**
	 * 将生成的证书密钥的base64字符串转换成公钥，私钥文件
	 * @param base64s
	 * @return
	 */
	public static RSAPublicKey getRSAPublidKeyBybase64(String base64s) {
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(Base64Helper.decode(base64s));
        RSAPublicKey publicKey = null;

        try {
        	KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            publicKey = (RSAPublicKey)keyFactory.generatePublic(keySpec);
        } catch (InvalidKeySpecException var4) {
            System.out.println("base64编码=" + base64s + "转RSA公钥失败"+var4);
        } catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		}

        return publicKey;
    }
	/**
	 * 将生成的证书密钥的base64字符串转换成公钥，私钥文件
	 * @param base64s
	 * @return
	 */
    public static RSAPrivateKey getRSAPrivateKeyBybase64(String base64s) {
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(Base64Helper.decode(base64s));
        RSAPrivateKey privateKey = null;

        try {
        	KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            privateKey = (RSAPrivateKey)keyFactory.generatePrivate(keySpec);
        } catch (InvalidKeySpecException var4) {
            System.out.println("base64编码=" + base64s + "转RSA私钥失败"+var4 );
        } catch (NoSuchAlgorithmException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

        return privateKey;
    }
    /**
     * 利用生成的私钥加密
     */
    public static String privateKeyEncrypt(String jsonStr,RSAPrivateKey privatekey){
    	String strhex = null;
    	Signature sig;
    	try {
			sig = Signature.getInstance("SHA1WithRSA");
			sig.initSign(privatekey);
			byte [] plainText = jsonStr.getBytes();
			sig.update(plainText);   
			byte[] signature=sig.sign(); 
			strhex = NumberStringUtil.bytesToHexString(signature);
			System.out.println(Base64Helper.encode(signature));
			System.out.println(strhex);
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} catch (InvalidKeyException e) {
			e.printStackTrace();
		} catch (SignatureException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} 
    	return strhex;
    }
    /**
     * 根据公钥验签
     */
    public synchronized static boolean signVerified(String signAlgor, String jsonstr,
			String signData,RSAPublicKey publicKey) {
    	byte[] plainText = jsonstr.getBytes();
    	byte[] sign = NumberStringUtil.hexStringToBytes(signData);
    	String temp = NumberStringUtil.bytesToHexString(sign);
    	System.out.println(temp);
		Boolean signVerify = false;
		try {
			Signature signature=Signature.getInstance("SHA1WithRSA");  
			signature.initVerify(publicKey);   
			signature.update(plainText);   
			signVerify = signature.verify(sign);
		} catch (Exception e) {
		}
		return signVerify;
	}
    /**
     * 生成公钥私钥
     * @return
     * @throws Exception
     */
    public static Map<String, Object> getPublicKey() throws Exception {
    	KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
    	keyPairGen.initialize(1024);
    	KeyPair keyPair = keyPairGen.generateKeyPair();
    	RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
    	RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
    	String privatestrxml = getRSAPrivateKeyAsNetFormat(privateKey.getEncoded());
		String publickeystrxml = getRSAPublicKeyAsNetFormat(publicKey.getEncoded());
		System.out.println(privatestrxml);
		System.out.println(publickeystrxml);
    	Map<String,Object> keyMap = new HashMap<String, Object>();
    	keyMap.put("PUBLIC_KEY", publicKey);
    	keyMap.put("PRIVATE_KEY", privateKey);
    	return keyMap;
    }
    public static boolean signVerified1(String signAlgor, byte[] plainText,
			byte[] signData, String modulus, String exponent) {
		RSAPublicKey publicKey;
		Boolean signVerify = null;
		try {
			publicKey = RsaUtil.loadPublicKey(modulus, exponent, 16);
			signVerify = SignatureUtil.signVerified(plainText, signData, publicKey, signAlgor);
		} catch (Exception e) {
		}
		return signVerify;
	}

    
}

开发中遇到和.net平台对接，用到了sha1withrsa算法进行，签名，验签，上面的方法没有起到效果，最终大神的通过将java中的jar包转成.net的dll文件，使用java的签名验签方法得以实现。

 

 

 

转载于:https://my.oschina.net/fangMuboy/blog/833920

chensi5723
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
RSA的使用方式
kusirp21的博客
12-16 2933
RSA的使用方式加密方式解密方式签名方式验签（检验签名）总结说明 一小部分人在学习RSA原理之后仍不清楚其使用的方式，在使用时将其理论讲错。本文厘清其使用方式，避免大家的误解。 加密方式 非对称加密的使用是非常环境下传输安全信息。换句话来说，加密方式的使用场景就是我想给你说句话，但别人不知道内容。 经常举例Alice和Bob的通信息过程，如果是Alice想通知Bob一个信息，那么必须使用Bob的公钥对信息加密，此时由于只有私钥能解，也就意味着只有Bob能拿到这个信息的真正明文。 但是，这里很多人都以为Bob
java加解密RSA使用方法代码示例
08-28
在Java中，我们可以使用Java Cryptography Extension (JCE)库来实现RSA加解密。以下是使用Java进行RSA加解密的关键知识点： 1. **RSA算法基础**： - RSA由三个大素数p、q和e、d组成。p和q是私钥的一部分，它们的...
RSA加解密算法的基本使用
qq_31830173的博客
06-27 785
RSA加解密的使用
RSA加密解密算法原理以及实现_rsa简介及源码实现，网络安全面试题2024基础
最新发布
m0_60147147的博客
04-15 1023
设F(x,y）表示为x，y的最大公约数，取k=x/y，b=x%y,那么x=ky+b，如果一个数能够整除x和y,那么一定可以整除y和b，也就是说，能够整除y和b的数，一定能够整除x和y，所以x和y的公约数和y和b的公约数相同，其最大公约数也相同，则有F(x,y)=F(y,x%y)(x>=y>0),这样就把求两个数的最大公约数转化为求两个更小的数的公约数，直到其中一个数为0，那么另一个数就是两者的最大公约数。φ(n)=n−1，因为质数在大于1的自然数中，除了1和它本身以外不会再有其他因数的自然数。
OpenSSL之RSA用法
史D芬周
10-21 5639
RSA公开密钥密码体制是一种使用不同的加密密钥与解密密钥，“由已知加密密钥推导出解密密钥在计算上是不可行的”密码体制。在公开密钥密码体制中，加密密钥（即公开密钥）PK是公开信息，而解密密钥（即秘密密钥）SK是需要保密的。加密算法E和解密算法D也都是公开的。虽然解密密钥SK是由公开密钥PK决定的，但却不能根据PK计算出SK。正是基于这种理论，1978年出现了著名的RSA算法，它通常是先生成一对RSA密钥，其中之一是保密密钥，由用户保存；另一个为公开密钥，可对外公开，甚至可在网络服务器中注册。
RSA参数及RSA用法
CSDN博客
11-04 4226
rsa公钥和私钥区别
rsa简单使用
渣渣的博客
10-16 1034
RSAUtils.java public final class RSAUtils { /** 安全服务提供者 */ private static final Provider PROVIDER = new BouncyCastleProvider(); /** 密钥大小 */ private static final int KEY_SIZE = 2048; ...
RSA 加密解密的使用方法
06-04
一个的RSA 加密/解密的示例，其内容包括： 1: 如何通过 openssl 命令获得 public key, private key并存入文件 2: 如何通过文件读取RSA的 public/private key。 3: 如何用public key加密，然后用private key解密。 4:...
PHP rsa加密解密使用方法
12-18
以下是使用RSA加密解密的详细步骤： 1. **生成公钥和私钥对**： 生成RSA密钥对通常需要用到`openssl`工具。在Linux环境下，`openssl`一般已经预装。在命令行中，你可以执行以下命令： - `openssl genrsa -out rsa...
.NET使用RSA加密解密的方法
01-20
本文实例为大家分享了.NET使用RSA加密解密的具体代码，供大家参考，具体内容如下 PassWordHelper.cs代码: using System; using System.IO; using System.Text; using System.Globalization; using System....
RSA加密使用方式及签名验证
yowasa的博客
06-01 2万+
RSA加密原理使用方式签名验证 加密是网络传输中非常重要的一环，它保证了信息的安全性，让他人无法通过抓包来获取通讯的信息也无法通过伪造信息而实现对系统的入侵。其中最为常用的信息传递加密方式就是RSA加密。 RSA加密原理 RSA与传统加密方式不同的是，他是非对称加密，可以在不直接传递密钥的情况下，完成解密。这能够确保信息的安全性，避免了直接传递密钥所造成的被破解的风险。 RSA加密方式
RSA解密工具--RsaCtfTool使用
ITgougou_的博客
10-16 6306
用法一：已知公钥（自动求私钥）--publickey,密文 --uncipherfile python RsaCtfTool.py --publickey 公钥文件 --uncipherfile 加密的文件 用法二：已知公钥求私钥 RsaCtfTool.py --publickey 公钥文件 --private 用法三：密钥格式转换 把PEM格式的公钥转换为n，e >python RsaCtfTool.py --dumpkey --key 公钥文件 把n，e转换为PEM格式
一步一步 搞定RSA（公钥、私钥）
iOS开发
11-29 4万+
首先我们要会生成RSA密钥文件，现在一步步的来给大家展示一下，如何生成我们所需的公钥和私钥文件： RSA密钥生成过程 生成私钥文件 $ openssl genrsa -out private.pem 1024openssl:是一个自由的软件组织,专注做加密和解密的框架。 genrsa:指定了生成了算法使用RSA -out:后面的参数表示生成的key的输入文件 1024:表示的是生成key的长度,
非对称加密算法之RSA介绍及OpenSSL中RSA常用函数使用举例
网络资源是无限的
02-08 3万+
非对称加密算法之RSA介绍及OpenSSL中RSA常用函数使用举例！
java中rsa的使用方式
weixin_43785508的博客
01-08 328
https://blog.csdn.net/kusirp21/article/details/111270903
HashMap(一)——HashMap put方法原理
热门推荐
自恃无情的博客
08-14 4万+
1.HashMap重要成员 部分成员变量如下： //初始值，为16，必须为2的次幂 static final int DEFAULT_INITIAL_CAPACITY = 1 &lt;&lt; 4; //当容量被占满0.75时就需要reSize扩容 static final float DEFAULT_LOAD_FACTOR = 0.75f; //链表长度到8，就转为红黑树 stat...
如何使用RSA密钥登陆ssh
a19576的专栏
06-25 1441
http://tank.blogs.tkiicpp.com/2011/03/23/%E5%A6%82%E4%BD%95%E4%BD%BF%E7%94%A8rsa%E5%AF%86%E9%92%A5%E7%99%BB%E9%99%86ssh/ 作为一个unix／linux小白，今天折腾了下ssh登录，使用rsa，不再需要输入密码了，具体步骤如下： 在本机（客户端）生成rsa密钥
node-rsa使用
zhj_fly的博客
04-25 1万+
简单介绍使用node-rsa模块生成/导出秘钥,加密/解密,签名/验证具体方法见API1.首先导入模块:npm install node-rsa2.生成,导入导出秘钥var NodeRSA = require('node-rsa'); var key = new NodeRSA({b: 512});//生成512位秘钥 var pubkey = key.exportKey('pkcs8-publ...
rsa tool2 by te使用方法
03-16
以下是使用方法： 1. 打开RSA Tool2软件。 2. 选择“加密”或“解密”选项。 3. 输入要加密或解密的文本或文件路径。 4. 输入RSA密钥的公钥或私钥。 5. 点击“加密”或“解密”按钮。 6. 等待加密或解密完成。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值