使用SM2算法进行密钥交换的代码（BC包装）

最新推荐文章于 2024-09-03 23:15:00 发布
置顶 最新推荐文章于 2024-09-03 23:15:00 发布
阅读量6.3k 收藏 8
点赞数 1
分类专栏： 商密 SM2 密钥交换 文章标签： java 加密解密 安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baikeley74/article/details/106884922
版权
商密 同时被 3 个专栏收录
4 篇文章 9 订阅
订阅专栏
SM2
3 篇文章 0 订阅
订阅专栏
密钥交换
1 篇文章 0 订阅
订阅专栏

使用SM2算法进行密钥交换的代码（BC包装）

SM2是国家密码管理局于2010年12月17日发布的椭圆曲线公钥密码算法。SM2算法和RSA算法都是公钥密码算法，SM2算法是一种更先进安全的算法，在我们国家商用密码体系中被用来替换RSA算法。

SM2密钥交换的优点

  1. 密钥更短 ；
  2. 速度更快 ；
  3. 更加安全；

说明如下
BouncyCastleProvider bcp = new BouncyCastleProvider();
Security.addProvider(bcp);
需要在工程里面引用BC库。到http://www.bouncycastle.org/ 下载bcprov-ext-jdk15on-165.jar
在eclipse亲测可用。
把下面的两个文件完全复制下来，文件名已经包含在文件头。
存成两个java文件。
直接就可以执行了。
用SM2 做密钥交换虽然可以，但经过这个测试后，本人感觉SM2密钥交换比DH麻烦太多了！商用环境还是需要提高便利性，让大多数程序员去了解算法的椭圆曲线细节不太现实。
如果有致力于商密算法研究，特别是BC优化方面的人， 建议对此进行优化，把算法的细节尽量全部包装在库中。

代码如下：

/***
 * xuyanbai  2020.6.6 文件名 SM2Coder_Ag.java
 */
package xu.edu.testSM2_Agree;
import java.math.BigInteger;

import java.security.SecureRandom;

import java.util.HashMap;
import java.util.Map;
import org.bouncycastle.crypto.AsymmetricCipherKeyPair;
import org.bouncycastle.crypto.agreement.SM2KeyExchange;
import org.bouncycastle.crypto.generators.ECKeyPairGenerator;
import org.bouncycastle.crypto.params.ECDomainParameters;
import org.bouncycastle.crypto.params.ECKeyGenerationParameters;
import org.bouncycastle.crypto.params.ECPrivateKeyParameters;
import org.bouncycastle.crypto.params.ECPublicKeyParameters;
import org.bouncycastle.crypto.params.ParametersWithID;
import org.bouncycastle.crypto.params.SM2KeyExchangePrivateParameters;
import org.bouncycastle.crypto.params.SM2KeyExchangePublicParameters;

import org.bouncycastle.math.ec.ECConstants;
import org.bouncycastle.math.ec.ECCurve;
import org.bouncycastle.math.ec.ECPoint;

import org.bouncycastle.util.Strings;

import org.bouncycastle.util.test.TestRandomBigInteger;


public class SM2Coder_Ag {
    //xuyanbai add it for curve use
	//come from GB T 32918.3-2016 and BC 
    static BigInteger SM2_ECC_P = new BigInteger("8542D69E4C044F18E8B92435BF6FF7DE457283915C45517D722EDB8B08F1DFC3", 16); //素数域
    static BigInteger SM2_ECC_A = new BigInteger("787968B4FA32C3FD2417842E73BBFEFF2F3C848B6831D7E0EC65228B3937E498", 16); //曲线系数a
    static BigInteger SM2_ECC_B = new BigInteger("63E4C6D3B23B0C849CF84241484BFE48F61D59A5B16BA06E6E12D1DA27C5249A", 16); //曲线系数b
    static BigInteger SM2_ECC_N = new BigInteger("8542D69E4C044F18E8B92435BF6FF7DD297720630485628D5AE74EE7C32E79B7", 16); //生成元G的阶数
    static BigInteger SM2_ECC_H = ECConstants.ONE;                                  //余因子为1
    static BigInteger SM2_ECC_GX = new BigInteger("421DEBD61B62EAB6746434EBC3CC315E32220B3BADD50BDC4C4E6C147FEDD43D", 16); //生成元x坐标
    static BigInteger SM2_ECC_GY = new BigInteger("0680512BCBB42C07D47349D2153B70C4E5D7FDFCBFA36EA1A85841B9E46E09A2", 16); 生成元x坐标


		//获取椭圆曲线
	private static ECDomainParameters domainParams=null;
    private static void getcurve()
    {
    	if(domainParams !=null)return;
    	 ECCurve curve = new ECCurve.Fp(SM2_ECC_P, SM2_ECC_A, SM2_ECC_B, SM2_ECC_N, SM2_ECC_H);

         ECPoint g = curve.createPoint(SM2_ECC_GX, SM2_ECC_GY);
         domainParams = new ECDomainParameters(curve, g, SM2_ECC_N);
         return ;
    }
	/**
	 * 初始化甲方密钥
	 * 
	 * @return Map 甲方密钥Map
	 * @throws Exception
	 */
	public static Map<String, Object> initKeyA() throws Exception {

		// 构造曲线
		getcurve();
		// 实例化密钥对生成器
		ECKeyPairGenerator keyPairGenerator = new ECKeyPairGenerator();
		
        //A用户私钥6FCBA2EF9AE0AB902BC3BDE3FF915D44BA4CC78F88E2F8E7F8996D3B8CCEEDEE
		ECKeyGenerationParameters aKeyGenParams = new ECKeyGenerationParameters(domainParams, new TestRandomBigInteger("6FCBA2EF9AE0AB902BC3BDE3FF915D44BA4CC78F88E2F8E7F8996D3B8CCEEDEE", 16));
		// 初始化密钥对生成器
		keyPairGenerator.init(aKeyGenParams);
		// 生成密钥对
//		KeyPair keyPair = keyPairGenerator.generateKeyPair();
		AsymmetricCipherKeyPair aKp = keyPairGenerator.generateKeyPair();
		// 甲方公钥
		//PublicKey publicKey = (PublicKey) keyPair.getPublic();
		ECPublicKeyParameters aPub = (ECPublicKeyParameters)aKp.getPublic();
		// 甲方私钥
		//PrivateKey privateKey = (PrivateKey) keyPair.getPrivate();
		ECPrivateKeyParameters aPriv = (ECPrivateKeyParameters)aKp.getPrivate();
		
		//ra随机数
        //ECKeyGenerationParameters aeKeyGenParams = new ECKeyGenerationParameters(domainParams, new TestRandomBigInteger("83A2C9C8B96E5AF70BD480B472409A9A327257F1EBB73F5B073354B248668563", 16));
		SecureRandom random= new SecureRandom();
		ECKeyGenerationParameters aeKeyGenParams = new ECKeyGenerationParameters(domainParams, random);
        keyPairGenerator.init(aeKeyGenParams);
      
        AsymmetricCipherKeyPair aeKp = keyPairGenerator.generateKeyPair();

        ECPublicKeyParameters aePub = (ECPublicKeyParameters)aeKp.getPublic();
        ECPrivateKeyParameters aePriv = (ECPrivateKeyParameters)aeKp.getPrivate();
		// 将密钥对存储在Map中
		Map<String, Object> keyMap = new HashMap<String, Object>(4);

		//keyMap.put(PUBLIC_KEY, publicKey);
		keyMap.put("aPub", aPub);
		//keyMap.put(PRIVATE_KEY, privateKey);
		keyMap.put("aPriv", aPriv);
		keyMap.put("aePub",aePub);
		keyMap.put("aePriv",aePriv);
		
		return keyMap;
	}

	/**
	 * 初始化乙方密钥
	 * 
	 * @param key
	 *            甲方公钥
	 * @return Map 乙方密钥Map
	 * @throws Exception
	 */
	public static Map<String, Object> initKeyB() throws Exception {

		 //rb ,乙方
		ECKeyGenerationParameters bKeyGenParams = new ECKeyGenerationParameters(domainParams, new TestRandomBigInteger("5E35D7D3F3C54DBAC72E61819E730B019A84208CA3A35E4C2E353DFCCB2A3B53", 16));
		// 初始化算法参数生成器

		// 实例化密钥对儿生成器
        ECKeyPairGenerator keyPairGenerator = new ECKeyPairGenerator();
		// 初始化密钥对儿生成器
		 keyPairGenerator.init(bKeyGenParams);
		// 生成密钥对儿
		 AsymmetricCipherKeyPair bKp = keyPairGenerator.generateKeyPair();
		 //获取B用户的公私钥
	    ECPublicKeyParameters bPub = (ECPublicKeyParameters)bKp.getPublic();
	    ECPrivateKeyParameters bPriv = (ECPrivateKeyParameters)bKp.getPrivate();
	    //获取be的参数，rb随机
	    SecureRandom random= new SecureRandom();
	    //ECKeyGenerationParameters beKeyGenParams = new ECKeyGenerationParameters(domainParams, new TestRandomBigInteger("33FE21940342161C55619C4A0C060293D543C80AF19748CE176D83477DE71C80", 16));
	    ECKeyGenerationParameters beKeyGenParams = new ECKeyGenerationParameters(domainParams, random);	
        keyPairGenerator.init(beKeyGenParams);

        AsymmetricCipherKeyPair beKp = keyPairGenerator.generateKeyPair();

        ECPublicKeyParameters bePub = (ECPublicKeyParameters)beKp.getPublic();
        ECPrivateKeyParameters bePriv = (ECPrivateKeyParameters)beKp.getPrivate();

		// 封装密钥
		Map<String, Object> map = new HashMap<String, Object>(4);

		//map.put(PUBLIC_KEY, publicKey);
		map.put("bPub", bPub);
		//map.put(PRIVATE_KEY, privateKey);
		map.put("bPriv", bPriv);
		map.put("bePub", bePub);
		map.put("bePriv", bePriv);
		return map;

	}
/***
 * 
 * @param aPriv
 * @param aePriv
 * @param bPub
 * @param bePub
 * @return 协商后的密钥
 * @throws Exception
 */
	public static byte[] KeyExchangeA(ECPrivateKeyParameters aPriv,ECPrivateKeyParameters aePriv,ECPublicKeyParameters bPub,ECPublicKeyParameters bePub) throws Exception {
		
		SM2KeyExchange exch = new SM2KeyExchange();
		
        exch.init(new ParametersWithID(new SM2KeyExchangePrivateParameters(true, aPriv, aePriv), Strings.toByteArray("ALICE123@YAHOO.COM")));

        byte[] k1 = exch.calculateKey(128, new ParametersWithID(new SM2KeyExchangePublicParameters(bPub, bePub), Strings.toByteArray("BILL456@YAHOO.COM")));
		//共享密钥是55b0ac62a6b927ba23703832c853ded4
       // isTrue("key 1 wrong", Arrays.areEqual(Hex.decode("55b0ac62a6b927ba23703832c853ded4"), k1));

		return k1;
	}

	/****
	 * 
	 * @param bPriv
	 * @param bePriv
	 * @param aPub
	 * @param aePub
	 * @return 返回协商后的密钥
	 * @throws Exception
	 */
	public static byte[] KeyExchangeB(ECPrivateKeyParameters bPriv,ECPrivateKeyParameters bePriv,ECPublicKeyParameters aPub,ECPublicKeyParameters aePub) throws Exception {

		SM2KeyExchange exch = new SM2KeyExchange();

	        exch.init(new ParametersWithID(new SM2KeyExchangePrivateParameters(false, bPriv, bePriv), Strings.toByteArray("BILL456@YAHOO.COM")));

	        byte[] k2 = exch.calculateKey(128, new ParametersWithID(new SM2KeyExchangePublicParameters(aPub, aePub), Strings.toByteArray("ALICE123@YAHOO.COM")));

	  //      isTrue("key 2 wrong", Arrays.areEqual(Hex.decode("55b0ac62a6b927ba23703832c853ded4"), k2));
		return k2;
	}

	
	/**
	 * 取得私钥
	 * 
	 * @param keyMap
	 *            密钥Map
	 * @return byte[] 私钥
	 * @throws Exception
	 */
	public static ECPrivateKeyParameters getPrivateKey(String str,Map<String, Object> keyMap )
			throws Exception {

		ECPrivateKeyParameters key = (ECPrivateKeyParameters) keyMap.get(str);
		return key;
	}

	/**
	 * 取得公钥
	 * 
	 * @param keyMap
	 *            密钥Map
	 * @return byte[] 公钥
	 * @throws Exception
	 */
	public static ECPublicKeyParameters getPublicKey(String str,Map<String, Object> keyMap )
			throws Exception {

		ECPublicKeyParameters key = (ECPublicKeyParameters) keyMap.get(str);

		return key;
	}
}


   下面的文件是用前面的包装类进行测试 的文件：

/***
 * xuyanbai  2020.6.6 文件名：SM2Coder_AgTest.java
 */
package xu.edu.testSM2_Agree;

import java.security.Security;
import java.util.Map;

import org.bouncycastle.util.encoders.Base64;
import org.bouncycastle.crypto.params.ECPrivateKeyParameters;
import org.bouncycastle.crypto.params.ECPublicKeyParameters;
import org.bouncycastle.jce.provider.BouncyCastleProvider;

public class SM2Coder_AgTest {


	public final void test() throws Exception {

		// 生成甲方密钥对儿
		Map<String, Object> keyMap1 = SM2Coder_Ag.initKeyA();
	 // 生成乙方密钥对儿
		Map<String, Object> keyMap2 = SM2Coder_Ag.initKeyB();
		//甲方生成的密钥
		ECPrivateKeyParameters aPriv = SM2Coder_Ag.getPrivateKey("aPriv", keyMap1);
		ECPrivateKeyParameters aePriv = SM2Coder_Ag.getPrivateKey("aePriv", keyMap1);
		
		ECPublicKeyParameters aPub = SM2Coder_Ag.getPublicKey("aPub", keyMap1);
		ECPublicKeyParameters aePub = SM2Coder_Ag.getPublicKey("aePub", keyMap1);
		
	
		//乙方生成的密钥
		ECPrivateKeyParameters bPriv = SM2Coder_Ag.getPrivateKey("bPriv", keyMap2);
		ECPrivateKeyParameters bePriv = SM2Coder_Ag.getPrivateKey("bePriv", keyMap2);
	
		ECPublicKeyParameters bPub = SM2Coder_Ag.getPublicKey("bPub", keyMap2);
		ECPublicKeyParameters bePub = SM2Coder_Ag.getPublicKey("bePub", keyMap2);
		//开始协商		
		byte[] mykeyA = SM2Coder_Ag.KeyExchangeA(aPriv, aePriv, bPub, bePub);
		byte[] mykeyB = SM2Coder_Ag.KeyExchangeB(bPriv, bePriv, aPub, aePub);
		
		//输出结果
		System.out.println("甲方协商结果:\n" + Base64.toBase64String(mykeyA));
		System.out.println("乙方协商结果:\n" + Base64.toBase64String(mykeyB));

	
	}


	public static void main(String[] args) throws Exception {
		//初始化BC库
		 BouncyCastleProvider bcp = new BouncyCastleProvider();
		 Security.addProvider(bcp);

		 SM2Coder_AgTest a =new SM2Coder_AgTest();
   		a.test();
	}
}


执行结果类似如下：（每次协商均为不同的密钥值）
甲方协商结果:
ywR8rVvf8dqKt/B2ovPlXw==
乙方协商结果:
ywR8rVvf8dqKt/B2ovPlXw==
baikeley74
关注
专栏目录
GMSSL ：SM2椭圆曲线公钥密码算法-密钥交换协议
vincy_yeha的博客
12-26 2652
2021SC@SDUSC 目录 一、整体架构 二、具体分析 前一篇文章写了密钥交换协议的基本流程，这一篇文章看一下代码实现 一、整体架构 整体来看这一部分有6个函数，相对重要的是序号3，4代表的函数 二、具体分析 首先看第一个函数 从名称可以初步判断出，这是对交换需要的用的数据进行初始化 分析这部分函数的代码，主要内容基本就是对结构体ctx的各个成员进行复制 ctx->id_dgstlen = sizeof(ctx->id_dgst); ctx->rem..
java中SM2加密算法的实操代码
wjianwei666的专栏
05-31 1542
我们指定了算法为"EC"，提供者为"Bouncy Castle"。在上面的代码中，我们使用Cipher类来进行加密操作。我们指定了算法为"SM2"，提供者为"Bouncy Castle"。然后，我们使用init方法初始化加密器，并指定加密模式为Cipher.ENCRYPT_MODE，以及使用公钥进行加密。我们指定了算法为"SM2"，提供者为"Bouncy Castle"。然后，我们使用init方法初始化解密器，并指定解密模式为Cipher.DECRYPT_MODE，以及使用私钥进行解密。
java 国密算法实现包含SM2 SM3 SM4和数字签名、数字证书的验证
05-05
java 国密算法实现，包含SM2 SM3 SM4和数字签名、数字证书的验证以及相应的说明文档
TLCP国密协议ECC（SM2）密钥交换协议验签过程
weixin_41034271的博客
07-19 365
目前在现有商密SM系列算法使用下：依据GB/T38636-2020《信息安全技术传输层密码协议（TLCP）》相关技术规范，在使用ECC（SM2）进行密钥交换时,singed_params是服务端对双方随机数和服务端加密证书的签名。以下为标准信息： 1. 打开国密算法算法的业务系统，并进行抓包2. 抓...
SM2：密钥交换
weixin_44885334的博客
12-17 2120
国家标准全文公开系统：http://openstd.samr.gov.cn/ 本文参考：http://c.gb688.cn/bzgk/gb/showGb?type=online&hcno=66A89DD6DA64F49C49456B757BA0624F 系统参数 域FqF_qFq​的描述 椭圆曲线的两个定义元a,b∈Fqa,b \in F_qa,b∈Fq​ E(Fq)E(F_q)E(Fq​)的基点G=(xG,yG)≠OG=(x_G,y_G) \not = OG=(xG​,yG​)​=O，其中x
Python实现SM2密钥交换协议
Hopeless_Loop的博客
01-25 1527
​ 本文参考自国家密码管理局发布的《SM2椭圆曲线公钥密码算法》。不对SM2密钥交换协议的算法细节做介绍，着眼于代码实现。
SM2密钥交换
l13501058595的博客
10-13 1436
SM2密钥交换 代码拆解（只做记录） 1.创建曲线（标准曲线） public class SM2Util extends SM2GennerateKeyPair{ /** 素数p */ public static final BigInteger p = new BigInteger("FFFFFFFE" + "FFFFFFFF" + "FFFFFFFF" + "FFFFFFFF" + "FFFFFFFF" + "00000000" + "FFFFFFFF"
SM2中密钥交换的问题
l13501058595的博客
10-13 2090
SM2中密钥交换的问题 1.字节数组转十六进制字符串（Hex） public static String HexString(byte[] b) { StringBuilder builder = new StringBuilder(); if (b == null || b.length <= 0){ return null; } for (int i = 0; i < b.length; i++) {
SM2密钥交换算法的java语言实现
weixin_30724853的博客
08-24 2625
考虑到网上大多数SM2密钥交换协议均是C语言实现，没有找到java实现的版本，所以参考了网上SM2加密算法实现的代码，自行写出了Java版本的密钥交换算法。 本文中的SM2.java SM3.java SM3Digest.java Util.java来源于CSDN博客：https://blog.csdn.net/ErErFei/article/details/50998162 本文程序均...
国密密钥生成算法java_【国密SM2算法】创建密钥对、通过base64密钥串生成PublicKey和PrivateKey...
weixin_39635084的博客
02-26 5192
一：创建密钥对System.out.println("----------生成秘钥对start----------------");//引入BC库Security.addProvider(newBouncyCastleProvider());//获取SM2椭圆曲线的参数finalECGenParameterSpecsm2Spec=newECGenParameterSpec("sm2...
Java实现加密（六）国密SM2算法
最新发布
ACGkaka的博客
09-03 1784
Java实现加密（六）国密SM2算法
SM2密钥交换协议java实现所需导入的库函数
08-24
该库是实现椭圆曲线的很多功能。比如生成给定参数的椭圆曲线，计算椭圆曲线点的相加，点乘运算等等功能。
基于MIRACL库下的SM2密钥交换的实现
10-24
基于MIRACL库下的SM2加密算法的实现。其中SM3算法以及KDF算法非原创
SM2密钥生成、加解密、签名验签、密钥交换
11-01
工具功能：SM2密钥生成、SM2加密解密、SM2签名验签、SM2密钥交换
国密SM2椭圆曲线密码算法
一切有为法，如梦亦如幻，如露亦如电，应作如是观。
08-15 6870
其中，HASH为使用SM3算法对明文数据运算得到的杂凑值，其长度固定为256位。CipherText是与明文数据等长的密文。
商用密码应用与安全性评估要点笔记（SM2密钥交换算法）
ryanzzzzz的博客
03-21 3758
PA和PB分别是A和B实体的公钥（公开的），dA和dB分别是A和B实体的私钥（不公开），ZA和ZB分别分别是A和B的唯一标识（公开的）。SM2密码算法是我国2010年发布的商用密码算法，属于公钥密码算法，也成为非对称密钥机制密码算法。SM2算法私钥长度为256bit，公钥长度为512bit。A和B两个交互实体，用各自的密钥和对方的公钥来商定一个只有他们自己知道的密钥（一般是对称密钥）。当A和B双方协商出共享密钥KA=KB，可选的第三条消息是可以进行密钥确认，即A和B确认协商到的密钥是一致的。
SM2算法第三篇：实现SM2秘钥交换协议的算法流程
热门推荐
刘兵马俑的博客
04-19 2万+
秘钥交换协议
国密算法 SM2 公钥加密 数字签名 密钥交换 全网最高效的开源python代码
qq_43339242的博客
07-12 3310
国密算法 SM2 公钥加密 数字签名 密钥交换 全网最高效的开源python代码 采用预计算技术加速椭圆曲线基点点乘，SM2基点点乘效率追平PyCryptodome库的ECC-256
SM2加密算法示列 java代码示例
06-21
SM2是中国的国密算法，全称为“安全多方信息基础”（Secure Multi-party Information Base）算法之一，主要用于数字签名和密钥交换。Java中实现SM2加密算法需要使用专门的库，如BCryptor或中国国密算法的Java实现。 以下是一个简化的Java代码示例，展示了SM2的基本用法，包括密钥生成、签名和验证，但请注意实际使用时你需要导入相应的库： ```java import org.bouncycastle.jce.provider.BouncyCastleProvider; import org.bouncycastle.util.encoders.Hex; public class SM2Example { static { Security.addProvider(new BouncyCastleProvider()); } // 导入SM2相关的密钥对 private static KeyPairGenerator keyGen = KeyPairGenerator.getInstance("SM2", "BC"); private static KeyPair keyPair; public static void main(String[] args) { try { // 生成密钥对 keyGen.initialize(2048); // 随机数长度，可以根据需要调整 keyPair = keyGen.generateKeyPair(); // 使用公钥进行签名 SecureRandom random = new SecureRandom(); byte[] message = "Hello, SM2!".getBytes(); Signature signature = Signature.getInstance("SM2withRSA", "BC"); signature.initSign(keyPair.getPrivate(), random); signature.update(message); byte[] signatureBytes = signature.sign(); // 使用公钥验证签名 signature.initVerify(keyPair.getPublic()); signature.update(message); boolean isVerified = signature.verify(signatureBytes); System.out.println("Signature verified: " + isVerified); // 也可以将密钥和签名转换为十六进制字符串展示 String privateKeyHex = Hex.toHexString(keyPair.getPrivate().getEncoded()); String publicKeyHex = Hex.toHexString(keyPair.getPublic().getEncoded()); String signatureHex = Hex.toHexString(signatureBytes); System.out.println("Private Key (hex): " + privateKeyHex); System.out.println("Public Key (hex): " + publicKeyHex); System.out.println("Signature (hex): " + signatureHex); } catch (Exception e) { e.printStackTrace(); } } } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值