CTF练习4

RSA加密

注：L：是与N互质的个数不是最小公倍数这里的最小公倍数指的是存在于N中(互质当N个整数的最大公因数是1时，则称这N个整数为互质）

解密：因为N与E是公开的所以要解密就要求出D，要解出D就要求出L,要求出L就要对N进行因式分解这对一个很大的整数来说是很难的所以很难。（E其实会有很多个但题目会给出其中一个）

示例：在已知两个因式下用python求解

from Crypto.Util.number import * # 导包存在于pycryptodome库里面的
e = 306645347334662727966285107364291531289 # 给出的密钥
q = 7021910101974335245794950722131367118195509913680915814438898999848788125908122655583911434165700354149914056221915541094395668546921268189522005629523759
p = 8228801334907462855397256098699556584084854642543205682719705217859576250443629616812386484797164506834582095674143447181804355696220642775619711451990971
c = 21812306272967730147845738706030680242331165675981994115949615844012361551700506020612445969402056602389411244248745130826969002161047213415607978602535719418999319494842608994479027676787499235277662156571617957720793923983451286566879014875330118016740706736991981355194846993958405444652507211603807160958
d = inverse(e,(p-1)*(q-1)) #inverse：在已知L的情况下求出解密密钥，要不然通过循环一个一个试要很久
n = p*q
m = pow(c,d,n) # pow:就是那个解密公式了
print(long_to_bytes(m))
#这样会很久
for i in range((p-1)*(q-1)):
    if (e*i)%((p-1)*(q-1)) == 1:
        print(i)

注：在from Crypto.Util.number import *中，inverse() 函数的作用主要是计算模逆元。模逆元是数论中的一个重要概念，它在密码学、加密和解密过程中有广泛的应用，具体来说，给定两个整数 a 和 m（其中 m 是正整数，且 a 和 m 互质），a 关于模 m 的逆元是一个整数 x，满足a⋅x≡1(modm)换句话说，x 是 a 在模 m 下的乘法逆元，如果 a 和 m 互质，则这样的 x 一定存在且唯一（在模 m 的意义下）

RC4加密

核心：注意在于生成密钥流与密钥流表

# -*- coding: utf-8 -*-
import base64

def get_message():
    print("输入你的信息： ")
    s = input()
    return s


def get_key():
    print("输入你的密钥： ")
    key = input()
    if key == '':
        key = "不要输入空的 key 值"
    return key


def init_box(key):
    """
    S盒
    """
    s_box = list(range(256))  # 我这里没管秘钥小于256的情况，小于256应该不断重复填充即可
    j = 0
    for i in range(256):
        j = (j + s_box[i] + ord(key[i % len(key)])) % 256
        s_box[i], s_box[j] = s_box[j], s_box[i]
    return s_box


def ex_encrypt(plain, box, mode):
    """
    利用PRGA生成秘钥流并与密文字节异或，加解密同一个算法
    """
    if mode == '2':
        while True:
            c_mode = input("输入你的解密模式：base64 or ordinary\n")
            if c_mode == 'base64':
                plain = base64.b64decode(plain)
                plain = bytes.decode(plain)  # 因为返回的是解码过的  bytes，所以需要再用 decode 解码成字符串。
                break
            elif c_mode == 'ordinary':
                break
            else:
                print("输入不合法，请重新输入")
                continue

    res = []
    i = j = 0
    for s in plain:
        i = (i + 1) % 256 #注意这里是从1开始的
        j = (j + box[i]) % 256
        box[i], box[j] = box[j], box[i]
        t = (box[i] + box[j]) % 256
        k = box[t]
        res.append(chr(ord(s) ^ k))

    cipher = "".join(res)

    if mode == '1':
        # 化成可视字符需要编码
        print("加密后的输出（没经过任何编码）")
        print(cipher)
        # base64的目的也是为了变成可见字符
        print("base64后的编码")
        print(str(base64.b64encode(cipher.encode('utf-8')), 'utf-8'))
    if mode == '2':
        print("解密后的密文")
        print(cipher)


def get_mode():
    print("请选择加密或者解密")
    print("1.Encrypt")
    print("2.Decrypt")

    mode = input()

    if mode == '1':  # 加密解密虽同源，但是由于不能直接用 =='1' or '2'，所以还是得分开写
        message = get_message()
        key = get_key()
        box = init_box(key)
        ex_encrypt(message, box, mode)
    elif mode == '2':  # 由于异或运算的对合性，RC4加密解密使用同一套算法。
        message = get_message()
        key = get_key()
        box = init_box(key)
        ex_encrypt(message, box, mode)
    else:
        print("输入有误！ ")


if __name__ == '__main__':
    while True:
        get_mode()

RC4加密是一种广泛使用的流密码算法，由美国计算机科学家罗纳德·李维斯特（Ronald Rivest）在1987年设计，但最初并未公开，因为RC4被视为商业机密。直到1994年，RC4的加密规则才被一位匿名人士公开，之后被广泛应用于各种加密场景。以下是关于RC4加密的详细介绍：

一、RC4加密算法原理

RC4加密算法的原理基于伪随机数流和异或运算。具体来说，它首先需要一个密钥K，密钥K的长度可以是5到256字节不等。通过密钥编排算法（KSA, Key Scheduling Algorithm）对密钥进行处理，生成一个256字节的密钥流S（也称为S盒）。然后，通过生成伪随机数流（Keystream），并将伪随机数流与明文进行异或运算，从而得到密文。解密过程则是将密文与相同的伪随机数流进行异或运算，以恢复出明文。

二、RC4加密算法特点

1. 运算速度快：RC4算法的实现相对简单，运行速度快，适用于资源有限的设备和环境，以及对实时性要求比较高的应用场景。
2. 对称加密：RC4算法是一种对称加密算法，使用相同的密钥进行加密和解密。
3. 可变密钥长度：RC4算法支持变长密钥，密钥长度可以在1到256字节之间，提供了较高的灵活性。
4. 无填充需求：RC4算法不需要进行填充操作，可以直接对数据进行加密。
5. 长度无限制：RC4算法对于加密/解密数据的长度没有限制，适合于加密数据流。

三、RC4加密算法应用

RC4算法由于其高效性和易用性，被广泛应用于多个领域，包括但不限于：

• 无线通信网络：如WEP（Wired Equivalent Privacy）和WPA（Wi-Fi Protected Access）协议中的加密通信。
• 网络安全协议：如SSL（安全套接字层）和TLS（传输层安全性）等协议中的加密套件。
• 数据加密：用于文件加密、数据库加密等场景。

四、RC4加密算法的安全性

尽管RC4算法在多个领域得到了广泛应用，但其安全性却存在一些问题。具体来说，RC4算法的密钥流生成过程中存在循环依赖，当密钥长度较短时，密钥流的周期也较短，容易被暴力破解。此外，RC4算法还存在相关密钥攻击、明文攻击等问题。因此，在安全性要求较高的场景中，建议使用更加安全的加密算法，如AES算法。

五、总结

RC4加密是一种基于伪随机数流和异或运算的流密码算法，具有运算速度快、对称加密、可变密钥长度等特点。然而，由于其安全性问题，RC4算法已经不再被推荐使用。在实际应用中，应根据具体的安全需求选择合适的加密算法。

RC4加密算法的缺点主要包括以下几个方面：

1. 安全性能较差

• 容易被暴力破解：RC4算法的安全性已经被证明存在漏洞，特别是在密钥长度较短时，攻击者可以通过暴力破解的方式尝试所有可能的密钥组合，从而解密数据。随着计算能力的提升，较短的密钥长度已经难以抵御现代计算资源的攻击。（来源：腾讯云 产业智变·云启未来）
• 密钥长度较短：RC4算法的密钥长度虽然可变，但通常推荐使用较长的密钥以保证安全性。然而，在实际应用中，如果密钥长度设置不当，可能会导致加密强度不足。

2. 密钥流生成过程中的问题

• 密钥流生成过程存在相关性：RC4算法的密钥流生成过程中存在相关性，当密钥长度较短时，密钥流的周期也较短，这可能会被攻击者利用来预测或重建密钥流，从而破解加密数据。
• 明文攻击的风险：RC4算法存在明文攻击的风险，即攻击者可以通过多次加密相同的明文来推算出密钥流，进而得到密钥和明文。这种攻击方式对于某些应用场景来说是非常危险的。

3. 实际应用中的局限性

• 不再被推荐使用：由于RC4算法存在上述安全性问题，许多现代安全标准和规范已经不再推荐使用RC4算法进行数据加密。例如，TLS协议已经废弃了RC4作为加密套件的一部分。
• 替代算法的出现：随着加密技术的发展，许多更加安全、高效的加密算法已经出现，如AES算法等。这些算法在安全性、性能和灵活性等方面都优于RC4算法，因此在实际应用中应该优先考虑使用这些替代算法。

综上所述，RC4加密算法的缺点主要包括安全性能较差、密钥流生成过程中的问题以及实际应用中的局限性等方面。在选择加密算法时，应该根据具体的安全需求和场景来选择合适的算法，以确保数据的安全性和完整性。

记住：加密就是解密，解密就是加密 （就是加密的数据在进行加密就是解密因为’^‘）

TEA加密

TEA加密算法（Tiny Encryption Algorithm）是一种由剑桥大学计算机实验室的David Wheeler和Roger Needham于1994年设计的分组密码算法。该算法以其实现简单、加密速度快、安全性高等特点而广受欢迎，特别适用于资源受限的环境

1. 初始化：

• 将明文数据分成多个N位的分组（一般为32）。
• 准备128位的密钥（也会进行分组）。

2. 加密过程：

• 对每个明文分组进行多轮迭代加密。
• 在每轮迭代中，使用密钥和神秘常数δ（0x9e3779b9）对明文分组进行复杂的移位和异或运算。
• 最终生成与明文等长的密文分组。

3. 解密过程：

• 解密是加密的逆过程，使用相同的密钥和算法对密文分组进行多轮迭代解密。
• 最终恢复出原始的明文分组。

代码实现

from ctypes import *


def encrypt(v, k):
    v0 = c_uint32(v[0])
    v1 = c_uint32(v[1])
    sum1 = c_uint32(0)
    delta = 0x9e3779b9
    for i in range(32):
        sum1.value += delta
        v0.value += ((v1.value << 4) + k[0]) ^ (v1.value + sum1.value) ^ ((v1.value >> 5) + k[1])
        v1.value += ((v0.value << 4) + k[2]) ^ (v0.value + sum1.value) ^ ((v0.value >> 5) + k[3])
    return v0.value, v1.value


def decrypt(v, k):
    v0 = c_uint32( v[0])
    v1 = c_uint32(v[1])
    delta = 0x9e3779b9
    sum1 = c_uint32(delta * 32)
    for i in range(32):
       v1.value-= ((v0.value << 4) + k[2]) ^ (v0.value + sum1.value) ^ ((v0.value >> 5) + k[3])
        v0.value -= ((v1.value << 4) + k[0]) ^ (v1.value + sum1.value) ^ ((v1.value >> 5) + k[1])
        sum1.value -= delta
    return v0.value, v1.value


if __name__ == '__main__':
    a = [1, 2]
    k = [2, 2, 3, 4]
    print("加密前数据:", a)
    res = encrypt(a, k)
    print("加密后的数据:", res)
    res = decrypt(res, k)
    print("解密后数据:", res)

注：解密就是利用错位（只要找到密钥，与加密后的就行）神秘常数可以魔改这样就用不了工具了

XTEA 加密

XTEA（有时也被称为"tean"）是TEA的升级版：增加了更多的密钥表，移位和异或操作等等，设计者是 Roger Needham, David Wheeler

from ctypes import * 
def encrypt(v,k):
    v0=c_uint32(v[0])
    v1=c_uint32(v[1])
    sum1=c_uint32(0)
    delta=0x9e3779b9
    for i in range(32):
        v0.value+=(((v1.value<<4)^(v1.value>>5))+v1.value)^(sum1.value+k[sum1.value&3])
        sum1.value+=delta
        v1.value+=(((v0.value<<4)^(v0.value>>5))+v0.value)^(sum1.value+k[(sum1.value>>11)&3])
    return v0.value,v1.value
 
def decrypt(v,k):
    v0=c_uint32(v[0])
    v1=c_uint32(v[1])
    delta=0x9e3779b9
    sum1=c_uint32(delta*32)
    for i in range(32):
        v1.value-=(((v0.value<<4)^(v0.value>>5))+v0.value)^(sum1.value+k[(sum1.value>>11)&3])
        sum1.value-=delta
        v0.value-=(((v1.value<<4)^(v1.value>>5))+v1.value)^(sum1.value+k[sum1.value&3])
    return v0.value,v1.value
 
if __name__=='__main__':
    a=[1,2]
    k=[2,2,3,4]
    print("加密前数据:",a)
    res=encrypt(a,k)
    print("加密后的数据:",res)
    res=decrypt(res,k)

注：解密原理与TEA一样