2. 程式人生 > >RSA非對稱加密

RSA非對稱加密

阿新 • • 發佈：2019-01-08

概念

在說 RSA 之前，首先聊聊什麼是非對稱加密。在講對稱加密的時候，就曾經說過，對稱加密演算法在加密和解密時使用的是同一個祕鑰，加解密雙方必須使用同一個金鑰才能進行正常的溝通。而非對稱加密則不然，非對稱加密演算法需要兩個金鑰來進行加密和解密，分別是公鑰和私鑰。需要注意的一點，這個公鑰和私鑰必須是一對的，如果用公鑰對資料進行加密，那麼只有使用對應的私鑰才能解密，反之亦然。由於加密和解密使用的是兩個不同的金鑰，因此，這種演算法叫做非對稱加密演算法。

工作過程

如下圖，甲乙之間使用非對稱加密的方式傳輸資料。
  • 乙方生成一對金鑰（公鑰和私鑰）並將公鑰向其它方公開；
  • 得到該公鑰的甲方使用該金鑰對機密資訊進行加密後再發送給乙方；
  • 乙方再用自己儲存的另一把專用金鑰（私鑰）對加密後的資訊進行解密；
  • 乙方只能用其專用金鑰（私鑰）解密由對應的公鑰加密後的資訊；
  • 在傳輸過程中，即使攻擊者截獲了傳輸的密文，並得到了乙的公鑰，也無法破解密文，因為只有乙的私鑰才能解密密文。
在非對稱加密中使用的主要演算法有：RSA、Elgamal、揹包演算法、Rabin、D-H、ECC（橢圓曲線加密演算法）等。今天主要是介紹 RSA ，至於其他的演算法，後續會選擇幾個進行介紹。

RSA

其實，在早在 1978 年的時候，RSA就已經出現了，它是第一個既能用於資料加密也能用於數字簽名的演算法。它易於理解和操作，也很流行。其原理就如上面的工作過程所述。RSA 演算法基於一個十分簡單的數論事實：將兩個大素數相乘十分容易，但是想要對其乘積進行因式分解卻極其困難，因此可以將乘積公開作為加密金鑰。

程式碼實現

下面來看一下具體的程式碼實現。
package com.github.hls.utils;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

import javax.crypto.Cipher;
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;

public class RSA {
    /**
     * 定義加密方式
     */
    private final static String KEY_RSA = "RSA";
    /**
     * 定義簽名演算法
     */
    private final static String KEY_RSA_SIGNATURE = "MD5withRSA";
    /**
     * 定義公鑰演算法
     */
    private final static String KEY_RSA_PUBLICKEY = "RSAPublicKey";
    /**
     * 定義私鑰演算法
     */
    private final static String KEY_RSA_PRIVATEKEY = "RSAPrivateKey";

    /**
     * 初始化金鑰
     *
     * @return
     */
    public static Map<String, Object> init() {
        Map<String, Object> map = null;
        try {
            KeyPairGenerator generator = KeyPairGenerator.getInstance(KEY_RSA);
            generator.initialize(1024);
            KeyPair keyPair = generator.generateKeyPair();
            // 公鑰
            RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
            // 私鑰
            RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
            // 將金鑰封裝為map
            map = new HashMap<>();
            map.put(KEY_RSA_PUBLICKEY, publicKey);
            map.put(KEY_RSA_PRIVATEKEY, privateKey);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return map;
    }

    /**
     * 用私鑰對資訊生成數字簽名
     *
     * @param data       加密資料
     * @param privateKey 私鑰
     * @return
     */
    public static String sign(byte[] data, String privateKey) {
        String str = "";
        try {
            // 解密由base64編碼的私鑰
            byte[] bytes = decryptBase64(privateKey);
            // 構造PKCS8EncodedKeySpec物件
            PKCS8EncodedKeySpec pkcs = new PKCS8EncodedKeySpec(bytes);
            // 指定的加密演算法
            KeyFactory factory = KeyFactory.getInstance(KEY_RSA);
            // 取私鑰物件
            PrivateKey key = factory.generatePrivate(pkcs);
            // 用私鑰對資訊生成數字簽名
            Signature signature = Signature.getInstance(KEY_RSA_SIGNATURE);
            signature.initSign(key);
            signature.update(data);
            str = encryptBase64(signature.sign());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return str;
    }

    /**
     * 校驗數字簽名
     *
     * @param data      加密資料
     * @param publicKey 公鑰
     * @param sign      數字簽名
     * @return 校驗成功返回true，失敗返回false
     */
    public static boolean verify(byte[] data, String publicKey, String sign) {
        boolean flag = false;
        try {
            // 解密由base64編碼的公鑰
            byte[] bytes = decryptBase64(publicKey);
            // 構造X509EncodedKeySpec物件
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(bytes);
            // 指定的加密演算法
            KeyFactory factory = KeyFactory.getInstance(KEY_RSA);
            // 取公鑰物件
            PublicKey key = factory.generatePublic(keySpec);
            // 用公鑰驗證數字簽名
            Signature signature = Signature.getInstance(KEY_RSA_SIGNATURE);
            signature.initVerify(key);
            signature.update(data);
            flag = signature.verify(decryptBase64(sign));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return flag;
    }

    /**
     * 私鑰解密
     *
     * @param data 加密資料
     * @param key  私鑰
     * @return
     */
    public static byte[] decryptByPrivateKey(byte[] data, String key) {
        byte[] result = null;
        try {
            // 對私鑰解密
            byte[] bytes = decryptBase64(key);
            // 取得私鑰
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(bytes);
            KeyFactory factory = KeyFactory.getInstance(KEY_RSA);
            PrivateKey privateKey = factory.generatePrivate(keySpec);
            // 對資料解密
            Cipher cipher = Cipher.getInstance(factory.getAlgorithm());
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            result = cipher.doFinal(data);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 私鑰解密
     *
     * @param data 加密資料
     * @param key  公鑰
     * @return
     */
    public static byte[] decryptByPublicKey(byte[] data, String key) {
        byte[] result = null;
        try {
            // 對公鑰解密
            byte[] bytes = decryptBase64(key);
            // 取得公鑰
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(bytes);
            KeyFactory factory = KeyFactory.getInstance(KEY_RSA);
            PublicKey publicKey = factory.generatePublic(keySpec);
            // 對資料解密
            Cipher cipher = Cipher.getInstance(factory.getAlgorithm());
            cipher.init(Cipher.DECRYPT_MODE, publicKey);
            result = cipher.doFinal(data);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 公鑰加密
     *
     * @param data 待加密資料
     * @param key  公鑰
     * @return
     */
    public static byte[] encryptByPublicKey(byte[] data, String key) {
        byte[] result = null;
        try {
            byte[] bytes = decryptBase64(key);
            // 取得公鑰
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(bytes);
            KeyFactory factory = KeyFactory.getInstance(KEY_RSA);
            PublicKey publicKey = factory.generatePublic(keySpec);
            // 對資料加密
            Cipher cipher = Cipher.getInstance(factory.getAlgorithm());
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            result = cipher.doFinal(data);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 私鑰加密
     *
     * @param data 待加密資料
     * @param key  私鑰
     * @return
     */
    public static byte[] encryptByPrivateKey(byte[] data, String key) {
        byte[] result = null;
        try {
            byte[] bytes = decryptBase64(key);
            // 取得私鑰
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(bytes);
            KeyFactory factory = KeyFactory.getInstance(KEY_RSA);
            PrivateKey privateKey = factory.generatePrivate(keySpec);
            // 對資料加密
            Cipher cipher = Cipher.getInstance(factory.getAlgorithm());
            cipher.init(Cipher.ENCRYPT_MODE, privateKey);
            result = cipher.doFinal(data);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 獲取公鑰
     *
     * @param map
     * @return
     */
    public static String getPublicKey(Map<String, Object> map) {
        String str = "";
        try {
            Key key = (Key) map.get(KEY_RSA_PUBLICKEY);
            str = encryptBase64(key.getEncoded());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return str;
    }

    /**
     * 獲取私鑰
     *
     * @param map
     * @return
     */
    public static String getPrivateKey(Map<String, Object> map) {
        String str = "";
        try {
            Key key = (Key) map.get(KEY_RSA_PRIVATEKEY);
            str = encryptBase64(key.getEncoded());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return str;
    }

    /**
     * BASE64 解密
     *
     * @param key 需要解密的字串
     * @return 位元組陣列
     * @throws Exception
     */
    public static byte[] decryptBase64(String key) throws Exception {
        return (new BASE64Decoder()).decodeBuffer(key);
    }

    /**
     * BASE64 加密
     *
     * @param key 需要加密的位元組陣列
     * @return 字串
     * @throws Exception
     */
    public static String encryptBase64(byte[] key) throws Exception {
        return (new BASE64Encoder()).encodeBuffer(key);
    }

    /**
     * 測試方法
     *
     * @param args
     */
    public static void main(String[] args) {
        String privateKey = "";
        String publicKey = "";
        // 生成公鑰私鑰
        Map<String, Object> map = init();
        publicKey = getPublicKey(map);
        privateKey = getPrivateKey(map);
        System.out.println("公鑰: \n\r" + publicKey);
        System.out.println("私鑰： \n\r" + privateKey);
        System.out.println("公鑰加密--------私鑰解密");
        String word = "你好，世界！Salt";
        byte[] encWord = encryptByPublicKey(word.getBytes(), publicKey);
        String decWord = new String(decryptByPrivateKey(encWord, privateKey));
        System.out.println("加密前: " + word + "\n\r" + "解密後: " + decWord);
        System.out.println("私鑰加密--------公鑰解密");
        String english = "Hello, World!";
        byte[] encEnglish = encryptByPrivateKey(english.getBytes(), privateKey);
        String decEnglish = new String(decryptByPublicKey(encEnglish, publicKey));
        System.out.println("加密前: " + english + "\n\r" + "解密後: " + decEnglish);
        System.out.println("私鑰簽名——公鑰驗證簽名");
        // 產生簽名
        String sign = sign(encEnglish, privateKey);
        System.out.println("簽名:\r" + sign);
        // 驗證簽名
        boolean status = verify(encEnglish, publicKey, sign);
        System.out.println("狀態:\r" + status);
    }
}

相關推薦

RSA 非對稱加密【轉】

omx javax 生成 lba 測試 data htm dog ash 演示代碼：https://pan.baidu.com/s/10rfSUUDEEHvCDEYH0oEVCw Base64工具類，可以讓rsa編碼的亂碼變成一串字符序列 1 pack

python----RSA非對稱加密算法使用

算法 *** utf 獲取 目的 怎麽加密 save 判斷 非對稱加密 最近在搞項目的接口持續性自動化測試，好久沒有更新博客了。 項目中接觸到很多加密相關的數據，很多項目都會用到非對稱加密算法來保證前端和服務器交互的數據安全。 下面介紹下python下怎麽使用RSA加密算法

openssl RSA非對稱加密解密

需要先了解的openssl系列函式 openssl_pkey_get_private 從證書中解析獲取私鑰，以供使用。成功，返回真實的金鑰資源識別符號(Resource ID),否則返回false openssl_pkey_get_public 從證書中解析獲取公鑰，以供使用。成功，返

RSA非對稱加密演算法(表單提交時，前端js加密，後端java解密)

RSA非對稱加密演算法(表單提交時，前端js加密，後端java解密 非對稱加密演算法 需要的工具 前端jsp頁面 js程式碼 加密解密的工具類 產生公鑰的類 處理登陸請求的類 加密成功的密碼 非對稱加密演算

php rsa非對稱加密

class Rsa { private static $PRIVATE_KEY = '-----BEGIN RSA PRIVATE KEY-----MIICXgIBAAKBgQCoZZ8iUBprOIc0kGckr5ax6/Fd9IKKMc/XHayKEAvqpS0oz0b1ojEkpkdZB

非對稱加密過程詳解（基於RSA非對稱加密演算法實現）

1、非對稱加密過程：         假如現實世界中存在A和B進行通訊，為了實現在非安全的通訊通道上實現資訊的保密性、完整性、可用性（即資訊保安的三個性質），A和B約定使用非對稱加密通道進行通訊，具體過程如下：   說明：         國內目前使用雙證書體系，即

php實現openssl RSA非對稱加密解密

今天跟第三方公司對接別人看了我寫的文件當時文件寫的是DES加密，然後我的一個回答都讓我覺得對不起別人，我說了是AES加密，當時AES和RSA加解密的原理我不瞭解導致我也誤解了別人，今天就特意去理解了一下，下面就看一下RSA非對稱的加解密吧 首先先來說一下RSA和AES的區別

前端js，後臺python實現RSA非對稱加密

先熟悉使用 在後臺使用RSA實現祕鑰生產，加密，解密;   # -*- encoding:utf-8 -*- import base64 from Crypto import Random from Crypto.Cipher import PKCS1_v1_5 as Ci

php RSA非對稱加密演算法

class Rsa { private static $PRIVATE_KEY = '-----BEGIN RSA PRIVATE KEY-----MIICXgIBAAKBgQCoZZ8iUBprOIc0kGckr5ax6/Fd9IKKMc/XHayKEAvqpS0oz0b1ojEkpk

使用RSA非對稱加密登陸介面登陸密碼，防止明文傳輸

    public class RSAUtil { public static final String PUBLIC_KEY = "RSAPublicKey"; public static final String PRIVATE_KEY = "RSAPrivateKey"; publi

AES對稱加密+RSA非對稱加密實現

</pre>AesEncrypt.h<pre name="code" class="cpp">//enum KeySize { Bits128, Bits192, Bits256 }; // key size, in bits, for construtor #define

RSA非對稱加密

概念在說 RSA 之前，首先聊聊什麼是非對稱加密。在講對稱加密的時候，就曾經說過，對稱加密演算法在加密和解密時使用的是同一個祕鑰，加解密雙方必須使用同一個金鑰才能進行正常的溝通。而非對稱加密則不然，非對稱加密演算法需要兩個金鑰來進行加密和解密，分別是公鑰和私鑰。需要注意的一點

整理的AES對稱加密和RSA非對稱加密

專案用到這兩個加密方法，就整理了下做了個demo，這裡也貼出來程式碼供參考 AES加密解密 public class AESUtil { /** * 生成AES金鑰 * @param strkey * @return * @t

python ----RSA非對稱加密演算法使用

最近在搞專案的介面持續性自動化測試，好久沒有更新部落格了。 專案中接觸到很多加密相關的資料，很多專案都會用到非對稱加密演算法來保證前端和伺服器互動的資料安全。 下面介紹下python下怎麼使用RSA加密演算法: import rsa (publickey,priva

RSA非對稱加密傳輸---前端加密&解密(VUE專案)

A要傳給B一句話(需要保密)，就由B生成一對公鑰和私鑰存好，公鑰就好比一把鎖，鑰匙就是私鑰。B只需要把鎖給A，A把那句話鎖起來，交還給B，在這過程中，即使大家都能看到公鑰(鎖)，也是不知道那句話是啥的，然後B拿到鎖好的機密，拿只有自己才有的私鑰(鑰匙)解開，這個差不多就是非對

php使用openssl來實現RSA(非對稱加密)

使用非對稱加密主要是藉助openssl的公鑰和私鑰，用公鑰加密私鑰解密，或者私鑰加密公鑰解密。 1.安裝openssl和PHP的openssl擴充套件 2.生成私鑰：openssl genrsa 用於

Java實現Rsa非對稱加密

import org.bouncycastle.jce.provider.BouncyCastleProvider; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileInputStre

JAVA RSA非對稱加密詳解

 原文：原文地址 package com.rsa; import org.apache.commons.codec.binary.Base64; import javax.crypto.Cipher; import java.security.*; import jav

RSA 非對稱加密原理（小白也能看懂哦~）

RSA 加密原理 步驟 說明 描述 備註 1 找出質數 P 、Q - 2 計算公共模數 N = P * Q - 3 尤拉函式 φ(N) = (P-1)(Q-1) - 4

Python程式設計：Crypto模組RSA非對稱加密

pycrypto模組支援的加密方式 對稱加密方式： AES DES ARC4 雜湊值計算： MD5 SHA HMAC 公鑰加密和簽名： RSA DSA RSA加密演算法是一種非對稱加密演算法 安裝 pip install pycr