java国密算法工具类,Java国密相关算法（bouncycastle）

最新推荐文章于 2024-06-28 14:29:01 发布
最新推荐文章于 2024-06-28 14:29:01 发布
阅读量1.5k 收藏
点赞数
文章标签： java国密算法工具类

标签：

公用类算法：

PCIKeyPair.java

/**

* @Author: dzy

* @Date: 2018/9/27 14:18

* @Describe: 公私钥对

*/

@Data

@AllArgsConstructor

@NoArgsConstructor

public class PCIKeyPair {

private String priKey; //私钥

private String pubKey; //公钥

}

CommonUtils.java

import org.apache.commons.lang3.StringUtils;

import java.io.UnsupportedEncodingException;

import java.nio.ByteBuffer;

import java.nio.ByteOrder;

import java.text.SimpleDateFormat;

import java.util.Calendar;

import java.util.Date;

/**

* @ClassName: CommonUtils

* @Description: 通用工具类

* @since: 0.0.1

* @author: dzy

* @date: 2017年2月22日 上午11:46:44

*/

public class CommonUtils {

/**

* @param date 日期

* @param pattern 模式 如:yyyyMMdd等

* @return

* @Title: formatDate

* @Description: 格式化日期

* @since: 0.0.1

*/

public static String formatDate(Date date, String pattern) {

SimpleDateFormat formatter = new SimpleDateFormat(pattern);

return formatter.format(date);

}

/**

* @param strDate String类型日期

* @param pattern 日期显示模式

* @return

* @Title: parseDate

* @Description: 将String日期转换为Date类型日期

* @since: 0.0.1

*/

public static Date parseDate(String strDate, String pattern) {

SimpleDateFormat formatter = null;

if (StringUtils.isBlank(strDate)) {

return null;

}

formatter = new SimpleDateFormat(pattern);

try {

return formatter.parse(strDate);

} catch (Exception e) {

e.printStackTrace();

return null;

}

}

/**

* @param date 操作前的日期

* @param field 日期的部分如:年,月,日

* @param amount 增加或减少的值(负数表示减少)

* @return

* @Title: dateAdd

* @Description: 日期的加减操作

* @since: 0.0.1

*/

public static Date dateAdd(Date date, int field, int amount) {

Calendar calendar = Calendar.getInstance();

calendar.setTime(date);

calendar.add(field, amount);

return calendar.getTime();

}

/**

* @param source 源字符串

* @param offset 填充开始的位置, 0-在左边, source.getBytes().length 在右边, 如果有中文时需小心位置

* @param c 用于填充的字符

* @param length 最后字符串的字节长度

* @return

* @Title: fill

* @Description: 填充字符串, 长度是按字节计算, 不是字符

* @since: 0.0.1

*/

public static String fill(String source, int offset, char c, int length) throws UnsupportedEncodingException {

if (null == source) {

source = "";

}

if (source.getBytes(CustomConstants.CHARSET_UTF8).length == length) {

return source;

}

byte[] buf = new byte[length];

byte[] src = source.getBytes(CustomConstants.CHARSET_UTF8);

if (src.length > length) {

System.arraycopy(src, src.length - length, buf, 0, length);

return new String(buf, CustomConstants.CHARSET_UTF8);

}

if (offset > src.length) {

offset = src.length;

} else if (offset < 0) {

offset = 0;

}

int n = length - src.length;

System.arraycopy(src, 0, buf, 0, offset);

for (int i = 0; i < n; i++) {

buf[i + offset] = (byte) c;

}

System.arraycopy(src, offset, buf, offset + n, src.length - offset);

return new String(buf, CustomConstants.CHARSET_UTF8);

}

/**

* @param original 原字符串

* @param offset 填充开始的位置, 0-在左边, original.getBytes().length 在右边, 如果有中文时需小心位置

* @param length 替换的字节数

* @param c 用于替换的字符

* @return

* @Title: replace

* @Description: 替换字符串, 长度是按字节计算, 不是字符

* @since: 0.0.1

*/

public static String replace(String original, int offset, int length, char c) throws UnsupportedEncodingException {

if (original == null) {

original = "";

}

if (original.getBytes(CustomConstants.CHARSET_UTF8).length <= offset) {

return original;

}

if (original.getBytes(CustomConstants.CHARSET_UTF8).length < offset + length) {

length = original.getBytes(CustomConstants.CHARSET_UTF8).length - offset;

}

byte[] buf = new byte[original.length()];

byte[] src = original.getBytes(CustomConstants.CHARSET_UTF8);

System.arraycopy(src, 0, buf, 0, offset);

for (int i = offset; i < offset + length; i++) {

buf[i] = (byte) c;

}

System.arraycopy(src, offset + length, buf, offset + length, src.length - offset - length);

return new String(buf, CustomConstants.CHARSET_UTF8);

}

/**

* @param s 16进制字符串

* @return

* @Title: hexToByte

* @Description: 16进制字符串转字节数组

* @since: 0.0.1

*/

public static byte[] hexToByte(String s) {

byte[] result = null;

try {

int i = s.length();

// if (i % 2 == 1) {

// throw new Exception("字符串长度不是偶数.");

// }

if (i % 2 != 0) {

throw new Exception("字符串长度不是偶数.");

}

result = new byte[i / 2];

for (int j = 0; j < result.length; j++) {

result[j] = (byte) Integer.parseInt(s.substring(j * 2, j * 2 + 2), 16);

}

} catch (Exception e) {

result = null;

e.printStackTrace();

// log.error("16进制字符串转字节数组时出现异常:", e);

}

return result;

}

/**

* @param bytes 字节数组

* @return

* @Title: byte2hexString

* @Description: 字节数组转换为16进制字符串 //0x33 0xD2 0x00 0x46 转换为 "33d20046" 转换和打印报文用

* @since: 0.0.1

*/

public static String byte2hexString(byte[] bytes) {

StringBuffer buf = new StringBuffer(bytes.length * 2);

for (int i = 0; i < bytes.length; i++) {

if (((int) bytes[i] & 0xff) < 0x10) {

buf.append("0");

}

buf.append(Long.toString((int) bytes[i] & 0xff, 16));

}

return buf.toString().toUpperCase();

}

/**

* @param hexString 16进制字符串 如:"33d20046" 转换为 0x33 0xD2 0x00 0x46

* @return

* @Title: hexString2byte

* @Description: 16进制字符串转字节数组

* @since: 0.0.1

*/

public static byte[] hexString2byte(String hexString) {

if (null == hexString || hexString.length() % 2 != 0 || hexString.contains("null")) {

return null;

}

byte[] bytes = new byte[hexString.length() / 2];

for (int i = 0; i < hexString.length(); i += 2) {

bytes[i / 2] = (byte) (Integer.parseInt(hexString.substring(i, i + 2), 16) & 0xff);

}

return bytes;

}

/**

* @param i 需要转的int类型数字

* @return

* @Title: byte1ToBcd2

* @Description: int类型转BCD码

* @since: 0.0.1

*/

public static String byte1ToBcd2(int i) {

// return (new Integer(i / 16).toString() + (new Integer(i % 16)).toString());

return Integer.toString(i / 16) + Integer.toString(i % 16);

}

/**

* @param b 字节数组

* @return

* @Title: byteToHex2

* @Description: 字节数组转换为16进制字符串 For example, byte[] {0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF} will be changed to String "0123456789ABCDEF"

* @since: 0.0.1

*/

public static String byteToHex2(byte[] b) {

StringBuffer result = new StringBuffer();

String tmp = "";

for (int i = 0; i < b.length; i++) {

tmp = Integer.toHexString(b[i] & 0xff);

if (tmp.length() == 1) {

result.append("0" + tmp);

} else {

result.append(tmp);

}

}

return result.toString().toUpperCase();

}

/**

* @param num 数字

* @param len 字节数组长度

* @return

* @Title: intToHexBytes

* @Description: int类型转16进制字节数组

*/

public static byte[] intToHexBytes(int num, int len) {

byte[] bytes = null;

String hexString = Integer.toHexString(num);

if (len > 0) {

int length = len * 2;

hexString = CustomStringUtils.leftFill(hexString, '0', length);

bytes = CommonUtils.hexString2byte(hexString);

}

return bytes;

}

/*public static String byteToHex3(byte[] b) {

String result = "";

String tmp = "";

for (int n = 0; n < b.length; n++) {

tmp = (java.lang.Integer.toHexString(b[n] & 0XFF));

if (tmp.length() == 1) {

result = result + "0" + tmp;

} else {

result = result + tmp;

}

if (n < b.length - 1) {

result = result + "";

}

}

return result.toUpperCase();

}*/

/**

* @param str 需要转换编码的字符串

* @return

* @Title: iso2Gbk

* @Description: 将ISO-8859-1编码的字符串转成GBK编码的字符串

* @since: 0.0.1

*/

public static String iso2Gbk(String str) {

if (null == str) {

return str;

}

try {

return new String(str.getBytes("ISO-8859-1"), "GBK");

} catch (UnsupportedEncodingException e) {

// log.error("不支持的编码异常:", e);

e.printStackTrace();

return str;

}

}

// /**

// * @param message

// * @return

// * @Title: getSubElement

// * @Description: 分解各子域到HashMap

// * @since: 0.0.1

// */

// public static Map getSubElement(byte[] message) {

// Map map = new HashMap();

// String key = null;

// String value = null;

// int len = 0;

// int idx = 0;

// while (idx < message.length) {

// key = new String(message, idx, 2);

// idx += 2; //取了SE id 移2位

// len = Integer.parseInt(new String(message, idx, 2));

// idx += 2; //取了SE id的内容长度 移2位

// value = new String(message, idx, len);

// map.put(key, value);

// idx += len;

// }

// return map;

// }

//byte数组转成long

/**

* @param b 将字节数组转long类型 位置为小端

* @return

*/

public static long byteToLong(byte[] b) {

long s = 0;

long s0 = b[0] & 0xff;// 最低位

long s1 = b[1] & 0xff;

long s2 = b[2] & 0xff;

long s3 = b[3] & 0xff;

long s4 = b[4] & 0xff;// 最低位

long s5 = b[5] & 0xff;

long s6 = b[6] & 0xff;

long s7 = b[7] & 0xff;

// s0不变

s1 <<= 8;

s2 <<= 16;

s3 <<= 24;

s4 <<= 8 * 4;

s5 <<= 8 * 5;

s6 <<= 8 * 6;

s7 <<= 8 * 7;

s = s0 | s1 | s2 | s3 | s4 | s5 | s6 | s7;

return s;

}

/**

* @param b 将字节数组转int类型 位置为小端

* @return

*/

public static int byteToInt(byte[] b) {

int s = 0;

int s0 = b[0] & 0xff;// 最低位

int s1 = b[1] & 0xff;

int s2 = b[2] & 0xff;

int s3 = b[3] & 0xff;

// s0不变

s1 <<= 8;

s2 <<= 16;

s3 <<= 24;

s = s0 | s1 | s2 | s3;

return s;

}

/**

* int类型转换小端的byte数组

* @param i

* @return

*/

public static byte[] intToLittleBytes(int i) {

ByteBuffer byteBuffer = ByteBuffer.allocate(4);

byteBuffer.order(ByteOrder.LITTLE_ENDIAN);

byteBuffer.asIntBuffer().put(i);

byte[] littleBytes = byteBuffer.array();

return littleBytes;

}

/**

* 将一个字节转成10进制

* @param b

* @return

*/

public static int byteToInt(byte b) {

int value = b & 0xff;

return value;

}

/**

* 字节数组合并

* @param bt1 字节数组bt1

* @param bt2 字节数组bt2

* @return

*/

public static byte[] byteMerger(byte[] bt1, byte[] bt2){

byte[] bt3 = new byte[bt1.length+bt2.length];

System.arraycopy(bt1, 0, bt3, 0, bt1.length);

System.arraycopy(bt2, 0, bt3, bt1.length, bt2.length);

return bt3;

}

}

SM2算法：

import org.bouncycastle.asn1.gm.GMNamedCurves;

import org.bouncycastle.asn1.x9.X9ECParameters;

import org.bouncycastle.crypto.AsymmetricCipherKeyPair;

import org.bouncycastle.crypto.generators.ECKeyPairGenerator;

import org.bouncycastle.crypto.params.*;

import org.bouncycastle.crypto.signers.SM2Signer;

import org.bouncycastle.math.ec.ECPoint;

import org.bouncycastle.util.Strings;

import org.bouncycastle.util.encoders.Hex;

import java.math.BigInteger;

import java.security.NoSuchAlgorithmException;

import java.security.SecureRandom;

import java.text.SimpleDateFormat;

import java.util.Calendar;

/**

* @Author: dzy

* @Date: 2018/9/28 15:53

* @Describe: SM2工具类

*/

public class SM2Util {

/**

* 生成SM2公私钥对

* @return

*/

private static AsymmetricCipherKeyPair genKeyPair0() {

//获取一条SM2曲线参数

X9ECParameters sm2ECParameters = GMNamedCurves.getByName("sm2p256v1");

//构造domain参数

ECDomainParameters domainParameters = new ECDomainParameters(sm2ECParameters.getCurve(),

sm2ECParameters.getG(), sm2ECParameters.getN());

//1.创建密钥生成器

ECKeyPairGenerator keyPairGenerator = new ECKeyPairGenerator();

//2.初始化生成器,带上随机数

try {

keyPairGenerator.init(new ECKeyGenerationParameters(domainParameters, SecureRandom.getInstance("SHA1PRNG")));

} catch (NoSuchAlgorithmException e) {

e.printStackTrace();

}

//3.生成密钥对

AsymmetricCipherKeyPair asymmetricCipherKeyPair = keyPairGenerator.generateKeyPair();

return asymmetricCipherKeyPair;

}

/**

* 生成公私钥对(默认压缩公钥)

* @return

*/

public static PCIKeyPair genKeyPair() {

return genKeyPair(true);

}

/**

* 生成公私钥对

* @param compressedPubKey 是否压缩公钥

* @return

*/

public static PCIKeyPair genKeyPair(boolean compressedPubKey) {

AsymmetricCipherKeyPair asymmetricCipherKeyPair = genKeyPair0();

//提取公钥点

ECPoint ecPoint = ((ECPublicKeyParameters) asymmetricCipherKeyPair.getPublic()).getQ();

//公钥前面的02或者03表示是压缩公钥,04表示未压缩公钥,04的时候,可以去掉前面的04

String pubKey = Hex.toHexString(ecPoint.getEncoded(compressedPubKey));

BigInteger privatekey = ((ECPrivateKeyParameters) asymmetricCipherKeyPair.getPrivate()).getD();

String priKey = privatekey.toString(16);

//TODO 删掉控制台输出

System.out.println("pubKey:" + pubKey);

System.out.println("sm2 private key = " + priKey);

System.out.println("sm2 public key = " + CommonUtils.byte2hexString(ecPoint.getEncoded(false)));

System.out.println("sm2 public key compressed = " + CommonUtils.byte2hexString(ecPoint.getEncoded(true)));

PCIKeyPair keyPair = new PCIKeyPair(priKey, pubKey);

return keyPair;

}

public static void main(String[] args) {

PCIKeyPair keyPair = genKeyPair();

System.out.println("keyPair:" + keyPair);

}

/**

* 私钥签名

* @param privateKey 私钥

* @param content 待签名内容

* @return

*/

public static String sign(String privateKey, String content) {

//待签名内容转为字节数组

byte[] message = Hex.decode(content);

//获取一条SM2曲线参数

X9ECParameters sm2ECParameters = GMNamedCurves.getByName("sm2p256v1");

//构造domain参数

ECDomainParameters domainParameters = new ECDomainParameters(sm2ECParameters.getCurve(),

sm2ECParameters.getG(), sm2ECParameters.getN());

BigInteger privateKeyD = new BigInteger(privateKey, 16);

ECPrivateKeyParameters privateKeyParameters = new ECPrivateKeyParameters(privateKeyD, domainParameters);

//创建签名实例

SM2Signer sm2Signer = new SM2Signer();

//初始化签名实例,带上ID,国密的要求,ID默认值:1234567812345678

try {

sm2Signer.init(true, new ParametersWithID(new ParametersWithRandom(privateKeyParameters, SecureRandom.getInstance("SHA1PRNG")), Strings.toByteArray("1234567812345678")));

} catch (NoSuchAlgorithmException e) {

e.printStackTrace();

}

//生成签名,签名分为两部分r和s,分别对应索引0和1的数组

BigInteger[] bigIntegers = sm2Signer.generateSignature(message);

String r = Hex.toHexString(bigIntegers[0].toByteArray());

r = r.substring(r.length() - 64);

String s = Hex.toHexString(bigIntegers[1].toByteArray());

s = s.substring(s.length() - 64);

String sign = CustomStringUtils.append(r, s);

//TODO 删掉控制台输出

System.out.println("Message signatrue = " + CommonUtils.byte2hexString(CommonUtils.byteMerger(bigIntegers[0].toByteArray(), bigIntegers[1].toByteArray())));

System.out.println("生成的签名(r+s) : " + sign);

return sign;

}

/**

* 验证签名

* @param publicKey 公钥

* @param content 待签名内容

* @param sign 签名值

* @return

*/

public static boolean verify(String publicKey, String content, String sign) {

//待签名内容

byte[] message = Hex.decode(content);

byte[] signData = Hex.decode(sign);

// 获取一条SM2曲线参数

X9ECParameters sm2ECParameters = GMNamedCurves.getByName("sm2p256v1");

// 构造domain参数

ECDomainParameters domainParameters = new ECDomainParameters(sm2ECParameters.getCurve(),

sm2ECParameters.getG(),

sm2ECParameters.getN());

//获取签名

BigInteger R = null;

BigInteger S = null;

byte[] rBy = new byte[33];

System.arraycopy(signData, 0, rBy, 1, 32);

rBy[0] = 0x00;

byte[] sBy = new byte[33];

System.arraycopy(signData, 32, sBy, 1, 32);

sBy[0] = 0x00;

R = new BigInteger(rBy);

S = new BigInteger(sBy);

//提取公钥点

ECPoint pukPoint = sm2ECParameters.getCurve().decodePoint(CommonUtils.hexString2byte(publicKey));

// 公钥前面的02或者03表示是压缩公钥，04表示未压缩公钥, 04的时候，可以去掉前面的04

ECPublicKeyParameters publicKeyParameters = new ECPublicKeyParameters(pukPoint, domainParameters);

//创建签名实例

SM2Signer sm2Signer = new SM2Signer();

ParametersWithID parametersWithID = new ParametersWithID(publicKeyParameters, Strings.toByteArray("1234567812345678"));

sm2Signer.init(false, parametersWithID);

//验证签名结果

boolean verify = sm2Signer.verifySignature(message, R, S);

return verify;

}

}

SM3算法：

import lombok.extern.slf4j.Slf4j;

import org.bouncycastle.crypto.digests.SM3Digest;

import org.bouncycastle.crypto.macs.HMac;

import org.bouncycastle.crypto.params.KeyParameter;

import org.bouncycastle.util.encoders.Hex;

import java.security.MessageDigest;

/**

* @Author: dzy

* @Date: 2018/10/19 16:36

* @Describe: SM3工具类(杂凑算法-hash算法)

*/

@Slf4j

public class SM3Util {

/**

* 16进制字符串SM3生成HASH签名值算法

* @param hexString 16进制字符串

* @return

*/

public static String hexEncrypt(String hexString) {

byte[] srcData = Hex.decode(hexString);

byte[] encrypt = encrypt(srcData);

String cipherStr = Hex.toHexString(encrypt);

return cipherStr;

}

/**

* 16进制字符串SM3生成HASH签名值算法

* @param hexKey 16进制密钥

* @param hexString 16进制字符串

* @return

*/

public static String hexEncrypt(String hexKey, String hexString) {

byte[] key = Hex.decode(hexKey);

byte[] srcData = Hex.decode(hexString);

byte[] encrypt = encrypt(key, srcData);

String cipherStr = Hex.toHexString(encrypt);

return cipherStr;

}

/**

* 普通文本SM3生成HASH签名算法

* @param plain 待签名数据

* @return

*/

public static String plainEncrypt(String plain) {

// 将返回的hash值转换成16进制字符串

String cipherStr = null;

try {

//将字符串转换成byte数组

byte[] srcData = plain.getBytes(CustomConstants.CHARSET_UTF8);

//调用encrypt计算hash

byte[] encrypt = encrypt(srcData);

//将返回的hash值转换成16进制字符串

cipherStr = Hex.toHexString(encrypt);

} catch (Exception e) {

log.error("将字符串转换为字节时出现异常:", e);

}

return cipherStr;

}

/**

* 普通文本SM3生成HASH签名算法

* @param hexKey 密钥

* @param plain 待签名数据

* @return

*/

public static String plainEncrypt(String hexKey, String plain) {

// 将返回的hash值转换成16进制字符串

String cipherStr = null;

try {

//将字符串转换成byte数组

byte[] srcData = plain.getBytes(CustomConstants.CHARSET_UTF8);

//密钥

byte[] key = Hex.decode(hexKey);

//调用encrypt计算hash

byte[] encrypt = encrypt(key, srcData);

//将返回的hash值转换成16进制字符串

cipherStr = Hex.toHexString(encrypt);

} catch (Exception e) {

log.error("将字符串转换为字节时出现异常:", e);

}

return cipherStr;

}

/**

* SM3计算hashCode

* @param srcData 待计算数据

* @return

*/

public static byte[] encrypt(byte[] srcData) {

SM3Digest sm3Digest = new SM3Digest();

sm3Digest.update(srcData, 0, srcData.length);

byte[] encrypt = new byte[sm3Digest.getDigestSize()];

sm3Digest.doFinal(encrypt, 0);

return encrypt;

}

/**

* 通过密钥进行加密

* @param key 密钥byte数组

* @param srcData 被加密的byte数组

* @return

*/

public static byte[] encrypt(byte[] key, byte[] srcData) {

KeyParameter keyParameter = new KeyParameter(key);

SM3Digest digest = new SM3Digest();

HMac mac = new HMac(digest);

mac.init(keyParameter);

mac.update(srcData, 0, srcData.length);

byte[] result = new byte[mac.getMacSize()];

mac.doFinal(result, 0);

return result;

}

/**

* SM3计算hashCode

* @param srcData 待计算数据

* @return

* @throws Exception

*/

public static byte[] encrypt_0(byte[] srcData) throws Exception {

MessageDigest messageDigest = MessageDigest.getInstance("SM3", "BC");

byte[] digest = messageDigest.digest(srcData);

return digest;

}

}

SM4算法：

import org.bouncycastle.crypto.engines.SM4Engine;

import org.bouncycastle.crypto.params.KeyParameter;

import org.bouncycastle.util.encoders.Hex;

/**

* @Author: dzy

* @Date: 2018/10/9 16:41

* @Describe: SM4算法

*/

public class SM4Util {

//加解密的字节快大小

public static final int BLOCK_SIZE = 16;

/**

* SM4ECB加密算法

* @param in 待加密内容

* @param keyBytes 密钥

* @return

*/

public static byte[] encryptByEcb0(byte[] in, byte[] keyBytes) {

SM4Engine sm4Engine = new SM4Engine();

sm4Engine.init(true, new KeyParameter(keyBytes));

int inLen = in.length;

byte[] out = new byte[inLen];

int times = inLen / BLOCK_SIZE;

for (int i = 0; i < times; i++) {

sm4Engine.processBlock(in, i * BLOCK_SIZE, out, i * BLOCK_SIZE);

}

return out;

}

/**

* SM4ECB加密算法

* @param in 待加密内容

* @param keyBytes 密钥

* @return

*/

public static String encryptByEcb(byte[] in, byte[] keyBytes) {

byte[] out = encryptByEcb0(in, keyBytes);

String cipher = Hex.toHexString(out);

return cipher;

}

/**

* SM4的ECB加密算法

* @param content 待加密内容

* @param key 密钥

* @return

*/

public static String encryptByEcb(String content, String key) {

byte[] in = Hex.decode(content);

byte[] keyBytes = Hex.decode(key);

String cipher = encryptByEcb(in, keyBytes);

return cipher;

}

/**

* SM4的ECB解密算法

* @param in 密文内容

* @param keyBytes 密钥

* @return

*/

public static byte[] decryptByEcb0(byte[] in, byte[] keyBytes) {

SM4Engine sm4Engine = new SM4Engine();

sm4Engine.init(false, new KeyParameter(keyBytes));

int inLen = in.length;

byte[] out = new byte[inLen];

int times = inLen / BLOCK_SIZE;

for (int i = 0; i < times; i++) {

sm4Engine.processBlock(in, i * BLOCK_SIZE, out, i * BLOCK_SIZE);

}

return out;

}

/**

* SM4的ECB解密算法

* @param in 密文内容

* @param keyBytes 密钥

* @return

*/

public static String decryptByEcb(byte[] in, byte[] keyBytes) {

byte[] out = decryptByEcb0(in, keyBytes);

String plain = Hex.toHexString(out);

return plain;

}

/**

* SM4的ECB解密算法

* @param cipher 密文内容

* @param key 密钥

* @return

*/

public static String decryptByEcb(String cipher, String key) {

byte[] in = Hex.decode(cipher);

byte[] keyBytes = Hex.decode(key);

String plain = decryptByEcb(in, keyBytes);

return plain;

}

}

标签：

来源： https://www.cnblogs.com/alsodzy/p/9854521.html

沃特JS
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java sm2国密工具类
11-02
Java SM2 国密工具类是用于实现中国国家商用密码算法SM2的编程工具，它在Java环境中提供了加密、解密、签名以及...同时，由于国密算法在中国的合规性要求，使用这些工具类可以帮助满足法规要求，确保数据传输的安全。
基于Java的（SM2_SM3_SM4）国密算法java源代码及工具类及测试demo
10-24
这里的“基于Java的（SM2_SM3_SM4）国密算法java源代码及工具类及测试demo”是一个关于如何在Java环境中实现中国国家标准加密算法的资源包。下面我们将详细探讨这些算法的核心概念、用途以及如何在Java中应用。 1. ...
国密：生成SM2秘钥、加解密及加验签
Su7148的博客
11-16 2万+
简述国密SM2的公私钥生成以及加签验签。
国密算法SM2、SM3的使用
weixin_48568302的博客
05-31 2万+
一、SM2、SM3介绍： 1. SM2是非对称加密算法 它是基于椭圆曲线密码的公钥密码算法标准，其秘钥长度256bit，包含数字签名、密钥交换和公钥加密，用于替换RSA/DH/ECDSA/ECDH等国际算法。可以满足电子认证服务系统等应用需求，由国家密码管理局于2010年12月17号发布。 2.SM3是一种密码杂凑算法 用于替代MD5/SHA-1/SHA-2等国际算法，适用于数字签名和验证、消息认证码的生成与验证以及随机数的生成，可以满足电子认证服务系统等应用需求，于...
笔记: SM2签名/验签例子
最新发布
likq2003的专栏
06-28 327
System.out.println("签名验证: " + signer.verifySignature(signBytes));System.out.println("数据签名串: " + signBase64Str);System.out.println("私钥: " + privateKeyStr);System.out.println("公钥: " + publicKeyStr);System.out.println("原始字符串: " + message);// 签名换为Base64字符串。
最近用到国密sm3算法，报错 java.lang.SecurityException: class “org.bouncycastle.crypto.digests.GeneralDigest
live的专栏
01-05 6043
最近用到 国密sm3算法，报错 java.lang.SecurityException: class "org.bouncycastle.crypto.digests.GeneralDigest"'s signer information does not match signer information of other classes in the same package 一、原因 jar 包冲突 二、解决 *尝试方案一： 项目是maven项目，使用命令：dependency:tree ...
国密算法SM3-java实现
yao583224426的博客
12-06 2302
22
国密算法-SM2
一个秃头程序猿的零散分享
08-15 7425
国密算法是国家密码局制定标准的一系列算法，包括SM1、SM2、SM3、SM4等。其中，SM1是采用硬件实现的，不予讨论；SM2是非对称加密算法；SM4是对称加密算法。本篇贴出SM2 Java版本实现生成公私钥及加解密、签名验签代码，供大家一起讨论学习，所有的代码实现都是基于BC库来做的。BC库是实现加解密算法的基础库，我们首先要在代码里引入BC库。下面是整个工具类，实现密钥生成，加解密及签名验签功能。...
国密算法java实现
10-18
在实际开发中，除了自己实现SM4算法，也可以考虑使用已有的开源库，如Apache Shenmi或Bouncy Castle，这些库已经提供了成熟的国密算法支持，可以节省开发时间和提高代码质量。但如果你选择自定义实现，务必确保遵循...
java实现国密算法SM2,SM3,SM4算法
04-26
总的来说，实现Java中的国密算法需要理解其背后的数学原理，同时依赖于像Bouncy Castle这样的第三方库来提供必要的加密操作。在实际开发中，还需要考虑性能优化、安全性以及与其他系统的兼容性等问题。对于初学者，...
JAVA SM2 SM3 SM4 算法实现，提供例子
12-20
压缩包中的"smutil"可能是一个包含这些国密算法实现的工具类库。这个库可能封装了上述的Java API，提供了更简洁易用的接口，以供开发者调用SM2、SM3和SM4算法。使用这样的库可以大大简化开发工作，避免重复造轮子，...
[SM2_SM3_SM4]国密加解密算法java实现源码，附带代码使用到的jar包以及PC验证工具
12-15
在Java中实现SM2，需要引入支持椭圆曲线的库，比如Bouncy Castle。在Android Studio中，可以配置该库的jar包，然后创建公钥和私钥对，进行加密和解密操作。关键步骤包括：生成椭圆曲线参数，创建密钥对，以及执行...
sm 2 3 4 加密工具类-java
06-07
在描述中提到的"bcprov-jdk16"就是Bouncy Castle库的一个版本，它提供了对SM2算法的支持。在项目中，你需要配置这个jar包为安全提供者，然后就可以使用SM2的相关类进行加密和解密操作。 2. SM3 哈希算法： SM3是一...
SM2加密工具类JAVA
03-01
在JAVA中，可以使用`org.bouncycastle.jce.provider.BouncyCastleProvider`提供者，并通过`KeyPairGenerator`生成密钥对。 ```java Security.addProvider(new BouncyCastleProvider()); KeyPairGenerator keyGen = ...
国密依赖包bcprov-jdk16-1.46.jar
03-04
bcprov-jdk16-1.46.jar是由Bouncy Castle提供的，Bouncy Castle是一个Java安全框架，提供了大量的加密算法和协议实现，包括对国密算法的支持。这个特定的版本（1.46）是针对JDK16编译的，因此它兼容Java 1.6及以上的...
SM2、SM系列加解密java代码
03-26
开发者需要理解ECC的基础理论，并掌握如何在Java中使用如Bouncy Castle等加密库来实现这些功能。 接着，SM3是一种密码散列函数，类似于SHA-256，用于产生消息摘要。在Java中实现SM3，通常涉及将输入数据转化为固定...
hutool国密sm2算法使用， 正确的秘钥生成签名及验签，签名为64字节
qq_33140565的博客
02-15 2万+
hutool工具类： 在糊涂提供的国密算法，需要通过椭圆曲线生成秘钥，且当前业内私钥长度为固定32字节，公用固定长度为64字节。在参考hutool官方文档中的国密算法的例子，发现生成的秘钥非常长，远大于32字节和64字节，生成的签名长度也不是64字节。 问题描述： 官方提供如下例子，用于演示签名和验签 String content = "我是Hanley."; KeyPair pair = SecureUtil.generateKeyPair("SM2"); final SM2 sm2 = new SM2(
java实现国产SM3、SM4加密
weixin_42456784的博客
09-13 1万+
java实现国产SM3\SM4加密
sm2,sm4加密（js+java）
热门推荐
qq_41427281的博客
09-26 4万+
一、使用 做项目时，首先采用了sm2数据传输加密，随后又改为sm4，此处使用仅为个人愚见，望与诸君共勉。 sm2,非对称加密，在后端生成两对秘钥，私钥A,公钥A,私钥B,公钥B。前端持有公钥A,私钥B，后端持有公钥B,私钥A，即前端利用js算法和公钥A对数据加密，后端利用java算法和秘钥A解密；后端利用java算法和密匙B加密,前端利用js算法和公式B对数据解密。 sm4,对称加密，在前段随机ECB模式【生成一个秘钥】,CBC模式【生成一个秘钥，和一个初始向量】，登录时采用sm2加密后传递给后台，每个客
java实现国密算法
12-31
Java作为一种广泛应用的编程语言，可以通过多种方式实现国密算法。 首先，可以使用Java语言自带的加密库实现国密算法。Java提供了丰富的加密算法库，可以用于实现国密算法的各种功能，比如SM2的数字签名、SM3的消息...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值