From 682add6ed27385b00902e3fd031d1980f14c520e Mon Sep 17 00:00:00 2001 From: huanghaiquan Date: Fri, 29 Mar 2019 01:23:03 +0800 Subject: [PATCH] Fix bugs in test case; --- .../jd/blockchain/crypto/CryptoAlgorithm.java | 14 +- .../impl/AsymmtricCryptographyImpl.java | 33 ++- .../crypto/impl/HashCryptographyImpl.java | 26 +- .../JNIED25519SignatureFunction.java | 260 +++++++++--------- .../jni/hash/JNIRIPEMD160HashFunction.java | 106 +++---- .../impl/jni/hash/JNISHA256HashFunction.java | 106 +++---- .../AsymmtricCryptographyImplTest.java | 260 +++++++++--------- .../crypto/hash/HashCryptographyImplTest.java | 148 +++++----- .../crypto/jniutils/JNIED25519UtilsTest.java | 246 ++++++++--------- .../crypto/jniutils/JNIMBSHA256UtilsTest.java | 222 +++++++-------- .../jniutils/JNIRIPEMD160UtilsTest.java | 82 +++--- .../crypto/jniutils/JNISHA256UtilsTest.java | 82 +++--- 12 files changed, 794 insertions(+), 791 deletions(-) diff --git a/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/CryptoAlgorithm.java b/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/CryptoAlgorithm.java index 33a9c562..014e41d8 100644 --- a/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/CryptoAlgorithm.java +++ b/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), // 对称加密； /** diff --git a/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/impl/AsymmtricCryptographyImpl.java b/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/impl/AsymmtricCryptographyImpl.java index 2d18626c..6201a982 100644 --- a/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/impl/AsymmtricCryptographyImpl.java +++ b/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); diff --git a/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/impl/HashCryptographyImpl.java b/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/impl/HashCryptographyImpl.java index ae1772c5..77c871bd 100644 --- a/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/impl/HashCryptographyImpl.java +++ b/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; } diff --git a/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/impl/jni/asymmetric/JNIED25519SignatureFunction.java b/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/impl/jni/asymmetric/JNIED25519SignatureFunction.java index 7aa6b80f..ee1d7a50 100644 --- a/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/impl/jni/asymmetric/JNIED25519SignatureFunction.java +++ b/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)); +// +// } +//} diff --git a/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/impl/jni/hash/JNIRIPEMD160HashFunction.java b/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/impl/jni/hash/JNIRIPEMD160HashFunction.java index 72d0777e..01482e12 100644 --- a/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/impl/jni/hash/JNIRIPEMD160HashFunction.java +++ b/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); +// } +//} +// diff --git a/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/impl/jni/hash/JNISHA256HashFunction.java b/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/impl/jni/hash/JNISHA256HashFunction.java index bb6e84f0..08aba6a3 100644 --- a/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/impl/jni/hash/JNISHA256HashFunction.java +++ b/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); +// } +// +//} diff --git a/source/crypto/crypto-framework/src/test/java/test/com/jd/blockchain/crypto/asymmetric/AsymmtricCryptographyImplTest.java b/source/crypto/crypto-framework/src/test/java/test/com/jd/blockchain/crypto/asymmetric/AsymmtricCryptographyImplTest.java index 2970635b..b78167c1 100644 --- a/source/crypto/crypto-framework/src/test/java/test/com/jd/blockchain/crypto/asymmetric/AsymmtricCryptographyImplTest.java +++ b/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, diff --git a/source/crypto/crypto-framework/src/test/java/test/com/jd/blockchain/crypto/hash/HashCryptographyImplTest.java b/source/crypto/crypto-framework/src/test/java/test/com/jd/blockchain/crypto/hash/HashCryptographyImplTest.java index 513cb577..30546b98 100644 --- a/source/crypto/crypto-framework/src/test/java/test/com/jd/blockchain/crypto/hash/HashCryptographyImplTest.java +++ b/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 diff --git a/source/crypto/crypto-framework/src/test/java/test/com/jd/blockchain/crypto/jniutils/JNIED25519UtilsTest.java b/source/crypto/crypto-framework/src/test/java/test/com/jd/blockchain/crypto/jniutils/JNIED25519UtilsTest.java index 8cbce2bb..70fe7181 100644 --- a/source/crypto/crypto-framework/src/test/java/test/com/jd/blockchain/crypto/jniutils/JNIED25519UtilsTest.java +++ b/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(); +// } +//} diff --git a/source/crypto/crypto-framework/src/test/java/test/com/jd/blockchain/crypto/jniutils/JNIMBSHA256UtilsTest.java b/source/crypto/crypto-framework/src/test/java/test/com/jd/blockchain/crypto/jniutils/JNIMBSHA256UtilsTest.java index e5b5ef2f..0b4b8b34 100644 --- a/source/crypto/crypto-framework/src/test/java/test/com/jd/blockchain/crypto/jniutils/JNIMBSHA256UtilsTest.java +++ b/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)); +// } +// } +//} diff --git a/source/crypto/crypto-framework/src/test/java/test/com/jd/blockchain/crypto/jniutils/JNIRIPEMD160UtilsTest.java b/source/crypto/crypto-framework/src/test/java/test/com/jd/blockchain/crypto/jniutils/JNIRIPEMD160UtilsTest.java index 47bb7bda..d226d837 100644 --- a/source/crypto/crypto-framework/src/test/java/test/com/jd/blockchain/crypto/jniutils/JNIRIPEMD160UtilsTest.java +++ b/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)); - } - } -} \ No newline at end of file +//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)); +// } +// } +//} \ No newline at end of file diff --git a/source/crypto/crypto-framework/src/test/java/test/com/jd/blockchain/crypto/jniutils/JNISHA256UtilsTest.java b/source/crypto/crypto-framework/src/test/java/test/com/jd/blockchain/crypto/jniutils/JNISHA256UtilsTest.java index 10e040f8..0b4c027b 100644 --- a/source/crypto/crypto-framework/src/test/java/test/com/jd/blockchain/crypto/jniutils/JNISHA256UtilsTest.java +++ b/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)); +// } +// } +//}