SpringBoot集成ECDH密钥交换的方法
更新时间：2025年01月03日 09:19:43 作者：code2roc
ECDH密钥交换算法通过椭圆曲线和Diffie-Hellman方法生成共享密钥,用于前端和后端之间的AES加密通信,前端使用elliptic.js生成密钥对,后端使用crypto-js.min.js进行AES加密,本文给大家介绍SpringBoot集成ECDH密钥交换的相关知识,感兴趣的朋友一起看看吧
简介
对称加解密算法都需要一把秘钥，但是很多情况下，互联网环境不适合传输这把对称密码，有密钥泄露的风险，为了解决这个问题ECDH密钥交换应运而生
EC：Elliptic Curve——椭圆曲线，生成密钥的方法
DH：Diffie-Hellman Key Exchange——交换密钥的方法
设计
数据传输的两方服务端（Server）和客户端（Client）
服务端生成密钥对Server-Public和Servier-Private
客户端生成密钥对Client-Public和Client-Private
客户端获取服务端的公钥和客户端的私钥进行计算CaculateKey(Server-Public，Client-Private)出共享密钥ShareKey1
服务端获取客户端的公钥和服务端的私钥进行计算CaculateKey(Client-Public，Server-Private)出共享密钥ShareKey2
ShareKey1和ShareKey2必定一致，ShareKey就是双方传输数据进行AES加密时的密钥
实现
生成密钥对
后端
public static ECDHKeyInfo generateKeyInfo(){
ECDHKeyInfo keyInfo = new ECDHKeyInfo();
try{
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("EC");
ECGenParameterSpec ecSpec = new ECGenParameterSpec("secp256r1");
keyPairGenerator.initialize(ecSpec, new SecureRandom());
KeyPair kp = keyPairGenerator.generateKeyPair();
ECPublicKey ecPublicKey = (ECPublicKey) kp.getPublic();
ECPrivateKey ecPrivateKey = (ECPrivateKey) kp.getPrivate();
// 获取公钥点的x和y坐标
BigInteger x = ecPublicKey.getW().getAffineX();
BigInteger y = ecPublicKey.getW().getAffineY();
// 将x和y坐标转换为十六进制字符串
String xHex = x.toString(16);
String yHex = y.toString(16);
String publicKey = xHex + "|" + yHex;
String privateKey = Base64.getEncoder().encodeToString(ecPrivateKey.getEncoded());
keyInfo.setPublicKey(publicKey);
keyInfo.setPrivateKey(privateKey);
}catch (Exception e){
e.printStackTrace();
}
return keyInfo;
}
public static class ECDHKeyInfo{
private String publicKey;
private String privateKey;
public String getPublicKey() {
return publicKey;
}
public void setPublicKey(String publicKey) {
this.publicKey = publicKey;
}
public String getPrivateKey() {
return privateKey;
}
public void setPrivateKey(String privateKey) {
this.privateKey = privateKey;
}
}前端
引入elliptic.js（https://cdn.bootcdn.net/ajax/libs/elliptic/6.5.6/elliptic.js）
const EC = elliptic.ec;
const ec = new EC('p256'); // P-256曲线
// 生成密钥对
const keyPair = ec.genKeyPair();
const publicKey = keyPair.getPublic().getX().toString('hex') + "|" + keyPair.getPublic().getY().toString('hex');共享密钥计算
后端
public static String caculateShareKey(String serverPrivateKey,String receivePublicKey){
String shareKey = "";
try{
// 1. 后端私钥 Base64 字符串
// 2. 从 Base64 恢复后端私钥
ECPrivateKey privKey = loadPrivateKeyFromBase64(serverPrivateKey);
// 3. 前端传递的公钥坐标 (x 和 y 坐标，假设为十六进制字符串)
// 假设这是从前端接收到的公钥的 x 和 y 坐标
String xHex = receivePublicKey.split("\\|")[0]; // 用前端传递的 x 坐标替换
String yHex = receivePublicKey.split("\\|")[1]; // 用前端传递的 y 坐标替换
// 4. 将 x 和 y 转换为 BigInteger
BigInteger x = new BigInteger(xHex, 16);
BigInteger y = new BigInteger(yHex, 16);
// 5. 创建 ECPoint 对象 (公钥坐标)
ECPoint ecPoint = new ECPoint(x, y);
// 6. 获取 EC 参数（例如 secp256r1）
ECParameterSpec ecSpec = getECParameterSpec();
// 7. 恢复公钥
ECPublicKey pubKey = recoverPublicKey(ecPoint, ecSpec);
// 8. 使用 ECDH 计算共享密钥
byte[] sharedSecret = calculateSharedSecret(privKey, pubKey);
// 9. 打印共享密钥
shareKey = bytesToHex(sharedSecret);
}catch (Exception e){
e.printStackTrace();
}
return shareKey;
}
// 从 Base64 加载 ECPrivateKey
private static ECPrivateKey loadPrivateKeyFromBase64(String privateKeyBase64) throws Exception {
byte[] decodedKey = Base64.getDecoder().decode(privateKeyBase64);
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(decodedKey);
KeyFactory keyFactory = KeyFactory.getInstance("EC");
return (ECPrivateKey) keyFactory.generatePrivate(keySpec);
}
// 获取 EC 参数（例如 secp256r1）
private static ECParameterSpec getECParameterSpec() throws Exception {
// 手动指定 EC 曲线（例如 secp256r1）
AlgorithmParameters params = AlgorithmParameters.getInstance("EC");
params.init(new ECGenParameterSpec("secp256r1")); // 使用标准的 P-256 曲线
return params.getParameterSpec(ECParameterSpec.class);
}
// 恢复公钥
private static ECPublicKey recoverPublicKey(ECPoint ecPoint, ECParameterSpec ecSpec) throws Exception {
ECPublicKeySpec pubKeySpec = new ECPublicKeySpec(ecPoint, ecSpec);
KeyFactory keyFactory = KeyFactory.getInstance("EC");
return (ECPublicKey) keyFactory.generatePublic(pubKeySpec);
}
// 使用 ECDH 计算共享密钥
private static byte[] calculateSharedSecret(ECPrivateKey privKey, ECPublicKey pubKey) throws Exception {
KeyAgreement keyAgreement = KeyAgreement.getInstance("ECDH");
keyAgreement.init(privKey);
keyAgreement.doPhase(pubKey, true);
return keyAgreement.generateSecret();
}
// 将字节数组转换为十六进制字符串
private static String bytesToHex(byte[] bytes) {
StringBuilder hexString = new StringBuilder();
for (byte b : bytes) {
hexString.append(String.format("%02x", b));
}
return hexString.toString();
} 前端
var keyArray = serverPublicPointKey.split("|")
const otherKey = ec.keyFromPublic({ x: keyArray[0], y: keyArray[1] }, 'hex');
const sharedSecret = keyPair.derive(otherKey.getPublic());AES加密
后端
public static String encryptData(String data,String shareKey){
String result = "";
try{
MessageDigest digest = MessageDigest.getInstance("SHA-256");
byte[] aesKey = digest.digest(shareKey.getBytes()); // 获取 256 位密钥
SecretKey key = new SecretKeySpec(aesKey, "AES");
byte[] resultData = encrypt(data,key);
result = Base64.getEncoder().encodeToString(resultData);
}catch (Exception e){
e.printStackTrace();
}
return result;
}
public static String decryptData(String data,String shareKey){
String result = "";
try{
MessageDigest digest = MessageDigest.getInstance("SHA-256");
byte[] aesKey = digest.digest(shareKey.getBytes()); // 获取 256 位密钥
SecretKey key = new SecretKeySpec(aesKey, "AES");
byte[] resultData = decrypt(Base64.getDecoder().decode(data),key);
result = new String(resultData);
}catch (Exception e){
e.printStackTrace();
}
return result;
}
private static final String KEY_ALGORITHM = "AES";
private static final String CIPHER_ALGORITHM = "AES/CBC/PKCS5Padding";
private static final String IV = "0102030405060708"; // 16 bytes key
// 使用AES密钥加密数据
private static byte[] encrypt(String plaintext, SecretKey aesKey) throws Exception {
SecretKeySpec keySpec = new SecretKeySpec(aesKey.getEncoded(), KEY_ALGORITHM);
IvParameterSpec iv = new IvParameterSpec(IV.getBytes());
Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
cipher.init(Cipher.ENCRYPT_MODE, keySpec, iv);
byte[] encrypted = cipher.doFinal(plaintext.getBytes());
return encrypted;
}
// 使用AES密钥解密数据
private static byte[] decrypt(byte[] encryptedData, SecretKey aesKey) throws Exception {
SecretKeySpec keySpec = new SecretKeySpec(aesKey.getEncoded(), KEY_ALGORITHM);
IvParameterSpec iv = new IvParameterSpec(IV.getBytes());
Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
cipher.init(Cipher.DECRYPT_MODE, keySpec, iv);
byte[] original = cipher.doFinal(encryptedData);
return original;
} 前端
引入crypto-js.min.js（https://cdnjs.cloudflare.com/ajax/libs/crypto-js/4.1.1/crypto-js.min.js）
function encryptByECDH(message, shareKey) {
const aesKey = CryptoJS.SHA256(shareKey);
const key = CryptoJS.enc.Base64.parse(aesKey.toString(CryptoJS.enc.Base64));
return encryptByAES(message,key)
}
function decryptByECDH(message, shareKey) {
const aesKey = CryptoJS.SHA256(shareKey);
const key = CryptoJS.enc.Base64.parse(aesKey.toString(CryptoJS.enc.Base64));
return decryptByAES(message,key)
}
function encryptByAES(message, key) {
const iv = CryptoJS.enc.Utf8.parse("0102030405060708");
const encrypted = CryptoJS.AES.encrypt(message, key, { iv: iv , mode: CryptoJS.mode.CBC, padding: CryptoJS.pad.Pkcs7 });
return encrypted.toString();
}
function decryptByAES(message, key) {
const iv = CryptoJS.enc.Utf8.parse("0102030405060708");
const bytes = CryptoJS.AES.decrypt(message, key, { iv: iv, mode: CryptoJS.mode.CBC, padding: CryptoJS.pad.Pkcs7 });
const originalText = bytes.toString(CryptoJS.enc.Utf8);
return originalText;
}注意
- 前端生成的密钥对和后端生成的密钥对形式不一致，需要将前端的公钥拆解成坐标点到后端进行公钥还原
- 同理后端的公钥也要拆分成坐标点传输到前端进行计算
- 生成的ShareKey共享密钥为了满足AES的密钥长度要求需要进行Share256计算
- 前后端AES互通需要保证IV向量为同一值
到此这篇关于SpringBoot集成ECDH密钥交换的文章就介绍到这了,更多相关SpringBoot集成ECDH密钥交换内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！
相关文章
这篇文章主要介绍了HTTPClient如何在Springboot中封装工具类问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教2023-09-09
这篇文章主要介绍了Spring中HandlerAdapter接口源码解析,HandlerAdapter是一个适配器接口类,适配器模式是指两个不兼容接口之间的桥梁,要想让一个接口使用另外一个接口的实现中间可以加一层适配器类,需要的朋友可以参考下2023-11-11
这篇文章主要介绍了spring-mybatis获取mapper的四种方式汇总，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教2023-03-03
这篇文章主要介绍了Java多线程之Callable接口的实现，Callable和Runnbale一样代表着任务，区别在于Callable有返回值并且可以抛出异常。感兴趣的小伙伴们可以参考一下2018-08-08
这篇文章主要为大家详细解析了JavaWeb文件上传与下载功能，具有一定的参考价值，感兴趣的小伙伴们可以参考一下2016-06-06
这篇文章主要介绍了idea中项目前端网页图标不显示的原因及解决方案，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教2023-07-07
本文详细介绍了Java中注解和反射的概念及应用,注解是用于给代码添加元数据的标记,如@Override、@Deprecated等,反射机制则是在运行时获取和操作类的内部信息,提高了代码的灵活度,感兴趣的朋友跟随小编一起看看吧2023-06-06
原型模式其实就是从一个对象在创建另外一个可定制的对象，不需要知道任何创建的细节。本文就来通过示例为大家详细聊聊原型模式，需要的可以参考一下2022-09-09
这篇文章主要介绍了Java中线程Thread的三种方式和对比，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧2021-04-04
这篇文章主要介绍了springboot获取profile的操作，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教2021-09-09
最新评论