SM2国密算法java应用，可以与c++端互相验签通过

已于 2023-04-06 18:04:23 修改
阅读量1.5k 收藏 7
点赞数 2
文章标签： java 算法 c++
于 2020-09-24 10:18:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42192467/article/details/108767810
版权

引入maven依赖

		<dependency>
			<groupId>org.bouncycastle</groupId>
			<artifactId>bcprov-jdk15on</artifactId>
			<version>1.60</version>
		</dependency>

		<dependency>
			<groupId>org.bouncycastle</groupId>
			<artifactId>bcpkix-jdk15on</artifactId>
			<version>1.60</version>
		</dependency>



import org.bouncycastle.asn1.ASN1EncodableVector;
import org.bouncycastle.asn1.ASN1Integer;
import org.bouncycastle.asn1.ASN1Sequence;
import org.bouncycastle.asn1.DERSequence;
import org.bouncycastle.asn1.gm.GMNamedCurves;
import org.bouncycastle.asn1.x9.X9ECParameters;
import org.bouncycastle.crypto.InvalidCipherTextException;
import org.bouncycastle.crypto.digests.SM3Digest;
import org.bouncycastle.crypto.engines.SM2Engine;

import org.bouncycastle.crypto.params.*;
import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPrivateKey;
import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPublicKey;
import org.bouncycastle.jcajce.spec.SM2ParameterSpec;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.jce.spec.ECParameterSpec;
import org.bouncycastle.jce.spec.ECPrivateKeySpec;
import org.bouncycastle.jce.spec.ECPublicKeySpec;
import org.bouncycastle.math.ec.ECCurve;
import org.bouncycastle.math.ec.ECPoint;
import org.bouncycastle.util.encoders.Hex;

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.io.*;
import java.math.BigInteger;
import java.security.*;
import java.security.cert.CertPathBuilderException;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import java.util.Arrays;

/**
 * need jars: bcpkix-jdk15on-160.jar bcprov-jdk15on-160.jar
 *
 * ref: https://tools.ietf.org/html/draft-shen-sm2-ecdsa-02
 * http://gmssl.org/docs/oid.html http://www.jonllen.com/jonllen/work/164.aspx
 *
 * 用BC的注意点：
 * 这个版本的BC对SM3withSM2的结果为asn1格式的r和s，如果需要直接拼接的r||s需要自己转换。下面rsAsn1ToPlainByteArray、rsPlainByteArrayToAsn1就在干这事。
 * 这个版本的BC对SM2的结果为C1||C2||C3，据说为旧标准，新标准为C1||C3||C2，用新标准的需要自己转换。下面changeC1C2C3ToC1C3C2、changeC1C3C2ToC1C2C3就在干这事。
 */
public class GmUtil {

	private static BigInteger p = new BigInteger(
			"FFFFFFFE" + "FFFFFFFF" + "FFFFFFFF" + "FFFFFFFF" + "FFFFFFFF" + "00000000" + "FFFFFFFF" + "FFFFFFFF", 16);
	private static BigInteger a = new BigInteger(
			"FFFFFFFE" + "FFFFFFFF" + "FFFFFFFF" + "FFFFFFFF" + "FFFFFFFF" + "00000000" + "FFFFFFFF" + "FFFFFFFC", 16);
	private static BigInteger b = new BigInteger(
			"28E9FA9E" + "9D9F5E34" + "4D5A9E4B" + "CF6509A7" + "F39789F5" + "15AB8F92" + "DDBCBD41" + "4D940E93", 16);
	private static X9ECParameters x9ECParameters = GMNamedCurves.getByName("sm2p256v1");
	private static ECDomainParameters ecDomainParameters = new ECDomainParameters(x9ECParameters.getCurve(),
			x9ECParameters.getG(), x9ECParameters.getN());
	private static ECParameterSpec ecParameterSpec = new ECParameterSpec(x9ECParameters.getCurve(),
			x9ECParameters.getG(), x9ECParameters.getN());
	@SuppressWarnings("deprecation")
	private static ECCurve.Fp curve = new ECCurve.Fp(p, a, b);
	static {
		if (Security.getProvider("BC") == null) {
			Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
		}
	}

	/**
	 *
	 * @param msg
	 * @param userId
	 * @param privateKey
	 * @return r||s，直接拼接byte数组的rs
	 */
	public static byte[] signSm3WithSm2(byte[] msg, byte[] userId, PrivateKey privateKey) {
		return rsAsn1ToPlainByteArray(signSm3WithSm2Asn1Rs(msg, userId, privateKey));
	}

	/**
	 *
	 * @param msg
	 * @param userId
	 * @param privateKey
	 * @return rs in <b>asn1 format</b>
	 */
	public static byte[] signSm3WithSm2Asn1Rs(byte[] msg, byte[] userId, PrivateKey privateKey) {
		try {
			SM2ParameterSpec parameterSpec = new SM2ParameterSpec(userId);
			Signature signer = Signature.getInstance("SM3withSM2", "BC");
			signer.setParameter(parameterSpec);
			signer.initSign(privateKey, new SecureRandom());
			signer.update(msg, 0, msg.length);
			byte[] sig = signer.sign();
			return sig;
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 *
	 * @param msg
	 * @param userId
	 * @param rs        r||s，直接拼接byte数组的rs
	 * @param publicKey
	 * @return
	 */
	public static boolean verifySm3WithSm2(byte[] msg, byte[] userId, byte[] rs, String publicKey) {
		ECPoint ecPoint = curve.decodePoint(Hex.decode(publicKey));
		ecPoint = ecPoint.normalize();
		BCECPublicKey bcecPublicKey = getPublickeyFromXY(ecPoint.getXCoord().toBigInteger(),ecPoint.getYCoord().toBigInteger());
		return verifySm3WithSm2Asn1Rs(msg, userId, rsPlainByteArrayToAsn1(rs), bcecPublicKey);
	}

	/**
	 *
	 * @param msg
	 * @param userId
	 * @param rs        in <b>asn1 format</b>
	 * @param publicKey
	 * @return
	 */
	public static boolean verifySm3WithSm2Asn1Rs(byte[] msg, byte[] userId, byte[] rs, PublicKey publicKey) {
		try {
			SM2ParameterSpec parameterSpec = new SM2ParameterSpec(userId);
			Signature verifier = Signature.getInstance("SM3withSM2", "BC");
			verifier.setParameter(parameterSpec);
			verifier.initVerify(publicKey);
			verifier.update(msg, 0, msg.length);
			return verifier.verify(rs);
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * bc加解密使用旧标c1||c2||c3，此方法在加密后调用，将结果转化为c1||c3||c2
	 * 
	 * @param c1c2c3
	 * @return
	 */
	private static byte[] changeC1C2C3ToC1C3C2(byte[] c1c2c3) {
		final int c1Len = (x9ECParameters.getCurve().getFieldSize() + 7) / 8 * 2 + 1; // sm2p256v1的这个固定65。可看GMNamedCurves、ECCurve代码。
		final int c3Len = 32; // new SM3Digest().getDigestSize();
		byte[] result = new byte[c1c2c3.length];
		System.arraycopy(c1c2c3, 0, result, 0, c1Len); // c1
		System.arraycopy(c1c2c3, c1c2c3.length - c3Len, result, c1Len, c3Len); // c3
		System.arraycopy(c1c2c3, c1Len, result, c1Len + c3Len, c1c2c3.length - c1Len - c3Len); // c2
		return result;
	}

	/**
	 * bc加解密使用旧标c1||c3||c2，此方法在解密前调用，将密文转化为c1||c2||c3再去解密
	 * 
	 * @param c1c3c2
	 * @return
	 */
	private static byte[] changeC1C3C2ToC1C2C3(byte[] c1c3c2) {
		final int c1Len = (x9ECParameters.getCurve().getFieldSize() + 7) / 8 * 2 + 1; // sm2p256v1的这个固定65。可看GMNamedCurves、ECCurve代码。
		final int c3Len = 32; // new SM3Digest().getDigestSize();
		byte[] result = new byte[c1c3c2.length];
		System.arraycopy(c1c3c2, 0, result, 0, c1Len); // c1: 0->65
		System.arraycopy(c1c3c2, c1Len + c3Len, result, c1Len, c1c3c2.length - c1Len - c3Len); // c2
		System.arraycopy(c1c3c2, c1Len, result, c1c3c2.length - c3Len, c3Len); // c3
		return result;
	}

	/**
	 * c1||c3||c2
	 * 
	 * @param data
	 * @param key
	 * @return
	 */
	public static byte[] sm2Decrypt(byte[] data, PrivateKey key) {
		return sm2DecryptOld(changeC1C3C2ToC1C2C3(data), key);
	}

	/**
	 * c1||c3||c2
	 * 
	 * @param data
	 * @param key
	 * @return
	 */

	public static byte[] sm2Encrypt(byte[] data, PublicKey key) {
		return changeC1C2C3ToC1C3C2(sm2EncryptOld(data, key));
	}

	/**
	 * c1||c2||c3
	 * 
	 * @param data
	 * @param key
	 * @return
	 */
	public static byte[] sm2EncryptOld(byte[] data, PublicKey key) {
		BCECPublicKey localECPublicKey = (BCECPublicKey) key;
		ECPublicKeyParameters ecPublicKeyParameters = new ECPublicKeyParameters(localECPublicKey.getQ(),
				ecDomainParameters);
		SM2Engine sm2Engine = new SM2Engine();
		sm2Engine.init(true, new ParametersWithRandom(ecPublicKeyParameters, new SecureRandom()));
		try {
			return sm2Engine.processBlock(data, 0, data.length);
		} catch (InvalidCipherTextException e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * c1||c2||c3
	 * 
	 * @param data
	 * @param key
	 * @return
	 */
	public static byte[] sm2DecryptOld(byte[] data, PrivateKey key) {
		BCECPrivateKey localECPrivateKey = (BCECPrivateKey) key;
		ECPrivateKeyParameters ecPrivateKeyParameters = new ECPrivateKeyParameters(localECPrivateKey.getD(),
				ecDomainParameters);
		SM2Engine sm2Engine = new SM2Engine();
		sm2Engine.init(false, ecPrivateKeyParameters);
		try {
			return sm2Engine.processBlock(data, 0, data.length);
		} catch (InvalidCipherTextException e) {
			throw new RuntimeException(e);
		}
	}

	public static byte[] sm4Encrypt(byte[] keyBytes, byte[] plain) {
		if (keyBytes.length != 16)
			throw new RuntimeException("err key length");
		if (plain.length % 16 != 0)
			throw new RuntimeException("err data length");

		try {
			Key key = new SecretKeySpec(keyBytes, "SM4");
			Cipher out = Cipher.getInstance("SM4/ECB/NoPadding", "BC");
			out.init(Cipher.ENCRYPT_MODE, key);
			return out.doFinal(plain);
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	public static byte[] sm4Decrypt(byte[] keyBytes, byte[] cipher) {
		if (keyBytes.length != 16)
			throw new RuntimeException("err key length");
		if (cipher.length % 16 != 0)
			throw new RuntimeException("err data length");

		try {
			Key key = new SecretKeySpec(keyBytes, "SM4");
			Cipher in = Cipher.getInstance("SM4/ECB/NoPadding", "BC");
			in.init(Cipher.DECRYPT_MODE, key);
			return in.doFinal(cipher);

		} catch (Exception e) {
			throw new RuntimeException(e);
		}

	}

	/**
	 * @param bytes
	 * @return
	 */
	public static byte[] sm3(byte[] bytes) {
		SM3Digest sm3 = new SM3Digest();
		sm3.update(bytes, 0, bytes.length);
		byte[] result = new byte[sm3.getDigestSize()];
		sm3.doFinal(result, 0);
		return result;
	}

	private final static int RS_LEN = 32;

	private static byte[] bigIntToFixexLengthBytes(BigInteger rOrS) {
		// for sm2p256v1, n is
		// 00fffffffeffffffffffffffffffffffff7203df6b21c6052b53bbf40939d54123,
		// r and s are the result of mod n, so they should be less than n and have
		// length<=32
		byte[] rs = rOrS.toByteArray();
		if (rs.length == RS_LEN)
			return rs;
		else if (rs.length == RS_LEN + 1 && rs[0] == 0)
			return Arrays.copyOfRange(rs, 1, RS_LEN + 1);
		else if (rs.length < RS_LEN) {
			byte[] result = new byte[RS_LEN];
			Arrays.fill(result, (byte) 0);
			System.arraycopy(rs, 0, result, RS_LEN - rs.length, rs.length);
			return result;
		} else {
			throw new RuntimeException("err rs: " + Hex.toHexString(rs));
		}
	}

	/**
	 * BC的SM3withSM2签名得到的结果的rs是asn1格式的，这个方法转化成直接拼接r||s
	 * 
	 * @param rsDer rs in asn1 format
	 * @return sign result in plain byte array
	 */
	private static byte[] rsAsn1ToPlainByteArray(byte[] rsDer) {
		ASN1Sequence seq = ASN1Sequence.getInstance(rsDer);
		byte[] r = bigIntToFixexLengthBytes(ASN1Integer.getInstance(seq.getObjectAt(0)).getValue());
		byte[] s = bigIntToFixexLengthBytes(ASN1Integer.getInstance(seq.getObjectAt(1)).getValue());
		byte[] result = new byte[RS_LEN * 2];
		System.arraycopy(r, 0, result, 0, r.length);
		System.arraycopy(s, 0, result, RS_LEN, s.length);
		return result;
	}

	/**
	 * BC的SM3withSM2验签需要的rs是asn1格式的，这个方法将直接拼接r||s的字节数组转化成asn1格式
	 * 
	 * @param sign in plain byte array
	 * @return rs result in asn1 format
	 */
	private static byte[] rsPlainByteArrayToAsn1(byte[] sign) {
		if (sign.length != RS_LEN * 2)
			throw new RuntimeException("err rs. ");
		BigInteger r = new BigInteger(1, Arrays.copyOfRange(sign, 0, RS_LEN));
		BigInteger s = new BigInteger(1, Arrays.copyOfRange(sign, RS_LEN, RS_LEN * 2));
		ASN1EncodableVector v = new ASN1EncodableVector();
		v.add(new ASN1Integer(r));
		v.add(new ASN1Integer(s));
		try {
			return new DERSequence(v).getEncoded("DER");
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
	}

	public static KeyPair generateKeyPair() {
		try {
			KeyPairGenerator kpGen = KeyPairGenerator.getInstance("EC", "BC");
			kpGen.initialize(ecParameterSpec, new SecureRandom());
			KeyPair kp = kpGen.generateKeyPair();
			return kp;
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	public static BCECPrivateKey getPrivatekeyFromD(BigInteger d) {
		ECPrivateKeySpec ecPrivateKeySpec = new ECPrivateKeySpec(d, ecParameterSpec);
		return new BCECPrivateKey("EC", ecPrivateKeySpec, BouncyCastleProvider.CONFIGURATION);
	}

	public static BCECPublicKey getPublickeyFromXY(BigInteger x, BigInteger y) {
		ECPublicKeySpec ecPublicKeySpec = new ECPublicKeySpec(x9ECParameters.getCurve().createPoint(x, y),
				ecParameterSpec);
		return new BCECPublicKey("EC", ecPublicKeySpec, BouncyCastleProvider.CONFIGURATION);
	}

	public static PublicKey getPublickeyFromX509File(File file) {
		try {
			CertificateFactory cf = CertificateFactory.getInstance("X.509", "BC");
			FileInputStream in = new FileInputStream(file);
			X509Certificate x509 = (X509Certificate) cf.generateCertificate(in);
//           System.out.println(x509.getSerialNumber());
			return x509.getPublicKey();
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	public static void main(String[] args)
			throws IOException, NoSuchAlgorithmException, NoSuchProviderException, InvalidAlgorithmParameterException,
			CertPathBuilderException, InvalidKeyException, SignatureException, CertificateException {

		// 生成公私钥对 ---------------------
//		KeyPair kp = generateKeyPair();
//
//       System.out.println(Hex.toHexString(kp.getPrivate().getEncoded()));
//       System.out.println(Hex.toHexString(kp.getPublic().getEncoded()));

//       System.out.println(kp.getPrivate().getAlgorithm());
//       System.out.println(kp.getPublic().getAlgorithm());

//       System.out.println(kp.getPrivate().getFormat());
//       System.out.println(kp.getPublic().getFormat());

//		System.out.println("private key d: " + ((BCECPrivateKey) kp.getPrivate()).getD().toString(16));
//		System.out.println("private key d: " + Hex.toHexString(((BCECPrivateKey) kp.getPrivate()).getD().toByteArray()));
//		System.out.println("public key q:" + Hex.toHexString(((BCECPublicKey) kp.getPublic()).getQ().getEncoded(true))); // {x,
																															// y,
																															// zs...}

//		byte[] msg = "1234567890".getBytes();
//		byte[] userId = "1234567890".getBytes();
//		String pri = ((BCECPrivateKey) kp.getPrivate()).getD().toString(16);
//		String pri = "a69587527f10addc2daf640c792157dddcc521b761ce47df96aa4bbe8a58bff1";
//		BigInteger d = new BigInteger(pri, 16);
//		BCECPrivateKey bcecPrivateKey = getPrivatekeyFromD(d);
//		byte[] sig = signSm3WithSm2(msg, userId, bcecPrivateKey);
//		System.out.println(Hex.toHexString(sig));
		
//		String pub = Hex.toHexString(((BCECPublicKey) kp.getPublic()).getQ().getEncoded(true));
//		String pub = "02bc72dddb2358dcf5f3066dc2fa8babcc6af07eaad9f76683809b7e73ee85aabf";
//		ECPoint ecPoint = curve.decodePoint(Hex.decode(pub));
//		ecPoint = ecPoint.normalize();
//		BCECPublicKey bcecPublicKey = getPublickeyFromXY(ecPoint.getXCoord().toBigInteger(),ecPoint.getYCoord().toBigInteger());
//		System.out.println(verifySm3WithSm2(msg, userId, sig, bcecPublicKey));
		
//       // 由d生成私钥 ---------------------
//       BigInteger d = new BigInteger("097b5230ef27c7df0fa768289d13ad4e8a96266f0fcb8de40d5942af4293a54a", 16);
//       BCECPrivateKey bcecPrivateKey = getPrivatekeyFromD(d);
//       System.out.println(bcecPrivateKey.getParameters());
//       System.out.println(Hex.toHexString(bcecPrivateKey.getEncoded()));
//       System.out.println(bcecPrivateKey.getAlgorithm());
//       System.out.println(bcecPrivateKey.getFormat());
//       System.out.println(bcecPrivateKey.getD());
//       System.out.println(bcecPrivateKey instanceof java.security.interfaces.ECPrivateKey);
//       System.out.println(bcecPrivateKey instanceof ECPrivateKey);
//       System.out.println(bcecPrivateKey.getParameters());

//       公钥X坐标PublicKeyXHex: 59cf9940ea0809a97b1cbffbb3e9d96d0fe842c1335418280bfc51dd4e08a5d4
//       公钥Y坐标PublicKeyYHex: 9a7f77c578644050e09a9adc4245d1e6eba97554bc8ffd4fe15a78f37f891ff8
//       PublicKey publicKey = getPublickeyFromX509File(new File("/Users/xxx/Downloads/xxxxx.cer"));
//       System.out.println(publicKey);
//       PublicKey publicKey1 = getPublickeyFromXY(new BigInteger("59cf9940ea0809a97b1cbffbb3e9d96d0fe842c1335418280bfc51dd4e08a5d4", 16), new BigInteger("9a7f77c578644050e09a9adc4245d1e6eba97554bc8ffd4fe15a78f37f891ff8", 16));
//       System.out.println(publicKey1);
//       System.out.println(publicKey.equals(publicKey1));
//       System.out.println(publicKey.getEncoded().equals(publicKey1.getEncoded()));
//

//       // sm2 encrypt and decrypt test ---------------------
//       KeyPair kp = generateKeyPair();
//       PublicKey publicKey2 = kp.getPublic();
//       PrivateKey privateKey2 = kp.getPrivate();
//       byte[]bs = sm2Encrypt("s".getBytes(), publicKey2);
//       System.out.println(Hex.toHexString(bs));
//       bs = sm2Decrypt(bs, privateKey2);
//       System.out.println(new String(bs));

//       // sm4 encrypt and decrypt test ---------------------
//       //0123456789abcdeffedcba9876543210 + 0123456789abcdeffedcba9876543210 -> 681edf34d206965e86b3e94f536e4246
//       byte[] plain = Hex.decode("0123456789abcdeffedcba98765432100123456789abcdeffedcba98765432100123456789abcdeffedcba9876543210");
//       byte[] key = Hex.decode("0123456789abcdeffedcba9876543210");
//       byte[] cipher = Hex.decode("595298c7c6fd271f0402f804c33d3f66");
//       byte[] bs = sm4Encrypt(key, plain);
//       System.out.println(Hex.toHexString(bs));;
//       bs = sm4Decrypt(key, bs);
//       System.out.println(Hex.toHexString(bs));
	}
}


public class S2KeyPair {

	private final String publicKey;
	private final String privateKey;

	public S2KeyPair(String publicKey, String privateKey) {
		this.publicKey = publicKey;
		this.privateKey = privateKey;
	}

	public String getPublicKey() {
		return publicKey;
	}

	public String getPrivateKey() {
		return privateKey;
	}
}

import java.math.BigInteger;
import java.security.KeyPair;

import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPrivateKey;
import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPublicKey;
import org.bouncycastle.util.encoders.Hex;

public class SM2Utils {
	
	private static String userId = "123456";

	//获取密钥对
	public static S2KeyPair createKey() {
		KeyPair keyPair = GmUtil.generateKeyPair();
		String privateKey = ((BCECPrivateKey) keyPair.getPrivate()).getD().toString(16);
		System.out.println("私钥"+privateKey);
		String publicKey = Hex.toHexString(((BCECPublicKey) keyPair.getPublic()).getQ().getEncoded(true));
		System.out.println("公钥" + publicKey);
		return new S2KeyPair(publicKey, privateKey);
	}
	//签名
	public static String signSm3WithSm2(String msg, String privateKey) {
		BigInteger d = new BigInteger(privateKey, 16);
		BCECPrivateKey bcecPrivateKey = GmUtil.getPrivatekeyFromD(d);
		byte[] sig = GmUtil.signSm3WithSm2(msg.getBytes(), userId.getBytes(), bcecPrivateKey);
		String hexString = Hex.toHexString(sig);
		System.out.println("签名值"+hexString);
		return hexString;
	}
	//验签
	public static boolean verifySm3WithSm2(String msg, String sig, String publicKey) {
		boolean verify = GmUtil.verifySm3WithSm2(msg.getBytes(), userId.getBytes(), sig.getBytes(), publicKey);
		System.out.println("验签结果"+verify);
		return verify;
	}

}
一小昊
关注
  • 2
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C/C++ SM2算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-07 6071
其中，数字签名采用椭圆曲线数字签名算法（ECDSA），密钥交换采用椭圆曲线Diffie-Hellman（ECDH）算法，公钥加密采用椭圆曲线公钥加密算法（ECIES）。虽然SM2算法在安全性、效率和灵活性方面都有显著优势，但作为一种较新的密码算法，其在实际应用过程中可能还存在一些潜在的问题和挑战。SM2算法使用素数域上的椭圆曲线方程y^2 = x^3 + ax + b (mod p)，其中a和b是椭圆曲线的系数，p是一个大素数。在实际使用中，需要选择合适的a、b和p值，以满足安全性和效率的要求。
Java SM2 国密算法（最权威）！
最新发布
12-18
二、SM2算法的应用场景 SM2算法作为一种公钥密码算法，可广泛应用于各种场景，如： 1. 数据加密：SM2算法可用于加密和解密数据，保障数据传输的安全性。 2. 数字签名：SM2算法可用于生成数字签名，验证文档或数据...
python国密算法SM2 + 加解密及签名验签 + 可与java交互
07-05
用于python与java之间，使用国密算法SM2加解密及签名验签
Java实现国密电子签章(itext+bouncycastle +sm3withsm2)
Hanko的专栏
12-29 1万+
电子签名、电子签章已经不是个陌生的东西了。在java领域使用itextpdf可以完成pdf的电子签名。当然最终是以pkcs7的格式存储在pdf文件中。类似 我们知道pkcs7是RSA体系中的，属于国际标准。我们国家的国密标准也早就出台了，那是否能实现国密的数字签名呢？答案是肯定的可以。 方案一、 itextpdf+修改源代码+bouncycastle MakeSignature.signDetached(appearance, digest, pks, chain, c...
国密sm2 sm3 sm4 c++
sun007700的专栏
08-08 2292
国密
java加密使用
Echo的博客
10-10 1611
加密和解密使用相同的秘钥,常见算法有DES、TDES、AES、SM4、RC2/4 加密和解密使用不同的秘钥,公钥加密私钥解密，私钥加密公钥解密。常见算法有RSA、SM2、ECC类似于hash，不可逆。常见的信息摘要算法有：MD2/4/5、SHA1/SHA224/SHA256/SHA384、SM3算法、MAC算法等 【数字签名】主要解决了两个核心问题：发送的消息是完整的，未被篡改的；接收的消息一定就是对应发送者发送的，别人无法仿制。前者体现的是数据的完整性，后者体现的是数据的不可抵赖性数字签名的应用公式如下所
SM2 SM3 SM4加密java实现
11-01 2万+
原文地址：https://blog.csdn.net/ererfei/article/details/50998162   【摘要】 本文主要讲解“国密加密算法”SM系列的Java实现方法，不涉及具体的算法剖析，在网络上找到的java实现方法比较少，切在跨语言加密解密上会存在一些问题，所以整理此文志之。 源码下载地址http://download.csdn.net/detail/ererf...
JAVA SM2 数字证书生成
q1009020096的博客
12-21 9645
文章目录Before StartBuild with MavenQuickStart生成自签名公私钥对证书签名算法算法提供者设置证书信息标识信息构造（DN）获取扩展密钥用途构造（可选）证书信息构造X.509格式证书对象生成保存证书ASN.1 结构解析工具致谢 Before Start X.509数字证书请参考： RFC5280 Internet X.509 Public Key Infrastru...
java 国密算法sm2、sm3
热门推荐
那些年我们踩过的坑
01-07 3万+
国密即国家密码局认定的国产密码算法。主要有SM1，SM2，SM3，SM4。密钥长度和分组长度均为128位。 SM1 为对称加密。其加密强度与AES相当。该算法不公开，调用该算法时，需要通过加密芯片的接口进行调用。 SM2为非对称加密，基于ECC。该算法已公开。由于该算法基于ECC，故其签名速度与秘钥生成速度都快于RSA。ECC 256位（SM2采用的就是ECC 256位的一种）安全强度比RSA...
SM2加解密、签名验签
qq_42873640的博客
08-11 1万+
加密流程。
国密算法学习笔记
yjkhtddx的专栏
04-20 1474
国密算法是由中国密码学专家自主设计并发布的一系列密码算法，它们包括SM1、SM2、SM3、SM4等。SM1是一种对称加密算法，采用128位密钥长度，支持分组长度为64位或者128位，具有较高的安全性和性能。SM2是一种非对称加密算法，基于椭圆曲线密码体制，具有与RSA算法相当的安全性，同时具有更高的运算速度和更短的密钥长度。SM2算法主要用于数字签名、密钥交换、加密和解密等方面的应用。SM3是一种密码杂凑算法，用于实现消息摘要的功能，具有较高的安全性和性能。
基于 gmssl实现的sm2加密（C++）(改进版）
canlynetsky的博客
06-15 2189
此文章基于https://blog.csdn.net/hacker_lpy/article/details/124211114提供的方法，经过测试修正代码后，与https://the-x.cn/zh-cn/cryptography/Sm2.aspx提供的工具的加密解密数据一致。将上述三个文件替换掉该项目中的相应文件，make即可得到libgmutil.so和test文件。1、修正SM2加密解密使用C1C3C2的顺序（手动调整的）。2、修正SM2结果不正确的问题。
国密SM2-签名与验签算法(JAVA)
10-10
功能：签名与验签，已完成封装，并亲测有效，能达到开箱即用的效果
SM2&SM3&SM4国密算法java源码.rar_sms4 java_国密_国密SM2_国密算法 java_国密算法源码
09-21
SM2&SM3&SM4国密算法java源码
sm2国密算法加解密、签名、验签QT工具源码（包含sm2,sm3和sm4源代码）
04-23
sm2国密算法加解密，签名、验签QT工具的源代码（包含sm2,sm3和sm4源码）。 环境我使用的QT5.14的IDE编译，其他版本qt未测试。不过仅使用了几个简单控件应该关系不大。 详细介绍参见个人博客：SM2 (含SM3、SM4)国密...
腾讯国密套件KonaCrypto使用（SM2加密）
Soncat2000的博客
05-22 3222
腾讯Kona Crypto是一个Java安全Provider实现，其Provider名称为KonaCrypto。它遵循相关的国家标准实现了如下的国密基础算法：GB/T 32918.1-2016 第1部分：总则GB/T 32918.2-2016 第2部分：数字签名GB/T32918.3-2016 第3部分：密钥交换协议GB/T 32918.4-2016 第4部分：公钥加密算法GB/T 32918.5-2017 第5部分：参数定义GB/T 32905-2016 SM3密码杂凑算法。
国密：生成SM2秘钥、加解密及加验签
Su7148的博客
11-16 2万+
简述国密SM2的公私钥生成以及加签验签。
图解SM2算法流程——第2章 签名验签
ayang1986的专栏
12-11 7163
转载自：https://blog.csdn.net/samsho2/article/details/80770862 A.2 第2部分——数字签名算法 A.2.1 签名（User A） l  签名者用户A的密钥对包括其私钥dA和公钥PA=[dA]G= (xA,yA) l  签名者用户A具有长度为entlenA比特的可辨别标识IDA， l  ENTLA是由整数entlenA转换而成的两个字节 ...
国密算法SM2签名、SM2验证签名示例（二）
07-01 5328
国密算法SM2签名、SM2验证签名示例（二）;SM2模式与ASN1区别在于签名值长度不一样。
sm2国密算法 单片机
12-02
SM2国密算法是我国自主研发的一种非对称加密算法，适用于安全通信、数据加密等场景。它具有安全性高、性能优越、抗攻击能力强的特点，因此在单片机等资源受限的环境中也能够很好地发挥作用。 在单片机中使用SM2国密算法可以实现对数据进行安全加密和解密操作，保护数据的机密性和完整性。由于单片机资源有限，因此SM2算法在设计时需要考虑到算法的执行效率和内存占用情况，以确保在单片机中能够高效地运行。 单片机作为嵌入式系统的核心部件，广泛应用于智能家居、工业控制、汽车电子等领域。在这些领域中，数据的安全性至关重要，因此SM2国密算法正好满足了单片机在这些应用场景中对数据安全的需求。 另外，SM2国密算法还可以与硬件加速引擎相结合，进一步提高在单片机中的运行效率。通过将算法部分操作转移到硬件中进行处理，可以减轻单片机的负担，提高加密解密效率，同时也能够在一定程度上提高系统的抗攻击能力。 因此，SM2国密算法在单片机中的应用具有重要意义，能够为嵌入式系统提供可靠的数据安全保障，并且在资源受限的环境中依然能够保持较高的性能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值