2. 程式人生 > 實用技巧 >Java中使用OpenSSL生成的RSA公私鑰進行資料加解密

Java中使用OpenSSL生成的RSA公私鑰進行資料加解密

阿新 • • 發佈：2020-10-18

參考自：https://www.cnblogs.com/yaowen/p/9226566.html

　　　：https://www.cnblogs.com/wjqhuaxia/p/13829680.html

1.使用openssl生成RSA私鑰及證書

　　生成 RSA 私鑰和自簽名證書，命令如下：

openssl req -newkey rsa:2048 -nodes -keyout rsa_private.pem -x509 -days 365 -out cert.crt

　　req是證書請求的子命令，-newkey rsa:2048 -keyout rsa_private.pem 表示生成私鑰(PKCS8格式)，-nodes 表示私鑰不加密，若不帶引數將提示輸入密碼；
-x509表示輸出證書，-days365 為有效期，此後根據提示輸入證書擁有者資訊；

　　至此，可用的金鑰對已經生成好了，私鑰使用rsa_private.pem，公鑰證書採用cert.crt。

說明：　　

　　如果生成的私鑰檔案是PKCS#1格式的，則在使用時需在java中進行相應處理。不能直接使用。

RSAPrivateKeyStructure asn1PrivKey = new RSAPrivateKeyStructure((ASN1Sequence) ASN1Sequence.fromByteArray(priKeyData));  
RSAPrivateKeySpec rsaPrivKeySpec = new RSAPrivateKeySpec(asn1PrivKey.getModulus(), asn1PrivKey.getPrivateExponent());  
KeyFactory keyFactory= KeyFactory.getInstance("RSA");  
PrivateKey priKey= keyFactory.generatePrivate(rsaPrivKeySpec);

　　首先將PKCS#1的私鑰檔案讀取出來（注意去掉減號開頭的註釋內容），然後使用Base64解碼讀出的字串，便得到priKeyData，也就是第一行程式碼中的引數。最後一行得到了私鑰。接下來的用法就沒什麼區別了。

2.使用java程式碼進行加密解

2.1RSA加密解密類

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
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.PublicKey;
import java.security.SecureRandom;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
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 java.util.Base64;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;


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) {
            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 = new String(Base64.getEncoder().encodeToString(publicKey.getEncoded()));
            // 得到私鑰字串
            String privateKeyString = new String(Base64.getEncoder().encodeToString(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
                    + "/rsa_public.crt"));
            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.getDecoder().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 cerPath
     * @return
     * @throws Exception
     */
    public static String getPublicKey(String cerPath) throws Exception {
		CertificateFactory certificatefactory = CertificateFactory.getInstance("X.509");
		FileInputStream fis = new FileInputStream(cerPath);
		X509Certificate Cert = (X509Certificate) certificatefactory.generateCertificate(fis);
		PublicKey pk = Cert.getPublicKey();
		String publicKey = Base64.getEncoder().encodeToString(pk.getEncoded());
		return publicKey;
	}

    /**
     * 從檔案中載入私鑰
     *
     * @param keyFileName
     *            私鑰檔名
     * @return 是否成功
     * @throws Exception
     */
    public static String loadPrivateKeyByFile(String path) throws Exception {
        try {
            BufferedReader br = new BufferedReader(new FileReader(path
                    + "/rsa_private.pem"));
            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.getDecoder().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("密文資料已損壞");
        }
    }

    /**
     * 公鑰解密過程
     *
     * @param publicKey
     *            公鑰
     * @param cipherData
     *            密文資料
     * @return 明文
     * @throws Exception
     *             解密過程中的異常資訊
     */
    public static byte[] decrypt(RSAPublicKey publicKey, byte[] cipherData)
            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.DECRYPT_MODE, publicKey);
            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("密文資料已損壞");
        }
    }

    /**
     * 位元組資料轉十六進位制字串
     *
     * @param data
     *            輸入資料
     * @return 十六進位制內容
     */
    public static String byteArrayToString(byte[] data) {
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < data.length; i++) {
            // 取出位元組的高四位 作為索引得到相應的十六進位制識別符號 注意無符號右移
            stringBuilder.append(HEX_CHAR[(data[i] & 0xf0) >>> 4]);
            // 取出位元組的低四位 作為索引得到相應的十六進位制識別符號
            stringBuilder.append(HEX_CHAR[(data[i] & 0x0f)]);
            if (i < data.length - 1) {
                stringBuilder.append(' ');
            }
        }
        return stringBuilder.toString();
    }
}

2.2簽名及校驗類

package cn.com.wjqhuaxia;

import java.security.KeyFactory;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;


/**
 * RSA簽名驗籤類
 */
public class RSASignature {

    /**
     * 簽名演算法
     */
    public static final String SIGN_ALGORITHMS = "SHA1WithRSA";

    /**
     * RSA簽名
     *
     * @param content
     *            待簽名資料
     * @param privateKey
     *            商戶私鑰
     * @param encode
     *            字符集編碼
     * @return 簽名值
     */
    public static String sign(String content, String privateKey, String encode) {
        try {
            PKCS8EncodedKeySpec priPKCS8 = new PKCS8EncodedKeySpec(Base64.getDecoder().decode(privateKey));

            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(encode));

            byte[] signed = signature.sign();

            return new String(Base64.getEncoder().encodeToString(signed));
        } catch (Exception e) {
            e.printStackTrace();
        }

        return null;
    }

    public static String sign(String content, String privateKey) {
        try {
            PKCS8EncodedKeySpec priPKCS8 = new PKCS8EncodedKeySpec(Base64.getDecoder().decode(privateKey));
            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());
            byte[] signed = signature.sign();
            return new String(Base64.getEncoder().encode(signed));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * RSA驗簽名檢查
     *
     * @param content
     *            待簽名資料
     * @param sign
     *            簽名值
     * @param publicKey
     *            分配給開發商公鑰
     * @param encode
     *            字符集編碼
     * @return 布林值
     */
    public static boolean doCheck(String content, String sign, String publicKey, String encode) {
        try {
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            byte[] encodedKey = Base64.getDecoder().decode(publicKey);
            PublicKey pubKey = keyFactory.generatePublic(new X509EncodedKeySpec(encodedKey));

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

            signature.initVerify(pubKey);
            signature.update(content.getBytes(encode));

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

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

        return false;
    }

    public static boolean doCheck(String content, String sign, String publicKey) {
        try {
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            byte[] encodedKey = Base64.getDecoder().decode(publicKey);
            PublicKey pubKey = keyFactory.generatePublic(new X509EncodedKeySpec(encodedKey));

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

            signature.initVerify(pubKey);
            signature.update(content.getBytes());

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

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

        return false;
    }

}

2.3 測試類

package cn.com.wjqhuaxia;

import java.util.Base64;

public class MainTest {

	public static final String PRIVATE_KEY_FILE = "D:/tools/openssl/RSA/rsa_private.pem";
	//公鑰檔案路徑
//	public static final String PUBLIC_KEY_FILE = RSAUtil.class.getClassLoader().getResource("").getPath() + "rsa_private.key";
	public static final String PUBLIC_KEY_FILE = "D:/tools/openssl/RSA/rsa_public.crt";
	
	
    public static void main(String[] args) throws Exception {

        // RSAEncrypt.genKeyPair(filepath);
    	String filepath = "D:/tools/openssl/RSA/";


        System.out.println("--------------公鑰加密私鑰解密過程-------------------");
        // 公鑰
        String publicKeyString = RSAEncrypt.getPublicKey(PUBLIC_KEY_FILE);
        // 私鑰
//        String loadPrivateKeyByFile = RSAEncrypt.loadPrivateKeyByFile(filepath); //獲取私鑰
        String privateKeyString = "MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQC3Vs7ndTzw9lS+3KijEY26RistYbOx0qNTlrq49vDg+2fVQurNh41uzeIdjwKZfpe9Gtsy7ZRzGv+3EH5rK8Bo+rPteBGKt2tjsZAcaR78RZ8PVOmozJYX2aZqpirPf/vSLhB/vaKeyJpvp6WQG6gLSbZRgFzb+vACgE2m7Pt9rD2pNjPowEsPf6jcqQ19I7FY9TtYRU4ypRR4MXFJw6pLfrIfof/TPpgXdp5AaQ8OaPmxsOsiYHG3Nvv0HWLRYtq/JYhQrh8bCOklPI/jdusxvXpTBfJLrQmruVfRJ3HyqXuY1R4/IP2iyZdPdnncnqKPr8UdOk9SDB9CR32dH2V7AgMBAAECggEAJwOH/+UI1NX2bq8SC7FekXcBFSUnUf3a15zJmzahR574F3+n65ie1idlqJiYGwW/UHR4lLvNzTi/lbsiy7eBuFUxGKVmRjiF168fVYxhFZnTITYWit8OSYD9UtCNZ556fd1jkWtPQa66fmwUZTgdaFmFPI6uM/mQPVgELjNbyQATZ7i9rZKUuDhT5QwWjn+uk/qcsv80gDjHCesdrzfwbWbnlPMFLY8f7rKOyTnwuBIR07UqagiLrHdli8NpWw6viNymdxmqgteiG4LBXERdV3/vA0Zr+naX4rGpmgMum77mbyKqFZ8Q3j4MYVCA29SVH9OeYJRUJqIy8hnKU5faIQKBgQDv8Cn/ng5xHiI9emDDryIDmZmDZaswkL2Wm010ccgcoyMzYUiHmHRUYy47yrk0VVlqnJObZlUSHNTrTkamjMqXrIF4Q69ndXDVRoF8VXzmJvYuSEeClg0YvkLSQV87dZu6DI7R0ucIrrGY/hXIxNSmzZIbDuDTBexvK3puy6bxKQKBgQDDnLPY1Xca6QMHpWTlIHWsEJ58szNKsJpMNsxHQT7tozrW0iBztAw13d6fs3Yt4LJF4XpNqBd1GSuVKRtnrClXT1xf3pZZbo7999OfFQMht6xp53kZYYE0toMJEt6039uHgQUvFXPOv3eVLvYcU1kJXwzrXWqd+3V1DItoOc5CAwKBgQDiPA89qGhxnDoowZUvrZhi0JeA34I0vqUktranjwlihygPsDDVOZimYQYc9p7+i2NONOiw5CJee7T/UcUoESSNMui43wkqgf+r+VjqRSkJUb9aEGjs5lLe+7bBzUXgKJp3KJQZn8Sb2Sw314vuzDi+NqMGxFaUYsd2YwaEJZ35UQKBgQC8rCyb/GlBP3Z4rYK/ratSJ0V2qbHTXLu2vzQRllEIDOT3xv0eHI+adUIBb6uRXKUW2gCJXpQhkgGDgX65ZEkLubQzlBIYeJbbR2qKik3W+74E+ArJ/E4Pdeq1mcnNVA3+iOdjHqHwzKSe9AjWEV5Tt6ZSbmwjrSMBnvPnt7nF2QKBgAS0/YHxPU4QDsb6PqoGJ64utjgmqrqDAjp4OgCpdtP9gJqKYSi60b54NF50JKnpxVunq8+kOp38LsDdp+9RdD8+xvPMPFM3wGRHhnFvbd1ZnwSjsCj7bw1ARSHldQ2N3aUhtSyCjj0Gdc1jDquORMTGGgUA0jQ2/blTFw+WRE9b";
        
        String plainText = "ihep_公鑰加密私鑰解密";
        System.out.println("原文：" + plainText);
        
        // 公鑰加密過程
        byte[] cipherData = RSAEncrypt.encrypt(RSAEncrypt.loadPublicKeyByStr(publicKeyString),
                plainText.getBytes());
        String cipher = new String(Base64.getEncoder().encode(cipherData));
        System.out.println("加密：" + cipher);
        // 私鑰解密過程
        byte[] res = RSAEncrypt.decrypt(RSAEncrypt.loadPrivateKeyByStr(privateKeyString),
        		Base64.getDecoder().decode(cipher));
        String restr = new String(res);
        System.out.println("解密：" + restr);
        System.out.println();

        System.out.println("--------------私鑰加密公鑰解密過程-------------------");
        plainText = "ihep_私鑰加密公鑰解密";
        // 私鑰加密過程
        cipherData = RSAEncrypt.encrypt(RSAEncrypt.loadPrivateKeyByStr(privateKeyString),
                plainText.getBytes());
        cipher = new String(Base64.getEncoder().encode(cipherData));
        // 公鑰解密過程
        res = RSAEncrypt.decrypt(RSAEncrypt.loadPublicKeyByStr(publicKeyString),
        		Base64.getDecoder().decode(cipher));
        restr = new String(res);
        System.out.println("原文：" + plainText);
        System.out.println("加密：" + cipher);
        System.out.println("解密：" + restr);
        System.out.println();

        System.out.println("---------------私鑰簽名過程------------------");
        String content = "ihep_這是用於簽名的原始資料";
        String signstr = RSASignature.sign(content, privateKeyString);
        System.out.println("簽名原串：" + content);
        System.out.println("簽名串：" + signstr);
        System.out.println();

        System.out.println("---------------公鑰校驗簽名------------------");
        System.out.println("簽名原串：" + content);
        System.out.println("簽名串：" + signstr);

        System.out.println("驗簽結果：" + RSASignature.doCheck(content, signstr, publicKeyString));
        System.out.println();

    }
}

　　

相關推薦

Java中使用OpenSSL生成的RSA公私鑰進行資料加解密

參考自：https://www.cnblogs.com/yaowen/p/9226566.html 　　　：https://www.cnblogs.com/wjqhuaxia/p/13829680.html

openssl生成rsa金鑰

技術標籤：rsa加密opensslrsa 進入opensll\\bin目錄下1、生成rsa私鑰，文字儲存格式，長度2048(儲存在在mycerts下)

openssl生成RSA私鑰

技術標籤：linux openssl OpenSSL>genrsa -out app_private_key.pem 2048#預設生成PKCS#1的私鑰，2048表示私鑰的長度，我們建議是2048位，這樣安全，如果由於某些限制，可以改為1024，表示1024位長度，我們仍

OPENSSL 生成RSA公鑰、私鑰和證書

在命令視窗執行下列操作。 1）生成RSA私鑰： openssl genrsa -out rsa_private_key.pem 2048

Java讀取OpenSSL生成的PEM公鑰檔案操作

JDK8的JCE是不支援讀取PEM檔案的。需要使用bouncycastle。 專案需求，使用SHA1WithRSA演算法，對介面資料做簽名。

java實現RSA公私鑰PKCS#1與PKCS#8之間的相互轉換（java rsa pkcs8轉pkcs1，rsa pkcs1轉pkcs8），PKCS8和PKCS1公私鑰byte陣列還原為java物件

技術標籤：數字簽名pkcspkirsa加密解密演算法 目錄 前言引入依賴一、公鑰轉換公鑰PKCS1轉PKCS8公鑰PKCS8轉PKCS1

java隨機生成RSA金鑰對

public static Map<Integer, String> genKeyPair() throws NoSuchAlgorithmException { //儲存使用者級別公鑰和私鑰對

淺談Java中是否直接可以使用enum進行傳輸

背景 我們在進行傳輸的時候 會有一些狀態值，如Status為1代表刪除，為0代表失敗或者怎麼樣的。只傳輸一個）0或者1過去給第三方（此處不包括給前端），如果沒有契約第三方會不認識你這個是什麼意思，那我們在平時寫業

PHP 生成RSA金鑰證書以及RSA加密解密

1，生成證書 $config = [ \'config\' => dirname(__FILE__) . \'/openssl.cnf\', // 定位至你的openssl.cnf檔案

golang 如何獲取pem格式RSA公私鑰長度

因在做license註冊機制當中，有對根據本地RSA pem金鑰檔案判斷出RSA的公私金鑰長度的需求（即：根據pem內容判斷出RSA金鑰是1024位或者2048位，或者其他位數等），因此個人通過思考，摸索整理出一個方法，予以記錄，備

java中隨機生成字串的方法（三種）

1、生成的字串每個位置都有可能是str中的一個字母或數字，需要匯入的包是import java.util.Random;

java中list集合按物件屬性進行排序

在日常搬磚中，我們可能會需要對List中自定義的一些物件進行排序，但java是不知道我們的物件是需要怎麼排序，因此我們得自己寫排序的規則。

[Golang軟體推薦] RSA公私鑰加解密(解決Golang私鑰加密公鑰解密問題)

安全是軟體開始中很重要的一個環節,在金融場景以及設計資產的場景下更是如此,在加密演算法中主要使用較多加密方式分別是對稱加密和非對稱加密,對稱加密中的代表是AES,DES,3DES等,非對稱加密中使用比較多的是RSA,ECC等

java使用RSA加密方式實現資料加密解密的程式碼

RSA的應用 RSA是一種非對稱加密演算法。現在，很多登陸表單的密碼的都採用RSA加密，例如京東中的登陸使用公鑰對密碼進行加密

Java中怎樣遍歷Map的所有資料

場景 Java中遍歷陣列或者List時可以使用每個元素的型別的變數去foreach 如果想要遍歷一個map怎樣遍歷。

Java中根據兩個欄位查詢資料並形成Map的方式

如題，分頁列表介面返回的資料中 preWarningIsUpload欄位需要額外查詢另外一張表去獲取資料判斷

Python實現金鑰密碼（加解密）例項詳解

金鑰密碼 \'\'\' 如金鑰短語密碼為: university -> universty 明文: abcdefghijklmnopqrstuvwxyz

C# 對含有向量偏移的明文進行AES加解密

直接上程式碼： using System; using System.Collections.Generic; using System.Linq; using System.Security.Cryptography;

md5加密解密程式碼_Python內建方法實現基於祕鑰的資訊加解密

技術標籤：md5加密解密程式碼md5解密程式碼python md5解密 點選關注州的先生 精彩不容錯過

Java如何基於command呼叫openssl生成私鑰證書

在windows環境下進行的測試，前提條件，windows上需要先安裝openssl。 配置環境變數，檢視版本：