分组密码加密
分组密码和序列密码
分组密码和序列密码
分组密码和序列密码是两种常见的对称密码算法。
分组密码是将明文分成固定长度的组（通常为64位或128位），然后对每一组进行加密操作，最终得到密文。
其中最常见的分组密码算法是DES和AES。
序列密码是按照明文或密文的顺序逐个加密或解密。
序列密码算法没有固定的分组长度，而是
根据算法规定的步骤对每个字符或比特进行处理。
最常见的序列密码算法是RC4和Salsa20。
分组密码和序列密码的主要区别在于加密的方式。
分组密码将明文分组加密，而序列密码是逐
个字符或比特加密。
这导致了两者在速度和安全性方面的差异。
分组密码通常比序列密码更安全，因为每个分组的长度固定，使得密码算法能更好地控制和混
淆数据。
而序列密码由于处理的单位是逐个字符或比特，容易受到统计分析等攻击。
然而，序列密码在某些特定的应用场景下具有优势。
由于可以逐个加密或解密，序列密码通常
具有更高的效率，适用于数据流传输和实时加密等场景。
总的来说，分组密码和序列密码都有自己的适用范围和优势，选择哪种密码算法取决于具体的应用需求和安全要求。
分组密码的基本特征
分组密码的基本特征
分组密码是对明文进行分块处理，然后对每个分组进行加密操作。
以下是分组密码的基本特征：
1. 分组长度：分组密码将明文分成固定长度的分组进行处理。
分组长度可以是固定的，也可以是可变的，但在同一次加密过程中，分组长度保持一致。
2. 加密模式：分组密码使用特定的加密模式对每个分组进行加密。
常见的加密模式包括电子密码本模式（ECB）、密码块链模式（CBC）等。
3. 初始向量：在使用某些加密模式时，分组密码需要使用一个初始向量（IV）来增加加密过程的随机性和安全性。
初始向量通常与第一个分组一起使用，而后的分组则与前一个分组相关。
4. 密钥：分组密码使用一个密钥对每个分组进行加密。
密钥长度可以是固定的或可变的，但对于每个分组来说，密钥长度保持一致。
5. 填充方式：由于分组长度固定，对于最后一个分组可能不足分组长度的明文需要进行填充。
填充方式可以是填充字符、填充比特等。
6. 迭代次数：分组密码通常会对每个分组进行多次迭代加密，以增加安全性。
迭代次数通常由密码算法和加密强度决定。
7. 可逆性：分组密码的加密操作是可逆的，即可以通过相应的解密操作将加密后的分组转换回原始的明文分组。
总体而言，分组密码通过将明文分成固定长度的分组，并使用特定的加密模式、初始向量、密钥和迭代次数对每个分组进行加密，以保护明文的安全性。
分组密码和对称密码
分组密码和对称密码
分组密码和对称密码都属于对称加密算法，指的是使用相同的密钥进行加密和解密的算法。
分组密码是将明文分成长度固定的数据块进行加密，每个数据块都使用相同的密钥和相同的算法进行加密处理。
加密和解密过程都是按数据块进行的，因此在加密前需要对明文进行分组，同时在解密后也要对密文进行分组处理。
常见的分组密码算法有DES、AES等。
对称密码也是使用相同的密钥进行加密和解密，但不同的是它不需要将明文分成固定的数据块进行加密，而是逐个字节或逐个比特进行加密处理。
因此，在使用对称密码进行加密前，无需对明文进行分组，也不需要在解密后对密文进行分组处理。
常见的对称密码算法有DES、AES等。
分组密码和对称密码都具有高效性和安全性较强的特点，适用于保护数据的传输和存储。
但由于它们使用相同的密钥进行加密和解密，密钥的分发和管理会面临一定的挑战。
因此，在实际应用中，通常会使用公钥密码体系来解决密钥管理的问题。
对称加密和分组加密中的四种模式（ECB、CBC、CFB、OFB）
对称加密和分组加密中的四种模式（ECB、CBC、CFB、OFB）⼀. AES对称加密:
AES加密
分组
⼆. 分组密码的填充
分组密码的填充
e.g.:
PKCS#5填充⽅式
三. 流密码:
四. 分组密码加密中的四种模式:
3.1 ECB模式
优点:
1.简单；
2.有利于并⾏计算；
3.误差不会被传送；
缺点:
1.不能隐藏明⽂的模式；
2.可能对明⽂进⾏主动攻击；
3.2 CBC模式：
优点：
1.不容易主动攻击,安全性好于ECB,适合传输长度长的报⽂,是SSL、IPSec的标准。
缺点：
1.不利于并⾏计算；
2.误差传递；
3.需要初始化向量IV
3.3 CFB模式：
优点：
1.隐藏了明⽂模式;
2.分组密码转化为流模式;
3.可以及时加密传送⼩于分组的数据;
缺点:
1.不利于并⾏计算;
2.误差传送：⼀个明⽂单元损坏影响多个单元;
3.唯⼀的IV;
3.4 OFB模式：
优点:
1.隐藏了明⽂模式;
2.分组密码转化为流模式;
3.可以及时加密传送⼩于分组的数据;
缺点:
1.不利于并⾏计算;
2.对明⽂的主动攻击是可能的;
3.误差传送：⼀个明⽂单元损坏影响多个单元;。
分组密码算法的运行模式
分组密码算法的运行模式
分组密码算法是一种常见的加密算法，它将明文分成一定长度的数据块进行加密，常用的分组密码算法包括DES、AES等。
在数据加密过程中，分组密码算法采用不同的运行模式，以提高加密效率和安全性。
以下是几种常见的分组密码算法的运行模式：
1. 电子密码本模式(ECB)
这是一种最简单的运行模式，将明文分成若干个固定长度的数据块，每个数据块都采用相同的密钥进行加密。
但是，这种模式存在相同明文块产生相同密文块的问题，容易受到攻击。
2. 密码分组链接模式(CBC)
在这种模式下，每个数据块都与前一个数据块的密文进行异或操作，从而增加了加密的随机性。
同时，为了避免初始向量对加密的影响，需要引入一个随机的初始向量。
3. 输出反馈模式(OFB)
这种模式下，将前一个加密输出作为密钥对下一个明文块进行加密，从而实现了对明文的逐块加密。
该模式可以实现流加密，但是需要保证初始向量的安全性。
4. 计数器模式(CTR)
在该模式下，使用一个计数器生成密钥流，再将明文块与密钥流进行异或操作，得到密文块。
该模式具有高效性和安全性，可以快速生成加密流，并且不受相同明文块和加密块的影响。
总之，不同的运行模式可以提高分组密码算法的安全性和加密效
率，但也需要注意选择合适的模式，并采取适当的安全措施。
NAYUTA：一种基于分组密码的加密算法
Computer Science and Application 计算机科学与应用, 2023, 13(10), 1889-1901Published Online October 2023 in Hans. https:///journal/csahttps:///10.12677/csa.2023.1310187NAYUTA：一种基于分组密码的加密算法董旭鹏1，周雪晴1，杨文忠1，孟繁一21新疆大学计算机科学与技术学院(网络空间安全学院)，新疆乌鲁木齐2复旦大学微电子学院，上海收稿日期：2023年9月16日；录用日期：2023年10月16日；发布日期：2023年10月23日摘要分组密码作为对称密码的一个重要分支，在保护信息安全方面具有重要作用；当今主流的分组密码算法有DES、AES、SMS4等加密算法。
该算法作为基于分组密码设计的加密算法，选取分组密码的K空间中的密钥元素作为置换依据对密文进行置换，并在置换完毕后将密钥插入密文中，通过函数将密文中的所有块和密钥进行处理并发送。
相较于其他的加密算法，NAYUTA主要面向即时通讯，利用密文–密文验证的双因子验证模式和密文–密文验证的双因子混合模式，增加了统计学分析攻击的难度，同时也保证了密文信息的可信性和完整性。
对于双因子验证模式的处理函数而言，该模式是一种基于时间的对称加密方式，使得加密近似于理想OTP (One-Time Password)的加密方式。
NAYUTA目前已将在软件层面和硬件层面均有实现。
关键词分组密码，对称加密，密码学，加密算法，信息安全，一次一密，信息内容安全NAYUTA: An Encryption Algorithm Based on Block CiphersXupeng Dong1, Xueqing Zhou1, Wenzhong Yang1, Fanyi Meng21School of Computer Science and Technology (School of Cyberspace Security),Xinjiang University, UrumqiXinjiang2School of Microelectronics, Fudan University, ShanghaiReceived: Sep. 16th, 2023; accepted: Oct. 16th, 2023; published: Oct. 23rd, 2023AbstractAs an important branch of symmetric ciphers, block ciphers play an important role in protecting董旭鹏 等information security; today’s mainstream block cipher algorithms include DES, AES, SMS4 and other encryption algorithms. As an encryption algorithm designed based on block cipher, the al-gorithm selects the key element in the K space of the block cipher as the replacement basis to re-place the ciphertext, and inserts the key into the ciphertext after the replacement is completed, and processes and sends all blocks and keys in the ciphertext through the function. Compared with other encryption algorithms, NAYUTA is mainly oriented to instant messaging, and uses the two-factor authentication mode of ciphertext-ciphertext verification and the two-factor hybrid mode of ciphertext-ciphertext verification, which increases the difficulty of statistical analysis of attacks and ensures the credibility and integrity of ciphertext information. For the processing functions of the two-factor authentication mode, this mode is a symmetric time-based encryption method, which makes the encryption similar to the ideal OTP (One-Time Password) encryption method. NAYUTA will now be implemented at both the software and hardware levels.KeywordsBlock Cipher, Symmetric Encryption, Cryptology, Encryption Algorithms, Information Security, One Secret at a Time, Information Content SecurityCopyright © 2023 by author(s) and Hans Publishers Inc.This work is licensed under the Creative Commons Attribution International License (CC BY 4.0)./licenses/by/4.0/1. 引言随着信息网络技术的发展，人们使用网络进行社会活动的现象越来越普遍，同时使用网络的人数也在不断增加，在网络不断便利人们的同时，也产生了一系列与网络安全和信息安全相关的问题[1]。
分组加密的四种模式（ECB、CBC、CFB、OFB）
分组加密的四种模式（ECB、CBC、CFB、OFB）加密⼀般分为对称加密(Symmetric Key Encryption)和⾮对称加密(Asymmetric Key Encryption)。
对称加密⼜分为分组加密和序列密码。
分组密码，也叫块加密(block cyphers)，⼀次加密明⽂中的⼀个块。
是将明⽂按⼀定的位长分组，明⽂组经过加密运算得到密⽂组，密⽂组经过解密运算（加密运算的逆运算），还原成明⽂组。
序列密码，也叫流加密(stream cyphers)，⼀次加密明⽂中的⼀个位。
是指利⽤少量的密钥（制乱元素）通过某种复杂的运算（密码算法）产⽣⼤量的伪随机位流，⽤于对明⽂位流的加密。
解密是指⽤同样的密钥和密码算法及与加密相同的伪随机位流，⽤以还原明⽂位流。
分组加密算法中，有ECB,CBC,CFB,OFB这⼏种算法模式。
1)ECB(Electronic Code Book)/电码本模式DES ECB（电⼦密本⽅式）其实⾮常简单，就是将数据按照8个字节⼀段进⾏DES加密或解密得到⼀段8个字节的密⽂或者明⽂，最后⼀段不⾜8个字节，按照需求补⾜8个字节进⾏计算，之后按照顺序将计算所得的数据连在⼀起即可，各段数据之间互不影响。
特点：1.简单，有利于并⾏计算，误差不会被传送；2.不能隐藏明⽂的模式；repetitions in message may show in cipher text/在密⽂中出现明⽂消息的重复3.可能对明⽂进⾏主动攻击；加密消息块相互独⽴成为被攻击的弱点/weakness due to encrypted message blocks being independent2)CBC(Cipher Block Chaining)/密⽂分组链接⽅式DES CBC（密⽂分组链接⽅式）有点⿇烦，它的实现机制使加密的各段数据之间有了联系。
其实现的机理如下：加密步骤如下：1）⾸先将数据按照8个字节⼀组进⾏分组得到D1D2......Dn（若数据不是8的整数倍，⽤指定的PADDING数据补位）2）第⼀组数据D1与初始化向量I异或后的结果进⾏DES加密得到第⼀组密⽂C1（初始化向量I为全零）3）第⼆组数据D2与第⼀组的加密结果C1异或以后的结果进⾏DES加密，得到第⼆组密⽂C24）之后的数据以此类推，得到Cn5）按顺序连为即为加密结果。
分组密码加密算法的常见算法结构
分组密码加密算法的常见算法结构随着计算机技术的不断发展，信息安全问题也越来越受到关注。
在信息传输过程中，数据的加密是保障信息安全的重要手段之一。
分组密码加密算法是一种常见的加密算法，它将明文数据分成若干个固定长度的分组，通过对每个分组进行加密来实现整个消息的加密。
本文将介绍分组密码加密算法的常见算法结构，以及它们的优缺点和应用场景。
1. 基本结构分组密码加密算法的基本结构由两个部分组成：明文分组和密文分组。
明文分组是指明文数据被分割成固定长度的块，每个块长度通常为64位或128位。
密文分组是指加密后的明文分组，长度与明文分组一致。
加密算法的核心是将明文分组转换为密文分组，这个过程称为加密。
解密的过程是将密文分组转换为明文分组。
分组密码加密算法的常见算法结构包括：ECB、CBC、CFB和OFB。
这些算法结构在加密和解密过程中采用不同的方式来处理明文和密文分组。
2. ECB模式ECB（Electronic Codebook）模式是最简单的分组密码加密算法结构，它将每个明文分组单独加密，得到对应的密文分组。
每个明文分组之间是独立的，因此ECB模式无法处理明文分组之间的关系。
这种模式的缺点是，它容易受到重放攻击，即攻击者可以拦截并重复发送相同的密文分组，从而获得明文数据。
ECB模式的优点是加密和解密过程简单，可以并行处理多个分组。
它适用于每个明文分组的安全性要求不高的情况，例如对称密钥的传输和存储。
3. CBC模式CBC（Cipher Block Chaining）模式是一种常见的分组密码加密算法结构，它采用前一个密文分组来加密当前的明文分组。
具体地，在加密过程中，首先将前一个密文分组和当前明文分组进行异或运算，得到一个新的数据块，然后对这个新数据块进行加密。
解密过程与加密过程相反，将密文分组解密后再与前一个密文分组进行异或运算，得到对应的明文分组。
CBC模式的优点是可以处理明文分组之间的关系，提高安全性。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实习二分组密码加密一、实习目的1．理解对称加密算法的原理，熟悉常用的对称加密算法：DES、TripleDES、Blowfish；2．以DES加密算法为例，掌握分组加密算法加、解密过程的实现。
二、实习要求1．实习前认真预习第5章有关内容；2．熟悉java中的java.security.*和java.crypto.*中的相关类；3．按要求认真撰写实习报告。
三、实习内容1．[基本要求]以DES/DESede为例，利用java中的相关类实现对指定字符串的加、解密。
2．[实现提示](1) 可以利用java中的KeyGenerator类创建对称秘钥，利用工厂类KeyGenerator 的静态方法getInstance()获得KeyGenerator()类对象；(2) 方法getInstance()的参数为字符串类型，指定加密算法的名称如：Blowfish、DES、DESede、HmacMD5或HmacSHA1等；(3) 利用工厂类Cipher的对象可以创建密码器。
同样的，getInstance()的参数为字符串类型，指定加密算法的名称。
实验截图：以DES加密为例，客户端：客户端解密：实习代码：服务器MyServer类：package Caesar_Modification;import java.awt.EventQueue;import java.awt.TextArea;import javax.crypto.BadPaddingException; import javax.crypto.Cipher;import javax.crypto.IllegalBlockSizeException; import javax.crypto.NoSuchPaddingException;import javax.swing.JFrame;import java.awt.Color;import javax.swing.JButton;import javax.swing.JLabel;import sun.misc.BASE64Decoder;import java.awt.event.ActionListener;import java.awt.event.ActionEvent;import java.io.BufferedReader;import java.io.IOException;import java.io.InputStream;import java.io.InputStreamReader;import java.io.ObjectInputStream;import .ServerSocket;import .Socket;import java.security.InvalidKeyException; import java.security.Key;import java.security.NoSuchAlgorithmException; public class MyServer {private JFrame frame;private static ServerSocket server_text; private static Socket you_text;private static ServerSocket server_key; private static Socket you_key;private static TextArea SDealWith_Before; private static TextArea SDealWith_After;public static void main(String[] args) { EventQueue.invokeLater(new Runnable() { public void run() {try {MyServer window = new MyServer();window.frame.setVisible(true);} catch (Exception e) {e.printStackTrace();}}});}public MyServer() throws IOException {initialize();}private void initialize() throws IOException { frame = new JFrame();frame.getContentPane().setBackground(Color.LIGHT_GR AY);frame.setTitle("服务器端");frame.setBounds(100, 100, 450, 300);frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE );frame.getContentPane().setLayout(null);final TextArea SDealWith_After = new TextArea();SDealWith_After.setBounds(227, 103, 150, 115);frame.getContentPane().add(SDealWith_After);JLabel lblNewLabel = new JLabel("接收到的秘钥"); lblNewLabel.setBounds(227, 10, 93, 15);frame.getContentPane().add(lblNewLabel);JLabel label_1 = new JLabel("处理后");label_1.setBounds(227, 78, 54, 15);frame.getContentPane().add(label_1);JButton button_1 = new JButton("清除");button_1.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { SDealWith_After.setText("");SDealWith_Before.setText("");}});button_1.setBounds(269, 228, 93, 23);frame.getContentPane().add(button_1);final TextArea Pri_KeyS = new TextArea();Pri_KeyS.setBounds(227, 27, 150, 43);frame.getContentPane().add(Pri_KeyS);final TextArea SDealWith_Before = new TextArea();SDealWith_Before.setBounds(10, 103, 156, 115);frame.getContentPane().add(SDealWith_Before);JButton btnNewButton_1 = new JButton("开启秘钥通道");btnNewButton_1.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) { try {server_key = new ServerSocket(5679);you_key = server_key.accept();Pri_KeyS.setText("秘钥已传送。
");} catch (IOException e1) {e1.printStackTrace();}}});btnNewButton_1.setBounds(10, 6, 150, 23);frame.getContentPane().add(btnNewButton_1);JButton btnNewButton = new JButton("解密");btnNewButton.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) { try {InputStream in =you_text.getInputStream();InputStream is =you_key.getInputStream();ObjectInputStream b = new ObjectInputStream(is);Key k1 = (Key)b.readObject();b.close();int total_ctext = in.available();byte[]ctext = new byte[total_ctext];byte[]ptext = new byte[total_ctext];Cipher cp = Cipher.getInstance("DES");cp.init(Cipher.DECRYPT_MODE, k1);BufferedReader br= new BufferedReader(new InputStreamReader(in));String cstring = br.readLine();BASE64Decoder base64decoder = newBASE64Decoder();ctext =base64decoder.decodeBuffer(cstring);ptext = cp.doFinal(ctext);String p = new String(ptext,"UTF8");SDealWith_Before.setText(cstring);SDealWith_After.setText(p);} catch (IOException e2) {e2.printStackTrace();} catch (NoSuchAlgorithmException e1) {// TODO Auto-generated catch blocke1.printStackTrace();} catch (NoSuchPaddingException e1) { // TODO Auto-generated catch blocke1.printStackTrace();} catch (InvalidKeyException e1) { // TODO Auto-generated catch blocke1.printStackTrace();} catch (IllegalBlockSizeException e1) { // TODO Auto-generated catch blocke1.printStackTrace();} catch (BadPaddingException e1) { // TODO Auto-generated catch blocke1.printStackTrace();} catch (ClassNotFoundException e1) { // TODO Auto-generated catch blocke1.printStackTrace();}try {you_text.close();server_text.close();server_key.close();you_key.close();} catch (IOException e1) {e1.printStackTrace();}}});btnNewButton.setBounds(111, 228, 93, 23);frame.getContentPane().add(btnNewButton);JButton btnNewButton_2 = new JButton("开启密文通道");btnNewButton_2.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) { try {server_text = new ServerSocket(5678);you_text = server_text.accept();} catch (IOException e1) {e1.printStackTrace();}}});btnNewButton_2.setBounds(10, 39, 150, 23);frame.getContentPane().add(btnNewButton_2);JLabel lbldes = new JLabel("通过DES加密后");lbldes.setBounds(20, 74, 93, 23);frame.getContentPane().add(lbldes);}}客户端MyClient类：package Caesar_Modification;import java.awt.EventQueue;import java.awt.TextArea;import javax.crypto.BadPaddingException;import javax.crypto.Cipher;import javax.crypto.IllegalBlockSizeException;import javax.crypto.KeyGenerator;import javax.crypto.NoSuchPaddingException;import java.security.Key;import javax.swing.JFrame;import javax.swing.JTextField;import javax.swing.JLabel;import javax.swing.JButton;import java.awt.event.ActionListener;import java.awt.event.ActionEvent;import java.awt.Color;import java.io.FileOutputStream;import java.io.IOException;import java.io.ObjectOutputStream;import java.io.OutputStream;import java.io.PrintWriter;import .Socket;import .UnknownHostException;import java.security.InvalidKeyException;import java.security.NoSuchAlgorithmException;import javax.swing.JTextArea;import sun.misc.BASE64Encoder;public class MyClient {private JFrame frame;private JTextField Login_C;private static TextArea CDealWith_Before;private static TextArea Pri_KeyC;private static Key secretkey;public static void main(String[] args) {EventQueue.invokeLater(new Runnable() {public void run() {try {MyClient window = new MyClient();window.frame.setVisible(true);} catch (Exception e) {e.printStackTrace();}}});}public MyClient() {initialize();}private void initialize() {frame = new JFrame();frame.getContentPane().setBackground(Color.LIGHT_GRAY);frame.setTitle("客户端");frame.setBounds(100, 100, 450, 300);frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);frame.getContentPane().setLayout(null);JLabel lblNewLabel = new JLabel("明文");lblNewLabel.setBounds(169, 18, 112, 33);frame.getContentPane().add(lblNewLabel);final TextArea CDealWith_Before = new TextArea();CDealWith_Before.setBounds(169, 61, 242, 143);frame.getContentPane().add(CDealWith_Before);JButton btnNewButton_1 = new JButton("加密");btnNewButton_1.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {Socket mySocket_text;String str_before = "";try {mySocket_text = new Socket(Login_C.getText(),5678);OutputStream os= null;os = mySocket_text.getOutputStream();PrintWriter pw = new PrintWriter(os);str_before = CDealWith_Before.getText();Cipher cp = Cipher.getInstance("DES");//初始化Cipher对象cp.init(Cipher.ENCRYPT_MODE, secretkey);byte[] ptext = str_before.getBytes("UTF8");//指定UTF8字符集，可以跨平台byte[] ctext;try {ctext = cp.doFinal(ptext);BASE64Encoder base64encoder = new BASE64Encoder();pw.write(base64encoder.encode(ctext));pw.close();} catch (IllegalBlockSizeException e1) {// TODO Auto-generated catch blocke1.printStackTrace();} catch (BadPaddingException e1) {// TODO Auto-generated catch blocke1.printStackTrace();}//加密序列化mySocket_text.close();}catch (UnknownHostException e1) {e1.printStackTrace();} catch (IOException e1) {e1.printStackTrace();} catch (NoSuchAlgorithmException e1) {// TODO Auto-generated catch blocke1.printStackTrace();} catch (NoSuchPaddingException e1) {// TODO Auto-generated catch blocke1.printStackTrace();} catch (InvalidKeyException e1) {// TODO Auto-generated catch blocke1.printStackTrace();} catch (Exception e2) {// TODO Auto-generated catch blocke2.printStackTrace();}}});btnNewButton_1.setBounds(169, 228, 93, 23); frame.getContentPane().add(btnNewButton_1);Login_C = new JTextField();Login_C.setBounds(23, 82, 93, 22);frame.getContentPane().add(Login_C);Login_C.setColumns(10);JButton button = new JButton("清除");button.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { CDealWith_Before.setText("");Pri_KeyC.setText("");}});button.setBounds(305, 228, 93, 23);frame.getContentPane().add(button);JLabel Login_name = new JLabel("服务器地址"); Login_name.setBounds(23, 57, 93, 15);frame.getContentPane().add(Login_name);JButton button_1 = new JButton("发送秘钥");button_1.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {Socket mySocket_key;try {mySocket_key = new Socket(Login_C.getText(),5679);KeyGenerator kg = KeyGenerator.getInstance("DES");kg.init(56);//DESede默认秘钥长度为168bitsecretkey = kg.generateKey();ObjectOutputStream os_key = new ObjectOutputStream(mySocket_key.getOutputStream());os_key.writeObject(secretkey);os_key.close();mySocket_key.close();} catch (UnknownHostException e1) {e1.printStackTrace();} catch (IOException e1) {e1.printStackTrace();} catch (NoSuchAlgorithmException e1) {// TODO Auto-generated catch blocke1.printStackTrace();}}});button_1.setBounds(23, 158, 93, 23);frame.getContentPane().add(button_1);}}实验总结：本次实验结合了第一次实验的成果，将秘钥和密文分别使用第一次实验的结果通信，运用JA V A自带的加密方法进行加密。