JAVA RSA非对称加密实现--工具类

最新推荐文章于 2024-03-19 18:38:26 发布
最新推荐文章于 2024-03-19 18:38:26 发布
阅读量317 收藏 2
点赞数
分类专栏： java 文章标签： 加密解密
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39668819/article/details/106502144
版权
工具类
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

import javax.crypto.Cipher;

import java.io.ByteArrayOutputStream;
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;

/**
 * RSA加密工具类 使用PKCS1_PADDING填充，密钥长度1024
 * 加解密结果在这里测试通过：http://tool.chacuo.net/cryptrsaprikey 注意加密内容的编码要一致，统一UTF-8比较好
 *
 * @author akieay
 */
public class RSAUtil {

	private static final String privatekey = "MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAJm/9uevAvDNI4C58N8c2H8Z6wPR" +
			"sEJ6erkdMbhYV+X1G39lWR05oobt0h85F97V/IQMzASCG4e3lEky56pnJOPaX4MO96aDcWBencf7" +
			"q5WBOTj+CD0MXy/5B5oiqihBKx6N/VSTwbmdgYLCkMvL1UGGfS112qiFaLesxWsZg41LAgMBAAEC" +
			"gYAfMKk3APL4xLTSFWZ+7Iwi5LAfezdllRE2YmzGt+1E8j9czcORQTLuamp4+Q0VoJV0eGAe/gH1" +
			"u1EytEf48qmx2h/vCpwn1mCFcTHV9PHEX2ZvkObeeN0T0KEZ5EGsn0G/zVOSPXupnnK0QSocXOsY" +
			"rtjOW/y19vq135ASMBBxWQJBAOaYeepTSnA2d7YiczxFiU1MaTAe/gVuUMGAuYkolzxqDWw6zYyO" +
			"q6AIm3xFD/oWBHAIECWD5/H8qXNCF4Ff6EcCQQCqsDIWvGG51v8Jz++pR49xsy5cZHQ8HRajtICk" +
			"rr3sY5S9pOHufyZdgwSpKkH4iaicWY5ds2QFdWWyTY0Wk7jdAkBIG/pT6oPmn0HENPWwLVaIU5K5" +
			"N5fb/ulF+YkLeSQCAm/8Hk9U2vCUdNyaecZLQENW/U5/TMZlh8s9fbd3/5PVAkAHmjdw6c0UgO31" +
			"GuzaxlQuRUPQW60NrGIAwp5kN2BAMiNC2yAxBjrIOXiwrDAqCL+YzyhXJhFTaOoxqeCZ29SFAkEA" +
			"3PmrghxHRGr0rc+VqNtgdUad/YHDHvjZaC7tAaHnGRGathIibVn8SrQbNZjSI5vCb6FgYVaKX6V2" +
			"yfO/YzOC/w==";

	private static final String publickey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCZv/bnrwLwzSOAufDfHNh/GesD0bBCenq5HTG4" +
			"WFfl9Rt/ZVkdOaKG7dIfORfe1fyEDMwEghuHt5RJMueqZyTj2l+DDvemg3FgXp3H+6uVgTk4/gg9" +
			"DF8v+QeaIqooQSsejf1Uk8G5nYGCwpDLy9VBhn0tddqohWi3rMVrGYONSwIDAQAB";

	public static final String KEY_ALGORTHM = "RSA";
	public static final String SIGNATURE_ALGORITHM = "MD5withRSA";

	public static final String PUBLIC_KEY = "RSAPublicKey";
	public static final String PRIVATE_KEY = "RSAPrivateKey";

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

	public static String getPrivatekey() {
		return privatekey;
	}

	public static String getPublickey() {
		return publickey;
	}

	/**
	 * 初始化密钥 RSA加密解密的实现，需要有一对公私密钥，公私密钥的初始化如下 非对称加密一般都用于加密对称加密算法的密钥，而不是直接加密内容
	 * @return
	 * @throws Exception
	 */
	public static Map<String, Object> initKey() throws Exception {
		KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORTHM);
		keyPairGenerator.initialize(1024);
		KeyPair keyPair = keyPairGenerator.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;
	}

	/**
	 * 取得公钥，并转化为String类型
	 *
	 * @param keyMap
	 * @throws Exception
	 * @return-
	 */
	public static String getPublicKey(Map<String, Object> keyMap) throws Exception {
		Key key = (Key) keyMap.get(PUBLIC_KEY);
		return Coder.encryptBASE64(key.getEncoded());
	}

	/**
	 * 取得私钥，并转化为String类型
	 *
	 * @param keyMap
	 * @return
	 * @throws Exception
	 */
	public static String getPrivateKey(Map<String, Object> keyMap) throws Exception {
		Key key = (Key) keyMap.get(PRIVATE_KEY);
		return Coder.encryptBASE64(key.getEncoded());
	}


	/**
	 * 用私钥加密
	 *
	 * @param data
	 *            加密数据
	 * @param key
	 *            密钥
	 * @return
	 * @throws Exception
	 */
	public static byte[] encryptByPrivateKey(byte[] data, String key) throws Exception {

		byte[] keyBytes = Coder.decryptBASE64(key);
		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM);
		Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(Cipher.ENCRYPT_MODE, privateK);
		int inputLen = data.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(data, offSet, MAX_ENCRYPT_BLOCK);
			} else {
				cache = cipher.doFinal(data, offSet, inputLen - offSet);
			}
			out.write(cache, 0, cache.length);
			i++;
			offSet = i * MAX_ENCRYPT_BLOCK;
		}
		byte[] encryptedData = out.toByteArray();
		out.close();
		return encryptedData;

	}

	/**
	 * 用私钥解密 * @param data 加密数据
	 *
	 * @param key
	 *            密钥
	 * @return
	 * @throws Exception
	 */
	public static byte[] decryptByPrivateKey(byte[] data, String key) throws Exception {
		byte[] keyBytes = Coder.decryptBASE64(key);
		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM);
		Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(Cipher.DECRYPT_MODE, privateK);
		int inputLen = data.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(data, offSet, MAX_DECRYPT_BLOCK);
			} else {
				cache = cipher.doFinal(data, offSet, inputLen - offSet);
			}
			out.write(cache, 0, cache.length);
			i++;
			offSet = i * MAX_DECRYPT_BLOCK;
		}
		byte[] decryptedData = out.toByteArray();
		out.close();
		return decryptedData;

	}

	/**
	 * 用公钥加密
	 *
	 * @param data
	 *            加密数据
	 * @param key
	 *            密钥
	 * @return
	 * @throws Exception
	 */
	public static byte[] encryptByPublicKey(byte[] data, String key) throws Exception {
		byte[] keyBytes = Coder.decryptBASE64(key);
		X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM);
		Key publicK = keyFactory.generatePublic(x509KeySpec);
		// 对数据加密
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(Cipher.ENCRYPT_MODE, publicK);
		int inputLen = data.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(data, offSet, MAX_ENCRYPT_BLOCK);
			} else {
				cache = cipher.doFinal(data, offSet, inputLen - offSet);
			}
			out.write(cache, 0, cache.length);
			i++;
			offSet = i * MAX_ENCRYPT_BLOCK;
		}
		byte[] encryptedData = out.toByteArray();
		out.close();
		return encryptedData;
	}

	/**
	 * 用公钥解密
	 *
	 * @param data
	 *            加密数据
	 * @param key
	 *            密钥
	 * @return
	 * @throws Exception
	 */
	public static byte[] decryptByPublicKey(byte[] data, String key) throws Exception {
		byte[] keyBytes = Coder.decryptBASE64(key);
		X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM);
		Key publicK = keyFactory.generatePublic(x509KeySpec);
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(Cipher.DECRYPT_MODE, publicK);
		int inputLen = data.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(data, offSet, MAX_DECRYPT_BLOCK);
			} else {
				cache = cipher.doFinal(data, offSet, inputLen - offSet);
			}
			out.write(cache, 0, cache.length);
			i++;
			offSet = i * MAX_DECRYPT_BLOCK;
		}
		byte[] decryptedData = out.toByteArray();
		out.close();
		return decryptedData;
	}

	/**************************************************************************
	 * 通过RSA加密解密算法，我们可以实现数字签名的功能。我们可以用私钥对信息生 成数字签名，再用公钥来校验数字签名，当然也可以反过来公钥签名，私钥校验。
	 *************************************************************************/

	/**
	 * 用私钥对信息生成数字签名
	 *
	 * @param data
	 *            //加密数据
	 * @param privateKey
	 *            //私钥
	 * @return
	 * @throws Exception
	 */
	public static String sign(byte[] data, String privateKey) throws Exception {
		// 解密私钥
		byte[] keyBytes = Coder.decryptBASE64(privateKey);
		// 构造PKCS8EncodedKeySpec对象
		PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(keyBytes);
		// 指定加密算法
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM);
		// 取私钥匙对象
		PrivateKey privateKey2 = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
		// 用私钥对信息生成数字签名
		Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
		signature.initSign(privateKey2);
		signature.update(data);

		return Coder.encryptBASE64(signature.sign());
	}

	/**
	 * 校验数字签名
	 *
	 * @param data
	 *            加密数据
	 * @param publicKey
	 *            公钥
	 * @param sign
	 *            数字签名
	 * @return
	 * @throws Exception
	 */
	public static boolean verify(byte[] data, String publicKey, String sign) throws Exception {
		// 解密公钥
		byte[] keyBytes = Coder.decryptBASE64(publicKey);
		// 构造X509EncodedKeySpec对象
		X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(keyBytes);
		// 指定加密算法
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM);
		// 取公钥匙对象
		PublicKey publicKey2 = keyFactory.generatePublic(x509EncodedKeySpec);

		Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
		signature.initVerify(publicKey2);
		signature.update(data);
		// 验证签名是否正常
		return signature.verify(Coder.decryptBASE64(sign));

	}

	/**
	 * 使用公钥对参数进行加密
	 * @param paramStr
	 * @return
	 */
	public static String toEncrypt(String paramStr, String publickey) throws Exception{
		byte[] publicEncrypt = encryptByPublicKey(paramStr.getBytes("UTF-8"), publickey.replace(" ", ""));
		return Coder.encryptBASE64(publicEncrypt);
	}
	/**
	 * 使用私钥对数据解密
	 * @param pwd
	 * @return
	 */
	public static String toDencrypt(String pwd) throws Exception{
		String privatekey = "MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAJKpBM8FQknWV4W+0uJrEkbR4pZS\r\n"
				+ "qBfxCDApe0NA2SAW7ZWL8OM0LWXP5XhYQCStnUGT5GLrqxUZzTxm/HfHpv7loKrW8RNwZBCOq2lS\r\n"
				+ "ekTGHSpytTgV7B9JdE1PNIlNmN4CM3wEwJfEWp3dFmXm6EEyn/pe009F+zEbDY6dQSQrAgMBAAEC\r\n"
				+ "gYBAoEglLY0TWmdA4WCuMz5fhLdTRGMcAbN4/Z56eUX0VQYmgv8IL4LdvWnBySmiv/pu3kuip3TB\r\n"
				+ "HJiKyFryMUFNn7c4wwe3bE7qTbxlI12HVNi2TM5juSwkcOnQoCSO36GUQnpTfircp1hUudmAudpE\r\n"
				+ "H3iB5q7KYvs9mOaVJQ892QJBANU5W1R+4bWjSvz06Yd9MrWobgTmk8dmwQ1gb5dryxvzpT7lLQtQ\r\n"
				+ "W+17mwByPWbdU4To1mvdESo6HqD5D9AnRt0CQQCwFR0xJ1i+BWMRs8dk6nv3TEbfCYG62ymxoOEB\r\n"
				+ "zTy1Gl43GT7T3gFd5X2U2FR5Yq3Wl9zoHUgVRMSb9XgKafKnAkBRJ7OLRX/DEpPIE6+O0igq3CCD\r\n"
				+ "3P8CNinkXYAbsftseB+9AJ1UYRGcIh+s285jCHpxa+2wwEN4PwbJXgKWx1xBAkBtxev6DdaUOFWH\r\n"
				+ "3rVrI4f/Jy1ztMCM1j8K/wnnjqTPHs4nuXRirx/ZAs4ksi0Ps8Y+Z1SP3Flo8QNFW2Xn0B83AkB4\r\n"
				+ "6voviQRiKWwUjX1xPikrLEWNmLw94MUvAcUb4kH2vvpsRBJzaWAP5/ZaF9QOMCokyYtWTF5Y88/w\r\n" + "1PfezMdT";
		byte[] messages = Coder.decryptBASE64(pwd);
		return new String(decryptByPrivateKey(messages, privatekey.replace(" ", "")));
	}
	
	public static void main(String[] args) throws Exception {
		// 生产密钥
//		Map<String, Object> keys = RSAUtil.initKey();
//		String privatekey = RSAUtil.getPrivateKey(keys);
//		String publickey = RSAUtil.getPublicKey(keys);
//
//		// 打印私钥
//		System.out.println("-----BEGIN PRIVATE KEY-----");
//		System.out.println(privatekey);
//		System.out.println("-----END PRIVATE KEY-----");
//
//		System.out.println();
//
//		// 打印公钥
//		System.out.println("-----BEGIN PUBLIC KEY-----");
//		System.out.println(publickey);
//		System.out.println("-----END PUBLIC KEY-----");

//		// RSA公钥加密
//
//		String message = "hello";
//		byte[] publicEncrypt = encryptByPublicKey(message.getBytes("UTF-8"), publickey.replace(" ", ""));
//		String publicBase = Coder.encryptBASE64(publicEncrypt);
//		System.out.println("公钥加密：" + publicBase);
//
//		// RSA私钥解密
//		byte[] messages = Coder.decryptBASE64(publicBase);
//		String decryptedNaughty = new String(decryptByPrivateKey(messages, privatekey.replace(" ", "")));
//		System.out.println("私钥解密" + decryptedNaughty);
//
//		// RSA私钥加密
//		byte[] privateEncrypt = encryptByPrivateKey(message.getBytes("UTF-8"), privatekey.replace(" ", ""));
//		String privateBase = Coder.encryptBASE64(privateEncrypt);
//		System.out.println("私钥加密" + privateBase);
//
//		// RSA公钥解密
//		byte[] messages1 = Coder.decryptBASE64(privateBase);
//		String decryptedNaughty1 = new String(decryptByPublicKey(messages1, publickey.replace(" ", "")));
//		System.out.println("公钥解密" + decryptedNaughty1);

		syjm();
	}

	/**
	 * 使用默认公钥对数据进行加密并使用 Base64转码成字符串
	 * @param data
	 * @return
	 * @throws Exception
	 */
	public static String publicKeyEncryption(String data) throws Exception {
		byte[] publicEncrypt = encryptByPublicKey(data.getBytes("UTF-8"), publickey.replace(" ", ""));
		return Coder.encryptBASE64(publicEncrypt);
	}

	/**
	 * 使用默认私钥对数据进行解密
	 * @param encryptionData
	 * @return
	 * @throws Exception
	 */
	public static String privateKeyDecryption(String encryptionData) throws Exception {
		byte[] messages = Coder.decryptBASE64(encryptionData);
		String data = new String(decryptByPrivateKey(messages, privatekey.replace(" ", "")));
		return data;
	}

	/***
	 * 测试加密
	 */
	public static void syjm() throws Exception {
		String privatekey = "MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAJm/9uevAvDNI4C58N8c2H8Z6wPR" +
				"sEJ6erkdMbhYV+X1G39lWR05oobt0h85F97V/IQMzASCG4e3lEky56pnJOPaX4MO96aDcWBencf7" +
				"q5WBOTj+CD0MXy/5B5oiqihBKx6N/VSTwbmdgYLCkMvL1UGGfS112qiFaLesxWsZg41LAgMBAAEC" +
				"gYAfMKk3APL4xLTSFWZ+7Iwi5LAfezdllRE2YmzGt+1E8j9czcORQTLuamp4+Q0VoJV0eGAe/gH1" +
				"u1EytEf48qmx2h/vCpwn1mCFcTHV9PHEX2ZvkObeeN0T0KEZ5EGsn0G/zVOSPXupnnK0QSocXOsY" +
				"rtjOW/y19vq135ASMBBxWQJBAOaYeepTSnA2d7YiczxFiU1MaTAe/gVuUMGAuYkolzxqDWw6zYyO" +
				"q6AIm3xFD/oWBHAIECWD5/H8qXNCF4Ff6EcCQQCqsDIWvGG51v8Jz++pR49xsy5cZHQ8HRajtICk" +
				"rr3sY5S9pOHufyZdgwSpKkH4iaicWY5ds2QFdWWyTY0Wk7jdAkBIG/pT6oPmn0HENPWwLVaIU5K5" +
				"N5fb/ulF+YkLeSQCAm/8Hk9U2vCUdNyaecZLQENW/U5/TMZlh8s9fbd3/5PVAkAHmjdw6c0UgO31" +
				"GuzaxlQuRUPQW60NrGIAwp5kN2BAMiNC2yAxBjrIOXiwrDAqCL+YzyhXJhFTaOoxqeCZ29SFAkEA" +
				"3PmrghxHRGr0rc+VqNtgdUad/YHDHvjZaC7tAaHnGRGathIibVn8SrQbNZjSI5vCb6FgYVaKX6V2" +
				"yfO/YzOC/w==";

		String publickey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCZv/bnrwLwzSOAufDfHNh/GesD0bBCenq5HTG4" +
				"WFfl9Rt/ZVkdOaKG7dIfORfe1fyEDMwEghuHt5RJMueqZyTj2l+DDvemg3FgXp3H+6uVgTk4/gg9" +
				"DF8v+QeaIqooQSsejf1Uk8G5nYGCwpDLy9VBhn0tddqohWi3rMVrGYONSwIDAQAB";

		// 公钥加密\
		String message = "{\"LOCKMAC\": \"00:00:a4:fa:fe:3f\", \"TIMESTAMP\": \"1559527190799\", \"FKEY\": \"ae7d4f45e4b6f22cdc56931c2f807d26\"}";
		byte[] publicEncrypt = encryptByPublicKey(message.getBytes("UTF-8"), publickey.replace(" ", ""));
		String publicBase = Coder.encryptBASE64(publicEncrypt);
		System.out.println("公钥加密：" + publicBase);

		// RSA私钥解密
		byte[] messages = Coder.decryptBASE64(publicBase);
		String decryptedNaughty = new String(decryptByPrivateKey(messages, privatekey.replace(" ", "")));
		System.out.println("私钥解密" + decryptedNaughty);
//
//		// RSA私钥加密
//		byte[] privateEncrypt = encryptByPrivateKey(message.getBytes("UTF-8"), privatekey.replace(" ", ""));
//		String privateBase = Coder.encryptBASE64(privateEncrypt);
//		System.out.println("私钥加密" + privateBase);
//
//		// RSA公钥解密
//		byte[] messages1 = Coder.decryptBASE64(privateBase);
//		String decryptedNaughty1 = new String(decryptByPublicKey(messages1, publickey.replace(" ", "")));
//		System.out.println("公钥解密" + decryptedNaughty1);
	}
}

class Coder {
	/**
	 * 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);
	}
}
akieay
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA中RSA加密解密工具类
07-13
JAVA中RSA加密解密工具类
工具类-RSA非对称加密工具类，自用留存
07-06
工具类-RSA非对称加密工具类，自用留存
JAVA 做非对称加密（RSA）
java_chc的博客
09-22 4376
java项目中使用 RSA 非对称加密实现对数据的加解密和生成签名（sign），全流程记录
RSA加密解密签名加签验签RsaUtils工具类
最新发布
gongjin28_csdn的博客
03-19 1112
RSA基于数学上的大整数因子分解难题，只要密钥足够大（通常建议至少2048位），在现有的计算机技术和算法条件下，破解RSA加密的数据所需的时间极其漫长，从而确保了高度的安全性。RSA算法基于大数因子分解难题，提供了公钥加密和私钥解密的能力。：除了加密外，RSA还可用于数字签名，通过私钥对数据进行签名，然后接收方可以用公钥验证签名的真实性，确保数据完整性并确认发送者的身份。：虽然实际运算复杂，但RSA算法本身是公开的，这增强了人们对算法安全性的信任，因为任何潜在的漏洞都可以经过全球专家的审查和改进。
JAVA RSA非对称加密工具类
默默不代表沉默
11-17 1455
RSATestUtils.java import org.apache.tomcat.util.codec.binary.Base64; import javax.crypto.BadPaddingException; import javax.crypto.Cipher; import javax.crypto.IllegalBlockSizeException; import javax.crypto.NoSuchPaddingException; import java.nio.chars..
Java之对称加密
小小熊的博客
01-26 6818
对称加密 采用单钥密码系统的加密方法，同一个密钥可以同时用作信息的加密和解密，这种加密方法称为对称加密，也称为单密钥加密。 常见的对称加密方法 DES : Data Encryption Standard，即数据加密标准，是一种使用密钥加密的块算法，1977年被美国联邦政府的国家标准局确定为联邦资料处理标准（FIPS），并授权在非密级政府通信中使用，随后该算法在国际上广泛流传开来。 AES : Advanced Encryption Standard, 高级加密标准 .在密码学中又称Rijndael加密法
3分钟快速了解使用Java进行对称加密
万猫学社
04-03 2641
在这个例子中，我们使用了AES算法，并且使用了ECB模式和PKCS5Padding填充方式。ECB是一种简单的模式，它将明文分成固定大小的数据块，并将每个数据块分别加密。PKCS5Padding是一种填充方式，它在明文末尾填充适当的字节，使明文长度为块长度的整数倍。在这个例子中，我们首先使用相同的密钥生成器来生成相同的密钥。然后，我们使用相同的加密器类和密钥对明文进行加密，并将加密后的密文作为输入传递给解密器类。因为我们使用相同的密钥，所以解密器类可以正确地解密密文，并且输出明文。我们为什么要使用加密呢？
rsa非对称加密java工具类
02-08
项目中使用过的一个rsa非对称加密类，用着很不错 ，需要注意的是里边的密钥长度最小是128，不能再小了，还有里边用到了base64的编码，我们用的是jdk 1.8自带的工具类，如果要用的童靴的项目是不jdk 1.8的项目也可以...
RSA非对称加密工具类-java
03-09
RSA非对称加密工具类 用于网络传输中数据加密
Rsa非对称加密技术工具类
03-10
Rsa非对称加密技术工具类
RSA非对称加密工具类
03-09
RSA非对称加密工具类，用于网络信息传输中
独孤密码-非对称加密算法RSA解析
01-07
公私钥的生成可以通过现成的工具软件或者写java代码来生成RSA公私钥对,java密钥类及keytools都可以.常用的RSA密钥长度有1028位和2048位,JAVA7本身实现了1028位.如果使用2048位可通过BouncyCastle实现. 三.RS
RSA非对称加密解密
04-26
一， ToolsUtil.java为主要加密解密的工具类。里面的Public.key加密字符，Private.key解密字符方法按项目修改路径。 二， Test为加密数据库用户名和密码，生成完成后可将其赋值到属性文件中。 三， Crypt.java文件...
RSA非对称加密前端用工具类
03-09
RSA非对称加密前端工具类 用于网络传输中数据加密
Java实现RSA加解密工具类Demo
11-08
这个RSA加解密的Demo是我从别的地方花了好多金币下载的，希望对大家有帮助，资源共享嘛。
vue生成rsa非对称加密工具类及使用方法（包含公钥加密，私钥解密）
03-11
RSA加密算法是一种非对称加密算法。在公开密钥加密和电子商业中RSA被广泛使用。RSA公开密钥密码体制。所谓的公开密钥密码体制就是使用不同的加密密钥与解密密钥，是一种“由已知加密密钥推导出解密密钥在计算上是不...
密码学【java】初探究加密方式之对称加密
缘友一世的博客
05-02 1399
该类提供加密和解密的加密密码的功能。它构成了Java加密扩展（JCE）框架的核心。为了创建一个Cipher对象，应用程序调用Cipher的getInstance方法，并将所请求的转换的名称传递给它。可选地指定提供者的名称。转换是描述要在给定输入上执行的操作（或操作集）的字符串，以产生一些输出。转换包括**：加密算法的名称（例如， DES ），并且可以跟随有反馈模式和填充方案。
RSA加密算法介绍及Java工具类
Java修炼记
11-22 2610
RSA加密算法是一种非对称加密算法，所谓非对称，就是指该算法加密和解密使用不同的密钥，即使用加密密钥进行加密、解密密钥进行解密。在RAS算法中，加密密钥（即公开密钥）PK是公开信息，而解密密钥（即秘密密钥）SK是需要保密的。
Java RSA 加密解密工具类 RSAUtil 支持长文本加密解密（密钥对生成、公钥加密、私钥加密、公钥解密、私钥解密）
emmmm.....
10-24 2252
对于加密解密的代码，我把我能想到的可能会使用的都封装在了如下工具类中，代码注释也尽量写详细了，如：密钥对生成、公钥加密、私钥加密、公钥解密、私钥解密，不包括其中的 main 测试的话，加上注释 500+ 行，嘿嘿~
javarsa实现接口安全
08-09
Java RSA（Rivest-Shamir-Adleman）是一种非对称加密算法，它使用了一对公钥和私钥进行加密和解密。接口安全是指在网络通信中保护接口的安全性，防止未经授权的访问和数据泄露。下面是使用Java RSA实现接口安全的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值