AES，线程，线程池，锁

梅有卷呀

已于 2023-07-20 17:41:20 修改

阅读量106

点赞数

分类专栏： java笔记文章标签： java 开发语言

于 2023-07-19 20:06:02 首次发布

本文链接：https://blog.csdn.net/weixin_51704612/article/details/131794083

版权

java笔记专栏收录该内容

4 篇文章 0 订阅

订阅专栏

🍓

一.AES算法的CBC和ECB两种工作模式

AES是一种对称加密算法（加密和解密是同一把key）

应用场景：加密过程：使用密码对压缩包进行加密

解密过程：加密后的压缩包和原始密码进行解密

AES算法，传统的DES太过于简短，很容易暴力破解。所以有了AES算法。

AES每个分组数据的长度为128位16个字节,密钥长度可以是128位16个字节、192位或256位

本文主要介绍AES有两种模式：CBC和ECB

AES-128-ECB为指令长度。也是分组加密算法。对于长的明文，需要按照算法约定的块大小进行分组，AES每一组为16B，不同组之间使用相同的密钥进行计算的话，会产生一些安全问题，所以为了将分组密码应用到不同的实际应用。

1.1ECB实现

package ciper;

import java.security.GeneralSecurityException;
import java.util.Base64;

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

// AES + ECB
public class Work01 {
	public static void main(String[] args) throws GeneralSecurityException {
		// 原文:
		String message = "天生我材必有用飞流直下三千尺";
		System.out.println("Message(原始信息): " + message);

		// 128位密钥 = 16 bytes Key:
		byte[] key = "1234567890abcdef".getBytes();

		// 加密:
		byte[] data = message.getBytes();
		byte[] encrypted = encrypt(key, data);
		System.out.println("Encrypted(加密内容): " + Base64.getEncoder().encodeToString(encrypted));

		// 解密:
    byte[] decrypted = decrypt(key, encrypted);
	System.out.println("Decrypted(解密内容): " + new String(decrypted));
	}

	// 加密:
	public static byte[] encrypt(byte[] key, byte[] input) throws GeneralSecurityException {
		// 创建密码对象，需要传入算法/工作模式/填充模式
		Cipher ciper=Cipher.getInstance("AES/ECS/PKCS5Padding");
		// 根据key的字节内容，"恢复"秘钥对象
		SecretKey sk=new SecretKeySpec(key,"AES");
		// 初始化秘钥:设置加密模式ENCRYPT_
		ciper.init(Cipher.ENCRYPT_MODE, sk);
		// 根据原始内容(字节),进行加密
		return ciper.doFinal(input);
	}

	// 解密:
	public static byte[] decrypt(byte[] key, byte[] input) throws GeneralSecurityException {
		// 创建密码对象，需要传入算法/工作模式/填充模式
		Cipher ciper =Cipher.getInstance("AES/ECS/PAS5padding");
		// 根据key的字节内容，"恢复"秘钥对象
		SecretKey keySpec =new SecretKeySpec(key,"AES");
		// 初始化秘钥:设置解密模式DECRYPT_MODE
		ciper.init(Cipher.DECRYPT_MODE, keySpec);
		// 根据原始内容(字节),进行解密
		return ciper.doFinal(input);
	}
}

ECB模式很简单可能从性能角度讲非常占优，因为分组之间没有关联，可以独立并行计算。但从安全角度来看这种直接将密文分组进行拼接的方式，很可能会被攻击者猜解出明文特征或替换丢弃部分密文块达到明文的替换与截取效果。

AES-128-CBC模式就提出将明文分组先于一个随机值分组IV进行异或且本组的密文又与下一组的明文进行异或的方式，这种方式增加了密文的随机性。

算法原理：第一个明文分组在加密前明文a需要和一个初始分组IV进行异或运算即 a^IV，然后再用密钥K进行标准的AES加密

1.2CBC实现

package ciper;

import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;

public class work02 {
	public static void main(String[] args) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException {
		byte[] content= "奈何明月赵高去".getBytes();
		byte[]  key="2334344324324343".getBytes();
		String x=entry(key,content);
		System.out.println(x);
		
		
	}
	
	
	public static String entry(byte[] key,byte[] content) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException
	{
		Cipher cipher=Cipher.getInstance("CBC");
		
		SecureRandom sr=new SecureRandom();
		byte[] bytes=sr.generateSeed(16);
		IvParameterSpec iv=new IvParameterSpec(bytes);
		
		SecretKey key1=new SecretKeySpec(key,"CBC");
		cipher.init(Cipher.ENCRYPT_MODE, key1,iv);
		cipher.doFinal(content);
		return join(iv,content);
		
	}
	
	public static String join(IvParameterSpec iv,byte[] content)
	{
		byte[] iv1=iv.getIV();
//		byte[] newByte= new byte[iv1.length+content.length];
		
		StringBuilder sx=new StringBuilder();
		for(byte x:iv1)
		{
			sx.append(x);
		}
		for(byte x:content)
		{
			sx.append(x);
		}
		return sx.toString();
		
	}

}

二,线程的实现方式

四种实现方式：继承Thread类，实现Runnable,Callable接口，线程池实现方式

package Thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

public class test {
	public static void main(String[] args) {
		Thread t1=new Thread() {
			public void run()
			{
				System.out.println("线程1");
			}
		};
		Thread t2=new Thread(new Runnable() {
			public void run()
			{
				System.out.println("线程2");
			}
		}) ;
		Thread t3=new Thread(new FutureTask<Integer>(new Callable() {
			
			public Integer call()
			{
				System.out.println("线程3");
				return 3;
				
				
			}
		}));
		
		ExecutorService executorservice =Executors.newFixedThreadPool(1);
		executorservice.execute(new Thread() {
			public void run() {
				System.out.println("线程4");
			}
		});
		t1.start();
		t2.start();
		t3.start();
		
		executorservice.shutdown();
		
	}
	

}