SM4国密算法Java实现

MessiNine MessiNine 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 1.4w累计阅读 1.4w+平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄10年
关注
原创 最新推荐文章于 2026-06-28 16:48:12 发布 1.4w 阅读 AI 写同款· GEO 优化 ›
数据加密算法之国密SM4、SM3、SM2研究及Java实现 国密加密算法研究 阅读详情

1、基本密码部件,S盒置换,非线性变换τ,L变换,T变换

public class BasicComponents {
	private int[][] SBOX={{0xd6,0x90,0xe9,0xfe,0xcc,0xe1,0x3d,0xb7,0x16,0xb6,0x14,0xc2,0x28,0xfb,0x2c,0x05},
            {0x2b,0x67,0x9a,0x76,0x2a,0xbe,0x04,0xc3,0xaa,0x44,0x13,0x26,0x49,0x86,0x06,0x99},
            {0x9c,0x42,0x50,0xf4,0x91,0xef,0x98,0x7a,0x33,0x54,0x0b,0x43,0xed,0xcf,0xac,0x62},
            {0xe4,0xb3,0x1c,0xa9,0xc9,0x08,0xe8,0x95,0x80,0xdf,0x94,0xfa,0x75,0x8f,0x3f,0xa6},
            {0x47,0x07,0xa7,0xfc,0xf3,0x73,0x17,0xba,0x83,0x59,0x3c,0x19,0xe6,0x85,0x4f,0xa8},
            {0x68,0x6b,0x81,0xb2,0x71,0x64,0xda,0x8b,0xf8,0xeb,0x0f,0x4b,0x70,0x56,0x9d,0x35},
            {0x1e,0x24,0x0e,0x5e,0x63,0x58,0xd1,0xa2,0x25,0x22,0x7c,0x3b,0x01,0x21,0x78,0x87},
            {0xd4,0x00,0x46,0x57,0x9f,0xd3,0x27,0x52,0x4c,0x36,0x02,0xe7,0xa0,0xc4,0xc8,0x9e},
            {0xea,0xbf,0x8a,0xd2,0x40,0xc7,0x38,0xb5,0xa3,0xf7,0xf2,0xce,0xf9,0x61,0x15,0xa1},
            {0xe0,0xae,0x5d,0xa4,0x9b,0x34,0x1a,0x55,0xad,0x93,0x32,0x30,0xf5,0x8c,0xb1,0xe3},
            {0x1d,0xf6,0xe2,0x2e,0x82,0x66,0xca,0x60,0xc0,0x29,0x23,0xab,0x0d,0x53,0x4e,0x6f},
            {0xd5,0xdb,0x37,0x45,0xde,0xfd,0x8e,0x2f,0x03,0xff,0x6a,0x72,0x6d,0x6c,0x5b,0x51},
            {0x8d,0x1b,0xaf,0x92,0xbb,0xdd,0xbc,0x7f,0x11,0xd9,0x5c,0x41,0x1f,0x10,0x5a,0xd8},
            {0x0a,0xc1,0x31,0x88,0xa5,0xcd,0x7b,0xbd,0x2d,0x74,0xd0,0x12,0xb8,0xe5,0xb4,0xb0},
            {0x89,0x69,0x97,0x4a,0x0c,0x96,0x77,0x7e,0x65,0xb9,0xf1,0x09,0xc5,0x6e,0xc6,0x84},
            {0x18,0xf0,0x7d,0xec,0x3a,0xdc,0x4d,0x20,0x79,0xee,0x5f,0x3e,0xd7,0xcb,0x39,0x48}
			};
	
	
	//S盒置换,输入8位,输出8位,输入一个两位的16进制数
	int S_Box(int n){
		if(n<0||n>255){
			System.out.println("S盒输入错误");
			return 0;
		}
		int j = n%16;  //j为第二位的数
		int i = (n-j)/16;   //i为第一位的数
		//System.out.println("i:" + i + ",j:" + j);
		int result = SBOX[i][j];
		return result;
	}
	
	//非线性变换τ,4个S盒并行置换,输入32位,输出32位,输入4个两位的16进制数
	int[] PIChange(int[] n1){
		if(n1.length!=4){
			System.out.println("τ变换输入错误");
			return null;
		}
		for(int i=0;i<4;i++){
			if(n1[i]<0||n1[i]>255){
				System.out.println("τ变换输入错误");
				return null;
			}
		}
		int[] res = new int[4];
		for(int i=0;i<4;i++){
			res[i] = S_Box(n1[i]);
		}
		return res;
	}
	
	//L变换,32位输入,32位输出,输入4个两位的16进制数
	int[] LChange(int[] n1){
		if(n1.length!=4){
			System.out.println("L变换输入错误");
			return null;
		}
		for(int i=0;i<4;i++){
			if(n1[i]<0||n1[i]>255){
				System.out.println("L变换输入错误");
				return null;
			}
		}
		Tools tool = new Tools();
		String res = "";
		String B = tool.HexToStr(n1);
		res = tool.XOR(B, tool.loopleftmove(B, 2));
		res = tool.XOR(res, tool.loopleftmove(B, 10));
		res = tool.XOR(res, tool.loopleftmove(B, 18));
		res = tool.XOR(res, tool.loopleftmove(B, 24));
		int[] result = tool.BinToIntArray(res);
		return result;
	}
	
	//T变换
	int[] TChange(int[] n1){
		int[] result = new int[4];
		result = PIChange(n1);
		result = LChange(result);
		return result;
	}
	
	//L'变换,32位输入,32位输出,输入4个两位的16进制数
	int[] L_1Change(int[] n1){
		if(n1.length!=4){
			System.out.println("L变换输入错误");
			return null;
		}
		for(int i=0;i<4;i++){
			if(n1[i]<0||n1[i]>255){
				System.out.println("L变换输入错误");
				return null;
			}
		}
		Tools tool = new Tools();
		String res = "";
		String B = tool.HexToStr(n1);
		res = tool.XOR(B, tool.loopleftmove(B, 13));
		res = tool.XOR(res, tool.loopleftmove(B, 23));
		int[] result = tool.BinToIntArray(res);
		return result;
	}
	
	//T'变换
	int[] T_1Change(int[] n1){
		int[] result = new int[4];
		result = PIChange(n1);
		result = L_1Change(result);
		return result;
	}
	
	public static void main(String[] args){
		BasicComponents bc = new BasicComponents();
		int[] n = {0x11,0x12,0x13,0x14};
		int[] m = bc.PIChange(n);
		for(int i=0;i<4;i++){
			System.out.println(m[i]);
		}
		
	}
	
}

2、轮函数

public class WheelFunction {
	//轮函数方法,输入128位,输出32位,输入4个32位字的数据和一个32位的轮密钥,输出一个32位字
	int[] F(int[] tn0, int[] tn1, int[] tn2, int[] tn3, int[] rk){
		if(tn0.length!=4||tn1.length!=4||tn2.length!=4||tn3.length!=4||rk.length!=4){
			System.out.println("轮函数输入错误");
			return null;
		}
		Tools tool = new Tools();
		BasicComponents bc = new BasicComponents();
		String str = "";
		str = tool.XOR(tool.HexToStr(tn1), tool.HexToStr(tn2));
		str = tool.XOR(str, tool.HexToStr(tn3));
		str = tool.XOR(str, tool.HexToStr(rk));
		int[] res = new int[4];
		res = tool.BinToIntArray(str);
		res = bc.TChange(res);
		str = tool.HexToStr(res);
		str = tool.XOR(tool.HexToStr(tn0), str);
		res = tool.BinToIntArray(str);
		return res;
	}
	
}

3、密钥拓展算法

public class KeyExpansion {
	private String FK0 = "a3b1bac6";
	private String FK1 = "56aa3350";
	private String FK2 = "677d9197";
	private String FK3 = "b27022dc";
	private String[] CK = {"00070e15","1c232a31","383f464d","545b6269",
						"70777e85","8c939aa1","a8afb6bd","c4cbd2d9",
						"e0e7eef5","fc030a11","181f262d","343b4249",
						"50575e65","6c737a81","888f969d","a4abb2b9",
						"c0c7ced5","dce3eaf1","f8ff060d","141b2229",
						"30373e45","4c535a61","686f767d","848b9299",
						"a0a7aeb5","bcc3cad1","d8dfe6ed","f4fb0209",
						"10171e25","2c333a41","484f565d","646b7279"
						};
	
	//输入加密密钥4个32位字,输出轮密钥
	String[] wheelKey(String[] MK){
		Tools tool = new Tools();
		BasicComponents bc = new BasicComponents();
		String[] k = new String[36];  //k中存的是32位的比特串
		String[] rk = new String[32];
		String tmk = tool.HexToStr(tool.HexToIntArray(MK[0]));
		String tfk = tool.HexToStr(tool.HexToIntArray(FK0));
		k[0] = tool.XOR(tmk, tfk);
		tmk = tool.HexToStr(tool.HexToIntArray(MK[1]));
		tfk = tool.HexToStr(tool.HexToIntArray(FK1));
		k[1] = tool.XOR(tmk, tfk);
		tmk = tool.HexToStr(tool.HexToIntArray(MK[2]));
		tfk = tool.HexToStr(tool.HexToIntArray(FK2));
		k[2] = tool.XOR(tmk, tfk);
		tmk = tool.HexToStr(tool.HexToIntArray(MK[3]));
		tfk = tool.HexToStr(tool.HexToIntArray(FK3));
		k[3] = tool.XOR(tmk, tfk);
		for(int i=0;i<32;i++){
			String ts = "";
			ts = tool.XOR(k[i+1], k[i+2]);
			ts = tool.XOR(ts, k[i+3]);
			ts = tool.XOR(ts, tool.HexToStr(tool.HexToIntArray(CK[i])));
			ts = tool.HexToStr(bc.T_1Change(tool.BinToIntArray(ts)));
			ts = tool.XOR(k[i], ts);
			k[i+4] = ts;
			rk[i] = tool.IntArrayToStr(tool.BinToIntArray(ts));
		}
		return rk;
	}
	
}

4、加密算法

import java.util.ArrayList;

//加密算法

public class Encrypt {
	private String plaintext;  //明文
	private String[] MK;  //密钥
	
	public Encrypt(){
		
	}
	
	public Encrypt(String plaintext, String[] MK){
		this.plaintext = plaintext;
		this.MK = MK;
	}

	//加密入口,接受一个String类型的明文,将其依次转换成4个int数组放入encryptProcess中加密,获得输出,输出最后结果
	public ArrayList<int[]> encryptEntrance(){
		KeyExpansion ke = new KeyExpansion();
		String[] rk = ke.wheelKey(MK);  //根据密钥拓展得出轮密钥
		Tools tool = new Tools();
		plaintext = tool.fillNumber(plaintext);
		ArrayList<int[]> res = new ArrayList<int[]>();
		for(int n=0;n<plaintext.length()/16;n++){
			ArrayList<int[]> t = new ArrayList<int[]>();
			ArrayList<int[]> tres = new ArrayList<int[]>();
			String s = plaintext.substring(n*16, (n+1)*16);
			t = tool.StrToList(s);
			tres = encryptProcess(t.get(0),t.get(1),t.get(2),t.get(3),rk);
			res.add(tres.get(0));
			res.add(tres.get(1));
			res.add(tres.get(2));
			res.add(tres.get(3));
		}
		return res;
	}
	
	//加密过程,输入128位明文,4个长度为4的int数组(每一个元素为一个两位的十六进制数),输入轮密钥,输出128位密文
	ArrayList<int[]> encryptProcess(int[] n0, int[] n1, int[] n2,int[] n3, String[] rk){
		if(n0.length!=4||n1.length!=4||n2.length!=4||n3.length!=4){
			System.out.println("encrypt输入错误");
			return null;
		}
		Tools tool = new Tools();
		WheelFunction wf = new WheelFunction();
		ArrayList<int[]> x = new ArrayList<int[]>();
		x.add(n0);
		x.add(n1);
		x.add(n2);
		x.add(n3);
		for(int i=0;i<32;i++){
			int[] trk = tool.HexToIntArray(rk[i]);
			x.add(wf.F(x.get(i), x.get(i+1), x.get(i+2), x.get(i+3), trk));
		}
		ArrayList<int[]> res = new ArrayList<int[]>();
		res.add(x.get(35));
		res.add(x.get(34));
		res.add(x.get(33));
		res.add(x.get(32));
		return res;
	}
	
	
	public String getPlaintext() {
		return plaintext;
	}

	public void setPlaintext(String plaintext) {
		this.plaintext = plaintext;
	}

	public String[] getMK() {
		return MK;
	}

	public void setMK(String[] mK) {
		MK = mK;
	}
}

5、解密算法

import java.util.ArrayList;

public class Decrypt {
	private ArrayList<int[]> ciphertext;  //密文
	private String[] MK;  //密钥
	
	public Decrypt(){
		
	}
	
	public Decrypt(ArrayList<int[]> ciphertext, String[] MK){
		this.ciphertext = ciphertext;
		this.MK = MK;
	}

	//解密入口
	public String decryptEntrance(){
		KeyExpansion ke = new KeyExpansion();
		String[] rk = ke.wheelKey(MK);  //根据密钥拓展得出轮密钥
		Tools tool = new Tools();
		String res = ""; 
		for(int n=0;n<ciphertext.size()/4;n++){
			ArrayList<int[]> tal = new ArrayList<int[]>();
			tal = decryptProcess(ciphertext.get(n*4),ciphertext.get(n*4+1),ciphertext.get(n*4+2),ciphertext.get(n*4+3),rk);
			res += tool.ListToStr(tal);
		}
		res = tool.restore(res);
		return res;
	}
	
	

	//解密过程,输入128位密文,4个长度为4的int数组(每一个元素为一个两位的十六进制数),输入轮密钥,输出128位明文
	ArrayList<int[]> decryptProcess(int[] n0, int[] n1, int[] n2,int[] n3, String[] rk){
		if(n0.length!=4||n1.length!=4||n2.length!=4||n3.length!=4){
			System.out.println("decrypt输入错误");
			return null;
		}
		Tools tool = new Tools();
		WheelFunction wf = new WheelFunction();
		ArrayList<int[]> x = new ArrayList<int[]>();
		x.add(n0);
		x.add(n1);
		x.add(n2);
		x.add(n3);
		for(int i=0;i<32;i++){
			int[] trk = tool.HexToIntArray(rk[31-i]);
			x.add(wf.F(x.get(i), x.get(i+1), x.get(i+2), x.get(i+3), trk));
		}
		ArrayList<int[]> res = new ArrayList<int[]>();
		res.add(x.get(35));
		res.add(x.get(34));
		res.add(x.get(33));
		res.add(x.get(32));
		return res;
	}
	

	public void setCiphertext(ArrayList<int[]> ciphertext) {
		this.ciphertext = ciphertext;
	}
	
	public ArrayList<int[]> getCiphertext() {
		return ciphertext;
	}

	public String[] getMK() {
		return MK;
	}

	public void setMK(String[] mK) {
		MK = mK;
	}
	
}

6、工具类

import java.util.ArrayList;

public class Tools {
	//将0到255之间int类型的数转换为8位二进制的String类型表示
	public String IntToBin(int i){
		if(i<0||i>255){
			System.out.println("IntToStr输入错误");
			return null;
		}
		String str = "";
		for(int n=7;n>=0;n--){
			int t = 1<<n;  //1<<n等于2的n次方
			if(i>=t){
				str = str + "1";
				i = i-t;
			}else{
				str = str + "0";
			}
		}
		return str;
	}
	
	//把8位String类型的二进制表示转换为int类型的数
	public int BinToInt(String str){
		if(str.length()!=8){
			System.out.println("BinToInt输入错误");
			return 0;
		}
		int result = 0;
		for(int i=0;i<8;i++){
			if(str.charAt(i)=='1'){
				result += 1<<(7-i);
			}
		}
		return result;
	}
	
	//把一个包含4个两位十六进制数的数组转换成32位(二进制表示)的字符串
	public String HexToStr(int[] n1){
		String res = "";
		for(int i=0;i<n1.length;i++){
			res += IntToBin(n1[i]);
		}
		return res;
	}
	
	//将一个32位的比特串转换成一个int数组
	public int[] BinToIntArray(String str){
		if(str.length()!=32){
			System.out.println("BinToIntArray输入错误");
			return null;
		}
		int[] result = new int[4];
		result[0] = BinToInt(str.substring(0, 8));
		result[1] = BinToInt(str.substring(8, 16));
		result[2] = BinToInt(str.substring(16, 24));
		result[3] = BinToInt(str.substring(24, 32));
		return result;
	}
	
	//循环左移n位方法
	public String loopleftmove(String str,int n){
		if(n>32){
			return null;
		}
		String s1,s2,res;
		s1 = str.substring(0, n);
		s2 = str.substring(n,32);
		res = s2 + s1;
		return res;
	}
	
	//String类型的异或运算,相同为零,不同为一
	public String XOR(String str1,String str2){
		if(str1.length()!=str2.length()){
			System.out.println("XOR方法输入错误,参数长度不同");
			return null;
		}
		String res = "";
		for(int i=0;i<str1.length();i++){
			if(str1.charAt(i)==str2.charAt(i)){
				res += "0";
			}else{
				res += "1";
			}
		}
		return res;
	}	
	
	//将String表示的4个两位十六进制数转换成一个int数组
	public int[] HexToIntArray(String str){
		if(str.length()!=8){
			System.out.println("HexToIntArray输入错误");
			return null;
		}
		int[] res = new int[4];
		for(int i=0;i<4;i++){
			int sum = 0;
			if(str.charAt(2*i)>=48&&str.charAt(2*i)<=57){
				sum += (str.charAt(2*i)-48)*16;
			}else{
				sum += (str.charAt(2*i)-87)*16;
			}
			if(str.charAt(2*i+1)>=48&&str.charAt(2*i+1)<=57){
				sum += str.charAt(2*i+1)-48;
			}else{
				sum += str.charAt(2*i+1)-87;
			}
			res[i] = sum;
		}
		return res;
	}
	
	//将一个长度为4的int数组装换成String类型的十六进制表示
	public String IntArrayToStr(int[] n1){
		if(n1.length!=4){
			System.out.println("IntArrayToStr输入错误");
			return null;
		}
		String res = "";
		for(int i=0;i<4;i++){
			res += IntToHex(n1[i]);
		}
		return res;
	}
	
	//将一个int数转换成一个两位的十六进制数
	public String IntToHex(int i){
		String res = "";
		//第一位数是n，第二位是变换后的i
		int n=15;
		for(;n>=0;n--){
			if(n*16<=i){
				i = i-n*16;
				break;
			}
		}
		if(n>9){
			res = res + (char)(n+87);
		}else{
			res = res + n;
		}
		if(i>9){
			res = res + (char)(i+87);
		}else{
			res = res + i;
		}
		return res;
	}
	
	//若str不能整除16则用" "补齐位数
	public String fillNumber(String str){
		int m = str.length()%16;
		if(m!=0){
			for(int n=0;n<(16-m%16);n++){
				str += " ";
			}
		}
		return str;
	}
	
	//若str末尾有" ",则将末尾的" "全都去掉
	public String restore(String str){
		while(str.charAt(str.length()-1)==' '){
			str = str.substring(0, str.length()-1);
		}
		return str;
	}
	
	//将一个16位的字符串转化成4个长度为4的int数组存入ArrayList中
	public ArrayList<int[]> StrToList(String str){
		if(str.length()!=16){
			System.out.println("StrToList输入错误");
			return null;
		}
		ArrayList<int[]> res = new ArrayList<int[]>();
		for(int n=0;n<4;n++){
			int[] t = new int[4];
			t[0] = str.charAt(n*4);
			t[1] = str.charAt(n*4+1);
			t[2] = str.charAt(n*4+2);
			t[3] = str.charAt(n*4+3);
			res.add(t);
		}
		return res;
	}
	
	//将ArrayList中的数提出来转换为String
	public String ListToStr(ArrayList<int[]> al){
		String res = "";
		for(int n=0;n<4;n++){
			int[] t = al.get(n);
			for(int i=0;i<4;i++){
				res += (char)t[i];
			}
		}
		return res;
	}
	
	public static void main(String[] args){
		Tools tool = new Tools();
		String s = "abcdABCDjigi1234";
		ArrayList<int[]> a = tool.StrToList(s);
		System.out.println(tool.ListToStr(a));
		
	}
	
}

收录于
密码学

当前文章被收录于：

密码学
1 篇文章 0 人学习
订阅专栏 查看详情
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
sm4 加解密算法工具类（ Java 版 ） sm4 加解密算法工具类（java）说明：密钥是 hexString。 阅读详情

相关推荐

国密SM4加解密--Java实现

【代码】国密SM4加解密--Java实现。

怪只怪满眼尽是人间烟火 5158

Java实现常用加密算法 —— SM4

本篇主要介绍SM4算法在Java（JDK1.8）中如何实现，借助Java标准库或第三方库，非原始实现，较为基础。一、SM4是什么？SM4.0（原名SMS4.0）是中华人民共和国政府采用的一种分组密码标准，由国家密码管理局于2012年3月21日发布。相关标准为“GM/T 0002-2012《SM4分组密码算法》（原SMS4分组密码算法）”。

m0_46713218的博客 1万+

sm2、sm4国密加密算法java实现(真实可用)

sm2、sm4国密加密算法java实现加密后内容 加密后内容 可自行验证是否是你需要的sm2加密算法 私钥：BF1F907B4E0487F798DC80AFD7BC2A6201E8514233002272EA3BE2FC6F797843 公钥:前缀04+x坐标+y坐标 042DBA45E7B03394F603CADAFCDDEC854D3E01A4E9C52CD799B85B1A14BDB970137AE58BA553D79F058604DC1CD4B77DE5408BA3308E767584100C2B6

gusijin的博客 8899

国密算法 SM4 加解密 java 工具类

我国国家密码管理局陆续发布了一系列国产加密算法，这其中就包括 SM1、SM2、SM3 、SM4、SM7、SM9、ZUC（祖冲之加密算法）等，SM 代表商密，即商业密码，是指用于商业的、不涉及国家秘密的密码技术。SM1 和 SM7 的算法不公开，其余算法都已成为 ISO/IEC 国际标准

技术博客 1万+

Java实现SM4国密算法加密：基于Bouncy Castle的实战指南

在数据安全领域，对称加密算法是保障信息机密性的核心技术，通过对数据进行加密转换，确保只有授权方能够访问原始内容。其原理基于密钥和特定算法对数据进行混淆与还原，在金融、政务等高安全要求场景中具有重要价值。国密SM4算法作为我国商用密码标准，采用128位分组长度，与AES结构相似但自主可控，广泛应用于数据加密传输。本文聚焦于Java生态下的SM4算法实现，针对JDK未内置该算法的现状，详细介绍了如何通过引入Bouncy Castle密码库来构建完整的加解密方案，涵盖CBC工作模式、PKCS5Padding填充方

weixin_27199085的博客 176

Java实现SM4国密算法与Base64编码的完整工程实践

在数据安全传输领域，对称加密算法是保障信息机密性的核心技术。其原理是通过同一密钥进行数据的加密与解密，确保只有授权方能够访问原始信息。这项技术的核心价值在于为金融、政务等高合规性场景提供可靠的数据保护方案。国密SM4算法作为我国商用密码标准，以其128位分组长度和固定的密钥长度，在自主可控与安全性之间取得了平衡。在实际工程应用中，常需将加密后的二进制数据通过文本协议（如HTTP/JSON）传输，Base64编码技术在此扮演关键角色，它能将二进制数据转换为ASCII字符，避免特殊字符引发的传输错误。本文聚焦于

weixin_31648507的博客 308

java运用SM4国密算法对文件的加密与解密的实现

为jar包的文件路径，我们需要使用以下的路径存储jar包。然后创建所需要加密的文件 ，需要加密的文件内容，并保存文件加密的地址。我们用右键选择打开方式，用文本的方式打开可以看到加密后的信息如下。首先我们在idae开发工具导入导入pom.xml的两个必要依赖。我们可以看到文件路径上多了两个文件，分别是加解密后的文件。以上就是java对sm4国密算法的加密解密方式。ok我们加密成功了！同理解密的文件也能解密成功。java包的文件路径如图所示。图上systemPath。

qq_20485939的博客 7692

【进阶之路】SM4国密算法与实现

一、起因 最近在工作中，突然一个交易异常缓慢，调用时间高达40wms，严重影响了整个集群的生产效率。得知这个情况，我开始对整个交易进行剖析，最终发现原来是RSA非对称加密算法的锅。 RSA作为一种非对称的加密算法，其中很重要的一特点是当数据在网络中传输时，用来加密数据的密钥并不需要也和数据一起传送。因此，这就减少了密钥泄露的可能性。RSA在不允许加密方解密数据时也很有用，加密的一方使用一个密钥，称为公钥，解密的一方使用另一个密钥，称为私钥，私钥需要保持其私有性。 RSA非常安全，但是效率却很低，本身的秘

南橘Home 1万+

sm4算法 java_SM4国密算法java实现

importorg.apache.commons.codec.binary.Hex;importorg.bouncycastle.jce.provider.BouncyCastleProvider;importorg.bouncycastle.pqc.math.linearalgebra.ByteUtils;importjavax.crypto.Cipher;importjavax.crypto....

weixin_42307436的博客 2364

Java国密SM4算法实战：从原理到工程化实现

对称加密是保障数据机密性的核心技术，其核心原理在于使用相同密钥进行加解密，确保信息传输的私密性。在分组密码中，算法通过多轮迭代的混淆与扩散操作，将固定长度的明文块转换为密文，从而构建起基础的数据安全屏障。随着数据安全法规的日益严格与自主可控需求的提升，国密算法体系的重要性凸显，其在金融、政务等关键领域有着广泛的应用场景。SM4作为国密标准中的对称加密算法，凭借其128位分组长度和32轮迭代的Feistel结构，提供了与国际主流算法相当的安全强度。本文聚焦于SM4-CBC模式在Java环境下的工程实践，详细解

ctpaknc9526的博客 478

SPD5 集线器协议内容解析

​ 若不同SPD5 Hub后面的本地侧设备同时发送请求，则是22和23、24的混合过程，先通过LID裁决，再通过HID裁决，这里的LID是本地设备的，若LID一致，则看HID，由于SPD5 Hub的本地侧设备HID均为111，因此实际上是比较SPD5 Hub的HID，这个过程在前文提到，SPD5 Hub会转换HID。​ 若MR27[4]=1且MR27[3:0]=1，如果MR51[3:0]=1时，发送IBI，并且MR48[7]置1，将GETSTATUS CCC的待处理中断位[3:0]更新为0001。

weixin_50591344的博客 3860

SM4国密算法java实现

import org.apache.commons.codec.binary.Hex; import org.bouncycastle.jce.provider.BouncyCastleProvider; import org.bouncycastle.pqc.math.linearalgebra.ByteUtils; import javax.crypto.Cipher; import javax.crypto.KeyGenerator; import javax.crypto.spec.SecretK

qq_21236251的博客 2355

KMS服务器一键部署与激活实战指南

本文详细介绍了KMS服务器的一键部署与激活实战指南，包括快速入门、安装步骤、服务管理技巧及常见问题排查。特别针对Windows和Mac用户提供了Office激活的具体操作步骤，并分享了高级配置与优化方案，帮助IT管理员高效管理批量授权激活。

weixin_29305313的博客 461

Java国密SM4算法实战：从原理到ECB模式加解密完整实现

分组密码是保障数据机密性的基础密码学组件，其核心原理是将明文按固定长度分组，通过轮函数和密钥进行多轮迭代变换，实现混淆与扩散。在工程实践中，分组密码需结合特定工作模式来处理任意长度数据，并依赖成熟的密码库确保安全与效率。国密SM4算法作为我国商用密码标准，采用128位分组和密钥长度，其Feistel结构设计兼顾了安全性与实现便利性，广泛应用于金融、政务等对合规性有严格要求的领域。本文聚焦于SM4的ECB模式，通过Bouncy Castle库在Java环境中完成从密钥生成到加解密的完整流程，为开发者应对数据安

weixin_42530732的博客 328

SAP(ERP)工艺路线(Routing)业务视角解析

工艺路线(Routing)也是PP模块，即生产制造模块中最重要核心主数据之一，也是ERP(SAP)顾问，必需从业务与系统深入掌握的重要主数据，它也是整个生产计划与生产流程的重要基础。因为执行步骤只是操作层面的认知，业务顾问需要从业务本质上去理解它，要真正从业务视角理解工艺路线的业务价值，而不仅仅是操作层面的认知。因此将工艺路线理解为“有以上业务本质的理解，然后进到SAP系统中，就容易理解工艺路线(Routing)的每一组成部分结构与功能了，本质就是理解制造企业如何将设计意图转化为物理现实的编码规则。

m0_45197968的博客 1501

从ORCAP-1589警告看Cadence ORCAD的DRC设置：如何避免‘网络别名’引发的潜在短路风险

本文深入解析Cadence ORCAD中ORCAP-1589警告的深层含义，探讨网络别名可能引发的短路风险及DRC设置优化方案。通过分析网络别名的设计意图、DRC规则配置及最佳实践，帮助工程师有效规避设计风险，提升电路设计的可靠性和规范性。

weixin_34194829的博客 297

Java实现SM4国密算法：从原理到实战的完整指南

对称加密是保障数据机密性的核心技术，其原理在于使用同一密钥进行加解密操作，确保信息传输安全。作为分组密码算法，SM4采用128位分组长度和密钥长度，通过Feistel网络结构实现32轮迭代运算，结合S盒和线性变换确保混淆与扩散特性。在工程实践中，选择合适的工作模式（如CBC、GCM）和填充方案（如PKCS7）对安全性至关重要。针对Java开发场景，Bouncy Castle库提供了标准化的SM4算法实现，开发者需掌握密钥生成、IV管理及异常处理等关键环节。本文聚焦SM4国密算法在Java项目中的集成与应用，

weixin_28716443的博客 334

保姆级教程：在Ubuntu 22.04上用Python3.10和pysoem搞定EtherCAT电机回零与位置控制

本文提供在Ubuntu 22.04上使用Python3.10和pysoem实现EtherCAT电机回零与位置控制的详细指南。涵盖环境搭建、权限配置、EtherCAT主站架构解析、CiA402协议核心机制及工业级精度控制实现，帮助开发者快速掌握Python在工业自动化中的应用。

weixin_30952535的博客 329

Java实现SM4国密算法：从原理到生产环境实践

分组密码算法是现代信息安全的核心基础技术之一，它通过对固定长度的数据块进行置换和混淆操作，实现数据的机密性保护。其核心原理在于利用密钥控制的多轮非线性变换，将可读的明文转换为不可读的密文，技术价值在于为数据传输和存储提供了基础的加密保障。在金融、政务等对数据安全有严格要求的应用场景中，国密算法SM4作为我国自主设计的分组密码标准，正逐步替代国际算法。本文聚焦于在Java工程中，如何借助Bouncy Castle密码库，稳健地实现SM4算法的ECB与CBC两种工作模式，并深入探讨密钥管理、初始化向量(IV)安

weixin_27199085的博客 433

把 ABAP 选择屏幕 Selection Screen 打造成可维护的交互面板：常用屏幕元素与动态控制全解析

本文详细介绍了ABAP报表中Selection Screen的设计技巧，包括空行(SKIP)、横线(ULINE)、注释(COMMENT)等基础元素的使用方法，以及如何通过MODIF ID实现动态界面调整。重点讲解了行内布局(BEGIN OF LINE)、按钮(PUSHBUTTON)和区块(BLOCK)等高级功能，帮助开发者将选择屏幕从"能用"提升到"好用、易扩展、可维护"的水平。文章还分享了项目实践中的命名规范和分组策略，特别适合需要优化ABAP报表用户体验的开发人员

2007 年 ~ 2025 年，深耕 SAP 技术 18 年 331

【Java开发者必看】LangChain4j实战指南：使用AIService轻松集成聊天记忆Chat Memory到SpringBoot应用，通过封装多轮复杂对话，使聊天记忆的实现变得简单

聊天记忆是指在与用户的多轮对话过程中，能够记住之前的交互内容，从而提供更加连贯和个性化的回复。LangChain4j支持通过ChatMemoryProvider接口实现聊天记忆功能。

Spring Boot-Common On With You 448

探索国密算法：SM2、SM3、SM4的Java实现

探索国密算法：SM2、SM3、SM4的Java实现 【下载地址】SM2SM3SM4国密算法Java实现含详细测试代码 本仓库提供了一个完整的Java实现，涵盖了国密算法中的SM2、SM3和SM4。具体包括：- **SM2密码算法**：实现了加密/解密、签名验签功能。- **SM3密码杂凑算法**：实现了密码杂凑功能。- ...

gitblog_09702的博客 1008

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

Java实现SM4国密算法：从原理到实践，手把手教你手搓加密引擎

分组密码算法是现代密码学的基石，它通过固定长度的数据块和密钥，实现数据的加密与解密，为信息安全提供核心保障。其原理基于复杂的数学变换，通过多轮迭代和非线性操作，确保密文的混乱与扩散特性，从而具备极高的抗攻击能力。在工程实践中，这类算法广泛应用于金融、政务、通信等对数据安全有严格要求的领域，是构建安全系统的关键技术组件。本文聚焦于国密标准SM4算法，深入解析其轮函数F的工作原理和密钥扩展的线性变换L‘机制，并提供了完整的Java实现方案，涵盖核心模块设计、CBC工作模式与PKCS7填充，以及常见问题调试技巧，

weixin_42524171的博客 312

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件，这是C++版本的破解文件

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android：LinePhone3.2.7(最新版本)，官网地址：http://www.linphone.org/

SM4国密对称加密算法实现javascript js web前端SM4算法加密，java后端SM4算法解密，等保http请求明文传输漏洞处理，SM4前端、后端加密解密算法记录

SM4国密对称加密算法实现javascript js web前端SM4算法加密，java后端SM4算法解密，等保http请求明文传输漏洞处理

qq445829096的博客 724

文档：亲测可用解决vnc灰屏，黑屏，鼠标大黑叉情况

主要解决vnc-viewer灰屏，黑屏，鼠标大黑叉等现象，详细见文档。

Java实现SM4国密算法：从原理到工程实践详解

对称加密是现代信息安全的基础，其核心在于通过相同的密钥完成数据的加密与解密，保障了信息传输的机密性。其工作原理通常基于分组密码结构，通过多轮迭代的混淆与扩散操作，将明文转换为难以破解的密文。这种技术在数据安全领域具有重要价值，广泛应用于金融支付、政务通信、物联网设备认证等对数据保密性要求极高的场景。本文聚焦于国密标准SM4算法，深入剖析其作为分组密码的算法结构、S盒非线性变换与密钥扩展机制等核心原理，并提供了完整的Java工程实现方案，涵盖ECB/CBC工作模式与PKCS7填充，助力开发者应对金融、政务等领

weixin_28715953的博客 342
上一篇： SQL必知必会阅读笔记(过滤数据、高级数据过滤、用通配符进行过滤)
下一篇： 七种排序方法个人总结
点赞 1
评论 5
书签 书签 15
MessiNine
MessiNine
博客等级 码龄10年 61粉丝 4原创
+ 关注 专栏目录 订阅专栏
评论 5
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值