DH加密通信python实现

最新推荐文章于 2024-05-14 19:05:01 发布
最新推荐文章于 2024-05-14 19:05:01 发布
阅读量2.8k 收藏 30
点赞数 4
分类专栏： 密码学 文章标签： python 密码学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40398985/article/details/107115782
版权

DH_Crypto

概况介绍

本次实验实现了DH原理的双机通信。DH_Client和DH_Server的main部分与call_DH部分大同小异，主要是用于本地调试显示，可以忽略。

原理介绍

p,q为公有信息。
1.Alice 选择一个范围在[1, p-1]的随机数，为rand_a
2.Alice 计算cal_a = q^rand_a mod p
3.Bob选择一个范围在[1, p-1]的随机数，为rand_b = 6
4.Bob计算cal_b = q^rand_b mod p
5.Alice和Bob交换cal_a和cal_b
6.Alice计算共享密钥S = cal_b ^rand_a mod p
7.Bob计算共享密钥S = cal_a ^rand_b mod p

RSA_sign

# -*- coding:utf-8 -*-
import rsa
import binascii
import os
#快速模幂运算，模重复平方
def powmod(b,n,m):
	ans=1
	while n > 0:
		if (n & 1) !=0:
			ans = (ans*b)%m
		b = (b*b) % m
		n >>= 1
	return ans
def bytes_to_int(s):
    return int.from_bytes(s,byteorder='big',signed=False)
#rsa类
class rsa_crypto():
	#生成RSA密钥对同时返回公钥
	def generate_key(self,dir):
		list=rsa.newkeys(1024)
		list=str(list)
		with open(dir, 'w') as f:
			f.write(list)
		list=list.split(',')
		n=str(list[0][11:])
		pubkey = str(list[1][:-1])
		return n,pubkey
	#私钥加密 C=M^d mod n
	def rsa_encrypt(self,s,dir):
		with open(dir, 'r') as f:
			temp = f.read()
		ne = temp.split(',')
		# print("ne",ne)
		n = int(ne[0][11:])
		d = int(ne[4])
		string =binascii.b2a_hex(s.encode())
		intstr = bytes_to_int(string)
		cryptot = ("%x"%powmod(intstr,d,n))
		if len(cryptot)%2 == 1:
			cryptot = '0'+cryptot
		return binascii.a2b_hex(cryptot)
	#解密 M=C^d mod n
	def rsa_decrypt(self,string,n,e):
		intstr = bytes_to_int(string)
		content = ("%x"%powmod(intstr,e,n))
		if len(content)%2 == 1:
			content = '0' + content
		return binascii.a2b_hex(content)

rsa_key内存储生成的密钥，调用python的rsa库
在这里插入图片描述

Connection.py

# -*- coding: UTF-8 -*-
from socket import *
#保存client与server通信时的公有量
class connect():
    #发送连接请求
    def client(self,C_ip,C_port):
        # 绑定对象服务器
        HOST = C_ip#192.168.43.198
        PORT=C_port
        ADDR = (HOST, PORT)
        # 面向网络的TCP数据报流
        global tcpCliSock, tcpSerSock
        tcpCliSock = socket(AF_INET, SOCK_STREAM)
        tcpCliSock.connect(ADDR)
        print("client connects successfully")
    #服务端等待连接
    def server(self,S_ip,S_port):
        HOST = S_ip#192.168.43.100
        PORT = S_port
        ADDR = (HOST,PORT)
        global tcpCliSock,tcpSerSock
        tcpSerSock = socket(AF_INET, SOCK_STREAM)
        tcpSerSock.bind(ADDR)
        tcpSerSock.listen(5)
        tcpCliSock, addr =tcpSerSock.accept()
        print("server is connected successfully")
    #发送，报文需提前写好且格式为bytes
    def send_data(self,pack):
        tcpCliSock.send(pack)
        print("send successfully")
    #接受报文
    def getdata(self):
        while 1:
            data = tcpCliSock.recv(1024)
            if data!=b'':
                print("RECEIEVE", data)
                #print("flag_get3\n",tcp.flag)
                return data

DH_Client.py

# -*- coding: UTF-8 -*-
import rsa
import random
import connection
import HASH,DES
import RSA_sign
import binascii
class DH_C:
    def __init__(self,length=1024):
        self.length=length
        return
    #得到一个大素数p，从rsa方法内选择，且不与下加密签名内相同
    def get_prime(self,length):
        prime=rsa.newkeys(length)[1]
        string= str(prime).split(',')
        p = int(string[3][1:])
        print("p")
        print(p)
        return p
    #生成本原元，但是由于基数过大，所以本实验默认为2
    def get_generator(self,p):
        if p == 0:
            return
        a = 2
        while 1:
            if a ** (p - 1)% p== 1:
                n = 2
                mark = 0
                while n < p - 1:
                    if a ** n % p == 1:
                        mark = 1
                    n += 1
            if mark == 0:
                print(a)
                return a
            a += 1
    #得到随机数rand_A
    def get_random_a(self,p):
        rand_A = random.randint(0, p - 1)
        print("rand_A\n",rand_A)
        return rand_A
    #计算Client的cal_A
    def cal_A(self,g,random_A,p):
        cal_A=pow(g,random_A,p)
        print("cal_A\n",cal_A)
        return cal_A
    #进行公有信息打包，利用space分割，便于传输
    def pre_pack(self, p, g,C_n, C_pubkey):
        pack = bytes(str(p) + 'space' + str(g) + 'space' + str(C_n) + 'space' +str(C_pubkey) + 'space' + 'hello' + 'space', 'utf-8')
        return pack
    #进行加密信息打包，source_C为附加的HASH验证
    def pack(self, A, source_C):
        pack = bytes(str(A) + 'space', 'utf-8') + source_C
        return pack
    #解析Server发来的B，S_Key与对应的两个签名
    def pre_prase(self, data):
        string = data.split(b'space')
        S_pubkey = int(string[0])
        S_n=int(string[1])
        message = string[2]
        print("S_pubkey\n", S_pubkey)
        print("S_n\n", S_n)
        print("message\n", message)
        return S_pubkey,S_n, message
    def data_parse(self,data):
        string = data.split(b'space')
        B = int(string[0])
        source_B=string[1]
        print("B\n", B)
        print("source_B\n",source_B)
        return B,source_B
    #计算共享密钥
    def C_get_Key(self,g,A,p):
        C_Key= pow(g, A, p);
        print("C_key\n",C_Key)
        with open('./key/DH_C_key.txt', 'w') as f:
            f.write(str(C_Key))
        return C_Key
if __name__ == '__main__':
    dh_c = DH_C(256)
    share=connection.connect()
    hash=HASH.HASH()
    C=RSA_sign.rsa_crypto()

    share.client('127.0.0.1',21567)
    #发送公有的数据
    p = dh_c.get_prime(dh_c.length)
    g = 2
    C_n,C_pubkey=C.generate_key('./key/DH_C_signkey.txt')
    pack=dh_c.pre_pack(p,g,C_n,C_pubkey)
    share.send_data(pack)
    #解析传递的公有数据
    data=share.getdata()
    (S_pubkey,S_n,message)=dh_c.pre_prase(data)
    rand_A = dh_c.get_random_a(p)
    A = dh_c.cal_A(g, rand_A, p)
    complete=hash.SHA_1(str(A))
    source_C=C.rsa_encrypt(complete,'./key/DH_C_signkey.txt')
    #传输加密后的数据
    pack=dh_c.pack(A,source_C)
    share.send_data(pack)
    #接受并解析加密后的数据
    data = share.getdata()
    (B,source_B)=dh_c.data_parse(data)
    #解密签名并计算获得值的HASH，比对正确说明无丢失来源正确，可计算得到共享密钥
    complete_B=hash.SHA_1(str(B))
    cal_source_B=C.rsa_decrypt(source_B,S_n,S_pubkey)
    cal_source_B= binascii.a2b_hex(cal_source_B).decode()
    if (complete_B==cal_source_B):
        C_Key = dh_c.C_get_Key(B, rand_A, p)
        with open('./key/DH_C_key.txt', 'w') as f:
            f.write(str(C_Key))
            #使用商量好的密钥对称加密
            des=DES.des()
            des_key=str(C_Key)[0:8]
            with open('./key/DH_Sec_C.txt', 'w') as f2:
                f2.write(des_key)
            des.encryptDes('./input/send_message.txt', './key/DH_Sec_C.txt', './output/des_encrypt_message.txt')

DH_Server.py

# -*- coding: UTF-8 -*-
import random
import connection
import HASH,DES
import RSA_sign
import binascii
class DH_S:
    def __init__(self):
        return
    #得到随机数rand_b
    def get_random_b(self,p):
        rand_B = random.randint(0, p-1)
        print("rand_B",rand_B)
        return rand_B
    #解析公有的信息内容
    def pre_parse(self, data):
        string = data.split(b'space')
        p = int(string[0])
        g = int(string[1])
        C_n=int(string[2])
        C_pubkey=int(string[3])
        message=string[4]
        print("p\n", p)
        print("g\n", g)
        print("C_n\n",type(C_n),C_n)
        print("C_pubkey\n", C_pubkey)
        print("message\n", message)
        return p, g, C_n,C_pubkey, message
    #解析含hash的加密信息
    def data_parse(self, data):
        string = data.split(b'space')
        A = int(string[0])
        signature = string[1]
        print("A\n", A)
        print("signature\n", signature)
        return A, signature
    #计算B与S_Key
    def cal_B(self, g, random_B, p):
        cal_B = pow(g, random_B, p);
        print("cal_B", cal_B)
        return cal_B
    def S_get_Key(self, A, rand_B, p):
        S_Key = pow(int(A), rand_B, p)
        print("S_key", S_Key)
        with open('./key/DH_S_key.txt', 'w') as f:
            f.write(str(S_Key))
        return S_Key
    #打包公有信息
    def pre_pack(self, S_pubkey,S_n, message):
        pack = bytes(str(S_pubkey) + 'space'+ str(S_n)+ 'space', 'utf-8') + message
        return pack
    #打包加密信息
    def pack(self,B,source_B):
        pack =bytes(str(B)+'space','utf-8')+source_B
        return pack
if __name__ == '__main__':
    share = connection.connect()
    dh_s = DH_S()
    hash = HASH.HASH()
    S = RSA_sign.rsa_crypto()
    #循环等待实现多次认证
    while 1:
        share.server('127.0.0.1',21567)
        #接受公有信息
        data=share.getdata()
        (p, g, C_n,C_pubkey,message) = dh_s.pre_parse(data)
        S_n,S_pubkey = S.generate_key('./key/DH_S_signkey.txt')
        pack=dh_s.pre_pack(S_pubkey,S_n,message)
        share.send_data(pack)
        #接受加密的信息
        data = share.getdata()
        (A,signature)=dh_s.data_parse(data)
        orgin_source = hash.SHA_1(str(A))
        complete =S.rsa_decrypt(signature,C_n,C_pubkey)
        print(complete)
        cal_source=(binascii.a2b_hex(complete).decode())
        print("orgin_source\n",orgin_source)
        #若验证了得到的共享内容正确
        if cal_source==orgin_source:
            #发送加密信息
            print("it is a right pack")
            rand_B = dh_s.get_random_b(p)
            B = dh_s.cal_B(g, rand_B, p)
            S_Key = dh_s.S_get_Key(A, rand_B, p)
            complete_B = hash.SHA_1(str(B))
            source_B= S.rsa_encrypt(complete_B,'./key/DH_S_signkey.txt')
            pack=dh_s.pack(B,source_B)
            share.send_data(pack)
            with open('./key/DH_S_key.txt', 'w') as f:
                f.write(str(S_Key))
                #利用得到的对称密钥加密
                des=DES.des()
                des_key=str(S_Key)[0:8]
                with open('./key/DH_Sec_S.txt','w') as f2:
                    f2.write(des_key)
                des.decryptDes('./output/des_encrypt_message.txt','./key/DH_Sec_S.txt', './output/des_decrypt_message.txt')

call_DH.py

# -*- coding: utf-8 -*-
import sys,binascii
import DES,RSA_sign,DH_Client,DH_Server,connection,HASH
from PyQt5.QtWidgets import QApplication, QMainWindow
#导入designer工具生成的login模块
from DH import Ui_MainWindow
class MyMainForm(QMainWindow, Ui_MainWindow):
    def __init__(self, parent=None):
        super(MyMainForm, self).__init__(parent)
        self.setupUi(self)
        self.button_begin.clicked.connect(self.run_begin)
        self.button_client.clicked.connect(self.run_button_client)
        self.button_server.clicked.connect(self.run_button_server)
        self.button_client_connect.clicked.connect(self.run_button_client_connect)
        self.button_server_connect.clicked.connect(self.run_button_server_connect)
        self.button_pre_C_send.clicked.connect(self.run_button_pre_C_send)
        self.button_pre_S_send.clicked.connect(self.run_button_pre_S_send)
        self.button_C_send.clicked.connect(self.run_button_C_send)
        self.button_S_send.clicked.connect(self.run_button_S_send)
        self.button_S_getkey.clicked.connect(self.run_button_S_getkey)
        self.button_C_getkey.clicked.connect(self.run_button_C_getkey)
        self.button_sec_C.clicked.connect(self.run_button_sec_C)
        self.button_sec_S.clicked.connect(self.run_button_sec_S)

    def run_begin(self):
        global share, dh_c, dh_s, hash, C, S, des
        share = connection.connect()
        dh_c = DH_Client.DH_C(48)#控制DH生成密钥的长度，但是有一定误差
        dh_s = DH_Server.DH_S()
        hash = HASH.HASH()
        C = RSA_sign.rsa_crypto()
        S = RSA_sign.rsa_crypto()
        des=DES.des()
        self.show_config.setText("设置成功")

    def run_button_client(self):
        self.button_server.setEnabled(False)
        self.button_S_send.setEnabled(False)
        self.button_S_getkey.setEnabled(False)
        self.button_server_connect.setEnabled(False)
        self.show_S_send.setEnabled(False)
        self.output_S_key.setEnabled(False)
        self.output_pre_S_send.setEnabled(False)
        self.output_sec_S.setEnabled(False)
        self.button_pre_S_send.setEnabled(False)
        self.button_sec_S.setEnabled(False)
        self.label_ip.setText("请输入通信对象IP：")

    def run_button_server(self):
        self.button_client.setEnabled(False)
        self.button_C_send.setEnabled(False)
        self.button_C_getkey.setEnabled(False)
        self.button_client_connect.setEnabled(False)
        self.show_C_send.setEnabled(False)
        self.output_C_key.setEnabled(False)
        self.output_pre_C_send.setEnabled(False)
        self.output_sec_C.setEnabled(False)
        self.button_pre_C_send.setEnabled(False)
        self.button_sec_C.setEnabled(False)
        self.label_ip.setText("请输入本机IP：")

    def run_button_server_connect(self):
        ip = self.input_ip.text()
        port = int(self.input_port.text())
        share.server(ip, port)
        self.show_connect.setText("连接成功,为Server端")

    def run_button_client_connect(self):
        ip = self.input_ip.text()
        port = int(self.input_port.text())
        share.client(ip, port)
        self.show_connect.setText("连接成功,为Client端")

    def run_button_pre_C_send(self):
        global p_A,g_A,C_pubkey
        p_A = dh_c.get_prime(512)
        self.output_pre_C_send.setText("p生成完毕:\n")
        self.output_pre_C_send.append(str(p_A))
        g_A = 2
        self.output_pre_C_send.append("g生成完毕:\n")
        self.output_pre_C_send.append(str(g_A))
        C_n, C_pubkey = C.generate_key('./key/DH_C_signkey.txt')
        self.output_pre_C_send.append("Client端RSA公私钥对生成完毕,输出C_n:\n")
        self.output_pre_C_send.append(str(C_n))
        self.output_pre_C_send.append("输出C_pubkey:\n")
        self.output_pre_C_send.append(str(C_pubkey))
        pack = dh_c.pre_pack(p_A, g_A, C_n, C_pubkey)
        self.output_pre_C_send.setText("打包p,g,C_n,C_pubkey完成并发送hello:\n")
        self.output_pre_C_send.append(str(pack))
        share.send_data(pack)
        self.output_pre_C_send.append("发送包成功")

    def run_button_pre_S_send(self):
        global C_n,C_pubkey,p_B,g_B
        data = share.getdata()
        self.output_pre_S_send.setText("接收到包:\n")
        (p_B, g_B, C_n, C_pubkey, message) = dh_s.pre_parse(data)
        self.output_pre_S_send.append("获得p:\n")
        self.output_pre_S_send.append(str(p_B))
        self.output_pre_S_send.append("获得g:\n")
        self.output_pre_S_send.append(str(g_B))
        self.output_pre_S_send.append("获得C_n:\n")
        self.output_pre_S_send.append(str(C_n))
        self.output_pre_S_send.append("获得C_pubkey:\n")
        self.output_pre_S_send.append(str(C_pubkey))
        S_n, S_pubkey = S.generate_key('./key/DH_S_signkey.txt')
        self.output_pre_S_send.append("Server端RSA公私钥对生成完毕,输出S_n:\n")
        self.output_pre_S_send.append(str(S_n))
        self.output_pre_S_send.append("输出S_pubkey:\n")
        self.output_pre_S_send.append(str(S_pubkey))
        pack = dh_s.pre_pack(S_pubkey, S_n, message)
        self.output_pre_S_send.append("打包S_n,S_pubkey完毕并回复原消息:\n")
        self.output_pre_S_send.append(str(pack))
        share.send_data(pack)
        self.output_pre_S_send.append("包发送完毕\n")

    def run_button_C_send(self):
        global rand_A,p_A,S_pubkey,S_n
        data = share.getdata()
        self.show_C_send.setText("接受到包:\n")
        (S_pubkey, S_n, message) = dh_c.pre_prase(data)
        self.show_C_send.append("获得S_n:\n")
        self.show_C_send.append(str(S_n))
        self.show_C_send.append("获得S_pubkey:\n")
        self.show_C_send.append(str(S_pubkey))
        rand_A = dh_c.get_random_a(p_A)
        self.show_C_send.append("生成随机元rand_A:\n")
        self.show_C_send.append(str(rand_A))
        A = dh_c.cal_A(g_A, rand_A, p_A)
        self.show_C_send.append("计算获得A:\n")
        self.show_C_send.append(str(A))
        complete = hash.SHA_1(str(A))
        self.show_C_send.append("对A生成HASH摘要:\n")
        self.show_C_send.append(str(complete))
        source_C = C.rsa_encrypt(complete, './key/DH_C_signkey.txt')
        self.show_C_send.append("对A的摘要使用Client的私钥进行签名:\n")
        self.show_C_send.append(str(source_C))
        pack = dh_c.pack(A, source_C)
        self.show_C_send.append("打包A与A的数字签名完毕\n")
        self.show_C_send.append(str(pack))
        share.send_data(pack)
        self.show_C_send.append("发送包成功\n")


    def run_button_S_send(self):
        global A,rand_B
        data = share.getdata()
        self.show_S_send.setText("收到包\n")
        (A, signature_A) = dh_s.data_parse(data)
        self.show_S_send.append("A:\n")
        self.show_S_send.append(str(A))
        self.show_S_send.append("A的数字签名:\n")
        self.show_S_send.append(str(signature_A))
        complete_A = hash.SHA_1(str(A))
        self.show_S_send.append("本地计算A的HASH值为\n")
        self.show_S_send.append(str(complete_A))
        source_A = S.rsa_decrypt(signature_A, C_n, C_pubkey)
        source_A = binascii.a2b_hex(source_A).decode()
        self.show_S_send.append("使用Server的私钥解签A的HASH值为:\n")
        self.show_S_send.append(str(source_A))
        # 若验证了得到的共享内容正确
        if complete_A == source_A:
            self.show_S_send.append("A的完整性与来源性验证正确\n")
            rand_B = dh_s.get_random_b(p_B)
            self.show_S_send.append("生成随机元rand_B:\n")
            self.show_S_send.append(str(rand_B))
            B = dh_s.cal_B(g_B, rand_B, p_B)
            self.show_S_send.append("根据g,rand_B,p计算得到B\n")
            self.show_S_send.append(str(B))
            complete_B = hash.SHA_1(str(B))
            self.show_S_send.append("对B生成HASH摘要\n")
            self.show_S_send.append(str(complete_B))
            source_B = S.rsa_encrypt(complete_B, './key/DH_S_signkey.txt')
            self.show_S_send.append("对B的摘要使用Server的私钥进行签名\n")
            self.show_S_send.append(str(source_B))
            pack = dh_s.pack(B,source_B)
            self.show_S_send.append("打包B与B的数字签名\n")
            self.show_S_send.append(str(pack))
            share.send_data(pack)
            self.show_S_send.append("发送包成功\n")

    def run_button_C_getkey(self):
        data = share.getdata()
        self.output_C_key.setText("接收到包\n")
        (B,signature_B) = dh_c.data_parse(data)
        self.output_C_key.append("B:\n")
        self.output_C_key.append(str(B))
        self.output_C_key.append("B的数字签名:\n")
        self.output_C_key.append(str(signature_B))
        complete_B = hash.SHA_1(str(B))
        self.output_C_key.append("B的本地计算HASH为:\n")
        self.output_C_key.append(str(complete_B))
        source_B = C.rsa_decrypt(signature_B, S_n, S_pubkey)
        source_B = binascii.a2b_hex(source_B).decode()
        self.output_C_key.append("使用Client的公钥解签得B的HASH为:\n")
        self.output_C_key.append(str(source_B))
        if (complete_B == source_B):
            self.output_C_key.append("B的来源性与完整性验证成功:\n")
            C_Key = dh_c.C_get_Key(B, rand_A, p_A)
            self.output_C_key.append("根据B，rand_A,p_A计算共享密钥C_Key:\n")
            self.output_C_key.append(str(C_Key))
            with open('./key/DH_C_key.txt','w') as f:
                f.write(str(C_Key))
    def run_button_S_getkey(self):
        S_Key = dh_s.S_get_Key(A, rand_B, p_B)
        self.output_S_key.setText("根据A，rand_B,p_B计算共享密钥S_Key\n")
        self.output_S_key.append(str(S_Key))
        with open('./key/DH_S_key.txt', 'w') as f:
            f.write(str(S_Key))

    def run_button_sec_C(self):
        with open('./key/DH_C_key.txt', 'r') as f:
            C_des_key=f.read()[0:8]
        with open('./key/DH_Sec_C.txt', 'w') as f2:
           f2.write(C_des_key)
        self.output_sec_C.setText("取共享密钥前64位作为DES密钥加密消息")
        des.encryptDes('./input/send_message.txt', './key/DH_Sec_C.txt', './output/des_encrypt_message.txt')
        with open('./input/send_message.txt', 'r',encoding='utf-8') as f3:
           message=f3.read()
        with open('./output/des_encrypt_message.txt',encoding='utf-8') as f4:
           encrypto=f4.read()
        self.output_sec_C.append("明文为；")
        self.output_sec_C.append(str(message))
        self.output_sec_C.append("加密成功，密文为；")
        self.output_sec_C.append(str(encrypto))
    def run_button_sec_S(self):
        with open('./key/DH_S_key.txt', 'r') as f:
            S_des_key=f.read()[0:8]
        with open('./key/DH_Sec_S.txt', 'w') as f2:
           f2.write(S_des_key)
        self.output_sec_S.setText("取共享密钥前64位作为DES密钥解密消息")
        des.decryptDes('./output/des_encrypt_message.txt', './key/DH_Sec_S.txt', './output/des_decrypt_message.txt')
        self.output_sec_S.append("解密完成，请查看./output/des_decrypt_message.txt获取解密后信息")
        with open('./output/des_encrypt_message.txt', 'r',encoding='utf-8') as f3:
           encrypto=f3.read()
        with open('./output/des_decrypt_message.txt', 'r',encoding='utf-8') as f4:
           decrypto=f4.read()
        self.output_sec_S.append("密文为；")
        self.output_sec_S.append(str(encrypto))
        self.output_sec_S.append("解密后消息为；")
        self.output_sec_S.append(str(decrypto))

if __name__ == "__main__":
     #固定的，PyQt5程序都需要QApplication对象。sys.argv是命令行参数列表，确保程序可以双击运行
     app = QApplication(sys.argv)
     #初始化
     myWin = MyMainForm()
     #将窗口控件显示在屏幕上
     myWin.show()
     #程序运行，sys.exit方法确保程序完整退出。
     sys.exit(app.exec_())

DH.py(用于Qt界面设计)

# -*- coding: utf-8 -*-

# Form implementation generated from reading ui file 'DH.ui'
#
# Created by: PyQt5 UI code generator 5.13.0
#
# WARNING! All changes made in this file will be lost!


from PyQt5 import QtCore, QtGui, QtWidgets


class Ui_MainWindow(object):
    def setupUi(self, MainWindow):
        MainWindow.setObjectName("MainWindow")
        MainWindow.resize(1000, 1000)
        self.centralwidget = QtWidgets.QWidget(MainWindow)
        self.centralwidget.setObjectName("centralwidget")
        self.layoutWidget = QtWidgets.QWidget(self.centralwidget)
        self.layoutWidget.setGeometry(QtCore.QRect(11, 51, 646, 843))
        self.layoutWidget.setObjectName("layoutWidget")
        self.gridLayout = QtWidgets.QGridLayout(self.layoutWidget)
        self.gridLayout.setContentsMargins(0, 0, 0, 0)
        self.gridLayout.setObjectName("gridLayout")
        self.button_pre_C_send = QtWidgets.QPushButton(self.layoutWidget)
        self.button_pre_C_send.setObjectName("button_pre_C_send")
        self.gridLayout.addWidget(self.button_pre_C_send, 3, 0, 1, 1)
        self.button_S_send = QtWidgets.QPushButton(self.layoutWidget)
        self.button_S_send.setObjectName("button_S_send")
        self.gridLayout.addWidget(self.button_S_send, 4, 2, 1, 1)
        self.label_port = QtWidgets.QLabel(self.layoutWidget)
        self.label_port.setAlignment(QtCore.Qt.AlignCenter)
        self.label_port.setObjectName("label_port")
        self.gridLayout.addWidget(self.label_port, 2, 2, 1, 1)
        self.output_pre_C_send = QtWidgets.QTextBrowser(self.layoutWidget)
        self.output_pre_C_send.setObjectName("output_pre_C_send")
        self.gridLayout.addWidget(self.output_pre_C_send, 3, 1, 1, 1)
        self.button_server = QtWidgets.QPushButton(self.layoutWidget)
        self.button_server.setObjectName("button_server")
        self.gridLayout.addWidget(self.button_server, 1, 2, 1, 1)
        self.show_C_send = QtWidgets.QTextBrowser(self.layoutWidget)
        self.show_C_send.setObjectName("show_C_send")
        self.gridLayout.addWidget(self.show_C_send, 4, 1, 1, 1)
        self.button_sec_C = QtWidgets.QPushButton(self.layoutWidget)
        self.button_sec_C.setObjectName("button_sec_C")
        self.gridLayout.addWidget(self.button_sec_C, 6, 0, 1, 1)
        self.button_pre_S_send = QtWidgets.QPushButton(self.layoutWidget)
        self.button_pre_S_send.setObjectName("button_pre_S_send")
        self.gridLayout.addWidget(self.button_pre_S_send, 3, 2, 1, 1)
        self.show_config = QtWidgets.QLabel(self.layoutWidget)
        self.show_config.setAlignment(QtCore.Qt.AlignCenter)
        self.show_config.setObjectName("show_config")
        self.gridLayout.addWidget(self.show_config, 0, 1, 1, 1)
        self.button_sec_S = QtWidgets.QPushButton(self.layoutWidget)
        self.button_sec_S.setObjectName("button_sec_S")
        self.gridLayout.addWidget(self.button_sec_S, 6, 2, 1, 1)
        self.button_begin = QtWidgets.QPushButton(self.layoutWidget)
        self.button_begin.setObjectName("button_begin")
        self.gridLayout.addWidget(self.button_begin, 0, 0, 1, 1)
        self.button_client = QtWidgets.QPushButton(self.layoutWidget)
        self.button_client.setObjectName("button_client")
        self.gridLayout.addWidget(self.button_client, 1, 0, 1, 1)
        self.output_pre_S_send = QtWidgets.QTextBrowser(self.layoutWidget)
        self.output_pre_S_send.setObjectName("output_pre_S_send")
        self.gridLayout.addWidget(self.output_pre_S_send, 3, 4, 1, 1)
        self.label_connect = QtWidgets.QLabel(self.layoutWidget)
        self.label_connect.setAlignment(QtCore.Qt.AlignCenter)
        self.label_connect.setObjectName("label_connect")
        self.gridLayout.addWidget(self.label_connect, 0, 2, 1, 1)
        self.label_ip = QtWidgets.QLabel(self.layoutWidget)
        self.label_ip.setAlignment(QtCore.Qt.AlignCenter)
        self.label_ip.setObjectName("label_ip")
        self.gridLayout.addWidget(self.label_ip, 2, 0, 1, 1)
        self.input_port = QtWidgets.QLineEdit(self.layoutWidget)
        self.input_port.setObjectName("input_port")
        self.gridLayout.addWidget(self.input_port, 2, 4, 1, 1)
        self.output_sec_S = QtWidgets.QTextBrowser(self.layoutWidget)
        self.output_sec_S.setObjectName("output_sec_S")
        self.gridLayout.addWidget(self.output_sec_S, 6, 4, 1, 1)
        self.output_sec_C = QtWidgets.QTextBrowser(self.layoutWidget)
        self.output_sec_C.setObjectName("output_sec_C")
        self.gridLayout.addWidget(self.output_sec_C, 6, 1, 1, 1)
        self.output_S_key = QtWidgets.QTextBrowser(self.layoutWidget)
        self.output_S_key.setObjectName("output_S_key")
        self.gridLayout.addWidget(self.output_S_key, 5, 4, 1, 1)
        self.button_client_connect = QtWidgets.QPushButton(self.layoutWidget)
        self.button_client_connect.setObjectName("button_client_connect")
        self.gridLayout.addWidget(self.button_client_connect, 1, 1, 1, 1)
        self.output_C_key = QtWidgets.QTextBrowser(self.layoutWidget)
        self.output_C_key.setObjectName("output_C_key")
        self.gridLayout.addWidget(self.output_C_key, 5, 1, 1, 1)
        self.button_C_getkey = QtWidgets.QPushButton(self.layoutWidget)
        self.button_C_getkey.setObjectName("button_C_getkey")
        self.gridLayout.addWidget(self.button_C_getkey, 5, 0, 1, 1)
        self.show_S_send = QtWidgets.QTextBrowser(self.layoutWidget)
        self.show_S_send.setObjectName("show_S_send")
        self.gridLayout.addWidget(self.show_S_send, 4, 4, 1, 1)
        self.input_ip = QtWidgets.QLineEdit(self.layoutWidget)
        self.input_ip.setObjectName("input_ip")
        self.gridLayout.addWidget(self.input_ip, 2, 1, 1, 1)
        self.button_C_send = QtWidgets.QPushButton(self.layoutWidget)
        self.button_C_send.setObjectName("button_C_send")
        self.gridLayout.addWidget(self.button_C_send, 4, 0, 1, 1)
        self.button_S_getkey = QtWidgets.QPushButton(self.layoutWidget)
        self.button_S_getkey.setObjectName("button_S_getkey")
        self.gridLayout.addWidget(self.button_S_getkey, 5, 2, 1, 1)
        self.show_connect = QtWidgets.QLabel(self.layoutWidget)
        self.show_connect.setAlignment(QtCore.Qt.AlignCenter)
        self.show_connect.setObjectName("show_connect")
        self.gridLayout.addWidget(self.show_connect, 0, 4, 1, 1)
        self.button_server_connect = QtWidgets.QPushButton(self.layoutWidget)
        self.button_server_connect.setObjectName("button_server_connect")
        self.gridLayout.addWidget(self.button_server_connect, 1, 4, 1, 1)
        MainWindow.setCentralWidget(self.centralwidget)
        self.menubar = QtWidgets.QMenuBar(MainWindow)
        self.menubar.setGeometry(QtCore.QRect(0, 0, 1000, 18))
        self.menubar.setObjectName("menubar")
        MainWindow.setMenuBar(self.menubar)
        self.statusbar = QtWidgets.QStatusBar(MainWindow)
        self.statusbar.setObjectName("statusbar")
        MainWindow.setStatusBar(self.statusbar)

        self.retranslateUi(MainWindow)
        QtCore.QMetaObject.connectSlotsByName(MainWindow)

    def retranslateUi(self, MainWindow):
        _translate = QtCore.QCoreApplication.translate
        MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow"))
        self.button_pre_C_send.setText(_translate("MainWindow", "通信验证"))
        self.button_S_send.setText(_translate("MainWindow", "数据发送"))
        self.label_port.setText(_translate("MainWindow", "Port"))
        self.button_server.setText(_translate("MainWindow", "Server"))
        self.button_sec_C.setText(_translate("MainWindow", "保密通信"))
        self.button_pre_S_send.setText(_translate("MainWindow", "通信验证"))
        self.show_config.setText(_translate("MainWindow", "statue"))
        self.button_sec_S.setText(_translate("MainWindow", "保密通信"))
        self.button_begin.setText(_translate("MainWindow", "初始化配置"))
        self.button_client.setText(_translate("MainWindow", "Client"))
        self.label_connect.setText(_translate("MainWindow", "连接状态"))
        self.label_ip.setText(_translate("MainWindow", "IP："))
        self.button_client_connect.setText(_translate("MainWindow", "client_connect"))
        self.button_C_getkey.setText(_translate("MainWindow", "交换密钥生成"))
        self.button_C_send.setText(_translate("MainWindow", "数据发送"))
        self.button_S_getkey.setText(_translate("MainWindow", "交换密钥生成"))
        self.show_connect.setText(_translate("MainWindow", "out_of_connection"))
        self.button_server_connect.setText(_translate("MainWindow", "server_connect"))

结果展示

可以发现共享密钥生成的部分产生的内容是一样的。下图演示为本地演示，实际可在一个局域网下的不同主机进行结果实现。每次通信都可以重新生成一个新的对称密钥进行通信。
在这里插入图片描述

eunsummeo
关注
  • 4
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
软件算法库（新增SHA256,DH算法）
03-30
我原来的软件算法库，进行了升级了，增加了dh算法，SHA256算法，并修改了原来的几个bug。这个库是原来库的升级版，完全包括原来的代码。大家以后可以下这个，就不用下原来那个了。
（计算机安全学）用Python实现DH秘钥交换协议
zhongbk的博客
04-23 2979
import math  import random    def judge_prime(p):   #素数判断      if p &lt;= 1:          return False      i = 2      while i * i &lt;= p:          if p % i == 0:              return False          i += ...
密钥交换算法 之 DH ECDH ECDHE原理与Python实现_pycharm实现dh密钥交换
最新发布
2401_84972676的博客
05-14 1029
给定一个有限群G，其生成元为g，以及群G中的一个元素h，离散对数问题要求找到一个整数x，使得 g^x = h 在群G中成立。这里的x就是h关于底数g的离散对数。在更加直观的数学术语中，如果我们考虑模p的乘法群（其中p是质数），问题可以表述为：给定两个元素g和h，找到一个整数x，使得 g^x ≡ h (mod p)。
Linux 中用 dh_make 将 Qt + CMake 项目打包为 deb 文件
03-27 5207
文章目录步骤流程详细说明源码包名有个格式规定配置环境变量dh_make 生成 debian 目录修改 `debian/changelog`修改 `debian/control `修改 `debian/copyright`dh_make 的参数含义dpkg-buildpackage 生成 deb 包lintian 检查包dpkg-deb 查看 deb 的安装路径其它有用命令系列地址 简 述: 在 Ubuntu 20.04 中，将基于 Qt5 + CMake 的个人项目 PicShot ，通过 dh_make
【NodeJS】NodeJS基本模块学习笔记
DreamSeeker_1314的博客
07-16 371
       由于Node.js把JavaScript引入了服务器端，因此，原来必须使用PHP/Java/C#/Python/Ruby等其他语言来开发服务器端程序，现在可以使用Node.js开发了！用Node.js开发Web服务器端，有几个显著的优势： 一是后端语言也是JavaScript，以前掌握了前端JavaScript的开发人员，现在可以同时编写后端代码； 二是前后端统一使用JavaSc...
DH密钥交换算法的python实现——Diffie–Hellman key exchange
monster663的博客
07-29 4906
DH交换算法简介 Deffie-Hellman(简称 DH) 密钥交换是最早的密钥交换算法之一，它使得通信的双方能在非安全的信道中安全的交换密钥，用于加密后续的通信消息。 Whitfield Diffie 和 Martin Hellman 于 1976 提出该算法，之后被应用于安全领域，比如 Https 协议的 TLS(Transport Layer Security) 和 IPsec 协议的 IKE(Internet Key Exchange) 均以 DH 算法作为密钥交换算法。 DH算法
用Python养一只DHT爬虫
weixin_33905756的博客
02-27 843
DHT是什么 DHT全称叫分布式哈希表(Distributed Hash Table)，是一种分布式存储方法。在不需要服务器的情况下，每个客户端负责一个小范围的路由，并负责存储一小部分数据，从而实现整个DHT网络的寻址和存储。 各种博客已经有很多关于DHT介绍，这里就不详细列举了 加入DHT网络可以做什么 老司机开车(神秘代码) P2P资源共享 DHT网络的其中一种协议实现(Kademli...
大数算法_python_
10-02
本项目中的"大数算法_python_"显然关注的是如何用Python有效地实现大数的算术操作，包括加法、减法、乘法和除法，以及涉及到加密通信的Diffie-Hellman（DH）公钥算法。 1. **大数运算**：Python的内置类型`int`允许...
毕设论文（毕业论文模板）：基于Python、DH与DES算法的校园即时消息通讯软件的设计和实现
04-01
最后本软件采用Python语言实现，在软件界面设计上采用Tkinter图形界面包，对用户密码进行加密采用MD5算法，在密钥交换中采用DH算法，对即时消息内容的加密和解密采用DES算法，网络通信采用Socket技术。。本校园即时...
DiffieHellman:Python Diffie-Hellman算法实现
04-11
**迪菲-赫尔曼（Diffie...总的来说，迪菲-赫尔曼密钥交换算法为网络安全提供了基础，它在各种加密通信和安全协议中扮演着至关重要的角色。尽管面临新的威胁，但其原理和实现方式仍然是理解和学习现代密码学的关键部分。
密码学实验报告_python版本.7z
05-13
在公钥密码体制方面，实验报告探讨了DH（Diffie-Hellman）协议，这是一种密钥交换协议，允许两个通信方在不安全的信道上安全地协商一个共享密钥。实验可能包括了大素数选择、计算公钥和私钥以及密钥交换的步骤。 ...
一个简单的dh加密算法实现
04-26
简单的DH加密算法程序，采用C语言实现，权当学习资料使用； 一共7个函数，加上一个主程序实现； 不用makefile文件编写，直接一个文件编译执行
基于socket通信的javaDH通信实现
02-09
基于socket通信的javaDH通信实现，采用最基础的思路和算法进行多个客户端的通信的以及加解密的实现。
Python库 | pyOpenSSL-0.12-py2.6-win32.egg
02-21
pyOpenSSL库允许开发者在Python应用程序中实现这些协议，从而创建安全的HTTPS连接，实现服务器和客户端之间的安全通信。 **主要功能** 1. **证书管理**：pyOpenSSL提供了处理X.509证书的能力，包括生成、读取、...
python使用Crypto库实现加密解密
huaweichenai的博客
01-11 8169
python使用Crypto库实现加密解密
Python crypto模块实现RSA和AES加密解密
热门推荐
weixin_43790276的博客
09-01 2万+
Python crypto模块实现RSA和AES加密解密 Python的crypto是用于RSA加密解密，AES加密解密的。 一、RSA和AES简介 RSA加密算法是一种非对称加密算法。RSA 是1977年由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）一起提出的。RSA就是他们三人姓氏开头字母拼在一起组成的。...
加解密篇 - 非对称加密算法 (RSA、DSA、ECC、DH)
BlackWell 的博客
02-17 7447
转载自：Tony-老师 https://blog.csdn.net/u014294681/article/details/86705999 版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
Python实现DH密钥协议
熊與貓v
04-22 3738
import random import math def isprime() : #判断是否素数，直至输入为素数为止 count = 1 while count: n = int(input("输入一个质数(p)：")) for i in range(2, n): if n % i == 0: ...
DH 加密算法的使用
Hwaphon
08-12 1万+
DH 算法的介绍上面介绍的 DES,3DES,AES 算法都是对称密码算法，所谓对称，在上面也解释了，就是加密和解密的过程中使用相同的密钥 。而现在将要介绍的是 DH 算法，属于非对称密码算法，根据对称密码的概念，很容易知道，非对称密码算法就是解密和加密过程中使用不同密钥的算法。对称密码算法有什么局限呢？由于加密和解密使用相同的数据，所以我们在发送密文的同时，需要将密钥发送给对方，这个时候假如我们的
DH算法python代码实现
06-10
下面是Python实现DH算法的示例代码： ```python import random # 素数p和底数g p = 23 g = 5 # 随机生成私钥a和b a = random.randint(1, p-1) b = random.randint(1, p-1) # 计算A和B A = pow(g, a, p) B = pow...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值