基于国产密码算法的云计算网络信息传输认证系统设计与实现

目　录

摘　要 I
Abstract II
第一章 绪论 1
1.1 研究的背景与意义 1
1.2 研究的主要内容与方法 2
1.3 组织结构 2
1.4 本章小结 3
第二章 密码算法同态性及网络 4
2.1 密码算法简介 4
2.1.1 对称密码算法 4
2.1.2 非对称密码算法 5
2.1.3 数字摘要算法 5
2.1.4 应用 6
2.2 加密算法的同态性 8
2.2.1 完全同态加密技术 8
2.2.2 部分同态加密技术 8
2.3 加密模式介绍 9
2.3.1 ECB模式 9
2.3.2 CBC模式 10
2.4 网络通信介绍 10
2.4.1 传输层通信 11
2.4.2 数据传输过程 12
2.5 本章小结 13
第三章 国产密码算法与通信实现 14
3.1 国产密码算法实现 14
3.1.1 对称密码算法实现 14
3.1.2 非对称密码算法实现 15
3.1.3 数字摘要算法实现 16
3.2 网络通信实现 18
3.3 本章小结 19
第四章 国产密码算法同态性分析 21
4.1 方案设计 21
4.2 SM2同态性分析 21
4.2.1 SM2实验 21
4.2.2 SM2结果分析 25
4.3 SM4同态性分析 25
4.3.1 ECB模式实验 26
4.3.2 CBC模式实验 27
4.3.3 SM4结果分析 28
4.4 密码算法同态性结果对比分析 29
4.5本章小结 29
第五章 密码算法的性能对比 30
5.1 性能方案设计 30
5.2 SM2加解密时间分析 30
5.3 SM3加解密时间分析 33
5.4 SM4加解密时间分析 34
5.4.1 ECB模式加解密时间分析 34
5.4.2 CBC模式加解密时间分析 35
5.5 密码算法性能分析 37
5.6 本章小结 37
第六章 传输认证系统设计与实现 38
6.1 实现方案 38
6.2 系统架构 38
6.3 实验分析 39
6.4 本章小结 40
结　论 41
参考文献 42
致　谢 43
1.2 研究的主要内容与方法
本课题研究国产加密算法在云计算网络信息传输认证的设计与实现，主要是基于现有的国产密码算法，通过实验判断其是否具有同态特性,再选择合适的密码算法对传输认证系统进行设计与实现。密码算法的同态性是指对于密文进行某种操作，得到相应的密文结果，对密文结果进行解密后得到的结果与直接使用明文进行运算得到的结果是一样的，即对密文的操作等价于在明文上进行相同的操作，满足此类性质的密码算法称为加密算法的同态性。
当在云计算中使用的加密算法具有同态性时，我们可以在客户端对数据进行加密，将密文发送给云服务，云服务根据密文进行相应的计算，返回给我们需要的密文结果，客户端对收到的密文解密。整个过程对于云服务来说，都是在对密文进行操作，不需要进行任何的解密，也无法拿到密文对应的明文，即使数据泄露也可以保证数据的隐私安全，所以密码算法的同态性可以保证我们隐私数据的安全。
研究国产密码算法的同态性，主要采用socket实现客户端和服务端，模拟实际的环境，在客户端加密，将加密后的结果通过socket发送给服务端，服务端只是对密文进行计算，最后返回给客户端，客户端解密拿到结果。
1.3 组织结构
本课题主要研究国产密码算法在云计算网络中信息传输认证的原型设计与实现，论文一共分为五个章节。
第一章主要介绍了研究的背景和意义，阐述了目前云计算所存在的问题，研究的主要内容和方法的简要概述以及论文的组织结构等。
第二章研究了密码算法的分类，主要分为对称密码算法，非对称密码算法以及数字摘要算法。同时对密码算法的同态性，分组加密的模式介绍以及网络通信介绍。
第三章主要是对国产密码算法的实现和网络通信的实现做了介绍。
第四章主要阐述使用的SM2，SM4算法的同态性验证方案，实验流程以及对最后的实验得到结果分析。
第五章主要阐述对三种国产密码算法加解密效率的研究以及最后的结果。
第六章主要阐述了传输认证系统的设计与实现。

package com.htj.cloudEnpt;


import cn.xjfme.encrypt.utils.Util;
import cn.xjfme.encrypt.utils.sm2.SM2EncDecUtils;
import org.bouncycastle.crypto.digests.SM3Digest;
import org.bouncycastle.util.encoders.Hex;


import java.io.*;
import java.net.Socket;

public class ClientSocket {
    
    

    private Socket socket = null; //单例客户端

    /**
     * 构造器初始化，主要进行ip和port的初始化
     */
    public ClientSocket(){
    
    
        ServerProp.initIpAndPort("./src/main/resources/server.properties");
        socket = Singleton.getClientSocket();
    }

    /**
     * 获取用户输入，然后加密，发送到服务端
     */
    public void getInput() {
    
    
        //身份验证
        ensureId("connect to server");
        if (!isSuccess()){
    
    
            System.out.println("认证失败!!!");
            return;
        }
        System.out.println("身份认证成功!!!");
        System.out.println("开始接收用户输入数据...");
        System.out.println("----------------------------------------");
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        int i = 1;
        String content = "";
        try{
    
    
            while (!"#".equals(content)){
    
    
                System.out.println("请输入您的第"+ i +"个字符串：");
                content = in.readLine();
                i++;
                String encrptyText = encrptyData(content);
                sendData(encrptyText);
            }
            receiveData();
        } catch (Exception e){
    
    
            e.printStackTrace();
        }
    }

    /**
     * sm4解密函数，解密客户端从服务端收到的数据
     * @param encryptData
     * @return
     */
    public static String decrptySM4(String encryptData) throws Exception{
    
    
        //return Singleton.getSm4Utils().decryptData_CBC(encryptData);
        return Singleton.getSm4Utils().decryptData_ECB(encryptData);
        //return new String(SM2EncDecUtils.decrypt(Util.hexToByte(Singleton.privatekey), Util.hexToByte(encryptData)));
    }

    /**
     * sm4算法加密函数，加密客户端输入
     * @param plainText
     * @return
     */
    public static String encrptySM4(String plainText) throws Exception {
    
    
        //return Singleton.getSm4Utils().encryptData_CBC(plainText);
        return Singleton.getSm4Utils().encryptData_ECB(plainText);
        //return new String(SM2EncDecUtils.encrypt(Util.hexToByte(Singleton.publicKey), plainText.getBytes()));
    }

    public static String getHash(String plainText){
    
    
        byte[] md = new byte[32];
        byte[] msg1 = plainText.getBytes();
        SM3Digest sm3 = new SM3Digest();
        sm3.update(msg1, 0, msg1.length);
        sm3.doFinal(md, 0);
        return new String(Hex.encode(md));
    }

    /**
     * 加密控制
     * @param plainText
     * @return
     */
    public static String encrptyData(String plainText) throws Exception {
    
    
        if ("#".equals(plainText)){
    
    
            return "#";
        }
        //生成hash值
        String hash = getHash(plainText);
        System.out.println("生成的hash数值为：" + hash);
        //sm4加密
        String encrptyText = encrptySM4(plainText);
        System.out.println("加密后的密文为：" + encrptyText);
        return encrptyText + "|" + hash;
    }

    /**
     * 通过socket发送数据
     * @param msg
     */
    public void sendData(String msg) {
    
    
        try {
    
    
            //Socket socket = new Socket(ServerProp.ip, ServerProp.port); //每次传送数据一个新的tcp连接
            OutputStream outputStream = socket.getOutputStream();
            outputStream.write(msg.getBytes("UTF-8")); //写出数据
            outputStream.flush();
            //socket.shutdownOutput();
        }catch (Exception e){
    
    
            e.printStackTrace();
        }
    }

    /**
     * 接收服务端传递来的数据
     */
    public void receiveData(){
    
    
        System.out.println("----------------------------------------");
        System.out.println("开始接收服务端返回的数据...");
        try {
    
    
            //Socket socket = new Socket(ServerProp.ip, ServerProp.port);
            InputStream in = socket.getInputStream();
            byte[] buffer = new byte[1024];
            StringBuilder s = new StringBuilder();
            int len = 0;
            while ((len = in.read(buffer)) != -1) {
    
    
               s.append(new String(buffer, 0, len, "UTF-8"));
            }
            showData(s.toString());
        }catch (Exception e){
    
    
            e.printStackTrace();
        }
    }

    /**
     * 对服务端的数据解密展示
     */
    public void showData(String s) throws Exception {
    
    
        String[] strs = s.split(",");
        String encrptyText = strs[strs.length - 1];
        System.out.println("总的解密的结果是：" + decrptySM4(encrptyText));
        StringBuilder res = new StringBuilder();
        for (int i = 0; i < strs.length - 1; i++){
    
    
            res.append(decrptySM4(strs[i]));
        }
        System.out.println("分开解密的结果是：" + res.toString());
    }
    /**
     * 身份认证
     */
    private void ensureId(String plainText){
    
    
        System.out.println("开始进行身份认证...");
        //使用公钥加密某个字符串
        try {
    
    
            byte[] sourceData = plainText.getBytes();
            String pubk ="04BB34D657EE7E8490E66EF577E6B3CEA28B739511E787FB4F71B7F38F241D87F18A5A93DF74E90FF94F4EB907F271A36B295B851F971DA5418F4915E2C1A23D6E";
            String cipherText =  SM2EncDecUtils.encrypt(Util.hexToByte(pubk), sourceData);
            sendData(cipherText);
        }catch (Exception e){
    
    
            e.printStackTrace();
        }
    }

    private boolean isSuccess(){
    
    
        try {
    
    
            //Socket socket = new Socket(ServerProp.ip, ServerProp.port);
            InputStream in = socket.getInputStream();
            byte[] buffer = new byte[1024];
            StringBuilder s = new StringBuilder();
            int len = 0;
            while ((len = in.read(buffer)) != -1) {
    
    
                s.append(new String(buffer, 0, len, "UTF-8"));
                System.out.println("接收到服务端的数据为：" + s.toString());
                return "OK".equals(s.toString());
            }
        }catch (Exception e){
    
    
            e.printStackTrace();
        }
        return false;
    }
    /**
     * 主函数，程序入口
     * @param args
     */
    public static void main(String[] args) {
    
    
       ClientSocket one = new ClientSocket();
       one.getInput();
    }
}