互联网交互加密安全：ECDH/ECC秘钥磋商和AES加密组合加密

最新推荐文章于 2023-08-24 15:55:13 发布
最新推荐文章于 2023-08-24 15:55:13 发布
阅读量3k 收藏 4
点赞数 1
分类专栏： 加密

最近在项目中用到了一个加密方式，ECDH/ECC秘钥磋商。

然后使用AES加密，这个加密方式非常的有点绕，也就是如此，他的加密方式会稍微有点麻烦，但是安全性我个人觉得比现在市面上的大多数组合对称加密方式要安全吧。

这是一个组合的加密方式，通过ECDH算法的EC/BC Provider进行秘钥磋商，得到一个Key对请求和响应的报文进行安全AES算法加密。

1. 我们先来了解下AES加密算法：

       高级加密标准(AES,Advanced Encryption Standard)为最常见的对称加密算法(微信小程序加密传输就是用这个加密算法的)。对称加密算法也就是加密和解密用相同的密钥，具体的加密流程如下图：

 

2. 然后是ECDH/ECC秘钥磋商：

ECC：Elliptic Curves Cryptography，椭圆曲线密码编码学

ECDSA：用于数字签名，是ECC与DSA的结合，整个签名过程与DSA类似，所不一样的是签名中采取的算法为ECC，最后签名出来的值也是分为r,s。

ECDH：是基于ECC（Elliptic Curve Cryptosystems，椭圆曲线密码体制，参看ECC）的DH（ Diffie-Hellman）密钥交换算法。交

重点说一下，ECDH用途：

由于通过ECDH，双方可以在不共享任何秘密的前提下协商出一个共享秘密，因此，ECDH广泛用于协议之中，通过ECDH得到对称加密密钥。如TLS中的*_ECDH_*密码套件。使用DH算法的协议，都可以升级到ECDH算法。ECDH具有ECC的高强度、短密钥长度、计算速度快等优点。


密钥交换过程：

假设密钥交换双方为Alice、Bob，其有共享曲线参数（椭圆曲线E、阶N、基点G）。


1.Alice生成随机整数a，计算A=a*G。Bob生成随机整数b，计算B=b*G。

2.Alice将A传递给Bob。A的传递可以公开，即攻击者可以获取A。由于椭圆曲线的离散对数问题是难题，

   所以攻击者不可以通过A、G计算出a。Bob将B传递给Alice。同理，B的传递可以公开。

3.Bob收到Alice传递的A，计算Q=b*A

4.Alice收到Bob传递的B，计算Q‘=a*B

最终：Alice、Bob双方即得Q=b*A=b*(a*G)=(b*a)*G=(a*b)*G=a*(b*G)=a*B=Q' (交换律和结合律)，

          即双方得到一致的密钥Q

3.最后是使用ECDH/ECC秘钥磋商，为AES加密提供加密/解密Key：

   具体过程：

    （1）服务器初始化时，客户端和服务端都会生成各自的一对初始化公私钥，并各自拥有对方的初始化公钥；

    （2）客户端请求服务端时，会生成一对临时公私钥，并使用初始化私钥对明文进行加签，然后客户端临时私钥与服务端初始化公钥进行秘钥磋商生成key，使用key对加签后的明文进行AES加密，对可无端请求时，会将签名，客户端临时公钥和密文一起传给服务端；

    （3）服务端获取请求参数后，会使用客户端临时公钥和自己服务端初始化私钥进行秘钥磋商获得key，对明文进行AES解密，

然后使用签名，客户端初始化公钥对密文进行解密操作；

 另外这里客户端和服务端秘钥磋商生成的key是一模一样的，这就ECDH/ECC秘钥磋商的效果

下面是我写的简单测试类
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.Provider;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.Security;
import java.security.Signature;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Map;
import java.util.Scanner;
 
import javax.crypto.Cipher;
import javax.crypto.KeyAgreement;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
 
import org.apache.commons.lang3.StringUtils;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.Base64Utils;
 
import com.google.common.collect.Maps;
 
import cn.sunline.common.exception.ProcessException;
 
public class AESTest {
    private static Logger logger = LoggerFactory.getLogger(AESTest.class);
    private static final String DEFAULT_CHARSET = "UTF-8";
    private static final String KEY_SET = "AES";
    private final static String charset = "utf-8";
    private final static String KEY_INSTANCE = "EC";
    private final static String SIGN_INSTANCE = "SHA1withECDSA";
    private final static String PROVIDER = "BC";
    private final static String ECDH = "ECDH";
    
    /** 服务端初始化公钥  */
    private static String serPubKey = "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEr5ztcktUiBfJuVSA2TQ+8CkSvtLNQRZg3XhyxlbAr+LxRg31WAC0mpIVx4PQEAZ9wyiIkD/2sPkA0ABIdxMEqQ==";
    
    /** 服务端初始化私钥  */
    private static String serPriKey = "MEECAQAwEwYHKoZIzj0CAQYIKoZIzj0DAQcEJzAlAgEBBCAqpgFzWbt1EAEkhH9iU68J6IxPSRLhNSVPS26PmiDcmQ==";
    
    /** 服务端临时公钥 */
    private static String tmpSerPubKey = "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0sCyuvgbTD8mdIcGtHm4VRp0Mgp9MEtTLwIxCb37K4If48B9eotGBtpZOIimQAUoX6U+rkyFumKCmpwMd1eRkQ==";
    
    /** 服务端临时私钥  */
    private static String TmpSerPriKey = "MEECAQAwEwYHKoZIzj0CAQYIKoZIzj0DAQcEJzAlAgEBBCD2I/MPxobXJFH3ZuqXqtfxARJhMMR4QG1IMaez/Yytgg==";
    
    /** 客户端初始化公钥  */
    private static String cliPubKey = "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEEwPf1HGy6slx7a3Ne/uIlfry2mOBsUOfNjoVkgNxbD+4YC2Uz0fiyJf8i/w2XD9OiYI2aap7h8ez+45g+butSQ==";
    
    /** 客户端初始化私钥  */
    private static String cliPriKey = "MEECAQAwEwYHKoZIzj0CAQYIKoZIzj0DAQcEJzAlAgEBBCDqh6fROJMhkWVuoee3bZKCEnnIT2nNBE+mgfqwAvvKfw==";
    
    /** 客户端临时公钥  */
    private static String TmpCliPubKey = "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtUYCQoax8bFbqpm4t797AzikHfOAhRyAJXctcZw7Ff3mW5uE6Nlq1TxjieySojdL9oHrsLgDC7je4bS9veGR5A==";
    
    /** 客户端临时私钥  */
    private static String TmpCliPriKey = "MEECAQAwEwYHKoZIzj0CAQYIKoZIzj0DAQcEJzAlAgEBBCA65SA+i6fh1KuNI9Nd5zK8A5+1d5473w0DEXZ+LwAGTQ==";
    
    public static void main(String[] args) {
//        String content = "7FD7C96E02B52341FD415374F0E3487B55F4987F87A32A8935A92AC6088ACE2B726AA314A3D4D52AA5874FC51CCC8CB3F6FF943E6CF224E6B3C7FED3D07DFFCBD82583D78BC58518149D79D956D0005DC3788D342855810306DF6B788CDD641364F00887736676C6347E19133D77A89221C025E9E0718B979ACFA8A532C14FC8FBF6C5C66B08FD5858C781F3911F375E17AEB8108CC79E87BA728BE2F39EBBDC4397ECEFE7EE961C4BF3ECF06BAFEA341B5BB93E7003B7228937C62CFDAE814A98B9B7644891CF0A62EC33B842B12D624DCC3A0FBFED9755EC600A355500BD76989AAE79AF43958F2258EBD2093C2F85";    
//        String content = "{\"serviceHeader\":{\"serviceId\":\"1010\",\"responseCode\":\"000000\",\"responseMsg\":\"请求成功\"},\"serviceBody\":{\"sessionId\":\"bf2d5af85239439aa56db5a149ddaaac\",\"userId\":null,\"deviceId\":\"990009263463476\",\"lastAccessTime\":\"2018-06-11 14:30:21\"}}";
        Scanner scanner = new Scanner(System.in);  
        System.out.println("请开始你的操作：1.客户端请求内容加密, 2.服务端对请求内容解密, 3.服务端相应内容解密, 4.客户端对服务端相应内容解密");
        System.out.println("请输入要操作的编号:");  
        int number = scanner.nextInt();
        
        switch (number) {
        case 1:
            System.out.println("开始客户端加密--------------------->");
            System.out.println("输入你要加密的内容后回车：");
            String content1 = scanner.next();
            //客户端加密
            Map<String, String> clientRequest = encryption(content1);
            String secretContent = clientRequest.get("secretContent");
            String signData = clientRequest.get("signData");
            System.out.println("加密后内容:"+secretContent);
            System.out.println("加密后签名:"+signData);
            break;
        case 2:
            System.out.println("开始服务端解密--------------------->");
            System.out.println("输入你要解密的内容后回车：");
            String secretContent1 = scanner.next();
            System.out.println("输入你的签名：");
            String signData1 = scanner.next();
            //服务端解密
            Map<String, String> sercerRequest = decryption(secretContent1, signData1);
            String textContent = sercerRequest.get("textContent");
            String res = sercerRequest.get("res");
            System.out.println("解密后:"+textContent);
            System.out.println("解密后验签结果:"+res);
            break;
        case 3:
            System.out.println("开始服务端加密--------------------->");
            System.out.println("输入你要加密的内容后回车：");
            String content2 = scanner.next();
            //服务端加密
            Map<String, String> serverResponse = serverEncryption(content2);
            String secretContent3 = serverResponse.get("secretContent");
            String signData3 = serverResponse.get("signData");
            System.out.println("加密后内容:"+secretContent3);
            System.out.println("加密后签名:"+signData3);
            break;
        case 4:
            System.out.println("开始客户端解密--------------------->");
            System.out.println("输入你要加密的内容后回车：");
            String secretContent2 = scanner.next();
            System.out.println("输入你的签名：");
            String signData2 = scanner.next();
            //客户端解密
            Map<String, String> clientResponse = serverDecryption(secretContent2, signData2);
            String textContent2 = clientResponse.get("textContent");
            String res2 = clientResponse.get("res");
            System.out.println("解密后:"+textContent2+", 解密后验签结果:"+res2);
            break;
        default:
            break;
        }
        
        System.out.println("|---------------------------------------------------------------------------------------------------|");
        System.out.println("|                                                                                                   |");
        System.out.println("|----------------------------------------服务结束，以上是结果内容-------------------------------------|");
        System.out.println("|                                                                                                   |");
        System.out.println("|---------------------------------------------------------------------------------------------------|");
//        
//        
//        
//        Map<String, String> keys = generatorKey();
//        String serPub = keys.get("serPubKey");
//        String serPri = keys.get("serPriKey");
//        String cliPub = keys.get("cliPubKey");
//        String cliPri = keys.get("cliPriKey");
//        
//        System.out.println(serPub);
//        System.out.println(serPri);
//        System.out.println(cliPub);
//        System.out.println(cliPri);
        
    }
    
    /**
     * client加密前置
     * @param content
     * @return
     */
    public static Map<String, String> encryption(String content){
        System.out.println("加密前:"+content);
        Map<String, String> encrypt = encrypt(content, TmpCliPriKey, serPubKey, cliPriKey);
        return encrypt;
    }
    
    /**    
     * server解密前置
     * @param secretContent
     * @param signData
     * @return
     */
    public static Map<String, String> decryption(String secretContent, String signData){
        Map<String, String> result = decrypt(secretContent, TmpCliPubKey, serPriKey, cliPubKey, signData);
        return result;
    }
    
    
    /**
     * server加密前置
     * @param content
     * @return
     */
    public static Map<String, String> serverEncryption(String content){
        System.out.println("加密前:"+content);
        Map<String, String> encrypt = encrypt(content, TmpSerPriKey, cliPubKey, serPriKey);
        return encrypt;
    }
    
    /**    
     * client解密前置
     * @param secretContent
     * @param signData
     * @return
     */
    public static Map<String, String> serverDecryption(String secretContent, String signData){
        //解密 + 验签
        Map<String, String> result = decrypt(secretContent, tmpSerPubKey, cliPriKey, serPubKey, signData);
        return result;
    }
    
    /**
     * 加密
     * @param content    待加密明文
     * @param serPriKey    服务端私钥用于加签
     * @param cliPubKey    客户端公钥用于和生成的服务端临时私钥磋商加密
     * @param cliPriKey2
     * @return
     */
    public static Map<String, String> encrypt(String content, String TmpCliPriKey, String serPubKey, String cliPriKey){
        Map<String, String> result = Maps.newHashMap();
        try {
            //加签
            String signData = sign(cliPriKey, content);
            System.out.println("加签:"+signData);
            //秘钥磋商
            String key = ecdhKey(TmpCliPriKey, serPubKey);
            System.out.println("加锁钥匙:ecdhKey[----------{"+key+"}----------]");
            String secretContent = doAES(content, key, Cipher.ENCRYPT_MODE);
            result.put("secretContent", secretContent);
            result.put("signData", signData);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
    
    /**
     * 解密
     * @param signData2
     * @param data  明文
     * @param key   加密秘钥
     * @param cliPubKey
     * @return
     */
    public static Map<String, String> decrypt(String content, String TmpCliPubKey, String serPriKey, String cliPubKey, String signData){
        
        Map<String, String> result = Maps.newHashMap();
        try {
            //秘钥磋商
            String key = ecdhKey(serPriKey, TmpCliPubKey);
            System.out.println("开锁钥匙:ecdhKey[----------{"+key+"}----------]");
            String textContent = doAES(content, key, Cipher.DECRYPT_MODE);
            System.out.println("解密后内容:" + textContent);
            //验签
            boolean res = verify(textContent, cliPubKey, signData);
            result.put("textContent", textContent);
            result.put("res", res+"");
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return result;
    }
    
    /**
     * 验签
     * @param textContent    解密明文
     * @param serPubKey        服务端公钥
     * @param signData        签名
     * @return
     */
    private static boolean verify(String textContent, String serPubKey, String signData) {
        try {
            //验签
            byte[] keyBytes = Base64Utils.decode(serPubKey.getBytes(charset));
            byte[] contentBytes = Base64Utils.decode(textContent.getBytes(charset));
            byte[] signBytes = Base64Utils.decode(signData.getBytes(charset));
            X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_INSTANCE);
            PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
            Signature signature = Signature.getInstance(SIGN_INSTANCE);
            signature.initVerify(publicKey);  
            signature.update(contentBytes);
            return signature.verify(signBytes);
        } catch (Exception e) {
            logger.error("报文签名验证出现异常", e);
            throw new ProcessException("", "报文签名验证出现异常");
        }
    }
 
    /**
     * 秘钥磋商
     * @param serPriKey
     * @param cliPubKey
     * @return
     */
    private static String ecdhKey(String serPriKey, String cliPubKey) {
        try {
                    //使用ECDH-BC前，BC方法添加进环境信息内
            Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
            //初始化ecdh keyFactory
            KeyFactory keyFactory = KeyFactory.getInstance(ECDH, PROVIDER);
            //处理私钥
            byte[] priKeyBytes = Base64Utils.decode(serPriKey.getBytes(charset));
            PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(priKeyBytes);
            PrivateKey ecPriKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
            //处理公钥
            byte[] pubKeyBytes = Base64Utils.decode(cliPubKey.getBytes(charset));
            X509EncodedKeySpec pubX509 = new X509EncodedKeySpec(pubKeyBytes);
            PublicKey ecPubKey = keyFactory.generatePublic(pubX509);
            //秘钥磋商生成新的秘钥byte数组
            KeyAgreement aKeyAgree = KeyAgreement.getInstance(ECDH, PROVIDER);
            aKeyAgree.init(ecPriKey);
            aKeyAgree.doPhase(ecPubKey, true);
            return Base64Utils.encodeToString(aKeyAgree.generateSecret());
        } catch (Exception e) {
            logger.error("秘钥磋商出现异常", e);
            throw new ProcessException("", "秘钥磋商出现异常");
        }
    }
 
    /**
     * 加签
     * @param serPriKey
     * @param content
     * @return
     */
    private static String sign(String serPriKey, String content) {
        try {
            byte[] keyBytes = Base64Utils.decode(serPriKey.getBytes(charset));
            byte[] contentBytes = Base64Utils.decode(content.getBytes(charset));
            PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_INSTANCE);
            PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
            Signature signature = Signature.getInstance(SIGN_INSTANCE);
            signature.initSign(privateKey);
            signature.update(contentBytes);
            return Base64Utils.encodeToString(signature.sign());
        } catch (Exception e) {
            logger.error("报文加签出现出现异常", e);
            throw new ProcessException("", "报文加签出现出现异常");
        }
    }
 
 
    private static String doAES(String data, String key, int mode) {
        try {
            if(StringUtils.isBlank(data) || StringUtils.isBlank(key)){
                return null;
            }
            boolean encrypt = mode == Cipher.ENCRYPT_MODE;
            byte[] content;
            //判断加密还是解密
            if(encrypt){
                content = data.getBytes(DEFAULT_CHARSET);
            }else{
                content = parseHexStr2Byte(data);
            }
            //1.构造秘钥生成器，指定为AES算法，不区分大小写
            KeyGenerator kgen = KeyGenerator.getInstance(KEY_SET);
            //2.根据EncodeResult规则初始化秘钥生成器，生成一个128位的随机源，根据传入的字节数组
            kgen.init(128, new SecureRandom((key.getBytes())));
            //3.产生原始对称秘钥
            SecretKey secretKey = kgen.generateKey();
            //4.获取原始对称秘钥的字节数组
            byte[] enCodeFormat = secretKey.getEncoded();
            //5.根据字节数组生成AES秘钥
            SecretKeySpec keySpec = new SecretKeySpec(enCodeFormat, KEY_SET);
            //6.根据指定算法AES自称密码器
            Cipher cipher = Cipher.getInstance(KEY_SET);
            //7.初始化秘钥器，第一个参数为加密或者解密操作，第二个参数为使用的Key
            cipher.init(mode, keySpec);//初始化
            byte[] result = cipher.doFinal(content);
            if(encrypt){
                //将二进制转化成16进制
                return parseByte2HexStr(result);
            }else{
                return new String(result, DEFAULT_CHARSET);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
 
    /**
     * 将二进制转化成十六进制
     * @param result
     * @return
     */
    private static String parseByte2HexStr(byte[] result) {
        StringBuffer buffer = new StringBuffer();
        for (int i=0;i < result.length;i++){
            String hex = Integer.toHexString(result[i] & 0xFF);
            if(hex.length() == 1){
                hex = '0' + hex;
            }
            buffer.append(hex.toUpperCase());
        }
        return buffer.toString();
    }
 
    /**
     * 将十六进制转换成二进制
     * @param data
     * @return
     */
    private static byte[] parseHexStr2Byte(String data) {
 
        if(data.length() < 1){
            return null;
        }
        int hexStr = data.length() / 2;
        byte[] result = new byte[hexStr];
        for(int i=0;i<hexStr;i++){
            int high = Integer.parseInt(data.substring(i * 2, i * 2 + 1), 16);
            int low = Integer.parseInt(data.substring(i * 2 + 1, i * 2 + 2), 16);
            result[i] = (byte) (high * 16 +low);
        }
        return result;
    }
 
    /**
     * 生成客户端服务端初始化公私钥
     * @return
     */
    public static Map<String, String> generatorKey(){
        Map<String, String> keys = Maps.newHashMap();
        try {
            Provider provider = new BouncyCastleProvider();
            //1.服务端初始化密钥   
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("ECDH", provider);  
            keyPairGenerator.initialize(256);  
            KeyPair keyPair = keyPairGenerator.generateKeyPair();             //生成密钥对
//            生成服务端公私钥
            String serPubKey = Base64Utils.encodeToString(keyPair.getPublic().getEncoded());
            String serPriKey = Base64Utils.encodeToString(keyPair.getPrivate().getEncoded());
            
            //1.客户端初始化密钥   
            KeyPairGenerator keyPairGenerator2 = KeyPairGenerator.getInstance("ECDH", provider);  
            keyPairGenerator2.initialize(256);  
            KeyPair keyPair2 = keyPairGenerator2.generateKeyPair();             //生成密钥对
//            生成客戶端公私钥
            String cliPubKey = Base64Utils.encodeToString(keyPair2.getPublic().getEncoded());
            String cliPriKey = Base64Utils.encodeToString(keyPair2.getPrivate().getEncoded());
            keys.put("serPubKey", serPubKey);
            keys.put("serPriKey", serPriKey);
            keys.put("cliPubKey", cliPubKey);
            keys.put("cliPriKey", cliPriKey);
        } catch (NoSuchAlgorithmException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return keys;
    }
}
---------------------
 

caodongfang126
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
file-force：分散的匿名加密目标文件共享工具
02-04
文件力 去中心化的匿名加密对象/文件共享工具，其功能如下： 分散的文件存储（或网络）。 椭圆曲线密码学（曲线： ） ， 和 （跟踪和不可否认机制） 安装 首先，您需要使文件强制进入您的项目。 您可以使用npm和package.json。 " dependencies " : { " file-force " : " https://github.com/ikonovalov/file-force.git " } ...和 > npm install 在Node.js中使用 yaml-config模块的配置app.yml default : ipfs : a
Ecdh-agree算法
04-07
Ecdh-agree算法源代码，使用Crypto++所做的Diffie算法
Core/Standard版ECDH(秘钥磋商)+AES(加解密)
05-06
封装了.net core和.net Standard版的ECDH秘钥磋商和AES加解密源码。
加密解密算法-java 实现(algorithm.rar)
02-22
公司要求调研加密解密算法，该资源包含 RAS，AES，3DES，Blowfish，RC4，IDEA，DSA，Diffile-Hellman(D-H) 解密和解密的是代码，亲测可用。
securechat:点对点加密聊天，使用 RSA 和 ECDH
07-02
安全聊天 点对点加密聊天，使用 RSA 和 ECDH。 使用资源 Cryptico.js： 、 base64.js: , PasswordHash.java： 引导模板： 应用服务器：WildFly-8.2.0.Final 数据库：PostgreSQL-9.4 演示
物联网安全系列 - 非对称加密算法 ECDH
物联网布道师
07-13 8061
   之前的章节讲到了对称加密算法AES，发送方和接收方需要使用相同的密钥进行通讯，但是发送方怎么将密钥安全的发送给接收方？这是一个问题。   对称加密算法中，为了将密钥安全的发送给对端，通常有以下四种方法：事先共享密钥    事先双方约定好密钥的数值，或者使用其他安全的手段例如派特工押送等，将密钥安全的送到对端，这种方式虽然简单，但是局限性很大，另外通讯量增大以后，密钥个数也会相应增加，这在高数量级的设备通讯上并不现实。密钥分配中心    为了解决事先共享密钥的密钥增多的问题，也可以使用密钥分配中心来解决
ECDH、ECDSA、AES
最新发布
qq_40716069的博客
08-24 215
简单介绍ECDH
RSA+AES实现混合加密
wzw_wwl的博客
03-24 7080
RSA+AES实现混合加密
易语言ECDH密钥生成与密钥协商-易语言
06-12
易语言ECDH密钥生成与密钥协商
ECDHUtils-OC:ECDH ECC DH OpenSSL Object-C iOS OC
05-11
ECDHUtils-OC
常见加密算法附JAVA代码案例
俗尘某某
06-20 1577
1、对称加密算法（AES、DES、3DES） 对称加密算法是指加密和解密采用相同的密钥，是可逆的（即可解密）。 AES加密算法是密码学中的高级加密标准，采用的是对称分组密码体制，密钥长度的最少支持为128。AES加密算法是美国联邦政府采用的区块加密标准，这个标准用来替代原先的DES，已经被多方分析且广为全世界使用。 AES数学原理详解：https://www.cnblogs.com/bloc.....................
安全加解密引擎基础（ECC、ECDH）
qq_32100199的博客
10-16 2193
ECC、ECDH、ECDSA
BLE安全机制从入门到放弃
weixin_42583147的博客
06-21 5026
端午安康，今天借Jayden这篇文章和大家谈一下无线传输的信息安全，该文从加密，认证，以及对应的算法优劣做了清晰明确的介绍，并在此基础上对蓝牙的配对加密过程进行了分析，是我看到把信息安全和蓝牙配对讲的很透彻的科普文章，该文也给各位工程师提供了一课信息安全的科普。如何保障无线传输中的数据安全是一项非常重要的课题，我们要在做工程角度运用各种密码技术保障数据的安全性。另外非常推荐结城浩的《图解密码技术...
ECC证书操作汇总（ECC certificate operations summary)
阿道夫的博客
12-12 1209
项目里用到了ECC的证书使用，有一些证书的常规操作，在此进行汇总说明，以便后浪来踏。ECC的public key长度为65字节，第一个字节是标识符0x04，32字节biginteger X, 32字节biginteger Y;private key的长度是 32字节的biginteger。以下代码示例均为ECC secp256r1 曲线。
AES,RSA,ECC加密算法实现
Embeded system Development
04-01 3290
RSA算法： [java] view plaincopy package key;   import java.math.BigInteger;   import java.util.Random;         public class RSA extends Cryption{        KEY ku;//公钥
ECC椭圆曲线加密算法
qq_47529104的博客
02-25 3486
ECC算法概述 ECC：Elliptic Curves Cryptography，椭圆曲线密码编码学 ECDSA：用于数字签名，是ECC与DSA的结合，整个签名过程与DSA类似，所不一样的是签名中采取的算法为ECC，最后签名出来的值也是分为r,s。 ECDHE：是基于ECC（Elliptic Curve Cryptosystems，椭圆曲线密码体制，参看ECC）的DH（ Diffie-Hellman）密钥交换算法。 椭圆曲线加密算法，简称ECC，是基于椭圆曲线数学理论实现的一种非对称加密算法。相比R
ECC-based 算法(ECDSA/ECDH) 新潮算法的原理
热门推荐
tiandyoin的专栏
06-01 1万+
ECDH:       ECC算法用途比RSA还猛，不仅可以加解密、签名验证。还可以与DH结合使用，用于密钥磋商，这个密钥交换算法称为ECDH。交换双方可以在不共享任何秘密的情况下协商出一个密钥。ECC是建立在基于椭圆曲线的离散对数问题上的密码体制，给定椭圆曲线上的一个点P，一个整数k，求解Q=kP很容易；给定一个点P、Q，知道Q=kP，求整数k确是一个难题。ECDH即建立在此数学难题之上。密钥
椭圆曲线加密ECC及密钥交换ECDH
Starr
01-18 1162
椭圆曲线加密及密钥交换
_DEFAULT_CIPHERS = ( 'ECDH+AESGCM:DH+AESGCM:ECDH+AES256:DH+AES256:ECDH+AES128:DH+AES:ECDH+HIGH:' 'DH+HIGH:ECDH+3DES:DH+3DES:RSA+AESGCM:RSA+AES:RSA+HIGH:RSA+3DES:ECDH+RC4:' 'DH+RC4:RSA+RC4:!aNULL:!eNULL:!MD5' )
06-06
这是Python的SSL/TLS加密套件配置，它定义了SSL/TLS握手协议中使用的加密算法和密钥长度等。该配置指定了多个加密套件，这些加密套件包括了ECDH、DH、RSA等算法，同时也排除了一些不安全或过时的算法，如aNULL、eNULL和MD5等。这个默认的配置是经过安全专家审查的，可以提供较高的安全性和性能。如果你需要更改或自定义加密套件配置，可以修改这个默认值。但是需要注意，不当的配置可能会导致安全风险或性能下降。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值