2. 程式人生 > >非對稱加密演算法RSA工具

非對稱加密演算法RSA工具

阿新 • • 發佈：2018-11-27

非對稱加密演算法RSA工具

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
 

import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
import java.security.SignatureException;
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 javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;

import org.bouncycastle.util.encoders.Base64;

public class RSAUtil
 
 {

	/**
	 * RSA演算法
	 */
	private static final String KEY_ALGORITHM = "RSA";
	/**
	 * 數字簽名
	 */
	private static final String SIGNATURE_ALGORITHM = "MD5withRSA";

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

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

	public static String[] createKeys() {
		try {
			KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
			keyPairGen.initialize(1024);
			KeyPair keyPair = keyPairGen.generateKeyPair();
			// 公鑰
			RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
			// 私鑰
			RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
			String[] res = new String[2];
			res[0] = byteArrayToBase64Str(publicKey.getEncoded());
			res[1] = byteArrayToBase64Str(privateKey.getEncoded());
			return res;
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		}
		return null;
	}

	private static byte[] base64StrToByteArray(String data) {
		return Base64.decode(data.getBytes());
	}

	private static String byteArrayToBase64Str(byte[] data) {
		return Base64.toBase64String(data);
	}

	/**
	 * 數字簽名
	 * 
	 * @param data       要簽名的密文
	 * @param privateKey 私鑰
	 * @return 返回簽名信息
	 */
	public static String RSASign(String data, String privateKey) {
		try {
			// 解密由base64編碼的私鑰
			byte[] keyBytes = base64StrToByteArray(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(base64StrToByteArray(data));
			return byteArrayToBase64Str(signature.sign());
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} catch (InvalidKeySpecException e) {
			e.printStackTrace();
		} catch (InvalidKeyException e) {
			e.printStackTrace();
		} catch (SignatureException e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 驗證簽名
	 * 
	 * @param data      要驗證的密文
	 * @param publicKey 公鑰
	 * @param sign      簽名信息
	 * @return 返回驗證成功狀態
	 */
	public static boolean RSAVerify(String data, String publicKey, String sign) {
		try {
			// 解密由base64編碼的公鑰
			byte[] keyBytes = base64StrToByteArray(publicKey);
			// 構造X509EncodedKeySpec物件
			X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
			// KEY_ALGORITHM 指定的加密演算法
			Signature signature;
			KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
			// 取公鑰匙物件
			PublicKey pubKey = keyFactory.generatePublic(keySpec);
			signature = Signature.getInstance(SIGNATURE_ALGORITHM);
			signature.initVerify(pubKey);
			signature.update(base64StrToByteArray(data));
			// 驗證簽名是否正常
			return signature.verify(base64StrToByteArray(sign));
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} catch (InvalidKeySpecException e) {
			e.printStackTrace();
		} catch (InvalidKeyException e) {
			e.printStackTrace();
		} catch (SignatureException e) {
			e.printStackTrace();
		}
		return false;
	}

	/**
	 * 私鑰解密
	 * 
	 * @param data 要解密的字串
	 * @param key  私鑰
	 * @return 返回解密後的字串
	 */
	public static String RSADecryptByPrivateKey(String data, String key) {
		try {
			// 對金鑰解密
			byte[] keyBytes = base64StrToByteArray(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);

			byte[] encryptedData = base64StrToByteArray(data);
			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 new String(decryptedData);
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} catch (InvalidKeySpecException e) {
			e.printStackTrace();
		} catch (NoSuchPaddingException e) {
			e.printStackTrace();
		} catch (InvalidKeyException e) {
			e.printStackTrace();
		} catch (IllegalBlockSizeException e) {
			e.printStackTrace();
		} catch (BadPaddingException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 公鑰解密
	 * 
	 * @param data 要解密的資料
	 * @param key  公鑰
	 * @return 返回解密後的資料
	 */
	public static String RSADecryptByPublicKey(String data, String key) {
		try {
			// 對金鑰解密
			byte[] keyBytes = base64StrToByteArray(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);

			byte[] encryptedData = base64StrToByteArray(data);
			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 new String(decryptedData);
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} catch (IllegalBlockSizeException e) {
			e.printStackTrace();
		} catch (BadPaddingException e) {
			e.printStackTrace();
		} catch (InvalidKeySpecException e) {
			e.printStackTrace();
		} catch (InvalidKeyException e) {
			e.printStackTrace();
		} catch (NoSuchPaddingException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 公鑰加密
	 * 
	 * @param data 要加密的資料
	 * @param key  公鑰
	 * @return 返回加密的資料
	 */
	public static String RSAEncryptByPublicKey(String data, String key) {
		try {
			// 對公鑰解密
			byte[] keyBytes = base64StrToByteArray(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);

			byte[] decryptedData = data.getBytes();
			int inputLen = decryptedData.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(decryptedData, offSet, MAX_ENCRYPT_BLOCK);
				} else {
					cache = cipher.doFinal(decryptedData, offSet, inputLen - offSet);
				}
				out.write(cache, 0, cache.length);
				i++;
				offSet = i * MAX_ENCRYPT_BLOCK;
			}
			byte[] encryptedData = out.toByteArray();
			out.close();
			return byteArrayToBase64Str(encryptedData);
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} catch (InvalidKeySpecException e) {
			e.printStackTrace();
		} catch (NoSuchPaddingException e) {
			e.printStackTrace();
		} catch (InvalidKeyException e) {
			e.printStackTrace();
		} catch (IllegalBlockSizeException e) {
			e.printStackTrace();
		} catch (BadPaddingException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 私鑰加密
	 * 
	 * @param data 要加密的資料
	 * @param key  私鑰
	 * @return 返回加密後的資料
	 */
	public static String RSAEncryptByPrivateKey(String data, String key) {
		try {
			// 對金鑰解密
			byte[] keyBytes = base64StrToByteArray(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);

			byte[] decryptedData = data.getBytes();
			int inputLen = decryptedData.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(decryptedData, offSet, MAX_ENCRYPT_BLOCK);
				} else {
					cache = cipher.doFinal(decryptedData, offSet, inputLen - offSet);
				}
				out.write(cache, 0, cache.length);
				i++;
				offSet = i * MAX_ENCRYPT_BLOCK;
			}
			byte[] encryptedData = out.toByteArray();
			out.close();
			return byteArrayToBase64Str(encryptedData);
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} catch (InvalidKeyException e) {
			e.printStackTrace();
		} catch (InvalidKeySpecException e) {
			e.printStackTrace();
		} catch (NoSuchPaddingException e) {
			e.printStackTrace();
		} catch (IllegalBlockSizeException e) {
			e.printStackTrace();
		} catch (BadPaddingException e) {
			e.printStackTrace

相關推薦

非對稱加密演算法RSA工具

非對稱加密演算法RSA工具 import java.io.ByteArrayOutputStream; import java.io.IOException; import java.security.InvalidKeyException; import java.security.K

非對稱加密演算法RSA公鑰私鑰的模數和指數提取方法

生成非對稱加密演算法RSA公鑰、私鑰的方法： 1. 通過OpenSSL庫生成，可參考  https://github.com/fengbingchun/OpenSSL_Test/blob/master/demo/OpenSSL_Test/funset.cpp  中的Gen

Java非對稱加密演算法RSA

流程分析：  甲方構建金鑰對兒，將公鑰公佈給乙方，將私鑰保留。 甲方使用私鑰加密資料，然後用私鑰對加密後的資料簽名，傳送給乙方簽名以及加密後的資料；乙方使用公鑰、簽名來驗證待解密資料是否有效，如果有效使用公鑰對資料解密。 乙方使用公鑰加密資料，向甲方傳送經過加密後的資料

資料傳輸加密——非對稱加密演算法RSA+對稱演算法AES(適用於java,android和Web)

本篇文章已授權微信公眾號 guolin_blog （郭霖）獨家釋出 資料傳輸加密   在開發應用過程中，客戶端與服務端經常需要進行資料傳輸，涉及到重要隱私資訊時，開發者自然會想到對其進行加密，即使傳輸過程中被“有心人”擷取，也不會將資訊洩露。對於加密

【IoT】加密與安全：非對稱加密演算法 RSA 1024 公鑰、祕鑰、明文和密文長度

RSA 1024 是指公鑰及私鑰分別是 1024bit，也就是 1024/8 = 128Bytes。 RSA 演算法金鑰長度的選擇是安全性和程式效能平衡的結果，金鑰長度越長，安全性越好，加密解密所需時間越長。 1、非對稱加密演算法中 1024bit 金鑰的強度相當於對稱加

非對稱加密演算法-RSA演算法

  加密演算法分為對稱加密演算法和非對稱加密演算法，其中非對稱加密演算法作為計算機通訊安全的基石，在保證資料安全方面起著重要的作用。而相對於對稱加密演算法的易理解性，非對稱加密演算法存在一定的難度。下面通過對RSA演算法的剖析，讓我們更好的理解非對稱加密演算法的原理。 一、對稱加密演算法和非對稱加密演算法 1

非對稱加密演算法RSA 學習

非對稱加密演算法RSA 學習 RSA加密演算法是一種非對稱加密演算法。RSA是1977年由羅納德·李維斯特（Ron Rivest）、阿迪·薩莫爾（Adi Shamir）和倫納德·阿德曼（Leonard Adleman）一起提出的。當時他們三人都在麻省理工學院工作。RSA就是他們三人姓氏開頭字母拼在一起組成的。

php openssl_sign() 語法+RSA公私鑰加密解密,非對稱加密演算法詳解

其實有時候覺得寫部落格好煩，就個函式就開篇部落格。很小的意見事情而已，知道的人看來多取一舉，或者說沒什麼必要，浪費時間，不知道的人就會很鬱悶。技術就是這樣的，懂的人覺得真的很簡單啊，不知道的人真的好難。。。 一般在跟第三方介面對接資料的時候，為了保證很多都使用的RSA簽名，沒性趣瞭解的同學只需要

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

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

非對稱加密之RSA演算法

1977年，MIT的三位老師Rivest、Shamir 和 Adleman 設計了一種演算法，可以實現非對稱加密。這種演算法以他們三個人的名字命名為RSA。RSA演算法是使用最為廣泛的非對稱加密演算法。 RSA加密利用了單向函式正向求解很簡單，反向求解很複雜的特

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

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

JAVA密碼加密演算法.RSA演算法(非對稱加密演算法)和密碼加鹽MD5

密碼加鹽MD5 Message Digest Algorithm MD5（中文名為訊息摘要演算法第五版）為電腦保安領域廣泛使用的一種雜湊函式，用以提供訊息的完整性保護。 是計算機廣泛使用的雜湊演算法之一（又譯摘要演算法、雜湊演算法），主流程式語言普遍已有MD5實現。將資料（如漢字）運

php RSA非對稱加密演算法

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

JAVA實現RSA加密,非對稱加密演算法

RSA.java package org.icesnow.jeasywx.util.security; import java.security.Key; import java.security.KeyFactory; import java.security.KeyPair;

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

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

Java 加密解密 對稱加密演算法 非對稱加密演算法 MD5 BASE64 AES RSA

【前言】 本文簡單的介紹了加密技術相關概念，最後總結了java中現有的加密技術以及使用方法和例子 【最簡單的加密】1.簡單的概念 明文：加密前的資訊 密文：機密後的資訊 演算法：加密或解密的演算法 金鑰：演算法使用的鑰匙（讀作miyao，正確應該是miyue，但是大家都讀m

[加密]--PHP 使用非對稱加密演算法（RSA）

解釋 非對稱加密演算法需要兩個金鑰：公開金鑰（publickey）和私有金鑰（privatekey）。 公開金鑰與私有金鑰是一對，如果用公開金鑰對資料進行加密，只有用對應的私有金鑰才能解密； 如果用私有金鑰對資料進行加密，那麼只有用對應的公開金鑰才能解密。 因為加密和

非對稱加密演算法（2）：RSA

一.RSA：RSA公鑰加密演算法是1977年由羅納德·李維斯特（Ron Rivest）、阿迪·薩莫爾（Adi Shamir）和倫納德·阿德曼（Leonard Adleman）一起提出的。1987年7月首次在美國公佈，當時他們三人都在麻省理工學院工作實習。RSA就是他們

c語言實現rsa nopadding非對稱加密演算法（openssl api方式），匹配java後端 bouncycastle

公私鑰： —–BEGIN PUBLIC KEY—– MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC32V2IAfotG8bZhPF8/Bx8y65g EDycAMyTWmvpPCfagEKORO/WvdkTYim7yhG/+

RSA ~ 非對稱加密演算法

RSA：      非對稱加密，加密與解密使用的金鑰不是同一金鑰，對中一個對外公開，稱為公鑰，另一個只有所有者知道，稱為私鑰。      用公鑰加密的資訊只有私鑰才能解開，反之，用私鑰加密的資訊只有公鑰才能解開（簽名驗籤）。      代表：RSA演算法。速度慢，