SHA256、RSA1024加密解密，加签验签

最新推荐文章于 2024-07-01 08:30:00 发布
最新推荐文章于 2024-07-01 08:30:00 发布
阅读量3.2k 收藏
点赞数 1
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lml58586/article/details/105055147
版权

package com.common.util;


import javax.crypto.Cipher;

import cat.util.charset.Base64;

import java.io.ByteArrayOutputStream;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;


/**
 * @author : lml
 * @Description: RSA工具类，支持长度为2048的秘钥
 * @date : 2020/3/23
 * @time : 16:29
 */
public class RSAUtils2048 {


    /**
     * 加密算法RSA
     */
    private static final String KEY_ALGORITHM = "RSA";

    /**
     * 签名算法
     */
    // public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
    private static final String SIGNATURE_ALGORITHM = "SHA256withRSA";

    /**
     * 获取公钥的key
     */
    private static final String PUBLIC_KEY = "RSAPublicKey";


    /**
     * 获取私钥的key
     */
    private static final String PRIVATE_KEY = "RSAPrivateKey";


    /**
     * RSA最大加密明文大小
     */
    private static final int MAX_ENCRYPT_BLOCK = 245;


    /**
     * RSA最大解密密文大小
     */
    private static final int MAX_DECRYPT_BLOCK = 256;


    public static void main(String[] args) {


        /*RSA  1024 */
//        String publicKey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCIarYvrIMZGHKa8f2E6ubg0//28R1zJ4ArD+XELXYvDrM8UBR42PqJCpjPN3hC91YAnnk2Y9U+X5o/rGxH5ZTZzYy+rkAmZFJa1fK2mWDxPYJoxH+DGHQc+h8t83BMB4pKqVPhcJVF6Ie+qpD5RFUU/e5iEz8ZZFDroVE3ubKaKwIDAQAB";
//        String privateKey = "MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAIhqti+sgxkYcprx/YTq5uDT//bxHXMngCsP5cQtdi8OszxQFHjY+okKmM83eEL3VgCeeTZj1T5fmj+sbEfllNnNjL6uQCZkUlrV8raZYPE9gmjEf4MYdBz6Hy3zcEwHikqpU+FwlUXoh76qkPlEVRT97mITPxlkUOuhUTe5sporAgMBAAECgYA0aSND37iifKUTaKOpXIKFoI23910EMAnrAXmaTIkafUBZjL7Ay0Q+QIcDHeGjgNlW9YvGXMbB5wMhMYKMgOUV1FpeqQdDslO4Z7zynRjkDJkjOKkE2/j10CvmNO8e2uCWKsYYUE9IyTkxcypjBCv16ifT0qmdxb7uKLccYI16eQJBANMutfNO/q7kUKiYvilBLN9+pZOg6eTmKmV0Xygoa3ClpQTfurwLA8W/Fv3oXnjHXTryNVHeoxSH69imo0RZ9kcCQQClXhMbXlfvl5iInmwziFhtYBztvkLuyQ084FgszR7iR0nuOWoURLQa5O7sLL724FNRlSvOCmmmWguh2vmQgRr9AkBDS5tHkWCvMqpRT3spgk9eWOlChgCCpKXV9qNsFJVILEDNsM28pnXpSd91wdp4+m7HHe/Hyv6EyFtrio50dYZ5AkAODVVwUO8GBArJKTUml+JzwOQUa8OCSQFf9+xmOjPypH4qySQzfrcTRfrrhM3haqSJ3TQwuP/LTAGLCnGEjwP9AkBqFFyrrQviPOhwel3NWjRv8mftOFgnm0Isk/NQJ4JtoahYvPDeUyP80WSuVWnPyV4zHz9Kw7BggYCPc4xZDACV";


        /*RSA 2048*/

        String publicKey = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAv3+Le3a9DL5hLDnOZllw9va/vQaPab75O++7vK/WZqv7H+sMniK/eHgHReykORy81slAgDVIbg54M8hr5KbYquuJfRcvl0xgytu6Dc3nUpCnMcb1OV5UJtampBc1CdLioQcoZx7GCzhi7rKpga2VQXNtJ7ez83xNvK10+EIdwqWvLpkLHKNURbD7aaz4axNu/LJImx649CRMEDRgzlbsmXqdjpqK11qjmkqUE8WYytr9RJEBE0GRdtTCYgrqUB6/n5MQv8jwCntdSR9z55l9Z8ZaA16UTq1Vyq4EKvcHSjr8WXEDkIcsZ5ekq+qdtSq9eTQOtLBr7s0AZJHVUhIJswIDAQAB";
        String privateKey = "MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQC/f4t7dr0MvmEsOc5mWXD29r+9Bo9pvvk777u8r9Zmq/sf6wyeIr94eAdF7KQ5HLzWyUCANUhuDngzyGvkptiq64l9Fy+XTGDK27oNzedSkKcxxvU5XlQm1qakFzUJ0uKhByhnHsYLOGLusqmBrZVBc20nt7PzfE28rXT4Qh3Cpa8umQsco1RFsPtprPhrE278skibHrj0JEwQNGDOVuyZep2OmorXWqOaSpQTxZjK2v1EkQETQZF21MJiCupQHr+fkxC/yPAKe11JH3PnmX1nxloDXpROrVXKrgQq9wdKOvxZcQOQhyxnl6Sr6p21Kr15NA60sGvuzQBkkdVSEgmzAgMBAAECggEACCWA5YuzlysyLxN2eFwtthPhLEVvLGx3ZdlY/znrwQpn8H+rVb7crl9Mz+i1Q8i5L9n36HxbzHLJIkrQbDW82eiTPMMTvzf8liSq0ZOE17pXooJ4RCyDH/PZuvlRxE04XulTCrAAdNG9Q7JOC7o6s0IZzqq9+Qm8tN4cL8OASJt49AqugaOG/+mLOhEc0jvOmJxWgxQAFoXrTWNiyb5hsrhQM8338GdLI0InfmrDPj+wFPjmaJfqDg99nxVWuNFVnLqRKaGM6lqWwQFHfFurv4mZU8WiZNpZUPVtBdCmrZM64ciQBf2hses/toqwZhjkyAfB9Ch+cGrERBSCPiO9oQKBgQDjV30IDHC+uv2OFCtD/js23s6jwpFCbk41zyG/xsI5xGVOHiqUn+gVs3UABhe4KDRNAskRhHhi/b05aY34DmYtwi/CsjjgiYqh9kka8Z8jlfkaGDSeyWrXzaRkW5UwfOfa6t7PQeqaf0rXMOn5v406tE9CEr2B4K/M9NrbkEIknwKBgQDXo1rzm5SXbgCi/m2bJG5dLK27q+FIA0O9ERQU/TB650NR/9kHoO4BXPuGC0SuOVZn1y1dPWbfUx6K8CLLflGBg8DKLaKO9iafFGUteHFXsEE7wKdfcEGO8oBxmfi/02S37VYrn/9mPcqh+d0cW5pO5Yhtgz08PnxEEfwuCUBObQKBgQC1armB1Lub2IhB+uJTzere7IolsDxOsMuEsRgTe76+bnURE42TMM/5kU2KiVIgSSUDV3ewnO+cvzNjP1JlYsgzN8T5L1OoCtowSOMptyrxMNqp8ir7k2vJbncDBvpUyTgUQF0xMz7Nr0q/0m7EOBGxiPW+mknT/MMNYU/M6p99rQKBgA/M1mM3KSIXW1CWF+3gM338QhaYN3+RTatSzwfirWS0AUjG2F4ouoe7Cmr99GBXry8YoyhL0XfXnUtM4R/L96jnwH6P7XNQMfBCDE/SnWtxbLY2HY1uqj8RIbwxLfrQQHcBmujDZnFVYb2Qk1T6mUnio6ZykVASvAQ41SOCZgXZAoGADeos1WxWRGSVgFY8CpHyHepCKI23TUf+Zrb9mcltaYmyKWNSg5eFVJm4UqSnwN8rlN7kPSIuM7lR+sRvwvDAT86HQmeyKjkwpHY+RQ2kGI8D9mRk1FHu/IvOBZlmgmlw55jwEaQazSXYI4uf1oo/pv/7Rok0DQO8jjzuCv6XUVE=";


        try {

            String data = "hello";

            byte[] publicEncryptBytes = RSAUtils2048.encryptByPublicKey(data.getBytes(), publicKey);
            System.out.println("公钥加密后的数据：" + Base64.encode(publicEncryptBytes));
            byte[] privatDecryptBytes = RSAUtils2048.decryptByPrivateKey(publicEncryptBytes, privateKey);
            System.out.println("私钥解密后的数据：" + new String(privatDecryptBytes));


            System.out.println("--------------------");

            byte[] privateKeyEncryptBytes = RSAUtils2048.encryptByPrivateKey(data.getBytes(), privateKey);
            System.out.println("私钥加密后的数据：" + Base64.encode(privateKeyEncryptBytes));

            String singnData = RSAUtils2048.sign(data.getBytes(), privateKey);
            System.out.println("私钥签名后的数据：" + singnData);


            byte[] publicDecryptBytes = RSAUtils2048.decryptByPublicKey(privateKeyEncryptBytes, publicKey);
            System.out.println("公钥解密后的数据：" + new String(publicDecryptBytes));

            boolean isSign = RSAUtils2048.verify(data.getBytes(), publicKey, singnData);
            System.out.println("签名是否正确：" + isSign);


        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /**
     * @param keySize 生成的秘钥长度  一般为1024或2048
     * @return
     * @throws Exception
     */
    public static Map<String, Object> genKeyPair(int keySize) throws Exception {
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        keyPairGen.initialize(keySize);
        KeyPair keyPair = keyPairGen.generateKeyPair();
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        Map<String, Object> keyMap = new HashMap<String, Object>(2);
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);

        System.out.println("publicKey：" + Base64.encode(publicKey.getEncoded()));
        System.out.println("privateKey：" + Base64.encode(privateKey.getEncoded()));

        return keyMap;
    }


    /**
     * 对已加密数据进行签名
     *
     * @param data       已加密的数据
     * @param privateKey 私钥
     * @return 对已加密数据生成的签名
     * @throws Exception
     */

    public static String sign(byte[] data, String privateKey) throws Exception {
        byte[] keyBytes = Base64.decode(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initSign(privateK);
        signature.update(data);
        return Base64.encode(signature.sign());
    }


    /**
     * 验签
     *
     * @param data      签名之前的数据
     * @param publicKey 公钥
     * @param sign      签名之后的数据
     * @return 验签是否成功
     * @throws Exception
     */
    public static boolean verify(byte[] data, String publicKey, String sign) throws Exception {
        byte[] keyBytes = Base64.decode(publicKey);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        PublicKey publicK = keyFactory.generatePublic(keySpec);
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initVerify(publicK);
        signature.update(data);
        return signature.verify(Base64.decode(sign));
    }


    /**
     * 用私钥对数据进行解密
     *
     * @param encryptedData 使用公钥加密过的数据
     * @param privateKey    私钥
     * @return 解密后的数据
     * @throws Exception
     */
    public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey) throws Exception {
        byte[] keyBytes = Base64.decode(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        //Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, privateK);

        int inputLen = encryptedData.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段解密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_DECRYPT_BLOCK;
        }
        byte[] decryptedData = out.toByteArray();
        out.close();


        return decryptedData;
    }

    /**
     * 公钥解密
     *
     * @param encryptedData 使用私钥加密过的数据
     * @param publicKey     公钥
     * @return 解密后的数据
     * @throws Exception
     */
    public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey) throws Exception {
        byte[] keyBytes = Base64.decode(publicKey);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key publicK = keyFactory.generatePublic(x509KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, publicK);
        int inputLen = encryptedData.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段解密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_DECRYPT_BLOCK;
        }
        byte[] decryptedData = out.toByteArray();
        out.close();
        return decryptedData;
    }


    /**
     * 公钥加密
     *
     * @param data      需要加密的数据
     * @param publicKey 公钥
     * @return 使用公钥加密后的数据
     * @throws Exception
     */
    public static byte[] encryptByPublicKey(byte[] data, String publicKey) throws Exception {
        byte[] keyBytes = Base64.decode(publicKey);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key publicK = keyFactory.generatePublic(x509KeySpec);
        // 对数据加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, publicK);
        int inputLen = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段加密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(data, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_ENCRYPT_BLOCK;
        }
        byte[] encryptedData = out.toByteArray();
        out.close();
        return encryptedData;
    }


    /**
     * 私钥加密
     *
     * @param data       待加密的数据
     * @param privateKey 私钥
     * @return 使用私钥加密后的数据
     * @throws Exception
     */
    public static byte[] encryptByPrivateKey(byte[] data, String privateKey) throws Exception {
        byte[] keyBytes = Base64.decode(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, privateK);
        int inputLen = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段加密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(data, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_ENCRYPT_BLOCK;
        }
        byte[] encryptedData = out.toByteArray();
        out.close();
        return encryptedData;
    }


    /**
     * 获取私钥
     *
     * @param keyMap 生成的秘钥对
     * @return
     * @throws Exception
     */
    public static String getPrivateKey(Map<String, Object> keyMap) throws Exception {
        Key key = (Key) keyMap.get(PRIVATE_KEY);
        return Base64.encode(key.getEncoded());
    }


    /**
     * 获取公钥
     *
     * @param keyMap 生成的秘钥对
     * @return
     * @throws Exception
     */
    public static String getPublicKey(Map<String, Object> keyMap) throws Exception {
        Key key = (Key) keyMap.get(PUBLIC_KEY);
        return Base64.encode(key.getEncoded());
    }
}
 

lml58586
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C# SHA256WithRSA加密帮助类
星火燎猿
06-11 2350
这篇文章接上一篇一起用，主要是实现SHA1/SHA256和RSA加解密算法。
android rsa签名验证,Android/Python如何验证签名SHA256withRSA和PKCS1填充
weixin_39996742的博客
05-29 702
我是新成员，我已经等了两天才找到从android客户端到python服务器的解决方案验证签名。首先，我创建密钥对并从私钥生成签名。谢谢你佩德罗布我已经更新了完整的代码。验证在python服务器中完成。在protected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentVi...
一文搞懂支付安全
最新发布
Karka_的博客
07-01 1661
在电子支付的万亿级市场中，安全无疑是核心中的核心。大部分人都知道支付安全很重要，但支付安全具体包括哪些方面，面临的问题，以及有哪些具体技术或方案来应对，包括在支付行业从业多年的老支付人，却未必有全局而清晰的认知。今天尝试从在线支付面临的主要安全问题，常见的技术手段如加密解密、签名验签、安全证书等入手，尝试讲清楚支付安全体系。在线支付面临的主要安全问题。常见的加密解密技术。常见的签名验签技术。安全身份认证体系。常见的安全协议。密钥存储与统一安全服务。工程应用中的常见问题。
sha256withrsa 的C语言实现
cxm19830125的专栏
08-16 1389
#include <string.h> #include <openssl/rsa.h> #include <openssl/pem.h> #include <openssl/err.h> #include <openssl/sha.h> #include <openssl/crypto.h> typedef unsigned char uint8_t; #define ERROR_SM_SUCCESS 0 ...
RSA_SHA256数字签名
热门推荐
gyqinag的专栏
01-15 2万+
原文链接：https://www.bbsmax.com/A/xl56xk2ozr/ RSA_SHA256数字签名 ------------------ rsa 加密与解密 ----------------------------- 数论知识的实际应用: rsa加密 把问题归结为对数字的加密。 被加密的数字为明文。 RSA加密通过公钥对明文进行加密， 得到密文。 网络中传输的都是密文。接收方收到密文...
接口数据使用了 RSA 加密和签名？一篇文章带你搞定
chinaherolts2008的博客
08-28 160
1、前言 很多童鞋在工作中，会遇到一些接口使用RSA加密和签名来处理的请求参数，那么遇到这个问题的时候，第一时间当然是找开发要加解密的方法，但是开发给加解密代码，大多数情况都是java,c++，js等语言实现的，加解密的代码虽然有了，但是咱们身为一个测试，使用python做的自动化，并不是什么语言都会，这个时候就会比较尴尬了，看着这一团加解密的代码，自己却不知从何下手，再去找开发给写个python版本的，开发估计不一定搭理你，就算搭理你，开发也未必会python，那么今天咱们就来讲讲如何通过python
C++使用Openssl进行RSA加密解密及签名验签功能（SHA256）
09-19
使用Openssl实现RSA的加密和解密过程；使用Openssl实现签名和验签过程；SHA256WithRSA签名验签过程；封装很好，一看就懂，直接使用!
RSA sha-256加密解密，加签验签工具类
01-14
在Spring框架中，我们经常需要处理加密解密和签名验证的问题，以确保数据传输的安全性和完整性。RSA与SHA-256结合使用可以提供更高级别的安全保护。RSA用于非对称加密，而SHA-256用于生成消息摘要，进行数字签名。 ...
java SHA256withRSA，json数据证书加签验签
08-31
这个"JAVA-SHA256withRSA.java"文件提供了一个完整的工具类RSAUtils，包含了加签、验签、公钥加密和私钥解密的功能。以下是关于这些知识点的详细解释： 1. **签名（Signing）**： 使用SHA256withRSA进行签名是将...
C# 实现与JAVA互通 加签/验签，RSA加密/解密
05-07
* RSA加密解密：私钥解密，公钥加密。 * RSA数字签名-俗称加签验签：私钥加签，公钥验签。  * RSA加密解密：私钥解密，公钥加密。 * RSA数字签名-俗称加签验签：私钥加签，公钥验签。  * RSA加密解密：私钥...
Python3.7 基于 pycryptodome 的AES加密解密、RSA加密解密、加签验签
09-18
本文将详细介绍如何使用Python 3.7及pycryptodome库进行AES和RSA加密解密以及加签验签操作。pycryptodome是一个强大的密码学库，提供了多种加密算法和签名机制。 首先，我们来看AES加密解密。AES（Advanced ...
RSA加密解密与签名验证
10-01
利用RSA算法进行加密解密与签名验证，基于VC6.0开发，使用MFC。
rsa算法SHA256算法
11-21
1.主要解决同一套Java代码实现RSA加解密算吗，在.net和Android上使用时解密出来的结果不同的问题。（代码中兼容.net和Android） 2。代码中包含SHA256签名验签。 3.解密时还有点问题，
rsa 2048 java_使用SHA-256和RSA 2048进行加密和签名
weixin_33631836的博客
02-19 5310
介绍由于SHA-1和RSA-1024已过时且安全性较低，因此SHA-256和RSA 2048是当前的标准。SHA-256是一种非常好的安全散列算法，非常适合在证书上使用，而2048位RSA是一种很好的签名算法(注意签名与加密不同)。使用带有SHA-256的2048位RSA是证书的安全签名方案。这将允许您生成可用于加密和解密数据的公钥和私钥。为了演示这个我创建了测试类，你可以按照指南并检查下面的代码...
C# 微信证书签名，WECHATPAY2-SHA256-RSA2048 签名方式
小枪 bolg ---hello，wrold
05-15 2791
今日在做微信支付对接相关事宜，需要用到证书做签名 C#相关读取证书，获得证书私钥，再去做RSA256签名，代码如下 public static class WeChartPaySecurityHelper { /// <summary> /// 调用签名方法 sha256方式 /// </summary> ...
关于RSASSA-PSS-2048-SHA256签名
yjmAndroid的博客
07-30 5050
最近做了一个项目,其中需要用到一个RSASSA-PSS-2048-SHA256算法,对上送的数据进行签名,在网上找了许多,没有找到合适自己的,现在项目,做的差不多了,就想着把这个给整理一下,小弟菜鸟一枚,文档中如若有不正确之处,请帮忙指出,谢谢 好了,废话不多说,直接上代码吧   /** * SHA256WithRSA签名 * * @param data ...
关于RSA算法密钥长度/密文长度/明文长度
hjxisking的专栏
08-18 2471
zhuanzai 1.密钥长度 rsa算法初始化的时候一般要填入密钥长度,在96-1024bits间 (1)为啥下限是96bits(12bytes)?因为加密1byte的明文,需要至少1+11=12bytes的密钥(不懂?看下面的明文长度),低于下限96bits时,一个byte都加密不了,当然没意义啦 (2)为啥上限是1024(128bytes)?这是算法本身决定的...当然如果某天网上出
数字签名算法之RSA
虎哥LoveDroid
10-21 6486
数字签名算法之RSA1.数字签名简述2. 模型分析3. 代码实现3.1 签名算法实现3.2 测试代码3.3 运行结果 1.数字签名简述 数字签名算法可以看做是一种带有密钥的消息摘要算法，并且这种密钥包含了公钥和私钥。也就是说数字签名算法是非对称加密算法和消息摘要算法的结合体。 数字签名算法是公钥基础设施（PKI）以及许多网络安全机制（SSL/TLS、VPN等）的基础。 数字签名算法能够验证数据的完整性、认证性以及抗否认性。 数字签名算法遵循“私钥签名，公钥验证” 的签名/验证方式。 数字签名算法主要包括 R
RSA算法密钥长度的选择
u013758702的专栏
01-12 8531
RSA算法密钥长度的选取直接关系到加解密、签名验签的安全强度和运算速度。密钥的长度实际上是指公钥模N的长度（以Bit为单位），理论上来讲N越大，安全强度越高，算法运算速度越慢。因此，RSA算法密钥长度要结合项目的实际情况来选取，以求在安全性和运算性能之间取得平衡点。例如：有些产品的应用场景要求RSA加解密必须具有很高的实时性，比如公交刷卡机。如果RSA运算时间过长会导致刷卡交易整体时间延长，用户刷卡体验变差，上下车客流速度变慢，因此这种应用场景不适合选取过高的公钥模长。有些PC端产品依托于强...
sha256加密解密Java
06-11
SHA-256是一种哈希算法，不是加密算法，所以不能进行解密。它将任意长度的消息输入并输出一个256位的哈希值，但哈希值不能被还原回原始消息。 在Java中，可以使用java.security.MessageDigest类来计算SHA-256哈希值...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值