From f693a7a1205a7f56685eed4048a4d6ec7c911048 Mon Sep 17 00:00:00 2001 From: ghy Date: Tue, 9 Mar 2021 22:00:57 +0800 Subject: [PATCH 1/3] =?UTF-8?q?=E4=BD=BF=E7=94=A8mapDB=E6=8C=81=E4=B9=85?= =?UTF-8?q?=E5=8C=96identity(50%)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- pom.xml | 8 ++ .../java/minsecurity/identity/Identity.java | 21 +++- .../identity/persist/IdentitySerializer.java | 97 +++++++++++++++++++ .../minsecurity/identity/TestIdentity.java | 4 +- .../minsecurity/identity/TestPersist.java | 68 +++++++++++++ 5 files changed, 194 insertions(+), 4 deletions(-) create mode 100644 src/main/java/minsecurity/identity/persist/IdentitySerializer.java create mode 100644 src/test/java/minsecurity/identity/TestPersist.java diff --git a/pom.xml b/pom.xml index 8fa4433..115f598 100644 --- a/pom.xml +++ b/pom.xml @@ -76,6 +76,14 @@ + + + + org.mapdb + mapdb + 3.0.8 + + \ No newline at end of file diff --git a/src/main/java/minsecurity/identity/Identity.java b/src/main/java/minsecurity/identity/Identity.java index b16efd0..f678dd4 100644 --- a/src/main/java/minsecurity/identity/Identity.java +++ b/src/main/java/minsecurity/identity/Identity.java @@ -20,6 +20,7 @@ import javax.crypto.BadPaddingException; import javax.crypto.IllegalBlockSizeException; import javax.crypto.NoSuchPaddingException; import java.io.IOException; +import java.io.Serializable; import java.security.InvalidAlgorithmParameterException; import java.security.InvalidKeyException; import java.security.NoSuchAlgorithmException; @@ -43,10 +44,12 @@ public class Identity { private PublicKeyInterface Pubkey; private String Passwd; private Certificate Cert; + private boolean IsDefault; public Identity(String name, KeyParam keyParam, PrivateKeyInterface prikey, byte[] prikeyRawByte, - PublicKeyInterface pubkey, String passwd, Certificate cert) { + PublicKeyInterface pubkey, String passwd, Certificate cert, + boolean isDefault) { Name = name; KeyParam = keyParam; Prikey = prikey; @@ -54,6 +57,7 @@ public class Identity { Pubkey = pubkey; Passwd = passwd; Cert = cert; + IsDefault = isDefault; } @@ -240,16 +244,27 @@ public class Identity { Cert = cert; } + public boolean isDefault() { + return IsDefault; + } + + public void setDefault(boolean aDefault) { + IsDefault = aDefault; + } + @Override public String toString() { return "Identity{" + "Name='" + Name + '\'' + - ", KeyParam=" + KeyParam + - ", Prikey=" + Prikey + + ", KeyParam.signAlgo=" + KeyParam.SignatureAlgorithm + + ", KeyParam.pubAlgo=" + KeyParam.PublicKeyAlgorithm + + ", Prikey=" + ByteUtils.toHexString(Prikey.getBytes()) + + ", pubKey=" + ByteUtils.toHexString(Pubkey.getBytes()) + ", PrikeyRawByte=" + (PrikeyRawByte == null ? "null":ByteUtils.toHexString(PrikeyRawByte)) + ", Pubkey=" + Pubkey + ", Passwd='" + Passwd + '\'' + ", Cert=" + Cert + + ", isDefault=" + IsDefault + '}'; } } diff --git a/src/main/java/minsecurity/identity/persist/IdentitySerializer.java b/src/main/java/minsecurity/identity/persist/IdentitySerializer.java new file mode 100644 index 0000000..fea81d4 --- /dev/null +++ b/src/main/java/minsecurity/identity/persist/IdentitySerializer.java @@ -0,0 +1,97 @@ +package minsecurity.identity.persist; + +import com.fasterxml.jackson.databind.ObjectMapper; +import minsecurity.Common; +import minsecurity.certificate.cert.CertException; +import minsecurity.certificate.cert.CertUtils; +import minsecurity.certificate.cert.Certificate; +import minsecurity.crypto.sm2.SM2PrivateKey; +import minsecurity.crypto.sm2.SM2PublicKey; +import minsecurity.identity.Identity; +import minsecurity.identity.KeyParam; +import org.bouncycastle.pqc.math.linearalgebra.ByteUtils; +import org.jetbrains.annotations.NotNull; +import org.mapdb.DataInput2; +import org.mapdb.DataOutput2; +import org.mapdb.Serializer; + +import javax.crypto.BadPaddingException; +import javax.crypto.IllegalBlockSizeException; +import javax.crypto.NoSuchPaddingException; +import java.io.IOException; +import java.security.InvalidAlgorithmParameterException; +import java.security.InvalidKeyException; +import java.security.NoSuchAlgorithmException; +import java.security.NoSuchProviderException; + +/* + * @Author: hongyu guo + * @Description: mapDB需要自定义序列化、反序列化方法 + * @Version: 1.0.0 + * @Date: 20:50 2021/03/09 + * @Copyright: MIN-Group；国家重大科技基础设施——未来网络北大实验室；深圳市信息论与未来网络重点实验室 + */ +public class IdentitySerializer implements Serializer { + + + @Override + public void serialize(@NotNull DataOutput2 dataOutput2, @NotNull Identity identity) throws IOException { + String name = identity.getName(); + String pub = ByteUtils.toHexString(identity.getPubkey().getBytes()); + String priv = ByteUtils.toHexString(identity.getPrikey().getBytes()); + int pubAlgo = identity.getKeyParam().PublicKeyAlgorithm; + int signAlgo = identity.getKeyParam().SignatureAlgorithm; + String passwd = identity.getPasswd(); + String cert = ""; + try { + cert = CertUtils.toPem(identity.getCert(),null, Common.SM4CBC); + } catch (CertException | NoSuchPaddingException | InvalidAlgorithmParameterException | + NoSuchAlgorithmException | IllegalBlockSizeException | BadPaddingException | + NoSuchProviderException | InvalidKeyException e) { + e.printStackTrace(); + } + boolean isDefault = identity.isDefault(); + String prikeyRawByte = identity.getPrikeyRawByte()== null ? + "" :ByteUtils.toHexString(identity.getPrikeyRawByte()); + + + dataOutput2.writeUTF(name); + dataOutput2.writeUTF(pub); + dataOutput2.writeUTF(priv); + dataOutput2.writeInt(pubAlgo); + dataOutput2.writeInt(signAlgo); + dataOutput2.writeUTF(passwd); + dataOutput2.writeUTF(cert); + dataOutput2.writeBoolean(isDefault); + dataOutput2.writeUTF(prikeyRawByte); + } + + @Override + public Identity deserialize(@NotNull DataInput2 dataInput2, int i) throws IOException { + String name = dataInput2.readUTF(); + byte[] pub = ByteUtils.fromHexString(dataInput2.readUTF()); + byte[] priv = ByteUtils.fromHexString(dataInput2.readUTF()); + int pubAlgo = dataInput2.readInt(); + int signAlgo = dataInput2.readInt(); + String passwd = dataInput2.readUTF(); + String certString = dataInput2.readUTF(); + Certificate certificate = null; + try { + certificate = CertUtils.fromPem(certString, null, Common.SM4CBC); + } catch (CertException | BadPaddingException | NoSuchPaddingException | + InvalidAlgorithmParameterException | NoSuchAlgorithmException | + IllegalBlockSizeException | NoSuchProviderException | InvalidKeyException e) { + e.printStackTrace(); + } + boolean isDefault = dataInput2.readBoolean(); + byte[] prikeyRawByte = dataInput2.readUTF().equals("") ? + null : ByteUtils.fromHexString(dataInput2.readUTF()); + KeyParam keyParam = new KeyParam(pubAlgo, signAlgo); + SM2PrivateKey sm2PrivateKey = new SM2PrivateKey(); + sm2PrivateKey.setBytes(priv); + SM2PublicKey sm2PublicKey = new SM2PublicKey(); + sm2PublicKey.setBytes(pub); + return new Identity(name,keyParam, sm2PrivateKey,prikeyRawByte, sm2PublicKey, passwd, certificate, isDefault); + } + +} diff --git a/src/test/java/minsecurity/identity/TestIdentity.java b/src/test/java/minsecurity/identity/TestIdentity.java index d8df6ae..45394bc 100644 --- a/src/test/java/minsecurity/identity/TestIdentity.java +++ b/src/test/java/minsecurity/identity/TestIdentity.java @@ -41,7 +41,7 @@ public class TestIdentity { SM2PrivateKey sm2PrivateKey = new SM2PrivateKey(d); SM2PublicKey sm2PublicKey = new SM2PublicKey(x,y); KeyParam keyParam = new KeyParam(Common.SM2, Common.SM3withSM2); - Identity identity = new Identity("root",keyParam,sm2PrivateKey,null,sm2PublicKey, "123456", null); + Identity identity = new Identity("root",keyParam,sm2PrivateKey,null,sm2PublicKey, "123456", null, false); Certificate certificate = new Certificate(1, 1, sm2PublicKey, null, Common.SM3withSM2, Common.SM2, "root", "root", System.currentTimeMillis() - 1000, System.currentTimeMillis() + 5000, @@ -73,6 +73,8 @@ public class TestIdentity { idFromBytes = Identity.load(bytesOfDump, null); assertEquals(ByteUtils.toHexString(identity.getPrikey().getBytes()), ByteUtils.toHexString(idFromBytes.getPrikey().getBytes())); assertEquals(ByteUtils.toHexString(identity.getPubkey().getBytes()), ByteUtils.toHexString(idFromBytes.getPubkey().getBytes())); + + logger.debug(identity.getPrikey().getBytes().length + " " + identity.getPubkey().getBytes().length); } diff --git a/src/test/java/minsecurity/identity/TestPersist.java b/src/test/java/minsecurity/identity/TestPersist.java new file mode 100644 index 0000000..8578ba6 --- /dev/null +++ b/src/test/java/minsecurity/identity/TestPersist.java @@ -0,0 +1,68 @@ +package minsecurity.identity; + + +import minsecurity.Common; +import minsecurity.certificate.cert.CertUtils; +import minsecurity.certificate.cert.Certificate; +import minsecurity.crypto.sm2.SM2Base; +import minsecurity.crypto.sm2.SM2PrivateKey; +import minsecurity.crypto.sm2.SM2PublicKey; +import minsecurity.identity.persist.IdentitySerializer; +import org.bouncycastle.crypto.AsymmetricCipherKeyPair; +import org.bouncycastle.crypto.params.ECPrivateKeyParameters; +import org.bouncycastle.crypto.params.ECPublicKeyParameters; +import org.junit.Test; +import org.mapdb.BTreeMap; +import org.mapdb.DB; +import org.mapdb.DBMaker; +import org.mapdb.Serializer; +import org.slf4j.LoggerFactory; + +import java.util.concurrent.ConcurrentMap; + +/* + * @Author: hongyu guo + * @Description: + * @Version: 1.0.0 + * @Date: 17:35 2021/03/09 + * @Copyright: MIN-Group；国家重大科技基础设施——未来网络北大实验室；深圳市信息论与未来网络重点实验室 + */ +public class TestPersist { + private static final org.slf4j.Logger logger = LoggerFactory.getLogger(TestIdentity.class); + + @Test + public void testMapDB() throws Exception { + + + AsymmetricCipherKeyPair keyPair = SM2Base.generateKeyPairParameter(); + ECPrivateKeyParameters priKey = (ECPrivateKeyParameters) keyPair.getPrivate(); + ECPublicKeyParameters pubKey = (ECPublicKeyParameters) keyPair.getPublic(); + byte[] d = priKey.getD().toByteArray(); + // d = Arrays.copyOf(d,32); + byte[] x = pubKey.getQ().getAffineXCoord().getEncoded(); + byte[] y = pubKey.getQ().getAffineYCoord().getEncoded(); + // BigInteger bigInteger = priKey.getD(); + SM2PrivateKey sm2PrivateKey = new SM2PrivateKey(d); + SM2PublicKey sm2PublicKey = new SM2PublicKey(x,y); + KeyParam keyParam = new KeyParam(Common.SM2, Common.SM3withSM2); + Identity identity = new Identity("root",keyParam,sm2PrivateKey,null,sm2PublicKey, "123456", null, false); + Certificate certificate = new Certificate(1, 1, sm2PublicKey, null, + Common.SM3withSM2, Common.SM2, "root", "root", + System.currentTimeMillis() - 1000, System.currentTimeMillis() + 5000, + Common.CertSign, true, System.currentTimeMillis()); + CertUtils.signCert(certificate, sm2PrivateKey); + identity.setCert(certificate); + DB db = DBMaker.fileDB("./target/test.db").closeOnJvmShutdown().transactionEnable().make(); + Serializer customSerializer = new IdentitySerializer(); + ConcurrentMap map = db.hashMap("identity") + .keySerializer(Serializer.STRING) + .valueSerializer(customSerializer) + .createOrOpen(); + // map.put("/min/test05", new Identity()); + map.put("/min/test06", identity); + db.commit(); + logger.debug(identity.toString()); + Identity id = map.get("/min/test06"); + logger.debug(id.toString()); + } +} From 4a738fcfe0eb1d2b0a013f51826b0d21dc6695ac Mon Sep 17 00:00:00 2001 From: zhaofeng233 Date: Wed, 10 Mar 2021 02:13:48 +0800 Subject: [PATCH 2/3] =?UTF-8?q?ByteHelperTest,=E8=BF=98=E6=9C=89=E9=83=A8?= =?UTF-8?q?=E5=88=86=E6=9C=AA=E5=AE=8C=E6=88=90?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/test/java/util/ByteHelperTest.java | 420 +++++++++++++++++++++++++ 1 file changed, 420 insertions(+) create mode 100644 src/test/java/util/ByteHelperTest.java diff --git a/src/test/java/util/ByteHelperTest.java b/src/test/java/util/ByteHelperTest.java new file mode 100644 index 0000000..88678f2 --- /dev/null +++ b/src/test/java/util/ByteHelperTest.java @@ -0,0 +1,420 @@ +package util; + +import org.junit.Test; + +import static org.junit.Assert.*; + +/* + * @Author: feng Zhao + * @Description: + * @Version: 1.0.0 + * @Date: 16:20 2021/3/9 + * @Copyright: MIN-Group；国家重大科技基础设施——未来网络北大实验室；深圳市信息论与未来网络重点实验室 + */public class ByteHelperTest { + +// @Test +// public void getFirstByte() { +// +// } +// +// @Test +// public void getLenBytes() { +// } +// +// @Test +// public void testGetLenBytes() { +// } + + // 0 1 127 128 255 + @Test + public void uint8ToInt() { + byte b1 = 0x00; + byte b2 = 0x01; + byte b3 = 0x7f; + byte b4 = (byte) 0x80; + byte b5 = (byte) 0xff; + ByteHelper byteHelper = new ByteHelper(); + int a1 = byteHelper.uint8ToInt(b1); + int a2 = byteHelper.uint8ToInt(b2); + int a3 = byteHelper.uint8ToInt(b3); + int a4 = byteHelper.uint8ToInt(b4); + int a5 = byteHelper.uint8ToInt(b5); + + assertEquals(a1,0); + assertEquals(a2,1); + assertEquals(a3,127); + assertEquals(a4,128); + assertEquals(a5,255); + } + + @Test + public void uint8ToByte() { + byte b1 = 0x00; + byte b2 = 0x01; + byte b3 = 0x7f; + byte b4 = (byte) 0x80; + byte b5 = (byte) 0xff; + ByteHelper byteHelper = new ByteHelper(); + byte a1 = byteHelper.uint8ToByte(0); + byte a2 = byteHelper.uint8ToByte(1); + byte a3 = byteHelper.uint8ToByte(127); + byte a4 = byteHelper.uint8ToByte(128); + byte a5 = byteHelper.uint8ToByte(255); + + assertEquals(a1,b1); + assertEquals(a2,b2); + assertEquals(a3,b3); + assertEquals(a4,b4); + assertEquals(a5,b5); + + } + + @Test + public void uint8ToLong() { + + byte b1 = 0x00; + byte b2 = 0x01; + byte b3 = 0x7f; + byte b4 = (byte) 0x80; + byte b5 = (byte) 0xff; + ByteHelper byteHelper = new ByteHelper(); + long a1 = byteHelper.uint8ToLong(b1); + long a2 = byteHelper.uint8ToLong(b2); + long a3 = byteHelper.uint8ToLong(b3); + long a4 = byteHelper.uint8ToLong(b4); + long a5 = byteHelper.uint8ToLong(b5); + + assertEquals(a1,0); + assertEquals(a2,1); + assertEquals(a3,127); + assertEquals(a4,128); + assertEquals(a5,255); + } + + @Test + public void uint16ToInt() { + byte[] b1 = new byte[]{0x00,0x00}; //0 + byte[] b2 = new byte[]{0x00,0x01}; //1 + byte[] b3 = new byte[]{0x00,0x7f}; //127 + byte[] b4 = new byte[]{0x00, (byte) 0x80}; //128 + byte[] b5 = new byte[]{0x00, (byte) 0xff}; //255 + byte[] b6 = new byte[]{0x01, 0x00}; //256 + byte[] b7 = new byte[]{0x7f, (byte) 0xff}; //32767 + byte[] b8 = new byte[]{(byte) 0x80, 0x00}; //32768 + byte[] b9 = new byte[]{(byte) 0xff, (byte) 0xff};//65535 + ByteHelper byteHelper = new ByteHelper(); + int a1 = byteHelper.uint16ToInt(b1); + int a2 = byteHelper.uint16ToInt(b2); + int a3 = byteHelper.uint16ToInt(b3); + int a4 = byteHelper.uint16ToInt(b4); + int a5 = byteHelper.uint16ToInt(b5); + int a6 = byteHelper.uint16ToInt(b6); + int a7 = byteHelper.uint16ToInt(b7); + int a8 = byteHelper.uint16ToInt(b8); + int a9 = byteHelper.uint16ToInt(b9); + assertEquals(a1,0); + assertEquals(a2,1); + assertEquals(a3,127); + assertEquals(a4,128); + assertEquals(a5,255); + assertEquals(a6,256); + assertEquals(a7,32767); + assertEquals(a8,32768); + assertEquals(a9,65535); + } + + //error + @Test + public void uint16ToByteArray() { + ByteHelper byteHelper = new ByteHelper(); + byte[] b1 = new byte[]{0x00,0x00}; //0 + byte[] b2 = new byte[]{0x00,0x01}; //1 + byte[] b3 = new byte[]{0x00,0x7f}; //127 + byte[] b4 = new byte[]{0x00, (byte) 0x80}; //128 + byte[] b5 = new byte[]{0x00, (byte) 0xff}; //255 + byte[] b6 = new byte[]{0x01, 0x00}; //256 + byte[] b7 = new byte[]{0x7f, (byte) 0xff}; //32767 + byte[] b8 = new byte[]{(byte) 0x80, 0x00}; //32768 + byte[] b9 = new byte[]{(byte) 0xff, (byte) 0xff};//65535 + + byte [] a1 = byteHelper.uint16ToByteArray(0); + byte [] a2 = byteHelper.uint16ToByteArray(1); + byte [] a3 = byteHelper.uint16ToByteArray(127); + byte [] a4 = byteHelper.uint16ToByteArray(128); + byte [] a5 = byteHelper.uint16ToByteArray(255); + byte [] a6 = byteHelper.uint16ToByteArray(256); + byte [] a7 = byteHelper.uint16ToByteArray(32767); + byte [] a8 = byteHelper.uint16ToByteArray(32768); + byte [] a9 = byteHelper.uint16ToByteArray(65535); + assertEquals(a1,b1); + assertEquals(a2,b2); + assertEquals(a3,b3); + assertEquals(a4,b4); + assertEquals(a5,b5); + assertEquals(a6,b6); + assertEquals(a7,b7); + assertEquals(a8,b8); + assertEquals(a9,b9); + assertEquals(a6,b6); + assertEquals(a7,b7); + assertEquals(a8,b8); + assertEquals(a9,b9); + } + + @Test + public void uint16ToLong() { + byte[] b1 = new byte[]{0x00,0x00}; //0 + byte[] b2 = new byte[]{0x00,0x01}; //1 + byte[] b3 = new byte[]{0x00,0x7f}; //127 + byte[] b4 = new byte[]{0x00, (byte) 0x80}; //128 + byte[] b5 = new byte[]{0x00, (byte) 0xff}; //255 + byte[] b6 = new byte[]{0x01, 0x00}; //256 + byte[] b7 = new byte[]{0x7f, (byte) 0xff}; //32767 + byte[] b8 = new byte[]{(byte) 0x80, 0x00}; //32768 + byte[] b9 = new byte[]{(byte) 0xff, (byte) 0xff};//65535 + ByteHelper byteHelper = new ByteHelper(); + long a1 = byteHelper.uint16ToLong(b1); + long a2 = byteHelper.uint16ToLong(b2); + long a3 = byteHelper.uint16ToLong(b3); + long a4 = byteHelper.uint16ToLong(b4); + long a5 = byteHelper.uint16ToLong(b5); + long a6 = byteHelper.uint16ToLong(b6); + long a7 = byteHelper.uint16ToLong(b7); + long a8 = byteHelper.uint16ToLong(b8); + long a9 = byteHelper.uint16ToLong(b9); + assertEquals(a1,0); + assertEquals(a2,1); + assertEquals(a3,127); + assertEquals(a4,128); + assertEquals(a5,255); + assertEquals(a6,256); + assertEquals(a7,32767); + assertEquals(a8,32768); + assertEquals(a9,65535); + } + + //error + @Test + public void uint32ToLong() { + byte[] b1 = new byte[]{0x00,0x00,0x00,0x00}; //0 + byte[] b2 = new byte[]{0x00,0x00,0x00,0x01}; //1 + byte[] b3 = new byte[]{0x00,0x00,0x00,0x7f}; //127 + byte[] b4 = new byte[]{0x00,0x00,0x00, (byte) 0x80}; //128 + byte[] b5 = new byte[]{0x00,0x00,0x00, (byte) 0xff}; //255 + byte[] b6 = new byte[]{0x00,0x00,0x01, 0x00}; //256 + byte[] b7 = new byte[]{0x00,0x00,0x7f, (byte) 0xff}; //32767 + byte[] b8 = new byte[]{0x00,0x00,(byte) 0x80, 0x00}; //32768 + byte[] b9 = new byte[]{0x00,0x00,(byte) 0xff, (byte) 0xff}; //65535 + byte[] b10 = new byte[]{0x00,0x01,0x00,0x00}; //65536 + byte[] b11 = new byte[]{0x7f,(byte) 0xff,(byte) 0xff,(byte) 0xff};//2147483647 + byte[] b12 = new byte[]{(byte) 0x80,0x00,0x00,0x00}; //2147483648 + byte[] b13 = new byte[]{(byte) 0xff,(byte) 0xff,(byte) 0xff,(byte) 0xff};//4294967295 + ByteHelper byteHelper = new ByteHelper(); + long a1 = byteHelper.uint32ToLong(b1); + long a2 = byteHelper.uint32ToLong(b2); + long a3 = byteHelper.uint32ToLong(b3); + long a4 = byteHelper.uint32ToLong(b4); + long a5 = byteHelper.uint32ToLong(b5); + long a6 = byteHelper.uint32ToLong(b6); + long a7 = byteHelper.uint32ToLong(b7); + long a8 = byteHelper.uint32ToLong(b8); + long a9 = byteHelper.uint32ToLong(b9); + long a10 = byteHelper.uint32ToLong(b10); + long a11 = byteHelper.uint32ToLong(b11); + long a12 = byteHelper.uint32ToLong(b12); + long a13 = byteHelper.uint32ToLong(b13); + + assertEquals(a1,0); + assertEquals(a2,1); + assertEquals(a3,127); + assertEquals(a4,128); + assertEquals(a5,255); + assertEquals(a6,256); + assertEquals(a7,32767); + assertEquals(a8,32768); + assertEquals(a9,65535); + assertEquals(a10,65536); + assertEquals(a11,2147483647); + assertEquals(a12,2147483648L); + assertEquals(a13,4294967295L); + + } + + //error + @Test + public void uint32ToByteArray() { + byte[] b1 = new byte[]{0x00,0x00,0x00,0x00}; //0 + byte[] b2 = new byte[]{0x00,0x00,0x00,0x01}; //1 + byte[] b3 = new byte[]{0x00,0x00,0x00,0x7f}; //127 + byte[] b4 = new byte[]{0x00,0x00,0x00, (byte) 0x80}; //128 + byte[] b5 = new byte[]{0x00,0x00,0x00, (byte) 0xff}; //255 + byte[] b6 = new byte[]{0x00,0x00,0x01, 0x00}; //256 + byte[] b7 = new byte[]{0x00,0x00,0x7f, (byte) 0xff}; //32767 + byte[] b8 = new byte[]{0x00,0x00,(byte) 0x80, 0x00}; //32768 + byte[] b9 = new byte[]{0x00,0x00,(byte) 0xff, (byte) 0xff}; //65535 + byte[] b10 = new byte[]{0x00,0x01,0x00,0x00}; //65536 + byte[] b11 = new byte[]{0x7f,(byte) 0xff,(byte) 0xff,(byte) 0xff};//2147483647 + byte[] b12 = new byte[]{(byte) 0x80,0x00,0x00,0x00}; //2147483648 + byte[] b13 = new byte[]{(byte) 0xff,(byte) 0xff,(byte) 0xff,(byte) 0xff};//4294967295 + ByteHelper byteHelper = new ByteHelper(); + byte [] a1 = byteHelper.uint32ToByteArray(0); + byte [] a2 = byteHelper.uint16ToByteArray(1); + byte [] a3 = byteHelper.uint32ToByteArray(127); + byte [] a4 = byteHelper.uint32ToByteArray(128); + byte [] a5 = byteHelper.uint32ToByteArray(255); + byte [] a6 = byteHelper.uint32ToByteArray(256); + byte [] a7 = byteHelper.uint32ToByteArray(32767); + byte [] a8 = byteHelper.uint32ToByteArray(32768); + byte [] a9 = byteHelper.uint32ToByteArray(65535); + byte [] a10 = byteHelper.uint32ToByteArray(65536); + byte [] a11 = byteHelper.uint32ToByteArray(2147483647); + byte [] a12 = byteHelper.uint32ToByteArray(2147483648l); + byte [] a13 = byteHelper.uint32ToByteArray(4294967295l); + assertEquals(a1,b1); + assertEquals(a2,b2); + assertEquals(a3,b3); + assertEquals(a4,b4); + assertEquals(a5,b5); + assertEquals(a6,b6); + assertEquals(a7,b7); + assertEquals(a8,b8); + assertEquals(a9,b9); + assertEquals(a6,b6); + assertEquals(a7,b7); + assertEquals(a8,b8); + assertEquals(a9,b9); + assertEquals(a10,b10); + assertEquals(a11,b11); + assertEquals(a12,b12); + assertEquals(a13,b13); + } + + //error + //todo 大于2^64次方无法表示 + @Test + public void uint64ToLong() { + byte[] b1 = new byte[]{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}; //0 + byte[] b2 = new byte[]{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01}; //1 + byte[] b3 = new byte[]{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7f}; //127 + byte[] b4 = new byte[]{0x00,0x00,0x00,0x00,0x00,0x00,0x00, (byte) 0x80}; //128 + byte[] b5 = new byte[]{0x00,0x00,0x00,0x00,0x00,0x00,0x00, (byte) 0xff}; //255 + byte[] b6 = new byte[]{0x00,0x00,0x00,0x00,0x00,0x00,0x01, 0x00}; //256 + byte[] b7 = new byte[]{0x00,0x00,0x00,0x00,0x00,0x00,0x7f, (byte) 0xff}; //32767 + byte[] b8 = new byte[]{0x00,0x00,0x00,0x00,0x00,0x00,(byte) 0x80, 0x00}; //32768 + byte[] b9 = new byte[]{0x00,0x00,0x00,0x00,0x00,0x00,(byte) 0xff, (byte) 0xff}; //65535 + byte[] b10 = new byte[]{0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00}; //65536 + byte[] b11 = new byte[]{0x00,0x00,0x00,0x00,0x7f,(byte) 0xff,(byte) 0xff,(byte) 0xff};//2147483647 + byte[] b12 = new byte[]{0x00,0x00,0x00,0x00,(byte) 0x80,0x00,0x00,0x00}; //2147483648 + byte[] b13 = new byte[]{0x00,0x00,0x00,0x00,(byte) 0xff,(byte) 0xff,(byte) 0xff,(byte) 0xff};//4294967295 + byte[] b14 = new byte[]{0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00};//4294967296 + byte[] b15 = new byte[]{0x7f,(byte) 0xff,(byte) 0xff,(byte) 0xff,(byte) 0xff,(byte) 0xff,(byte) 0xff,(byte) 0xff};//9223372036854775807 + byte[] b16 = new byte[]{(byte) 0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00};//9223372036854775808 + byte[] b17 = new byte[]{(byte) 0xff,(byte) 0xff,(byte) 0xff,(byte) 0xff,(byte) 0xff,(byte) 0xff,(byte) 0xff,(byte) 0xff};//18446744073709551615 + ByteHelper byteHelper = new ByteHelper(); + +// byte[] b_test = new byte[]{0x00,0x00,0x00,0x00,(byte) 0x80,0x00,0x00,0x01};//2147483649 +// long a_test = byteHelper.uint64ToLong(b_test); +// assertEquals(a_test,2147483649l); + + long a1 = byteHelper.uint64ToLong(b1); + long a2 = byteHelper.uint64ToLong(b2); + long a3 = byteHelper.uint64ToLong(b3); + long a4 = byteHelper.uint64ToLong(b4); + long a5 = byteHelper.uint64ToLong(b5); + long a6 = byteHelper.uint64ToLong(b6); + long a7 = byteHelper.uint64ToLong(b7); + long a8 = byteHelper.uint64ToLong(b8); + long a9 = byteHelper.uint64ToLong(b9); + long a10 = byteHelper.uint64ToLong(b10); + long a11 = byteHelper.uint64ToLong(b11); + long a12 = byteHelper.uint64ToLong(b12); + long a13 = byteHelper.uint64ToLong(b13); + long a14 = byteHelper.uint64ToLong(b14); + long a15 = byteHelper.uint64ToLong(b15); + long a16 = byteHelper.uint64ToLong(b16); + long a17 = byteHelper.uint64ToLong(b17); + assertEquals(a1,0); + assertEquals(a2,1); + assertEquals(a3,127); + assertEquals(a4,128); + assertEquals(a5,255); + assertEquals(a6,256); + assertEquals(a7,32767); + assertEquals(a8,32768); + assertEquals(a9,65535); + assertEquals(a10,65536); + assertEquals(a11,2147483647); + + assertEquals(a12,2147483648L); + assertEquals(a13,4294967295L); + assertEquals(a14,4294967296L); + assertEquals(a15,9223372036854775807L); + //待解决：long number too large，暂无法表示 +// assertEquals(a16,9223372036854775808L); +// assertEquals(a17,18446744073709551615L); + + } + + //error + //todo 大于2^64次方无法表示 + @Test + public void uint64ToByteArray() { + byte[] b1 = new byte[]{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}; //0 + byte[] b2 = new byte[]{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01}; //1 + byte[] b3 = new byte[]{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7f}; //127 + byte[] b4 = new byte[]{0x00,0x00,0x00,0x00,0x00,0x00,0x00, (byte) 0x80}; //128 + byte[] b5 = new byte[]{0x00,0x00,0x00,0x00,0x00,0x00,0x00, (byte) 0xff}; //255 + byte[] b6 = new byte[]{0x00,0x00,0x00,0x00,0x00,0x00,0x01, 0x00}; //256 + byte[] b7 = new byte[]{0x00,0x00,0x00,0x00,0x00,0x00,0x7f, (byte) 0xff}; //32767 + byte[] b8 = new byte[]{0x00,0x00,0x00,0x00,0x00,0x00,(byte) 0x80, 0x00}; //32768 + byte[] b9 = new byte[]{0x00,0x00,0x00,0x00,0x00,0x00,(byte) 0xff, (byte) 0xff}; //65535 + byte[] b10 = new byte[]{0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00}; //65536 + byte[] b11 = new byte[]{0x00,0x00,0x00,0x00,0x7f,(byte) 0xff,(byte) 0xff,(byte) 0xff};//2147483647 + byte[] b12 = new byte[]{0x00,0x00,0x00,0x00,(byte) 0x80,0x00,0x00,0x00}; //2147483648 + byte[] b13 = new byte[]{0x00,0x00,0x00,0x00,(byte) 0xff,(byte) 0xff,(byte) 0xff,(byte) 0xff};//4294967295 + byte[] b14 = new byte[]{0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00};//4294967296 + byte[] b15 = new byte[]{0x7f,(byte) 0xff,(byte) 0xff,(byte) 0xff,(byte) 0xff,(byte) 0xff,(byte) 0xff,(byte) 0xff};//9223372036854775807 + byte[] b16 = new byte[]{(byte) 0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00};//9223372036854775808 + byte[] b17 = new byte[]{(byte) 0xff,(byte) 0xff,(byte) 0xff,(byte) 0xff,(byte) 0xff,(byte) 0xff,(byte) 0xff,(byte) 0xff};//18446744073709551615 + ByteHelper byteHelper = new ByteHelper(); + byte [] a1 = byteHelper.uint64ToByteArray(0); + byte [] a2 = byteHelper.uint64ToByteArray(1); + byte [] a3 = byteHelper.uint64ToByteArray(127); + byte [] a4 = byteHelper.uint64ToByteArray(128); + byte [] a5 = byteHelper.uint64ToByteArray(255); + byte [] a6 = byteHelper.uint64ToByteArray(256); + byte [] a7 = byteHelper.uint64ToByteArray(32767); + byte [] a8 = byteHelper.uint64ToByteArray(32768); + byte [] a9 = byteHelper.uint64ToByteArray(65535); + byte [] a10 = byteHelper.uint64ToByteArray(65536); + byte [] a11 = byteHelper.uint64ToByteArray(2147483647); + byte [] a12 = byteHelper.uint64ToByteArray(2147483648l); + byte [] a13 = byteHelper.uint64ToByteArray(4294967295l); + byte [] a14 = byteHelper.uint64ToByteArray(4294967296L); + byte [] a15 = byteHelper.uint64ToByteArray(9223372036854775807L); +// byte [] a16 = byteHelper.uint64ToByteArray(9223372036854775808L); +// byte [] a17 = byteHelper.uint64ToByteArray(18446744073709551615L); + assertEquals(a1,b1); + assertEquals(a2,b2); + assertEquals(a3,b3); + assertEquals(a4,b4); + assertEquals(a5,b5); + assertEquals(a6,b6); + assertEquals(a7,b7); + assertEquals(a8,b8); + assertEquals(a9,b9); + assertEquals(a6,b6); + assertEquals(a7,b7); + assertEquals(a8,b8); + assertEquals(a9,b9); + assertEquals(a10,b10); + assertEquals(a11,b11); + assertEquals(a12,b12); + assertEquals(a13,b13); + assertEquals(a14,b14); + assertEquals(a15,b15); +// assertEquals(a16,b16); +// assertEquals(a17,b17); + } + +} \ No newline at end of file From 16416fecf4fd22dacc6726782a96008b057c86c0 Mon Sep 17 00:00:00 2001 From: ghy Date: Wed, 10 Mar 2021 15:43:03 +0800 Subject: [PATCH 3/3] =?UTF-8?q?identity=20&=20identity=E5=9F=BA=E7=A1=80?= =?UTF-8?q?=E5=8A=9F=E8=83=BD=E6=B5=8B=E8=AF=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../minsecurity/crypto/sm2/SM2PrivateKey.java | 10 +- .../identity/persist/IdentitySerializer.java | 4 +- .../minsecurity/identity/persist/MapDB.java | 152 ++++++++++++++++++ .../minsecurity/identity/TestPersist.java | 121 ++++++++++++-- 4 files changed, 265 insertions(+), 22 deletions(-) create mode 100644 src/main/java/minsecurity/identity/persist/MapDB.java diff --git a/src/main/java/minsecurity/crypto/sm2/SM2PrivateKey.java b/src/main/java/minsecurity/crypto/sm2/SM2PrivateKey.java index 51d4e1a..3d18b38 100644 --- a/src/main/java/minsecurity/crypto/sm2/SM2PrivateKey.java +++ b/src/main/java/minsecurity/crypto/sm2/SM2PrivateKey.java @@ -38,15 +38,7 @@ public class SM2PrivateKey implements PrivateKeyInterface { * @date 2021/3/7 **/ public SM2PrivateKey(byte[] d) { - if(d.length == 32 || d.length == 33) - privateKey = new ECPrivateKeyParameters(new BigInteger(d), SM2Base.DOMAIN_PARAMS); - else { - try { - throw new SM2Exception("SM2私钥中，参数d长度应为32/33"); - } catch (SM2Exception e) { - e.printStackTrace(); - } - } + privateKey = new ECPrivateKeyParameters(new BigInteger(d), SM2Base.DOMAIN_PARAMS); } public SM2PrivateKey(byte[] d, ECDomainParameters parameters){ if(d.length == 32 || d.length == 33) diff --git a/src/main/java/minsecurity/identity/persist/IdentitySerializer.java b/src/main/java/minsecurity/identity/persist/IdentitySerializer.java index fea81d4..1da24b9 100644 --- a/src/main/java/minsecurity/identity/persist/IdentitySerializer.java +++ b/src/main/java/minsecurity/identity/persist/IdentitySerializer.java @@ -1,6 +1,5 @@ package minsecurity.identity.persist; -import com.fasterxml.jackson.databind.ObjectMapper; import minsecurity.Common; import minsecurity.certificate.cert.CertException; import minsecurity.certificate.cert.CertUtils; @@ -31,8 +30,9 @@ import java.security.NoSuchProviderException; * @Date: 20:50 2021/03/09 * @Copyright: MIN-Group；国家重大科技基础设施——未来网络北大实验室；深圳市信息论与未来网络重点实验室 */ -public class IdentitySerializer implements Serializer { +// TODO: 加密版本的序列化 +public class IdentitySerializer implements Serializer { @Override public void serialize(@NotNull DataOutput2 dataOutput2, @NotNull Identity identity) throws IOException { diff --git a/src/main/java/minsecurity/identity/persist/MapDB.java b/src/main/java/minsecurity/identity/persist/MapDB.java new file mode 100644 index 0000000..308a969 --- /dev/null +++ b/src/main/java/minsecurity/identity/persist/MapDB.java @@ -0,0 +1,152 @@ +package minsecurity.identity.persist; + +import com.fasterxml.jackson.annotation.JsonTypeInfo; +import minsecurity.identity.Identity; +import org.mapdb.DB; +import org.mapdb.DBMaker; +import org.mapdb.Serializer; +import org.slf4j.LoggerFactory; + +import java.util.ArrayList; +import java.util.concurrent.ConcurrentMap; + +/* + * @Author: hongyu guo + * @Description: 封装MapDB中需要的方法 + * @Version: 1.0.0 + * @Date: 10:34 2021/03/10 + * @Copyright: MIN-Group；国家重大科技基础设施——未来网络北大实验室；深圳市信息论与未来网络重点实验室 + */ +public class MapDB { + private static final org.slf4j.Logger logger = LoggerFactory.getLogger(MapDB.class); + // TODO: 如有需要, 后续添加其他map + // TODO: 数据库加密? + public static final String defaultPath = "./target/test.db"; + public static final String defaultIdentity = "identity"; + public static final String defaultName = "/default"; + private DB db; + private ConcurrentMap identityMap; + private Serializer customSerializer; + private static MapDB mapDB = null; + + private MapDB(){ + db = DBMaker.fileDB(defaultPath).closeOnJvmShutdown().transactionEnable().make(); + customSerializer = new IdentitySerializer(); + identityMap = db.hashMap(defaultIdentity) + .keySerializer(Serializer.STRING) + .valueSerializer(customSerializer) + .createOrOpen(); + } + private MapDB(String filePath){ + db = DBMaker.fileDB(filePath).closeOnJvmShutdown().transactionEnable().make(); + customSerializer = new IdentitySerializer(); + identityMap = db.hashMap(defaultIdentity) + .keySerializer(Serializer.STRING) + .valueSerializer(customSerializer) + .createOrOpen(); + } + + public static MapDB getInstance(){ + if(mapDB == null){ + mapDB = new MapDB(); + } + return mapDB; + } + public static MapDB getInstance(String filePath){ + if(mapDB == null){ + mapDB = new MapDB(filePath); + } + return mapDB; + } + + public Identity addIdentity(String name, Identity identity, boolean commit){ + Identity id = identityMap.put(name,identity); + if(identityMap.size() == 1){ + // 首次添加default Identity + setDefaultIdentity(name, commit); + } + + + if(commit){ + db.commit(); + } + return id; + } + + public void closeDB(){ + db.close(); + mapDB = null; + } + + public void commit(){ + db.commit(); + } + + + public Identity getIdentityByName(String name){ + return identityMap.get(name); + } + + public ArrayList getAllIdentity(){ + ArrayList list = new ArrayList<>(); + for(String key : identityMap.keySet()){ + list.add(identityMap.get(key)); + } + return list; + } + + public boolean setDefaultIdentity(String name, boolean commit){ + Identity identity = identityMap.get(name); + if(identity == null) + return false; + // 将所有identity的设置为非默认 + for(String key : identityMap.keySet()){ + Identity id = identityMap.get(key); + if(id.isDefault()) { + id.setDefault(false); + identityMap.put(key, id); + } + } + identity.setDefault(true); + identityMap.put(name, identity); + // set /default + identityMap.put(defaultName, identity); + if(commit){ + db.commit(); + } + return true; + } + + public Identity getDefaultIdentity(){ + return identityMap.get(defaultName); + } + + public Identity deleteIdentity(String name, boolean commit){ + // 不能删除默认Identity + if(name.equals(defaultName)){ + logger.error("不能删除default identity"); + return null; + } + Identity identity = identityMap.remove(name); + if(commit){ + db.commit(); + } + return identity; + } + + public DB getDb() { + return db; + } + + public void setDb(DB db) { + this.db = db; + } + + public ConcurrentMap getIdentityMap() { + return identityMap; + } + + public void setIdentityMap(ConcurrentMap identityMap) { + this.identityMap = identityMap; + } +} diff --git a/src/test/java/minsecurity/identity/TestPersist.java b/src/test/java/minsecurity/identity/TestPersist.java index 8578ba6..a67c655 100644 --- a/src/test/java/minsecurity/identity/TestPersist.java +++ b/src/test/java/minsecurity/identity/TestPersist.java @@ -8,6 +8,7 @@ import minsecurity.crypto.sm2.SM2Base; import minsecurity.crypto.sm2.SM2PrivateKey; import minsecurity.crypto.sm2.SM2PublicKey; import minsecurity.identity.persist.IdentitySerializer; +import minsecurity.identity.persist.MapDB; import org.bouncycastle.crypto.AsymmetricCipherKeyPair; import org.bouncycastle.crypto.params.ECPrivateKeyParameters; import org.bouncycastle.crypto.params.ECPublicKeyParameters; @@ -18,6 +19,7 @@ import org.mapdb.DBMaker; import org.mapdb.Serializer; import org.slf4j.LoggerFactory; +import java.util.*; import java.util.concurrent.ConcurrentMap; /* @@ -33,7 +35,6 @@ public class TestPersist { @Test public void testMapDB() throws Exception { - AsymmetricCipherKeyPair keyPair = SM2Base.generateKeyPairParameter(); ECPrivateKeyParameters priKey = (ECPrivateKeyParameters) keyPair.getPrivate(); ECPublicKeyParameters pubKey = (ECPublicKeyParameters) keyPair.getPublic(); @@ -52,17 +53,115 @@ public class TestPersist { Common.CertSign, true, System.currentTimeMillis()); CertUtils.signCert(certificate, sm2PrivateKey); identity.setCert(certificate); - DB db = DBMaker.fileDB("./target/test.db").closeOnJvmShutdown().transactionEnable().make(); - Serializer customSerializer = new IdentitySerializer(); - ConcurrentMap map = db.hashMap("identity") - .keySerializer(Serializer.STRING) - .valueSerializer(customSerializer) - .createOrOpen(); - // map.put("/min/test05", new Identity()); - map.put("/min/test06", identity); - db.commit(); + MapDB mapDB = MapDB.getInstance("./target/test.db"); + int random = new Random().nextInt(); + mapDB.addIdentity("/test" + random, identity, false); + mapDB.commit(); + mapDB.closeDB(); + mapDB = MapDB.getInstance("./target/test.db"); + ArrayList arrayList = mapDB.getAllIdentity(); + logger.debug("db size: {}",arrayList.size()); + Identity id = mapDB.getIdentityByName("/test" + random); logger.debug(identity.toString()); - Identity id = map.get("/min/test06"); logger.debug(id.toString()); } + + @Test + public void testMapDB2() throws Exception { + MapDB mapDB = MapDB.getInstance("./target/test.db"); + for(int i = 0; i < 100; i++){ + AsymmetricCipherKeyPair keyPair = SM2Base.generateKeyPairParameter(); + ECPrivateKeyParameters priKey = (ECPrivateKeyParameters) keyPair.getPrivate(); + ECPublicKeyParameters pubKey = (ECPublicKeyParameters) keyPair.getPublic(); + byte[] d = priKey.getD().toByteArray(); + // d = Arrays.copyOf(d,32); + byte[] x = pubKey.getQ().getAffineXCoord().getEncoded(); + byte[] y = pubKey.getQ().getAffineYCoord().getEncoded(); + // BigInteger bigInteger = priKey.getD(); + SM2PrivateKey sm2PrivateKey = new SM2PrivateKey(d); + SM2PublicKey sm2PublicKey = new SM2PublicKey(x,y); + KeyParam keyParam = new KeyParam(Common.SM2, Common.SM3withSM2); + Identity identity = new Identity("root",keyParam,sm2PrivateKey,null,sm2PublicKey, "123456", null, false); + Certificate certificate = new Certificate(1, 1, sm2PublicKey, null, + Common.SM3withSM2, Common.SM2, "root", "root", + System.currentTimeMillis() - 1000, System.currentTimeMillis() + 5000, + Common.CertSign, true, System.currentTimeMillis()); + CertUtils.signCert(certificate, sm2PrivateKey); + identity.setCert(certificate); + int random = new Random().nextInt(); + mapDB.addIdentity("/test" + random, identity, false); + } + mapDB.commit(); + ArrayList arrayList = mapDB.getAllIdentity(); + logger.debug("size = {}", arrayList.size()); + for(Identity id : arrayList){ + logger.debug(id.toString()); + } + } + + @Test + public void testHashmap(){ + HashMap primeNumbers = new HashMap<>(); + + // 往HasMap中添加映射 + primeNumbers.put("Two", 2); + primeNumbers.put("Three", 3); + primeNumbers.put("Five", 5); + System.out.println("HashMap: " + primeNumbers); + + // 得到value + Integer value = primeNumbers.get("Three"); + System.out.println("key Three 对应的 value: " + value); + + } + + @Test + public void testDefault() throws Exception { + MapDB mapDB = MapDB.getInstance("./target/test.db"); + for(int i = 0; i < 20; i++){ + int random = new Random().nextInt(); + Identity identity = generateIdentity("/test/" + random); + mapDB.addIdentity(identity.getName(), identity, false); + } + // mapDB.commit(); + ArrayList arrayList = mapDB.getAllIdentity(); + logger.debug("size = {}", arrayList.size()); + for(Identity id : arrayList){ + logger.debug(id.getName() + " " + id.isDefault()); + } + logger.debug("----setDefault----"); + Identity identity = generateIdentity("/abc"); + identity.setDefault(true); + mapDB.addIdentity("/abc", identity, false); + mapDB.setDefaultIdentity("/abc",false); + mapDB.commit(); + + arrayList = mapDB.getAllIdentity(); + for(Identity id : arrayList){ + logger.debug(id.getName() + " " + id.isDefault()); + } + logger.debug("get default"); + logger.debug(mapDB.getDefaultIdentity().toString()); + } + + + private Identity generateIdentity(String name) throws Exception { + AsymmetricCipherKeyPair keyPair = SM2Base.generateKeyPairParameter(); + ECPrivateKeyParameters priKey = (ECPrivateKeyParameters) keyPair.getPrivate(); + ECPublicKeyParameters pubKey = (ECPublicKeyParameters) keyPair.getPublic(); + byte[] d = priKey.getD().toByteArray(); + byte[] x = pubKey.getQ().getAffineXCoord().getEncoded(); + byte[] y = pubKey.getQ().getAffineYCoord().getEncoded(); + SM2PrivateKey sm2PrivateKey = new SM2PrivateKey(d); + SM2PublicKey sm2PublicKey = new SM2PublicKey(x,y); + KeyParam keyParam = new KeyParam(Common.SM2, Common.SM3withSM2); + Identity identity = new Identity(name,keyParam,sm2PrivateKey,null,sm2PublicKey, "123456", null, false); + Certificate certificate = new Certificate(1, 1, sm2PublicKey, null, + Common.SM3withSM2, Common.SM2, "root", "root", + System.currentTimeMillis() - 1000, System.currentTimeMillis() + 5000, + Common.CertSign, true, System.currentTimeMillis()); + CertUtils.signCert(certificate, sm2PrivateKey); + identity.setCert(certificate); + return identity; + } }