国密算法标准

合集下载

国密通讯方案

国密通讯方案1. 引言在信息时代，网络通信的安全性一直是一个非常重要的议题。

随着信息技术的迅猛发展，传统的加密算法逐渐暴露出安全性不足的问题。

为了应对这个问题，中国自主研发了一套密码算法集合，即国家密码管理局（Commercial Cryptography Bureau）所发布的国密算法。

国密算法是中国国家密码管理局所发布的一套密码算法标准，采用这一标准的通信方案能够提供更高的安全性。

本文将介绍国密通讯方案的背景、基本原理以及应用场景。

2. 背景随着互联网的快速发展，人们日常的通信方式也越来越多样化。

然而，通信网络的数据安全性始终是一个亟待解决的问题。

在以往的通信方案中，采用的是国际上通行的加密算法，如RSA、AES等。

然而，这些算法在一些特定的场景下存在着风险，因为这些算法并非中国自主研发，无法确保其安全性。

于是，中国国家密码管理局自主研发了一套密码算法集合，即国密算法。

该算法集合包括了SM1、SM2、SM3和SM4等算法。

3. 基本原理3.1 SM1算法SM1算法是对称加密算法，也是国家密码局的第一套密码标准。

它采用分组加密的方式，对明文进行加密后得到密文。

SM1算法的优势在于其高度的安全性和优良的性能。

3.2 SM2算法SM2算法是非对称加密算法，是国家密码局的第二套密码标准。

它基于椭圆曲线密码学，提供了一种安全高效的数字签名算法。

SM2算法具有密码强度高、计算量小、使用灵活等特点。

3.3 SM3算法SM3算法是哈希算法，也是国家密码局的第三套密码标准。

它可用于数据的完整性校验和数字签名等应用。

SM3算法具有较高的安全强度和较快的计算速度。

3.4 SM4算法SM4算法是对称分组密码算法，是国家密码局的第四套密码标准。

它采用密钥长度为128位的分组密码算法，具有优秀的安全性和高效的性能。

SM4算法适用于各种加密算法和协议的实现。

4. 应用场景国密通讯方案适用于各种场景，包括但不限于以下几个方面：•互联网金融：在互联网金融领域，用户的交易数据需要得到严格的保护。

SpringBoot中_JAVA利用国密算法_实现内容的加密_解密

首先来看一下什么是国密算法:国密即国家密码局认定的国产密码算法，即商用密码。

国密主要有SM1，SM2，SM3，SM4。

密钥长度和分组长度均为128位。

1、SM1 为对称加密。

其加密强度与AES(高级加密标准,Advanced Encryption Standard)相当。

该算法不公开，调用该算法时，需要通过加密芯片的接口进行调用。

2、SM2为非对称加密，基于ECC。

该算法已公开。

由于该算法基于ECC，故其签名速度与秘钥生成速度都快于RSA。

ECC 256位（SM2采用的就是ECC 256位的一种）安全强度比RSA 2048位高，但运算速度快于RSA。

3、SM3为消息摘要。

可以用MD5作为对比理解。

该算法已公开。

校验结果为256位。

4、SM4为无线局域网标准的分组数据算法。

对称加密，密钥长度和分组长度均为128位。

由于SM1、SM4加解密的分组大小为128bit，故对消息进行加解密时，若消息长度过长，需要进行分组，要消息长度不足，则要进行填充。

在很多地方还是会用到的,这里说一下这个:SM21.在pom.xml中引入依赖jar包:<dependency><groupId>org.bouncycastle</groupId><artifactId>bcprov-jdk15on</artifactId><version>1.58</version></dependency>2.然后来写一个工具类,用来生成国密的,公钥和私钥这个密码对.import org.bouncycastle.jce.provider.BouncyCastleProvider;import java.security.*;import java.security.spec.ECGenParameterSpec;import java.security.spec.PKCS8EncodedKeySpec;import java.security.spec.X509EncodedKeySpec;import java.util.Base64;/*** @author hulala* @Description 国密公私钥对工具类public class KeyUtils {/*** 生成国密公私钥对** @return* @throws Exception*/public static String[] generateSmKey() throws Exception {KeyPairGenerator keyPairGenerator = null;SecureRandom secureRandom = new SecureRandom();ECGenParameterSpec sm2Spec = new ECGenParameterSpec("sm2p256v1");keyPairGenerator = KeyPairGenerator.getInstance("EC", new BouncyCastleProvider());keyPairGenerator.initialize(sm2Spec);keyPairGenerator.initialize(sm2Spec, secureRandom);KeyPair keyPair = keyPairGenerator.generateKeyPair();PrivateKey privateKey = keyPair.getPrivate();PublicKey publicKey = keyPair.getPublic();//String[0] 公钥//String[1] 私钥String[] result = {new String(Base64.getEncoder().encode(publicKey.getEncoded())), new String(Base64.getEncoder().encode(privateKey.getEncoded())) };return result;}/*** 将Base64转码的公钥串，转化为公钥对象** @param publicKey* @return*/public static PublicKey createPublicKey(String publicKey) {PublicKey publickey = null;try {X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(Base64.getDecoder().decode(publicKey));KeyFactory keyFactory = KeyFactory.getInstance("EC", new BouncyCastleProvider());publickey = keyFactory.generatePublic(publicKeySpec);} catch (Exception e) {e.printStackTrace();}return publickey;}/*** 将Base64转码的私钥串，转化为私钥对象** @param privateKey* @return*/public static PrivateKey createPrivateKey(String privateKey) {PrivateKey publickey = null;try {PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(Base64.getDecoder().decode(privateKey));KeyFactory keyFactory = KeyFactory.getInstance("EC", new BouncyCastleProvider());publickey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);} catch (Exception e) {e.printStackTrace();}return publickey;}}3.根据公钥和私钥工具类,生成的密钥对,对数据,进行加密和解密操作import org.bouncycastle.asn1.gm.GMObjectIdentifiers;import org.bouncycastle.crypto.InvalidCipherTextException;import org.bouncycastle.crypto.engines.SM2Engine;import org.bouncycastle.crypto.params.ECDomainParameters;import org.bouncycastle.crypto.params.ECPrivateKeyParameters;import org.bouncycastle.crypto.params.ECPublicKeyParameters;import org.bouncycastle.crypto.params.ParametersWithRandom;import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPrivateKey;import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPublicKey;import org.bouncycastle.jce.provider.BouncyCastleProvider;import org.bouncycastle.jce.spec.ECParameterSpec;import java.security.*;/*** @author hulala* @Description SM2实现工具类*/public class Sm2Util {static {Security.addProvider(new BouncyCastleProvider());}/*** 根据publicKey对原始数据data，使用SM2加密** @param data* @param publicKey* @return*/public static byte[] encrypt(byte[] data, PublicKey publicKey) {ECPublicKeyParameters localECPublicKeyParameters = null;if (publicKey instanceof BCECPublicKey) {BCECPublicKey localECPublicKey = (BCECPublicKey) publicKey;ECParameterSpec localECParameterSpec = localECPublicKey.getParameters();ECDomainParameters localECDomainParameters = new ECDomainParameters(localECParameterSpec.getCurve(),localECParameterSpec.getG(), localECParameterSpec.getN());localECPublicKeyParameters = new ECPublicKeyParameters(localECPublicKey.getQ(), localECDomainParameters);}SM2Engine localSM2Engine = new SM2Engine();localSM2Engine.init(true, new ParametersWithRandom(localECPublicKeyParameters, new SecureRandom()));byte[] arrayOfByte2;try {arrayOfByte2 = localSM2Engine.processBlock(data, 0, data.length);return arrayOfByte2;} catch (InvalidCipherTextException e) {e.printStackTrace();return null;}}/*** 根据privateKey对加密数据encodedata，使用SM2解密** @param encodedata* @param privateKey* @return*/public static byte[] decrypt(byte[] encodedata, PrivateKey privateKey) {SM2Engine localSM2Engine = new SM2Engine();BCECPrivateKey sm2PriK = (BCECPrivateKey) privateKey;ECParameterSpec localECParameterSpec = sm2PriK.getParameters();ECDomainParameters localECDomainParameters = new ECDomainParameters(localECParameterSpec.getCurve(),localECParameterSpec.getG(), localECParameterSpec.getN());ECPrivateKeyParameters localECPrivateKeyParameters = new ECPrivateKeyParameters(sm2PriK.getD(),localECDomainParameters);localSM2Engine.init(false, localECPrivateKeyParameters);try {byte[] arrayOfByte3 = localSM2Engine.processBlock(encodedata, 0, encodedata.length);return arrayOfByte3;} catch (InvalidCipherTextException e) {e.printStackTrace();return null;}}/*** 私钥签名** @param data* @param privateKey* @return* @throws Exception*/public static byte[] signByPrivateKey(byte[] data, PrivateKey privateKey) throws Exception { Signature sig = Signature.getInstance(GMObjectIdentifiers.sm2sign_with_sm3.toString(), BouncyCastleProvider.PROVIDER_NAME);sig.initSign(privateKey);sig.update(data);byte[] ret = sig.sign();return ret;}/*** 公钥验签** @param data* @param publicKey* @param signature* @return* @throws Exception*/public static boolean verifyByPublicKey(byte[] data, PublicKey publicKey, byte[] signature) throws Exception {Signature sig = Signature.getInstance(GMObjectIdentifiers.sm2sign_with_sm3.toString(), BouncyCastleProvider.PROVIDER_NAME);sig.initVerify(publicKey);sig.update(data);boolean ret = sig.verify(signature);return ret;}}4.来测试一下,对数据进行加密解密import org.junit.Test;import java.util.Base64;/*** @author hulala* @Description Sm2Util 的测试类*/public class Sm2UtilTest {private String testStr = "wangjing";java.security.PublicKey publicKey = null;java.security.PrivateKey privateKey = null;@Testpublic void test() throws Exception {//生成公私钥对String[] keys = KeyUtils.generateSmKey();System.out.println("原始字符串：" + testStr);System.out.println("公钥：" + keys[0]);publicKey = KeyUtils.createPublicKey(keys[0]);System.out.println("私钥：" + keys[1]);privateKey = KeyUtils.createPrivateKey(keys[1]);System.out.println("");byte[] encrypt = Sm2Util.encrypt(testStr.getBytes(), publicKey);String encryptBase64Str = Base64.getEncoder().encodeToString(encrypt);System.out.println("加密数据：" + encryptBase64Str);byte[] decode = Base64.getDecoder().decode(encryptBase64Str);byte[] decrypt = Sm2Util.decrypt(decode, privateKey);System.out.println("解密数据：" + new String(decrypt));byte[] sign = Sm2Util.signByPrivateKey(testStr.getBytes(), privateKey);System.out.println("数据签名：" + Base64.getEncoder().encodeToString(sign));boolean b = Sm2Util.verifyByPublicKey(testStr.getBytes(), publicKey, sign);System.out.println("数据验签：" + b);}}5.这样就实现了利用国密,SM2进行加密解密了.。

国产商用密码算法及其相关标准介绍

标准咨询国产商用密码算法及其相关标准介绍谢宗晓（中国金融认证中心）董坤祥（山东财经大学管理科学与工程学院）甄杰（重庆工商大学管理科学与工程学院）1　概述《中华人民共和国密码法》第六条中规定：密码分为核心密码、普通密码和商用密码。

同时，在第七条和第八条中规定：核心密码、普通密码属于国家秘密，商用密码用于保护不属于国家秘密的信息。

因此，在常见应用中，商用密码得到了大面积的推广，以至于，在实践中，提到“国密”，经常就被默认为国产商用密码算法。

在现代密码系统中，密码算法、密码协议和密钥管理是三个不可或缺的部分，而在这三者之中，最为核心的毫无疑问就是密码算法。

虽然实践证明，绝大部分的安全漏洞都产生于实现和部署过程中，但是，算法的安全与否，直接决定了一个密码系统的基础是否安全。

例如，选用SHA-1、MD4、MD5、RC4和密钥长度小于2048位的RSA 等不安全的算法，不可能实现安全的密码系统。

已经发布的国产商用密码算法，按照类别可以分为：1）对称密码算法，主要包括ZUC 和SM4；2）非对称密码算法，主要包括SM2和SM9；3）密码杂凑算法，主要包括SM3。

2　对称密码算法对称密码（symmetric cryptography）是用相同的密钥（或方法）进行加密解密，这在逻辑上非常清晰，也最直观，有时候也被称之为共享密钥密码，对称密码算法的基本过程如图1所示。

1）　注意，RC4算法已经证明不安全。

图1　对称密码的工作过程已经发布国产商用密码算法中属于对称密码算法的有ZUC 和SM4。

ZUC（祖冲之密码算法）属于序列密码，也称为“流密码”，与之类似的国外密码算法如RC41）。

ZUC 对应的国家标准、行业标准，如表1所示。

SM4属于分组密码，也称为“块密码”，与之类似的国外密码算法如DES（数据加密标准），TDEA/3DES（三重数据加密标准）以及AES（高级加密标准）等。

SM4对应的国家标准、行业标准，如表2所示。

国密杂凑算法SM3

国密杂凑算法SM30. 引⾔SM3杂凑算法是中国国家密码局公布的hash算法商⽤标准，能应⽤于数字签名与验证、消息认证码的⽣成以及伪随机数的⽣成。

1. 常数与函数1.1 初始值IV = 7380166f 4914b2b9 172442d7 da8a0600 a96f30bc 163138aa e38dee4d b0fb0e4e1.2 常量T j={ 79cc4519 0≤j≤15；7a879d8a 16≤j≤63}1.3 布尔函数FF j(X,Y,Z)={X^Y^Z 0≤j≤15；(X & Y)|(X&Z)|(Y&Z) 16≤j≤63}GG j(X,Y,Z)={X^Y^Z 0≤j≤15；（X & Y）|（~X&Z）16≤j≤63}X，Y，Z为字（32bit）1.4 置换函数P0（X）= X^(X<<<9)^（X<<<17)P1（X）= X^(X<<<15)^（X<<<23)X 为字2. 算法简介SM3算法能够对长度为l(l<2^64)bit的消息m，进⾏填充和迭代压缩，⽣成杂凑值，最终的杂凑值为256bit。

2.1 填充过程设消息m的长度为l bit，⾸先将bit"1"添加到消息末尾，再加k个“0”，k是满⾜l+1+k =448 mod 512的最⼩⾮负整数。

然后再添加⼀个64bit串，该串是l的⼆进制表⽰，填充后的消息m'长度为512的整数倍。

2.2 迭代压缩迭代过程:m'按照512bit进⾏分组：m'=B(0)B(1)...B(n-1)n=(l+k+65)/512.迭代过程如下：FOR i=0 to n-1 V(i+1) = CF(V(i),B(i)ENDFORCF为压缩函数，V(0)为初始值IV，迭代压缩的结果为V(n)消息扩展：消息分组B(i)扩展⽣成132个字W0，W1，...W67,W0',W1'...W63'。

SM系列国密算法

SM系列国密算法SM系列国密算法众所周知，为了保障商⽤密码的安全性，国家商⽤密码管理办公室制定了⼀系列密码标准，包括SM1（SCB2）、SM2、SM3、SM4、SM7、SM9、祖冲之密码算法（ZUC)那等等。

其中SM1、SM4、SM7、祖冲之密码（ZUC）是对称算法；SM2、SM9是⾮对称算法；SM3是哈希算法。

⽬前，这些算法已⼴泛应⽤于各个领域中，期待有⼀天会有采⽤国密算法的区块链应⽤出现。

其中SM1、SM7算法不公开，调⽤该算法时，需要通过加密芯⽚的接⼝进⾏调⽤；⽐较少⼈了解这些算法，在这⾥对这些国密算法做简单的科普1 SM1对称密码SM1 算法是分组密码算法，分组长度为128位，密钥长度都为 128 ⽐特，算法安全保密强度及相关软硬件实现性能与 AES 相当，算法不公开，仅以IP核的形式存在于芯⽚中。

采⽤该算法已经研制了系列芯⽚、智能IC卡、智能密码钥匙、加密卡、加密机等安全产品，⼴泛应⽤于电⼦政务、电⼦商务及国民经济的各个应⽤领域（包括国家政务通、警务通等重要领域）。

2 SM2椭圆曲线公钥密码算法SM2算法就是ECC椭圆曲线密码机制，但在签名、密钥交换⽅⾯不同于ECDSA、ECDH等国际标准，⽽是采取了更为安全的机制。

另外，SM2推荐了⼀条256位的曲线作为标准曲线。

SM2标准包括总则，数字签名算法，密钥交换协议，公钥加密算法四个部分，并在每个部分的附录详细说明了实现的相关细节及⽰例。

SM2算法主要考虑素域Fp和F2m上的椭圆曲线，分别介绍了这两类域的表⽰，运算，以及域上的椭圆曲线的点的表⽰，运算和多倍点计算算法。

然后介绍了编程语⾔中的数据转换，包括整数和字节串，字节串和⽐特串，域元素和⽐特串，域元素和整数，点和字节串之间的数据转换规则。

详细说明了有限域上椭圆曲线的参数⽣成以及验证，椭圆曲线的参数包括有限域的选取，椭圆曲线⽅程参数，椭圆曲线群基点的选取等，并给出了选取的标准以便于验证。

最后给椭圆曲线上密钥对的⽣成以及公钥的验证，⽤户的密钥对为（s，sP），其中s为⽤户的私钥，sP为⽤户的公钥，由于离散对数问题从sP难以得到s，并针对素域和⼆元扩域给出了密钥对⽣成细节和验证⽅式。

国密算法Java代码的标准实现

国密算法Java代码的标准实现前⼀阵⼦做的项⽬，越来越多的⾦融类应⽤使⽤国密算法进⾏加解密的运算。

国密即国家密码局认定的国产密码算法。

主要有SM1，SM2，SM3，SM4。

密钥长度和分组长度均为128位。

SM1 为对称加密。

其加密强度与AES相当。

该算法不公开，调⽤该算法时，需要通过加密芯⽚的接⼝进⾏调⽤。

SM2为⾮对称加密，基于ECC。

该算法已公开。

由于该算法基于ECC，故其签名速度与秘钥⽣成速度都快于RSA。

ECC 256位（SM2采⽤的就是ECC 256位的⼀种）安全强度⽐RSA 2048位⾼，但运算速度快于RSA。

SM3 消息摘要。

可以⽤MD5作为对⽐理解。

该算法已公开。

校验结果为256位。

SM4 ⽆线局域⽹标准的分组数据算法。

对称加密，密钥长度和分组长度均为128位。

由于SM1、SM4加解密的分组⼤⼩为128bit，故对消息进⾏加解密时，若消息长度过长，需要进⾏分组，要消息长度不⾜，则要进⾏填充。

JAVA代码：Util:import javax.crypto.SecretKey;2 import javax.crypto.SecretKeyFactory;3 import javax.crypto.spec.PBEKeySpec;4 import javax.crypto.spec.SecretKeySpec;5 import java.math.BigInteger;6 import java.security.NoSuchAlgorithmException;7 import java.security.SecureRandom;8 import java.security.spec.InvalidKeySpecException;9 import java.security.spec.KeySpec;1011 public class Util {12 public static final byte MAX_VALUE = -1;13 public static byte[] hexToByte(String arg8) {14 if(arg8.length() % 2 == 0) {15 char[] v0 = arg8.toCharArray();16 byte[] v1 = new byte[arg8.length() / 2];17 int v2 = 0;18 int v3 = 0;19 int v4 = arg8.length();20 while(v2 < v4) {21 StringBuilder v5 = new StringBuilder();22 v5.append("");23 int v6 = v2 + 1;24 v5.append(v0[v2]);25 v5.append(v0[v6]);26 v1[v3] = new Integer(Integer.parseInt(v5.toString(), 16) & 255).byteValue();27 v2 = v6 + 1;28 ++v3;29 }3031 return v1;32 }33 throw new IllegalArgumentException();34 }35 public static String byteToHex(byte[] arg5) {36 if(arg5 != null) {37 String v0 = "";38 int v2;39 for(v2 = 0; v2 < arg5.length; ++v2) {40 String v1 = Integer.toHexString(arg5[v2] & 255);41 v0 = v1.length() == 1 ? v0 + "0" + v1 : v0 + v1;42 }4344 return v0.toUpperCase();45 }46 throw new IllegalArgumentException("Argument b ( byte array ) is null! ");47 }4849 public static byte[] byteConvert32Bytes(BigInteger arg5) {50 byte[] v0 = null;51 if(arg5 == null) {52 return v0;53 }5455 int v4 = 32;56 if(arg5.toByteArray().length == 33) {57 v0 = new byte[v4];58 System.arraycopy(arg5.toByteArray(), 1, v0, 0, v4);59 }60 else if(arg5.toByteArray().length == v4) {61 v0 = arg5.toByteArray();62 }63 else {64 v0 = new byte[v4];65 int v1;66 for(v1 = 0; v1 < 32 - arg5.toByteArray().length; ++v1) {67 v0[v1] = 0;68 }6970 System.arraycopy(arg5.toByteArray(), 0, v0, v4 - arg5.toByteArray().length, arg5.toByteArray().length);71 }7273 return v0;74 }7576 public static byte[] hexStringToBytes(String arg7) {77 if(arg7 != null) {78 if(arg7.equals("")) {79 }80 else {81 arg7 = arg7.toUpperCase();82 int v0 = arg7.length() / 2;83 char[] v1 = arg7.toCharArray();84 byte[] v2 = new byte[v0];85 int v3;86 for(v3 = 0; v3 < v0; ++v3) {87 int v4 = v3 * 2;88 v2[v3] = ((byte)(Util.charToByte(v1[v4]) << 4 | Util.charToByte(v1[v4 + 1])));89 }9091 return v2;92 }93 }9495 return null;96 }9798 public static byte charToByte(char arg1) {99 return ((byte)"0123456789ABCDEF".indexOf(arg1));100 }101102 }1 import javax.crypto.SecretKey;2 import javax.crypto.SecretKeyFactory;3 import javax.crypto.spec.PBEKeySpec;4 import javax.crypto.spec.SecretKeySpec;5 import java.math.BigInteger;6 import java.security.NoSuchAlgorithmException;7 import java.security.SecureRandom;8 import java.security.spec.InvalidKeySpecException;9 import java.security.spec.KeySpec;1011 public class Util {12 public static final byte MAX_VALUE = -1;13 public static byte[] hexToByte(String arg8) {14 if(arg8.length() % 2 == 0) {15 char[] v0 = arg8.toCharArray();16 byte[] v1 = new byte[arg8.length() / 2];17 int v2 = 0;18 int v3 = 0;19 int v4 = arg8.length();20 while(v2 < v4) {21 StringBuilder v5 = new StringBuilder();22 v5.append("");23 int v6 = v2 + 1;24 v5.append(v0[v2]);25 v5.append(v0[v6]);26 v1[v3] = new Integer(Integer.parseInt(v5.toString(), 16) & 255).byteValue();27 v2 = v6 + 1;28 ++v3;29 }3031 return v1;32 }33 throw new IllegalArgumentException();34 }35 public static String byteToHex(byte[] arg5) {36 if(arg5 != null) {37 String v0 = "";38 int v2;39 for(v2 = 0; v2 < arg5.length; ++v2) {40 String v1 = Integer.toHexString(arg5[v2] & 255);41 v0 = v1.length() == 1 ? v0 + "0" + v1 : v0 + v1;42 }4344 return v0.toUpperCase();45 }46 throw new IllegalArgumentException("Argument b ( byte array ) is null! ");47 }4849 public static byte[] byteConvert32Bytes(BigInteger arg5) {50 byte[] v0 = null;51 if(arg5 == null) {52 return v0;53 }5455 int v4 = 32;56 if(arg5.toByteArray().length == 33) {57 v0 = new byte[v4];58 System.arraycopy(arg5.toByteArray(), 1, v0, 0, v4);59 }60 else if(arg5.toByteArray().length == v4) {61 v0 = arg5.toByteArray();62 }63 else {64 v0 = new byte[v4];65 int v1;66 for(v1 = 0; v1 < 32 - arg5.toByteArray().length; ++v1) {67 v0[v1] = 0;68 }6970 System.arraycopy(arg5.toByteArray(), 0, v0, v4 - arg5.toByteArray().length, arg5.toByteArray().length);71 }7273 return v0;74 }7576 public static byte[] hexStringToBytes(String arg7) {77 if(arg7 != null) {78 if(arg7.equals("")) {79 }80 else {81 arg7 = arg7.toUpperCase();82 int v0 = arg7.length() / 2;83 char[] v1 = arg7.toCharArray();84 byte[] v2 = new byte[v0];85 int v3;86 for(v3 = 0; v3 < v0; ++v3) {87 int v4 = v3 * 2;88 v2[v3] = ((byte)(Util.charToByte(v1[v4]) << 4 | Util.charToByte(v1[v4 + 1])));89 }9091 return v2;92 }93 }9495 return null;96 }9798 public static byte charToByte(char arg1) {99 return ((byte)"0123456789ABCDEF".indexOf(arg1));100 }101102 } SM2:import org.bouncycastle.crypto.generators.ECKeyPairGenerator;2 import org.bouncycastle.crypto.params.ECDomainParameters;3 import org.bouncycastle.crypto.params.ECKeyGenerationParameters;4 import org.bouncycastle.math.ec.ECCurve;5 import org.bouncycastle.math.ec.ECFieldElement;6 import org.bouncycastle.math.ec.ECPoint;78 import java.math.BigInteger;9 import java.security.SecureRandom;1011 public class SM2 {12 public static String[] ecc_param = {"FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFF", "FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFC", "28E9FA9E9D9F5E3413 public final BigInteger ecc_p = new BigInteger(ecc_param[0], 16);14 public final BigInteger ecc_a = new BigInteger(ecc_param[1], 16);15 public final BigInteger ecc_b = new BigInteger(ecc_param[2], 16);16 public final BigInteger ecc_n = new BigInteger(ecc_param[3], 16);17 public final BigInteger ecc_gx = new BigInteger(ecc_param[4], 16);18 public final BigInteger ecc_gy = new BigInteger(ecc_param[5], 16);19 public final ECFieldElement ecc_gx_fieldelement = new ECFieldElement.Fp(this.ecc_p, this.ecc_gx);20 public final ECFieldElement ecc_gy_fieldelement = new ECFieldElement.Fp(this.ecc_p, this.ecc_gy);21 public final ECCurve ecc_curve = new ECCurve.Fp(this.ecc_p, this.ecc_a, this.ecc_b);22 public final ECPoint ecc_point_g = new ECPoint.Fp(this.ecc_curve, this.ecc_gx_fieldelement, this.ecc_gy_fieldelement);23 public final ECDomainParameters ecc_bc_spec = new ECDomainParameters(this.ecc_curve, this.ecc_point_g, this.ecc_n);24 public final ECKeyPairGenerator ecc_key_pair_generator;2526 public static SM2 Instance() {27 return new SM2();28 }2930 public SM2() {31 ECKeyGenerationParameters ecc_ecgenparam = new ECKeyGenerationParameters(this.ecc_bc_spec, new SecureRandom());32 this.ecc_key_pair_generator = new ECKeyPairGenerator();33 this.ecc_key_pair_generator.init(ecc_ecgenparam);34 }35 } SM2Util：import org.bouncycastle.crypto.AsymmetricCipherKeyPair;2 import org.bouncycastle.crypto.params.AsymmetricKeyParameter;3 import org.bouncycastle.crypto.params.ECPrivateKeyParameters;4 import org.bouncycastle.crypto.params.ECPublicKeyParameters;5 import org.bouncycastle.math.ec.ECPoint;67 import java.io.IOException;8 import java.math.BigInteger;910 public class SM2Util {11 public static final String PUBLIC_KEY = "你的公钥1";12 public static final String PUBLIC_KEY_2 = "你的公钥2";13 public static String encrypt(String key, String mes) {14 byte[] arg9 = mes.getBytes();15 byte[] arg8 = Util.hexToByte(key);16 String v0 = null;17 if(arg8 != null) {18 if(arg8.length == 0) {19 }20 else {21 if(arg9 != null) {22 if(arg9.length == 0) {23 }24 else {25 byte[] v0_1 = new byte[arg9.length];26 System.arraycopy(arg9, 0, v0_1, 0, arg9.length);27 Cipher v1 = new Cipher();28 SM2 v2 = SM2.Instance();29 ECPoint v4 = v1.Init_enc(v2, v2.ecc_curve.decodePoint(arg8));30 v1.Encrypt(v0_1);31 byte[] v5 = new byte[32];32 v1.Dofinal(v5);33 return Util.byteToHex(v4.getEncoded()) + Util.byteToHex(v5) + Util.byteToHex(v0_1);34 }35 }36 return v0;37 }38 }39 return v0;40 }4142 public static String decrypt(String key, String mes) throws IOException {43 byte[] arg9 = Util.hexToByte(key);44 byte[] arg10 = Util.hexToByte(mes);45 byte[] v0 = null;46 if(arg9 != null) {47 if(arg9.length == 0) {48 }49 else {50 if(arg10 != null) {51 if(arg10.length == 0) {52 }53 else {54 String v0_1 = Util.byteToHex(arg10);55 byte[] v1 = Util.hexToByte(v0_1.substring(0, 130));56 int v3 = arg10.length - 97;57 byte[] v2 = Util.hexToByte(v0_1.substring(130, 194));58 byte[] v4 = Util.hexToByte(v0_1.substring(194, v3 * 2 + 194));59 SM2 v5 = SM2.Instance();60 BigInteger v6 = new BigInteger(1, arg9);61 ECPoint v7 = v5.ecc_curve.decodePoint(v1);62 Cipher v8 = new Cipher();63 v8.Init_dec(v6, v7);64 v8.Decrypt(v4);65 v8.Dofinal(v2);66 return new String(v4);67 }68 }6970 return new String(v0);71 }72 }73 return new String(v0);74 }7576 // public static SM2KeyVO generateKeyPair() {77 // AsymmetricCipherKeyPair v1;78 // SM2 v0 = SM2.Instance();79 // while(true) {80 // v1 = v0.ecc_key_pair_generator.generateKeyPair();81 // if(v1.getPrivate().getD().toByteArray().length == 32) {82 // break;83 // }84 // }85 //86 // AsymmetricKeyParameter v2 = v1.getPrivate();87 // AsymmetricKeyParameter v3 = v1.getPublic();88 // BigInteger v4 = ((ECPrivateKeyParameters)v2).getD();89 // ECPoint v5 = ((ECPublicKeyParameters)v3).getQ();90 // SM2KeyVO v6 = new SM2KeyVO();91 // v6.setPublicKey(v5);92 // v6.setPrivateKey(v4);93 // return v6;94 // }9596 } SM2KeyVO:import org.bouncycastle.math.ec.ECPoint;23 import java.math.BigInteger;45 public class SM2KeyVO {6 BigInteger privateKey;7 ECPoint publicKey;89 public String getPriHexInSoft() {10 return Util.byteToHex(this.privateKey.toByteArray());11 }1213 public BigInteger getPrivateKey() {14 return this.privateKey;15 }1617 public String getPubHexInSoft() {18 return Util.byteToHex(this.publicKey.getEncoded());19 }2021 public ECPoint getPublicKey() {22 return this.publicKey;23 }2425 public void setPrivateKey(BigInteger arg1) {26 this.privateKey = arg1;27 }2829 public void setPublicKey(ECPoint arg1) {30 this.publicKey = arg1;31 }32 } SM3Util:import org.bouncycastle.crypto.digests.SM3Digest;2 import org.bouncycastle.util.encoders.Hex;34 public class SM3Util {5 public static String sm3(String arg5) {6 byte[] v0 = new byte[32];7 byte[] v1 = arg5.getBytes();8 SM3Digest v2 = new SM3Digest();9 v2.update(v1, 0, v1.length);10 v2.doFinal(v0, 0);11 return new String(Hex.encode(v0)).toUpperCase();12 }13 } SM4:import java.io.ByteArrayInputStream;2 import java.io.ByteArrayOutputStream;34 public class SM4 {5 public static final int[] CK = new int[]{462357, 472066609, 943670861, 1415275113, 1886879365, -1936483679, -1464879427, -993275175, -521670923, -66909679, 404694573, 876298825, 1347903077, 1819507329, -2003855715, -153225146 public static final int[] FK = new int[]{-1548633402, 1453994832, 1736282519, -1301273892};7 public static final int SM4_DECRYPT = 0;8 public static final int SM4_ENCRYPT = 1;9 public static final byte[] SboxTable = new byte[]{-42, -112, -23, -2, -52, -31, 61, -73, 22, -74, 20, -62, 40, -5, 44, 5, 43, 103, -102, 118, 42, -66, 4, -61, -86, 68, 19, 38, 73, -122, 6, -103, -100, 66, 80, -12, -111, -17, -104, 122, 51, 84, 11, 67, -11011 public SM4() {12 super();13 }1415 private long GET_ULONG_BE(byte[] arg7, int arg8) {16 return (((long)(arg7[arg8] & 255))) << 24 | (((long)((arg7[arg8 + 1] & 255) << 16))) | (((long)((arg7[arg8 + 2] & 255) << 8))) | (((long)(arg7[arg8 + 3] & 255))) & 4294967295L;17 }1819 private void PUT_ULONG_BE(long arg7, byte[] arg9, int arg10) {20 arg9[arg10] = ((byte)(((int)(arg7 >> 24 & 255))));21 arg9[arg10 + 1] = ((byte)(((int)(arg7 >> 16 & 255))));22 arg9[arg10 + 2] = ((byte)(((int)(arg7 >> 8 & 255))));23 arg9[arg10 + 3] = ((byte)(((int)(arg7 & 255))));24 }2526 private long ROTL(long arg5, int arg7) {27 return this.SHL(arg5, arg7) | arg5 >> 32 - arg7;28 }2930 private long SHL(long arg3, int arg5) {31 return (-1 & arg3) << arg5;32 }3334 private void SWAP(long[] arg5, int arg6) {35 long v0 = arg5[arg6];36 arg5[arg6] = arg5[31 - arg6];37 arg5[31 - arg6] = v0;38 }3940 private byte[] padding(byte[] arg6, int arg7) {41 int v1;42 byte[] v0 = null;43 if(arg6 == null) {44 return v0;45 }4647 if(arg7 == 1) {48 v1 = 16 - arg6.length % 16;49 v0 = new byte[arg6.length + v1];50 System.arraycopy(arg6, 0, v0, 0, arg6.length);51 int v2;52 for(v2 = 0; v2 < v1; ++v2) {53 v0[arg6.length + v2] = ((byte)v1);54 }55 }56 else {57 v1 = arg6[arg6.length - 1];58 v0 = new byte[arg6.length - v1];59 System.arraycopy(arg6, 0, v0, 0, arg6.length - v1);60 }6162 return v0;63 }6465 private long sm4CalciRK(long arg11) {66 byte[] v5 = new byte[4];67 byte[] v4 = new byte[4];68 this.PUT_ULONG_BE(arg11, v5, 0);69 v4[0] = this.sm4Sbox(v5[0]);70 v4[1] = this.sm4Sbox(v5[1]);71 v4[2] = this.sm4Sbox(v5[2]);72 v4[3] = this.sm4Sbox(v5[3]);73 long v0 = this.GET_ULONG_BE(v4, 0);74 return this.ROTL(v0, 13) ^ v0 ^ this.ROTL(v0, 23);75 }7677 private long sm4F(long arg3, long arg5, long arg7, long arg9, long arg11) {78 return this.sm4Lt(arg5 ^ arg7 ^ arg9 ^ arg11) ^ arg3;79 }8081 private long sm4Lt(long arg11) {82 byte[] v5 = new byte[4];83 byte[] v4 = new byte[4];84 this.PUT_ULONG_BE(arg11, v5, 0);85 v4[0] = this.sm4Sbox(v5[0]);86 v4[1] = this.sm4Sbox(v5[1]);87 v4[2] = this.sm4Sbox(v5[2]);88 v4[3] = this.sm4Sbox(v5[3]);89 long v0 = this.GET_ULONG_BE(v4, 0);90 return this.ROTL(v0, 2) ^ v0 ^ this.ROTL(v0, 10) ^ this.ROTL(v0, 18) ^ this.ROTL(v0, 24);91 }9293 private byte sm4Sbox(byte arg3) {94 return SM4.SboxTable[arg3 & 255];95 }9697 public byte[] sm4_crypt_cbc(SM4_Context arg13, byte[] arg14, byte[] arg15) throws Exception {98 byte[] v8;99 byte[] v6;100 byte[] v2;101 if(arg14 != null) {102 int v1 = 16;103 if(arg14.length == v1) {104 if(arg15 != null) {105 if((arg13.isPadding) && arg13.mode == 1) {106 arg15 = this.padding(arg15, 1);107 }108109 int v3 = arg15.length;110 ByteArrayInputStream v4 = new ByteArrayInputStream(arg15);111 ByteArrayOutputStream v5 = new ByteArrayOutputStream();112 if(arg13.mode == 1) {113 while(v3 > 0) {114 v2 = new byte[v1];115 v6 = new byte[v1];116 v8 = new byte[v1];117 v4.read(v2);118 int v0;119 for(v0 = 0; v0 < v1; ++v0) {120 v6[v0] = ((byte)(v2[v0] ^ arg14[v0]));121 }122123 this.sm4_one_round(arg13.sk, v6, v8);124 System.arraycopy(v8, 0, arg14, 0, v1);125 v5.write(v8);126 v3 += -16;127 }128 }129 else {130 v2 = new byte[v1];131 while(v3 > 0) {132 v6 = new byte[v1];133 v8 = new byte[v1];134 byte[] v9 = new byte[v1];135 v4.read(v6);136 System.arraycopy(v6, 0, v2, 0, v1);137 this.sm4_one_round(arg13.sk, v6, v8);138 int v0;139 for(v0 = 0; v0 < v1; ++v0) {140 v9[v0] = ((byte)(v8[v0] ^ arg14[v0]));141 }142143 System.arraycopy(v2, 0, arg14, 0, v1);144 v5.write(v9);145 v3 += -16;146 }147 }148149 byte[] v1_1 = v5.toByteArray();150 if((arg13.isPadding) && arg13.mode == 0) {151 v1_1 = this.padding(v1_1, 0);152 }153154 v4.close();155 v5.close();156 return v1_1;157 }158 else {159 throw new Exception("input is null!");160 }161 }162 }163164 throw new Exception("iv error!");165 }166167 public byte[] sm4_crypt_ecb(SM4_Context arg7, byte[] arg8) throws Exception {168 byte[] v3;169 if(arg8 != null) {170 if((arg7.isPadding) && arg7.mode == 1) {171 arg8 = this.padding(arg8, 1);172 }173174 int v0 = arg8.length;175 ByteArrayInputStream v1 = new ByteArrayInputStream(arg8);176 ByteArrayOutputStream v2 = new ByteArrayOutputStream();177 while(v0 > 0) {178 byte[] v4 = new byte[16];179 v3 = new byte[16];180 v1.read(v4);181 this.sm4_one_round(arg7.sk, v4, v3);182 v2.write(v3);183 v0 += -16;184 }185186 v3 = v2.toByteArray();187 if((arg7.isPadding) && arg7.mode == 0) {188 v3 = this.padding(v3, 0);189 }190191 v1.close();192 v2.close();193 return v3;194 }195196 throw new Exception("input is null!");197 }198199 private void sm4_one_round(long[] arg23, byte[] arg24, byte[] arg25) {200 int v0;201 SM4 v11 = this;202 byte[] v13 = arg25;203 long[] v14 = new long[36];204 v14[0] = v11.GET_ULONG_BE(arg24, 0);205 v14[1] = v11.GET_ULONG_BE(arg24, 4);206 v14[2] = v11.GET_ULONG_BE(arg24, 8);207 v14[3] = v11.GET_ULONG_BE(arg24, 12);208 int v8;209 for(v8 = 0; true; ++v8) {210 v0 = 32;211 if(v8 >= v0) {212 break;213 }214215 v14[v8 + 4] = this.sm4F(v14[v8], v14[v8 + 1], v14[v8 + 2], v14[v8 + 3], arg23[v8]);216 }217218 v11.PUT_ULONG_BE(v14[35], v13, 0);219 v11.PUT_ULONG_BE(v14[34], v13, 4);220 v11.PUT_ULONG_BE(v14[33], v13, 8);221 v11.PUT_ULONG_BE(v14[v0], v13, 12);222 }223224 private void sm4_setkey(long[] arg13, byte[] arg14) {225 long[] v1 = new long[4];226 long[] v2 = new long[36];227 int v3 = 0;228 v1[0] = this.GET_ULONG_BE(arg14, 0);229 v1[1] = this.GET_ULONG_BE(arg14, 4);230 v1[2] = this.GET_ULONG_BE(arg14, 8);231 v1[3] = this.GET_ULONG_BE(arg14, 12);232 long v5 = v1[0];233 int[] v9 = SM4.FK;234 v2[0] = v5 ^ (((long)v9[0]));235 v2[1] = v1[1] ^ (((long)v9[1]));236 v2[2] = v1[2] ^ (((long)v9[2]));237 v2[3] = v1[3] ^ (((long)v9[3]));238 while(v3 < 32) {239 v2[v3 + 4] = v2[v3] ^ this.sm4CalciRK(v2[v3 + 1] ^ v2[v3 + 2] ^ v2[v3 + 3] ^ (((long)SM4.CK[v3]))); 240 arg13[v3] = v2[v3 + 4];241 ++v3;242 }243 }244245 public void sm4_setkey_dec(SM4_Context arg4, byte[] arg5) throws Exception {246 if(arg4 != null) {247 if(arg5 != null) {248 int v1 = 16;249 if(arg5.length == v1) {250 arg4.mode = 0;251 this.sm4_setkey(arg4.sk, arg5);252 int v0;253 for(v0 = 0; v0 < v1; ++v0) {254 this.SWAP(arg4.sk, v0);255 }256257 return;258 }259 }260261 throw new Exception("key error!");262 }263264 throw new Exception("ctx is null!");265 }266267 public void sm4_setkey_enc(SM4_Context arg3, byte[] arg4) throws Exception {268 if(arg3 != null) {269 if(arg4 != null && arg4.length == 16) {270 arg3.mode = 1;271 this.sm4_setkey(arg3.sk, arg4);272 return;273 }274275 throw new Exception("key error!");276 }277278 throw new Exception("ctx is null!");279 }280 } SM4_Context:public class SM4_Context {2 public boolean isPadding;3 public int mode;4 public long[] sk;56 public SM4_Context() {7 super();8 this.mode = 1;9 this.isPadding = true;10 this.sk = new long[32];11 }12 } SM4Util:import mons.codec.binary.Base64;23 import java.io.IOException;4 import java.io.PrintStream;5 import java.util.regex.Pattern;67 public class SM4Utils {8 public static final String KEY = "你的key";9 public static final String IV = "你的IV";10 public boolean hexString;11 public String iv;12 public String secretKey;1314 public SM4Utils() {15 super();16 this.secretKey = "";17 this.iv = "";18 this.hexString = false;19 }2021 public static String sm4Decrypt(String mes) {22 SM4Utils v0 = new SM4Utils();23 v0.secretKey = KEY;24 v0.iv = IV;25 v0.hexString = true;26 return v0.decryptData_CBC(mes);27 }2829 public static String sm4Encrypt(String mes) {30 SM4Utils v0 = new SM4Utils();31 v0.secretKey = KEY;32 v0.iv = IV;33 v0.hexString = true;34 return v0.encryptData_CBC(mes);35 }3637 public String decryptData_CBC(String arg9) {38 byte[] v3;39 byte[] v2;40 try {41 arg9 = Base64.encodeBase64String(Util.hexToByte(arg9));42 if(arg9 != null && arg9.trim().length() > 0) {43 arg9 = pile("\\s*|\t|\r|\n").matcher(((CharSequence)arg9)).replaceAll("");44 }4546 SM4_Context v1 = new SM4_Context();47 v1.isPadding = true;48 v1.mode = 0;49 if(this.hexString) {50 v2 = Util.hexStringToBytes(this.secretKey);51 v3 = Util.hexStringToBytes(this.iv);52 }53 else {54 v2 = this.secretKey.getBytes();55 v3 = this.iv.getBytes();56 }5758 SM4 v4 = new SM4();59 v4.sm4_setkey_dec(v1, v2);60 return new String(v4.sm4_crypt_cbc(v1, v3, Base64.decodeBase64(arg9)), "UTF-8");61 }62 catch(Exception v0) {63 v0.printStackTrace();64 return null;65 }66 }6768 public String encryptData_CBC(String arg7) {69 byte[] v2;70 byte[] v1;71 try {72 SM4_Context v0_1 = new SM4_Context();73 v0_1.isPadding = true;74 v0_1.mode = 1;75 if(this.hexString) {76 v1 = Util.hexStringToBytes(this.secretKey);77 v2 = Util.hexStringToBytes(this.iv);78 }79 else {80 v1 = this.secretKey.getBytes();81 v2 = this.iv.getBytes();82 }8384 SM4 v3 = new SM4();85 v3.sm4_setkey_enc(v0_1, v1);86 return Util.byteToHex(v3.sm4_crypt_cbc(v0_1, v2, arg7.getBytes("UTF-8")));87 }88 catch(Exception v0) {89 v0.printStackTrace();90 return null;91 }92 }9394 public String decryptData_ECB(String arg8) {95 try {96 arg8 = Base64.encodeBase64String(Util.hexToByte(arg8));97 if(arg8 != null && arg8.trim().length() > 0) {98 arg8 = pile("\\s*|\t|\r|\n").matcher(((CharSequence)arg8)).replaceAll("");99 }100101 SM4_Context v1 = new SM4_Context();102 v1.isPadding = true;103 v1.mode = 0;104 byte[] v2 = this.hexString ? Util.hexStringToBytes(this.secretKey) : this.secretKey.getBytes(); 105 SM4 v3 = new SM4();106 v3.sm4_setkey_dec(v1, v2);107 return new String(v3.sm4_crypt_ecb(v1, Base64.decodeBase64(arg8)), "UTF-8");108 }109 catch(Exception v0) {110 v0.printStackTrace();111 return null;112 }113 }114115 public String encryptData_ECB(String arg6) {116 try {117 SM4_Context v0_1 = new SM4_Context();118 v0_1.isPadding = true;120 byte[] v1 = this.hexString ? Util.hexStringToBytes(this.secretKey) : Util.hexStringToBytes(this.secretKey); 121 SM4 v2 = new SM4();122 v2.sm4_setkey_enc(v0_1, v1);123 return Util.byteToHex(v2.sm4_crypt_ecb(v0_1, arg6.getBytes("UTF-8")));124 }125 catch(Exception v0) {126 v0.printStackTrace();127 return null;128 }129 }130131 }1 import mons.codec.binary.Base64;23 import java.io.IOException;4 import java.io.PrintStream;5 import java.util.regex.Pattern;67 public class SM4Utils {8 public static final String KEY = "你的key";9 public static final String IV = "你的IV";10 public boolean hexString;11 public String iv;12 public String secretKey;1314 public SM4Utils() {15 super();16 this.secretKey = "";17 this.iv = "";18 this.hexString = false;19 }2021 public static String sm4Decrypt(String mes) {22 SM4Utils v0 = new SM4Utils();23 v0.secretKey = KEY;24 v0.iv = IV;25 v0.hexString = true;26 return v0.decryptData_CBC(mes);27 }2829 public static String sm4Encrypt(String mes) {30 SM4Utils v0 = new SM4Utils();31 v0.secretKey = KEY;32 v0.iv = IV;33 v0.hexString = true;34 return v0.encryptData_CBC(mes);35 }3637 public String decryptData_CBC(String arg9) {38 byte[] v3;39 byte[] v2;40 try {41 arg9 = Base64.encodeBase64String(Util.hexToByte(arg9));42 if(arg9 != null && arg9.trim().length() > 0) {43 arg9 = pile("\\s*|\t|\r|\n").matcher(((CharSequence)arg9)).replaceAll("");44 }4546 SM4_Context v1 = new SM4_Context();47 v1.isPadding = true;48 v1.mode = 0;49 if(this.hexString) {50 v2 = Util.hexStringToBytes(this.secretKey);51 v3 = Util.hexStringToBytes(this.iv);52 }53 else {54 v2 = this.secretKey.getBytes();55 v3 = this.iv.getBytes();56 }5758 SM4 v4 = new SM4();59 v4.sm4_setkey_dec(v1, v2);60 return new String(v4.sm4_crypt_cbc(v1, v3, Base64.decodeBase64(arg9)), "UTF-8");61 }62 catch(Exception v0) {63 v0.printStackTrace();64 return null;65 }66 }6768 public String encryptData_CBC(String arg7) {69 byte[] v2;70 byte[] v1;71 try {72 SM4_Context v0_1 = new SM4_Context();73 v0_1.isPadding = true;74 v0_1.mode = 1;75 if(this.hexString) {76 v1 = Util.hexStringToBytes(this.secretKey);77 v2 = Util.hexStringToBytes(this.iv);78 }79 else {80 v1 = this.secretKey.getBytes();81 v2 = this.iv.getBytes();82 }8384 SM4 v3 = new SM4();85 v3.sm4_setkey_enc(v0_1, v1);86 return Util.byteToHex(v3.sm4_crypt_cbc(v0_1, v2, arg7.getBytes("UTF-8")));87 }88 catch(Exception v0) {89 v0.printStackTrace();90 return null;91 }92 }9394 public String decryptData_ECB(String arg8) {95 try {96 arg8 = Base64.encodeBase64String(Util.hexToByte(arg8));97 if(arg8 != null && arg8.trim().length() > 0) {98 arg8 = pile("\\s*|\t|\r|\n").matcher(((CharSequence)arg8)).replaceAll("");99 }100101 SM4_Context v1 = new SM4_Context();102 v1.isPadding = true;103 v1.mode = 0;104 byte[] v2 = this.hexString ? Util.hexStringToBytes(this.secretKey) : this.secretKey.getBytes();105 SM4 v3 = new SM4();106 v3.sm4_setkey_dec(v1, v2);107 return new String(v3.sm4_crypt_ecb(v1, Base64.decodeBase64(arg8)), "UTF-8");108 }109 catch(Exception v0) {。

国密算法对照

国密算法对照
国密即国家密码局认定的国产密码算法。

例如：在门禁应用中，采用SM1算法进行身份鉴别和数据加密通讯，实现卡片合法性的验证，保证身份识别的真实性。

安全是关系国家、城市信息、行业用户、百姓利益的关键问题。

国家密码管理局针对现有重要门禁系统建设和升级改造应用也提出指导意见，加强芯片、卡片、系统的标准化建设。

国密门禁系统的升级的案例也逐渐增多，基于自主国产知识产权的CPU卡、CPU卡读写设备及密钥管理系统广泛受到关注。

一些厂商在2009年推出CPU卡安全门禁系列产品，在2010年北京安博会上，向业界展示出系列CPU卡门禁系统、系列安全门禁读卡器以及基于CPU 卡技术的一卡通系统等主流产品和系统。

这些厂商是全国推广的国密门禁产品的先驱者，使系列CPU卡门禁系统广泛应用于政府、监狱、司法、军工企业和大型公共智能建筑等高安全领域。

国密SM4算法

国密SM4算法与DES和AES算法相似，国密SM4算法是⼀种分组加密算法。

SM4分组密码算法是⼀种迭代分组密码算法，由加解密算法和密钥扩展算法组成。

SM4是⼀种Feistel结构的分组密码算法，其分组长度和密钥长度均为128bits。

加密算法和密钥扩展算法迭代轮数均为32轮。

SM4加解密过程的算法相同但是轮密钥的使⽤顺序相反。

SM4密码算法使⽤模2加和循环移位作为基本运算。

密钥扩展算法：SM4算法使⽤128位的加密密钥，并采⽤32轮迭代加密结构，每⼀轮加密使⽤⼀个32位的轮密钥，总共使⽤32个轮密钥。

因此需要使⽤密钥扩展算法，从加密密钥中产⽣32个轮密钥。

SM4加解密流程SM4算法的加密⼤致流程如下：密钥：加密密钥的长度为128⽐特，表⽰为MK = (MK0, MK1, MK2, MK3)，其中MK i为32位，轮密钥表⽰为(rk0, rk1, ……, rk31)，其中rk i为32位。

轮函数F：假设输⼊为(X0, X1, X2, X3)，X i 为32位，则轮函数F为：F=(X0, X1, X2, X3, rk) = X0⊕ T(X1⊕ X2⊕ X3⊕ r k)合成置换：T函数是⼀个可逆变换，由⼀个⾮线性变换r和线性变换L复合⽽成的，即T( )=L(r( ))⾮线性变换有四个并⾏的S盒构成的，设输⼊为A=(a0, a1, a2, a3)，输出为B=(b0, b1, b2, b3)，其中a i和b i为8位。

每个S盒的输⼊都是⼀个8位的字节，将这8位的前四位对应的16进制数作为⾏编号，后四位对应的16进制数作为列编号，然后⽤相应位置中的字节代替输⼊的字节。

下图为S盒置换表：线性变换L：线形变换的输⼊就是S盒的输出，即C=L(B)=B ⊕ (B<<<2) ⊕ (B<<<10) ⊕ (B<<<18) ⊕ (B<<<24)，线性变换的输⼊和输出都是32位的。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

国密算法标准
国密算法是指中国国家密码管理局（National Cryptography Administration）发布的密码算法标准，包括对称密码算法、非对称密码算法和杂凑密码算法。

国密算法标准的实施旨在保障国家信息安全和数据隐私，保护国家关键信息基础设施和国家安全。

一、国密对称密码算法标准
国密对称密码算法采用的是SM4，也称为商用密码，是一种块密码算法，密钥长度为128比特。

SM4算法提供了高强度的加密和解密机制，适用于各种加密应用场景，如数据传输和存储安全等。

该算法已被广泛应用于金融、电子商务、移动通信等领域，受到了良好的评价和信任。

二、国密非对称密码算法标准
国密非对称密码算法采用的是SM2和SM9。

SM2是一种椭圆曲线公钥密码算法，具有高安全性和高效率。

SM2算法适用于数字签名、密钥交换和加密等场景，能够有效保护通信双方的数据安全。

SM9是用于密码协议的一种基于双线性对的密码算法，它支持密钥交换和数字签名等功能，并且适用于多方安全计算和身份认证。

三、国密杂凑密码算法标准
国密杂凑密码算法采用的是SM3，是一种基于SHA-256算法结构设计而成的密码杂凑算法。

SM3算法具有公开和透明的特点，广泛应用于数字签名、身份认证和数据完整性验证等场景。

该算法在安全性和性能上均表现出色，受到了广泛认可和应用。

国密算法标准的制定和实施，为国家信息安全提供了重要保障。

国密算法标准的推广应用，也对保护企业和个人的信息安全起到了积极作用。

未来，随着信息技术的不断发展和应用场景的不断拓展，国密算法标准也将不断完善和更新，以应对日益复杂的信息安全挑战。