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加密时的密钥

实现

生成密钥对

后端

java 复制代码
    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)

javascript 复制代码
    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');

共享密钥计算

后端

java 复制代码
    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();
    }    

前端

javascript 复制代码
    var keyArray = serverPublicPointKey.split("|")
    const otherKey = ec.keyFromPublic({ x: keyArray[0], y: keyArray[1] }, 'hex');
    const sharedSecret = keyPair.derive(otherKey.getPublic());

AES加密

后端

java 复制代码
    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)

javascript 复制代码
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向量为同一值
相关推荐
seventeennnnn2 小时前
谢飞机的Java高级开发面试:从Spring Boot到分布式架构的蜕变之旅
spring boot·微服务架构·java面试·分布式系统·电商支付
超级小忍3 小时前
服务端向客户端主动推送数据的几种方法(Spring Boot 环境)
java·spring boot·后端
时间会给答案scidag4 小时前
报错 400 和405解决方案
vue.js·spring boot
Wyc724094 小时前
SpringBoot
java·spring boot·spring
ladymorgana6 小时前
【Spring Boot】HikariCP 连接池 YAML 配置详解
spring boot·后端·mysql·连接池·hikaricp
GJCTYU7 小时前
spring中@Transactional注解和事务的实战理解附代码
数据库·spring boot·后端·spring·oracle·mybatis
风象南8 小时前
SpringBoot敏感配置项加密与解密实战
java·spring boot·后端
写不出来就跑路10 小时前
暑期实习感悟与经验分享:从校园到职场的成长之路
java·开发语言·经验分享·spring boot
程序员张314 小时前
Maven编译和打包插件
java·spring boot·maven
灵犀学长15 小时前
EasyExcel之SheetWriteHandler:解锁Excel写入的高阶玩法
spring boot·excel