Fix bugs in test case;

source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/CryptoAlgorithm.java

@@ -15,9 +15,9 @@ public enum CryptoAlgorithm {
 
 	SM3(CryptoAlgorithmType.HASH, (byte) 0x03, false, false),
 
-	JNISHA256(CryptoAlgorithmType.HASH, (byte) 0x04, false, false),
-
-	JNIRIPEMD160(CryptoAlgorithmType.HASH, (byte) 0x05, false, false),
+//	JNISHA256(CryptoAlgorithmType.HASH, (byte) 0x04, false, false),
+//
+//	JNIRIPEMD160(CryptoAlgorithmType.HASH, (byte) 0x05, false, false),
 
 	// 非对称签名/加密算法；
 
@@ -41,10 +41,10 @@ public enum CryptoAlgorithm {
 	 */
 	SM2(CryptoAlgorithmType.ASYMMETRIC, (byte) 0x04, true, true),
 
-	/**
-	 * JNIED25519 签名算法；只用于签名，没有加密特性；
-	 */
-	JNIED25519(CryptoAlgorithmType.ASYMMETRIC, (byte) 0x05, true, false),
+//	/**
+//	 * JNIED25519 签名算法；只用于签名，没有加密特性；
+//	 */
+//	JNIED25519(CryptoAlgorithmType.ASYMMETRIC, (byte) 0x05, true, false),
 
 	// 对称加密；
 	/**

source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/impl/AsymmtricCryptographyImpl.java

@@ -2,9 +2,14 @@ package com.jd.blockchain.crypto.impl;
 
 import com.jd.blockchain.crypto.Ciphertext;
 import com.jd.blockchain.crypto.CryptoAlgorithm;
-import com.jd.blockchain.crypto.asymmetric.*;
+import com.jd.blockchain.crypto.asymmetric.AsymmetricCryptography;
+import com.jd.blockchain.crypto.asymmetric.AsymmetricEncryptionFunction;
+import com.jd.blockchain.crypto.asymmetric.CryptoKeyPair;
+import com.jd.blockchain.crypto.asymmetric.PrivKey;
+import com.jd.blockchain.crypto.asymmetric.PubKey;
+import com.jd.blockchain.crypto.asymmetric.SignatureDigest;
+import com.jd.blockchain.crypto.asymmetric.SignatureFunction;
 import com.jd.blockchain.crypto.impl.def.asymmetric.ED25519SignatureFunction;
-import com.jd.blockchain.crypto.impl.jni.asymmetric.JNIED25519SignatureFunction;
 import com.jd.blockchain.crypto.impl.sm.asymmetric.SM2CryptoFunction;
 
 public class AsymmtricCryptographyImpl implements AsymmetricCryptography {
@@ -13,7 +18,7 @@ public class AsymmtricCryptographyImpl implements AsymmetricCryptography {
 
     private static final SignatureFunction SM2_SIGF = new SM2CryptoFunction();
 
-    private static final SignatureFunction JNIED25519_SIGF = new JNIED25519SignatureFunction();
+//    private static final SignatureFunction JNIED25519_SIGF = new JNIED25519SignatureFunction();
 
     private static final AsymmetricEncryptionFunction SM2_ENCF = new SM2CryptoFunction();
 
@@ -41,8 +46,8 @@ public class AsymmtricCryptographyImpl implements AsymmetricCryptography {
                 return ED25519_SIGF;
             case SM2:
                 return SM2_SIGF;
-            case JNIED25519:
-                return JNIED25519_SIGF;
+//            case JNIED25519:
+//                return JNIED25519_SIGF;
             default:
                 break;
         }
@@ -128,9 +133,9 @@ public class AsymmtricCryptographyImpl implements AsymmetricCryptography {
         if (SM2_SIGF.supportDigest(digestBytes)){
             return SM2_SIGF.resolveDigest(digestBytes);
         }
-        if (JNIED25519_SIGF.supportDigest(digestBytes)){
-            return JNIED25519_SIGF.resolveDigest(digestBytes);
-        }
+//        if (JNIED25519_SIGF.supportDigest(digestBytes)){
+//            return JNIED25519_SIGF.resolveDigest(digestBytes);
+//        }
         //否则返回null
         return null;
     }
@@ -153,9 +158,9 @@ public class AsymmtricCryptographyImpl implements AsymmetricCryptography {
         if (SM2_SIGF.supportPubKey(pubKeyBytes)){
             return SM2_SIGF.resolvePubKey(pubKeyBytes);
         }
-        if (JNIED25519_SIGF.supportPubKey(pubKeyBytes)){
-            return JNIED25519_SIGF.resolvePubKey(pubKeyBytes);
-        }
+//        if (JNIED25519_SIGF.supportPubKey(pubKeyBytes)){
+//            return JNIED25519_SIGF.resolvePubKey(pubKeyBytes);
+//        }
         //遍历非对称加密算法，如果满足，则返回解析结果
         if (SM2_ENCF.supportPubKey(pubKeyBytes)){
             return SM2_ENCF.resolvePubKey(pubKeyBytes);
@@ -181,9 +186,9 @@ public class AsymmtricCryptographyImpl implements AsymmetricCryptography {
         if (SM2_SIGF.supportPrivKey(privKeyBytes)){
             return SM2_SIGF.resolvePrivKey(privKeyBytes);
         }
-        if (JNIED25519_SIGF.supportPrivKey(privKeyBytes)){
-            return JNIED25519_SIGF.resolvePrivKey(privKeyBytes);
-        }
+//        if (JNIED25519_SIGF.supportPrivKey(privKeyBytes)){
+//            return JNIED25519_SIGF.resolvePrivKey(privKeyBytes);
+//        }
         //遍历非对称加密算法，如果满足，则返回解析结果
         if (SM2_ENCF.supportPrivKey(privKeyBytes)){
             return SM2_ENCF.resolvePrivKey(privKeyBytes);

source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/impl/HashCryptographyImpl.java

@@ -6,8 +6,6 @@ import com.jd.blockchain.crypto.hash.HashDigest;
 import com.jd.blockchain.crypto.hash.HashFunction;
 import com.jd.blockchain.crypto.impl.def.hash.RIPEMD160HashFunction;
 import com.jd.blockchain.crypto.impl.def.hash.SHA256HashFunction;
-import com.jd.blockchain.crypto.impl.jni.hash.JNIRIPEMD160HashFunction;
-import com.jd.blockchain.crypto.impl.jni.hash.JNISHA256HashFunction;
 import com.jd.blockchain.crypto.impl.sm.hash.SM3HashFunction;
 
 public class HashCryptographyImpl implements HashCryptography {
@@ -16,8 +14,8 @@ public class HashCryptographyImpl implements HashCryptography {
 	private static final HashFunction RIPEMD160_FUNC = new RIPEMD160HashFunction();
 	private static final HashFunction SM3_FUNC = new SM3HashFunction();
 
-	private static final HashFunction JNISHA256_FUNC = new JNISHA256HashFunction();
-	private static final HashFunction JNIRIPEMD160_FUNC = new JNIRIPEMD160HashFunction();
+//	private static final HashFunction JNISHA256_FUNC = new JNISHA256HashFunction();
+//	private static final HashFunction JNIRIPEMD160_FUNC = new JNIRIPEMD160HashFunction();
 
 	@Override
 	public HashFunction getFunction(CryptoAlgorithm algorithm) {
@@ -30,10 +28,10 @@ public class HashCryptographyImpl implements HashCryptography {
 			return RIPEMD160_FUNC;
 		case SM3:
 			return SM3_FUNC;
-		case JNISHA256:
-				return JNISHA256_FUNC;
-		case JNIRIPEMD160:
-				return JNIRIPEMD160_FUNC;
+//		case JNISHA256:
+//				return JNISHA256_FUNC;
+//		case JNIRIPEMD160:
+//				return JNIRIPEMD160_FUNC;
 		default:
 			break;
 		}
@@ -72,12 +70,12 @@ public class HashCryptographyImpl implements HashCryptography {
 		if (SM3_FUNC.supportHashDigest(digestBytes)) {
 			return SM3_FUNC.resolveHashDigest(digestBytes);
 		}
-		if (JNISHA256_FUNC.supportHashDigest(digestBytes)) {
-			return JNISHA256_FUNC.resolveHashDigest(digestBytes);
-		}
-		if (JNIRIPEMD160_FUNC.supportHashDigest(digestBytes)) {
-			return JNIRIPEMD160_FUNC.resolveHashDigest(digestBytes);
-		}
+//		if (JNISHA256_FUNC.supportHashDigest(digestBytes)) {
+//			return JNISHA256_FUNC.resolveHashDigest(digestBytes);
+//		}
+//		if (JNIRIPEMD160_FUNC.supportHashDigest(digestBytes)) {
+//			return JNIRIPEMD160_FUNC.resolveHashDigest(digestBytes);
+//		}
 		//否则返回null
 		return null;
 	}

source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/impl/jni/asymmetric/JNIED25519SignatureFunction.java

@@ -1,130 +1,130 @@
-package com.jd.blockchain.crypto.impl.jni.asymmetric;
-
-import com.jd.blockchain.crypto.CryptoAlgorithm;
-import com.jd.blockchain.crypto.asymmetric.*;
-import com.jd.blockchain.crypto.jniutils.asymmetric.JNIED25519Utils;
-
-import static com.jd.blockchain.crypto.CryptoAlgorithm.JNIED25519;
-import static com.jd.blockchain.crypto.CryptoBytes.ALGORYTHM_BYTES;
-import static com.jd.blockchain.crypto.CryptoKeyType.PRIV_KEY;
-import static com.jd.blockchain.crypto.CryptoKeyType.PUB_KEY;
-import static com.jd.blockchain.crypto.base.BaseCryptoKey.KEY_TYPE_BYTES;
-
-public class JNIED25519SignatureFunction implements SignatureFunction {
-
-    private static final int PUBKEY_SIZE = 32;
-    private static final int PRIVKEY_SIZE = 32;
-    private static final int DIGEST_SIZE = 64;
-
-    private static final int PUBKEY_LENGTH = ALGORYTHM_BYTES + KEY_TYPE_BYTES + PUBKEY_SIZE;
-    private static final int PRIVKEY_LENGTH = ALGORYTHM_BYTES + KEY_TYPE_BYTES + PRIVKEY_SIZE;
-    private static final int SIGNATUREDIGEST_LENGTH = ALGORYTHM_BYTES + DIGEST_SIZE;
-
-    public JNIED25519SignatureFunction() {
-    }
-
-    @Override
-    public SignatureDigest sign(PrivKey privKey, byte[] data) {
-
-        if (data == null)
-            throw new IllegalArgumentException("This data is null!");
-
-        JNIED25519Utils ed25519 = new JNIED25519Utils();
-
-        byte[] rawPrivKeyBytes = privKey.getRawKeyBytes();
-        byte[] rawPubKeyBytes = ed25519.getPubKey(rawPrivKeyBytes);
-
-        // 验证原始私钥长度为256比特，即32字节
-        if (rawPrivKeyBytes.length != PRIVKEY_SIZE)
-            throw new IllegalArgumentException("This key has wrong format!");
-
-        // 验证密钥数据的算法标识对应JNIED25519签名算法
-        if (privKey.getAlgorithm() != JNIED25519)
-            throw new IllegalArgumentException("This key is not ED25519 private key!");
-
-        // 调用JNIED25519签名算法计算签名结果
-        return new SignatureDigest(JNIED25519, ed25519.sign(data, rawPrivKeyBytes, rawPubKeyBytes));
-    }
-
-    @Override
-    public boolean verify(SignatureDigest digest, PubKey pubKey, byte[] data) {
-
-        JNIED25519Utils ed25519 = new JNIED25519Utils();
-
-        byte[] rawPubKeyBytes = pubKey.getRawKeyBytes();
-        byte[] rawDigestBytes = digest.getRawDigest();
-
-        // 验证原始公钥长度为256比特，即32字节
-        if (rawPubKeyBytes.length != PUBKEY_SIZE)
-            throw new IllegalArgumentException("This key has wrong format!");
-
-        // 验证密钥数据的算法标识对应JNIED25519签名算法
-        if (pubKey.getAlgorithm() != JNIED25519)
-            throw new IllegalArgumentException("This key is not ED25519 public key!");
-
-        // 验证密文数据的算法标识对应JNIED25519签名算法，并且原始摘要长度为64字节
-        if (digest.getAlgorithm() != JNIED25519 || rawDigestBytes.length != DIGEST_SIZE)
-            throw new IllegalArgumentException("This is not ED25519 signature digest!");
-
-        // 调用JNIED25519验签算法验证签名结果
-        return ed25519.verify(data, rawPubKeyBytes, rawDigestBytes);
-    }
-
-    @Override
-    public boolean supportPrivKey(byte[] privKeyBytes) {
-        // 验证输入字节数组长度=算法标识长度+密钥类型长度+密钥长度，密钥数据的算法标识对应JNIED25519签名算法，并且密钥类型是私钥
-        return privKeyBytes.length == PRIVKEY_LENGTH
-                && privKeyBytes[0] == JNIED25519.CODE && privKeyBytes[1] == PRIV_KEY.CODE;
-    }
-
-    @Override
-    public PrivKey resolvePrivKey(byte[] privKeyBytes) {
-        // 由框架调用 support 方法检查有效性，在此不做重复检查；
-        return new PrivKey(privKeyBytes);
-    }
-
-    @Override
-    public boolean supportPubKey(byte[] pubKeyBytes) {
-        // 验证输入字节数组长度=算法标识长度+密钥类型长度+密钥长度，密钥数据的算法标识对应JNIED25519签名算法，并且密钥类型是公钥
-        return pubKeyBytes.length == PUBKEY_LENGTH &&
-                pubKeyBytes[0] == JNIED25519.CODE && pubKeyBytes[1] == PUB_KEY.CODE;
-
-    }
-
-    @Override
-    public PubKey resolvePubKey(byte[] pubKeyBytes) {
-        // 由框架调用 support 方法检查有效性，在此不做重复检查；
-        return new PubKey(pubKeyBytes);
-    }
-
-    @Override
-    public boolean supportDigest(byte[] digestBytes) {
-        // 验证输入字节数组长度=算法标识长度+摘要长度，字节数组的算法标识对应JNIED25519算法
-        return digestBytes.length == SIGNATUREDIGEST_LENGTH && digestBytes[0] == JNIED25519.CODE;
-    }
-
-    @Override
-    public SignatureDigest resolveDigest(byte[] digestBytes) {
-        // 由框架调用 support 方法检查有效性，在此不做重复检查；
-        return new SignatureDigest(digestBytes);
-    }
-
-    @Override
-    public CryptoAlgorithm getAlgorithm() {
-        return JNIED25519;
-    }
-
-    @Override
-    public CryptoKeyPair generateKeyPair() {
-
-        JNIED25519Utils ed25519 = new JNIED25519Utils();
-        byte[] rawPrivKeyBytes = new byte[PRIVKEY_SIZE];
-        byte[] rawPubKeyBytes = new byte[PUBKEY_SIZE];
-
-        // 调用JNIED25519算法的密钥生成算法生成公私钥对
-        ed25519.generateKeyPair(rawPrivKeyBytes, rawPubKeyBytes);
-
-        return new CryptoKeyPair(new PubKey(JNIED25519, rawPubKeyBytes), new PrivKey(JNIED25519, rawPrivKeyBytes));
-
-    }
-}
+//package com.jd.blockchain.crypto.impl.jni.asymmetric;
+//
+//import com.jd.blockchain.crypto.CryptoAlgorithm;
+//import com.jd.blockchain.crypto.asymmetric.*;
+//import com.jd.blockchain.crypto.jniutils.asymmetric.JNIED25519Utils;
+//
+//import static com.jd.blockchain.crypto.CryptoAlgorithm.JNIED25519;
+//import static com.jd.blockchain.crypto.CryptoBytes.ALGORYTHM_BYTES;
+//import static com.jd.blockchain.crypto.CryptoKeyType.PRIV_KEY;
+//import static com.jd.blockchain.crypto.CryptoKeyType.PUB_KEY;
+//import static com.jd.blockchain.crypto.base.BaseCryptoKey.KEY_TYPE_BYTES;
+//
+//public class JNIED25519SignatureFunction implements SignatureFunction {
+//
+//    private static final int PUBKEY_SIZE = 32;
+//    private static final int PRIVKEY_SIZE = 32;
+//    private static final int DIGEST_SIZE = 64;
+//
+//    private static final int PUBKEY_LENGTH = ALGORYTHM_BYTES + KEY_TYPE_BYTES + PUBKEY_SIZE;
+//    private static final int PRIVKEY_LENGTH = ALGORYTHM_BYTES + KEY_TYPE_BYTES + PRIVKEY_SIZE;
+//    private static final int SIGNATUREDIGEST_LENGTH = ALGORYTHM_BYTES + DIGEST_SIZE;
+//
+//    public JNIED25519SignatureFunction() {
+//    }
+//
+//    @Override
+//    public SignatureDigest sign(PrivKey privKey, byte[] data) {
+//
+//        if (data == null)
+//            throw new IllegalArgumentException("This data is null!");
+//
+//        JNIED25519Utils ed25519 = new JNIED25519Utils();
+//
+//        byte[] rawPrivKeyBytes = privKey.getRawKeyBytes();
+//        byte[] rawPubKeyBytes = ed25519.getPubKey(rawPrivKeyBytes);
+//
+//        // 验证原始私钥长度为256比特，即32字节
+//        if (rawPrivKeyBytes.length != PRIVKEY_SIZE)
+//            throw new IllegalArgumentException("This key has wrong format!");
+//
+//        // 验证密钥数据的算法标识对应JNIED25519签名算法
+//        if (privKey.getAlgorithm() != JNIED25519)
+//            throw new IllegalArgumentException("This key is not ED25519 private key!");
+//
+//        // 调用JNIED25519签名算法计算签名结果
+//        return new SignatureDigest(JNIED25519, ed25519.sign(data, rawPrivKeyBytes, rawPubKeyBytes));
+//    }
+//
+//    @Override
+//    public boolean verify(SignatureDigest digest, PubKey pubKey, byte[] data) {
+//
+//        JNIED25519Utils ed25519 = new JNIED25519Utils();
+//
+//        byte[] rawPubKeyBytes = pubKey.getRawKeyBytes();
+//        byte[] rawDigestBytes = digest.getRawDigest();
+//
+//        // 验证原始公钥长度为256比特，即32字节
+//        if (rawPubKeyBytes.length != PUBKEY_SIZE)
+//            throw new IllegalArgumentException("This key has wrong format!");
+//
+//        // 验证密钥数据的算法标识对应JNIED25519签名算法
+//        if (pubKey.getAlgorithm() != JNIED25519)
+//            throw new IllegalArgumentException("This key is not ED25519 public key!");
+//
+//        // 验证密文数据的算法标识对应JNIED25519签名算法，并且原始摘要长度为64字节
+//        if (digest.getAlgorithm() != JNIED25519 || rawDigestBytes.length != DIGEST_SIZE)
+//            throw new IllegalArgumentException("This is not ED25519 signature digest!");
+//
+//        // 调用JNIED25519验签算法验证签名结果
+//        return ed25519.verify(data, rawPubKeyBytes, rawDigestBytes);
+//    }
+//
+//    @Override
+//    public boolean supportPrivKey(byte[] privKeyBytes) {
+//        // 验证输入字节数组长度=算法标识长度+密钥类型长度+密钥长度，密钥数据的算法标识对应JNIED25519签名算法，并且密钥类型是私钥
+//        return privKeyBytes.length == PRIVKEY_LENGTH
+//                && privKeyBytes[0] == JNIED25519.CODE && privKeyBytes[1] == PRIV_KEY.CODE;
+//    }
+//
+//    @Override
+//    public PrivKey resolvePrivKey(byte[] privKeyBytes) {
+//        // 由框架调用 support 方法检查有效性，在此不做重复检查；
+//        return new PrivKey(privKeyBytes);
+//    }
+//
+//    @Override
+//    public boolean supportPubKey(byte[] pubKeyBytes) {
+//        // 验证输入字节数组长度=算法标识长度+密钥类型长度+密钥长度，密钥数据的算法标识对应JNIED25519签名算法，并且密钥类型是公钥
+//        return pubKeyBytes.length == PUBKEY_LENGTH &&
+//                pubKeyBytes[0] == JNIED25519.CODE && pubKeyBytes[1] == PUB_KEY.CODE;
+//
+//    }
+//
+//    @Override
+//    public PubKey resolvePubKey(byte[] pubKeyBytes) {
+//        // 由框架调用 support 方法检查有效性，在此不做重复检查；
+//        return new PubKey(pubKeyBytes);
+//    }
+//
+//    @Override
+//    public boolean supportDigest(byte[] digestBytes) {
+//        // 验证输入字节数组长度=算法标识长度+摘要长度，字节数组的算法标识对应JNIED25519算法
+//        return digestBytes.length == SIGNATUREDIGEST_LENGTH && digestBytes[0] == JNIED25519.CODE;
+//    }
+//
+//    @Override
+//    public SignatureDigest resolveDigest(byte[] digestBytes) {
+//        // 由框架调用 support 方法检查有效性，在此不做重复检查；
+//        return new SignatureDigest(digestBytes);
+//    }
+//
+//    @Override
+//    public CryptoAlgorithm getAlgorithm() {
+//        return JNIED25519;
+//    }
+//
+//    @Override
+//    public CryptoKeyPair generateKeyPair() {
+//
+//        JNIED25519Utils ed25519 = new JNIED25519Utils();
+//        byte[] rawPrivKeyBytes = new byte[PRIVKEY_SIZE];
+//        byte[] rawPubKeyBytes = new byte[PUBKEY_SIZE];
+//
+//        // 调用JNIED25519算法的密钥生成算法生成公私钥对
+//        ed25519.generateKeyPair(rawPrivKeyBytes, rawPubKeyBytes);
+//
+//        return new CryptoKeyPair(new PubKey(JNIED25519, rawPubKeyBytes), new PrivKey(JNIED25519, rawPrivKeyBytes));
+//
+//    }
+//}

source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/impl/jni/hash/JNIRIPEMD160HashFunction.java

@@ -1,53 +1,53 @@
-package com.jd.blockchain.crypto.impl.jni.hash;
-
-import com.jd.blockchain.crypto.CryptoAlgorithm;
-import com.jd.blockchain.crypto.hash.HashDigest;
-import com.jd.blockchain.crypto.hash.HashFunction;
-import com.jd.blockchain.crypto.jniutils.hash.JNIRIPEMD160Utils;
-
-import java.util.Arrays;
-
-import static com.jd.blockchain.crypto.CryptoAlgorithm.JNIRIPEMD160;
-import static com.jd.blockchain.crypto.CryptoBytes.ALGORYTHM_BYTES;
-
-public class JNIRIPEMD160HashFunction implements HashFunction {
-
-    private static final int DIGEST_BYTES = 160 / 8;
-
-    private static final int DIGEST_LENGTH = ALGORYTHM_BYTES + DIGEST_BYTES;
-
-    @Override
-    public CryptoAlgorithm getAlgorithm() {
-        return JNIRIPEMD160;
-    }
-
-    @Override
-    public HashDigest hash(byte[] data) {
-
-        if (data == null)
-            throw new IllegalArgumentException("This data is null!");
-
-        JNIRIPEMD160Utils ripemd160 = new JNIRIPEMD160Utils();
-        byte[] digestBytes = ripemd160.hash(data);
-        return new HashDigest(JNIRIPEMD160, digestBytes);
-    }
-
-    @Override
-    public boolean verify(HashDigest digest, byte[] data) {
-        HashDigest hashDigest = hash(data);
-        return Arrays.equals(hashDigest.toBytes(), digest.toBytes());
-    }
-
-    @Override
-    public boolean supportHashDigest(byte[] digestBytes) {
-        // 验证输入字节数组长度=算法标识长度+摘要长度，字节数组的算法标识对应JNIRIPEMD160算法
-        return digestBytes.length == DIGEST_LENGTH && JNIRIPEMD160.CODE == digestBytes[0];
-    }
-
-    @Override
-    public HashDigest resolveHashDigest(byte[] digestBytes) {
-        // 由框架调用 support 方法检查有效性，在此不做重复检查；
-        return new HashDigest(digestBytes);
-    }
-}
-
+//package com.jd.blockchain.crypto.impl.jni.hash;
+//
+//import com.jd.blockchain.crypto.CryptoAlgorithm;
+//import com.jd.blockchain.crypto.hash.HashDigest;
+//import com.jd.blockchain.crypto.hash.HashFunction;
+//import com.jd.blockchain.crypto.jniutils.hash.JNIRIPEMD160Utils;
+//
+//import java.util.Arrays;
+//
+//import static com.jd.blockchain.crypto.CryptoAlgorithm.JNIRIPEMD160;
+//import static com.jd.blockchain.crypto.CryptoBytes.ALGORYTHM_BYTES;
+//
+//public class JNIRIPEMD160HashFunction implements HashFunction {
+//
+//    private static final int DIGEST_BYTES = 160 / 8;
+//
+//    private static final int DIGEST_LENGTH = ALGORYTHM_BYTES + DIGEST_BYTES;
+//
+//    @Override
+//    public CryptoAlgorithm getAlgorithm() {
+//        return JNIRIPEMD160;
+//    }
+//
+//    @Override
+//    public HashDigest hash(byte[] data) {
+//
+//        if (data == null)
+//            throw new IllegalArgumentException("This data is null!");
+//
+//        JNIRIPEMD160Utils ripemd160 = new JNIRIPEMD160Utils();
+//        byte[] digestBytes = ripemd160.hash(data);
+//        return new HashDigest(JNIRIPEMD160, digestBytes);
+//    }
+//
+//    @Override
+//    public boolean verify(HashDigest digest, byte[] data) {
+//        HashDigest hashDigest = hash(data);
+//        return Arrays.equals(hashDigest.toBytes(), digest.toBytes());
+//    }
+//
+//    @Override
+//    public boolean supportHashDigest(byte[] digestBytes) {
+//        // 验证输入字节数组长度=算法标识长度+摘要长度，字节数组的算法标识对应JNIRIPEMD160算法
+//        return digestBytes.length == DIGEST_LENGTH && JNIRIPEMD160.CODE == digestBytes[0];
+//    }
+//
+//    @Override
+//    public HashDigest resolveHashDigest(byte[] digestBytes) {
+//        // 由框架调用 support 方法检查有效性，在此不做重复检查；
+//        return new HashDigest(digestBytes);
+//    }
+//}
+//

source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/impl/jni/hash/JNISHA256HashFunction.java

@@ -1,53 +1,53 @@
-package com.jd.blockchain.crypto.impl.jni.hash;
-
-import com.jd.blockchain.crypto.CryptoAlgorithm;
-import com.jd.blockchain.crypto.hash.HashDigest;
-import com.jd.blockchain.crypto.hash.HashFunction;
-import com.jd.blockchain.crypto.jniutils.hash.JNISHA256Utils;
-
-import java.util.Arrays;
-
-import static com.jd.blockchain.crypto.CryptoAlgorithm.JNISHA256;
-import static com.jd.blockchain.crypto.CryptoBytes.ALGORYTHM_BYTES;
-
-public class JNISHA256HashFunction implements HashFunction {
-
-    private static final int DIGEST_BYTES = 256/8;
-
-    private static final int DIGEST_LENGTH = ALGORYTHM_BYTES + DIGEST_BYTES;
-
-    @Override
-    public CryptoAlgorithm getAlgorithm() {
-        return JNISHA256;
-    }
-
-    @Override
-    public HashDigest hash(byte[] data) {
-
-        if (data == null)
-            throw new IllegalArgumentException("This data is null!");
-
-        JNISHA256Utils sha256 = new JNISHA256Utils();
-        byte[] digestBytes = sha256.hash(data);
-        return new HashDigest(JNISHA256,digestBytes);
-    }
-
-    @Override
-    public boolean verify(HashDigest digest, byte[] data) {
-        HashDigest hashDigest=hash(data);
-        return Arrays.equals(hashDigest.toBytes(),digest.toBytes());
-    }
-
-    @Override
-    public boolean supportHashDigest(byte[] digestBytes) {
-        // 验证输入字节数组长度=算法标识长度+摘要长度，字节数组的算法标识对应JNISHA256算法
-        return digestBytes.length == DIGEST_LENGTH && JNISHA256.CODE == digestBytes[0];
-    }
-
-    @Override
-    public HashDigest resolveHashDigest(byte[] hashDigestBytes) {
-        // 由框架调用 support 方法检查有效性，在此不做重复检查；
-        return new HashDigest(hashDigestBytes);
-    }
-
-}
+//package com.jd.blockchain.crypto.impl.jni.hash;
+//
+//import com.jd.blockchain.crypto.CryptoAlgorithm;
+//import com.jd.blockchain.crypto.hash.HashDigest;
+//import com.jd.blockchain.crypto.hash.HashFunction;
+//import com.jd.blockchain.crypto.jniutils.hash.JNISHA256Utils;
+//
+//import java.util.Arrays;
+//
+//import static com.jd.blockchain.crypto.CryptoAlgorithm.JNISHA256;
+//import static com.jd.blockchain.crypto.CryptoBytes.ALGORYTHM_BYTES;
+//
+//public class JNISHA256HashFunction implements HashFunction {
+//
+//    private static final int DIGEST_BYTES = 256/8;
+//
+//    private static final int DIGEST_LENGTH = ALGORYTHM_BYTES + DIGEST_BYTES;
+//
+//    @Override
+//    public CryptoAlgorithm getAlgorithm() {
+//        return JNISHA256;
+//    }
+//
+//    @Override
+//    public HashDigest hash(byte[] data) {
+//
+//        if (data == null)
+//            throw new IllegalArgumentException("This data is null!");
+//
+//        JNISHA256Utils sha256 = new JNISHA256Utils();
+//        byte[] digestBytes = sha256.hash(data);
+//        return new HashDigest(JNISHA256,digestBytes);
+//    }
+//
+//    @Override
+//    public boolean verify(HashDigest digest, byte[] data) {
+//        HashDigest hashDigest=hash(data);
+//        return Arrays.equals(hashDigest.toBytes(),digest.toBytes());
+//    }
+//
+//    @Override
+//    public boolean supportHashDigest(byte[] digestBytes) {
+//        // 验证输入字节数组长度=算法标识长度+摘要长度，字节数组的算法标识对应JNISHA256算法
+//        return digestBytes.length == DIGEST_LENGTH && JNISHA256.CODE == digestBytes[0];
+//    }
+//
+//    @Override
+//    public HashDigest resolveHashDigest(byte[] hashDigestBytes) {
+//        // 由框架调用 support 方法检查有效性，在此不做重复检查；
+//        return new HashDigest(hashDigestBytes);
+//    }
+//
+//}

source/crypto/crypto-framework/src/test/java/test/com/jd/blockchain/crypto/asymmetric/AsymmtricCryptographyImplTest.java

@@ -91,36 +91,36 @@ public class AsymmtricCryptographyImplTest {
 
 
         //test JNIED25519
-        algorithm = CryptoAlgorithm.JNIED25519;
-        keyPair = asymmetricCrypto.generateKeyPair(algorithm);
-
-        assertNotNull(keyPair);
-
-        pubKey = keyPair.getPubKey();
-        privKey = keyPair.getPrivKey();
-
-        assertNotNull(pubKey);
-        assertNotNull(privKey);
-
-        assertEquals(algorithm,pubKey.getAlgorithm());
-        assertEquals(algorithm,privKey.getAlgorithm());
-
-        assertEquals(32,pubKey.getRawKeyBytes().length);
-        assertEquals(32,privKey.getRawKeyBytes().length);
-
-        pubKeyBytes = pubKey.toBytes();
-        privKeyBytes = privKey.toBytes();
-
-        assertEquals(32+1+1,pubKeyBytes.length);
-        assertEquals(32+1+1,privKeyBytes.length);
-
-        assertEquals(CryptoAlgorithm.JNIED25519.CODE,pubKeyBytes[0]);
-        assertEquals(CryptoAlgorithm.JNIED25519.CODE,privKeyBytes[0]);
-        assertEquals(CryptoAlgorithm.JNIED25519, CryptoAlgorithm.valueOf(pubKey.getAlgorithm().CODE));
-        assertEquals(CryptoAlgorithm.JNIED25519, CryptoAlgorithm.valueOf(privKey.getAlgorithm().CODE));
-
-        assertEquals(pubKey.getKeyType().CODE,pubKeyBytes[1]);
-        assertEquals(privKey.getKeyType().CODE,privKeyBytes[1]);
+//        algorithm = CryptoAlgorithm.JNIED25519;
+//        keyPair = asymmetricCrypto.generateKeyPair(algorithm);
+//
+//        assertNotNull(keyPair);
+//
+//        pubKey = keyPair.getPubKey();
+//        privKey = keyPair.getPrivKey();
+//
+//        assertNotNull(pubKey);
+//        assertNotNull(privKey);
+//
+//        assertEquals(algorithm,pubKey.getAlgorithm());
+//        assertEquals(algorithm,privKey.getAlgorithm());
+//
+//        assertEquals(32,pubKey.getRawKeyBytes().length);
+//        assertEquals(32,privKey.getRawKeyBytes().length);
+//
+//        pubKeyBytes = pubKey.toBytes();
+//        privKeyBytes = privKey.toBytes();
+//
+//        assertEquals(32+1+1,pubKeyBytes.length);
+//        assertEquals(32+1+1,privKeyBytes.length);
+//
+//        assertEquals(CryptoAlgorithm.JNIED25519.CODE,pubKeyBytes[0]);
+//        assertEquals(CryptoAlgorithm.JNIED25519.CODE,privKeyBytes[0]);
+//        assertEquals(CryptoAlgorithm.JNIED25519, CryptoAlgorithm.valueOf(pubKey.getAlgorithm().CODE));
+//        assertEquals(CryptoAlgorithm.JNIED25519, CryptoAlgorithm.valueOf(privKey.getAlgorithm().CODE));
+//
+//        assertEquals(pubKey.getKeyType().CODE,pubKeyBytes[1]);
+//        assertEquals(privKey.getKeyType().CODE,privKeyBytes[1]);
     }
 
     @Test
@@ -160,19 +160,19 @@ public class AsymmtricCryptographyImplTest {
         verifyGetSignatureFunction(asymmetricCrypto,algorithm,data,65,32,64,NullPointerException.class);
 
 
-        //test JNNIED25519
-        algorithm = CryptoAlgorithm.JNIED25519;
-
-        // 测试256字节的消息进行签名
-        data = new byte[256];
-        random.nextBytes(data);
-        verifyGetSignatureFunction(asymmetricCrypto,algorithm,data,32,32,64,null);
-
-        //错误的算法标识
-        verifyGetSignatureFunction(asymmetricCrypto,CryptoAlgorithm.AES,data,32,32,64,IllegalArgumentException.class);
-
-        data = null;
-        verifyGetSignatureFunction(asymmetricCrypto,algorithm,data,32,32,64,IllegalArgumentException.class);
+//        //test JNNIED25519
+//        algorithm = CryptoAlgorithm.JNIED25519;
+//
+//        // 测试256字节的消息进行签名
+//        data = new byte[256];
+//        random.nextBytes(data);
+//        verifyGetSignatureFunction(asymmetricCrypto,algorithm,data,32,32,64,null);
+//
+//        //错误的算法标识
+//        verifyGetSignatureFunction(asymmetricCrypto,CryptoAlgorithm.AES,data,32,32,64,IllegalArgumentException.class);
+//
+//        data = null;
+//        verifyGetSignatureFunction(asymmetricCrypto,algorithm,data,32,32,64,IllegalArgumentException.class);
     }
 
     private void verifyGetSignatureFunction(AsymmetricCryptography asymmetricCrypto, CryptoAlgorithm algorithm, byte[] data,
@@ -296,30 +296,30 @@ public class AsymmtricCryptographyImplTest {
         signatureDigestBytes = null;
         verifyVerify(asymmetricCrypto,false,data,pubKeyBytes,signatureDigestBytes,NullPointerException.class);
 
-        //test JNIED25519
-        algorithm = CryptoAlgorithm.JNIED25519;
-
-        // 测试256字节的消息进行签名
-        data = new byte[256];
-        randomData.nextBytes(data);
-        sf = asymmetricCrypto.getSignatureFunction(algorithm);
-        keyPair = sf.generateKeyPair();
-        pubKeyBytes = keyPair.getPubKey().toBytes();
-
-        signatureDigestBytes = sf.sign(keyPair.getPrivKey(),data).toBytes();
-        verifyVerify(asymmetricCrypto,true,data,pubKeyBytes,signatureDigestBytes,null);
-
-        //签名数据末尾两个字节丢失情况下，抛出异常
-        truncatedSignatureDigestBytes = new byte[signatureDigestBytes.length-2];
-        System.arraycopy(signatureDigestBytes,0,truncatedSignatureDigestBytes,0,truncatedSignatureDigestBytes.length);
-        verifyVerify(asymmetricCrypto,false,data,pubKeyBytes,truncatedSignatureDigestBytes,IllegalArgumentException.class);
-
-        signatureDigestBytesWithWrongAlgCode = signatureDigestBytes;
-        signatureDigestBytesWithWrongAlgCode[0] = CryptoAlgorithm.SHA256.CODE;
-        verifyVerify(asymmetricCrypto,false,data,pubKeyBytes,signatureDigestBytesWithWrongAlgCode,IllegalArgumentException.class);
-
-        signatureDigestBytes = null;
-        verifyVerify(asymmetricCrypto,false,data,pubKeyBytes,signatureDigestBytes,NullPointerException.class);
+//        //test JNIED25519
+//        algorithm = CryptoAlgorithm.JNIED25519;
+//
+//        // 测试256字节的消息进行签名
+//        data = new byte[256];
+//        randomData.nextBytes(data);
+//        sf = asymmetricCrypto.getSignatureFunction(algorithm);
+//        keyPair = sf.generateKeyPair();
+//        pubKeyBytes = keyPair.getPubKey().toBytes();
+//
+//        signatureDigestBytes = sf.sign(keyPair.getPrivKey(),data).toBytes();
+//        verifyVerify(asymmetricCrypto,true,data,pubKeyBytes,signatureDigestBytes,null);
+//
+//        //签名数据末尾两个字节丢失情况下，抛出异常
+//        truncatedSignatureDigestBytes = new byte[signatureDigestBytes.length-2];
+//        System.arraycopy(signatureDigestBytes,0,truncatedSignatureDigestBytes,0,truncatedSignatureDigestBytes.length);
+//        verifyVerify(asymmetricCrypto,false,data,pubKeyBytes,truncatedSignatureDigestBytes,IllegalArgumentException.class);
+//
+//        signatureDigestBytesWithWrongAlgCode = signatureDigestBytes;
+//        signatureDigestBytesWithWrongAlgCode[0] = CryptoAlgorithm.SHA256.CODE;
+//        verifyVerify(asymmetricCrypto,false,data,pubKeyBytes,signatureDigestBytesWithWrongAlgCode,IllegalArgumentException.class);
+//
+//        signatureDigestBytes = null;
+//        verifyVerify(asymmetricCrypto,false,data,pubKeyBytes,signatureDigestBytes,NullPointerException.class);
     }
 
     private void verifyVerify(AsymmetricCryptography asymmetricCrypto,boolean expectedResult,byte[] data,
@@ -620,25 +620,25 @@ public class AsymmtricCryptographyImplTest {
         signatureDigestBytes = null;
         verifyResolveSignatureDigest(asymmetricCrypto,algorithm,64,signatureDigestBytes,NullPointerException.class);
 
-        //test JNIED25519
-        algorithm = CryptoAlgorithm.JNIED25519;
-
-        // 测试256字节的消息进行签名
-        data = new byte[256];
-        randomData.nextBytes(data);
-        sf = asymmetricCrypto.getSignatureFunction(algorithm);
-        keyPair = sf.generateKeyPair();
-
-        signatureDigestBytes = sf.sign(keyPair.getPrivKey(),data).toBytes();
-        verifyResolveSignatureDigest(asymmetricCrypto,algorithm,64,signatureDigestBytes,null);
-
-        //签名数据末尾两个字节丢失情况下，抛出异常
-        truncatedSignatureDigestBytes = new byte[signatureDigestBytes.length-2];
-        System.arraycopy(signatureDigestBytes,0,truncatedSignatureDigestBytes,0,truncatedSignatureDigestBytes.length);
-        verifyResolveSignatureDigest(asymmetricCrypto,algorithm,64,truncatedSignatureDigestBytes,IllegalArgumentException.class);
-
-        signatureDigestBytes = null;
-        verifyResolveSignatureDigest(asymmetricCrypto,algorithm,64,signatureDigestBytes,NullPointerException.class);
+//        //test JNIED25519
+//        algorithm = CryptoAlgorithm.JNIED25519;
+//
+//        // 测试256字节的消息进行签名
+//        data = new byte[256];
+//        randomData.nextBytes(data);
+//        sf = asymmetricCrypto.getSignatureFunction(algorithm);
+//        keyPair = sf.generateKeyPair();
+//
+//        signatureDigestBytes = sf.sign(keyPair.getPrivKey(),data).toBytes();
+//        verifyResolveSignatureDigest(asymmetricCrypto,algorithm,64,signatureDigestBytes,null);
+//
+//        //签名数据末尾两个字节丢失情况下，抛出异常
+//        truncatedSignatureDigestBytes = new byte[signatureDigestBytes.length-2];
+//        System.arraycopy(signatureDigestBytes,0,truncatedSignatureDigestBytes,0,truncatedSignatureDigestBytes.length);
+//        verifyResolveSignatureDigest(asymmetricCrypto,algorithm,64,truncatedSignatureDigestBytes,IllegalArgumentException.class);
+//
+//        signatureDigestBytes = null;
+//        verifyResolveSignatureDigest(asymmetricCrypto,algorithm,64,signatureDigestBytes,NullPointerException.class);
     }
 
     private void verifyResolveSignatureDigest(AsymmetricCryptography asymmetricCrypto, CryptoAlgorithm algorithm,
@@ -730,28 +730,28 @@ public class AsymmtricCryptographyImplTest {
         pubKeyBytes = null;
         verifyResolvePubKey(asymmetricCrypto,algorithm,65,pubKeyBytes,NullPointerException.class);
 
-        //test JNIED25519
-        algorithm = CryptoAlgorithm.JNIED25519;
-
-        keyPair = asymmetricCrypto.generateKeyPair(algorithm);
-
-        pubKeyBytes = keyPair.getPubKey().toBytes();
-        verifyResolvePubKey(asymmetricCrypto,algorithm,32,pubKeyBytes,null);
-
-        truncatedPubKeyBytes = new byte[pubKeyBytes.length-2];
-        System.arraycopy(pubKeyBytes,0,truncatedPubKeyBytes,0,truncatedPubKeyBytes.length);
-        verifyResolvePubKey(asymmetricCrypto,algorithm,32,truncatedPubKeyBytes,IllegalArgumentException.class);
-
-        pubKeyBytesWithWrongAlgCode = pubKeyBytes;
-        pubKeyBytesWithWrongAlgCode[0] = CryptoAlgorithm.SHA256.CODE;
-        verifyResolvePubKey(asymmetricCrypto,algorithm,32,pubKeyBytesWithWrongAlgCode,IllegalArgumentException.class);
-
-        pubKeyBytesWithWrongKeyType= pubKeyBytes;
-        pubKeyBytesWithWrongKeyType[1] = PRIV_KEY.CODE;
-        verifyResolvePubKey(asymmetricCrypto,algorithm,32,pubKeyBytesWithWrongKeyType,IllegalArgumentException.class);
-
-        pubKeyBytes = null;
-        verifyResolvePubKey(asymmetricCrypto,algorithm,32,pubKeyBytes,NullPointerException.class);
+//        //test JNIED25519
+//        algorithm = CryptoAlgorithm.JNIED25519;
+//
+//        keyPair = asymmetricCrypto.generateKeyPair(algorithm);
+//
+//        pubKeyBytes = keyPair.getPubKey().toBytes();
+//        verifyResolvePubKey(asymmetricCrypto,algorithm,32,pubKeyBytes,null);
+//
+//        truncatedPubKeyBytes = new byte[pubKeyBytes.length-2];
+//        System.arraycopy(pubKeyBytes,0,truncatedPubKeyBytes,0,truncatedPubKeyBytes.length);
+//        verifyResolvePubKey(asymmetricCrypto,algorithm,32,truncatedPubKeyBytes,IllegalArgumentException.class);
+//
+//        pubKeyBytesWithWrongAlgCode = pubKeyBytes;
+//        pubKeyBytesWithWrongAlgCode[0] = CryptoAlgorithm.SHA256.CODE;
+//        verifyResolvePubKey(asymmetricCrypto,algorithm,32,pubKeyBytesWithWrongAlgCode,IllegalArgumentException.class);
+//
+//        pubKeyBytesWithWrongKeyType= pubKeyBytes;
+//        pubKeyBytesWithWrongKeyType[1] = PRIV_KEY.CODE;
+//        verifyResolvePubKey(asymmetricCrypto,algorithm,32,pubKeyBytesWithWrongKeyType,IllegalArgumentException.class);
+//
+//        pubKeyBytes = null;
+//        verifyResolvePubKey(asymmetricCrypto,algorithm,32,pubKeyBytes,NullPointerException.class);
     }
 
     private void verifyResolvePubKey(AsymmetricCryptography asymmetricCrypto, CryptoAlgorithm algorithm,
@@ -840,28 +840,28 @@ public class AsymmtricCryptographyImplTest {
         privKeyBytes = null;
         verifyResolvePrivKey(asymmetricCrypto,algorithm,32,privKeyBytes,NullPointerException.class);
 
-        //test JNIED25519
-        algorithm = CryptoAlgorithm.JNIED25519;
-
-        keyPair = asymmetricCrypto.generateKeyPair(algorithm);
-
-        privKeyBytes = keyPair.getPrivKey().toBytes();
-        verifyResolvePrivKey(asymmetricCrypto,algorithm,32,privKeyBytes,null);
-
-        truncatedPrivKeyBytes = new byte[privKeyBytes.length-2];
-        System.arraycopy(privKeyBytes,0,truncatedPrivKeyBytes,0,truncatedPrivKeyBytes.length);
-        verifyResolvePrivKey(asymmetricCrypto,algorithm,32,truncatedPrivKeyBytes,IllegalArgumentException.class);
-
-        privKeyBytesWithWrongAlgCode = privKeyBytes;
-        privKeyBytesWithWrongAlgCode[0] = CryptoAlgorithm.SHA256.CODE;
-        verifyResolvePrivKey(asymmetricCrypto,algorithm,32,privKeyBytesWithWrongAlgCode,IllegalArgumentException.class);
-
-        privKeyBytesWithWrongKeyType = privKeyBytes;
-        privKeyBytesWithWrongKeyType[1] = PUB_KEY.CODE;
-        verifyResolvePrivKey(asymmetricCrypto,algorithm,32,privKeyBytesWithWrongKeyType,IllegalArgumentException.class);
-
-        privKeyBytes = null;
-        verifyResolvePrivKey(asymmetricCrypto,algorithm,32,privKeyBytes,NullPointerException.class);
+//        //test JNIED25519
+//        algorithm = CryptoAlgorithm.JNIED25519;
+//
+//        keyPair = asymmetricCrypto.generateKeyPair(algorithm);
+//
+//        privKeyBytes = keyPair.getPrivKey().toBytes();
+//        verifyResolvePrivKey(asymmetricCrypto,algorithm,32,privKeyBytes,null);
+//
+//        truncatedPrivKeyBytes = new byte[privKeyBytes.length-2];
+//        System.arraycopy(privKeyBytes,0,truncatedPrivKeyBytes,0,truncatedPrivKeyBytes.length);
+//        verifyResolvePrivKey(asymmetricCrypto,algorithm,32,truncatedPrivKeyBytes,IllegalArgumentException.class);
+//
+//        privKeyBytesWithWrongAlgCode = privKeyBytes;
+//        privKeyBytesWithWrongAlgCode[0] = CryptoAlgorithm.SHA256.CODE;
+//        verifyResolvePrivKey(asymmetricCrypto,algorithm,32,privKeyBytesWithWrongAlgCode,IllegalArgumentException.class);
+//
+//        privKeyBytesWithWrongKeyType = privKeyBytes;
+//        privKeyBytesWithWrongKeyType[1] = PUB_KEY.CODE;
+//        verifyResolvePrivKey(asymmetricCrypto,algorithm,32,privKeyBytesWithWrongKeyType,IllegalArgumentException.class);
+//
+//        privKeyBytes = null;
+//        verifyResolvePrivKey(asymmetricCrypto,algorithm,32,privKeyBytes,NullPointerException.class);
     }
 
     private void verifyResolvePrivKey(AsymmetricCryptography asymmetricCrypto, CryptoAlgorithm algorithm,

source/crypto/crypto-framework/src/test/java/test/com/jd/blockchain/crypto/hash/HashCryptographyImplTest.java

@@ -77,37 +77,37 @@ public class HashCryptographyImplTest {
 		algorithm = CryptoAlgorithm.AES;
 		verifyGetFunction(hashCrypto, algorithm, data, 256 / 8,IllegalArgumentException.class);
 
-		// test JNISHA256
-		algorithm = CryptoAlgorithm.JNISHA256;
-		data = new byte[256];
-		rand.nextBytes(data);
-		verifyGetFunction(hashCrypto, algorithm, data, 256 / 8,null);
-
-		data = new byte[0];
-		verifyGetFunction(hashCrypto, algorithm, data, 256 / 8,null);
-
-		data = new byte[1056];
-		rand.nextBytes(data);
-		verifyGetFunction(hashCrypto, algorithm, data, 256 / 8,null);
-
-		data = null;
-		verifyGetFunction(hashCrypto, algorithm, data, 256 / 8,IllegalArgumentException.class);
-
-		// test JNIRIPEMD160
-		algorithm = CryptoAlgorithm.JNIRIPEMD160;
-		data=new byte[256];
-		rand.nextBytes(data);
-		verifyGetFunction(hashCrypto, algorithm, data, 160 / 8,null);
-
-		data = new byte[0];
-		verifyGetFunction(hashCrypto, algorithm, data, 160/ 8,null);
-
-		data = new byte[1056];
-		rand.nextBytes(data);
-		verifyGetFunction(hashCrypto, algorithm, data, 160 / 8,null);
-
-		data = null;
-		verifyGetFunction(hashCrypto, algorithm, data, 160 / 8,IllegalArgumentException.class);
+//		// test JNISHA256
+//		algorithm = CryptoAlgorithm.JNISHA256;
+//		data = new byte[256];
+//		rand.nextBytes(data);
+//		verifyGetFunction(hashCrypto, algorithm, data, 256 / 8,null);
+//
+//		data = new byte[0];
+//		verifyGetFunction(hashCrypto, algorithm, data, 256 / 8,null);
+//
+//		data = new byte[1056];
+//		rand.nextBytes(data);
+//		verifyGetFunction(hashCrypto, algorithm, data, 256 / 8,null);
+//
+//		data = null;
+//		verifyGetFunction(hashCrypto, algorithm, data, 256 / 8,IllegalArgumentException.class);
+//
+//		// test JNIRIPEMD160
+//		algorithm = CryptoAlgorithm.JNIRIPEMD160;
+//		data=new byte[256];
+//		rand.nextBytes(data);
+//		verifyGetFunction(hashCrypto, algorithm, data, 160 / 8,null);
+//
+//		data = new byte[0];
+//		verifyGetFunction(hashCrypto, algorithm, data, 160/ 8,null);
+//
+//		data = new byte[1056];
+//		rand.nextBytes(data);
+//		verifyGetFunction(hashCrypto, algorithm, data, 160 / 8,null);
+//
+//		data = null;
+//		verifyGetFunction(hashCrypto, algorithm, data, 160 / 8,IllegalArgumentException.class);
 	}
 
 	private void verifyGetFunction(HashCryptography hashCrypto, CryptoAlgorithm algorithm, byte[] data,
@@ -184,22 +184,22 @@ public class HashCryptographyImplTest {
 		rand.nextBytes(data);
 		verifyHashDigestByteArray(hashCrypto,algorithm,data,IllegalArgumentException.class);
 
-		//test JNISHA256
-		data=new byte[256];
-		rand = new Random();
-		rand.nextBytes(data);
-		algorithm=CryptoAlgorithm.JNISHA256;
-		verifyHashDigestByteArray(hashCrypto,algorithm,data,null);
-		data=null;
-		verifyHashDigestByteArray(hashCrypto,algorithm,data,IllegalArgumentException.class);
-
-		//test JNIRIPEMD160
-		algorithm=CryptoAlgorithm.JNIRIPEMD160;
-		data=new byte[896];
-		rand.nextBytes(data);
-		verifyHashDigestByteArray(hashCrypto,algorithm,data,null);
-		data=null;
-		verifyHashDigestByteArray(hashCrypto,algorithm,data,IllegalArgumentException.class);
+//		//test JNISHA256
+//		data=new byte[256];
+//		rand = new Random();
+//		rand.nextBytes(data);
+//		algorithm=CryptoAlgorithm.JNISHA256;
+//		verifyHashDigestByteArray(hashCrypto,algorithm,data,null);
+//		data=null;
+//		verifyHashDigestByteArray(hashCrypto,algorithm,data,IllegalArgumentException.class);
+//
+//		//test JNIRIPEMD160
+//		algorithm=CryptoAlgorithm.JNIRIPEMD160;
+//		data=new byte[896];
+//		rand.nextBytes(data);
+//		verifyHashDigestByteArray(hashCrypto,algorithm,data,null);
+//		data=null;
+//		verifyHashDigestByteArray(hashCrypto,algorithm,data,IllegalArgumentException.class);
 	}
 
 	private void verifyHashDigestByteArray(HashCryptography hashCrypto,CryptoAlgorithm algorithm,byte[] data,Class<?> expectedException){
@@ -273,33 +273,33 @@ public class HashCryptographyImplTest {
 		verifyResolveHashDigest(algorithm, hashCrypto,hashDigestBytes,32+1,NullPointerException.class);
 
 
-		//test JNISHA256
-		algorithm = CryptoAlgorithm.JNISHA256;
-		data = new byte[256];
-		rand.nextBytes(data);
-		hashDigestBytes = hashCrypto.getFunction(algorithm).hash(data).toBytes();
-		verifyResolveHashDigest(algorithm, hashCrypto,hashDigestBytes,32+1,null);
-
-		truncatedHashDigestBytes = new byte[hashDigestBytes.length-2];
-		System.arraycopy(hashDigestBytes,0,truncatedHashDigestBytes,0,truncatedHashDigestBytes.length);
-		verifyResolveHashDigest(algorithm, hashCrypto,truncatedHashDigestBytes,32+1,IllegalArgumentException.class);
-
-		hashDigestBytes = null;
-		verifyResolveHashDigest(algorithm, hashCrypto,hashDigestBytes,32+1,NullPointerException.class);
-
-		//test JNIRIPEMD160
-		algorithm = CryptoAlgorithm.JNIRIPEMD160;
-		data = new byte[256];
-		rand.nextBytes(data);
-		hashDigestBytes = hashCrypto.getFunction(algorithm).hash(data).toBytes();
-		verifyResolveHashDigest(algorithm, hashCrypto,hashDigestBytes,20+1,null);
-
-		truncatedHashDigestBytes = new byte[hashDigestBytes.length-2];
-		System.arraycopy(hashDigestBytes,0,truncatedHashDigestBytes,0,truncatedHashDigestBytes.length);
-		verifyResolveHashDigest(algorithm, hashCrypto,truncatedHashDigestBytes,20+1,IllegalArgumentException.class);
-
-		hashDigestBytes = null;
-		verifyResolveHashDigest(algorithm, hashCrypto,hashDigestBytes,20+1,NullPointerException.class);
+//		//test JNISHA256
+//		algorithm = CryptoAlgorithm.JNISHA256;
+//		data = new byte[256];
+//		rand.nextBytes(data);
+//		hashDigestBytes = hashCrypto.getFunction(algorithm).hash(data).toBytes();
+//		verifyResolveHashDigest(algorithm, hashCrypto,hashDigestBytes,32+1,null);
+//
+//		truncatedHashDigestBytes = new byte[hashDigestBytes.length-2];
+//		System.arraycopy(hashDigestBytes,0,truncatedHashDigestBytes,0,truncatedHashDigestBytes.length);
+//		verifyResolveHashDigest(algorithm, hashCrypto,truncatedHashDigestBytes,32+1,IllegalArgumentException.class);
+//
+//		hashDigestBytes = null;
+//		verifyResolveHashDigest(algorithm, hashCrypto,hashDigestBytes,32+1,NullPointerException.class);
+//
+//		//test JNIRIPEMD160
+//		algorithm = CryptoAlgorithm.JNIRIPEMD160;
+//		data = new byte[256];
+//		rand.nextBytes(data);
+//		hashDigestBytes = hashCrypto.getFunction(algorithm).hash(data).toBytes();
+//		verifyResolveHashDigest(algorithm, hashCrypto,hashDigestBytes,20+1,null);
+//
+//		truncatedHashDigestBytes = new byte[hashDigestBytes.length-2];
+//		System.arraycopy(hashDigestBytes,0,truncatedHashDigestBytes,0,truncatedHashDigestBytes.length);
+//		verifyResolveHashDigest(algorithm, hashCrypto,truncatedHashDigestBytes,20+1,IllegalArgumentException.class);
+//
+//		hashDigestBytes = null;
+//		verifyResolveHashDigest(algorithm, hashCrypto,hashDigestBytes,20+1,NullPointerException.class);
 	}
 
 	private void verifyResolveHashDigest(CryptoAlgorithm algorithm,HashCryptography

source/crypto/crypto-framework/src/test/java/test/com/jd/blockchain/crypto/jniutils/JNIED25519UtilsTest.java

@@ -1,123 +1,123 @@
-package test.com.jd.blockchain.crypto.jniutils;
-
-import com.jd.blockchain.crypto.jniutils.asymmetric.JNIED25519Utils;
-
-
-public class JNIED25519UtilsTest {
-
-    /* Program entry function */
-    public static void main(String args[]) {
-
-        byte[] msg = "abc".getBytes();
-        int i;
-        int j;
-        int count = 10000;
-
-        long startTS;
-        long elapsedTS;
-
-        byte[] privKey   = new byte[32];
-        byte[] pubKey    = new byte[32];
-        byte[] signature;
-
-
-        JNIED25519Utils ed25519 = new JNIED25519Utils();
-
-        System.out.println("=================== Key Generation test ===================");
-        ed25519.generateKeyPair(privKey,pubKey);
-        System.out.println("Private Key: ");
-        for(i = 0; i < privKey.length; i++) {
-            System.out.print(privKey[i] + " ");
-            if((i+1)%8 == 0)
-                System.out.println();
-        }
-        System.out.println();
-        System.out.println("Public Key: ");
-        for(i = 0; i < pubKey.length; i++) {
-            System.out.print(pubKey[i] + " ");
-            if((i+1)%8 == 0)
-                System.out.println();
-        }
-        System.out.println();
-
-        System.out.println("=================== Public Key Retrieval test ===================");
-        byte[] pk;
-        pk = ed25519.getPubKey(privKey);
-        System.out.println("Retrieved Public Key: ");
-        for(i = 0; i < pk.length; i++) {
-            System.out.print(pk[i] + " ");
-            if((i+1)%8 == 0)
-                System.out.println();
-        }
-        System.out.println();
-
-        System.out.println("=================== Signing test ===================");
-        signature = ed25519.sign(msg,privKey,pubKey);
-        System.out.println("Signature: ");
-        for(i = 0; i < signature.length; i++) {
-            System.out.print(signature[i] + " ");
-            if((i+1)%8 == 0)
-                System.out.println();
-        }
-        System.out.println();
-
-        System.out.println("=================== Verifying test ===================");
-        if (ed25519.verify(msg,pubKey,signature))
-            System.out.println("valid signature");
-        else System.out.println("invalid signature");
-
-        System.out.println("=================== Do ED25519 Key Pair Generation Test ===================");
-
-
-        for (j = 0; j < 5; j++) {
-            System.out.println("------------- round[" + j + "] --------------");
-            startTS = System.currentTimeMillis();
-            for (i = 0; i < count; i++) {
-                ed25519.generateKeyPair(privKey,pubKey);
-            }
-            elapsedTS = System.currentTimeMillis() - startTS;
-            System.out.println(String.format("ED25519 Key Pair Generation: Count=%s; Elapsed Times=%s; TPS=%.2f", count, elapsedTS,
-                    (count * 1000.00D) / elapsedTS));
-        }
-        System.out.println();
-
-        System.out.println("=================== Do ED25519 Public Key Retrieval Test ===================");
-        for (j = 0; j < 5; j++) {
-            System.out.println("------------- round[" + j + "] --------------");
-            startTS = System.currentTimeMillis();
-            for (i = 0; i < count; i++) {
-                ed25519.getPubKey(privKey);
-            }
-            elapsedTS = System.currentTimeMillis() - startTS;
-            System.out.println(String.format("ED25519 Public Key Retrieval: Count=%s; Elapsed Times=%s; TPS=%.2f", count, elapsedTS,
-                    (count * 1000.00D) / elapsedTS));
-        }
-        System.out.println();
-
-        System.out.println("=================== Do ED25519 Signing Test ===================");
-        for (j = 0; j < 5; j++) {
-            System.out.println("------------- round[" + j + "] --------------");
-            startTS = System.currentTimeMillis();
-            for (i = 0; i < count; i++) {
-                ed25519.sign(msg,privKey,pubKey);
-            }
-            elapsedTS = System.currentTimeMillis() - startTS;
-            System.out.println(String.format("ED25519 Signing: Count=%s; Elapsed Times=%s; TPS=%.2f", count, elapsedTS,
-                    (count * 1000.00D) / elapsedTS));
-        }
-        System.out.println();
-
-        System.out.println("=================== Do ED25519 Verifying Test ===================");
-        for (j = 0; j < 5; j++) {
-            System.out.println("------------- round[" + j + "] --------------");
-            startTS = System.currentTimeMillis();
-            for (i = 0; i < count; i++) {
-                ed25519.verify(msg,pubKey,signature);
-            }
-            elapsedTS = System.currentTimeMillis() - startTS;
-            System.out.println(String.format("ED25519 Verifying: Count=%s; Elapsed Times=%s; TPS=%.2f", count, elapsedTS,
-                    (count * 1000.00D) / elapsedTS));
-        }
-        System.out.println();
-    }
-}
+//package test.com.jd.blockchain.crypto.jniutils;
+//
+//import com.jd.blockchain.crypto.jniutils.asymmetric.JNIED25519Utils;
+//
+//
+//public class JNIED25519UtilsTest {
+//
+//    /* Program entry function */
+//    public static void main(String args[]) {
+//
+//        byte[] msg = "abc".getBytes();
+//        int i;
+//        int j;
+//        int count = 10000;
+//
+//        long startTS;
+//        long elapsedTS;
+//
+//        byte[] privKey   = new byte[32];
+//        byte[] pubKey    = new byte[32];
+//        byte[] signature;
+//
+//
+//        JNIED25519Utils ed25519 = new JNIED25519Utils();
+//
+//        System.out.println("=================== Key Generation test ===================");
+//        ed25519.generateKeyPair(privKey,pubKey);
+//        System.out.println("Private Key: ");
+//        for(i = 0; i < privKey.length; i++) {
+//            System.out.print(privKey[i] + " ");
+//            if((i+1)%8 == 0)
+//                System.out.println();
+//        }
+//        System.out.println();
+//        System.out.println("Public Key: ");
+//        for(i = 0; i < pubKey.length; i++) {
+//            System.out.print(pubKey[i] + " ");
+//            if((i+1)%8 == 0)
+//                System.out.println();
+//        }
+//        System.out.println();
+//
+//        System.out.println("=================== Public Key Retrieval test ===================");
+//        byte[] pk;
+//        pk = ed25519.getPubKey(privKey);
+//        System.out.println("Retrieved Public Key: ");
+//        for(i = 0; i < pk.length; i++) {
+//            System.out.print(pk[i] + " ");
+//            if((i+1)%8 == 0)
+//                System.out.println();
+//        }
+//        System.out.println();
+//
+//        System.out.println("=================== Signing test ===================");
+//        signature = ed25519.sign(msg,privKey,pubKey);
+//        System.out.println("Signature: ");
+//        for(i = 0; i < signature.length; i++) {
+//            System.out.print(signature[i] + " ");
+//            if((i+1)%8 == 0)
+//                System.out.println();
+//        }
+//        System.out.println();
+//
+//        System.out.println("=================== Verifying test ===================");
+//        if (ed25519.verify(msg,pubKey,signature))
+//            System.out.println("valid signature");
+//        else System.out.println("invalid signature");
+//
+//        System.out.println("=================== Do ED25519 Key Pair Generation Test ===================");
+//
+//
+//        for (j = 0; j < 5; j++) {
+//            System.out.println("------------- round[" + j + "] --------------");
+//            startTS = System.currentTimeMillis();
+//            for (i = 0; i < count; i++) {
+//                ed25519.generateKeyPair(privKey,pubKey);
+//            }
+//            elapsedTS = System.currentTimeMillis() - startTS;
+//            System.out.println(String.format("ED25519 Key Pair Generation: Count=%s; Elapsed Times=%s; TPS=%.2f", count, elapsedTS,
+//                    (count * 1000.00D) / elapsedTS));
+//        }
+//        System.out.println();
+//
+//        System.out.println("=================== Do ED25519 Public Key Retrieval Test ===================");
+//        for (j = 0; j < 5; j++) {
+//            System.out.println("------------- round[" + j + "] --------------");
+//            startTS = System.currentTimeMillis();
+//            for (i = 0; i < count; i++) {
+//                ed25519.getPubKey(privKey);
+//            }
+//            elapsedTS = System.currentTimeMillis() - startTS;
+//            System.out.println(String.format("ED25519 Public Key Retrieval: Count=%s; Elapsed Times=%s; TPS=%.2f", count, elapsedTS,
+//                    (count * 1000.00D) / elapsedTS));
+//        }
+//        System.out.println();
+//
+//        System.out.println("=================== Do ED25519 Signing Test ===================");
+//        for (j = 0; j < 5; j++) {
+//            System.out.println("------------- round[" + j + "] --------------");
+//            startTS = System.currentTimeMillis();
+//            for (i = 0; i < count; i++) {
+//                ed25519.sign(msg,privKey,pubKey);
+//            }
+//            elapsedTS = System.currentTimeMillis() - startTS;
+//            System.out.println(String.format("ED25519 Signing: Count=%s; Elapsed Times=%s; TPS=%.2f", count, elapsedTS,
+//                    (count * 1000.00D) / elapsedTS));
+//        }
+//        System.out.println();
+//
+//        System.out.println("=================== Do ED25519 Verifying Test ===================");
+//        for (j = 0; j < 5; j++) {
+//            System.out.println("------------- round[" + j + "] --------------");
+//            startTS = System.currentTimeMillis();
+//            for (i = 0; i < count; i++) {
+//                ed25519.verify(msg,pubKey,signature);
+//            }
+//            elapsedTS = System.currentTimeMillis() - startTS;
+//            System.out.println(String.format("ED25519 Verifying: Count=%s; Elapsed Times=%s; TPS=%.2f", count, elapsedTS,
+//                    (count * 1000.00D) / elapsedTS));
+//        }
+//        System.out.println();
+//    }
+//}

source/crypto/crypto-framework/src/test/java/test/com/jd/blockchain/crypto/jniutils/JNIMBSHA256UtilsTest.java

@@ -1,111 +1,111 @@
-package test.com.jd.blockchain.crypto.jniutils;
-
-import com.jd.blockchain.crypto.jniutils.hash.JNIMBSHA256Utils;
-
-public class JNIMBSHA256UtilsTest {
-    /* Program entry function */
-    public static void main(String args[]) {
-
-        String osName = System.getProperty("os.name").toLowerCase();
-
-        if (! osName.contains("linux")) {
-            return ;
-        }
-
-        byte[] array1 = "abc".getBytes();
-        byte[] array2 = "abcd".getBytes();
-        byte[] array3 = "abcde".getBytes();
-        byte[] array4 = "abcdef".getBytes();
-
-        byte[][] arrays = {array1,array2,array3,array4};
-        JNIMBSHA256Utils mbsha256 = new JNIMBSHA256Utils();
-        byte[][] results = mbsha256.multiBufferHash(arrays);
-
-        System.out.println("JAVA to C : ");
-        for (int i = 0; i < arrays.length; i++) {
-            for (int j = 0; j < arrays[i].length; j++) {
-                System.out.print(arrays[i][j] + " ");
-            }
-            System.out.println();
-        }
-
-        System.out.println();
-
-        System.out.println("C to JAVA : ");
-        for (int i = 0; i < results.length; i++) {
-            for (int j = 0; j < results[i].length; j++) {
-                System.out.print(results[i][j] + " ");
-            }
-            System.out.println();
-        }
-
-        System.out.println();
-
-        String str = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
-        byte[] array = str.getBytes();
-
-
-        int count = 1000000;
-
-
-        byte[][] arraysx4 = {array,array,array,array};
-        byte[][] arraysx8 = {array,array,array,array,array,array,array,array};
-        byte[][] arraysx16 = {array,array,array,array,array,array,array,array,array,array,array,array,array,array,array,array};
-        byte[][] arraysx32 = {array,array,array,array,array,array,array,array,array,array,array,array,array,array,array,array,array,array,array,array,array,array,array,array,array,array,array,array,array,array,array,array};
-
-
-        System.out.println("=================== do MBSHA256 hash test in x4===================");
-        for (int r = 0; r < 5; r++) {
-            System.out.println("------------- round[" + r + "] --------------");
-            long startTS = System.currentTimeMillis();
-            for (int i = 0; i < count; i++) {
-                mbsha256.multiBufferHash(arraysx4);
-            }
-            long elapsedTS = System.currentTimeMillis() - startTS;
-            System.out.println(String.format("SHA256 hashing Count=%s; Elapsed Times=%s; KBPS=%.2f;  Total KBPS=%.2f", count, elapsedTS,
-                    (count * 1000.00D) / elapsedTS, (count * 1000.00D) / elapsedTS*4));
-        }
-        System.out.println();
-        System.out.println();
-
-        System.out.println("=================== do MBSHA256 hash test in x8===================");
-        for (int r = 0; r < 5; r++) {
-            System.out.println("------------- round[" + r + "] --------------");
-            long startTS = System.currentTimeMillis();
-            for (int i = 0; i < count; i++) {
-                mbsha256.multiBufferHash(arraysx8);
-            }
-            long elapsedTS = System.currentTimeMillis() - startTS;
-            System.out.println(String.format("SHA256 hashing Count=%s; Elapsed Times=%s; KBPS=%.2f;  Total KBPS=%.2f", count, elapsedTS,
-                    (count * 1000.00D) / elapsedTS, (count * 1000.00D) / elapsedTS*8));
-        }
-        System.out.println();
-        System.out.println();
-
-        System.out.println("=================== do MBSHA256 hash test in x16===================");
-        for (int r = 0; r < 5; r++) {
-            System.out.println("------------- round[" + r + "] --------------");
-            long startTS = System.currentTimeMillis();
-            for (int i = 0; i < count; i++) {
-                mbsha256.multiBufferHash(arraysx16);
-            }
-            long elapsedTS = System.currentTimeMillis() - startTS;
-            System.out.println(String.format("SHA256 hashing Count=%s; Elapsed Times=%s; KBPS=%.2f;  Total KBPS=%.2f", count, elapsedTS,
-                    (count * 1000.00D) / elapsedTS, (count * 1000.00D) / elapsedTS*16));
-        }
-        System.out.println();
-        System.out.println();
-
-        System.out.println("=================== do MBSHA256 hash test in x32===================");
-        for (int r = 0; r < 5; r++) {
-            System.out.println("------------- round[" + r + "] --------------");
-            long startTS = System.currentTimeMillis();
-            for (int i = 0; i < count; i++) {
-                mbsha256.multiBufferHash(arraysx32);
-            }
-            long elapsedTS = System.currentTimeMillis() - startTS;
-            System.out.println(String.format("SHA256 hashing Count=%s; Elapsed Times=%s; KBPS=%.2f;  Total KBPS=%.2f", count, elapsedTS,
-                    (count * 1000.00D) / elapsedTS, (count * 1000.00D) / elapsedTS*32));
-        }
-    }
-}
+//package test.com.jd.blockchain.crypto.jniutils;
+//
+//import com.jd.blockchain.crypto.jniutils.hash.JNIMBSHA256Utils;
+//
+//public class JNIMBSHA256UtilsTest {
+//    /* Program entry function */
+//    public static void main(String args[]) {
+//
+//        String osName = System.getProperty("os.name").toLowerCase();
+//
+//        if (! osName.contains("linux")) {
+//            return ;
+//        }
+//
+//        byte[] array1 = "abc".getBytes();
+//        byte[] array2 = "abcd".getBytes();
+//        byte[] array3 = "abcde".getBytes();
+//        byte[] array4 = "abcdef".getBytes();
+//
+//        byte[][] arrays = {array1,array2,array3,array4};
+//        JNIMBSHA256Utils mbsha256 = new JNIMBSHA256Utils();
+//        byte[][] results = mbsha256.multiBufferHash(arrays);
+//
+//        System.out.println("JAVA to C : ");
+//        for (int i = 0; i < arrays.length; i++) {
+//            for (int j = 0; j < arrays[i].length; j++) {
+//                System.out.print(arrays[i][j] + " ");
+//            }
+//            System.out.println();
+//        }
+//
+//        System.out.println();
+//
+//        System.out.println("C to JAVA : ");
+//        for (int i = 0; i < results.length; i++) {
+//            for (int j = 0; j < results[i].length; j++) {
+//                System.out.print(results[i][j] + " ");
+//            }
+//            System.out.println();
+//        }
+//
+//        System.out.println();
+//
+//        String str = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
+//        byte[] array = str.getBytes();
+//
+//
+//        int count = 1000000;
+//
+//
+//        byte[][] arraysx4 = {array,array,array,array};
+//        byte[][] arraysx8 = {array,array,array,array,array,array,array,array};
+//        byte[][] arraysx16 = {array,array,array,array,array,array,array,array,array,array,array,array,array,array,array,array};
+//        byte[][] arraysx32 = {array,array,array,array,array,array,array,array,array,array,array,array,array,array,array,array,array,array,array,array,array,array,array,array,array,array,array,array,array,array,array,array};
+//
+//
+//        System.out.println("=================== do MBSHA256 hash test in x4===================");
+//        for (int r = 0; r < 5; r++) {
+//            System.out.println("------------- round[" + r + "] --------------");
+//            long startTS = System.currentTimeMillis();
+//            for (int i = 0; i < count; i++) {
+//                mbsha256.multiBufferHash(arraysx4);
+//            }
+//            long elapsedTS = System.currentTimeMillis() - startTS;
+//            System.out.println(String.format("SHA256 hashing Count=%s; Elapsed Times=%s; KBPS=%.2f;  Total KBPS=%.2f", count, elapsedTS,
+//                    (count * 1000.00D) / elapsedTS, (count * 1000.00D) / elapsedTS*4));
+//        }
+//        System.out.println();
+//        System.out.println();
+//
+//        System.out.println("=================== do MBSHA256 hash test in x8===================");
+//        for (int r = 0; r < 5; r++) {
+//            System.out.println("------------- round[" + r + "] --------------");
+//            long startTS = System.currentTimeMillis();
+//            for (int i = 0; i < count; i++) {
+//                mbsha256.multiBufferHash(arraysx8);
+//            }
+//            long elapsedTS = System.currentTimeMillis() - startTS;
+//            System.out.println(String.format("SHA256 hashing Count=%s; Elapsed Times=%s; KBPS=%.2f;  Total KBPS=%.2f", count, elapsedTS,
+//                    (count * 1000.00D) / elapsedTS, (count * 1000.00D) / elapsedTS*8));
+//        }
+//        System.out.println();
+//        System.out.println();
+//
+//        System.out.println("=================== do MBSHA256 hash test in x16===================");
+//        for (int r = 0; r < 5; r++) {
+//            System.out.println("------------- round[" + r + "] --------------");
+//            long startTS = System.currentTimeMillis();
+//            for (int i = 0; i < count; i++) {
+//                mbsha256.multiBufferHash(arraysx16);
+//            }
+//            long elapsedTS = System.currentTimeMillis() - startTS;
+//            System.out.println(String.format("SHA256 hashing Count=%s; Elapsed Times=%s; KBPS=%.2f;  Total KBPS=%.2f", count, elapsedTS,
+//                    (count * 1000.00D) / elapsedTS, (count * 1000.00D) / elapsedTS*16));
+//        }
+//        System.out.println();
+//        System.out.println();
+//
+//        System.out.println("=================== do MBSHA256 hash test in x32===================");
+//        for (int r = 0; r < 5; r++) {
+//            System.out.println("------------- round[" + r + "] --------------");
+//            long startTS = System.currentTimeMillis();
+//            for (int i = 0; i < count; i++) {
+//                mbsha256.multiBufferHash(arraysx32);
+//            }
+//            long elapsedTS = System.currentTimeMillis() - startTS;
+//            System.out.println(String.format("SHA256 hashing Count=%s; Elapsed Times=%s; KBPS=%.2f;  Total KBPS=%.2f", count, elapsedTS,
+//                    (count * 1000.00D) / elapsedTS, (count * 1000.00D) / elapsedTS*32));
+//        }
+//    }
+//}

source/crypto/crypto-framework/src/test/java/test/com/jd/blockchain/crypto/jniutils/JNIRIPEMD160UtilsTest.java

@@ -1,41 +1,41 @@
-package test.com.jd.blockchain.crypto.jniutils;
-
-import com.jd.blockchain.crypto.jniutils.hash.JNIRIPEMD160Utils;
-
-public class JNIRIPEMD160UtilsTest {
-
-    /* Program entry function */
-    public static void main(String args[]) {
-        byte[] array1 = "abc".getBytes();
-        byte[] array2;
-        JNIRIPEMD160Utils ripemd160 = new JNIRIPEMD160Utils();
-        array2 = ripemd160.hash(array1);
-
-        System.out.print("JAVA to C : ");
-        for (byte anArray1 : array1) {
-            System.out.print(anArray1 + " ");
-        }
-        System.out.println();
-        System.out.print("C to JAVA : ");
-        for (byte anArray2 : array2) {
-            System.out.print(anArray2 + " ");
-        }
-        System.out.println();
-
-        String str = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
-        byte[] array = str.getBytes();
-        int count = 1000000;
-
-        System.out.println("=================== do RIPEMD160 hash test ===================");
-        for (int r = 0; r < 5; r++) {
-            System.out.println("------------- round[" + r + "] --------------");
-            long startTS = System.currentTimeMillis();
-            for (int i = 0; i < count; i++) {
-                ripemd160.hash(array);
-            }
-            long elapsedTS = System.currentTimeMillis() - startTS;
-            System.out.println(String.format("RIPEMD160 hashing Count=%s; Elapsed Times=%s; KBPS=%.2f", count, elapsedTS,
-                    (count * 1000.00D) / elapsedTS));
-        }
-    }
-}
+//package test.com.jd.blockchain.crypto.jniutils;
+//
+//import com.jd.blockchain.crypto.jniutils.hash.JNIRIPEMD160Utils;
+//
+//public class JNIRIPEMD160UtilsTest {
+//
+//    /* Program entry function */
+//    public static void main(String args[]) {
+//        byte[] array1 = "abc".getBytes();
+//        byte[] array2;
+//        JNIRIPEMD160Utils ripemd160 = new JNIRIPEMD160Utils();
+//        array2 = ripemd160.hash(array1);
+//
+//        System.out.print("JAVA to C : ");
+//        for (byte anArray1 : array1) {
+//            System.out.print(anArray1 + " ");
+//        }
+//        System.out.println();
+//        System.out.print("C to JAVA : ");
+//        for (byte anArray2 : array2) {
+//            System.out.print(anArray2 + " ");
+//        }
+//        System.out.println();
+//
+//        String str = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
+//        byte[] array = str.getBytes();
+//        int count = 1000000;
+//
+//        System.out.println("=================== do RIPEMD160 hash test ===================");
+//        for (int r = 0; r < 5; r++) {
+//            System.out.println("------------- round[" + r + "] --------------");
+//            long startTS = System.currentTimeMillis();
+//            for (int i = 0; i < count; i++) {
+//                ripemd160.hash(array);
+//            }
+//            long elapsedTS = System.currentTimeMillis() - startTS;
+//            System.out.println(String.format("RIPEMD160 hashing Count=%s; Elapsed Times=%s; KBPS=%.2f", count, elapsedTS,
+//                    (count * 1000.00D) / elapsedTS));
+//        }
+//    }
+//}

source/crypto/crypto-framework/src/test/java/test/com/jd/blockchain/crypto/jniutils/JNISHA256UtilsTest.java

@@ -1,41 +1,41 @@
-package test.com.jd.blockchain.crypto.jniutils;
-
-import com.jd.blockchain.crypto.jniutils.hash.JNISHA256Utils;
-
-public class JNISHA256UtilsTest {
-
-    /* Program entry function */
-    public static void main(String args[]) {
-        byte[] array1 = "abc".getBytes();
-        byte[] array2;
-        JNISHA256Utils sha256 = new JNISHA256Utils();
-        array2 = sha256.hash(array1);
-        System.out.print("JAVA to C : ");
-        for (byte anArray1 : array1) {
-            System.out.print(anArray1 + " ");
-        }
-        System.out.println();
-        System.out.print("C to JAVA : ");
-        for (byte anArray2 : array2) {
-            System.out.print(anArray2 + " ");
-        }
-        System.out.println();
-
-
-        String str = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
-        byte[] array = str.getBytes();
-        int count = 1000000;
-
-        System.out.println("=================== do SHA256 hash test ===================");
-        for (int r = 0; r < 5; r++) {
-            System.out.println("------------- round[" + r + "] --------------");
-            long startTS = System.currentTimeMillis();
-            for (int i = 0; i < count; i++) {
-                sha256.hash(array);
-            }
-            long elapsedTS = System.currentTimeMillis() - startTS;
-            System.out.println(String.format("SHA256 hashing Count=%s; Elapsed Times=%s; KBPS=%.2f", count, elapsedTS,
-                    (count * 1000.00D) / elapsedTS));
-        }
-    }
-}
+//package test.com.jd.blockchain.crypto.jniutils;
+//
+//import com.jd.blockchain.crypto.jniutils.hash.JNISHA256Utils;
+//
+//public class JNISHA256UtilsTest {
+//
+//    /* Program entry function */
+//    public static void main(String args[]) {
+//        byte[] array1 = "abc".getBytes();
+//        byte[] array2;
+//        JNISHA256Utils sha256 = new JNISHA256Utils();
+//        array2 = sha256.hash(array1);
+//        System.out.print("JAVA to C : ");
+//        for (byte anArray1 : array1) {
+//            System.out.print(anArray1 + " ");
+//        }
+//        System.out.println();
+//        System.out.print("C to JAVA : ");
+//        for (byte anArray2 : array2) {
+//            System.out.print(anArray2 + " ");
+//        }
+//        System.out.println();
+//
+//
+//        String str = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
+//        byte[] array = str.getBytes();
+//        int count = 1000000;
+//
+//        System.out.println("=================== do SHA256 hash test ===================");
+//        for (int r = 0; r < 5; r++) {
+//            System.out.println("------------- round[" + r + "] --------------");
+//            long startTS = System.currentTimeMillis();
+//            for (int i = 0; i < count; i++) {
+//                sha256.hash(array);
+//            }
+//            long elapsedTS = System.currentTimeMillis() - startTS;
+//            System.out.println(String.format("SHA256 hashing Count=%s; Elapsed Times=%s; KBPS=%.2f", count, elapsedTS,
+//                    (count * 1000.00D) / elapsedTS));
+//        }
+//    }
+//}