RSA加密及验证签名

最新推荐文章于 2024-05-15 13:48:06 发布
最新推荐文章于 2024-05-15 13:48:06 发布
阅读量3.1k 收藏
点赞数
分类专栏： java加密解密 文章标签： rsa 加密
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guishengbin/article/details/51916790
版权

首先创建密钥工具类

import java.security.Key;  
import java.security.KeyFactory;  
import java.security.KeyPair;  
import java.security.KeyPairGenerator;  
import java.security.PrivateKey;  
import java.security.PublicKey;  
import java.security.Signature;  
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;  
 
import javax.crypto.Cipher;  
 
/**
 * RSA安全编码组件
 *  
 * @author 梁栋
 * @version 1.0
 * @since 1.0
 */  
public abstract class RSACoder extends Coder {  
    public static final String KEY_ALGORITHM = "RSA";  
    public static final String SIGNATURE_ALGORITHM = "MD5withRSA";  
 
    private static final String PUBLIC_KEY = "RSAPublicKey";  
    private static final String PRIVATE_KEY = "RSAPrivateKey";  
 
    /**
     * 用私钥对信息生成数字签名
     *  
     * @param data
     *            加密数据
     * @param privateKey
     *            私钥
     *  
     * @return
     * @throws Exception
     */  
    public static String sign(byte[] data, String privateKey) throws Exception {  
        // 解密由base64编码的私钥  
        byte[] keyBytes = decryptBASE64(privateKey);  
 
        // 构造PKCS8EncodedKeySpec对象  
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);  
 
        // KEY_ALGORITHM 指定的加密算法  
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  
 
        // 取私钥匙对象  
        PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);  
 
        // 用私钥对信息生成数字签名  
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);  
        signature.initSign(priKey);  
        signature.update(data);  
 
        return encryptBASE64(signature.sign());  
    }  
 
    /**
     * 校验数字签名
     *  
     * @param data
     *            加密数据
     * @param publicKey
     *            公钥
     * @param sign
     *            数字签名
     *  
     * @return 校验成功返回true 失败返回false
     * @throws Exception
     *  
     */  
    public static boolean verify(byte[] data, String publicKey, String sign)  
            throws Exception {  
 
        // 解密由base64编码的公钥  
        byte[] keyBytes = decryptBASE64(publicKey);  
 
        // 构造X509EncodedKeySpec对象  
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);  
 
        // KEY_ALGORITHM 指定的加密算法  
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  
 
        // 取公钥匙对象  
        PublicKey pubKey = keyFactory.generatePublic(keySpec);  
 
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);  
        signature.initVerify(pubKey);  
        signature.update(data);  
 
        // 验证签名是否正常  
        return signature.verify(decryptBASE64(sign));  
    }  
 
    /**
     * 解密<br>
     * 用私钥解密
     *  
     * @param data
     * @param key
     * @return
     * @throws Exception
     */  
    public static byte[] decryptByPrivateKey(byte[] data, String key)  
            throws Exception {  
        // 对密钥解密  
        byte[] keyBytes = decryptBASE64(key);  
 
        // 取得私钥  
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);  
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  
        Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);  
 
        // 对数据解密  
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());  
        cipher.init(Cipher.DECRYPT_MODE, privateKey);  
 
        return cipher.doFinal(data);  
    }  
 
    /**
     * 解密<br>
     * 用公钥解密
     *  
     * @param data
     * @param key
     * @return
     * @throws Exception
     */  
    public static byte[] decryptByPublicKey(byte[] data, String key)  
            throws Exception {  
        // 对密钥解密  
        byte[] keyBytes = decryptBASE64(key);  
 
        // 取得公钥  
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);  
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  
        Key publicKey = keyFactory.generatePublic(x509KeySpec);  
 
        // 对数据解密  
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());  
        cipher.init(Cipher.DECRYPT_MODE, publicKey);  
 
        return cipher.doFinal(data);  
    }  
 
    /**
     * 加密<br>
     * 用公钥加密
     *  
     * @param data
     * @param key
     * @return
     * @throws Exception
     */  
    public static byte[] encryptByPublicKey(byte[] data, String key)  
            throws Exception {  
        // 对公钥解密  
        byte[] keyBytes = decryptBASE64(key);  
 
        // 取得公钥  
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);  
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  
        Key publicKey = keyFactory.generatePublic(x509KeySpec);  
 
        // 对数据加密  
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());  
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);  
 
        return cipher.doFinal(data);  
    }  
 
    /**
     * 加密<br>
     * 用私钥加密
     *  
     * @param data
     * @param key
     * @return
     * @throws Exception
     */  
    public static byte[] encryptByPrivateKey(byte[] data, String key)  
            throws Exception {  
        // 对密钥解密  
        byte[] keyBytes = decryptBASE64(key);  
 
        // 取得私钥  
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);  
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  
        Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);  
 
        // 对数据加密  
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());  
        cipher.init(Cipher.ENCRYPT_MODE, privateKey);  
 
        return cipher.doFinal(data);  
    }  
 
    /**
     * 取得私钥
     *  
     * @param keyMap
     * @return
     * @throws Exception
     */  
    public static String getPrivateKey(Map<String, Object> keyMap)  
            throws Exception {  
        Key key = (Key) keyMap.get(PRIVATE_KEY);  
 
        return encryptBASE64(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 encryptBASE64(key.getEncoded());  
    }  
 
    /**
     * 初始化密钥
     *  
     * @return
     * @throws Exception
     */  
    public static Map<String, Object> initKey() throws Exception {  
        KeyPairGenerator keyPairGen = KeyPairGenerator  
                .getInstance(KEY_ALGORITHM);  
        keyPairGen.initialize(1024);  
 
        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);  
        return keyMap;  
    }  
}


测试类1

import static org.junit.Assert.*;  
 
import org.junit.Before;  
import org.junit.Test;  
 
import java.util.Map;  
 
/**
 *
 * @author Administrator
 *
 */
public class RSACoderTest {  
    private String publicKey;  
    private String privateKey;  
 
    @Before  
    public void setUp() throws Exception {  
        Map<String, Object> keyMap = RSACoder.initKey();  
 
        publicKey = RSACoder.getPublicKey(keyMap);  
        privateKey = RSACoder.getPrivateKey(keyMap);  
        System.err.println("公钥: \n\r" + publicKey);  
        System.err.println("私钥： \n\r" + privateKey);  
    }  
 
    @Test  
    public void test() throws Exception {  
        System.err.println("公钥加密——私钥解密");  
        String inputStr = "abc";  
        byte[] data = inputStr.getBytes();  
 
        byte[] encodedData = RSACoder.encryptByPublicKey(data, publicKey);  
 
        byte[] decodedData = RSACoder.decryptByPrivateKey(encodedData,  
                privateKey);  
 
        String outputStr = new String(decodedData);  
        System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);  
        assertEquals(inputStr, outputStr);  
 
    }  
 
    @Test  
    public void testSign() throws Exception {  
        System.err.println("私钥加密——公钥解密");  
        String inputStr = "sign";  
        byte[] data = inputStr.getBytes();  
 
        byte[] encodedData = RSACoder.encryptByPrivateKey(data, privateKey);  
 
        byte[] decodedData = RSACoder  
                .decryptByPublicKey(encodedData, publicKey);  
 
        String outputStr = new String(decodedData);  
        System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);  
        assertEquals(inputStr, outputStr);  
 
        System.err.println("私钥签名——公钥验证签名");  
        // 产生签名  
        String sign = RSACoder.sign(encodedData, privateKey);  
        System.err.println("签名:\r" + sign);  
 
        // 验证签名  
        boolean status = RSACoder.verify(encodedData, publicKey, sign);  
        System.err.println("状态:\r" + status);  
        assertTrue(status);  
 
    }  
 
}

测试类2

import static org.junit.Assert.assertEquals;

import java.util.Map;


public class TestRSA {
 
    //public static String publicKey ="MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC0zZOPn7telqqE7c1m2gVXDNXe6bMRhDVOM1AeBXs8is2AB+TkPuhqfJldgGarmismkM2o9D8WppdYDYFcZh4trCW+DDIPzvO0BAVc8DFnZ3lZi8gaNTuRLeNfAynjgKcLGoGG1YZf8SVXAmQlh0wBWcTpyQSc9zK5c5udWHX6fQIDAQAB";  
    //public static String privateKey ="sxGENU4zUB4FezyKzYAH5OQ+6Gp8mV2AZquaKyaQzaj0Pxaml1gNgVxmHi2sJb4MMg/O87QEBVzwMWdneVmLyBo1O5Et418DKeOApwsagYbVhl/xJVcCZCWHTAFZxOnJBJz3Mrlzm51Ydfp9AgMBAAECgYA8ofxsW+rgC7LfpUgOx+qmiL1oZgMRSr79nKOvjbMIWJwV5Y/TI22Z2HMuMhM8VRVHd6QglthZZkC23MCXFf/kSuYd6mPTcON8rt7Hj8304dk0hvdsWiGj+mO6Pr9TtAStBduTsQ3b/fnO9OcpOcrNMJF/2nZq+BkZWsptzVaXmQJBAP2rBxGOAU4XZxXpzqbIjLn9nyAlKR9fWEvm9Qoq9Z/NywKLbxY3JKWAnT3mBQKJ8d/qkO8SUOZ+opY8trMIuCMCQQC2dxIzTL7AtEJ3Td7EiODUgM1nm1rsplBdY3HjQ/8l9qk+4cisWg1Vl9r6uXXjLS/7NSxhMzTbPQGksaoyG1zfAkEA0qN2FymoA8SDITspEm1uDfOAcxzobNirZTu/NlY96Bjm/pHyCKx5jcSizYd3mYgahSkueJbo/r0hHUgFHd2bqQJAcT1qpT3O8MeurF4+j9inOBsL324SOuZo39yU1MfhdM0lcmor4ZMtzV4mQA6TtD7aFVyFw3lFJ38wIudESj6jHwJBAISkN5kwbcp4nIY1Vj8ISav4guHRPAACPwbWONBpihhkMP4MOpHCJyeEuK818Yhk6ox05D2F0qbO98cwENK3k74=";
    
    
    //public static String publicKey1 ="MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDYEiPZ9sEdFmU5GCjOMshW9cKQyJdZWDOSUP4WKXPDsb7a7k+nIZhfO6Sr64sk+Krm/w3nfyBGNdfVdpR+Cqj98nAmBNKgfPFTeVlbzHb0r87pEPI6UQsn8L0PUPABnjHXwngUnet/+nNVTuZMAWX3MPeol0gtybDGFZMdnw8zzQIDAQAB";  
    //public static String privateKey1 = "MIICeAIBADANBgkqhkiG9w0BAQEFAASCAmIwggJeAgEAAoGBANgSI9n2wR0WZTkYKM4yyFb1wpDIl1lYM5JQ/hYpc8OxvtruT6chmF87pKvriyT4qub/Ded/IEY119V2lH4KqP3ycCYE0qB88VN5WVvMdvSvzukQ8jpRCyfwvQ9Q8AGeMdfCeBSd63/6c1VO5kwBZfcw96iXSC3JsMYVkx2fDzPNAgMBAAECgYEAnKWiGk57uPPYlOkABGXquqjX0xGqMFryoJxZaYXJ6NF/Vce6Naf0iO57tyxAJ6Ckfm3hDbkrk9tLS/X5N9vQoV14A4GUjpeW/FR/edh3ernYLHLu58npVvNAq142svLMpPmfHhvmRrII88UDAROA5zYPtVWLSfR7kf7o/CjOF2ECQQD8a3vx6u7DqKo6R+gMrnTbOnP4jHZra6ZWs/wtvjkmnm/+SMbp3vu9gex6Fb0FAj6fCkkDAWY7+y1X3VKOEGl5AkEA2yKs9sjlP5e/ITsApqmgBDy//kkN18UT2E/epfHWYbEjNUBeZ/D7DXMfCZdi0VbrrkeBzswtpCXFr2ZTQ+6b9QJBAMpmTT5QCR/ucIDHA7SXdrALEM6too7EBN7k90Kekyj6Rgb5yDXjTKxKL5o9MBGCGUBheOXmC1nxMAySNQ4g7tECQQCqIVzJ6KTbX3PbV9SkkDMUtxmUUaF2sKI8oZ3Jll2L0Rv1nvjsl9JB2evx5V+qCWLHFus345tXwp+dEsN4jUr1AkBDClmM0BtXv/6lN8ddM/M1lDulU5xpHwLm3tOrHA1m9ia4dQzJngqduk+U8yolQqDscmfBztYxD81p3NKMkmV4";
    
    
 /*   static {
       Map<String, Object> keyMap;
    try {
        keyMap = RSACoder.initKey();
        String publicKey = RSACoder.getPublicKey(keyMap);  
        String privateKey = RSACoder.getPrivateKey(keyMap);  
        
        keyMap = RSACoder.initKey();
        
        String publicKey1 = RSACoder.getPublicKey(keyMap);  
        String privateKey1 = RSACoder.getPrivateKey(keyMap);
        
        System.err.println("publicKey公钥: \n\r" + publicKey);  
        System.err.println("privateKey私钥： \n\r" + privateKey);
        System.err.println("publicKey1公钥: \n\r" + publicKey1);  
        System.err.println("privateKey1私钥： \n\r" + privateKey1);
    } catch (Exception e) {
        e.printStackTrace();
    }  
    }*/
    
    public static void main(String[] args) throws Exception {

       /* Map<String, Object> keyMap;
        keyMap = RSACoder.initKey();
        String publicKey = RSACoder.getPublicKey(keyMap);  
        String privateKey = RSACoder.getPrivateKey(keyMap);  
        System.err.println("publicKey公钥: \n\r" + publicKey);  
        System.err.println("privateKey私钥： \n\r" + privateKey); */
        
        String publicKey ="MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCoBXQRscFTEBfJ9/LY9gmHfIHUd4j6rabI47mZ0sMJ/GM8je6XJ/xvtVp56oPqbnYyK0IrN1uTm3nP/JOPFqESZKRrjsOOnRSgDNZftAyL8J6/2B3UnjG+1dMi6FBHQzlc6Xz+J4h6dnVLrBRwuzpLEvhlRiOhnyxctRYHvWM8awIDAQAB";
        
        String privateKey ="MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAKgFdBGxwVMQF8n38tj2CYd8gdR3iPqtpsjjuZnSwwn8YzyN7pcn/G+1Wnnqg+pudjIrQis3W5Obec/8k48WoRJkpGuOw46dFKAM1l+0DIvwnr/YHdSeMb7V0yLoUEdDOVzpfP4niHp2dUusFHC7OksS+GVGI6GfLFy1Fge9YzxrAgMBAAECgYBpBu+k194mk9qq7wioQjN2s4dcTlQbjkzBKkgsNSihp1hI09eeOOp80Xn613MaKW5Msemspe/idr9QGWwLd3O6zGNWI91kArvalnzNvL6aTt5eSix6+jTdBF1+WG4SP1sXlpAo4Kw2JnUkEvprcoV1Uzh1Wsf5lDuKx1eAQYk9YQJBAOpMX0Cb58TvFEihhdLEqnGgtNRItf6idHFUJEbMJ+EZk+/lzuZIjgPPH01gF63CdXpxixJyy4BEElWXsUbG4okCQQC3lYknjQzXUpf2ZyRvNTbpb16DCLelhbjLMLoHaTwbkEmlUSX53ahqh5yqTYXT4iUOD5danT/hAmr5qBvwvvpTAkBe7MJKst+b8iENrCND2VoU3z9kInFZ0QfMQoLQDDa8BFjjgP/qXMrs0CWme6AcTgS6rvXha5D3Tpz/AI5aVonBAkBCFLtn1ye2Ie69LOc6eGcpo4Lbm7mvBPE9gm6T2FdgfJFlxk3rINRMdD/6NSlk2VQJOad7YHrr3VjwQIi+IaAtAkBQZJvlZZ9zIFR727Q3xqF3yAkTCBfZ9SGQ6bTs3yTEklvEsjvcLrtn03CqmKNYlxEBMh6HNlqAosfLmBxZKl6a";
 
        String publicKey1 ="MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCFFbjhwKVYJFny1PkHEQ+4d8z8ImJQIAN2tlcM9HQWjdY7OTZZQp3SrSpDbqhAlB0PWcEMmE3d3q1P5lX6CK201EF3m0j1dm2AaUiU28C4pcbv5MU6jw4xkIkkLJiPt7WeCUqep4Uo7A96D3cOZSbN9v7J0jqGh/5DGBN3hwVnKwIDAQAB";
        
        String privateKey1 ="MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAIUVuOHApVgkWfLU+QcRD7h3zPwiYlAgA3a2Vwz0dBaN1js5NllCndKtKkNuqECUHQ9ZwQyYTd3erU/mVfoIrbTUQXebSPV2bYBpSJTbwLilxu/kxTqPDjGQiSQsmI+3tZ4JSp6nhSjsD3oPdw5lJs32/snSOoaH/kMYE3eHBWcrAgMBAAECgYBfbYkJj4rAHijFYANFFu3P10+MB9e5Hot9Rxg6eNr5BTF1e/vFm2fxliu0+Jb633nK9Q/hSSCklDRwE3jY9fofpA2BabFYF/G/TV7qAPtLxnEQfMoBNwWPxwCaWP5rT0eUeVxZGkSMxkk8mSmhwLEAgtFWS4xCnY51A/c0f3LZeQJBAMESQCvJqiIiZnaneyxsxdcf0U8FwPj1yrZQ5v9GT2xZln90SPH9f8G7CHpMObmRNn718xMn1DCcOO2oOOtviCUCQQCwdj11o1Y9QZlwEgnRB9zl+ZX/YUvloFe/oLYmKhWN0jCNyw5CnUFDh83x5Tt/bWG2dw9XotQxoAfPXb+PbKkPAkBA11pJ2m6TDC6RRuotH1LKTttCyNHoStQLqtwJe5mM8AGFSI5/Bv3zGFdei18PnV9KAFvkYQn4UV8lIcwL9ecpAkAE9P1a/aChjeMyi78s2QyyhSVajDAmni942ZnkTpBWcI4enZKj+mjn7buyTN80AC2bg5Kxwog1cKpnf9muvL2vAkEAwOzzvLAbtOY6YoMnOlnDFK82JXit7jn0HyhyXyTLMBfimyzUKsb33Zb9f84ml3/e1usxjfFt25ex2d8BrP+t+A==";
 
        
        /*      System.err.println("公钥加密——私钥解密");  
        String inputStr = "abc";  
        byte[] data = inputStr.getBytes();  
 
        byte[] encodedData = RSACoder.encryptByPublicKey(data, publicKey);  
 
        byte[] decodedData = RSACoder.decryptByPrivateKey(encodedData,  
                privateKey);  
 
        String outputStr = new String(decodedData);  
        System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);  
        assertEquals(inputStr, outputStr); */
        
        
        
        System.err.println("私钥加密——公钥解密");  
        String inputStr = "sign";  
        byte[] data = inputStr.getBytes();  
 
        //发送方
        byte[] encodedData = RSACoder.encryptByPrivateKey(data, privateKey);  
 
        //接收方
        byte[] decodedData = RSACoder  
                .decryptByPublicKey(encodedData, publicKey);  
        String outputStr = new String(decodedData);  
        System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);  
        assertEquals(inputStr, outputStr);  
 
        //发送方使用私钥签名
        System.err.println("私钥签名——公钥验证签名");  
        // 产生签名  
        String sign = RSACoder.sign(encodedData, privateKey);  
        System.err.println("签名:\r" + sign);  
 
        //接收方使用公钥验证签名
        // 验证签名  
        boolean status = RSACoder.verify(encodedData, publicKey, sign);  
        System.err.println("状态:\r" + status);
        
        
        //接收方使用私钥签名
        System.err.println("私钥签名——公钥验证签名");  
        // 产生签名  
        String sign1 = RSACoder.sign(encodedData, privateKey1);  
        System.err.println("签名:\r" + sign);  
 
        //发送方使用公钥
        // 验证签名  
        boolean status1 = RSACoder.verify(encodedData, publicKey1, sign);  
        System.err.println("状态:\r" + status);
    }

}


guishengbin
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【网络安全】使用mbedtls 实现 RSA 签名、验签、加密、解密
weixin_45880295的博客
03-05 1190
使用 mbedtls 实现 RSA 的应用场景
mbedtls学习（9）数字签名RSA、DSA、ECDSA
jiang_2018的博客
11-23 9340
数字签名作用 数字签名是为了识别消息是否被篡改并验证消息可靠性，也可以防止否认。这里注意下和消息验证码的不同，数字签名还可以防止否认，因为数字签名的私钥只有签名者才持有，而消息认证码中的密钥是双方都有。mnedtls中的数字签名有3种，RSA、DSA、ECDSA RSA数字签名 RSA数字签名是基于RSA密钥系统，主要步骤如下 Alice生成RSA密钥对 Alice将公钥发送给Bob，自己保留私...
转载：RSA加密、解密、签名、验签的原理及方法
最新发布
三血狼
05-15 150
RSA加密
QT 中使用 rsa 加密 签名
qq_22878985的博客
12-13 2116
QT rsa 加密 签名
mbedtls RSA PSS加密验签.pdf
08-05
本文介绍如何使用mbedtls编译生成RSA 4096长度的公私钥，再使用私钥进行PSS签名，公钥验签
RSA的公钥和私钥验证
dabao87的博客
10-17 2442
1，如果私钥在一行，openssl_pkey_get_private()就会返回false，所以我们要修改格式 $privateKey = "MIICXgIBAAKBgQDjI484irh8X8+/ahon/+frln74K7azpwHrvei70c2cpjFoW4ghkfQmhBkcqNj/OCyGAcDDw30v/PActXlPGqxT79E7zobAU4PbikkEoqnY440E4D...
C#自定义RSA加密解密及RSA签名和验证类实例
09-03
本文将深入解析如何在C#中自定义RSA加密解密以及签名和验证类。通过实例代码，我们可以理解C#中RSA算法的实现原理和操作步骤。 首先，为了使用RSA算法，我们需要生成一对密钥：一个公钥和一个私钥。在`RSACryption`...
Python下实现的RSA加密/解密及签名/验证功能示例
09-21
RSA算法是一种非对称加密算法，它在信息安全领域有着广泛的应用，特别是在数据加密、数字签名和身份验证等方面。Python中的RSA实现通常依赖于第三方库，如本例中使用的`rsa`库。以下是对标题和描述中涉及的知识点的...
RSA加密解密，签名验证代码
12-01
发送方使用自己的私钥对数据的哈希值进行签名，接收方则用发送方的公钥验证签名的正确性。签名过程通常使用`Signature`类，先初始化，然后更新数据，最后生成签名。验证时，同样初始化`Signature`类，加载公钥，更新...
RSA加解密工具类
yuer629
08-07 675
package com.fh.util; import javax.crypto.Cipher; import Decoder.BASE64Decoder; import Decoder.BASE64Encoder; import java.io.ByteArrayOutputStream; import java.security.*; import java.security.inte...
RSA证书链验证
一个认真摸鱼的商用密码从业人员
03-20 1671
到这一步基本可以说明，证书链验证通过了，如果觉得不太能确认的话，可以通过对三级证书签名原文hash，验证是否同上述哈希值一致，一致则证明验证通过。因为上图中，可以看到证书使用的签名算法为SHA256，故数据后32字节为哈希值。使用工具解析三级证书，在签名值域中截取上级证书的签名值。使用SHA256算法对签名原文计算哈希，检查是否一致。获取上级证书公钥，使用工具解析二级证书。对比一致，证书链验证通过。
【RSA】RSA加密、解密、签名与验证
小王的储物间
12-20 3136
最近要做iOS SDK的联网授权，涉及到数据安全验证，因此想到使用RSA进行签名和验证。1、客户方前往我方开放平台注册授权，得到AppId和AppSecret。2、客户方集成SDK，调用Register接口传入AppId和AppSecret。3、SDK将AppId和客户端平台相关信息提交给服务器后台。4、服务器下发最新服务器时间戳、sign、公钥、授权相关数据给客户端。5、客户端使用公钥进行签名验证。6、签名验证通过计算授权时间是否有效。
mbedtls | 09 - 数字签名算法的配置与使用（RSA数字签名算法、ECDSA数字签名算法）
Mculover666的博客（嵌入式）
10-03 3399
mbedtls系列文章 mbedtls | 01 - 移植mbedtls库到STM32的两种方法 mbedtls | 02 - 伪随机数生成器（ctr_drbg）的配置与使用 mbedtls | 03 - 单向散列算法的配置与使用（MD5、SHA1、SHA256、SHA512） mbedtls | 04 - 对称加密算法的配置与使用（AES算法） mbedtls | 05 - 消息认证码的配置与使用（HMAC算法、GCM算法） mbedtls | 06 - 非对称加密算法的配置与使用（RSA算法） mbe
Qt5使用openssl实现RSA数字签名
好学近乎知，知耻近乎勇
07-05 9341
1、环境安装 安装qt-opensource-windows-x86-5.9.0.exe或更高版本 安装Win32OpenSSL-1_0_2L.exe 下载地址，最新版本可能因为pro配置问题，总不成功，希望大家提醒 2、在Qt5工程的pro中 填写 LIBS += -LC:/OpenSSL-Win32/lib/MinGW -llibeay32 LIBS += -LC:/Open
tsl c语言,C语言RSA算法实现（基于Mbedtls）
weixin_29692653的博客
05-19 849
最近项目中需要通过C语言实现RSA算法，这里我通过Mbedtls库来进行实现。1、下载Mbedtls首先我们将Mbedtls代码放入到工程中，相关传送门如下：官方网址是国外的下载慢，所以也附上本文使用到的Mbedtls代码，传送门如下：2、引入Mbedtls头文件这里我们在工程中的CMakeLists.txt中引入Mbedtls的头文件，代码如下：# for debug# add_compile_...
Android数据加密之Rsa加密
05-08 219
前言： 最近无意中和同事交流数据安全传输的问题，想起自己曾经使用过的Rsa非对称加密算法，闲下来总结一下。 其他几种加密方式： Android数据加密之Rsa加密 Android数据加密之Aes加密 Android数据加密之Des加密 Android数据加密之MD5加密 Android数据加密之Base64编码算法...
Rsa 验证简介
mingming_killer的专栏
02-05 892
如果不是用密码来进行验证的话，那么就可以使用 rsa 数据签名来进行验证。签名分为公钥和私钥2个。公钥是可以公开出来的，密钥是自己个人持有的。一般来使用 RSA 验证的话，是自己生成一对公钥/私钥。然后把公钥放置到服务器上，自己持有公钥和私钥，然后就可以通过公钥来验证了。下面上使用简介： 假设客户端的用户 charlee 要以 guest 用户登录到服务器上。首先在客户端执行
Java RSA 加解密及签名验证
guokm的博客
10-13 1779
RSA算法是目前非常常见的加密算法，他对应的加解密、签名验签的场景非常常见。因其特性对大字符串加解密效率较低，曾经想对较长字符串加解密，而因其解密过程为分段解密而捣鼓过；这里贴一下代码。
RSA加密使用方式及签名验证
热门推荐
yowasa的博客
06-01 2万+
RSA加密原理使用方式签名验证 加密是网络传输中非常重要的一环，它保证了信息的安全性，让他人无法通过抓包来获取通讯的信息也无法通过伪造信息而实现对系统的入侵。其中最为常用的信息传递加密方式就是RSA加密。 RSA加密原理 RSA与传统加密方式不同的是，他是非对称加密，可以在不直接传递密钥的情况下，完成解密。这能够确保信息的安全性，避免了直接传递密钥所造成的被破解的风险。 RSA加密方式
rsa加密算法签名空间
05-19
RSA加密算法的签名空间是通过对消息进行数字签名来保证消息的完整性、真实性和不可否认性。 具体来说，RSA数字签名的过程如下： 1. 首先，发送方使用SHA-256等散列函数对待签名消息进行哈希操作，得到一个固定长度...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值