第五周学习

梦择懿

已于 2023-11-29 22:20:51 修改

阅读量775

点赞数 18

文章标签：学习网络服务器

于 2023-11-26 16:54:08 首次发布

本文链接：https://blog.csdn.net/m0_60625735/article/details/134629808

版权

密码部分

pycharm

python调库实现64位加解密。

在Python中，有多个库可以用于实现64位加解密。以下是使用PyCryptodome库进行示例的代码：

首先，确保已安装PyCryptodome库。可以使用以下命令来安装：

使用64位的加密算法，可以考虑使用其他算法，比如DES算法。DES算法使用8字节的密钥长度，可以实现64位的加解密。

以下是使用PyCryptodome库进行DES加解密的示例代码：

代码由GPT提供

from Crypto.Cipher import DES
from Crypto.Util.Padding import pad, unpad
from Crypto.Random import get_random_bytes

def encrypt(key, data):
    cipher = DES.new(key, DES.MODE_ECB)
    ciphertext = cipher.encrypt(pad(data, DES.block_size))
    return ciphertext

def decrypt(key, ciphertext):
    cipher = DES.new(key, DES.MODE_ECB)
    data = unpad(cipher.decrypt(ciphertext), DES.block_size)
    return data

# 生成随机的64位密钥
key = get_random_bytes(8)

# 选择加密或解密
choice = input("请选择加密或解密 (encrypt/decrypt): ")

if choice == "encrypt":
    # 输入要加密的数据
    data = input("请输入要加密的数据: ").encode()

    # 加密数据
    encrypted_data = encrypt(key, data)
    print('加密后的数据:', encrypted_data)

elif choice == "decrypt":
    # 输入要解密的数据
    ciphertext = input("请输入要解密的数据: ").encode()

    # 解密数据
    decrypted_data = decrypt(key, ciphertext)
    print('解密后的数据:', decrypted_data)

else:
    print("无效的选择。请选择 encrypt 或 decrypt。")

效果如图

CTF show

crypto2

JSFuck是一种基于JavaScript的编码技术，它通过使用极少量的字符来表示完整的JavaScript代码。它的原理是利用JavaScript中的一些基本操作符和全局对象来构建完整的代码逻辑。

crypto3

aaencode是一种JavaScript代码混淆工具，用于将JavaScript代码转换为一串难以阅读和理解的字符。解密aaencode编码的代码需要使用特定的解码器。

这里可能会出错，页面编码显示问题如图

原本应该是

控制台输入密文回车即可

crypto4

RSA算法是一种非对称加密算法，它使用两个密钥：公钥和私钥。这些密钥是成对生成的，其中一个用于加密，另一个用于解密。

下面是RSA算法的基本步骤：

选择两个不同的质数 $p$ 和 $q$ ，计算它们的乘积 $\times q$ 。 $N$ 将作为RSA的模数。
计算欧拉函数 $\phi(N)$ ，它等于 $\times (q-1)$ 。
选择一个整数 $e$ ，满足 $\phi(N)$ ，且 $e$ 与 $\phi(N)$ 互质。 $e$ 将作为公钥的一部分。
计算私钥 $d$ ，使得 $\times e \equiv 1 \mod \phi(N)$ 。可以使用扩展的欧几里得算法来找到 $d$ 的值。
公钥是一个由 $N$ 和 $e$ 组成的公钥对 $(N, e)$ 。
私钥是一个由 $N$ 和 $d$ 组成的私钥对 $(N, d)$ 。

加密过程：

要加密一个消息 $M$ ，将其转换为一个整数 $m$ ，满足 $\leq m < N$ 。
使用公钥 $(N, e)$ ，计算密文 $C$ ： $C = m^e \mod N$ 。

解密过程：

要解密密文 $C$ ，使用私钥 $(N, d)$ ，计算原始消息 $M$ ： $M = C^d \mod N$ 。

import math

def extended_gcd(a, b):
    if b == 0:
        return a, 1, 0
    else:
        gcd, x, y = extended_gcd(b, a % b)
        return gcd, y, x - (a // b) * y

def calculate_private_key(p, q, e):
    n = p * q
    phi_n = (p - 1) * (q - 1)
    _, d, _ = extended_gcd(e, phi_n)
    d = d % phi_n
    return d

# 用户输入参数
p = int(input("请输入素数 p: "))
q = int(input("请输入素数 q: "))
e = int(input("请输入公钥 e: "))

private_key = calculate_private_key(p, q, e)
print("私钥 (d):", private_key)

python代码

crypto5

同样是RSA加密，这次求明文

import math

def gcd(a, b):
    if b == 0:
        return a
    return gcd(b, a % b)

def extended_gcd(a, b):
    if b == 0:
        return a, 1, 0
    d, x, y = extended_gcd(b, a % b)
    return d, y, x - (a // b) * y

def mod_inverse(a, m):
    d, x, _ = extended_gcd(a, m)
    if d == 1:
        return (x % m + m) % m
    raise ValueError("逆元不存在。")

def rsa_decrypt(ciphertext, private_key):
    n, d = private_key
    return pow(ciphertext, d, n)

def main():
    p = int(input("请输入 p 的值："))
    q = int(input("请输入 q 的值："))
    e = int(input("请输入 e 的值："))
    c = int(input("请输入密文："))

    n = p * q
    phi_n = (p - 1) * (q - 1)

    if gcd(e, phi_n) != 1:
        raise ValueError("e 和 phi(n) 不互质。")

    d = mod_inverse(e, phi_n)
    private_key = (n, d)

    plaintext = rsa_decrypt(c, private_key)
    print("明文：", plaintext)

if __name__ == "__main__":
    main()

crypto6

rabbit加密

Rabbit加密是一种对称加密算法，它使用了一个变种的分组密码结构。Rabbit算法的设计目标是在保持较高的加密强度的同时，提供更高的加密速度。

Rabbit算法使用了一个128位的密钥和一个64位的初始化向量（IV）。它将密钥和IV作为输入，生成一个伪随机数流，并使用该流对明文进行异或操作，从而实现加密和解密。

Rabbit算法的核心是一个基于非线性的函数，该函数接受一个128位的输入块和一个128位的密钥，生成一个128位的输出块。这个函数被迭代使用，以生成伪随机数流。

密钥为Rabbit

crypto7

Ook!加密是一种基于Ook!语言的加密方法。Ook!是一种简单的编程语言，由三个关键字组成：Ook.、Ook?和Ook!。在Ook!加密中，我们使用Ook!语言来表示明文，并通过一系列规则将其转换为密文。

下面是一些基本的Ook!加密规则：

每个Ook!指令由两个Ook!关键字组成，用空格分隔。

每个Ook!指令以"Ook."开头，并以"Ook!"结尾。

"Ook."指令表示0，"Ook?"指令表示1。

将明文转换为二进制表示。

将二进制表示的明文转换为Ook!语言表示。例如，0可以表示为"Ook. Ook.“，1可以表示为"Ook. Ook!”。

将Ook!语言表示的明文按照规则连接起来形成密文。

crypto8

Brainfuck是一种极简的编程语言，由八个指令组成：“>”, “<”, “+”, “-”, “.”, “,”, “[”, “]”。Brainfuck加密是一种使用Brainfuck语言来对明文进行加密的方法。

下面是一些基本的Brainfuck加密规则：

将明文转换为ASCII码表示。

将ASCII码表示的明文转换为Brainfuck语言表示。例如，字母"A"的ASCII码是65，可以表示为"++++++++[>++++++++<-]>."。

将Brainfuck语言表示的明文按照规则连接起来形成密文。

crypto9

文件时一个.zip压缩包，解压需要密码，使用ARCHPR爆破

爆破成功4132

得到一个.dat文件，是serpent加密

crypto10

Quoted-Printable是一种用于在电子邮件和其他文本传输协议中表示非ASCII字符的编码方法。它允许将非ASCII字符转换为一系列ASCII字符，以便在传输过程中保持数据的可靠性。

Quoted-Printable编码的基本规则如下：

ASCII字符（0-127）保持不变，不需要进行编码。

非ASCII字符被转换为"="后跟两位十六进制表示的ASCII码。

换行符（ASCII码10）和回车符（ASCII码13）保持不变。

若一行的长度超过了规定的最大长度（通常是76个字符），则在行尾添加"="符号，并在下一行继续编码。

import quopri

def quoted_printable_encode(text):
    encoded_text = quopri.encodestring(text.encode('utf-8'))
    return encoded_text.decode('utf-8')

def quoted_printable_decode(encoded_text):
    decoded_text = quopri.decodestring(encoded_text.encode('utf-8'))
    return decoded_text.decode('utf-8')

# 提示用户选择编码还是解码
choice = input("请选择操作（输入'E'进行编码，输入'D'进行解码）：")

if choice.lower() == 'e':
    # 编码操作
    text = input("请输入要编码的内容：")
    encoded_text = quoted_printable_encode(text)
    print("编码结果：", encoded_text)
elif choice.lower() == 'd':
    # 解码操作
    encoded_text = input("请输入要解码的内容：")
    decoded_text = quoted_printable_decode(encoded_text)
    print("解码结果：", decoded_text)
else:
    print("无效的选择！")



xt = input("请输入要编码的内容：")
    encoded_text = quoted_printable_encode(text)
    print("编码结果：", encoded_text)
elif choice.lower() == 'd':
    # 解码操作
    encoded_text = input("请输入要解码的内容：")
    decoded_text = quoted_printable_decode(encoded_text)
    print("解码结果：", decoded_text)
else:
    print("无效的选择！")