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/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/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..1da24b9
--- /dev/null
+++ b/src/main/java/minsecurity/identity/persist/IdentitySerializer.java
@@ -0,0 +1,97 @@
+package minsecurity.identity.persist;
+
+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；国家重大科技基础设施——未来网络北大实验室；深圳市信息论与未来网络重点实验室
+ */
+
+// TODO: 加密版本的序列化
+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/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/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..a67c655
--- /dev/null
+++ b/src/test/java/minsecurity/identity/TestPersist.java
@@ -0,0 +1,167 @@
+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 minsecurity.identity.persist.MapDB;
+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.*;
+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);
+ 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());
+ 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;
+ }
+}
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