《计算机网络简易速速上手小册》第4章：计算机网络安全基础（2024 最新版）

from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad
from Crypto.Random import get_random_bytes
def aes_encrypt_decrypt(data, key, mode=AES.MODE_CBC):
    # 加密
    cipher = AES.new(key, mode)
    ct_bytes = cipher.encrypt(pad(data.encode('utf-8'), AES.block_size))
    iv = cipher.iv
    # 解密
    cipher = AES.new(key, mode, iv=iv)
    pt = unpad(cipher.decrypt(ct_bytes), AES.block_size).decode('utf-8')
    print(f"Ciphertext: {ct_bytes}")
    print(f"Decrypted text: {pt}")
key = get_random_bytes(16)  # AES密钥长度可以是16（AES-128）、24（AES-192）或32（AES-256）字节
data = "Secret Message"
aes_encrypt_decrypt(data, key)

pip install pycryptodome

from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP
def rsa_encrypt_decrypt(data):
    # 生成密钥
    key = RSA.generate(2048)
    private_key = key.export_key()
    public_key = key.publickey().export_key()
    # 加密
    recipient_key = RSA.import_key(public_key)
    cipher_rsa = PKCS1_OAEP.new(recipient_key)
    enc_data = cipher_rsa.encrypt(data.encode('utf-8'))
    # 解密
    private_key = RSA.import_key(private_key)
    cipher_rsa = PKCS1_OAEP.new(private_key)
    dec_data = cipher_rsa.decrypt(enc_data).decode('utf-8')
    print(f"Encrypted data: {enc_data}")
    print(f"Decrypted data: {dec_data}")
data = "Secret RSA Message"
rsa_encrypt_decrypt(data)

import hashlib
def hash_data(data):
    result = hashlib.sha256(data.encode('utf-8')).hexdigest()
    print(f"The SHA-256 hash of {data} is: {result}")
data = "Secret Data"
hash_data(data)

from scapy.all import sniff, IP
def simple_firewall(packet):
    # 假定我们要阻止来自特定IP地址的流量
    blocked_ip = "192.168.1.100"
    if IP in packet and packet[IP].src == blocked_ip:
        print(f"Blocked packet from {blocked_ip}")
    else:
        print("Allowed packet")
# 使用Scapy嗅探进出的包，并应用防火墙规则
sniff(prn=simple_firewall, filter="ip", store=0)

from scapy.all import sniff, TCP
def detect_syn_flood(packet):
    if TCP in packet and packet[TCP].flags == 'S':
        print(f"Detected SYN packet from {packet[IP].src} to {packet[IP].dst}")
# 监控TCP流量，寻找大量的SYN包
sniff(prn=detect_syn_flood, filter="tcp", store=0)

import subprocess
def add_firewall_rule(src_ip):
    cmd = f"iptables -A INPUT -s {src_ip} -j DROP"
    subprocess.run(cmd.split())
    print(f"Added firewall rule to block IP: {src_ip}")
# 假设检测到192.168.1.100为可疑IP，动态添加规则以阻止其流量
add_firewall_rule("192.168.1.100")

import os
def connect_to_vpn(vpn_command):
    try:
        print("Connecting to VPN...")
        os.system(vpn_command)
        print("Successfully connected to VPN.")
    except Exception as e:
        print(f"Failed to connect to VPN: {str(e)}")
# 示例：使用openvpn命令连接到VPN
vpn_command = "openvpn --config /path/to/your/vpn/config.ovpn"
connect_to_vpn(vpn_command)

import subprocess
import time
def check_vpn_status():
    check_command = "ping -c 1 10.8.0.1"  # 假设10.8.0.1是通过VPN连接的内网IP地址
    while True:
        try:
            subprocess.check_output(check_command.split(), stderr=subprocess.STDOUT)
            print("VPN is active.")
        except subprocess.CalledProcessError:
            print("VPN is down. Attempting to reconnect...")
            connect_to_vpn("openvpn --config /path/to/your/vpn/config.ovpn")
        time.sleep(60)
check_vpn_status()

import socket
import ssl
def create_secure_tunnel():
    context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
    connection = context.wrap_socket(socket.socket(socket.AF_INET), server_hostname='hostname')
    try:
        connection.connect(('hostname', 443))  # 假设服务器监听在443端口
        print("Secure tunnel established.")
        # 可以在此处通过连接发送/接收数据
    except Exception as e:
        print(f"Failed to create secure tunnel: {str(e)}")
    finally:
        connection.close()
create_secure_tunnel()