加密通信 实验

已于 2024-05-15 19:10:58 修改
阅读量2.3k 收藏 64
点赞数 54
文章标签： 网络
于 2024-05-15 19:08:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43580791/article/details/138919712
版权

加密通信 实验

作业罢了。

实验内容

  • 学习理解网络通信

  • 学习数据加密和解密

  • 开发网络通信的客户端程序、服务器端程序，实现客户端将传输的网络数据进行加密、服务器端将收到的加密数据进行解密，在客户端和服务器端间传输加密数据。需要对比发送的数据、接受的数据是否一致，验证网络传输的正确性；需要对比两端的明文数据、密文数据是否一致，验证加密、解密的正确性。

本文使用套接字 + 多线程的方式完成服务器通信，编程语言为Python。

本文使用TEA加密算法进行加解密。

Socket

Socket 是一种网络通信的基础机制，用于在不同计算机之间传输数据。Socket 提供了一个在网络上进行数据通信的端点，通过它可以实现客户端与服务器之间的通信。

Socket 就像一个电话插孔（“插座”），它允许一台计算机与另一台计算机进行通信。在网络编程中，Socket 是一种抽象的表示，它包括了 IP 地址和端口号。通过 Socket，程序可以向网络上的另一台计算机发送数据或者接收数据。

如有疏漏，期待指出。

Socket 的类型

Socket 根据协议类型主要分为两类：

  1. 流式套接字（SOCK_STREAM）：使用 TCP（Transmission Control Protocol）协议，提供面向连接的稳定数据传输。

  2. 数据报套接字（SOCK_DGRAM）：使用 UDP（User Datagram Protocol）协议，提供无连接的数据传输。

本文主要讲解基于 TCP 协议的流式套接字。变成部分基于Python的Socket库。

首先梳理服务器端和客户端Socket从创建到关闭的过程。

服务器端

服务器端的套接字：创建、绑定、监听、接受、读写、关闭。

形象地描述一下服务器端。服务器端就相当于是一家之主，邀请客人来做客。创建套接字就相当于创建了一个人。绑定IP和端口就是让这个人去到一扇对外的大门前，和这扇大门“绑定”。监听就相当于这个人一直盯着门口，看看有没有客人来。一旦监听到这个门有客人来敲门，就可以选择开门接受连接。接受连接后，便可以进行读写，互相交流。兴致尽矣，便是送客，关闭连接。

创建一个套接字，给它绑定上IP和端口，然后开始监听这个IP和端口。如果IP正确的客户端向这个端口发来连接请求，那么套接字就会接受这个请求，并与客户端开始读写数据。直到双方关闭连接。

  1. 创建套接字（socket()）：

    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    • AF_INET 表示使用 IPv4 地址。
    • SOCK_STREAM 表示使用 TCP 协议。

  2. 绑定地址（bind()）：

    server_socket.bind(('IP_ADDRESS', PORT))
    • 绑定 IP 地址和端口号，使得服务器可以在指定地址和端口上监听客户端请求。

  3. 监听连接（listen()）：

    server_socket.listen(BACKLOG)
    • 开始监听端口，BACKLOG 指定等待连接的最大数量。

  4. 接受连接（accept()）：

    client_socket, client_address = server_socket.accept()
    • 阻塞等待客户端连接，一旦有客户端连接请求，就建立连接，并返回一个新的套接字对象 client_socket 以进行通信。

  5. 读写数据（read()/write()）：

    data = client_socket.recv(BUFFER_SIZE)
client_socket.sendall(response_data)
    • 使用 recv() 接收客户端数据，使用 sendall() 发送数据给客户端。

  6. 关闭连接（close()）：

    client_socket.close()
server_socket.close()
    • 关闭客户端和服务器端的套接字连接。

客户端

客户端的套接字：创建、连接、读写、关闭。

客户端和服务器端的区别在于，它不需要监听和接受。这也很容易理解，因为客户端是客人，服务器端是主人，主人需要时刻注意（监听）着门口有没有人，而客人只需要敲门连接就行了。

创建一个套接字，然后向服务器端发送连接请求。如果服务器端接受请求，那么将开始读写数据，直到关闭。

  1. 创建套接字（socket()）：

    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    • 同服务器端的创建方式。

  2. 连接服务器（connect()）：

    client_socket.connect(('SERVER_IP_ADDRESS', PORT))
    • 连接服务器端的 IP 地址和端口号。
    • connect是主动发起连接，服务器端的accept是被动接受连接。

  3. 读写数据（write()/read()）：

    client_socket.sendall(request_data)
response = client_socket.recv(BUFFER_SIZE)
    • 使用 sendall() 发送数据给服务器，使用 recv() 接收服务器的数据。

  4. 关闭连接（close()）：

    client_socket.close()
    • 关闭客户端的套接字连接。

完整示例代码

服务器端代码：

import socket

def server_program():
    # 创建套接字
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 绑定IP地址和端口
    # 注意，IP地址为空，意味着接受来自所有IP的请求
    server_socket.bind(('', 12345))
    # 监听连接
    server_socket.listen(5)
    
    print("服务器正在监听...")
    
    # 接受连接
    client_socket, client_address = server_socket.accept()
    print(f"连接来自: {client_address}")
    
    # 接收和发送数据
    while True:
        data = client_socket.recv(1024)
        if not data:
            break
        print(f"客户端说：{data.decode()}")
        client_socket.sendall(data)
    
    # 关闭连接
    client_socket.close()
    server_socket.close()

if __name__ == '__main__':
    server_program()

客户端代码：

import socket

def client_program():
    # 创建套接字
    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 连接服务器
    client_socket.connect(('127.0.0.1', 65432))
    
    # 发送和接收数据
    message = "我们连接上了捏！"
    client_socket.sendall(message.encode())
    
    data = client_socket.recv(1024)
    print(f"服务器说：{data.decode()}")
    
    # 关闭连接
    client_socket.close()

if __name__ == '__main__':
    client_program()

以上代码是客户端与服务器的通信，由于是单线程的，所以服务器端同时只能接受一个客户的连接，无法做到接受并发的多客户数据。

所以，接下来引入多线程，使用Python的threading库。

Threading

什么是线程？

线程是计算机科学中的一个基本概念，它是比进程更小的执行单元。一个进程可以包含多个线程，每个线程都共享进程的资源，如内存、文件描述符等。线程的引入是为了提高程序的并发性，利用多核处理器的优势。

简单地说，线程就像是一家公司的多个员工，每个员工都可以同时工作，完成不同的任务，而这些员工共享公司提供的资源，比如办公室、电脑和文具。公司（进程）是一个整体，而员工（线程）是这个整体中的个体，他们协同工作以完成更大的目标。

而多线程是指在同一个进程中同时运行多个线程。这些线程独立执行，但共享进程的资源。通过多线程，程序可以在同一时间处理多个任务，从而提高效率和响应速度。

举个例子，假设你在一家快餐店工作，你需要同时处理多个订单。你可以一个一个地处理订单，这样的话，顾客可能会等得不耐烦。或者，你可以雇用多名员工，每个人处理一个订单，这样所有订单可以同时进行处理，顾客的等待时间就会大大减少。（这例子是chatGPT写得）

多线程能做到什么？

多线程主要有以下几个优势：

  1. 提高程序的并发性和响应速度：
    多线程可以使程序在处理多个任务时更加高效。例如，一个 Web 服务器可以使用多线程来同时处理多个客户端的请求，而不会因为一个请求而阻塞其他请求。

  2. 更好地利用多核处理器的性能：
    在现代计算机中，多核处理器非常普遍。多线程可以让程序在多个核心上并行运行，从而充分利用硬件资源，提高程序的执行效率。

  3. 提高程序的灵活性和可扩展性：
    多线程可以让程序更灵活地处理复杂任务。例如，一个复杂的数据处理程序可以将不同的数据处理任务分配给不同的线程，从而更高效地完成任务。

在详细阐明了线程和多线程的概念之后，我们接下来将进入代码部分，讲解如何在 Python 中实现多线程服务器和客户端通信。

编程实践

在本节中，我们将基于之前的单线程示例，使用 Python 的 threading 库实现多线程的服务器和客户端通信。通过引入多线程，服务器能够同时处理多个客户端的连接请求，提高并发性和响应速度。

多线程服务器实现

我们需要修改服务器端代码，使其能够处理多个客户端的连接。我们将为每个客户端连接创建一个新线程，以便并发处理每个客户端的请求。

首先，因为会有很多客人来连接，所以我们的accept部分需要进行无限循环。每accept一次，就要创建一个新的线程。

形象地讲（这不是chatGPT写得），主人每接收到一个客人，就创建一个分身（线程），让这个分身去执行接待客人，也就是收发数据。

    while True:
        # 接受客户端连接
        client_socket, client_address = server_socket.accept()

        # 创建新线程处理客户端连接
        client_thread = threading.Thread(target=handle_client, args=(client_socket, client_address))
        client_thread.start()

线程创建后需要调用.start()启动。

我们发现这种创建线程的语法接受两个参数：target和args。

client_thread = threading.Thread(target=handle_client, args=(client_socket, client_address))

其中target是线程（分身）需要去执行的函数，在这里就是收发数据的函数，也就是handle_client函数。这个函数会负责招待客人（收发数据）。而args就是target函数所需要的变量传参。

# 处理客户端连接的函数
def handle_client(client_socket, client_address):
    print(f"新连接：{client_address}")
    while True:
        try:
            # 接收数据
            data = client_socket.recv(1024)
            if not data:
                break
            print(f"来自 {client_address} 的消息：{data.decode()}")
            # 回传数据
            client_socket.sendall(data)
        except ConnectionResetError:
            break
    # 关闭客户端连接
    client_socket.close()
    print(f"连接断开：{client_address}")

多线程服务器代码：

import socket
import threading

# 处理客户端连接的函数
def handle_client(client_socket, client_address):
    print(f"新连接：{client_address}")
    while True:
        try:
            # 接收数据
            data = client_socket.recv(1024)
            if not data:
                break
            print(f"来自 {client_address} 的消息：{data.decode()}")
            # 回传数据
            client_socket.sendall(data)
        except ConnectionResetError:
            break
    # 关闭客户端连接
    client_socket.close()
    print(f"连接断开：{client_address}")

def server_program():
    # 创建套接字
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 绑定IP地址和端口
    server_socket.bind(('0.0.0.0', 12345))
    # 监听连接
    server_socket.listen(5)
    
    print("服务器正在监听...")

    while True:
        # 接受客户端连接
        client_socket, client_address = server_socket.accept()
        # 创建新线程处理客户端连接
        client_thread = threading.Thread(target=handle_client, args=(client_socket, client_address))
        client_thread.start()

if __name__ == '__main__':
    server_program()

在这个多线程服务器代码中，我们做了以下修改：

  1. 创建线程处理客户端连接：
    每当有新的客户端连接请求时，我们创建一个新线程，调用 handle_client 函数来处理该连接。

  2. 处理客户端连接的函数 handle_client：
    在这个函数中，我们接收和发送数据。每个客户端连接都在独立的线程中运行，确保同时处理多个客户端请求。

多线程客户端实现

客户端代码不需要太多修改，因为它本身并不需要处理并发请求。不过，为了测试服务器的多线程能力，我们可以启动多个客户端连接。

多线程客户端代码：

import socket

def client_program():
    # 创建套接字
    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 连接服务器
    client_socket.connect(('127.0.0.1', 12345))
    
    try:
        while True:
            # 发送消息
            message = input("请输入要发送的信息：")
            if message.lower() == 'exit':
                break
            client_socket.sendall(message.encode())
            
            # 接收服务器的回传消息
            data = client_socket.recv(1024)
            print(f"服务器回应：{data.decode()}")
    finally:
        # 关闭连接
        client_socket.close()

if __name__ == '__main__':
    client_program()

测试多线程服务器

要测试多线程服务器，我们可以启动服务器程序，并在多个终端窗口中运行客户端程序。这样可以模拟多个客户端同时连接服务器，并验证服务器能否正确处理并发连接。

  1. 启动服务器：
    在一个终端窗口中运行服务器程序：

    python server_program.py

  2. 启动多个客户端：
    在其他终端窗口中运行多个客户端程序：

    python client_program.py

  3. 测试通信：

    在客户端程序中输入消息，并观察服务器端的输出，验证服务器是否正确接收并回应每个客户端的消息。

通过多线程的实现，服务器能够同时处理多个客户端的连接请求，提高了系统的并发能力和响应速度。

引入TEA加密

接下来，我们将引入 TEA 加密算法，对客户端和服务器之间传输的数据进行加解密，以确保通信的安全性。

加密算法部分可自行选择替换，选一种自己认为安全的，或者选几种进行对比。

TEA加密算法

TEA（Tiny Encryption Algorithm）是一种简单高效的对称加密算法。它使用一个128位的密钥，进行多轮数据加密操作。TEA 算法的主要特点是速度快、实现简单，非常适合嵌入式系统和资源受限的环境。

在这里插入图片描述

TEA加解密实现：

import struct

# TEA 加密函数
def tea_encrypt(plain_text, key):
    delta = 0x9e3779b9
    v0, v1 = struct.unpack('>2L', plain_text)
    k = struct.unpack('>4L', key)
    sum = 0
    for _ in range(32):
        sum += delta
        v0 += ((v1 << 4) + k[0]) ^ (v1 + sum) ^ ((v1 >> 5) + k[1])
        v1 += ((v0 << 4) + k[2]) ^ (v0 + sum) ^ ((v0 >> 5) + k[3])
    return struct.pack('>2L', v0, v1)

# TEA 解密函数
def tea_decrypt(cipher_text, key):
    delta = 0x9e3779b9
    v0, v1 = struct.unpack('>2L', cipher_text)
    k = struct.unpack('>4L', key)
    sum = delta * 32
    for _ in range(32):
        v1 -= ((v0 << 4) + k[2]) ^ (v0 + sum) ^ ((v0 >> 5) + k[3])
        v0 -= ((v1 << 4) + k[0]) ^ (v1 + sum) ^ ((v1 >> 5) + k[1])
        sum -= delta
    return struct.pack('>2L', v0, v1)

通过引入 TEA 加密算法，我们实现了对客户端和服务器之间传输的数据进行加解密处理，确保了通信的安全性。这样，我们不仅能够实现多线程的并发处理，还能够保证通信的机密性和完整性。

最终成品

上述代码还有点缺点：

  1. 客户端发送的信息只有服务器能看见，其它客户看不见。
  2. 每个客户端和服务器只能一问一答，极其混乱。
  3. 无法指定服务器IP。
  4. 没有昵称，极其无聊。
  5. TEA算法代码和服务器/客户端混到一起了。

解决方案：

  1. 服务器增加广播机制，把信息广播给所有人。
  2. 客户端同时启动收发线程。
  3. 单独设置变量，指定服务器IPv4。
  4. 加入昵称，并广播昵称。
  5. 单独构建my_crypt.py并在服务器/客户端中import，更方便替换加解密算法。

使用方法：

把server.py和my_crypt.py放在服务端同一目录下；把user.py和my_crypt.py放在客户端同一目录下，即可运行。

最终代码

server.py

import socket
import threading
from my_crypt import encrypt, decrypt

# 设置TEA加密密钥
key = b'1234567890abcdef'

# 客户端线程处理函数
def client_thread(conn, addr, clients, nicknames):
    # 接收客户端发送的昵称
    encrypted_nickname = conn.recv(1024)
    nickname = decrypt(encrypted_nickname, key).decode('utf-8')
    
    # 存储用户和用户名
    clients.append(conn)
    nicknames[conn] = nickname
    
    # 广播用户加入消息
    welcome_message = f"{nickname} 加入了聊天室！"
    conn.send(encrypt(welcome_message.encode('utf-8'), key))
    broadcast(welcome_message, conn, clients, nicknames)

    while True:
        try:
            encrypted_message = conn.recv(1024)
            message = decrypt(encrypted_message, key).decode('utf-8')
            if message:
                # 广播用户消息
                formatted_message = f"{nickname} 说: {message}"
                print(formatted_message)
                broadcast(formatted_message, conn, clients, nicknames)
            else:
                # 处理断开连接
                remove(conn, clients, nicknames)
                break
        except:
            continue

# 广播消息到所有客户端
def broadcast(message, connection, clients, nicknames):
    encrypted_message = encrypt(message.encode('utf-8'), key)
    for client in clients:
        if client != connection:
            try:
                client.send(encrypted_message)
            except:
                remove(client, clients, nicknames)

# 从列表中移除客户端
def remove(connection, clients, nicknames):
    if connection in clients:
        leave_message = f"{nicknames[connection]} 离开了聊天室。"
        broadcast(leave_message, connection, clients, nicknames)  # 广播用户离开消息
        clients.remove(connection)
        del nicknames[connection]
        connection.close()

# 服务器主程序
def server_program():
    host = ''
    port = 12345
    clients = []
    nicknames = {}
    
    # 创建，绑定，监听
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.bind((host, port))
    server_socket.listen(100)
    
    while True:
        # 接受新的连接并启动线程
        conn, addr = server_socket.accept()
        threading.Thread(target=client_thread, args=(conn, addr, clients, nicknames)).start()

if __name__ == '__main__':
    server_program()

user.py

import socket
import threading
from my_crypt import encrypt, decrypt

# 设置TEA加密密钥
key = b'1234567890abcdef'

# 发送消息线程
def send_msg(client_socket, nickname):
    while True:
        message = input()
        encrypted_message = encrypt(message.encode('utf-8'), key)
        client_socket.send(encrypted_message)
        if message.lower().strip() == 'bye':
            client_socket.close()
            break

# 接收消息线程
def receive_msg(client_socket):
    while True:
        try:
            encrypted_data = client_socket.recv(1024)
            if not encrypted_data:
                break
            data = decrypt(encrypted_data, key).decode('utf-8')
            print(data)  # 直接打印接收到的消息
        except:
            print("已断开连接")
            break

# 客户端主程序
def client_program():
    host = input("请输入服务器的IPv4地址: ")
    port = 12345
    nickname = input("请输入您的昵称：")
    
    # 创建，连接
    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    client_socket.connect((host, port))
    print("连接成功！")

    # 发送昵称到服务器
    encrypted_nickname = encrypt(nickname.encode('utf-8'), key)
    client_socket.send(encrypted_nickname)

    # 创建收发线程
    threading.Thread(target=send_msg, args=(client_socket, nickname)).start()
    threading.Thread(target=receive_msg, args=(client_socket,)).start()

if __name__ == '__main__':
    client_program()

my_crypt.py

import struct

# PKCS7 填充函数
def pad(data):
    padding_length = 8 - len(data) % 8
    return data + bytes([padding_length] * padding_length)

# PKCS7 去填充函数
def unpad(data):
    padding_length = data[-1]
    return data[:-padding_length]

# TEA 加密函数
def encrypt(plain_text, key):
    plain_text = pad(plain_text)
    cipher_text = b''
    delta = 0x9e3779b9
    k = struct.unpack('>4L', key)
    for i in range(0, len(plain_text), 8):
        v0, v1 = struct.unpack('>2L', plain_text[i:i+8])
        sum = 0
        for _ in range(32):
            sum = (sum + delta) & 0xffffffff
            v0 = (v0 + ((v1 << 4) + k[0] ^ v1 + sum ^ (v1 >> 5) + k[1])) & 0xffffffff
            v1 = (v1 + ((v0 << 4) + k[2] ^ v0 + sum ^ (v0 >> 5) + k[3])) & 0xffffffff
        cipher_text += struct.pack('>2L', v0, v1)
    return cipher_text

# TEA 解密函数
def decrypt(cipher_text, key):
    plain_text = b''
    delta = 0x9e3779b9
    k = struct.unpack('>4L', key)
    for i in range(0, len(cipher_text), 8):
        v0, v1 = struct.unpack('>2L', cipher_text[i:i+8])
        sum = (delta * 32) & 0xffffffff
        for _ in range(32):
            v1 = (v1 - ((v0 << 4) + k[2] ^ v0 + sum ^ (v0 >> 5) + k[3])) & 0xffffffff
            v0 = (v0 - ((v1 << 4) + k[0] ^ v1 + sum ^ (v1 >> 5) + k[1])) & 0xffffffff
            sum = (sum - delta) & 0xffffffff
        plain_text += struct.pack('>2L', v0, v1)
    return unpad(plain_text)
遮天华月
关注
  • 54
    点赞
  • 踩
  • 64
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
DES加密算法实验
09-27
、实验原理 信息加密根据采用的密钥类型可以划分为对称密码算法和非对称密码算法。对称密码算法是指加密系统的加密密钥和解密密钥相同，或者虽然不同，但是可以从其中任意一个推导出另一个，更形象的说就是用同一把钥匙开锁和解锁。在对称密码算法的发展历史中曾出现过多种优秀的算法，包括DES、3DES、AES等。下面我们以DES算法为例介绍对称密码算法的实现机制。
TEA加密通信实验中使用-完善版.rar
06-28
在电子通信领域，数据安全是至关重要的...总之，通过这个"TEA加密通信实验"，开发者不仅可以学习到STM32的C语言编程，还可以深入了解加密算法的实现和嵌入式系统的通信机制。这为后续更复杂的安全通信项目奠定了基础。
嵌入式（二十五）：串行通信
君陌的博客
05-30 3040
1、一个计算机系统（独立冯·诺伊曼计算机）如何与另一个系统（可能是计算机），在满足应用要求条件下，如何简便、实用、快捷、可靠……连接起来，以使能够相互交流信息。许多场合并不需要“并行总线”，更简洁的“串行通信总线”即可。 2、串口通信基本原理：用少量的“通道”（如导线）将要传送的多个bit数据，在时间轴上“分时”传送过去，用以代替（冯·诺伊曼系统结构）计算机系统中“并行”方式工作总线（一次传送多个bit），也解决了很多 “并行”总线难以实现场合。 3、系统结构中的串行通信类模块： a、“串行类模块”属“输入
加密实验网络空间安全实验一
qq_44047806的博客
06-07 636
加密****实验 1.实验内容与环境 1.1实验内容 （1）传统加密算法的实现 用自己熟悉的编程语言，实现古典凯撒密码加解密算法，感受加解密的基本思想，并给出测试验证界面截图。 （2）PGP邮件加密与签名 参照“利用PGP实现邮件加密签名.pdf”或检索、参照其它指导性文档，安装配置PGP，实现基于PGP的邮件加密与签名，检查、验证加密与签名的有效性，体验加密与签名的安全性。用Wireshark等抓包软件获取网络传输的邮件内容，属于加分项，不作为强制性实验内容。 1.2实验环境 操作系统：Windows10
记录--信息安全实验--加密
qq_22658373的博客
05-02 2153
记录–信息安全实验–加密 一、项目设计目标与要求 1.利用凯撒密码的加密方法编写算法； 1.1、根据对凯撒密码的介绍，自己创建明文信息，编写相应密码算法的实现程序，实现加密和解密操作。（编程语言自选） 1.2、提取出要加密的字符串、密钥，将字符串中毎个字符都取出并进行移位，以实现加密和解密的功能。 2.利用CAP4运算软件比较结果； 2.2、与CAP4的运算结果进行比较，验证你的实验结果是否正确。...
信息安全实验一：DES加密算法的实现
一顿吃不饱的博客
06-28 6937
一、实验目的及要求1．熟悉加密、解密算法；懂得加密在通信中的重要作用；2．对输入的十六进制数加密（把输入的字符转化成整数），比较输入和输出，当把输入的数改变一个比特时，比较输出的变化，说明原因。3．实现对一个文件进行加解密，提交程序代码和执行结果。二、实验内容本实验通过用DES算法对实际的数据进行加密和解密来深刻了解DES的运行原理。根据所提供的程序分析DES算法的实现过程。在分析密钥生成函数、加密函数（8字节）、解密函数、测试函数和密钥长度检验函数的基础上，用C/VC++或Java语言编写程序实现对文本文
计算机网络上机实验4——加密
小憨的学习博客
04-01 304
计算机网络上机实验4——加密 利用ASCII码值进行加密，如下： 简单示例 这是一个比较简单的计算，老师提供的示例，解密也容易写出来 加密 #include <stdio.h> #include <string.h> int main() { int i; int count = 0; char Text[128] = { "time"}; char cryptograph[128] = { '\0' }; printf("请输入要加密的明文：%s\n", Tex
电信设备-基于混沌同步的加密通信实验装置及其使用方法.zip
09-18
《电信设备-基于混沌同步的加密通信实验装置及其使用方法》这一资料主要涵盖了混沌理论在通信安全领域的应用，特别是如何利用混沌同步技术实现加密通信。混沌理论是数学和物理学的一个分支，它研究的是非线性动力...
java实现的简易版网络聊天加密通信程序
08-17
2. 利用Diffie-Hellman密钥交换协议生成对称加密通信的通信密钥。 3. 为防止中间人攻击，采用RSA非对称加密算法协助DH算法完成密钥交换。具体过程如下： a. 接收者与发送者双方各自利用RSA算法生成自己的公私钥，并...
移动通信实验指导书.doc
11-16
移动通信实验指导书是通信工程专业学生学习的重要参考资料，涵盖了通信系统中的多个核心概念和技术。以下将对指导书中涉及的主要知识点进行详细阐述。 1. **伪随机序列产生实验**： - **m 序列产生**：m 序列，又...
密码学加密试验（加密算法的实现）
07-10
简单的几个密码算法的实现，希望对大家有帮助，有不足之处请多多指教！！！！
密码学_异或加密实验.zip
12-15
广工 密码学 异或实验代码；可执行 密码学_异或加密实验 C语言写得 读书
DES加密算法实验报告
12-27
自己写的DES加密算法实验报告，里面附有代码！附有代码！附有代码！
通信安全实验-AES 加密-内含源码和说明书.zip
最新发布
05-15
**通信安全实验——AES加密** 在信息技术领域，通信安全是至关重要的，特别是在互联网无处不在的今天。AES（Advanced Encryption Standard）加密算法是目前广泛应用于数据保护的标准之一，为网络通信提供了一层强大...
C语言实验 文件加密与解密
eioway的博客
04-26 6570
简单的加密与解密方法有：异或实现，ASCII码移位，ASCII码与二进制、十进制等转换。 当然还有其他更复杂的包括军事加密机制，不作论述。 本次实验我采用ASCII码与十进制转换，把每个字符强制转化为3位ASCII数字，进行加密和解密。 #include <stdio.h> #include <stdlib.h> int main() { FILE *f1...
python加密
qq_53055597的博客
01-05 117
定义你要加密的的文字 str1 = ("你说麻烦我就粉末不服就干都是乐色") str2 = ("说好不笑直接全乱哈得一批怎么样嘛") str3 = ("走在前面看到后头脚下四年到底哪个") str4 = ("见面你好更会让看没开发和以便更了") 用maketrans函数相当于一个置换密码 table1 = str.maketrans(str1,str2) table2 = str.maketrans(str2,str3) table3 = str.maketrans(str3,str4) table1_1
PGP加密并签名邮件 实验
qq_53397065的博客
12-08 6522
记录性文章，记录自己曾做过的一些网络安全实验 ：phase 1 一、实验目的 使用PGP软件对邮件加密签名，了解密码体制在实际网络环境中的应用，加深对数字签名、hash函数、公钥加密和非对称加密的理解。 二、实验环境 Windows 10操作系统；PGP-desktop 实验原理 PGP加密解密签名：使用非对称加密，用户持有一对公钥和私钥，用公钥加密文件后只能使用相应的私钥解密，使用私钥加密则持有相应公钥的人可以验证资料是否是私钥的使用者传送的。 实验内容 1.对每组同学的“学号...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值