java实现双向ECC + AES加密

最新推荐文章于 2024-05-26 20:43:15 发布
最新推荐文章于 2024-05-26 20:43:15 发布
阅读量6.5k 收藏 18
点赞数 2
分类专栏： 加密解密 加密解密
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32523587/article/details/79221696
版权
本文补充了《java实现双向RSA + AES加密》的内容，重点介绍如何使用bouncycastle库实现在Java中进行双向椭圆曲线（ECC）加密解密。首先，需要解除JDK默认加密强度限制，然后下载并替换JDK安全目录中的jar包，接着引入bouncycastle库。提供了ECCUtil和HttpEncryptUtil的代码示例。
摘要由CSDN通过智能技术生成

本文主要是前面《java实现双向RSA + AES加密》的补充，只补充新增的代码，


JDK中自带了椭圆曲线的签名，但是没有实现椭圆曲线的加密解密。不过bouncycastle库实现了，下面的代码需要bouncycastle库。

需要做的准备工作：


1. 去JDK的下载页面，下载


http://www.oracle.com/technetwork/java/javase/downloads/jce8-download-2133166.html 

这个东西。这个是为了解除默认JDK中的加密强度的限制。不使用这个可能会报错。

下载下来以后，需要将local_policy.jar 和 US_export_policy.jar替换掉D:\Program Files\Java\jdk1.8.0_91\jre\lib\security下面的相同的两个jar包。


2. 下载bouncycastle的jar文件，加入classpath中。

http://mvnrepository.com/artifact/org.bouncycastle/bcprov-jdk15on 


下面上代码

ECCUtil：

package com.zhuyun.encrypt;

import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.Security;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

import javax.crypto.Cipher;

import org.bouncycastle.jce.interfaces.ECPrivateKey;
import org.bouncycastle.jce.interfaces.ECPublicKey;


public class ECCUtil {
	static {
		Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
	}
	
	//生成秘钥对
	public static KeyPair getKeyPair() throws Exception {
		KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("EC", "BC");
		keyPairGenerator.initialize(256, new SecureRandom());
		KeyPair keyPair = keyPairGenerator.generateKeyPair();
		return keyPair;
	}
	
	//获取公钥(Base64编码)
	public static String getPublicKey(KeyPair keyPair){
		ECPublicKey publicKey = (ECPublicKey) keyPair.getPublic();
		byte[] bytes = publicKey.getEncoded();
		return AESUtil.byte2Base64(bytes);
	}
	
	//获取私钥(Base64编码)
	public static String getPrivateKey(KeyPair keyPair){
		ECPrivateKey privateKey = (ECPrivateKey) keyPair.getPrivate();
		byte[] bytes = privateKey.getEncoded();
		return AESUtil.byte2Base64(bytes);
	}
	
	//将Base64编码后的公钥转换成PublicKey对象
	public static ECPublicKey string2PublicKey(String pubStr) throws Exception{
		byte[] keyBytes = AESUtil.base642Byte(pubStr);
		X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance("EC", "BC");
		ECPublicKey publicKey = (ECPublicKey) keyFactory.generatePublic(keySpec);
		return publicKey;
	}
	
	//将Base64编码后的私钥转换成PrivateKey对象
	public static ECPrivateKey string2PrivateKey(String priStr) throws Exception{
		byte[] keyBytes = AESUtil.base642Byte(priStr);
		PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance("EC", "BC");
		ECPrivateKey privateKey = (ECPrivateKey) keyFactory.generatePrivate(keySpec);
		return privateKey;
	}
	
	//公钥加密
	public static byte[] publicEncrypt(byte[] content, PublicKey publicKey) throws Exception{
		Cipher cipher = Cipher.getInstance("ECIES", "BC");
		cipher.init(Cipher.ENCRYPT_MODE, publicKey);
		byte[] bytes = cipher.doFinal(content);
		return bytes;
	}
	
	//私钥解密
	public static byte[] privateDecrypt(byte[] content, PrivateKey privateKey) throws Exception{
		Cipher cipher = Cipher.getInstance("ECIES", "BC");
		cipher.init(Cipher.DECRYPT_MODE, privateKey);
		byte[] bytes = cipher.doFinal(content);
		return bytes;
	}
	
	public static void main(String[] args) throws Exception {
		KeyPair keyPair = ECCUtil.getKeyPair();
		String publicKeyStr = ECCUtil.getPublicKey(keyPair);
		String privateKeyStr = ECCUtil.getPrivateKey(keyPair);
		System.out.println("ECC公钥Base64编码:" + publicKeyStr);
		System.out.println("ECC私钥Base64编码:" + privateKeyStr);
		
		ECPublicKey publicKey = string2PublicKey(publicKeyStr);
		ECPrivateKey privateKey = string2PrivateKey(privateKeyStr);
		
		byte[] publicEncrypt = publicEncrypt("hello world".getBytes(), publicKey);
		byte[] privateDecrypt = privateDecrypt(publicEncrypt, privateKey);
		System.out.println(new String(privateDecrypt));
	}
}



封装好的类 HttpEncryptUtil：

package com.zhuyun.encrypt;

import java.security.PrivateKey;
import java.security.PublicKey;

import javax.crypto.SecretKey;

import org.bouncycastle.jce.interfaces.ECPrivateKey;
import org.bouncycastle.jce.interfaces.ECPublicKey;


import net.sf.json.JSONObject;


public class HttpEncryptUtil {

//	//################################双向RSA + AES ##########################
//	//APP加密请求内容
//	public static String appEncrypt(String appPublicKeyStr, String content) throws Exception{
//		//将Base64编码后的Server公钥转换成PublicKey对象
//		PublicKey serverPublicKey = RSAUtil.string2PublicKey(KeyUtil.SERVER_PUBLIC_KEY);
//		//每次都随机生成AES秘钥
//		String aesKeyStr = AESUtil.genKeyAES();
//		SecretKey aesKey = AESUtil.loadKeyAES(aesKeyStr);
//		//用Server公钥加密AES秘钥
//		byte[] encryptAesKey = RSAUtil.publicEncrypt(aesKeyStr.getBytes(), serverPublicKey);
//		//用AES秘钥加密APP公钥
//		byte[] encryptAppPublicKey = AESUtil.encryptAES(appPublicKeyStr.getBytes(), aesKey);
//		//用AES秘钥加密请求内容
//		byte[] encryptRequest = AESUtil.encryptAES(content.getBytes(), aesKey);
//		
//		JSONObject result = new JSONObject();
//		result.put("ak", RSAUtil.byte2Base64(encryptAesKey).replaceAll("\r\n", ""));
//		result.put("apk", RSAUtil.byte2Base64(encryptAppPublicKey).replaceAll("\r\n", ""));
//		result.put("ct", RSAUtil.byte2Base64(encryptRequest).replaceAll("\r\n", ""));
//		return result.toString();
//	}
//	
//	//APP解密服务器的响应内容
//	public static String appDecrypt(String appPrivateKeyStr, String content) throws Exception{
//		JSONObject result = JSONObject.fromObject(content);
//		String encryptAesKeyStr = (String) result.get("ak");
//		String encryptContent = (String) result.get("ct");
//		
//		//将Base64编码后的APP私钥转换成PrivateKey对象
//		PrivateKey appPrivateKey = RSAUtil.string2PrivateKey(appPrivateKeyStr);
//		//用APP私钥解密AES秘钥
//		byte[] aesKeyBytes = RSAUtil.privateDecrypt(RSAUtil.base642Byte(encryptAesKeyStr), appPrivateKey);
//		//用AES秘钥解密请求内容
//		SecretKey aesKey = AESUtil.loadKeyAES(new String(aesKeyBytes));
//		byte[] response = AESUtil.decryptAES(RSAUtil.base642Byte(encryptContent), aesKey);
//		
//		return new String(response);
//	}
//	
//	//服务器加密响应给APP的内容
//	public static String serverEncrypt(String appPublicKeyStr, String aesKeyStr, String content) throws Exception{
//		//将Base64编码后的APP公钥转换成PublicKey对象
//		PublicKey appPublicKey = RSAUtil.string2PublicKey(appPublicKeyStr);
//		//将Base64编码后的AES秘钥转换成SecretKey对象
//		SecretKey aesKey = AESUtil.loadKeyAES(aesKeyStr);
//		//用APP公钥加密AES秘钥
//		byte[] encryptAesKey = RSAUtil.publicEncrypt(aesKeyStr.getBytes(), appPublicKey);
//		//用AES秘钥加密响应内容
//		byte[] encryptContent = AESUtil.encryptAES(content.getBytes(), aesKey);
//		
//		JSONObject result = new JSONObject();
//		result.put("ak", RSAUtil.byte2Base64(encryptAesKey).replaceAll("\r\n", ""));
//		result.put("ct", RSAUtil.byte2Base64(encryptContent).replaceAll("\r\n", ""));
//		return result.toString();
//	}
//	
//	//服务器解密APP的请求内容
//	public static String serverDecrypt(String content) throws Exception{
//		JSONObject result = JSONObject.fromObject(content);
//		String encryptAesKeyStr = (String) result.get("ak");
//		String encryptAppPublicKeyStr = (String) result.get("apk");
//		String encryptContent = (String) result.get("ct");
//		
//		//将Base64编码后的Server私钥转换成PrivateKey对象
//		PrivateKey serverPrivateKey = RSAUtil.string2PrivateKey(KeyUtil.SERVER_PRIVATE_KEY);
//		//用Server私钥解密AES秘钥
//		byte[] aesKeyBytes = RSAUtil.privateDecrypt(RSAUtil.base642Byte(encryptAesKeyStr), serverPrivateKey);
//		//用Server私钥解密APP公钥
//		SecretKey aesKey = AESUtil.loadKeyAES(new String(aesKeyBytes));
//		byte[] appPublicKeyBytes = AESUtil.decryptAES(RSAUtil.base642Byte(encryptAppPublicKeyStr), aesKey);
//		//用AES秘钥解密请求内容
//		byte[] request = AESUtil.decryptAES(RSAUtil.base642Byte(encryptContent), aesKey);
//		
//		JSONObject result2 = new JSONObject();
//		result2.put("ak", new String(aesKeyBytes));
//		result2.put("apk", new String(appPublicKeyBytes));
//		result2.put("ct", new String(request));
//		return result2.toString();
//	}
	
	
	//################################双向ECC + AES ##########################
	//APP加密请求内容
	public static String appEncrypt(String appPublicKeyStr, String content) throws Exception{
		//将Base64编码后的Server公钥转换成PublicKey对象
		ECPublicKey serverPublicKey = ECCUtil.string2PublicKey(KeyUtil.SERVER_PUBLIC_KEY);
		//每次都随机生成AES秘钥
		String aesKeyStr = AESUtil.genKeyAES();
		SecretKey aesKey = AESUtil.loadKeyAES(aesKeyStr);
		//用Server公钥加密AES秘钥
		byte[] encryptAesKey = ECCUtil.publicEncrypt(aesKeyStr.getBytes(), serverPublicKey);
		//用AES秘钥加密APP公钥
		byte[] encryptAppPublicKey = AESUtil.encryptAES(appPublicKeyStr.getBytes(), aesKey);
		//用AES秘钥加密请求内容
		byte[] encryptRequest = AESUtil.encryptAES(content.getBytes(), aesKey);
		
		JSONObject result = new JSONObject();
		result.put("ak", AESUtil.byte2Base64(encryptAesKey).replaceAll("\r\n", ""));
		result.put("apk", AESUtil.byte2Base64(encryptAppPublicKey).replaceAll("\r\n", ""));
		result.put("ct", AESUtil.byte2Base64(encryptRequest).replaceAll("\r\n", ""));
		return result.toString();
	}
	
	//APP解密服务器的响应内容
	public static String appDecrypt(String appPrivateKeyStr, String content) throws Exception{
		JSONObject result = JSONObject.fromObject(content);
		String encryptAesKeyStr = (String) result.get("ak");
		String encryptContent = (String) result.get("ct");
		
		//将Base64编码后的APP私钥转换成PrivateKey对象
		ECPrivateKey appPrivateKey = ECCUtil.string2PrivateKey(appPrivateKeyStr);
		//用APP私钥解密AES秘钥
		byte[] aesKeyBytes = ECCUtil.privateDecrypt(AESUtil.base642Byte(encryptAesKeyStr), appPrivateKey);
		//用AES秘钥解密请求内容
		SecretKey aesKey = AESUtil.loadKeyAES(new String(aesKeyBytes));
		byte[] response = AESUtil.decryptAES(AESUtil.base642Byte(encryptContent), aesKey);
		
		return new String(response);
	}
	
	//服务器加密响应给APP的内容
	public static String serverEncrypt(String appPublicKeyStr, String aesKeyStr, String content) throws Exception{
		//将Base64编码后的APP公钥转换成PublicKey对象
		ECPublicKey appPublicKey = ECCUtil.string2PublicKey(appPublicKeyStr);
		//将Base64编码后的AES秘钥转换成SecretKey对象
		SecretKey aesKey = AESUtil.loadKeyAES(aesKeyStr);
		//用APP公钥加密AES秘钥
		byte[] encryptAesKey = ECCUtil.publicEncrypt(aesKeyStr.getBytes(), appPublicKey);
		//用AES秘钥加密响应内容
		byte[] encryptContent = AESUtil.encryptAES(content.getBytes(), aesKey);
		
		JSONObject result = new JSONObject();
		result.put("ak", AESUtil.byte2Base64(encryptAesKey).replaceAll("\r\n", ""));
		result.put("ct", AESUtil.byte2Base64(encryptContent).replaceAll("\r\n", ""));
		return result.toString();
	}
	
	//服务器解密APP的请求内容
	public static String serverDecrypt(String content) throws Exception{
		JSONObject result = JSONObject.fromObject(content);
		String encryptAesKeyStr = (String) result.get("ak");
		String encryptAppPublicKeyStr = (String) result.get("apk");
		String encryptContent = (String) result.get("ct");
		
		//将Base64编码后的Server私钥转换成PrivateKey对象
		ECPrivateKey serverPrivateKey = ECCUtil.string2PrivateKey(KeyUtil.SERVER_PRIVATE_KEY);
		//用Server私钥解密AES秘钥
		byte[] aesKeyBytes = ECCUtil.privateDecrypt(AESUtil.base642Byte(encryptAesKeyStr), serverPrivateKey);
		//用AES秘钥解密APP公钥
		SecretKey aesKey = AESUtil.loadKeyAES(new String(aesKeyBytes));
		byte[] appPublicKeyBytes = AESUtil.decryptAES(AESUtil.base642Byte(encryptAppPublicKeyStr), aesKey);
		//用AES秘钥解密请求内容
		byte[] request = AESUtil.decryptAES(AESUtil.base642Byte(encryptContent), aesKey);
		
		JSONObject result2 = new JSONObject();
		result2.put("ak", new String(aesKeyBytes));
		result2.put("apk", new String(appPublicKeyBytes));
		result2.put("ct", new String(request));
		return result2.toString();
	}
}


测试类 TestHttpEncrypt：

package com.zhuyun.encrypt;

import java.io.InputStream;
import java.security.KeyPair;
import java.util.Properties;

import org.junit.Test;

public class TestHttpEncrypt {

	@Test
	public void testGenerateKeyPair() throws Exception{
		//生成RSA公钥和私钥，并Base64编码
//		KeyPair keyPair = RSAUtil.getKeyPair();
//		String publicKeyStr = RSAUtil.getPublicKey(keyPair);
//		String privateKeyStr = RSAUtil.getPrivateKey(keyPair);
//		System.out.println("RSA公钥Base64编码:" + publicKeyStr);
//		System.out.println("RSA私钥Base64编码:" + privateKeyStr);
		
		//生成ECC公钥和私钥，并Base64编码
		KeyPair keyPair = ECCUtil.getKeyPair();
		String publicKeyStr = ECCUtil.getPublicKey(keyPair);
		String privateKeyStr = ECCUtil.getPrivateKey(keyPair);
		System.out.println("ECC公钥Base64编码:" + publicKeyStr);
		System.out.println("ECC私钥Base64编码:" + privateKeyStr);
	}
	
	
	@Test
	public void testGenerateAesKey() throws Exception{
		//生成AES秘钥，并Base64编码
		String base64Str = AESUtil.genKeyAES();
		System.out.println("AES秘钥Base64编码:" + base64Str);
	}
	
	//测试  APP加密请求内容
	@Test
	public void testAppEncrypt() throws Exception{
		//APP端公钥和私钥从配置文件读取，不能写死在代码里
		Properties prop = new Properties();
		InputStream in = TestHttpEncrypt.class.getClassLoader().getResourceAsStream("client.properties");
		prop.load(in);
		String appPublicKey = prop.getProperty("app.public.key");
		//请求的实际内容
//		String content = "{\"name\":\"infi\", \"weight\":\"60\"}";
		String content = "{\"tenantid\":\"1\", \"account\":\"13015929018\", \"pwd\":\"123456\"}";
		String result = HttpEncryptUtil.appEncrypt(appPublicKey, content);
		System.out.println(result);
	}
	
	//测试  服务器解密APP的请求内容
	@Test
	public void testServerDecrypt() throws Exception{
		String result = "{\"ak\":\"BPXJhKTtBu6YrFXdxnzzl32tIKMER6X/XfaXbBKKqg6VP0m8Wk2AV+Se+D1MWgqaSC+ahzHh1s8m1hjdbSkFf4eBjdzwSbb0YXDofCgrD0fxvbQQsQdVhSRiL/nPlLzrgtQ9yGAcCF4qjDa4dA==\",\"apk\":\"Dtz7R4XbboA/SwsrUDXXEgt6q3fmMTqh4kvxZA1UyMvhi4isEgKoDL6KuLixXGXI709PBBW22kK6hz1jgMWUAr7QBUA8EqdLsi5GFPukEKBS1b+Xh71KKnwY21+uppds8gsJ9cPbxPmduJoCq44fwn15entZQ9EaWN+2xisF4ac=\",\"ct\":\"CAqCFSHCMKFKpEECVBngMX8sGD2teaeyLiQ13X4b2+gkOrm/mYnzvWpPK/tpQNWThw2146VcXrQX+NZNEOH5Vw==\"}";
		System.out.println(HttpEncryptUtil.serverDecrypt(result));
	}
	
	//测试 服务器加密响应给APP的内容
	@Test
	public void testserverEncrypt() throws Exception{
		String aesKeyStr = "zQMfufsgoWP+FWCKteGjdg==";
		String appPublicKeyStr = "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFXblKT9aq5X86K+d5RzXpspH4GVwqbSkUc80EbkJn7+ZIejEWba/Io9c5DftUy0AiGXlz9/HgFPdhYBuz5p5rg==";
		String content = "{\"retcode\":\"200\"}";
		System.out.println(HttpEncryptUtil.serverEncrypt(appPublicKeyStr, aesKeyStr, content));
	}
	
	//测试 	APP解密服务器的响应内容
	@Test
	public void testAppDecrypt() throws Exception{
		//APP端公钥和私钥从配置文件读取，不能写死在代码里
		Properties prop = new Properties();
		InputStream in = TestHttpEncrypt.class.getClassLoader().getResourceAsStream("client.properties");
		prop.load(in);
		String appPrivateKey = prop.getProperty("app.private.key");
		String content = "{\"ak\":\"BArM6HfwUYj78sSXrhzYDjVjjpl6Gp3UiFYvNXCJMKfk6aQnC9vto6ZniCEyWAEhmaw9xOw5GmyUy17tV8tiYwKGFfDhS1c4oGOsPEG9KiOxIOuo2saTwrTCGvCwDNju3AGJGfGg8SbnXBndkA==\",\"ct\":\"xE/BBpt30aS/fE5OMJGsyKOcqwlN9MT1swcqbiuMuLnZw98wwGCSZ0aeCdJkDkaZ/JfcJc3exf0tA+/UNdPZ8a7khq5RYyZNA1VfHdhKq6n6n7f7xDqHVZ7uW7ljeLRm\"}";
		System.out.println(HttpEncryptUtil.appDecrypt(appPrivateKey, content));
	}
}



嫩草终结者
关注
  • 2
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 26
    评论
专栏目录
java AES加密
hambaga的博客
10-28 180
直接上代码 import java.util.*; public class testBase64 { public static void main(String[] args) throws Exception { Base64.Decoder decoder = Base64.getDecoder(); Base64.Encoder encoder =...
JAVA实现AES加密
weixin_40544967的博客
01-07 2079
JAVA实现AES加密 今天单独实现AES加密，直接上代码： import java.security.InvalidKeyException; import java.security.NoSuchAlgorithmException; import javax.crypto.BadPaddingException; import javax.crypto.Cipher; import javax.crypto.IllegalBlockSizeException; import javax.crypto
java aes 加密api,java – 使用BouncyCastle轻量级API的AES-256加密
weixin_32941303的博客
03-11 495
我使用Java的内置加密库编写了一些(功能)AES加密代码,如下所示,但我想使用256位密钥.但是,我想在没有用户安装到Unlimited Strength Cryptography Policy文件的情况下执行此操作.现在,我听说使用BouncyCastle轻量级API可以让我这样做,但不幸的是我遇到了很多困难,我很难适应任何有助于我的文档.这是我当前的代码,其中’content’是要加密的字节...
Java实现各种加密算法签名算法（AES、DES、ECC、RSA、ECIES、ECDSA等）
最新发布
m0_61916291的博客
05-26 517
文中基于对称加密AES和非对称加密ECC为例，其他对称加密（DES等）和非对称加密（RSA等）同理。
java 文件pem,来自android，java上的PEM文件的PublicKey
weixin_39983554的博客
03-14 251
我搞定了。公钥是椭圆曲线(p192)公钥，应加载不同。拥有PublicKey我能够像使用openssl命令一样验证签名。import org.bouncycastle.jce.provider.BouncyCastleProvider;import java.io.Reader;import java.io.StringReader;import java.security.KeyFactory;...
ecc加密 java实现,使用ECC Curve25519在Java中加密/解密数据
weixin_29010003的博客
03-19 850
加密Android设备上的文件的关键是永远不存储密钥 . 为此，您添加了加密图片不需要密码的约束 . 最后，因为非对称加密很慢，所以你需要使用AES来完成繁重的工作 .这适用于RSA或任何其他非对称算法 .Initial Run首次运行时，生成密钥对并要求用户输入密码 .将公钥存储为明文 . 使用密码生成的AES密钥加密私钥 .Encryption为每张图片生成不同的AES密钥，并使用它加密图像 ...
JAVA实现ECC加密 eclipse
老油子的博客
12-27 2727
ECC加密 一、实验目的 通过使用JPBC库调用ECC椭圆曲线加解密算法，能够编写简单的实验代码进行正确的ECC加密和解密。 二、 实验要求 熟悉ECC椭圆曲线加解密算法。 了解如何使用Java简单实现ECC椭圆曲线加密算法。 掌握ECC椭圆曲线加密算法的简单代码实验。 熟悉JPBC密码学库。 三、开发环境 JDK1.8，Java相关开发环境（本实验以Windows平台为例） 四、实验内容 需要导入相关的jpbc包 【1-1】ECC椭圆曲线加密实验 1、 给定一个String类型的参数，使用如下的函数进行
aes密钥扩展java实现_需要使用bouncycastle将AES 256密钥“扩展”为Java中的10个圆形密钥...
weixin_36308751的博客
02-25 493
AES-128使用10轮,AES-192使用12轮,AES-256使用14轮.使用BouncyCastle,可以在名为org.bouncycastle.crypto.engines.AESEngine的类中的私有方法generateWorkingKey()中实现它.这不是通用的实现：该方法开始于：[...]int KC = keyLen >>> 2;ROUNDS = KC + 6...
JAVA实现AES加密、解密
slw20010213的博客
12-08 483
一、什么是AES？ 高级加密标准（英语：Advanced Encryption Standard，缩写：AES），是一种区块加密标准。这个标准用来替代原先的DES，已经被多方分析且广为全世界所使用。 那么为什么原来的DES会被取代呢，，原因就在于其使用56位密钥，比较容易被破解。而AES可以使用128、192、和256位密钥，并且用128位分组加密和解密数据，相对来说安全很多。完善的加密算法在理论上是无法破解的，除非使用穷尽法。使用穷尽法破解密钥长度在128位以上的加密数据是不现实的，仅存在理论上的可能
基于java实现的ECC加密算法示例
08-29
基于Java实现的ECC加密算法示例 本文主要介绍了基于Java实现的ECC加密算法，简单说明了ECC算法的概念、原理，并结合实例形式分析了Java实现ECC加密算法的定义与使用技巧。 ECC算法概念 ECC（Elliptic Curves ...
基于ECC和AES的混合加密应用系统 源代码+配置+毕业论文(1)
06-04
基于ECC和AES的混合加密应用系统 源代码+配置+毕业论文(1)基于ECC和AES的混合加密应用系统 源代码+配置+毕业论文(1)基于ECC和AES的混合加密应用系统 源代码+配置+毕业论文(1)基于ECC和AES的混合加密应用系统 源代码+...
java使用bouncycastle实现椭圆曲线（ECC）双向加密解密
04-27
Bouncy Castle是一个全面的Java加密库，包含了大量加密标准和算法，如AES、RSA、DES以及我们关注的ECC。它提供了一套低级API（Lightweight API）和一套更高级的API（Provider API），适合不同级别的开发者使用。 3...
Java_ECC.rar_ECC解密_ecc加密_java ECC加密_java实现ecc_椭圆曲线加密
09-20
在Java中实现ECC加密和解密涉及到多个关键概念和技术，包括椭圆曲线的数学基础、ECC曲线、点运算以及相关的Java类库。下面我们将深入探讨这些知识点。 首先，椭圆曲线加密（Elliptic Curve Cryptography，简称ECC）...
ECC.rar_ECC C实现_ecc_ecc加密
09-23
在C语言中实现ECC涉及到几个关键步骤：生成椭圆曲线参数、密钥对的生成（公钥和私钥）、加密和解密过程。以下是一些核心概念： 1. **椭圆曲线定义**：ECC的数学基础是椭圆曲线方程，通常形式为`y^2 = x^3 + ax + b`...
C++的AES及ECC加解密
weixin_41989340的博客
10-10 1954
使用C++语言，使用AES库及ECC库，实现对明文的加解密处理
使用 bouncycastle实现 AES
iteye_14264的博客
11-01 1600
[code="java"] import java.io.UnsupportedEncodingException; import java.security.Key; import java.security.Security; import javax.crypto.Cipher; import javax.crypto.spec.IvParameterSpec; impo...
java 的bouncycastle AES加密，怎么处理成php的，疑惑
sinat_35572053的博客
02-21 1868
JAVA AES 程序 public static String decryptWithBC(String data, String key) throws Exception { ByteBuffer buffer = ByteBuffer.allocate(32); buffer.put(key.getBytes()); KeyParameter kp = new KeyParameter(buffer.array()); byte[] bytes = Base6
浅谈常见的七种加密算法及实现
矢的飞跃的专栏
11-16 1018
原文链接 https://juejin.im/post/5b48b0d7e51d4519962ea383 前言 数字签名、信息加密 是前后端开发都经常需要使用到的技术，应用场景包括了用户登入、交易、信息通讯、oauth 等等，不同的应用场景也会需要使用到不同的签名加密算法，或者需要搭配不一样的 签名加密算法 来达到业务目标。这里简单的给大家介绍几种常见的签名加密算法和一些典型场景下的应用。 正文 ...
浅谈常见的七种验签以及加密算法实现
holmeswf的博客
12-13 2766
前言 数字签名、信息加密 是前后端开发都经常需要使用到的技术，应用场景包括了用户登入、交易、信息通讯、oauth 等等，不同的应用场景也会需要使用到不同的签名加密算法，或者需要搭配不一样的 签名加密算法 来达到业务目标。这里简单的给大家介绍几种常见的签名加密算法和一些典型场景下的应用。 正文 数字签名 数字签名，简单来说就是通过提供 可鉴别 的 数字信息 验证 自身身份 的一种方式。一套 数字签...
Java ECC加密技术探索与实现
"Java加密技术第四部分，主要探讨了椭圆曲线加密算法(ECC)在Java中的应用。ECC是一种高效的公钥加密体制，尤其在软件注册保护和生成序列号等方面有广泛应用。虽然Java从1.5版本开始支持ECC，但其加密/解密操作通常...
评论 26
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值