簡介
公鑰和私鑰就是俗稱的不對稱加密方式，是從以前的對稱加密(使用用戶名與密碼)方式的提高。用電子郵件的方式說明一下原理。
使用公鑰與私鑰的目的就是實現安全的電子郵件，必須實現如下目的：
- 我發送給你的內容必須加密，在郵件的傳輸過程中不能被別人看到
- 必須保證是我發送的郵件，不是別人冒充我的
要達到這樣的目標必須發送郵件的兩人都有公鑰和私鑰。
公鑰，就是給大家用的，你可以通過電子郵件發佈，可以通過網站讓別人下載，公鑰其實是用來加密/驗章用的。
私鑰，就是自己的，必須非常小心保存，最好加上密碼，私鑰是用來解密/簽章，首先就Key的所有權來說，私鑰只有個人擁有。
公鑰與私鑰的作用是：用公鑰加密的內容只能用私鑰解密，用私鑰加密的內容只能用公鑰解密。
比如說，我要給你發送一個加密的郵件。首先，我必須擁有你的公鑰，你也必須擁有我的公鑰。
- 首先，我用你的公鑰給這個郵件加密，這樣就保證這個郵件不被別人看到，而且保證這個郵件在傳送過程中沒有被修改。你收到郵件後，用你的私鑰就可以解密，就能看到內容。
- 其次，我用我的私鑰給這個郵件加密，發送到你手裏後，你可以用我的公鑰加密。因爲私鑰只有我手裏有，這樣就保證了這個郵件是我發送的。
- 當A->B資料時，A會使用B的公鑰加密，這樣才能確保只有B能解開，否則普通大衆都能解開加密的訊息，就是去了資料的保密性。驗證方面則是使用籤驗章的機制，A傳資料給大家時，會以自己的私鑰做簽章，如此所有收到訊息的人都可以用A的公鑰進行驗章，便可確認訊息是由A發出來的了。
加密算法包括對稱加密和非對稱加密，對稱加密就是加密和解密用一個密鑰，就像電報加密一樣，需要一個密碼本，發送方通過它加密，接收方通過它解密，因此密碼本非常重要，一旦泄露就會所有信息被竊取。而非對稱加密有兩個密鑰，公鑰和私鑰。接收方先生成一對公鑰私鑰，公鑰可以直接不加密發送給發送方，任何人都可以拿到。然後發送方用公鑰加密，發送給接收方後，接收方用私鑰可以解密，並且只有私鑰能解密，公鑰不能解密，只能加密。
著名的RSA算法就是非對稱加密的一種，是基於大數難以進行質因數分解設計的。加密等級越高，RSA位數就越長，目前常用1024bits。並且RSA算法除了加密以外還可以實現數字簽名。就是證明A發送的信息確實是A發出的。公鑰和私鑰實際上地位平等，可以互相加密解密。即用公鑰加密的密文可以用私鑰解密，這就是加密過程；反過來，用私鑰加密的密文可以用公鑰解密，也就是說大衆可以用公鑰對A發出的密文解密來驗證信息確實是A發出的，這就是數字簽名。
RSA速度很慢，一般只對少量信息進行加密。常用的做法是用RSA給對稱加密密鑰加密，發送給接收方。然後接收方解密知道了對稱加密密鑰，雙方再通過對稱加密方式通訊。
用java實現的代碼如下:
RsaEncrypt .java
注： 加密算法的各種形式參考
https://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html
package com.sm.test1;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import java.io.*;
import java.security.*;
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.Date;
/**
* 對文件加簽、驗籤工具類
* 對文件加簽、驗籤工具類
* 生成私鑰：openssl genrsa -out rsa_private_key.pem 1024
* 私鑰還不能直接被使用，需要進行PKCS#8編碼：openssl pkcs8 -topk8 -inform PEM -in rsa_private_key.pem -outform PEM -nocrypt
* 根據私鑰生成公鑰：openssl rsa -in rsa_private_key.pem -pubout -out rsa_public_key.pem
* 使用私鑰sha512簽名：openssl dgst -sha512 -sign rsa_private_key.pem -out xx.tar.gz.sign xx.tar.gz
* 使用公鑰sha512驗籤：openssl dgst -verify rsa_public_key.pem -sha512 -signature xx.tar.gz.sign xx.tar.gz
*
* @author miracle_8
* @date 2019/12/3
* @see [相關類/方法]（可選）
* @since [產品/模塊版本] （可選）
*/
public class RsaEncrypt {
/**
*
* RSA簽名
*
* @param data 待簽名的字符串
* @param privateKey rsa私鑰字符串
* @return
* @date 2019/12/3
* @author miracle_8
* @see [相關類/方法](可選)
* @since [產品/模塊版本](可選)
*/
public byte[] rsaSign(byte[] data, RSAPrivateKey privateKey)
throws SignatureException {
try {
Signature signature = Signature.getInstance("SHA512withRSA");
signature.initSign(privateKey);
signature.update(data);
byte[] signed = signature.sign();
return signed;
} catch (Exception e) {
throw new SignatureException("RSAcontent = " + data + "; charset = ", e );
}
}
/**
* RSA驗籤
*
* @param data 被簽名的內容
* @param sign 簽名後的結果
* @param publicKey rsa公鑰
* @return
* @date 2019/12/3
* @author miracle_8
* @see [相關類/方法](可選)
* @since [產品/模塊版本](可選)
*/
public boolean verify(byte[] data, byte[] sign, RSAPublicKey publicKey)
throws SignatureException {
try {
Signature signature = Signature.getInstance("SHA512withRSA");
signature.initVerify(publicKey);
signature.update(data);
return signature.verify(sign);
} catch (Exception e) {
throw new SignatureException("RSA驗證簽名[content = " + data + "; charset = ; signature = " + sign + "]發生異常!", e);
}
}
/**
* 私鑰 通過Base64Utils.encode(rsaEncrypt.getPrivateKey().getEncoded()) 可以獲取
*/
private RSAPrivateKey privateKey;
/**
* 公鑰 通過Base64Utils.encode(rsaEncrypt.getPublicKey().getEncoded()) 可以獲取
*/
private RSAPublicKey publicKey;
/**
* 字節數據轉字符串專用集合
*/
private static final char[] HEX_CHAR = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
/**
* 獲取私鑰
*
* @param
* @return
* @date 2019/12/3
* @author miracle_8
* @see [相關類/方法](可選)
* @since [產品/模塊版本](可選)
*/
public RSAPrivateKey getPrivateKey() {
return privateKey;
}
/**
* 獲取公鑰
*
* @param
* @return
* @date 2019/12/3
* @author miracle_8
* @see [相關類/方法](可選)
* @since [產品/模塊版本](可選)
*/
public RSAPublicKey getPublicKey() {
return publicKey;
}
/**
* 隨機生成密鑰對
*
* @param
* @return
* @date 2019/12/3
* @author miracle_8
* @see [相關類/方法](可選)
* @since [產品/模塊版本](可選)
*/
public void genKeyPair() {
KeyPairGenerator keyPairGenerator = null;
try {
keyPairGenerator = KeyPairGenerator.getInstance("RSA");
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
keyPairGenerator.initialize(1024, new SecureRandom());
KeyPair keyPair = keyPairGenerator.genKeyPair();
this.privateKey = (RSAPrivateKey) keyPair.getPrivate();
this.publicKey = (RSAPublicKey) keyPair.getPublic();
}
/**
* 從.pem文件中取得私鑰
*
* @param
* @return
* @date 2019/12/3
* @author miracle_8
* @see [相關類/方法](可選)
* @since [產品/模塊版本](可選)
*/
public String getPrivateKeyFromFile(String filePath) {
String strPrivateKey = "";
try {
BufferedReader privateKey = new BufferedReader(new FileReader(filePath));
String line = "";
while ((line = privateKey.readLine()) != null) {
strPrivateKey += line;
}
privateKey.close();
strPrivateKey = strPrivateKey.replace("-----BEGIN PRIVATE KEY-----", "")
.replace("-----END PRIVATE KEY-----", "");
} catch (Exception e) {
e.printStackTrace();
}
return strPrivateKey;
}
/**
* 從.pem文件中取得公鑰
*
* @param
* @return
* @date 2019/12/3
* @author miracle_8
* @see [相關類/方法](可選)
* @since [產品/模塊版本](可選)
*/
public String getPublicKeyFromFile(String filePath) {
String strPublicKey = "";
try {
BufferedReader publicKey = new BufferedReader(new FileReader(filePath));
String line = "";
while ((line = publicKey.readLine()) != null) {
strPublicKey += line;
}
publicKey.close();
strPublicKey = strPublicKey.replace("-----BEGIN PUBLIC KEY-----", "")
.replace("-----END PUBLIC KEY-----", "");
} catch (Exception e) {
e.printStackTrace();
}
return strPublicKey;
}
/**
* 從字符串中加載公鑰
*
* @param publicKeyStr 公鑰字符串
* @return
* @date 2019/12/3
* @author miracle_8
* @see [相關類/方法](可選)
* @since [產品/模塊版本](可選)
*/
public void loadPublicKey(String publicKeyStr)
throws Exception{
try {
byte[] buffer = Base64Utils.decode(publicKeyStr);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer); // 通過x509編碼後的
this.publicKey = (RSAPublicKey)keyFactory.generatePublic(keySpec);
} catch (NoSuchAlgorithmException e) {
throw new Exception("無此算法");
} catch (InvalidKeySpecException e) {
throw new Exception("公鑰非法");
}catch (NullPointerException e) {
throw new Exception("公鑰數據爲空");
}
}
/**
* 加載私鑰
*
* @param privateKeyStr 私鑰字符串 必須是已經經過PKCS8編碼後的字符串, 原字符串不可以
* @return
* @date 2019/12/3
* @author miracle_8
* @see [相關類/方法](可選)
* @since [產品/模塊版本](可選)
*/
public void loadPrivateKey(String privateKeyStr)
throws Exception {
try {
byte[] buffer = Base64Utils.decode(privateKeyStr);
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer); // PKCS8編碼後的
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
this.privateKey = (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
* @date 2019/12/3
* @author miracle_8
* @see [相關類/方法](可選)
* @since [產品/模塊版本](可選)
*/
public byte[] encrypt(RSAPublicKey publicKey, byte[] plainTextData)
throws Exception {
if (publicKey == null) {
throw new Exception("加密公鑰爲空, 請設置");
}
Cipher cipher = null;
try {
cipher = Cipher.getInstance("RSA");
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
* @return
* @date 2019/12/3
* @author miracle_8
* @see [相關類/方法](可選)
* @since [產品/模塊版本](可選)
*/
public byte[] decrypt(RSAPrivateKey privateKey, byte[] cipherData)
throws Exception{
if (privateKey == null) {
throw new Exception("解密私鑰爲空, 請設置");
}
Cipher cipher = null;
try {
cipher = Cipher.getInstance("RSA");
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 data 輸入數據
* @return byte[]
* @date 2019/12/3
* @author miracle_8
* @see [相關類/方法](可選)
* @since [產品/模塊版本](可選)
*/
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] & 0xf0)]);
if (i < data.length - 1) {
stringBuilder.append(' ');
}
}
return stringBuilder.toString();
}
/**
* byte轉換hex函數
*
* @param
* @return
* @date 2019/12/3
* @author miracle_8
* @see [相關類/方法](可選)
* @since [產品/模塊版本](可選)
*/
public static String byteToHex(byte[] byteArray) {
StringBuilder stringBuilder = new StringBuilder();
for (int i = 0; i < byteArray.length; i++) {
if (Integer.toHexString(0xFF & byteArray[i]).length() == 1) {
stringBuilder.append("0").append(Integer.toHexString(0xFF & byteArray[i]));
} else {
stringBuilder.append(Integer.toHexString(0xFF & byteArray[i]));
}
}
return stringBuilder.toString();
}
public static byte[] readFileByBytes(String fileName) {
File file = new File(fileName);
InputStream in = null;
byte[] txt = new byte[(int) file.length()];
try {
in = new FileInputStream(file);
int tempByte;
int i = 0;
while ((tempByte = in.read()) != -1) {
txt[i] = (byte) tempByte;
i++;
}
in.close();
return txt;
} catch (IOException e) {
e.printStackTrace();
return txt;
}
}
public static void main(String[] args) {
RsaEncrypt rsaEncrypt = new RsaEncrypt();
try {
// String publicKey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDPTrsUJ26WDSEQwKuAJhQ6XTNHKl1/+bWeyKRQKb0jeCyuiChMxN/qYSgg2BvS2bP51Rb5P9/UE1Rxm5drr3RYNMDvQoXBuA+rHiUX3wkdXmWSaktVbfe5C95N5FCF2jyLMIuWmrMk6Wo3r5MXrCb54A6zU7SzO/r7F0VkpBh9KwIDAQAB";
String publicKey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCwjCrXvf3JWq1cGwr7CyXzfUHolqKUdwyIb8MQUMCJFOPTzKB1wyFAacOogvSB3XkAUT/M9QTDsImYLRk7ISijQXekXcIEKwqej8TVsOaNIp0TITAmAQcusXpPuIpVa19q3PTpAzgEtGdW7ZKiqieom8Q3U00rXU+CdqKgJaE75QIDAQAB";
rsaEncrypt.loadPublicKey(publicKey);
System.out.println("加載公鑰成功");
} catch (Exception e) {
e.printStackTrace();
System.out.println("加載公鑰失敗");
}
try {
// String privateKey = "MIICeAIBADANBgkqhkiG9w0BAQEFAASCAmIwggJeAgEAAoGBAM9OuxQnbpYNIRDAq4AmFDpdM0cqXX/5tZ7IpFApvSN4LK6IKEzE3+phKCDYG9LZs/nVFvk/39QTVHGbl2uvdFg0wO9ChcG4D6seJRffCR1eZZJqS1Vt97kL3k3kUIXaPIswi5aasyTpajevkxesJvngDrNTtLM7+vsXRWSkGH0rAgMBAAECgYAlnFEQnP7RNlyTX4E95Kqy1AnjlWoVN8adoiU9bfUkpD7nA0jcdLNzIGFZZBvYKysd3m0ml1ISdddSLTpRjSl8K6O9dJDud3G9Oh3qCGgFflcKuKEXDnlaooX1sBrWF5vS0Gvg98x2C52Pnblm2eGVuTvCMaINDZLaamUlaFldMQJBAO3clhAIBJSWlm7Tt/a1d7+IbsGcS16Rk/N23DHg6LADXxIezxgSrpztSa5Nq81W5RC2WsotYYeRt+8KHsPRRn8CQQDfHa7A7hBTOT/V4FXTApuJUlReUh6cHWPsrxf/rUYKylK9WYBAJv1AZW9KaRtcadyu7ldNMb3MAsbE2vLoW2tVAkEAxhvLAF8tMXSapoO/3MMXkXbYiHjcbU9iooyEqSZhpven3ze51Jr6w8j+bSZTyRpufpTi2TEi4f8D6xvKs91BkQJBAKLS05xiX7GMfwSDQb7LEVzmo0FuJn6BiFHK+fWRqyLmwfkDHvAyQ/FB1TT1fY00iGN09msUWNFQWWSB8HEXfj0CQQCAJYV35rNJ781DXhBH5m1tq74zDNzAqynjm0hqhzlVMSHTYFIeU6SBnhk3swnfvJ8kgy3bQJtohYZ8Tuaz19VN";
String privateKey = "MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBALCMKte9/clarVwbCvsLJfN9QeiWopR3DIhvwxBQwIkU49PMoHXDIUBpw6iC9IHdeQBRP8z1BMOwiZgtGTshKKNBd6RdwgQrCp6PxNWw5o0inRMhMCYBBy6xek+4ilVrX2rc9OkDOAS0Z1btkqKqJ6ibxDdTTStdT4J2oqAloTvlAgMBAAECgYBhANL1cV3FSb5hEjbJUwnKLHOPQV0ZKARJ3uaVy1jOuRypHhC4Q7u8caBgsXt482BtrTbZ/XJdt10SsQzg8Uoq5m3biRASmuavz+7reYtv6mCYgDu2djUaQ7ocFaH3J5gCPYp8zdXIkuRJ3jzaMPXyiv2wK4vS/gLASyh4dIEMzQJBAOzLeu+VN0DD8/0kpYUASvTWHcaspBPc3nurwNyiAp4ASGi7MHHKVCZ1cCHROm2W/KBlNcCPKlpB0tJw+cl724MCQQC+3ckFcW3gtG3pWOg28NzD9yAA8RJWwZboF5J+ZBdis7crlZBiQs90NcpP64USyFdnEZsOEV8MWrMIfn2CiGZ3AkEA4REKmTu3l6xodPxnAoJjvFDjXlnrXiG5qcx29H5chHb6W+lHw3AvCZrn6Iyov08acQ2hyJOLCtyzmGffU12RJwJAOE3q0B0/AauYRN8CWbrCFVkgasay1z7yinLxtzFFqMtFPKk5V5NH6Ys4rEzZC8pn5jLOX98F//n9mILf+ZLNTwJBAKWH+duqt+3SqbWv4lHh7P/Z8lzSRS6n0p0ma+1vVQl95vY5pcp12GCIniUzKlH7XbZ5S9X5XbGI2inYYsiKGDs=";
rsaEncrypt.loadPrivateKey(privateKey);
System.out.println("加載私鑰成功");
} catch (Exception e) {
e.printStackTrace();
System.out.println("加載私鑰失敗");
}
// 測試字符串
String encryStr = "1212121212123234234sdfaffgterhkh";
try {
System.out.println(new Date());
// 加密
byte[] cipher = rsaEncrypt.encrypt(rsaEncrypt.getPublicKey(), encryStr.getBytes());
// 解密
byte[] plainText = rsaEncrypt.decrypt(rsaEncrypt.getPrivateKey(), cipher);
System.out.println(new Date());
System.out.println(new String(plainText));
byte[] content = readFileByBytes("C:\\Users\\miracle_8\\Desktop\\數字簽名\\數字簽名");
// 簽名驗證
byte[] signByte = rsaEncrypt.rsaSign(content, rsaEncrypt.getPrivateKey());
System.out.println("簽名----:" + byteToHex(signByte));
ByteUtil.saveFile(signByte, "C:\\Users\\miracle_8\\Desktop\\數字簽名", "數字簽名.sign");
Boolean isOk = rsaEncrypt.verify(content, signByte, rsaEncrypt.getPublicKey());
System.out.println("驗證:" + isOk);
// 讀取驗證文件
byte[] read = readFileByBytes("C:\\Users\\miracle_8\\Desktop\\數字簽名\\數字簽名.sign");
System.out.println("讀取簽名文件:" + byteToHex(read));
Boolean isFOk = rsaEncrypt.verify(content, read, rsaEncrypt.getPublicKey());
System.out.println("文件驗證2:" + isFOk);
} catch (Exception e) {
e.printStackTrace();
}
// rsaEncrypt.genKeyPair();
// System.out.println("publicKey:" + Base64Utils.encode(rsaEncrypt.getPublicKey().getEncoded()));
// System.out.println("privateKey:" + Base64Utils.encode(rsaEncrypt.getPrivateKey().getEncoded()));
}
}
Base64Utils.java
package com.sm.test1;
import java.io.UnsupportedEncodingException;
/**
* Base64 加密解密工具類
*
* @author miracle_8
* @date 2019/12/3
* @see [相關類/方法]（可選）
* @since [產品/模塊版本] （可選）
*/
public class Base64Utils {
private static char[] base64EncodeChars = new char[]
{ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5',
'6', '7', '8', '9', '+', '/' };
private static byte[] base64DecodeChars = new byte[]
{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63, 52, 53,
54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 26, 27, 28, 29,
30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1,
-1, -1, -1 };
public static String encode(byte[] data) {
StringBuffer sb = new StringBuffer();
int len = data.length;
int i = 0;
int b1, b2, b3;
while (i < len) {
b1 = data[i++] & 0xff;
if (i == len) {
sb.append(base64EncodeChars[b1 >>> 2]);
sb.append(base64EncodeChars[(b1 & 0x3) << 4]);
sb.append("==");
break;
}
b2 = data[i++] & 0xff;
if (i == len) {
sb.append(base64EncodeChars[b1 >>> 2]);
sb.append(base64EncodeChars[((b1 & 0x03) << 4) | ((b2 & 0xf0) >>> 4)]);
sb.append(base64EncodeChars[(b2 & 0x0f) << 2]);
sb.append("=");
break;
}
b3 = data[i++] & 0xff;
sb.append(base64EncodeChars[b1 >>> 2]);
sb.append(base64EncodeChars[((b1 & 0x03) << 4) | ((b2 & 0xf0) >>> 4)]);
sb.append(base64EncodeChars[((b2 & 0x0f) << 2) | ((b3 & 0xc0) >>> 6)]);
sb.append(base64EncodeChars[b3 & 0x3f]);
}
return sb.toString();
}
public static byte[] decode(String str) {
try {
return decodePrivate(str);
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
return new byte[]
{};
}
private static byte[] decodePrivate(String str) throws UnsupportedEncodingException {
StringBuffer sb = new StringBuffer();
byte[] data = null;
data = str.getBytes("US-ASCII");
int len = data.length;
int i = 0;
int b1, b2, b3, b4;
while (i < len) {
do {
b1 = base64DecodeChars[data[i++]];
} while (i < len && b1 == -1);
if (b1 == -1) {
break;
}
do {
b2 = base64DecodeChars[data[i++]];
} while (i < len && b2 == -1);
if (b2 == -1) {
break;
}
sb.append((char) ((b1 << 2) | ((b2 & 0x30) >>> 4)));
do {
b3 = data[i++];
if (b3 == 61) {
return sb.toString().getBytes("iso8859-1");
}
b3 = base64DecodeChars[b3];
} while (i < len && b3 == -1);
if (b3 == -1) {
break;
}
sb.append((char) (((b2 & 0x0f) << 4) | ((b3 & 0x3c) >>> 2)));
do {
b4 = data[i++];
if (b4 == 61) {
return sb.toString().getBytes("iso8859-1");
}
b4 = base64DecodeChars[b4];
} while (i < len && b4 == -1);
if (b4 == -1) {
break;
}
sb.append((char) (((b3 & 0x03) << 6) | b4));
}
return sb.toString().getBytes("iso8859-1");
}
}
***ByteUtil.java ***
package com.sm.test1;
import java.io.*;
/**
* byte數組工具類實現byte[]與文件之間的相互轉換
*
* @author miracle_8
* @date 2019/12/3
* @see [相關類/方法]（可選）
* @since [產品/模塊版本] （可選）
*/
public class ByteUtil {
public static byte[] getBytes(String filePath) {
byte[] buffer = null;
try {
File file = new File(filePath);
FileInputStream fis = new FileInputStream(file);
ByteArrayOutputStream bos = new ByteArrayOutputStream(1000);
byte[] b = new byte[1000];
int n;
while ((n = fis.read(b)) != -1) {
bos.write(b, 0, n);
}
fis.close();
bos.close();
buffer = bos.toByteArray();
}catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return buffer;
}
/**
* 根據byte數組，生成文件
*
* @param
* @return
* @date 2019/12/3
* @author miracle_8
* @see [相關類/方法](可選)
* @since [產品/模塊版本](可選)
*/
public static void saveFile(byte[] bfile, String filePath, String fileName) {
BufferedOutputStream bos = null;
FileOutputStream fos = null;
File file = null;
try {
File dir = new File(filePath);
// 判斷文件目錄是否存在
if (!dir.exists() && dir.isDirectory()) {
dir.mkdirs();
}
file = new File(filePath + "\\" + fileName);
fos = new FileOutputStream(file);
bos = new BufferedOutputStream(fos);
bos.write(bfile);
} catch (Exception e) {
e.printStackTrace();
} finally {
if (bos != null) {
try {
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (fos != null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
linux用openssl實現公鑰和私鑰
- 驗證openssl:
rpm -qa | grep openssl
2. yum安裝openssl
yum -y install openssl openssl-devel
3. 生成RSA私鑰：
openssl -> genrsa -out rsa_private_key.pem 1024
此時我們就可以在當前路徑下看到rsa_private_key.pem文件了，如下所示：
4. 把RSA私鑰轉換成PKCS8格式：
pkcs8 -topk8 -inform PEM -in rsa_private_key.pem -outform PEM -nocrypt
5. 生成RSA公鑰：
rsa -in rsa_private_key.pem -pubout -out rsa_public_key.pem
可以看到一個文件名爲rsa_public_key.pem的文件，打開它，可以看到-----BEGIN PUBLIC KEY-----開頭，-----END PUBLIC KEY-----結尾的沒有換行的字符串，這個就是公鑰：
附：ssh格式的公鑰
ssh-keygen -t rsa -f key
ssh-keygen -e -f key.pub > key_ss2.pub
