信息安全实习：实习二 分组密码加密 Swing图形化界面（报告+详细代码）

一、实习目的

1．理解对称加密算法的原理，熟悉常用的对称加密算法：DES、TripleDES、Blowfish；

2．以DES加密算法为例，掌握分组加密算法加、解密过程的实现。

二、实习要求

1．实习前认真预习第5章有关内容；

2．熟悉java中的java.security.*和java.crypto.*中的相关类；

3．按要求认真撰写实习报告。

三、实习内容

1．[阶梯任务]：实习任务按照难度渐次给出，阶梯(1)为必须完成的基础任务，请结合自己的实际选择后续阶梯任务

(1) 以本地两个目录模拟两个用户，实现基本DES加密通讯，引入的包具体到类；

(2)对于DES加密实现图形界面，用户可以输入明文和密钥，在文本框中显示对应密文；

(3)实现用户对文件的操作，用户可以通过指定路径文件和密钥，加密结果存储在指定文件中；

(4)采用Socket，建立安全通信过程；

(5)将方案移植到某个web应用中。

2．[实现提示]

(1) 可以利用java中的KeyGenerator类创建对称秘钥，利用工厂类KeyGenerator的静态方法getInstance()获得KeyGenerator()类对象；

(2) 方法getInstance()的参数为字符串类型，指定加密算法的名称如：Blowfish、DES、DESede、HmacMD5或HmacSHA1等；

(3) 利用工厂类Cipher的对象可以创建密码器。同样的，getInstance()的参数为字符串类型，指定加密算法的名称。

四、实验设计

1、基本思路

(1)设计加密解密算法

根据DES对称加密算法来实现加密、解密，首先，设计三个java类，创建Skey_DES类，可以利用java中的KeyGenerator类创建对称秘钥，利用工厂类KeyGenerator的静态方法getInstance()获得KeyGenerator()类对象，以此来生成对称密钥，并可以将其写入key.txt文件中。然后，再定义一个SEnc类，这个类用于加密，先输入一个字符串明文，然后读取密钥key，最后，利用该算法将加密后的写入SEnc.txt文件中，在控制台输出。最后，定义一个SDec类，读取加密文件SEnc.txt以及密钥key.txt文件，利用DES算法将其解密并在控制台输出。输出内容应与明文是一样的。最后测试运行时，先运行Skey_DES类，生成密钥，在运行SEnc类，进行加密，最后运行SDec类，在对加密文本进行解密。

(2)设计加密解密的操作界面

该界面类包括了明文，加密和解密三个输入的文本框部分，还有加密、解密的两个按钮，对按钮都添加了事件监听器，通过获取输入的字符串，以及生成的密钥来调用加密、解密两个方法实现对输入的字符串加密，解密。若想要加密，输入要加密的字符串并点击“加密”按钮，加密后的密文就显示在密文文本框中。相反，若要解密，则在此基础上点击“解密”按钮，解密后的明文就显示在文本框中。

2、类图设计

五、实验结果测试

1.设计加密解密算法

进行加密：

进行解密：

12.图形界面 加密：

解密：

 代码：

 

package work2;
//DES加密解密的图形界面
import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.security.Key;
import javax.crypto.Cipher;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;

/**
 * DES加密和解密工具,可以对字符串进行加密和解密操作 。
 */
public class DesDemo {
    
    public DesDemo() throws Exception {
        this(strDefaultKey);
    }
    public DesDemo(String strKey) throws Exception {
        Key key = getKey(strKey.getBytes());
        encryptCipher = Cipher.getInstance("DES");
        encryptCipher.init(Cipher.ENCRYPT_MODE, key);
        decryptCipher = Cipher.getInstance("DES");
        decryptCipher.init(Cipher.DECRYPT_MODE, key);
    }
    /** 字符串默认键值 */
    private static String strDefaultKey = "national";
    /** 加密工具 */
    private Cipher encryptCipher = null;
    /** 解密工具 */
    private Cipher decryptCipher = null;
    public static String byteArr2HexStr(byte[] arrB) throws Exception {
        int iLen = arrB.length;
        // 每个byte用两个字符才能表示，所以字符串的长度是数组长度的两倍
        StringBuffer sb = new StringBuffer(iLen * 2);
        for (int i = 0; i < iLen; i++) {
            int intTmp = arrB[i];
            // 把负数转换为正数
            while (intTmp < 0) {
                intTmp = intTmp + 256;
            }
            // 小于0F的数需要在前面补0
            if (intTmp < 16) {
                sb.append("0");
            }
            sb.append(Integer.toString(intTmp, 16));
        }
        return sb.toString();
    }
    public static byte[] hexStr2ByteArr(String strIn) throws Exception {
        byte[] arrB = strIn.getBytes();
        int iLen = arrB.length;
        // 两个字符表示一个字节，所以字节数组长度是字符串长度除以2
        byte[] arrOut = new byte[iLen / 2];
        for (int i = 0; i < iLen; i = i + 2) {
            String strTmp = new String(arrB, i, 2);
            arrOut[i / 2] = (byte) Integer.parseInt(strTmp, 16);
        }
        return arrOut;
    }

    public byte[] encrypt(byte[] arrB) throws Exception {
        return encryptCipher.doFinal(arrB);
    }
  
    public String encrypt(String strIn) throws Exception {
        return byteArr2HexStr(encrypt(strIn.getBytes()));
    }
   
    public byte[] decrypt(byte[] arrB) throws Exception {
        return decryptCipher.doFinal(arrB);
    }

    public String decrypt(String strIn) throws Exception {
        return new String(decrypt(hexStr2ByteArr(strIn)));
    }

    private Key getKey(byte[] arrBTmp) throws Exception {
        // 创建一个空的8位字节数组（默认值为0）
        byte[] arrB = new byte[8];
        // 将原始字节数组转换为8位
        for (int i = 0; i < arrBTmp.length && i < arrB.length; i++) {
            arrB[i] = arrBTmp[i];
        }
        // 生成密钥
        Key key = new javax.crypto.spec.SecretKeySpec(arrB, "DES");
        return key;
    }

    public static void main(String[] args) {

        JFrame frame = new JFrame("DES加密解密");
        // Button名称
        JButton button1 = new JButton("加密");
        JButton button2 = new JButton("解密");
        // JTextField名称
        final JTextField content = new JTextField();
        final JTextField pass = new JTextField();
        final JTextField dpass = new JTextField();

        // JLabel
        JLabel view = new JLabel("明文", JLabel.CENTER);
        view.setFont(new java.awt.Font("明文", 1, 15));
        view.setOpaque(true);
        view.setForeground(Color.BLACK);

        // 画布布局
        JPanel contentPane = new JPanel();
        contentPane.add(button1);
        contentPane.add(button2);
        contentPane.add(content);
        contentPane.add(pass);
        contentPane.add(dpass);
        contentPane.add(view);
        frame.setContentPane(contentPane);
        contentPane.setLayout(null);

        // 大小设置
        view.setBounds(250, 0, 80, 30);
        content.setBounds(50, 0, 200, 30);
        pass.setBounds(50, 50, 200, 30);
        button1.setBounds(250, 50, 80, 30);
        dpass.setBounds(50, 100, 200, 30);
        button2.setBounds(250, 100, 80, 30);
        frame.setSize(400, 300);
        frame.setVisible(true);

        button1.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {
                // TODO Auto-generated method stub
                String str1 = content.getText().toString();
                try {
                    pass.setText(new DesDemo().encrypt(str1));
                } catch (Exception e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                }
            }
        });

        button2.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {
                // TODO Auto-generated method stub
                String str2 = content.getText().toString();
                try {
                    dpass.setText(str2);
                } catch (Exception e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                }
            }
        });

        String path = "./jre7/en.jpg";
        // 背景图片
        ImageIcon background = new ImageIcon(path);
        // 把背景图片显示在一个标签里面
        JLabel label = new JLabel(background);
        // 把标签的大小位置设置为图片刚好填充整个面板
        label.setBounds(0, 0, frame.getWidth(), frame.getHeight());
        // 把内容窗格转化为JPanel，否则不能用方法setOpaque()来使内容窗格透明
        JPanel imagePanel = (JPanel) frame.getContentPane();
        imagePanel.setOpaque(false);
        // 把背景图片添加到分层窗格的最底层作为背景
        frame.getLayeredPane().add(label, new Integer(Integer.MIN_VALUE));

    }
}

package work2;

import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.security.Key;

import javax.crypto.Cipher;


public class SDec {
    //解密
	public static void main(String[] args) throws Exception {
		FileInputStream f=new FileInputStream("SEnc.txt");
		int num=f.available();
		byte[] ctext=new byte[num];
		f.read(ctext);
		FileInputStream f2=new FileInputStream("key.txt");
		ObjectInputStream b=new ObjectInputStream(f2);
		Key k=(Key)b.readObject();
		Cipher cp=Cipher.getInstance("DESede");
		cp.init(Cipher.DECRYPT_MODE, k);
		byte[] ptext=cp.doFinal(ctext);
		String p=new String(ptext,"UTF-8");
		System.out.println(p);
		

	}

}

package work2;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.security.Key;

import javax.crypto.Cipher;

public class SEnc {
    //加密
	public static void main(String[] args) throws Exception {
		String s="Hello123Hello123Hello123Hello123";
		FileInputStream f=new FileInputStream("key.txt");
		@SuppressWarnings("resource")
		ObjectInputStream b=new ObjectInputStream(f);
		Key k=(Key)b.readObject();
		Cipher cp=Cipher.getInstance("DESede");
		cp.init(Cipher.ENCRYPT_MODE, k);
		byte ptext[]=s.getBytes("UTF-8");
		for(int i=0;i<ptext.length;i++){
			System.out.print(ptext[i]+",");
		}
		System.out.println();
		byte ctext[]=cp.doFinal(ptext);
		for(int i=0;i<ctext.length;i++){
			System.out.print(ctext[i]+",");
		}
		@SuppressWarnings("resource")
		FileOutputStream f2=new FileOutputStream("SEnc.txt");
		f2.write(ctext);
		s=ctext.toString();
		

	}

}

package work2;

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
public class Skey_DES {
    //密钥生成
	public static void main(String[] args) throws Exception {
		KeyGenerator kg=KeyGenerator.getInstance("DESede");
		kg.init(168);
		SecretKey k=kg.generateKey();
		FileOutputStream f=new FileOutputStream("key.txt");
		@SuppressWarnings("resource")
		ObjectOutputStream b=new ObjectOutputStream(f);
		b.writeObject(k);
	}
}