Base64混合加解密破解

目录

方法一：反向暴力破解，已知：{密文，加密算法}， 未知：{加密顺序，即密钥}

方法二：正向暴力破解，已知：{密文，加密算法，部分明文}，未知：{加密顺序}

方法三：异常处理，根据解密时产生的错误异常处理来破解密文

方法四：编码识别 根据base64，base32和base16的编码方式不同来破解密文

---

方法一：反向暴力破解，已知：{密文，加密算法}， 未知：{加密顺序，即密钥}

# 算法逆向破解
# 加密函数，flag是某个字符串
import random
import base64

def enc(flag):
    bcode = {
        '16': lambda x: base64.b16encode(x),   # 使用lambda表达式对x进行base64编码
        '32': lambda x: base64.b32encode(x),
        '64': lambda x: base64.b64encode(x)
    }
    # 字符串在Python内部的表示是unicode编码
    # 因此，在做编码转换时，通常需要以unicode作为中间编码，即先将其他编码的字符串解码（decode）成unicode，再从unicode编码（encode）成另一种编码。
    msg = flag.encode('utf-8')   # encode的作用是将unicode编码转换成其他编码的字符串
    # 加密过程
    for i in range(10):
        order = random.choice(['64', '32', '16'])
        msg = bcode[order](msg)
        # print('{}:{}'.format(order, msg))


    msg = msg.decode('utf-8')   # decode的作用是将其他编码的字符串转换成unicode编码
    return msg


cipherText = enc("flag{****some secret****}")
print("密文是：", cipherText)

# 使用列表形式存储解密函数
# dcode = [lambda x: base64.b16decode(x), lambda x: base64.b32decode(x), lambda x: base64.b64decode(x)]

dcode = {
    0: lambda x: base64.b16decode(x),  # 使用lambda表达式对x进行base64编码
    1: lambda x: base64.b32decode(x),
    2: lambda x: base64.b64decode(x)
}
# cipherText = cipherText.encode('utf-8')
# 反向已知编码后的密文，使用暴力破解得到明文
# 已知{密文，加密算法}，未知{加密顺序，即密钥}
for i in range(3):
    for j in range(3):
        for k in range(3):
            for t in range(3):
                for p in range(3):
                    for q in range(3):
                        for m in range(3):
                            for n in range(3):
                                for r in range(3):
                                    for s in range(3):
                                        try:
                                            plaintext = dcode[s](dcode[r](dcode[n](dcode[m](dcode[q](dcode[p](dcode[t](dcode[k](dcode[j](dcode[i](cipherText))))))))))
                                            # print(plaintext)
                                            if plaintext:
                                                break
                                            else:
                                                continue
                                        except:
                                            pass

print("明文是：", plaintext)

方法二：正向暴力破解，已知：{密文，加密算法，部分明文}，未知：{加密顺序}

import random
import base64

def enc(flag):
    bcode = {
        '16': lambda x: base64.b16encode(x),   # 使用lambda表达式对x进行base64编码
        '32': lambda x: base64.b32encode(x),
        '64': lambda x: base64.b64encode(x)
    }
    msg = flag.encode('utf-8')   # encode的作用是将unicode编码转换成其他编码的字符串
    # 加密过程
    for i in range(10):
        order = random.choice(['64', '32', '16'])
        msg = bcode[order](msg)
        print('{}->{}'.format(order, msg))


    msg = msg.decode('utf-8')   # decode的作用是将其他编码的字符串转换成unicode编码
    return msg


cipherText = enc("flag{****some secret****}")
print("密文是：", cipherText)

# 使用列表形式存储加密函数
# dcode = [lambda x: base64.b16decode(x), lambda x: base64.b32decode(x), lambda x: base64.b64decode(x)]

bcode = {
    0: lambda x: base64.b16encode(x),  # 使用lambda表达式对x进行base64编码
    1: lambda x: base64.b32encode(x),
    2: lambda x: base64.b64encode(x)
}

dcode = {
    0: lambda x: base64.b16decode(x),  # 使用lambda表达式对x进行base64编码
    1: lambda x: base64.b32decode(x),
    2: lambda x: base64.b64decode(x)
}
plain = "flag{}"
plain = plain.encode('utf-8')
f =open('test.txt', 'a+')
# 正向破解，已知{密文，原来的加密代码，部分明文}，未知{加密顺序}
for i in range(3):
    for j in range(3):
        for k in range(3):
            for t in range(3):
                for p in range(3):
                    for q in range(3):
                        for m in range(3):
                            for n in range(3):
                                for r in range(3):
                                    for s in range(3):
                                        result = bcode[i](bcode[j](bcode[k](bcode[t](
                                            bcode[p](bcode[q](bcode[m](bcode[n](bcode[r](bcode[s](plain))))))))))
                                        result = result.decode('utf-8')
                                        f.writelines(result+"\n")
                                        # print(result)
                                        if result[:144] == cipherText[:144]:
                                            print("加密order：{}->{}->{}->{}->{}->{}->{}->{}->{}->{}".format(i,j,k,t,p,q,m,n,r,s) )
                                            plain = dcode[s](dcode[r](dcode[n](dcode[m](
                                                dcode[q](dcode[p](dcode[t](dcode[k](dcode[j](dcode[i](cipherText))))))))))
                                            print("明文是：", plain)
                                            break

 

方法三：异常处理，根据解密时产生的错误异常处理来破解密文

import random
import base64

def enc(flag):
    bcode = {
        '16': lambda x: base64.b16encode(x),   # 使用lambda表达式对x进行base64编码
        '32': lambda x: base64.b32encode(x),
        '64': lambda x: base64.b64encode(x)
    }
    # 字符串在Python内部的表示是unicode编码
    # 因此，在做编码转换时，通常需要以unicode作为中间编码，即先将其他编码的字符串解码（decode）成unicode，再从unicode编码（encode）成另一种编码。
    msg = flag.encode('utf-8')   # encode的作用是将unicode编码转换成其他编码的字符串
    # 加密过程
    for i in range(10):
        order = random.choice(['64', '32', '16'])
        msg = bcode[order](msg)
        # print('{}:{}'.format(order, msg))

    msg = msg.decode('utf-8')   # decode的作用是将其他编码的字符串转换成unicode编码
    return msg

# print(enc('flag{****some secret****}'))
# 任务：假设flag未知，如何通过加密结果恢复出flag

cipherText = enc("flag{****some secret****}")
print("密文是：", cipherText)


def dec(cipher):
    bcode = {
        '16': lambda x: base64.b16decode(x),  # 使用lambda表达式对x进行base64编码
        '32': lambda x: base64.b32decode(x),
        '64': lambda x: base64.b64decode(x)
    }
    num = ('16', '32', '64')
    msg = cipher.encode('utf-8')

    for i in range(10):    # 两层循环
        for k in num:
            try:
                msg = bcode[k](msg)
                # 如果解密成功那个跳过这次，否则继续下一轮
                if msg:
                    break
                else:
                    continue
            except:
                pass

    msg = msg.decode('utf-8')
    return msg

plainText = dec(cipherText)
print("解密后的明文是：", plainText)

方法四：编码识别 根据base64，base32和base16的编码方式不同来破解密文

根据base16,32,64之间的编码形式不同进行破解
Base64：
包含大写字母（A-Z）,小写字母（a-z），数字（0-9）以及+/，"="个数的取值范围为{0,1,2};

Base32:
Base32中只有大写字母（A-Z）和数字234567，"="个数的取值范围为{0,1,3,4,6}；

Base16:
Base16就是16进制，他的范围是数字(0-9)，字母（ABCDEF）；

# 算法逆向破解
# 加密函数，flag是某个字符串
import random
import base64
import re


def enc(flag):
    bcode = {
        '16': lambda x: base64.b16encode(x),   # 使用lambda表达式对x进行base64编码
        '32': lambda x: base64.b32encode(x),
        '64': lambda x: base64.b64encode(x)
    }
    # 字符串在Python内部的表示是unicode编码
    # 因此，在做编码转换时，通常需要以unicode作为中间编码，即先将其他编码的字符串解码（decode）成unicode，再从unicode编码（encode）成另一种编码。
    msg = flag.encode('utf-8')   # encode的作用是将unicode编码转换成其他编码的字符串
    # 加密过程
    for i in range(10):
        order = random.choice(['64', '32', '16'])
        msg = bcode[order](msg)
        # print('{}:{}'.format(order, msg))


    msg = msg.decode('utf-8')   # decode的作用是将其他编码的字符串转换成unicode编码
    return msg


cipherText = enc("flag{****some secret****}")
print("密文是：", cipherText)

# 根据base16,32,64之间的编码形式不同进行破解
# Base64：
# 包含大写字母（A-Z）,小写字母（a-z），数字（0-9）以及+/，"="个数的取值范围为{0,1,2};
#
# Base32:
# 而Base32中只有大写字母（A-Z）和数字234567，"="个数的取值范围为{0,1,3,4,6}；
#
# Base16:
# 而Base16就是16进制，他的范围是数字(0-9)，字母（ABCDEF）；

# dcode = [lambda x: base64.b16decode(x), lambda x: base64.b32decode(x), lambda x: base64.b64decode(x)]
base64Patter = re.compile('[A-Za-z0-9+/]')
base32Patter = re.compile('[^A-Z2-7]')
base16Patter = re.compile('[^G-Z]')

# findall可以获取字符串中所有匹配的字符串，返回一个列表。
# results = re.findall(p,source)
# print(results)

dcode = {
    '16': lambda x: base64.b16decode(x),  # 使用lambda表达式对x进行base64编码
    '32': lambda x: base64.b32decode(x),
    '64': lambda x: base64.b64decode(x)
}

msg = cipherText.encode('utf-8')
print(msg)

# text = 'GHIL'.encode('utf-8')
# if re.search(b'[^G-Z]', text) != None:   # 不要G-Z
#     print('符合要求')
# else:
#     print("不符合要求")

for i in range(10):
    if re.match(b'.*[a-z].*', msg) != None:     # 包含a-z，只有base64
        msg = dcode['64'](msg)
    elif re.match(b'.*[G-Z].*', msg) != None:     # base16编码中没有G-Z，如果编码中有G-Z，说明是base32
        msg = dcode['32'](msg)
    else:
        msg = dcode['16'](msg)


print("明文是：", msg.decode('utf-8'))