國密改造已經(jīng)持續(xù)了很長時間了，相信很多從事金融科技類的程序猿都遇到過這個需求。這篇文章就為大家?guī)砉P者對于國密改造的一些經(jīng)驗，主要是代碼層面，有興趣的同學可以研究下國密的算法模型！
注：本文所用到的工具類并非筆者所寫！
目錄
一、國密簡述
二、依賴準備
三、SM2算法應用
1、生成SM2公私鑰
工具類
測試Demo
?2、數(shù)據(jù)加解密
一、國密簡述
國密——國家密碼局制定的國家密碼算法。主要包含SM1、SM2、SM3、SM4幾種方式。
SM1：對稱加密，且算法不公開，使用硬件加密，本文不做敘述；
SM2：非對稱加密，簽名以及生成秘鑰速度優(yōu)于RSA，基于ECC算法，運算效率更高，且更安全；
SM3：摘要，國產(chǎn)雜湊算法，生成長度為256比特，優(yōu)于MD5以及SHA-1算法；
SM4：?無線局域網(wǎng)標準的分組數(shù)據(jù)算法。對稱加密，密鑰長度和分組長度均為128位；
注意
生成SM2 公鑰是130 位 前面多了04兩個標識符，注意區(qū)分！
二、依賴準備
國密主要用到下面的包
<dependency>
<groupId>org.bouncycastle</groupId>
<artifactId>bcpkix-jdk15on</artifactId>
<version>1.57</version>
</dependency>
一定注意版本。實際項目中筆者發(fā)現(xiàn)項目其他子工程用到1.56版本的包，所以選擇了低版本。
三、SM2算法應用
1、生成SM2公私鑰
工具類
package cn.test.encrypt.utils.sm2;
import cn.test.encrypt.utils.Util;
import org.bouncycastle.crypto.AsymmetricCipherKeyPair;
import org.bouncycastle.crypto.digests.SM3Digest;
import org.bouncycastle.crypto.params.ECPrivateKeyParameters;
import org.bouncycastle.crypto.params.ECPublicKeyParameters;
import org.bouncycastle.math.ec.ECPoint;
import java.math.BigInteger;
public class Cipher {
private int ct;
private ECPoint p2;
private SM3Digest sm3keybase;
private SM3Digest sm3c3;
private byte key[];
private byte keyOff;
public Cipher()
{
this.ct = 1;
this.key = new byte[32];
this.keyOff = 0;
}
private void Reset()
{
this.sm3keybase = new SM3Digest();
this.sm3c3 = new SM3Digest();
byte p[] = Util.byteConvert32Bytes(p2.getX().toBigInteger());
this.sm3keybase.update(p, 0, p.length);
this.sm3c3.update(p, 0, p.length);
p = Util.byteConvert32Bytes(p2.getY().toBigInteger());
this.sm3keybase.update(p, 0, p.length);
this.ct = 1;
NextKey();
}
private void NextKey()
{
SM3Digest sm3keycur = new SM3Digest(this.sm3keybase);
sm3keycur.update((byte) (ct >> 24 & 0xff));
sm3keycur.update((byte) (ct >> 16 & 0xff));
sm3keycur.update((byte) (ct >> 8 & 0xff));
sm3keycur.update((byte) (ct & 0xff));
sm3keycur.doFinal(key, 0);
this.keyOff = 0;
this.ct++;
}
public ECPoint Init_enc(SM2 sm2, ECPoint userKey)
{
AsymmetricCipherKeyPair key = sm2.ecc_key_pair_generator.generateKeyPair();
ECPrivateKeyParameters ecpriv = (ECPrivateKeyParameters) key.getPrivate();
ECPublicKeyParameters ecpub = (ECPublicKeyParameters) key.getPublic();
BigInteger k = ecpriv.getD();
ECPoint c1 = ecpub.getQ();
this.p2 = userKey.multiply(k);
Reset();
return c1;
}
public void Encrypt(byte data[])
{
this.sm3c3.update(data, 0, data.length);
for (int i = 0; i < data.length; i++)
{
if (keyOff == key.length)
{
NextKey();
}
data[i] ^= key[keyOff++];
}
}
public void Init_dec(BigInteger userD, ECPoint c1)
{
this.p2 = c1.multiply(userD);
Reset();
}
public void Decrypt(byte data[])
{
for (int i = 0; i < data.length; i++)
{
if (keyOff == key.length)
{
NextKey();
}
data[i] ^= key[keyOff++];
}
this.sm3c3.update(data, 0, data.length);
}
public void Dofinal(byte c3[])
{
byte p[] = Util.byteConvert32Bytes(p2.getY().toBigInteger());
this.sm3c3.update(p, 0, p.length);
this.sm3c3.doFinal(c3, 0);
Reset();
}
}
package cn.test.encrypt.utils.sm2;
import org.bouncycastle.crypto.generators.ECKeyPairGenerator;
import org.bouncycastle.crypto.params.ECDomainParameters;
import org.bouncycastle.crypto.params.ECKeyGenerationParameters;
import org.bouncycastle.math.ec.ECCurve;
import org.bouncycastle.math.ec.ECFieldElement;
import org.bouncycastle.math.ec.ECFieldElement.Fp;
import org.bouncycastle.math.ec.ECPoint;
import java.math.BigInteger;
import java.security.SecureRandom;
public class SM2 {
//國密參數(shù)
public static String[] ecc_param = {
"FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFF",
"FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFC",
"28E9FA9E9D9F5E344D5A9E4BCF6509A7F39789F515AB8F92DDBCBD414D940E93",
"FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFF7203DF6B21C6052B53BBF40939D54123",
"32C4AE2C1F1981195F9904466A39C9948FE30BBFF2660BE1715A4589334C74C7",
"BC3736A2F4F6779C59BDCEE36B692153D0A9877CC62A474002DF32E52139F0A0"
};
public static SM2 Instance()
{
return new SM2();
}
public final BigInteger ecc_p;
public final BigInteger ecc_a;
public final BigInteger ecc_b;
public final BigInteger ecc_n;
public final BigInteger ecc_gx;
public final BigInteger ecc_gy;
public final ECCurve ecc_curve;
public final ECPoint ecc_point_g;
public final ECDomainParameters ecc_bc_spec;
public final ECKeyPairGenerator ecc_key_pair_generator;
public final ECFieldElement ecc_gx_fieldelement;
public final ECFieldElement ecc_gy_fieldelement;
public SM2()
{
this.ecc_p = new BigInteger(ecc_param[0], 16);
this.ecc_a = new BigInteger(ecc_param[1], 16);
this.ecc_b = new BigInteger(ecc_param[2], 16);
this.ecc_n = new BigInteger(ecc_param[3], 16);
this.ecc_gx = new BigInteger(ecc_param[4], 16);
this.ecc_gy = new BigInteger(ecc_param[5], 16);
this.ecc_gx_fieldelement = new Fp(this.ecc_p, this.ecc_gx);
this.ecc_gy_fieldelement = new Fp(this.ecc_p, this.ecc_gy);
this.ecc_curve = new ECCurve.Fp(this.ecc_p, this.ecc_a, this.ecc_b);
this.ecc_point_g = new ECPoint.Fp(this.ecc_curve, this.ecc_gx_fieldelement, this.ecc_gy_fieldelement);
this.ecc_bc_spec = new ECDomainParameters(this.ecc_curve, this.ecc_point_g, this.ecc_n);
ECKeyGenerationParameters ecc_ecgenparam;
ecc_ecgenparam = new ECKeyGenerationParameters(this.ecc_bc_spec, new SecureRandom());
this.ecc_key_pair_generator = new ECKeyPairGenerator();
this.ecc_key_pair_generator.init(ecc_ecgenparam);
}
}
生成隨機秘鑰工具類
package cn.test.encrypt.utils.sm2;
import cn.test.encrypt.utils.Util;
import org.bouncycastle.crypto.AsymmetricCipherKeyPair;
import org.bouncycastle.crypto.params.ECPrivateKeyParameters;
import org.bouncycastle.crypto.params.ECPublicKeyParameters;
import org.bouncycastle.math.ec.ECPoint;
import java.io.IOException;
import java.math.BigInteger;
public class SM2EncDecUtils {
//生成隨機秘鑰對
public static SM2KeyVO generateKeyPair(){
SM2 sm2 = SM2.Instance();
AsymmetricCipherKeyPair key = null;
while (true){
key=sm2.ecc_key_pair_generator.generateKeyPair();
if(((ECPrivateKeyParameters) key.getPrivate()).getD().toByteArray().length==32){
break;
}
}
ECPrivateKeyParameters ecpriv = (ECPrivateKeyParameters) key.getPrivate();
ECPublicKeyParameters ecpub = (ECPublicKeyParameters) key.getPublic();
BigInteger privateKey = ecpriv.getD();
ECPoint publicKey = ecpub.getQ();
SM2KeyVO sm2KeyVO = new SM2KeyVO();
sm2KeyVO.setPublicKey(publicKey);
sm2KeyVO.setPrivateKey(privateKey);
//System.out.println("公鑰: " + Util.byteToHex(publicKey.getEncoded()));
//System.out.println("私鑰: " + Util.byteToHex(privateKey.toByteArray()));
return sm2KeyVO;
}
//數(shù)據(jù)加密
public static String encrypt(byte[] publicKey, byte[] data) throws IOException
{
if (publicKey == null || publicKey.length == 0)
{
return null;
}
if (data == null || data.length == 0)
{
return null;
}
byte[] source = new byte[data.length];
//將數(shù)組data復制到source
System.arraycopy(data, 0, source, 0, data.length);
Cipher cipher = new Cipher();
SM2 sm2 = SM2.Instance();//new自建類,， SM2 sm2 = new SM2();
ECPoint userKey = sm2.ecc_curve.decodePoint(publicKey);
ECPoint c1 = cipher.Init_enc(sm2, userKey);
cipher.Encrypt(source);
byte[] c3 = new byte[32];
cipher.Dofinal(c3);
// System.out.println("C1 " + Util.byteToHex(c1.getEncoded()));
// System.out.println("C2 " + Util.byteToHex(source));
//System.out.println("C3 " + Util.byteToHex(c3));
//C1 C2 C3拼裝成加密字串
// C1 | C2 | C3
//return Util.byteToHex(c1.getEncoded()) + Util.byteToHex(source) + Util.byteToHex(c3);
// C1 | C3 | C2
return Util.byteToHex(c1.getEncoded()) + Util.byteToHex(c3) + Util.byteToHex(source);
}
//數(shù)據(jù)解密
public static byte[] decrypt(byte[] privateKey, byte[] encryptedData) throws IOException
{
if (privateKey == null || privateKey.length == 0)
{
return null;
}
if (encryptedData == null || encryptedData.length == 0)
{
return null;
}
//加密字節(jié)數(shù)組轉(zhuǎn)換為十六進制的字符串 長度變?yōu)閑ncryptedData.length * 2
String data = Util.byteToHex(encryptedData);
/***分解加密字串 C1 | C2 | C3
* （C1 = C1標志位2位 + C1實體部分128位 = 130）
* （C3 = C3實體部分64位 = 64）
* （C2 = encryptedData.length * 2 - C1長度 - C2長度）
byte[] c1Bytes = Util.hexToByte(data.substring(0,130));
int c2Len = encryptedData.length - 97;
byte[] c2 = Util.hexToByte(data.substring(130,130 + 2 * c2Len));
byte[] c3 = Util.hexToByte(data.substring(130 + 2 * c2Len,194 + 2 * c2Len));
*/
/***分解加密字串 C1 | C3 | C2
* （C1 = C1標志位2位 + C1實體部分128位 = 130）
* （C3 = C3實體部分64位 = 64）
* （C2 = encryptedData.length * 2 - C1長度 - C2長度）
*/
byte[] c1Bytes = Util.hexToByte(data.substring(0,130));
int c2Len = encryptedData.length - 97;
byte[] c3 = Util.hexToByte(data.substring(130,130 + 64));
byte[] c2 = Util.hexToByte(data.substring(194,194 + 2 * c2Len));
SM2 sm2 = SM2.Instance();
BigInteger userD = new BigInteger(1, privateKey);
//通過C1實體字節(jié)來生成ECPoint
ECPoint c1 = sm2.ecc_curve.decodePoint(c1Bytes);
Cipher cipher = new Cipher();
cipher.Init_dec(userD, c1);
cipher.Decrypt(c2);
cipher.Dofinal(c3);
//返回解密結果
return c2;
}
}SM2曲線算法工具類
package cn.test.encrypt.utils.sm2;
import cn.test.encrypt.utils.Util;
import org.bouncycastle.crypto.AsymmetricCipherKeyPair;
import org.bouncycastle.crypto.digests.SM3Digest;
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.math.ec.ECCurve;
import org.bouncycastle.math.ec.ECFieldElement;
import org.bouncycastle.math.ec.ECFieldElement.Fp;
import org.bouncycastle.math.ec.ECPoint;
import java.math.BigInteger;
import java.security.SecureRandom;
public class SM2Factory {
/*-----------------------國密算法相關參數(shù)begin-----------
* ------------------*/
//A 第一系數(shù)
private static final BigInteger a = new BigInteger("fffffffeffffffffffffffffffffffffffffffff00000000fffffffffffffffc",16);
//B 第二系數(shù)
private static final BigInteger b = new BigInteger("28e9fa9e9d9f5e344d5a9e4bcf6509a7f39789f515ab8f92ddbcbd414d940e93",16);
//曲線X系數(shù)
private static final BigInteger gx = new BigInteger("32c4ae2c1f1981195f9904466a39c9948fe30bbff2660be1715a4589334c74c7",16);
//曲線Y系數(shù)
private static final BigInteger gy = new BigInteger("bc3736a2f4f6779c59bdcee36b692153d0a9877cc62a474002df32e52139f0a0",16);
//生產(chǎn)者順序系數(shù)
private static final BigInteger n = new BigInteger("fffffffeffffffffffffffffffffffff7203df6b21c6052b53bbf40939d54123",16);
//素數(shù)
private static final BigInteger p = new BigInteger("fffffffeffffffffffffffffffffffffffffffff00000000ffffffffffffffff",16);
//因子系數(shù) 1
private static final int h = 1;
/*-----------------------國密算法相關參數(shù)end-----------------------------*/
//一些必要類
public final ECFieldElement ecc_gx_fieldelement;
public final ECFieldElement ecc_gy_fieldelement;
public final ECCurve ecc_curve;
public final ECPoint ecc_point_g;
public final ECDomainParameters ecc_bc_spec;
public final ECKeyPairGenerator ecc_key_pair_generator;
/**
* 初始化方法
* @return
*/
public static SM2Factory getInstance(){
return new SM2Factory();
}
public SM2Factory() {
this.ecc_gx_fieldelement = new Fp(this.p,this.gx);
this.ecc_gy_fieldelement = new Fp(this.p, this.gy);
this.ecc_curve = new ECCurve.Fp(this.p, this.a, this.b);
this.ecc_point_g = new ECPoint.Fp(this.ecc_curve, this.ecc_gx_fieldelement,this.ecc_gy_fieldelement);
this.ecc_bc_spec = new ECDomainParameters(this.ecc_curve, this.ecc_point_g, this.n);
ECKeyGenerationParameters ecc_ecgenparam;
ecc_ecgenparam = new ECKeyGenerationParameters(this.ecc_bc_spec, new SecureRandom());
this.ecc_key_pair_generator = new ECKeyPairGenerator();
this.ecc_key_pair_generator.init(ecc_ecgenparam);
}
/**
* 根據(jù)私鑰、曲線參數(shù)計算Z
* @param userId
* @param userKey
* @return
*/
public byte[] sm2GetZ(byte[] userId, ECPoint userKey){
SM3Digest sm3 = new SM3Digest();
int len = userId.length * 8;
sm3.update((byte) (len >> 8 & 0xFF));
sm3.update((byte) (len & 0xFF));
sm3.update(userId, 0, userId.length);
byte[] p = Util.byteConvert32Bytes(this.a);
sm3.update(p, 0, p.length);
p = Util.byteConvert32Bytes(this.b);
sm3.update(p, 0, p.length);
p = Util.byteConvert32Bytes(this.gx);
sm3.update(p, 0, p.length);
p = Util.byteConvert32Bytes(this.gy);
sm3.update(p, 0, p.length);
p = Util.byteConvert32Bytes(userKey.normalize().getXCoord().toBigInteger());
sm3.update(p, 0, p.length);
p = Util.byteConvert32Bytes(userKey.normalize().getYCoord().toBigInteger());
sm3.update(p, 0, p.length);
byte[] md = new byte[sm3.getDigestSize()];
sm3.doFinal(md, 0);
return md;
}
/**
* 簽名相關值計算
* @param md
* @param userD
* @param userKey
* @param sm2Result
*/
public void sm2Sign(byte[] md, BigInteger userD, ECPoint userKey, SM2Result sm2Result) {
BigInteger e = new BigInteger(1, md);
BigInteger k = null;
ECPoint kp = null;
BigInteger r = null;
BigInteger s = null;
do {
do {
// 正式環(huán)境
AsymmetricCipherKeyPair keypair = ecc_key_pair_generator.generateKeyPair();
ECPrivateKeyParameters ecpriv = (ECPrivateKeyParameters) keypair.getPrivate();
ECPublicKeyParameters ecpub = (ECPublicKeyParameters) keypair.getPublic();
k = ecpriv.getD();
kp = ecpub.getQ();
//System.out.println("BigInteger:" + k + "\nECPoint:" + kp);
//System.out.println("計算曲線點X1: "+ kp.getXCoord().toBigInteger().toString(16));
//System.out.println("計算曲線點Y1: "+ kp.getYCoord().toBigInteger().toString(16));
//System.out.println("");
// r
r = e.add(kp.getXCoord().toBigInteger());
r = r.mod(this.n);
} while (r.equals(BigInteger.ZERO) || r.add(k).equals(this.n)||r.toString(16).length()!=64);
// (1 + dA)~-1
BigInteger da_1 = userD.add(BigInteger.ONE);
da_1 = da_1.modInverse(this.n);
// s
s = r.multiply(userD);
s = k.subtract(s).mod(this.n);
s = da_1.multiply(s).mod(this.n);
} while (s.equals(BigInteger.ZERO)||(s.toString(16).length()!=64));
sm2Result.r = r;
sm2Result.s = s;
}
/**
* 驗簽
* @param md sm3摘要
* @param userKey 根據(jù)公鑰decode一個ecpoint對象
* @param r 沒有特殊含義
* @param s 沒有特殊含義
* @param sm2Result 接收參數(shù)的對象
*/
public void sm2Verify(byte md[], ECPoint userKey, BigInteger r,
BigInteger s, SM2Result sm2Result) {
sm2Result.R = null;
BigInteger e = new BigInteger(1, md);
BigInteger t = r.add(s).mod(this.n);
if (t.equals(BigInteger.ZERO)) {
return;
} else {
ECPoint x1y1 = ecc_point_g.multiply(sm2Result.s);
//System.out.println("計算曲線點X0: "+ x1y1.normalize().getXCoord().toBigInteger().toString(16));
//System.out.println("計算曲線點Y0: "+ x1y1.normalize().getYCoord().toBigInteger().toString(16));
//System.out.println("");
x1y1 = x1y1.add(userKey.multiply(t));
//System.out.println("計算曲線點X1: "+ x1y1.normalize().getXCoord().toBigInteger().toString(16));
//System.out.println("計算曲線點Y1: "+ x1y1.normalize().getYCoord().toBigInteger().toString(16));
//System.out.println("");
sm2Result.R = e.add(x1y1.normalize().getXCoord().toBigInteger()).mod(this.n);
//System.out.println("R: " + sm2Result.R.toString(16));
return;
}
}
}
工具類
package cn.test.encrypt.utils;
import java.math.BigInteger;
public class Util {
/**
* 整形轉(zhuǎn)換成網(wǎng)絡傳輸?shù)淖止?jié)流（字節(jié)數(shù)組）型數(shù)據(jù)
*
* @param num 一個整型數(shù)據(jù)
* @return 4個字節(jié)的自己數(shù)組
*/
public static byte[] intToBytes(int num) {
byte[] bytes = new byte[4];
bytes[0] = (byte) (0xff & (num >> 0));
bytes[1] = (byte) (0xff & (num >> 8));
bytes[2] = (byte) (0xff & (num >> 16));
bytes[3] = (byte) (0xff & (num >> 24));
return bytes;
}
/**
* 四個字節(jié)的字節(jié)數(shù)據(jù)轉(zhuǎn)換成一個整形數(shù)據(jù)
*
* @param bytes 4個字節(jié)的字節(jié)數(shù)組
* @return 一個整型數(shù)據(jù)
*/
public static int byteToInt(byte[] bytes) {
int num = 0;
int temp;
temp = (0x000000ff & (bytes[0])) << 0;
num = num | temp;
temp = (0x000000ff & (bytes[1])) << 8;
num = num | temp;
temp = (0x000000ff & (bytes[2])) << 16;
num = num | temp;
temp = (0x000000ff & (bytes[3])) << 24;
num = num | temp;
return num;
}
/**
* 長整形轉(zhuǎn)換成網(wǎng)絡傳輸?shù)淖止?jié)流（字節(jié)數(shù)組）型數(shù)據(jù)
*
* @param num 一個長整型數(shù)據(jù)
* @return 4個字節(jié)的自己數(shù)組
*/
public static byte[] longToBytes(long num) {
byte[] bytes = new byte[8];
for (int i = 0; i < 8; i++) {
bytes[i] = (byte) (0xff & (num >> (i * 8)));
}
return bytes;
}
/**
* 大數(shù)字轉(zhuǎn)換字節(jié)流（字節(jié)數(shù)組）型數(shù)據(jù)
*
* @param n
* @return
*/
public static byte[] byteConvert32Bytes(BigInteger n) {
byte tmpd[] = (byte[]) null;
if (n == null) {
return null;
}
if (n.toByteArray().length == 33) {
tmpd = new byte[32];
System.arraycopy(n.toByteArray(), 1, tmpd, 0, 32);
} else if (n.toByteArray().length == 32) {
tmpd = n.toByteArray();
} else {
tmpd = new byte[32];
for (int i = 0; i < 32 - n.toByteArray().length; i++) {
tmpd[i] = 0;
}
System.arraycopy(n.toByteArray(), 0, tmpd, 32 - n.toByteArray().length, n.toByteArray().length);
}
return tmpd;
}
/**
* 換字節(jié)流（字節(jié)數(shù)組）型數(shù)據(jù)轉(zhuǎn)大數(shù)字
*
* @param b
* @return
*/
public static BigInteger byteConvertInteger(byte[] b) {
if (b[0] < 0) {
byte[] temp = new byte[b.length + 1];
temp[0] = 0;
System.arraycopy(b, 0, temp, 1, b.length);
return new BigInteger(temp);
}
return new BigInteger(b);
}
/**
* 根據(jù)字節(jié)數(shù)組獲得值(十六進制數(shù)字)
*
* @param bytes
* @return
*/
public static String getHexString(byte[] bytes) {
return getHexString(bytes, true);
}
/**
* 根據(jù)字節(jié)數(shù)組獲得值(十六進制數(shù)字)
*
* @param bytes
* @param upperCase
* @return
*/
public static String getHexString(byte[] bytes, boolean upperCase) {
String ret = "";
for (int i = 0; i < bytes.length; i++) {
ret += Integer.toString((bytes[i] & 0xff) + 0x100, 16).substring(1);
}
return upperCase ? ret.toUpperCase() : ret;
}
/**
* 打印十六進制字符串
*
* @param bytes
*/
public static void printHexString(byte[] bytes) {
for (int i = 0; i < bytes.length; i++) {
String hex = Integer.toHexString(bytes[i] & 0xFF);
if (hex.length() == 1) {
hex = '0' + hex;
}
System.out.print("0x" + hex.toUpperCase() + ",");
}
System.out.println("");
}
/**
* Convert hex string to byte[]
*
* @param hexString the hex string
* @return byte[]
*/
public static byte[] hexStringToBytes(String hexString) {
if (hexString == null || hexString.equals("")) {
return null;
}
hexString = hexString.toUpperCase();
int length = hexString.length() / 2;
char[] hexChars = hexString.toCharArray();
byte[] d = new byte[length];
for (int i = 0; i < length; i++) {
int pos = i * 2;
d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));
}
return d;
}
/**
* Convert char to byte
*
* @param c char
* @return byte
*/
public static byte charToByte(char c) {
return (byte) "0123456789ABCDEF".indexOf(c);
}
/**
* 用于建立十六進制字符的輸出的小寫字符數(shù)組
*/
private static final char[] DIGITS_LOWER = {'0', '1', '2', '3', '4', '5',
'6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
/**
* 用于建立十六進制字符的輸出的大寫字符數(shù)組
*/
private static final char[] DIGITS_UPPER = {'0', '1', '2', '3', '4', '5',
'6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
/**
* 將字節(jié)數(shù)組轉(zhuǎn)換為十六進制字符數(shù)組
*
* @param data byte[]
* @return 十六進制char[]
*/
public static char[] encodeHex(byte[] data) {
return encodeHex(data, true);
}
/**
* 將字節(jié)數(shù)組轉(zhuǎn)換為十六進制字符數(shù)組
*
* @param data byte[]
* @param toLowerCase <code>true</code> 傳換成小寫格式 ， <code>false</code> 傳換成大寫格式
* @return 十六進制char[]
*/
public static char[] encodeHex(byte[] data, boolean toLowerCase) {
return encodeHex(data, toLowerCase ? DIGITS_LOWER : DIGITS_UPPER);
}
/**
* 將字節(jié)數(shù)組轉(zhuǎn)換為十六進制字符數(shù)組
*
* @param data byte[]
* @param toDigits 用于控制輸出的char[]
* @return 十六進制char[]
*/
protected static char[] encodeHex(byte[] data, char[] toDigits) {
int l = data.length;
char[] out = new char[l << 1];
// two characters form the hex value.
for (int i = 0, j = 0; i < l; i++) {
out[j++] = toDigits[(0xF0 & data[i]) >>> 4];
out[j++] = toDigits[0x0F & data[i]];
}
return out;
}
/**
* 將字節(jié)數(shù)組轉(zhuǎn)換為十六進制字符串
*
* @param data byte[]
* @return 十六進制String
*/
public static String encodeHexString(byte[] data) {
return encodeHexString(data, true);
}
/**
* 將字節(jié)數(shù)組轉(zhuǎn)換為十六進制字符串
*
* @param data byte[]
* @param toLowerCase <code>true</code> 傳換成小寫格式 ， <code>false</code> 傳換成大寫格式
* @return 十六進制String
*/
public static String encodeHexString(byte[] data, boolean toLowerCase) {
return encodeHexString(data, toLowerCase ? DIGITS_LOWER : DIGITS_UPPER);
}
/**
* 將字節(jié)數(shù)組轉(zhuǎn)換為十六進制字符串
*
* @param data byte[]
* @param toDigits 用于控制輸出的char[]
* @return 十六進制String
*/
protected static String encodeHexString(byte[] data, char[] toDigits) {
return new String(encodeHex(data, toDigits));
}
/**
* 將十六進制字符數(shù)組轉(zhuǎn)換為字節(jié)數(shù)組
*
* @param data 十六進制char[]
* @return byte[]
* @throws RuntimeException 如果源十六進制字符數(shù)組是一個奇怪的長度，將拋出運行時異常
*/
public static byte[] decodeHex(char[] data) {
int len = data.length;
if ((len & 0x01) != 0) {
throw new RuntimeException("Odd number of characters.");
}
byte[] out = new byte[len >> 1];
// two characters form the hex value.
for (int i = 0, j = 0; j < len; i++) {
int f = toDigit(data[j], j) << 4;
j++;
f = f | toDigit(data[j], j);
j++;
out[i] = (byte) (f & 0xFF);
}
return out;
}
/**
* 將十六進制字符轉(zhuǎn)換成一個整數(shù)
*
* @param ch 十六進制char
* @param index 十六進制字符在字符數(shù)組中的位置
* @return 一個整數(shù)
* @throws RuntimeException 當ch不是一個合法的十六進制字符時，拋出運行時異常
*/
protected static int toDigit(char ch, int index) {
int digit = Character.digit(ch, 16);
if (digit == -1) {
throw new RuntimeException("Illegal hexadecimal character " + ch
+ " at index " + index);
}
return digit;
}
/**
* 數(shù)字字符串轉(zhuǎn)ASCII碼字符串
*
* @param String 字符串
* @return ASCII字符串
*/
public static String StringToAsciiString(String content) {
String result = "";
int max = content.length();
for (int i = 0; i < max; i++) {
char c = content.charAt(i);
String b = Integer.toHexString(c);
result = result + b;
}
return result;
}
/**
* 十六進制轉(zhuǎn)字符串
*
* @param hexString 十六進制字符串
* @param encodeType 編碼類型4：Unicode，2：普通編碼
* @return 字符串
*/
public static String hexStringToString(String hexString, int encodeType) {
String result = "";
int max = hexString.length() / encodeType;
for (int i = 0; i < max; i++) {
char c = (char) hexStringToAlgorism(hexString
.substring(i * encodeType, (i + 1) * encodeType));
result += c;
}
return result;
}
/**
* 十六進制字符串裝十進制
*
* @param hex 十六進制字符串
* @return 十進制數(shù)值
*/
public static int hexStringToAlgorism(String hex) {
hex = hex.toUpperCase();
int max = hex.length();
int result = 0;
for (int i = max; i > 0; i--) {
char c = hex.charAt(i - 1);
int algorism = 0;
if (c >= '0' && c <= '9') {
algorism = c - '0';
} else {
algorism = c - 55;
}
result += Math.pow(16, max - i) * algorism;
}
return result;
}
/**
* 十六轉(zhuǎn)二進制
*
* @param hex 十六進制字符串
* @return 二進制字符串
*/
public static String hexStringToBinary(String hex) {
hex = hex.toUpperCase();
String result = "";
int max = hex.length();
for (int i = 0; i < max; i++) {
char c = hex.charAt(i);
switch (c) {
case '0':
result += "0000";
break;
case '1':
result += "0001";
break;
case '2':
result += "0010";
break;
case '3':
result += "0011";
break;
case '4':
result += "0100";
break;
case '5':
result += "0101";
break;
case '6':
result += "0110";
break;
case '7':
result += "0111";
break;
case '8':
result += "1000";
break;
case '9':
result += "1001";
break;
case 'A':
result += "1010";
break;
case 'B':
result += "1011";
break;
case 'C':
result += "1100";
break;
case 'D':
result += "1101";
break;
case 'E':
result += "1110";
break;
case 'F':
result += "1111";
break;
}
}
return result;
}
/**
* ASCII碼字符串轉(zhuǎn)數(shù)字字符串
*
* @param String ASCII字符串
* @return 字符串
*/
public static String AsciiStringToString(String content) {
String result = "";
int length = content.length() / 2;
for (int i = 0; i < length; i++) {
String c = content.substring(i * 2, i * 2 + 2);
int a = hexStringToAlgorism(c);
char b = (char) a;
String d = String.valueOf(b);
result += d;
}
return result;
}
/**
* 將十進制轉(zhuǎn)換為指定長度的十六進制字符串
*
* @param algorism int 十進制數(shù)字
* @param maxLength int 轉(zhuǎn)換后的十六進制字符串長度
* @return String 轉(zhuǎn)換后的十六進制字符串
*/
public static String algorismToHexString(int algorism, int maxLength) {
String result = "";
result = Integer.toHexString(algorism);
if (result.length() % 2 == 1) {
result = "0" + result;
}
return patchHexString(result.toUpperCase(), maxLength);
}
/**
* 字節(jié)數(shù)組轉(zhuǎn)為普通字符串（ASCII對應的字符）
*
* @param bytearray byte[]
* @return String
*/
public static String byteToString(byte[] bytearray) {
String result = "";
char temp;
int length = bytearray.length;
for (int i = 0; i < length; i++) {
temp = (char) bytearray[i];
result += temp;
}
return result;
}
/**
* 二進制字符串轉(zhuǎn)十進制
*
* @param binary 二進制字符串
* @return 十進制數(shù)值
*/
public static int binaryToAlgorism(String binary) {
int max = binary.length();
int result = 0;
for (int i = max; i > 0; i--) {
char c = binary.charAt(i - 1);
int algorism = c - '0';
result += Math.pow(2, max - i) * algorism;
}
return result;
}
/**
* 十進制轉(zhuǎn)換為十六進制字符串
*
* @param algorism int 十進制的數(shù)字
* @return String 對應的十六進制字符串
*/
public static String algorismToHEXString(int algorism) {
String result = "";
result = Integer.toHexString(algorism);
if (result.length() % 2 == 1) {
result = "0" + result;
}
result = result.toUpperCase();
return result;
}
/**
* HEX字符串前補0，主要用于長度位數(shù)不足。
*
* @param str String 需要補充長度的十六進制字符串
* @param maxLength int 補充后十六進制字符串的長度
* @return 補充結果
*/
static public String patchHexString(String str, int maxLength) {
String temp = "";
for (int i = 0; i < maxLength - str.length(); i++) {
temp = "0" + temp;
}
str = (temp + str).substring(0, maxLength);
return str;
}
/**
* 將一個字符串轉(zhuǎn)換為int
*
* @param s String 要轉(zhuǎn)換的字符串
* @param defaultInt int 如果出現(xiàn)異常,默認返回的數(shù)字
* @param radix int 要轉(zhuǎn)換的字符串是什么進制的,如16 8 10.
* @return int 轉(zhuǎn)換后的數(shù)字
*/
public static int parseToInt(String s, int defaultInt, int radix) {
int i = 0;
try {
i = Integer.parseInt(s, radix);
} catch (NumberFormatException ex) {
i = defaultInt;
}
return i;
}
/**
* 將一個十進制形式的數(shù)字字符串轉(zhuǎn)換為int
*
* @param s String 要轉(zhuǎn)換的字符串
* @param defaultInt int 如果出現(xiàn)異常,默認返回的數(shù)字
* @return int 轉(zhuǎn)換后的數(shù)字
*/
public static int parseToInt(String s, int defaultInt) {
int i = 0;
try {
i = Integer.parseInt(s);
} catch (NumberFormatException ex) {
i = defaultInt;
}
return i;
}
/**
* 十六進制串轉(zhuǎn)化為byte數(shù)組
*
* @return the array of byte
*/
public static byte[] hexToByte(String hex)
throws IllegalArgumentException {
if (hex.length() % 2 != 0) {
throw new IllegalArgumentException();
}
char[] arr = hex.toCharArray();
byte[] b = new byte[hex.length() / 2];
for (int i = 0, j = 0, l = hex.length(); i < l; i++, j++) {
String swap = "" + arr[i++] + arr[i];
int byteint = Integer.parseInt(swap, 16) & 0xFF;
b[j] = new Integer(byteint).byteValue();
}
return b;
}
/**
* 字節(jié)數(shù)組轉(zhuǎn)換為十六進制字符串
*
* @param b byte[] 需要轉(zhuǎn)換的字節(jié)數(shù)組
* @return String 十六進制字符串
*/
public static String byteToHex(byte b[]) {
if (b == null) {
throw new IllegalArgumentException(
"Argument b ( byte array ) is null! ");
}
String hs = "";
String stmp = "";
for (int n = 0; n < b.length; n++) {
stmp = Integer.toHexString(b[n] & 0xff);
if (stmp.length() == 1) {
hs = hs + "0" + stmp;
} else {
hs = hs + stmp;
}
}
return hs.toLowerCase();
//return hs.toUpperCase();
}
public static byte[] subByte(byte[] input, int startIndex, int length) {
byte[] bt = new byte[length];
for (int i = 0; i < length; i++) {
bt[i] = input[i + startIndex];
}
return bt;
}
}
SM2對象
package cn.test.encrypt.utils.sm2;
import cn.test.encrypt.utils.Util;
import cn.test.encrypt.test.SecurityTestAll;
import org.bouncycastle.math.ec.ECPoint;
import java.math.BigInteger;
public class SM2KeyVO {
BigInteger privateKey ;
ECPoint publicKey ;
public BigInteger getPrivateKey() {
return privateKey;
}
public void setPrivateKey(BigInteger privateKey) {
this.privateKey = privateKey;
}
public ECPoint getPublicKey() {
return publicKey;
}
public void setPublicKey(ECPoint publicKey) {
this.publicKey = publicKey;
}
//HardPubKey:3059301306072A8648CE3D020106082A811CCF5501822D03420004+X+Y
//SoftPubKey:04+X+Y
public String getPubHexInSoft(){
return Util.byteToHex(publicKey.getEncoded(true));
//System.out.println("公鑰: " + );
}
public String getPubHexInHard(){
return SecurityTestAll.SM2PubHardKeyHead +Util.byteToHex(publicKey.getEncoded(true));
}
public String getPriHexInSoft(){
return Util.byteToHex(privateKey.toByteArray());
}
}
測試Demo
public static void main(String[] args) {
SM2KeyVO initKeyVO = SM2EncDecUtils.generateKeyPair();
System.out.println("初始公鑰為: "+initKeyVO.getPubHexInSoft());
System.out.println("初始私鑰為: "+initKeyVO.getPriHexInSoft());
}輸出結果：
?2、數(shù)據(jù)加解密
簡單業(yè)務描述：使用初始公鑰加密工作公鑰，使用初始私鑰解密加密后公鑰；
Demo
public static void main(String[] args) throws IOException {
//生成初始秘鑰
SM2KeyVO initKeyVO = SM2EncDecUtils.generateKeyPair();
String initPubKey = initKeyVO.getPubHexInSoft();
String initPriKey = initKeyVO.getPriHexInSoft();
System.out.println("初始公鑰為: " + initPubKey);
System.out.println("初始私鑰為: " + initPriKey);
//生成工作秘鑰
SM2KeyVO serverKey = SM2EncDecUtils.generateKeyPair();
String serverPubKey = serverKey.getPubHexInSoft();
String serverPriKey = serverKey.getPriHexInSoft();
System.out.println("服務端公鑰為: " + serverPubKey);
System.out.println("服務端私鑰為: " + serverPriKey);
//使用初始公鑰加密服務端公鑰 注意格式字節(jié)數(shù)組
String encryptServerPubKey = SM2EncDecUtils.encrypt(Convert.hexToBytes(initPubKey), serverPubKey.getBytes());
System.out.println("加密后公鑰："+encryptServerPubKey);
//使用初始私鑰解密服務端公鑰 注意格式
byte[] decrypt = SM2EncDecUtils.decrypt(Convert.hexToBytes(initPriKey), Convert.hexToBytes(encryptServerPubKey));
System.out.println("解密后服務端公鑰："+new String(decrypt));
if (serverPubKey.equals(new String(decrypt)))
System.out.println("——————————解密成功——————————");
}結果：
文章來源：http://www.zghlxwxcb.cn/news/detail-438566.html
?至此，SM2的公私鑰生成以及加解密就完成了，下一期內(nèi)容為生成Sign以及驗證。文章來源地址http://www.zghlxwxcb.cn/news/detail-438566.html
到了這里，關于國密：生成SM2秘鑰、加解密及加驗簽的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關文章，希望大家以后多多支持TOY模板網(wǎng)！
