rsa签名java代码 rsa签名验签

RSA PKCS#1在java中怎么实现？

楼主看看下面的代码是不是你所需要的，这是我原来用的时候收集的

成都创新互联公司网络公司拥有十余年的成都网站开发建设经验，超过千家客户的共同信赖。提供成都做网站、成都网站设计、成都外贸网站建设、网站开发、网站定制、卖友情链接、建网站、网站搭建、成都响应式网站建设、网页设计师打造企业风格，提供周到的售前咨询和贴心的售后服务

import javax.crypto.Cipher;

import java.security.*;

import java.security.spec.RSAPublicKeySpec;

import java.security.spec.RSAPrivateKeySpec;

import java.security.spec.InvalidKeySpecException;

import java.security.interfaces.RSAPrivateKey;

import java.security.interfaces.RSAPublicKey;

import java.io.*;

import java.math.BigInteger;

/**

* RSA 工具类。提供加密，解密，生成密钥对等方法。

* 需要到下载bcprov-jdk14-123.jar。

* RSA加密原理概述

* RSA的安全性依赖于大数的分解，公钥和私钥都是两个大素数（大于100的十进制位）的函数。

* 据猜测，从一个密钥和密文推断出明文的难度等同于分解两个大素数的积

* ===================================================================

* （该算法的安全性未得到理论的证明）

* ===================================================================

* 密钥的产生：

* 1.选择两个大素数 p,q ,计算 n=p*q;

* 2.随机选择加密密钥 e ,要求 e 和 (p-1)*(q-1)互质

* 3.利用 Euclid 算法计算解密密钥 d , 使其满足 e*d = 1(mod(p-1)*(q-1)) (其中 n,d 也要互质)

* 4:至此得出公钥为 (n,e) 私钥为 (n,d)

* ===================================================================

* 加解密方法：

* 1.首先将要加密的信息 m(二进制表示) 分成等长的数据块 m1,m2,...,mi 块长 s(尽可能大) ,其中 2^sn

* 2:对应的密文是： ci = mi^e(mod n)

* 3:解密时作如下计算： mi = ci^d(mod n)

* ===================================================================

* RSA速度

* 由于进行的都是大数计算，使得RSA最快的情况也比DES慢上100倍，无论是软件还是硬件实现。

* 速度一直是RSA的缺陷。一般来说只用于少量数据加密。

* 文件名：RSAUtil.javabr

* @author 赵峰br

* 版本:1.0.1br

* 描述：本算法摘自网络，是对RSA算法的实现br

* 创建时间:2009-7-10 下午09:58:16br

* 文件描述：首先生成两个大素数，然后根据Euclid算法生成解密密钥br

public class RSAUtil {

//密钥对

private KeyPair keyPair = null;

/**

* 初始化密钥对

public RSAUtil(){

try {

this.keyPair = this.generateKeyPair();

} catch (Exception e) {

e.printStackTrace();

}

/**

* 生成密钥对

* @return KeyPair

* @throws Exception

private KeyPair generateKeyPair() throws Exception {

try {

KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA",new org.bouncycastle.jce.provider.BouncyCastleProvider());

//这个值关系到块加密的大小，可以更改，但是不要太大，否则效率会低

final int KEY_SIZE = 1024;

keyPairGen.initialize(KEY_SIZE, new SecureRandom());

KeyPair keyPair = keyPairGen.genKeyPair();

return keyPair;

} catch (Exception e) {

throw new Exception(e.getMessage());

}

/**

* 生成公钥

* @param modulus

* @param publicExponent

* @return RSAPublicKey

* @throws Exception

private RSAPublicKey generateRSAPublicKey(byte[] modulus, byte[] publicExponent) throws Exception {

KeyFactory keyFac = null;

try {

keyFac = KeyFactory.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());

} catch (NoSuchAlgorithmException ex) {

throw new Exception(ex.getMessage());

}

RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(new BigInteger(modulus), new BigInteger(publicExponent));

try {

return (RSAPublicKey) keyFac.generatePublic(pubKeySpec);

} catch (InvalidKeySpecException ex) {

throw new Exception(ex.getMessage());

}

/**

* 生成私钥

* @param modulus

* @param privateExponent

* @return RSAPrivateKey

* @throws Exception

private RSAPrivateKey generateRSAPrivateKey(byte[] modulus, byte[] privateExponent) throws Exception {

KeyFactory keyFac = null;

try {

keyFac = KeyFactory.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());

} catch (NoSuchAlgorithmException ex) {

throw new Exception(ex.getMessage());

}

RSAPrivateKeySpec priKeySpec = new RSAPrivateKeySpec(new BigInteger(modulus), new BigInteger(privateExponent));

try {

return (RSAPrivateKey) keyFac.generatePrivate(priKeySpec);

} catch (InvalidKeySpecException ex) {

throw new Exception(ex.getMessage());

}

/**

* 加密

* @param key 加密的密钥

* @param data 待加密的明文数据

* @return 加密后的数据

* @throws Exception

public byte[] encrypt(Key key, byte[] data) throws Exception {

try {

Cipher cipher = Cipher.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());

cipher.init(Cipher.ENCRYPT_MODE, key);

// 获得加密块大小，如:加密前数据为128个byte，而key_size=1024 加密块大小为127 byte,加密后为128个byte;

// 因此共有2个加密块，第一个127 byte第二个为1个byte

int blockSize = cipher.getBlockSize();

// System.out.println("blockSize:"+blockSize);

int outputSize = cipher.getOutputSize(data.length);// 获得加密块加密后块大小

// System.out.println("加密块大小："+outputSize);

int leavedSize = data.length % blockSize;

// System.out.println("leavedSize:"+leavedSize);

int blocksSize = leavedSize != 0 ? data.length / blockSize + 1 : data.length / blockSize;

byte[] raw = new byte[outputSize * blocksSize];

int i = 0;

while (data.length - i * blockSize 0) {

if (data.length - i * blockSize blockSize)

cipher.doFinal(data, i * blockSize, blockSize, raw, i * outputSize);

else

cipher.doFinal(data, i * blockSize, data.length - i * blockSize, raw, i * outputSize);

// 这里面doUpdate方法不可用，查看源代码后发现每次doUpdate后并没有什么实际动作除了把byte[]放到ByteArrayOutputStream中

// 而最后doFinal的时候才将所有的byte[]进行加密，可是到了此时加密块大小很可能已经超出了OutputSize所以只好用dofinal方法。

i++;

}

return raw;

} catch (Exception e) {

throw new Exception(e.getMessage());

}

/**

* 解密

* @param key 解密的密钥

* @param raw 已经加密的数据

* @return 解密后的明文

* @throws Exception

@SuppressWarnings("static-access")

public byte[] decrypt(Key key, byte[] raw) throws Exception {

try {

Cipher cipher = Cipher.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());

cipher.init(cipher.DECRYPT_MODE, key);

int blockSize = cipher.getBlockSize();

ByteArrayOutputStream bout = new ByteArrayOutputStream(64);

int j = 0;

while (raw.length - j * blockSize 0) {

bout.write(cipher.doFinal(raw, j * blockSize, blockSize));

j++;

}

return bout.toByteArray();

} catch (Exception e) {

throw new Exception(e.getMessage());

}

/**

* 返回公钥

* @return

* @throws Exception

public RSAPublicKey getRSAPublicKey() throws Exception{

//获取公钥

RSAPublicKey pubKey = (RSAPublicKey) keyPair.getPublic();

//获取公钥系数(字节数组形式)

byte[] pubModBytes = pubKey.getModulus().toByteArray();

//返回公钥公用指数(字节数组形式)

byte[] pubPubExpBytes = pubKey.getPublicExponent().toByteArray();

//生成公钥

RSAPublicKey recoveryPubKey = this.generateRSAPublicKey(pubModBytes,pubPubExpBytes);

return recoveryPubKey;

}

/**

* 获取私钥

* @return

* @throws Exception

public RSAPrivateKey getRSAPrivateKey() throws Exception{

// 获取私钥

RSAPrivateKey priKey = (RSAPrivateKey) keyPair.getPrivate();

// 返回私钥系数(字节数组形式)

byte[] priModBytes = priKey.getModulus().toByteArray();

// 返回私钥专用指数(字节数组形式)

byte[] priPriExpBytes = priKey.getPrivateExponent().toByteArray();

// 生成私钥

RSAPrivateKey recoveryPriKey = this.generateRSAPrivateKey(priModBytes,priPriExpBytes);

return recoveryPriKey;

}

/**

* 测试

* @param args

* @throws Exception

public static void main(String[] args) throws Exception {

RSAUtil rsa = new RSAUtil();

String str = "天龙八部、神雕侠侣、射雕英雄传白马啸西风";

RSAPublicKey pubKey = rsa.getRSAPublicKey();

RSAPrivateKey priKey = rsa.getRSAPrivateKey();

// System.out.println("加密后==" + new String(rsa.encrypt(pubKey,str.getBytes())));

String mw = new String(rsa.encrypt(pubKey, str.getBytes()));

System.out.println("加密后："+mw);

// System.out.println("解密后：");

System.out.println("解密后==" + new String(rsa.decrypt(priKey,rsa.encrypt(pubKey,str.getBytes()))));

}

Java中RSA的方式如何实现非对称加密的示例

代码如下，需要依赖一个jar包commons-codec-1.9.jar，用于Base64转换，请自行下载。

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

import javax.crypto.BadPaddingException;

import javax.crypto.Cipher;

import javax.crypto.IllegalBlockSizeException;

import java.io.ByteArrayOutputStream;

import java.io.UnsupportedEncodingException;

import java.security.*;

import java.security.interfaces.RSAPrivateKey;

import java.security.interfaces.RSAPublicKey;

import java.security.spec.PKCS8EncodedKeySpec;

import java.security.spec.X509EncodedKeySpec;

public class RSAUtils {

// 加密方式

public static final String ALGORITHM = "RSA";

// 签名算法

private static final String SIGNATURE_ALGORITHM = "SHA1WithRSA";

// 创建密钥对初始长度

private static final int KEY_SIZE = 512;

// 字符编码格式

private static final String CHARSET = "UTF-8";

// RSA最大加密明文大小

private static final int MAX_ENCRYPT_BLOCK = 117;

// RSA最大解密密文大小

private static final int MAX_DECRYPT_BLOCK = 128;

private KeyFactory keyFactory;

public RSAUtils() throws NoSuchAlgorithmException {

keyFactory = KeyFactory.getInstance(ALGORITHM);

}

/**

* 私钥加密

* @param content 待加密字符串

* @param privateKey 私钥

* @return 加密后字符串（BASE64编码）

public String encryptByPrivateKey(String content, String privateKey) throws Exception {

String result;

try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {

byte[] keyBytes = new Base64().decode(privateKey);

PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);

PrivateKey pKey = keyFactory.generatePrivate(pkcs8KeySpec);

Cipher cipher = Cipher.getInstance(ALGORITHM);

cipher.init(Cipher.ENCRYPT_MODE, pKey);

byte[] data = content.getBytes(CHARSET);

write2Stream(cipher, data, out);

byte[] resultBytes = out.toByteArray();

result = Base64.encodeBase64String(resultBytes);

} catch (Exception e) {

throw new Exception(e);

}

return result;

}

/**

* 公钥解密

* @param content 已加密字符串（BASE64加密）

* @param publicKey 公钥

* @return

public String decryptByPublicKey(String content, String publicKey) throws Exception {

String result = "";

try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {

byte[] keyBytes = new Base64().decode(publicKey);

X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);

PublicKey pKey = keyFactory.generatePublic(x509KeySpec);

Cipher cipher = Cipher.getInstance(ALGORITHM);

cipher.init(Cipher.DECRYPT_MODE, pKey);

byte[] data = Base64.decodeBase64(content);

write2Stream(cipher, data, out);

byte[] resultBytes = out.toByteArray();

result = new String(resultBytes);

} catch (Exception e) {

throw new Exception(e);

}

return result;

}

/**

* 公钥加密

* @param content 待加密字符串

* @param publicKey 公钥

* @return 加密后字符串（BASE64编码）

public String encryptByPublicKey(String content, String publicKey) throws Exception {

String result = "";

try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {

byte[] keyBytes = new Base64().decode(publicKey);

X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);

PublicKey pKey = keyFactory.generatePublic(x509KeySpec);

Cipher cipher = Cipher.getInstance(ALGORITHM);

cipher.init(Cipher.ENCRYPT_MODE, pKey);

byte[] data = content.getBytes(CHARSET);

write2Stream(cipher,

data, out);

byte[] resultBytes = out.toByteArray();

result = Base64.encodeBase64String(resultBytes);

} catch (Exception e) {

throw new Exception(e);

}

return result;

}

/**

* 私钥解密

* @param content 已加密字符串

* @param privateKey 私钥

* @return 解密后字符串

public String decryptByPrivateKey(String content, String privateKey) throws Exception {

String result = "";

try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {

byte[] keyBytes = new Base64().decode(privateKey);

PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);

PrivateKey pKey = keyFactory.generatePrivate(pkcs8KeySpec);

Cipher cipher = Cipher.getInstance(ALGORITHM);

cipher.init(Cipher.DECRYPT_MODE, pKey);

byte[] data = Base64.decodeBase64(content);

write2Stream(cipher, data, out);

byte[] resultBytes = out.toByteArray();

result = new String(resultBytes);

} catch (Exception e) {

throw new Exception(e);

}

return result;

}

private static void write2Stream(Cipher cipher, byte[] data, ByteArrayOutputStream out) throws

BadPaddingException, IllegalBlockSizeException {

int dataLen = data.length;

int offSet = 0;

byte[] cache;

int i = 0;

// 对数据分段解密

while (dataLen - offSet 0) {

if (dataLen - offSet MAX_DECRYPT_BLOCK) {

cache = cipher.doFinal(data, offSet, MAX_DECRYPT_BLOCK);

} else {

cache = cipher.doFinal(data, offSet, dataLen - offSet);

}

out.write(cache, 0, cache.length);

i++;

offSet = i * MAX_DECRYPT_BLOCK;

}

/**

* 用私钥对信息生成数字签名

* @param data 已加密数据

* @param privateKey 私钥(BASE64编码)

* @return sign

public String sign(String data, String privateKey) throws Exception {

String result = "";

try {

byte[] keyBytes = new Base64().decode(privateKey);

PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);

PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);

Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);

signature.initSign(privateK);

signature.update(parse2HexStr(data).getBytes(CHARSET));

result = new Base64().encodeToString(signature.sign());

} catch (Exception e) {

throw new Exception(e);

}

return result;

}

/**

* 校验数字签名

* @param data 已加密数据

* @param publicKey 公钥(BASE64编码)

* @param sign 数字签名

* @return

* @throws Exception

public boolean verify(String data, String publicKey, String sign) throws Exception {

boolean result;

try {

byte[] keyBytes = new Base64().decode(publicKey);

X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);

PublicKey publicK = keyFactory.generatePublic(keySpec);

Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);

signature.initVerify(publicK);

signature.update(parse2HexStr(data).getBytes(CHARSET));

result = signature.verify(new Base64().decode(sign));

} catch (Exception e) {

throw new Exception(e);

}

return result;

}

/**

* 将二进制转换成16进制

* @param data

* @return

public static String parse2HexStr(String data) throws Exception {

String result = "";

try {

byte[] buf = data.getBytes(CHARSET);

StringBuffer sb = new StringBuffer();

for (int i = 0; i buf.length; i++) {

String hex = Integer.toHexString(buf[i] 0xFF);

if (hex.length() == 1) {

hex = '0' + hex;

}

sb.append(hex.toUpperCase());

}

result = sb.toString();

} catch (UnsupportedEncodingException e) {

throw new Exception(e);

}

return result;

}

/**

* 生成公钥与私钥

public static void createKey() throws Exception {

try {

KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(ALGORITHM);

keyPairGenerator.initialize(KEY_SIZE);

KeyPair keyPair = keyPairGenerator.generateKeyPair();

RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();

RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();

String publicKey = Base64.encodeBase64String(rsaPublicKey.getEncoded());

String privateKey = Base64.encodeBase64String(rsaPrivateKey.getEncoded());

System.out.println("publicKey=" + publicKey + "\nprivateKey=" + privateKey);

} catch (NoSuchAlgorithmException e) {

throw new Exception(e);

}

public static void main(String[] args) throws Exception {

String PRIVATE_KEY = "MIICeAIBADANBgkqhkiG9w0BAQEFAASCAmIwggJeAgEAAoGBAKeYGXH6Vz+m+KuL11RDRaNdHB4YQeZgqpJGPRSwBelgvEoHu2/fNs1bmgfJhI8lhr/o/Hy8EFB/I/DDyLcCcU4bCLtxpki8edC+KJR2WvyYfnVmWEe/3q2jSVKRf81868q9Cd3MMfrQPMsY4x0TQ0GtOf/nMSMbAltV2W8J86IfAgMBAAECgYEApYu4lr2SMW3ddJZNvQ42W4g9nfyYG9igpJx8+VJmhIDpfLbmjzsOBwvUupx0NHH9CNQ7k3qxItJzzf+W5C+lesEOAqdO5nahRZsL8BIDoxTEn2j+1GXkzQw3vqPY50xqRnZsoP5TyNNsOM7KYaOoz4VFMdVIFwoT3OKM5z7mxgECQQD51r17WZDSa/kucaH7gCOePxJPS6Ust0eVd5tBOMpFzD/VtziogSIWyhGKkLH0SyTJEe91CCpdpxufLSZgIiN5AkEAq7ojtvU4twak1N1/1qX+t8f5wD8i/8GU702PeCwkGI5ymrARq+W2yCuvU1bouXBhjKHV4KhafKYixdHUMg00VwJAYVUjpLaUESY3gbyLWqvlNHVl8LaLtwwAO17JgXNaei7Ef8JNtHf6i95VTyJn8cCEqEDwhSuVNb8wp6azWKh0IQJBAJHrcT2d0bt0IcvfCynRk0eG3WnGPG8mhu9w8GAk4ecb47YdtmZio5YjyK8AQnCQVdOyEJL9eyY/5XxCeBSvs7ECQQCKQ2f5HLDkkHvc6rlaHCJmqNRCS+CxhoaiaSPYLAac7WXmb614ACLECc86C/nkefTq0SNpUDVbGxVpJi9/FOUf";

String PUBLIC_KEY = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCnmBlx+lc/pviri9dUQ0WjXRweGEHmYKqSRj0UsAXpYLxKB7tv3zbNW5oHyYSPJYa/6Px8vBBQfyPww8i3AnFOGwi7caZIvHnQviiUdlr8mH51ZlhHv96to0lSkX/NfOvKvQndzDH60DzLGOMdE0NBrTn/5zEjGwJbVdlvCfOiHwIDAQAB";

RSAUtils rsaUtil = new RSAUtils();

String encryptByPublicKey = rsaUtil.encryptByPublicKey("你好！", PUBLIC_KEY);

System.out.println(encryptByPublicKey);

String decryptByPrivateKey = rsaUtil.decryptByPrivateKey(encryptByPublicKey, PRIVATE_KEY);

System.out.println(decryptByPrivateKey);

String encryptByPrivateKey = rsaUtil.encryptByPrivateKey("你好！", PRIVATE_KEY);

System.out.println(encryptByPrivateKey);

String decryptByPublicKey = rsaUtil.decryptByPublicKey(encryptByPrivateKey, PUBLIC_KEY);

System.out.println(decryptByPublicKey);

String sign = rsaUtil.sign("1234", PRIVATE_KEY);

System.out.println("sign:" + sign);

System.out.println(rsaUtil.verify("1234", PUBLIC_KEY, sign));

}

求JAVA编写的RSA加密算法

代码如下：main方法用于测试的，不是算法本身。

import java.security.KeyPair;

import java.security.KeyPairGenerator;

import java.security.PrivateKey;

import java.security.PublicKey;

import java.security.SecureRandom;

import javax.crypto.Cipher;

public class RSACrypto

{

private final static String RSA = "RSA";

public static PublicKey uk;

public static PrivateKey rk;

public static void generateKey() throws Exception

{

KeyPairGenerator gen = KeyPairGenerator.getInstance(RSA);

gen.initialize(512, new SecureRandom());

KeyPair keyPair = gen.generateKeyPair();

uk = keyPair.getPublic();

rk = keyPair.getPrivate();

}

private static byte[] encrypt(String text, PublicKey pubRSA) throws Exception

{

Cipher cipher = Cipher.getInstance(RSA);

cipher.init(Cipher.ENCRYPT_MODE, pubRSA);

return cipher.doFinal(text.getBytes());

}

public final static String encrypt(String text)

{

try {

return byte2hex(encrypt(text, uk));

}

catch(Exception e)

{

e.printStackTrace();

}

return null;

}

public final static String decrypt(String data)

{

try{

return new String(decrypt(hex2byte(data.getBytes())));

}

catch (Exception e)

{

e.printStackTrace();

}

return null;

}

private static byte[] decrypt(byte[] src) throws Exception

{

Cipher cipher = Cipher.getInstance(RSA);

cipher.init(Cipher.DECRYPT_MODE, rk);

return cipher.doFinal(src);

}

public static String byte2hex(byte[] b)

{

String hs = "";

String stmp = "";

for (int n = 0; n b.length; n ++)

{

stmp = Integer.toHexString(b[n] 0xFF);

if (stmp.length() == 1)

hs += ("0" + stmp);

else

hs += stmp;

}

return hs.toUpperCase();

}

public static byte[] hex2byte(byte[] b)

{

if ((b.length % 2) != 0)

throw new IllegalArgumentException("长度不是偶数");

byte[] b2 = new byte[b.length / 2];

for (int n = 0; n b.length; n += 2)

{

String item = new String(b, n, 2);

b2[n/2] = (byte)Integer.parseInt(item, 16);

}

return b2;

}

//just for test

public static void main(String args[])

{

try

{

RSACrypto.generateKey();

String cipherText = RSACrypto.encrypt("asdfghjh");

System.out.println(cipherText);

String plainText = RSACrypto.decrypt(cipherText);

System.out.println(plainText);

}

catch(Exception e)

{

e.printStackTrace();

}

安卓rsa在java端怎么验签不过

java和安卓肯定是一样的,因为安卓也是java 你说不一样,那有可能是字符串编码格式不对例如安卓上用UTF-8 你服务器用GBK 那肯定是无法同步的你可以运行一行代码,测试一下你的系统编码是什么 String encoding = System.getProperty("file.encoding"); System.out.println("Encoding:" + encoding);

Java如何生成支付宝RSA2签名

对支付宝进行设置再回主页面进行转义，具体步骤如下。

支付宝APP支付（Java后台生成签名具体步骤）

/**

*支付宝支付

* @param orderId 订单编号

* @param actualPay 实际支付金额

* @return

private String getOrderInfoByAliPay(String orderId,float actualPay) {

//回调页面

String ali_call_back_url = propertiesService.ALI_CALL_BACK_URL;

String seller_id = propertiesService.SELLER_ID;//商户编号

String[] parameters={

"service=\"mobile.securitypay.pay\"",//固定值（手机快捷支付）

"partner=\"2088421544444\"",//合作身份者ID（16位）

"_input_charset=\"utf-8\"",

"notify_url=\""+ali_call_back_url+"\"",//通知地址

"out_trade_no=\""+orderId+"\"",//商户内部订单号

"subject=\"测试\"",//测试

"payment_type=\"1\"",//固定值

"seller_id=\""+seller_id+"\"",//账户邮箱

"total_fee=\""+"0.01"+"\"",//支付金额（元）

"body=\"订单说明\"",//订单说明

"it_b_pay=\"30m\""（订单过期时间 30分钟过期无效）

};

String signOrderUrl = signAllString(parameters);

return signOrderUrl;

}

/**

* 支付宝签名

* @param array

* @return

private String signAllString(String [] array){

StringBuffer sb = new StringBuffer("");

for (int i = 0; i array.length; i++) {

if(i==(array.length-1)){

sb.append(array[i]);

}else{

sb.append(array[i]+"");

}

System.out.println(sb.toString());

String sign = "";

try {

sign = URLEncoder.encode(RSA.sign(sb.toString(), AlipayConfig.private_key, "utf-8"), "utf-8");//private_key私钥

} catch (UnsupportedEncodingException e) {

e.printStackTrace();

}

sb.append("sign=\""+sign+"\"");

sb.append("sign_type=\"RSA\"");

return sb.toString();

}

package com.alipay.sign;

import javax.crypto.Cipher;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.InputStream;

import java.security.KeyFactory;

import java.security.PrivateKey;

import java.security.PublicKey;

import java.security.spec.PKCS8EncodedKeySpec;

import java.security.spec.X509EncodedKeySpec;

public class RSA{

public static final String SIGN_ALGORITHMS = "SHA1WithRSA";

/**

* RSA签名

* @param content 待签名数据

* @param privateKey 商户私钥

* @param input_charset 编码格式

* @return 签名值

public static String sign(String content, String privateKey, String input_charset)

{

try

{

byte[] decode = Base64.decode(privateKey);

PKCS8EncodedKeySpec priPKCS8 = new PKCS8EncodedKeySpec(decode );

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

PrivateKey priKey= keyf.generatePrivate(priPKCS8);

java.security.Signature signature = java.security.Signature.getInstance(SIGN_ALGORITHMS);

signature.initSign(priKey);

signature.update( content.getBytes(input_charset) );

byte[] signed = signature.sign();

return Base64.encode(signed);

}

catch (Exception e)

{

e.printStackTrace();

}

return null;

}

/**

* RSA验签名检查

* @param content 待签名数据

* @param sign 签名值

* @param ali_public_key 支付宝公钥

* @param input_charset 编码格式

* @return 布尔值

public static boolean verify(String content, String sign, String ali_public_key, String input_charset)

{

try

{

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

byte[] encodedKey = Base64.decode(ali_public_key);

PublicKey pubKey = keyFactory.generatePublic(new X509EncodedKeySpec(encodedKey));

java.security.Signature signature = java.security.Signature

.getInstance(SIGN_ALGORITHMS);

signature.initVerify(pubKey);

signature.update( content.getBytes(input_charset) );

boolean bverify = signature.verify( Base64.decode(sign) );

return bverify;

}

catch (Exception e)

{

e.printStackTrace();

}

return false;

}

/**

* 解密

* @param content 密文

* @param private_key 商户私钥

* @param input_charset 编码格式

* @return 解密后的字符串

public static String decrypt(String content, String private_key, String input_charset) throws Exception {

PrivateKey prikey = getPrivateKey(private_key);

Cipher cipher = Cipher.getInstance("RSA");

cipher.init(Cipher.DECRYPT_MODE, prikey);

InputStream ins = new ByteArrayInputStream(Base64.decode(content));

ByteArrayOutputStream writer = new ByteArrayOutputStream();

//rsa解密的字节大小最多是128，将需要解密的内容，按128位拆开解密

byte[] buf = new byte[128];

int bufl;

while ((bufl = ins.read(buf)) != -1) {

byte[] block = null;

if (buf.length == bufl) {

block = buf;

} else {

block = new byte[bufl];

for (int i = 0; i bufl; i++) {

block[i] = buf[i];

}

writer.write(cipher.doFinal(block));

}

return new String(writer.toByteArray(), input_charset);

}

/**

* 得到私钥

* @param key 密钥字符串（经过base64编码）

* @throws Exception

public static PrivateKey getPrivateKey(String key) throws Exception {

byte[] keyBytes;

keyBytes = Base64.decode(key);

PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);

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

PrivateKey privateKey = keyFactory.generatePrivate(keySpec);

return privateKey;

}

java script 怎么做rsa签名

由于项目要用到非对称加密解密签名校验什么的，于是参考《Java加密解密的艺术》写一个RSA进行加密解密签名及校验的Demo，代码很简单，特此分享！

RSA加密解密类：

package com.ihep;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.security.InvalidKeyException;

import java.security.KeyFactory;

import java.security.KeyPair;

import java.security.KeyPairGenerator;

import java.security.NoSuchAlgorithmException;

import java.security.SecureRandom;

import java.security.interfaces.RSAPrivateKey;

import java.security.interfaces.RSAPublicKey;

import java.security.spec.InvalidKeySpecException;

import java.security.spec.PKCS8EncodedKeySpec;

import java.security.spec.X509EncodedKeySpec;

import javax.crypto.BadPaddingException;

import javax.crypto.Cipher;

import javax.crypto.IllegalBlockSizeException;

import javax.crypto.NoSuchPaddingException;

import com.fcplay.Base64;

public class RSAEncrypt {

/**

* 字节数据转字符串专用集合

private static final char[] HEX_CHAR = { '0', '1', '2', '3', '4', '5', '6',

'7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };

/**

* 随机生成密钥对

public static void genKeyPair(String filePath) {

// KeyPairGenerator类用于生成公钥和私钥对，基于RSA算法生成对象

KeyPairGenerator keyPairGen = null;

try {

keyPairGen = KeyPairGenerator.getInstance("RSA");

} catch (NoSuchAlgorithmException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

// 初始化密钥对生成器，密钥大小为96-1024位

keyPairGen.initialize(1024,new SecureRandom());

// 生成一个密钥对，保存在keyPair中

KeyPair keyPair = keyPairGen.generateKeyPair();

// 得到私钥

RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();

// 得到公钥

RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();

try {

// 得到公钥字符串

String publicKeyString = Base64.encode(publicKey.getEncoded());

// 得到私钥字符串

String privateKeyString = Base64.encode(privateKey.getEncoded());

// 将密钥对写入到文件

FileWriter pubfw = new FileWriter(filePath + "/publicKey.keystore");

FileWriter prifw = new FileWriter(filePath + "/privateKey.keystore");

BufferedWriter pubbw = new BufferedWriter(pubfw);

BufferedWriter pribw = new BufferedWriter(prifw);

pubbw.write(publicKeyString);

pribw.write(privateKeyString);

pubbw.flush();

pubbw.close();

pubfw.close();

pribw.flush();

pribw.close();

prifw.close();

} catch (Exception e) {

e.printStackTrace();

}

/**

* 从文件中输入流中加载公钥

* @param in

* 公钥输入流

* @throws Exception

* 加载公钥时产生的异常

public static String loadPublicKeyByFile(String path) throws Exception {

try {

BufferedReader br = new BufferedReader(new FileReader(path

+ "/publicKey.keystore"));

String readLine = null;

StringBuilder sb = new StringBuilder();

while ((readLine = br.readLine()) != null) {

sb.append(readLine);

}

br.close();

return sb.toString();

} catch (IOException e) {

throw new Exception("公钥数据流读取错误");

} catch (NullPointerException e) {

throw new Exception("公钥输入流为空");

}

/**

* 从字符串中加载公钥

* @param publicKeyStr

* 公钥数据字符串

* @throws Exception

* 加载公钥时产生的异常

public static RSAPublicKey loadPublicKeyByStr(String publicKeyStr)

throws Exception {

try {

byte[] buffer = Base64.decode(publicKeyStr);

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

X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);

return (RSAPublicKey) keyFactory.generatePublic(keySpec);

} catch (NoSuchAlgorithmException e) {

throw new Exception("无此算法");

} catch (InvalidKeySpecException e) {

throw new Exception("公钥非法");

} catch (NullPointerException e) {

throw new Exception("公钥数据为空");

}

/**

* 从文件中加载私钥

* @param keyFileName

* 私钥文件名

* @return 是否成功

* @throws Exception

public static String loadPrivateKeyByFile(String path) throws Exception {

try {

BufferedReader br = new BufferedReader(new FileReader(path

+ "/privateKey.keystore"));

String readLine = null;

StringBuilder sb = new StringBuilder();

while ((readLine = br.readLine()) != null) {

sb.append(readLine);

}

br.close();

return sb.toString();

} catch (IOException e) {

throw new Exception("私钥数据读取错误");

} catch (NullPointerException e) {

throw new Exception("私钥输入流为空");

}

public static RSAPrivateKey loadPrivateKeyByStr(String privateKeyStr)

throws Exception {

try {

byte[] buffer = Base64.decode(privateKeyStr);

PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer);

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

return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);

} catch (NoSuchAlgorithmException e) {

throw new Exception("无此算法");

} catch (InvalidKeySpecException e) {

throw new Exception("私钥非法");

} catch (NullPointerException e) {

throw new Exception("私钥数据为空");

}

/**

* 公钥加密过程

* @param publicKey

* 公钥

* @param plainTextData

* 明文数据

* @return

* @throws Exception

* 加密过程中的异常信息

public static byte[] encrypt(RSAPublicKey publicKey, byte[] plainTextData)

throws Exception {

if (publicKey == null) {

throw new Exception("加密公钥为空, 请设置");

}

Cipher cipher = null;

try {

// 使用默认RSA

cipher = Cipher.getInstance("RSA");

// cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());

cipher.init(Cipher.ENCRYPT_MODE, publicKey);

byte[] output = cipher.doFinal(plainTextData);

return output;

} catch (NoSuchAlgorithmException e) {

throw new Exception("无此加密算法");

} catch (NoSuchPaddingException e) {

e.printStackTrace();

return null;

} catch (InvalidKeyException e) {

throw new Exception("加密公钥非法,请检查");

} catch (IllegalBlockSizeException e) {

throw new Exception("明文长度非法");

} catch (BadPaddingException e) {

throw new Exception("明文数据已损坏");

}

/**

* 私钥加密过程

* @param privateKey

* 私钥

* @param plainTextData

* 明文数据

* @return

* @throws Exception

* 加密过程中的异常信息

public static byte[] encrypt(RSAPrivateKey privateKey, byte[] plainTextData)

throws Exception {

if (privateKey == null) {

throw new Exception("加密私钥为空, 请设置");

}

Cipher cipher = null;

try {

// 使用默认RSA

cipher = Cipher.getInstance("RSA");

cipher.init(Cipher.ENCRYPT_MODE, privateKey);

byte[] output = cipher.doFinal(plainTextData);

return output;

} catch (NoSuchAlgorithmException e) {

throw new Exception("无此加密算法");

} catch (NoSuchPaddingException e) {

e.printStackTrace();

return null;

} catch (InvalidKeyException e) {

throw new Exception("加密私钥非法,请检查");

} catch (IllegalBlockSizeException e) {

throw new Exception("明文长度非法");

} catch (BadPaddingException e) {

throw new Exception("明文数据已损坏");

}

/**

* 私钥解密过程

* @param privateKey

* 私钥

* @param cipherData

* 密文数据

* @return 明文

* @throws Exception

* 解密过程中的异常信息

public static byte[] decrypt(RSAPrivateKey privateKey, byte[] cipherData)

throws Exception {

if (privateKey == null) {

throw new Exception("解密私钥为空, 请设置");

}

Cipher cipher = null;

try {

// 使用默认RSA

cipher = Cipher.getInstance("RSA");

// cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());

cipher.init(Cipher.DECRYPT_MODE, privateKey);

byte[] output = cipher.doFinal(cipherData);

return output;

} catch (NoSuchAlgorithmException e) {

throw new Exception("无此解密算法");

} catch (NoSuchPaddingException e) {

e.printStackTrace();

return null;

} catch (InvalidKeyException e) {

throw new Exception("解密私钥非法,请检查");

} catch (IllegalBlockSizeException e) {

throw new Exception("密文长度非法");

} catch (BadPaddingException e) {

throw new Exception("密文数据已损坏");

}

网站标题：rsa签名java代码 rsa签名验签
当前链接：http://pwwzsj.com/article/hjiogh.html

平武建站

rsa签名java代码 rsa签名验签

RSA PKCS#1在java中怎么实现？

Java中RSA的方式如何实现非对称加密的示例

求JAVA编写的RSA加密算法

安卓rsa在java端怎么验签不过

Java如何生成支付宝RSA2签名

java script 怎么做rsa签名

其他资讯