Java使用ExecutorService线程池通过Socket传输AES加密，并在客户端用ServerSocket解密

最新推荐文章于 2023-05-30 16:31:57 发布
最新推荐文章于 2023-05-30 16:31:57 发布
阅读量1.7k 收藏 3
点赞数
分类专栏： Java 文章标签： socket 加密 java 多线程 解密 string
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/del1214/article/details/6641631
版权

发送端

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.net.Socket;
import java.net.UnknownHostException;
import java.security.InvalidKeyException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;


public class SocketExample {
	public void ThreadPoolService(int threadNumber, List<MyEntity> list,int commandType)
			throws NoSuchAlgorithmException, NoSuchPaddingException,
 InvalidKeyException,
			IllegalBlockSizeException, BadPaddingException,
			UnsupportedEncodingException {
		ExecutorService es = Executors.newFixedThreadPool(threadNumber);
		Iterator<MyEntity> iterator = list.iterator();
		while (iterator.hasNext()) {
			// 获取密匙生成器
			KeyGenerator kg = KeyGenerator.getInstance("AES");

			//获得一个key安全种子对象
			SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
			secureRandom.setSeed(("1234567890123456").getBytes());
			// 初始化
			// DES算法必须是56位
			// DESede算法可以是112位或168位
			// AES算法可以是128、192、256位
			kg.init(128,secureRandom);
			SecretKey key = kg.generateKey();
			Cipher cipher = Cipher.getInstance("AES"); // 创建密码器
			cipher.init(Cipher.ENCRYPT_MODE, key); // 初始化
			MyEntity me = iterator.next();
			byte[] ctext = cipher.doFinal(me.getData().getBytes()); // 加密
			String md5 = getMD5(me.getData());
			es.submit(new MyThread(commandType,me.getIp(), me.getPort(), ctext,md5));
		}
	}
	
	/**
	 * 获得md5值得方法，网络流传产品
	 * */
	public String getMD5(String source) {
		String dest = null;
		try {
			MessageDigest md5 = MessageDigest.getInstance("MD5");
		    char[] charArray = source.toCharArray();
		    byte[] byteArray = new byte[charArray.length];
		    for (int i = 0; i < charArray.length; i++)
		    byteArray[i] = (byte) charArray[i];
		    byte[] md5Bytes = md5.digest(byteArray);
		    StringBuffer hexValue = new StringBuffer();
		    for (int i = 0; i < md5Bytes.length; i++) {
		    	int val = ((int) md5Bytes[i]) & 0xff;
		    	if (val < 16)
		    		hexValue.append("0");
		    	hexValue.append(Integer.toHexString(val));
		    }
		    dest = hexValue.toString();
		} catch (NoSuchAlgorithmException e) {
		    e.printStackTrace();
		}
		return dest;
	}
	
	public static void main(String[] args) throws UnsupportedEncodingException, InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException {
		List<MyEntity> list = new ArrayList<MyEntity>();
		list.add(new MyEntity(1, "127.0.0.1", 8821,"1234567890123456","这是一个加密解密socket通信和多线程线程池的实验"));
		list.add(new MyEntity(1, "127.0.0.1", 8821,"1234567890123456","这是一个加密解密socket通信和多线程线程池的实验"));
		list.add(new MyEntity(1, "127.0.0.1", 8821,"1234567890123456","这是一个加密解密socket通信和多线程线程池的实验"));
		list.add(new MyEntity(1, "127.0.0.1", 8821,"1234567890123456","这是一个加密解密socket通信和多线程线程池的实验"));
		list.add(new MyEntity(1, "127.0.0.1", 8821,"1234567890123456","这是一个加密解密socket通信和多线程线程池的实验"));
		list.add(new MyEntity(1, "127.0.0.1", 8821,"1234567890123456","这是一个加密解密socket通信和多线程线程池的实验"));
		list.add(new MyEntity(1, "127.0.0.1", 8821,"1234567890123456","这是一个加密解密socket通信和多线程线程池的实验"));
		list.add(new MyEntity(1, "127.0.0.1", 8821,"1234567890123456","这是一个加密解密socket通信和多线程线程池的实验"));
		list.add(new MyEntity(1, "127.0.0.1", 8821,"1234567890123456","这是一个加密解密socket通信和多线程线程池的实验"));
		list.add(new MyEntity(1, "127.0.0.1", 8821,"1234567890123456","这是一个加密解密socket通信和多线程线程池的实验"));
		list.add(new MyEntity(1, "127.0.0.1", 8821,"1234567890123456","这是一个加密解密socket通信和多线程线程池的实验"));
		list.add(new MyEntity(1, "127.0.0.1", 8821,"1234567890123456","这是一个加密解密socket通信和多线程线程池的实验"));
		System.out.println("开始");
		SocketExample c = new SocketExample();
		c.ThreadPoolService(12, list, 2);
	}
}



class MyThread implements Runnable {
	private int commandType;
	private String ip;
	private int port;
	private byte[] data;
	private String md5;
	MyThread(int commandType,String ip, int port, byte[] data,String md5)

	{
		this.commandType = commandType;
		this.ip = ip;
		this.port = port;
		this.data = data;
		this.md5 = md5;
	}

	@Override
	public void run() {
		Socket socket = null;
		DataOutputStream writer = null;
		try {
			socket = new Socket(ip, port);
			writer = new DataOutputStream(
					socket.getOutputStream());
			writer.writeInt(commandType);
			writer.flush();//输出完毕后flush一下视为这一段结束
			writer.writeUTF(md5);
			writer.flush();
			writer.write(data);
			writer.flush();
			BufferedReader reader = new BufferedReader(new InputStreamReader(
					socket.getInputStream()));
			String msg = null;
			while ((msg = reader.readLine()) != null) {
				if (msg.equals("OK")) {
					break;
				}
			}
			reader.close();
			writer.close();
		} catch (UnknownHostException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				socket.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

接收端 

import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;

public class MultiThreadServerExample {
	private int port = 8821;
	private ServerSocket serverSocket;
	private ExecutorService executorService;// 线程池
	private final int POOL_SIZE = 50;// 单个CPU线程池大小
	
	public MultiThreadServerExample(){
		try {
			serverSocket = new ServerSocket(port);
			executorService = Executors.newFixedThreadPool(Runtime.getRuntime()
					.availableProcessors() * POOL_SIZE);
			System.out.println("线程开始");
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public void service() {
		while (true) {
			Socket socket = null;
			try {
				// 接收客户连接,只要客户进行了连接,就会触发accept();从而建立连接
				socket = serverSocket.accept();
				executorService.execute(new MyHandler(socket));
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}

	public static void main(String[] args){
		new MultiThreadServerExample().service();
	}

}

class MyHandler implements Runnable {
	private Socket socket;

	public MyHandler(Socket socket) {
		this.socket = socket;
	}
	
	public void run() {
		try {
			//DataInputStream类很好用，建议使用
			DataInputStream reader = new DataInputStream(socket.getInputStream());
			//读取int
			int commandType = reader.readInt();
			System.out.println("commandType:" + commandType);
			//读取String
			String msg = reader.readUTF();
			System.out.println("msg:" + msg);
			//读取byte数组
			byte[] b = new byte[reader.available()];  
			for(int i = 0;i < b.length;i++){
			  b[i] = (byte)reader.read();
			}
			KeyGenerator kg = KeyGenerator.getInstance("AES");
			//获得一个key安全种子对象
			SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
			secureRandom.setSeed(("1234567890123456").getBytes());
			// 初始化
			// DES算法必须是56位
			// DESede算法可以是112位或168位
			// AES算法可以是128、192、256位
			kg.init(128,secureRandom);
			SecretKey key = kg.generateKey();
			Cipher cipher = Cipher.getInstance("AES"); //创建密码器
			cipher.init(Cipher.DECRYPT_MODE, key); //初始化
			byte [] ptext = cipher.doFinal(b); //解密
			String str = new String(ptext, "utf-8"); //重新显示明文
			System.out.println("data:" + str);
			PrintWriter writer = new PrintWriter(new BufferedOutputStream(socket.getOutputStream()));
			//向客户端返回ok
			writer.println("OK");
			writer.flush();
			//输入流要晚一点关，自己的感觉是它关了socket就关了，输出流就不再起作用
			reader.close();
			writer.close();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} catch (NoSuchPaddingException e) {
			e.printStackTrace();
		} catch (InvalidKeyException e) {
			e.printStackTrace();
		} catch (IllegalBlockSizeException e) {
			e.printStackTrace();
		} catch (BadPaddingException e) {
			e.printStackTrace();
		} finally {
			try {
				if (socket != null)
					socket.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

最后的结果





查看的相关博文：

关于socket传输的

http://www.blogjava.net/sterning/archive/2007/10/13/152508.html

关于AES加密的

http://www.tianjiaguo.com/tech/java-aes%E5%8A%A0%E5%AF%86%E8%A7%A3%E5%AF%86/

del1214
关注
专栏目录
java socket使用加密协议传输对象
03-28
java socket使用加密协议传输对象
利用OpenSSL库对Socket传输进行安全加密(RSA+AES)
awsl0000000的专栏
06-11 1673
利用OpenSSL库对Socket传输进行安全加密(RSA+AES)  1. 利用RSA安全传输AES生成密钥所需的Seed(32字节)  2. 利用AES_encrypt/AES_decrypt对Socket上面的业务数据进行AES加密/解密  理论上只需要AES就能保证全部流程，但由于AES加密所需要的AES-KEY是一个结构。 这个一个结构，如果通过网络进行传输，就需要对它进行网络
C# AES加密Socket通信
08-08
C#实现的简单Socket通信。以及AES加密。
java-socket简单编程（socket C/S加解密）
qq_39697860的博客
09-21 1185
好久没更新博客了，最近在帮老师整理项目，本来对socket接触的不多。本次不多说废话，直接说项目 项目要求：1.实现服务端和客户端的传输文件加解密，我这边实现的是服务端传输加密后的文件，客户端收到文件后解密，为了展示方便，我此次采用了AES加密方式，填充方式采用AES/CBC/PKCS5Padding。                   2.实现客户端验证文件是否为服务端发送的文件，我这边采...
java 对字符串的加密解密
热门推荐
城墙上奔跑de二帅
05-12 1万+
import java.security.Key; import java.security.spec.AlgorithmParameterSpec; import javax.crypto.Cipher; import javax.crypto.SecretKeyFactory; import javax.crypto.spec.DESKeySpec; import javax.crypto.
在spring boot中使用java线程池ExecutorService的讲解
08-26
在 Spring Boot 中使用 Java 线程池 ExecutorService 的讲解 Spring Boot 作为一个流行的 Java 框架，提供了许多便捷的功能来帮助开发者快速构建应用程序。其中之一就是使用 Java 线程池 ExecutorService 来管理...
运用JAVA的concurrent.ExecutorService线程池实现socket的TCP和UDP连接.doc
最新发布
06-28
根据提供的文档标题、描述以及部分内容，我们可以总结出以下关于如何运用Java中的`concurrent.ExecutorService`线程池实现socket的TCP和UDP连接的关键知识点： ### 1. 理解Java中的`concurrent.ExecutorService` `...
运用JAVA的concurrent.ExecutorService线程池实现socket的TCP和UDP连接JAVA语言
03-26
运用JAVA的concurrent.ExecutorService线程池实现socket的TCP和UDP连接
Java ExecutorService四种线程池使用详解
08-28
Java的`java.util.concurrent`包中提供了`ExecutorService`的实现类，特别是通过`Executors`工厂类可以方便地创建四种类型的线程池，分别是`newCachedThreadPool`、`newFixedThreadPool`、`newScheduledThreadPool` ...
java通讯加密_Java Socket使用加密协议进行传输对象的方法
weixin_35075144的博客
02-12 708
本文实例讲述了Java Socket使用加密协议进行传输对象的方法。分享给大家供大家参考，具体如下：前面的几篇文章介绍了Socket中一些常见的用法，但是对于一些有安全要求的应用就需要加密传输的数据，此时就需要用到SSLSocket了。还是一样需要一个实现了Java.io.Serializable接口的简单Java对象package com.googlecode.garbagecan.test.s...
数据採集器服务——Socket(今天才发现AES加解密代码跟贴的时候不一样，貌似乱码，不知什么情况)...
weixin_34050005的博客
08-03 105
近期刚做的一个项目。关于 Socket TCP 通信。 需求方提供了一个 ARM 机器，及数据採集器，须要我做一个服务端与数据採集器进行交互。 目的： 数据採集器：定时将读取到的数据发送到服务端。 服务端：将数据採集器发送过来的数据保存在本地。 要求： 1、通信以 TCP 方式进行交互，port可配置。 2、自己实现握手、心跳包机制。 3、TCP 包结构...
java通信加密_基于Java的加密通信平台设计
weixin_33166692的博客
02-21 895
0引言信息作为一种资源,具有普遍性、共享性、增值性、可处理性以及多效用性等特征,使其对于人类具有特别重要的意义[1]。信息安全的概念在二十世纪经历了一个漫长的历史阶段,90年代以来得到了深化[2]。进入21世纪,随着计算机技术的发展,信息安全的重要性不断凸显。信息安全的实质就是保护信息系统或信息网络中的信息资源免受各种类型的威胁、干扰以及破坏[3]。目前主要通过加密方法对信息进行处理,达到保证信息...
浅谈客户端与服务端的加密通讯(HTTPS/AES/RSA/RequestBodyAdviceAdapter/ResponseBodyAdvice)
之一的博客
12-23 6567
目录前言HTTPSAESRSAAES + RSA 组合加密 前言   对项目中使用的加密通讯方案以及遇到的问题进行总结. HTTPS   全称:Hyper Text Transfer Protocol over SecureSocket Layer,是以安全为目标的 HTTP 通道,在HTTP的基础上通过传输加密和身份认证保证了传输过程的安全性.HTTPS 在HTTP 的基础下加入SSL,HTTPS 的安全基础是 SSL,因此加密的详细内容就需要 SSL. HTTPS 存在不同于 HTTP 的默认端口及一个
客户端与服务器交互使用AES+RSA混合加密原理详解
望月思灵
02-18 1092
写的简单易懂，非常好：https://blog.csdn.net/u011339364/article/details/78120904/
java socket 加密,Java socket通信实现DES加密与解密
weixin_39653764的博客
03-13 1659
DES是对称加密算法的其中一个，用一个密钥进行加密解密数据，安全性能比较低，效率较高，一些不太重要的数据可以使用DES加密算法进行加密解密传输，其他的3DES与AES用法类似。流程图首先认真看一下流程图，在脑海里过一遍，然后其实也就是分为以下两个过程，传输完密钥后，就可以使用这个密钥加密数据发送给服务器，服务器拿密钥解密数据，完事。OK，直接贴代码吧，注意下Base64转码传输以及密钥的传输就行了...
AES数据加密的socket传输问题
weixin_42013459的博客
10-10 710
AES数据加密的socket传输问题 在设计一个加密文件传输系统的时候碰到一个这样的问题，百度上有人提问过，就直接上图了。 char *szMessage = new char[size];//待发送数据存放buffer memset(szMessage, 0, size); FILE* pFile = NULL; pFile = fopen(out_path.c_str(), "rb"); //out_path是加密数据的存储位置，内容都是乱码，文件大小是和明文一样的 int read_size =
Socket安全（一）
qq_43456605的博客
05-30 4499
在传统的密钥（或称为对称密钥）加密中，加密和解密数据都使用相同的密钥。SSL常用于web服务器，因为web连接一般是暂时的，每个页面需要单独的Socket，如果每个页面搜要花一定时间来协商一个安全连接，会需要大量的握手时间 ，会产生很大的开销。前面介绍了Socket的基本使用，这里开始介绍Socket的安全问题，作为一个Internet用户，你确实有一些保护手段可以保护自己的隐私不被泄露，为了使Internet连接从根本上上更加安全，可以对Socket进行加密，这可以保持事务的机密性、真实性和准确性。
java凯撒加密socket,密钥短语密码加密，解密同理。
weixin_33283907的博客
03-11 211
//密钥短语密码，密钥不能太长！！vc++6.0成功#include #include #include int str_len(char *str){int len = 0;while(*(str++))len++;return len;}int main(int argc, char *argv[]){char *str=NULL;str=(char*)malloc(127);printf("...
Java多线程Socket编程示例：使用ExecutorService实现线程池
在给定的示例代码中，服务器端使用ExecutorService来管理线程池，服务器端可以接收多个客户端的请求，并将每个请求分配给不同的线程来处理。服务器端使用ServerSocket类来监听客户端的请求，并使用Socket类来与...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值