程序猿成长之路之密码学篇-AES算法解密详解及代码呈现

置顶 已于 2023-06-23 13:59:41 修改
阅读量2.6k 收藏 11
点赞数 2
文章标签： 密码学 算法 web安全
于 2023-06-14 14:48:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31236027/article/details/131206018
版权

各位csdn的小伙伴们大家好呀，我又回来了，这篇文章为上一次介绍AES加密算法的姊妹篇，重点将会详细介绍一下AES算法的解密过程并呈上AES加解密的代码。【暂时不包含iv即偏移量】。下面请跟随我一同进入AES解密的世界。

AES加密详解

如果有小伙伴对AES算法或者AES加密还有所疑问的，可以参考一下我之前写的文章。
https://blog.csdn.net/qq_31236027/article/details/129796471

AES解密

与DES解密仅需要调换密钥组的顺序相比，AES解密会变得更为繁琐。

整体流程

假设大家都了解了AES的加密过程，那么我们知道加密共11轮，而解密亦是如此。加密第一轮就只进行一次轮密钥加，而最后一轮加密则是无需列混淆的参与。解密的过程则恰好相反，解密它先是进行最后一轮加密过程逆置，之后往前递推，直至第一轮加密逆置，如下图所示。
在这里插入图片描述
在了解完整体流程后下面就来利用“分而治之”思想，将难点进行拆分讲解。

轮密钥加

密钥参与运算也是从后往前，即加密的最后一轮的密钥参与第一轮的解密。为了方便编程我们可以使用全局变量来存储加解密密钥。这里我不过多介绍密钥的编排原理，大家如有疑问可参考我上一篇介绍AES加密的博客。

逆向行移位

AES加密算法中行移位
第一行不动，第二行循环左移一位，第三行循环左移两位，第四行循环左移三位。
在这里插入图片描述
也就是说原来4*4的矩阵中B[0][1] -> B[1][2]（如图中的B1 -> B5) 【注意，此矩阵读法为自上往下，自左往右读】。
为了方便理解和计算，我们可以把这一矩阵一维化成一维数组，即B[0] = B[0][0] = B0, B[1] = B[0][1] = B1, B[2] = B[0][2] = B2 … B[16] = B[3][3] = B15,
那么我们通过数学归纳法，根据移位后B[1] -> B[5], B[2] -> B[10], B[3]->B[15] 易得：B[i] = B[(4 * (i/4) + 5 * (i % 4))mod 16] 【i 为下标】【结合图片更便于理解】

上面是加密中行移位的算法，理解了这一点，解密的逆向行移位就变得简单了。
解密无非是将左移改为右移，即 第一行不动，第二行循环右移一位，第三行循环右移两位，第四行循环右移三位。如下图所示
在这里插入图片描述
变成
在这里插入图片描述
【注意，此矩阵读法为自上往下，自左往右读】。
为了方便理解和计算，我们可以把这一矩阵一维化成一维数组，即B[0] = B[0][0] = B0, B[1] = B[0][1] = B1, B[2] = B[0][2] = B2 … B[16] = B[3][3] = B15,
那么我们同样通过数学归纳法易得：B[i] = B[(4 * (i/4) + 13 * (i % 4))mod 16] 【i 为下标】【结合图片更便于理解】

逆向列混淆

AES加密算法中列混淆
使用伽罗瓦域运算的加法和乘法【伽罗瓦域详见AES介绍文章，运算均为模运算】计算出密文矩阵和列混淆固定矩阵的乘积然后获取结果矩阵。固定矩阵如下图所示：
在这里插入图片描述
为了方便计算，也可以将矩阵进行一维化之后进行模数运算。这里我采用了一种比较快速的模数运算方案：
/**
* 算法解释：
* 伽罗瓦域乘法默认为模数运算
* (110)2 * (11)2 => (x^2 + x) * (x + 1) => x^3 + x^2 + x^2 + x => x^3 + x => (1010)2
* 可以理解为先将(110)2左移一位后与(110)进行异或运算 得到 => (1010)2
*/`
while (i < 模数2长度) {
result ^=(numb << (模数2长度 - i)); //表示模数1向左移n位后的值存储于result中并于之前的值进行异或。详见算法解释。
i自加
}
其中numb为模数1的值。之后矩阵模数运算后的结果如果超过8位就要进行归化处理，即与不可约多项式m(x)=x8+x4+x3+x+1（0X11B）进行异或运算

在了解完AES算法的列混淆之后，AES解密的列混淆也就变得简单了，它只要修改固定矩阵就行，如下所示：
{“0E”,“0B”,“0D”,“09”},
{“09”,“0E”,“0B”,“0D”},
{“0D”,“09”,“0E”,“0B”},
{“0B”,“0D”,“09”,“0E”}

逆向字节代换

这个比较简单就是和加密一样，将8位密文前4位作为行数，后4位作为列数在逆置s盒中获值即可。

逆置s盒：

/**
	 * 逆向s-盒
	 */
	public static final String[][] REVERSE_SBOX = {
			{"52","09","6A","D5","30","36","A5","38","BF","40","A3","9E","81","F3","D7","FB"},
			{"7C","E3","39","82","9B","2F","FF","87","34","8E","43","44","C4","DE","E9","CB"},
			{"54","7B","94","32","A6","C2","23","3D","EE","4C","95","0B","42","FA","C3","4E"},
			{"08","2E","A1","66","28","D9","24","B2","76","5B","A2","49","6D","8B","D1","25"},
			{"72","F8","F6","64","86","68","98","16","D4","A4","5C","CC","5D","65","B6","92"},
			{"6C","70","48","50","FD","ED","B9","DA","5E","15","46","57","A7","8D","9D","84"},
			{"90","D8","AB","00","8C","BC","D3","0A","F7","E4","58","05","B8","B3","45","06"},
			{"D0","2C","1E","8F","CA","3F","0F","02","C1","AF","BD","03","01","13","8A","6b"},
			{"3A","91","11","41","4F","67","DC","EA","97","F2","CF","CE","F0","B4","E6","73"},
			{"96","AC","74","22","E7","AD","35","85","E2","F9","37","E8","1C","75","DF","6E"},
			{"47","F1","1A","71","1D","29","C5","89","6F","B7","62","0E","AA","18","BE","1B"},
			{"FC","56","3E","4B","C6","D2","79","20","9A","DB","C0","FE","78","CD","5A","F4"},
			{"1F","DD","A8","33","88","07","C7","31","B1","12","10","59","27","80","EC","5F"},
			{"60","51","7F","A9","19","B5","4A","0D","2D","E5","7A","9F","93","C9","9C","EF"},
			{"A0","E0","3B","4D","AE","2A","F5","B0","C8","EB","BB","3C","83","53","99","61"},
			{"17","2B","04","7E","BA","77","D6","26","E1","69","14","63","55","21","0C","7d"}
	};

设计思路

在掌握了解密流程及算法思想后，我们可以进行解密的设计。

  1. 首先通过一个decrypt方法实现密文分组。
  2. 通过baseDecrypt方法实现每组的解密。
  3. 通过decLoop方法实现迭代解密（将轮密钥加、列混淆、行位移、字节代换写在里面）。
  4. 输出明文。

下面为正式代码：
进制类转换详见文章：
程序猿成长之路之密码学番外篇-----字符串(ascii)转二进制https://blog.csdn.net/qq_31236027/article/details/128579451

package aes;

import java.io.IOException;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import common.EncodeUtil;
import common.IEncrytion;
import common.EncodeUtil.EncodeRadix;
import constant.AESConstant;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

/**
 * aes 加解密工具(无iv【偏移量】版)
 * @author zygswo
 *
 */
public class AesUtil implements IEncrytion{
	
	/**
	 * 密钥对象
	 */
	private KeyUtil subKeyObj = new KeyUtil().init(); 
	/**
	 * subkeys
	 */
	public List<String> subKeys = Collections.synchronizedList(new ArrayList<>());

	/**
	 * 分组加密(128位一组)
	 * @param text 明文
	 */
	@Override
	public String encrypt(String text) {
		StringBuilder sb = new StringBuilder();
		int textLen = text.length();
		//获取分组长度
		// DIV_LEN * CHAR_LEN = 128
		// 根据DIV_LEN进行分组，如CHAR_LEN=16位，那么就每8个字符一组
		int divLen = textLen % AESConstant.DIV_LEN == 0 ? textLen / AESConstant.DIV_LEN : (textLen / AESConstant.DIV_LEN + 1);
		//份组加密处理
		for (int i = 0; i < divLen; i++) {
			int startIndex = i * AESConstant.DIV_LEN;
			int endIndex = (startIndex + AESConstant.DIV_LEN) >= textLen ? textLen : (startIndex + AESConstant.DIV_LEN);
			String substr = text.substring(startIndex, endIndex);
			//尾部填充
			while(substr.length() < AESConstant.DIV_LEN) {
				substr += " ";
			}
			sb.append(baseEncrypt(substr));
		}
		return new BASE64Encoder().encode(sb.toString().toLowerCase().trim().getBytes());
	}
	
	/**
	 * 加密（每个密文都是128位）
	 * @param text 需要加密的文本
	 * @return
	 */
	private String baseEncrypt(String text) {
		//获取11组密钥
		if (subKeys == null || subKeys.isEmpty()) {
			subKeys = subKeyObj.generateKeys();
		}
		if (subKeys.size() != 11) {
			throw new IllegalArgumentException("密钥长度有误");
		}
		//转成16进制
		return EncodeUtil.binaryToHexStr(
				encloops(text, subKeys)
		).trim();
	}

	/**
	 * 10轮循环加密
	 * @param step1Result 初始置换后的结果
	 * @param subKeys 16组子密钥
	 * @return 循环加密结果
	 */
	private String encloops(String text, List<String> subKeys) {
		//转二进制
		String binTempStr = EncodeUtil.strtoBinary(text, AESConstant.CHAR_LEN);
		//1.初始化密钥加法层
//		System.out.println("binTempStr0 = " + binTempStr);
		binTempStr = xor(binTempStr, subKeys.get(0));
		//第一轮至第十轮
		for(int level = 1; level <= 10; level++) {
//			System.out.println("binTempStr1 = " + binTempStr);
			//2.字节代换层
			String[] temp = replace(binTempStr, AESConstant.SBOX);
			//3.扩撒层
			//3.1 行位移
			temp = shiftRow(temp);
			//3.2列混淆
			if (level < 10) {
				binTempStr = mixColumn(temp);
//				System.out.println("binTempStr3 = " + binTempStr);
			} else {
				binTempStr = "";
				for(String str:temp) {
					binTempStr += str;
				}
			}
//			System.out.println("binTempStr4 = " + binTempStr);
			//4.密钥加法层
			binTempStr = xor(binTempStr, subKeys.get(level));
//			System.out.println("binTempStr5 = " + binTempStr);
		}
//		System.out.println("binTempStr6 = " + binTempStr);
		return binTempStr;
	}
	
	/**
	 * 列混淆 【重点】
	 * @param _8bitArr 8位字符串数组 (2进制)
	 * @return 返回2进制字符串，方便后续的密钥加法
	 */
	private String mixColumn(String[] _8bitArr) {
		StringBuilder sb = new StringBuilder();
		for(int i = 0; i < _8bitArr.length; i+=4) {
			/**
			 * 注意：在列混淆中，每一位代表着x的指数，如(2)16=>(10)2 => x, (3)16=>(11)2 => x+1、 (25)16 => (0010 0101)2【采用十六进制】
			 * 使用矩阵乘积后的结果作为每一字节位上的结果，矩阵相乘用到了异或和或运算，异或模拟GF(2^8)域相乘，或模拟不同位相加
			 * 
			 * 如
			 * (01)16*(25)16=>		 x^5 	   + x^2 	 + 1
			 * (01)16*(25)16=> 		 x^5 	   + x^2	 + 1
			 * (02)16*(25)16=> x^6 		 + x^3 		 + x
			 * (03)16*(25)16=> x^6 + x^5 + x^3 + x^2 + x + 1
			 * +____________________________________________
			 * 				   		 x^5 	   + x^2 	 + 1
			 * 
			 * 注意如果度》8 要进行模约简
			 * 模约简方式，与不可约多项式m(x)=x8+x4+x3+x+1（十六进制表示为'11B'）进行相加运算（异或）
			 */
			for (int j = 0; j < AESConstant.MIX_COLUMN_BOX.length; j++) {
				int res = 0;
				int rowNb = j;
				for (int m = 0; m < AESConstant.MIX_COLUMN_BOX[0].length; m++) {
					res ^= Integer.parseInt(
						EncodeUtil.binaryToDec(
								multiply(_8bitArr[i+j], AESConstant.MIX_COLUMN_BOX[rowNb][m])
						)	
					);
				}
				//超过了8位就和不可约多项式进行异或
				if (res >= 0x100) {
					res ^= 0x11B;  //11B => 不可约多项式m(x)=x8+x4+x3+x+1
				}
				//转二进制
				String finalRes = EncodeUtil.toBinary(res + "",EncodeRadix.DEC);
				//扩充
				while(finalRes.length() < 8) {
					finalRes = "0" + finalRes;
				}
				sb.append(finalRes);
			}
		}
		return sb.toString();
	}

	/**
	 * 二进制相乘
	 * @param source - 要处理的数(2进制)
	 * @param columnBox - 列混淆box(16进制)
	 * @return 相乘后结果(2进制)
	 */
	private String multiply(String source, String columnBox) {
		//将乘数十六进制转为二进制
		String temp = EncodeUtil.toBinary(columnBox, EncodeRadix.HEX);
		int result = 0;
		for (int i = 0; i < temp.length(); i++) {
			//如果开头位为0就跳过
			if (temp.charAt(i) == '0') {
				continue;
			}
			//否则就进行计算
			//转10进制
			int numb = Integer.parseInt(
				EncodeUtil.binaryToDec(source)
			);
			/**
			 * 算法解释：
			 * 伽罗瓦域乘法默认为模数运算
			 * (110)2 * (11)2 => (x^2 + x) * (x + 1) => x^3 + x^2 + x^2  + x => x^3 + x => (1010)2 
			 * 可以理解为先将(110)2左移一位后与(110)进行异或运算 得到 => (1010)2
			 */
			result ^=(numb << (temp.length()-1-i));
			/**
			 * 注意如果度》8 要进行模约简
			 * 模约简方式，与不可约多项式m(x)=x8+x4+x3+x+1（十六进制表示为'11B'）进行相加运算（异或）
			 */
			if (result >= 0x100) {
				result ^= 0x11B;  //11B => 不可约多项式m(x)=x8+x4+x3+x+1
			}
		}
		return EncodeUtil.toBinary(result+"", EncodeRadix.DEC);
	}

	/**
	 * 行位移 
	 * @param _8bitArr 8位字符串数组【16进制】
	 * @return 按行输出(2进制)
	 */
	private String[] shiftRow(String[] _8bitArr) {
		String[] res = new String[_8bitArr.length];
		for(int i = 0; i < _8bitArr.length / 4;i++) {
			for (int j = 0; j < 4; j++) {
				int index = i*4 + j%4;
				//经过行位移后， 原来B0B1B2B3 -> B0B5B10B15, B4B5B6B7 -> B4B9B14B3 。。。 于是找到了这个规律
				res[index] = EncodeUtil.toBinary(
						_8bitArr[(4*i + 5*j)% _8bitArr.length], EncodeRadix.HEX
				); 
				//扩充
				while(res[index].length() < 8) {
					res[index]= "0" + res[index];
				}
			}
		}
		return res;
	}

	/**
	 * 字节代换层
	 * @param binStr 二进制流
	 * @param _128bitsStr 128位字符串
	 * @return 16进制数据
	 */
	private String[] replace(String _128bitsStr, String[][] sbox) {
		String[] result = new String[16];
		//分组计算
		for (int i = 0; i <result.length; i++) {
			String rowNb = EncodeUtil.binaryToDec(_128bitsStr.substring(i * 8, i * 8 + 4));
			String colNb = EncodeUtil.binaryToDec(_128bitsStr.substring(i * 8 + 4, i * 8 + 8));
			result[i] = sbox[Integer.parseInt(rowNb)][Integer.parseInt(colNb)];
		}
		return result;
	}

	/**
	 * 异或运算
	 * @param text1 text1 
	 * @param text2 text2
	 * @return
	 */
	private String xor(String text1, String text2) {
		if (text1 == null || text2 == null || text1.length() != text2.length()) {
			throw new IllegalArgumentException("异或运算失败");
		}
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < text1.length();i++) {
			char ch1 = text1.charAt(i);
			char ch2 = text2.charAt(i);
			sb.append((ch1) ^ (ch2));
		}
		return sb.toString().trim();
	}


	/**
	 * 分组解密
	 * @param encrytedText 密文
	 */
	@Override
	public String decrypt(String encrytedText) {
		try {
			//base64解码
			byte[] bytes = new BASE64Decoder().decodeBuffer(encrytedText);
			String str = new String(bytes,Charset.forName("UTF8"));
			int textLen = str.length();
			StringBuilder sb = new StringBuilder();
			int divLen = textLen < 32 ? 1 : (int)(Math.ceil(textLen/(4*8*1.0))); //因为加密后会自动填充所以长度必为字符长度的倍数(HEX 4位)
			//分组解密
			for (int i = 0; i< divLen; i++) {
				int startIndex = i * (4*8);
				int endIndex = (startIndex + (4*8));
				String temp = str.substring(startIndex, endIndex);
				sb.append(baseDecrypt(temp));
			}
			return sb.toString();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return null;
	}
	
	/**
	 * 解密
	 * @param encHexStr 加密16进制文本
	 * @return
	 */
	private String baseDecrypt(String encHexStr) {
		//1. 获取密钥
		if (subKeys == null || subKeys.isEmpty()) {
			throw new IllegalArgumentException("密钥获取失败");
		}
		if (subKeys.size() != 11) {
			throw new IllegalArgumentException("密钥长度有误");
		}
		//2. 讲16进制转二进制并迭代解密输出结果
		return EncodeUtil.binaryToStr(
				decLoop(encHexStr,subKeys),
				AESConstant.CHAR_LEN
		);
	}
	
	/**
	 * 迭代递归解密
	 * @param encHexStr 加密16进制文本
	 * @param subKeys 子密钥
	 * @return 解密结果
	 */
	private String decLoop(String encHexStr, List<String> subKeys) {
		//1.16进制转二进制
		String binTempStr = EncodeUtil.toBinary(
				encHexStr, EncodeRadix.HEX);
		//2.逆向迭代解密
		for (int level=10;level > 0;level--) {
			//密钥加法层
//			System.out.println("reverseReplace binTempStr1 = " + binTempStr);
			binTempStr = xor(binTempStr, subKeys.get(level)); //没问题
//			System.out.println("reverseReplace binTempStr2 = " + binTempStr);
			String[] temp = new String[AESConstant.ARR_LEN];
			//转成字符串数组
			int len = 8; //字节数组
			for (int i = 0; i < AESConstant.ARR_LEN; i++) {
				temp[i] = binTempStr.substring(i* len, (i+1)*len);
			}
			//逆向列混淆层
			if (level < 10) {
				binTempStr = reverseMixColumn(temp);
//				System.out.println("reverseReplace binTempStr3 = " + binTempStr);
				for (int i = 0; i < AESConstant.ARR_LEN; i++) {
					temp[i] = binTempStr.substring(i* len, (i+1)*len);
				}
			}
			//逆向行位移层
			binTempStr = reverseShiftRow(temp);
//			System.out.println("reverseReplace binTempStr4 = " + binTempStr);
			//逆向字节代换
			binTempStr = reverseReplace(binTempStr, AESConstant.REVERSE_SBOX);
//			System.out.println("reverseReplace binTempStr5 = " + binTempStr);
		}
		//密钥加法层
//		System.out.println("reverseReplace binTempStr6 = " + binTempStr);
		binTempStr = xor(binTempStr, subKeys.get(0));
//		System.out.println("reverseReplace binTempStr7 = " + binTempStr);
		return binTempStr;
	}
	
	/**
	 * 逆向字节代换层
	 * @param binStr 二进制流
	 * @param _128bitsStr 128位字符串
	 * @return 2进制进制数据
	 */
	private String reverseReplace(String _128bitsStr, String[][] sbox) {
		StringBuilder result = new StringBuilder();
		//分组计算
		for (int i = 0; i < AESConstant.ARR_LEN; i++) {
			String rowNb = EncodeUtil.binaryToDec(_128bitsStr.substring(i * 8, i * 8 + 4));
			String colNb = EncodeUtil.binaryToDec(_128bitsStr.substring(i * 8 + 4, i * 8 + 8));
			result.append(EncodeUtil.toBinary(sbox[Integer.parseInt(rowNb)][Integer.parseInt(colNb)], EncodeRadix.HEX));
		}
		return result.toString();
	}
	
	/**
	 * 逆向行位移 
	 * @param _8bitArr 字符串数组(16位)【2进制】
	 * @return 按行输出(2进制)
	 */
	private String reverseShiftRow(String[] _8bitArr) {
		StringBuilder res = new StringBuilder();
		for(int i = 0; i < _8bitArr.length / 4;i++) {
			for (int j = 0; j < 4; j++) {
				//经过逆向行位移后， 原来B0B1B2B3 -> B0B13B10B7, B4B5B6B7 -> B4B1B14B11 。。。 于是找到了这个规律
				String temp =_8bitArr[(4*i + 13*j)% _8bitArr.length];
				//扩充
				while(temp.length() < 8) {
					temp = "0" + temp;
				}
				res.append(temp);
			}
		}
		return res.toString();
	}
	
	/**
	 * 列混淆 【重点】
	 * @param _8bitArr 8位字符串数组 (2进制)
	 * @return 返回2进制字符串，方便后续的密钥加法
	 */
	private String reverseMixColumn(String[] _8bitArr) {
		StringBuilder sb = new StringBuilder();
		for(int i = 0; i < _8bitArr.length; i+=4) {
			/**
			 * 注意：在列混淆中，每一位代表着x的指数，如(2)16=>(10)2 => x, (3)16=>(11)2 => x+1、 (25)16 => (0010 0101)2【采用十六进制】
			 * 使用矩阵乘积后的结果作为每一字节位上的结果，矩阵相乘用到了异或和或运算，异或模拟GF(2^8)域相乘，或模拟不同位相加
			 * 
			 * 如
			 * (01)16*(25)16=>		 x^5 	   + x^2 	 + 1
			 * (01)16*(25)16=> 		 x^5 	   + x^2	 + 1
			 * (02)16*(25)16=> x^6 		 + x^3 		 + x
			 * (03)16*(25)16=> x^6 + x^5 + x^3 + x^2 + x + 1
			 * +____________________________________________
			 * 				   		 x^5 	   + x^2 	 + 1
			 * 
			 * 注意如果度》8 要进行模约简
			 * 模约简方式，与不可约多项式m(x)=x8+x4+x3+x+1（十六进制表示为'11B'）进行相加运算（异或）
			 */
			for (int j = 0; j < AESConstant.REVERSE_MIX_COLUMN_BOX.length; j++) {
				int res = 0;
				int rowNb = j;
				int initLen = _8bitArr[i+j].length();
				for (int m = 0; m < AESConstant.REVERSE_MIX_COLUMN_BOX[0].length; m++) {
					res ^= Integer.parseInt(
						EncodeUtil.binaryToDec(
								multiply(_8bitArr[i+j], AESConstant.REVERSE_MIX_COLUMN_BOX[rowNb][m])
						)	
					);
				}
				//超过了8位就和不可约多项式进行异或
				if (res >= 0x100) {
					res ^= 0x11B;  //11B => 不可约多项式m(x)=x8+x4+x3+x+1
				}
				//转二进制
				String finalRes = EncodeUtil.toBinary(res + "",EncodeRadix.DEC);
				//扩充
				while(finalRes.length() < initLen) {
					finalRes = "0" + finalRes;
				}
				sb.append(finalRes);
			}
		}
		return sb.toString();
	}

	public static void main(String[] args) {
		AesUtil util = new AesUtil();
		String encrytedStr = util.encrypt("{\"code\":200,\"message\":\"成功！\",\"data\":{\"id\":\"2103813902831\",\"name\":\"章鱼哥是我哦\"}}");
		System.out.println("encrytedStr = " + encrytedStr);
		System.out.println("result= " + util.decrypt(encrytedStr));
	}
}

运行结果
在这里插入图片描述
—————————————创作不易，多多支持一下作者，感谢————————

zygswo
关注
  • 2
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
建模生必学之启发式优化智能算法-蜣螂优化
02-20
蜣螂优化模型（DBO）是近年来备受关注的一种群体智能优化算法，其灵感来源于蜣螂的独特行为模式，如滚球、跳舞、觅食、偷窃和繁殖等。DBO算法在解决复杂优化问题时展现出了优异的性能，因此在多个领域得到了广泛应用。本文档将详细描述DBO算法的相关资源，包括数学模型、代码实现和实验数据等。 DBO算法的数学模型主要包括以下几个部分： 蜣螂个体表示：每个蜣螂个体由其位置和速度两个向量表示，分别对应于解空间中的一个点和该点的运动方向。 蜣螂行为建模：根据蜣螂的自然行为，将其抽象为滚球、跳舞、觅食、偷窃和繁殖等行为，并建立相应的数学模型。这些模型描述了蜣螂个体在不同行为下的运动规律和相互作用机制。 适应度函数：适应度函数是评价蜣螂个体优劣的重要指标，通常与问题的目标函数密切相关。DBO算法通过不断优化适应度函数来寻找全局最优解。 初始化：创建蜣螂群体，随机生成每个个体的位置和速度，并计算初始适应度值。 行为模拟：根据蜣螂的自然行为，模拟每个个体的运动轨迹和相互作用过程。这包括滚球、跳舞、觅食、偷窃和繁殖等行为的实现。 更新位置和速度：根据模拟结果，更新每个蜣螂个体的位置和速度，以优化其适应度值。
AES128加解密流程详细介绍
John Lee 的专栏
08-09 1万+
AES128加解密流程详细介绍 公司想要对嵌入式设备里的文本进行加密，怎么办呢，只能用AES128试试，经过一上午的了解，整理了下流程。 参考文章： AES加密 https://zhuanlan.zhihu.com/p/125633081 https://www.sohu.com/a/278722262_100245441 AES加密每次只能加密16字节，我们先要学会如何对16字节数据进行加密，学会之后再学习大文件加密就简单多了。 下面介绍如何对16字节数据进行加密。 AES加密开始前要准备的东西 1
AES加解密算法详解
yxtxiaotian的专栏
08-01 2万+
0 AES简介 　　美国国家标准技术研究所在2001年发布了高级加密标准（AES）。AES是一个对称分组密码算法，旨在取代DES成为广泛使用的标准。 　　根据使用的密码长度，AES最常见的有3种方案，用以适应不同的场景要求，分别是AES-128、AES-192和AES-256。 1 算法流程 　　AES加解密的流程图如下(以128位密钥为例)：    
AES加密解密算法
这个博主不懒，但Ta什么也没写~（私信互关24小时必回）
03-27 1504
AES属于分组加密，算法明文长度固定为128位（单位是比特bit，1bit就是1位，128位等于16字节）而密钥长度可以是128、192、256位当密钥为128位时，需要循环10轮完成加密，在此基础上，密钥每增加64位，就要多循环2轮（即192位密钥循环12轮，256位密钥循环14轮）
AES加解密基本原理
一只Coding猪
10-09 7645
1. 概述 在网络通信中，经常会用到加解密技术，其中AES加解密算法是比较广泛的应用于大块数据的对称加解密算法，本文主要介绍AES算法的一些基本原理，目标是为了建立对AES算法的概念认知，这里不打算对算法的数学原理进行阐述。 2. 术语 名词 释义 AES Advanced Encryption Standard，高级加密标准，一种对称加密算法。最早由美国NIST发起，广泛征集替代DES的加密算法，最终Rijndael算法族胜出，而AES则是源于该算法的变体标准。目前被广泛应用于互联网。
AES加解密模式
liyuan0714的专栏
02-23 1万+
要想学习AES，首先要清楚三个基本的概念：密钥、填充、模式。 1、密钥 密钥是AES算法实现加密和解密的根本。对称加密算法之所以对称，是因为这类算法对明文的加密和解密需要使用同一个密钥。 AES支持三种长度的密钥： 128位，192位，256位 平时大家所说的AES128，AES192，AES256，实际上就是指AES算法对不同长度密钥的使用。 三种密钥的区别： 从安全性来看，AES256安全性最高。从性能看，AES128性能最高。本质原因是它们的加密处理轮数不同。 2、填充 要想了解填..
AES加密算法C语言代码实现
09-26
配套文章解析：https://blog.csdn.net/u013469753/article/details/108322140 AES加密算法，AES的全称是Advanced Encryption Standard，意思是高级加密标准。它的出现主要是为了取代DES加密算法的，因为我们都知道DES算法的密钥长度是56Bit，因此算法的理论安全强度是2的56次方。 AES密码与分组密码Rijndael基本上完全一致，Rijndael分组大小和密钥大小都可以为128位、192位和256位。然而AES只要求分组大小为128位，因此只有分组长度为128Bit的Rijndael才称为AES算法。
AES加密解密
u013021184的博客
08-19 5585
AES加密解密
AES加密算法原理的详细介绍与实现
热门推荐
qq_28205153的博客
02-19 76万+
AES简介高级加密标准(AES,Advanced Encryption Standard)为最常见的对称加密算法(微信小程序加密传输就是用这个加密算法的)。对称加密算法也就是加密和解密用相同的密钥，具体的加密流程如下图： 下面简单介绍下各个部分的作用与意义： 明文P 没有经过加密的数据。密钥K 用来加密明文的密码，在对称加密算法中，加密与解密的密钥是相同的。密钥为接收方与发送方协商产生
【密码学】AES加解密
小原的博客
06-07 5926
就
AES加密/解密
arnodev
10-20 1万+
AES加密/解密算法是一种可逆的对称加密算法，这类算法在加密和解密时使用相同的密钥，或是使用两个可以简单地相互推算的密钥，一般用于服务端对服务端之间对数据进行加密/解密。它是一种为了替代原先DES、3DES而建立的高级加密标准（Advanced Encryption Standard）。
密码学算法的C#工程源码_DES_AES_Present_Euclid_Primality_C#工程源码
05-15
DES全称为Data Encryption Standard，即数据加密标准，是一种使用密钥加密的块算法； 高级加密标准（英语：Advanced Encryption Standard，缩写：AES），在密码学中又称Rijndael加密法，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES； PRESENT算法，该算法具有出色的硬件实现性能和简洁的轮函数设计； 扩展欧几里得算法：A * X MOD N == 1 则称X为A关于模N的乘法逆元。 ； 素性检测算法：一个数是素数（也叫质数），当且仅当它的约数只有两个——1和它本身。规定这两个约数不能相同，因此1不是素数。对素数的研究属于数论范畴； 素性检测算法是基于费马小定理（`format`），二次探测定理（`x*x%p==1` ，若P为素数，则x的解只能是`x=1`或者`x=p-1`）加上迭代乘法判断的Miller算法共同构成的；
matlab实现的改进的粒子群优化算法完整程序代码
03-23
里面包含了一套完整的实现粒子群优化算法的程序（一个主程序ｍ文件和两个函数ｍ文件），实现了利用改进的粒子群优化算法对参数进行优化，得到更优的参数，并且构造了模拟的峰例子，来例化程序的可行性
Java程序猿技术路线图
08-29
Java程序猿技术路线图：让你从一个菜鸟到大神的指导线路！
JAVA实现AES加密和解密
08-15
1.采用秘钥为16位长度的加密字符 2.加密算法为AES/ECB/PKCS5Padding 3.解决加解密乱码问题 4.完整的线上可运行代码及各方法及步骤注释 5.无任何插件，java环境直接运行
密码学 | 承诺：绑定性 + 隐藏性
狂放不羁霸的博客
04-20 1245
绑定性和隐藏性的定义和安全性
网络安全之密码学技术
最新发布
缘友一世的博客
04-29 802
在DES算法中，明文按64位进行分组（块），密钥长度也是64位，（事实上只有56位参与DES运算，第8、16、24、32、40、48、56、64位是校验位， 使DES的每个密钥都有奇数个1），分组后的每64位明文组（块）分别与56位密钥进行多轮置换（按位替代/交换），最后生成64位的密文组（块）。RSA密钥是（公钥+模值）、（私钥+模值）成组分发的，单独一个公钥或私钥是没有用处，所以所谓的“密钥”其实是它们两者中的一个。IDEA是作为迭代的分组密码实现的，使用128位的密钥和8个循环。
ECC（椭圆曲线密码学）和DH（迪菲-赫尔曼密钥交换）
ZJQ的博客
04-23 198
需要注意的是，由于椭圆曲线上的运算具有特殊的性质，使得从公钥P推算出私钥k是非常困难的。总的来说，ECC和DH算法在密码学中各自发挥着重要作用，而它们的结合使用则提供了更高的安全性和更强的密钥管理能力。，它基于椭圆曲线数学上的难题，特别是椭圆曲线上的有理点构成的Abel加法群上椭圆离散对数的计算困难性。需要注意的是，密码学是一个复杂且专业的领域，对于涉及密码学的应用，建议咨询专业的密码学专家或查阅相关的专业文献，以确保应用的安全性和有效性。（在椭圆曲线加密的上下文中，这实际上是椭圆曲线上的点乘法）。
真实世界的密码学（一）
龙哥盟
04-21 1335
当你拿起这本书时，你可能会想，为什么又一本关于密码学的书？甚至，为什么我要读这本书？要回答这个问题，你必须了解它是什么时候开始的。密码学的一个基本概念是对称加密。它在本书中的大多数密码算法中使用，因此非常重要。我通过我们的第一个协议在这里介绍这个新概念。让我们想象一下，女王爱丽丝需要给住在几个城堡之外的鲍勃勋爵发送一封信。她请求她忠诚的信使骑着他可靠的坐骑，冒着前方危险的土地，为了将珍贵的消息送到鲍勃勋爵手中。然而，她心存疑虑；
CShap 恺撒加解密算法 源代码
04-01
以下是C#实现的恺撒加解密算法源代码： ```csharp public static string CaesarEncrypt(string plainText, int shift) { string cipherText = ""; foreach (char c in plainText) { if (char.IsLetter(c)) { char shifted = (char)(((c + shift) - 'A') % 26 + 'A'); cipherText += shifted; } else { cipherText += c; } } return cipherText; } public static string CaesarDecrypt(string cipherText, int shift) { string plainText = ""; foreach (char c in cipherText) { if (char.IsLetter(c)) { char shifted = (char)(((c - shift) - 'A' + 26) % 26 + 'A'); plainText += shifted; } else { plainText += c; } } return plainText; } ``` 在上面的代码中，`CaesarEncrypt()`方法将给定的纯文本和移位量作为输入参数，并返回加密后的密文。`CaesarDecrypt()`方法将给定的密文和移位量作为输入参数，并返回解密后的纯文本。 这些方法使用了foreach循环遍历输入字符串中的每个字符。对于每个字母字符，它们使用移位算法来转换字符，并将其添加到加密或解密输出字符串中。对于非字母字符，它们将其直接添加到输出字符串中。 在加密时，对于每个字母字符，我们将其转换为其在字母表中的位置（A = 0，B = 1，...，Z = 25）。然后，我们将移位量添加到这个位置，并将结果取模26，以确保它仍然在字母表中。最后，我们将结果转换回字母，并将其添加到输出字符串中。 在解密时，我们使用相同的移位算法，但是我们从字母位置中减去移位量，并将结果取模26。然后，我们将结果转换回字母，并将其添加到输出字符串中。 需要注意的是，这种加密方法是非常弱的，因为它只是简单地移动字母字符。这使得它容易被破解。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

zygswo

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值