「rsa签名java」rsa签名原理

博主：adminadmin 2022-11-26 08:25:08 60

本篇文章给大家谈谈rsa签名java，以及rsa签名原理对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

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端怎么验签不过

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

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如何生成支付宝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使用RSA加密的密串和签名如何在C#里解密和验签

你好，你需要知道RSA的秘钥和签名的算法。

首先你需要有RSA的私钥，利用私钥将encrypt的部分进行解密。然后利用签名的算法对解密的结果做一次签名的运算，如何结果和发送过来的sign一样的话，签名就是没有问题的。

C#有RSA和签名算法的库，所以你重要的是有秘钥和知道签名的算法。

rsa签名java的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于rsa签名原理、rsa签名java的信息别忘了在本站进行查找喔。

The End

发布于：2022-11-26，除非注明，否则均为首码项目网原创文章，转载请注明出处。

标签：