前言

寫CTF題目總是會碰到很多需要解密的地方，比如常見的base家族和url編碼轉化，恰逢看到一些師傅的博客，受到啟發利用python嘗試實作了一下，目的是能夠判斷是base家族的什么加密方式并進行解密，然而期末將近未能實作目的，不過實作了一些加密解密功能，經過測驗仍存在一些問題，在此進行分享學習，代碼中已給出注釋，可添加聯系方式一起交流學習，期待你的建議與指導，

python實作

# -*- coding:utf-8 -*-
import hashlib  # 用于md5、sha1的加密解密
import base64  # base64、32、16，85的加密解密
# 需要注意的是base64自帶的base85的加密解密對應base85四種種類里的兩種
# python3中的a85encode  -->  ASCII85 encoding. This is the default. 0x00000000 is compressed to z. Spaces are not compressed.
# python3中的b85encode  -->  Character set from RFC1924 which is an April fools joke. Spaces and zeroes are not compressed.

# from urllib import quote, unquote
from urllib.parse import quote, unquote  # quote進行url編碼 ， unquote進行url解碼
import argparse  # 撰寫用戶友好的命令列介面
import base58  # 用于base58的加密解密
import base91  # 用于base91的加密解密
# import base92     #用于base92的加密解密      #由于下載不成功base92的庫，所以暫時擱置
import base36  # 用于base36的加密解密

# import base62     #用于base62的加密解密      #由于下載不成功base62的庫，所以暫時擱置
# import binascii
"""

        名字：ctf_crypto_tool

        作者：Force

        時間：2020-11-24

        QQ ：1049453191

        Wechat:ForcesWang


"""


def menu():
    usage = """
       -m      MD5 encryption(32-bit lowercase)
       -s      SH1 encryption
       -h      Show help information
       -b64    Base64 encode
       -b32    Base32 encode
       -b16    Base16 encode
       -b85_1  Base85_1 encode
       -b85_2  Base85_2 encode
       -b36    Base36 encode
       -b58    Base58 encode
       -b91    Base91 encode
       -db64   Base64 decode
       -db32   Base32 decode
       -db16   Base16 decode    #可
       -db85_1 Base85_1 decode
       -db85_2 Base85_2 decode
       -db36   Base36 decode
       -db58   Base58 decode
       -db91   Base91 decode
       -urlen  URL encode
       -urlde  URL decode
       -bin    Binary To Decimal   #二進制到十進制
       -octal  Octal  to Decimal   #八進制到十進制
       -hex    Hexadecimal to Decimal   #十六進制到十進制
       -dbin   Decimal To Binary    #十進制到二進制
       -doctal Decimal to Octal     #十進制到八進制
       -dhex   Decimal to Hexadecimal    #十進制到十六進制
       -ord    Letter To ASCII  #字母到ASCII         Example  -ord asdfasfa      -ord='dfafs afasfa asfasf'
       -chr    ASCII  To Letters   #ASCII到字母      Example  -chr 105           -chr = '102 258 654'



    """

    # 在使用ord 和chr命令的時候要注意如果輸入的字符和數字不包含空格則直接實用例子前面的命令如果包含空格則使用后面的命令

    parser = argparse.ArgumentParser()

    parser.add_argument('-m', dest='md', help='MD5 encryption')

    parser.add_argument('-s', dest='sh', help='SH1 encryption')

    parser.add_argument('--h', action="store_true", help='Show help information')

    parser.add_argument('-b64', dest='b64', help='Base64 encode')

    parser.add_argument('-b32', dest='b32', help='Base32 encode')

    parser.add_argument('-b16', dest='b16', help='Base16 encode')

    parser.add_argument('-b85_1', dest='b85_1', help='Base85_1 encode')

    parser.add_argument('-b85_2', dest='b85_2', help='Base85_2 encode')

    parser.add_argument('-b36', dest='b36', help='Base36 encode')

    parser.add_argument('-b58', dest='b58', help='Base58 encode')

    parser.add_argument('-b91', dest='b91', help='Base91 encode')

    parser.add_argument('-db64', dest='db64', help='Base64 decode')

    parser.add_argument('-db32', dest='db32', help='Base32 decode')

    parser.add_argument('-db16', dest='db16', help='Base16 decode')

    parser.add_argument('-db85_1', dest='db85_1', help='Base85_1 decode')

    parser.add_argument('-db85_2', dest='db85_2', help='Base85_2 decode')

    parser.add_argument('-db36', dest='db36', help='Base36 decode')

    parser.add_argument('-db58', dest='db58', help='Base58 decode')

    parser.add_argument('-db91', dest='db91', help='Base91  decode')

    # parser.add_argument('-dbfamily', dest='dbfamily', help='basefamily decode')

    parser.add_argument('-urlen', dest='urlen', help='URL encode')

    parser.add_argument('-urlde', dest='urlde', help='URL decode')

    parser.add_argument('-bin', dest='bin', help='Binary To Decimal')

    parser.add_argument('-octal', dest='octal', help='Octal  to Decimal')

    parser.add_argument('-hex', dest='hex', help='Hexadecimal to Decimal')

    parser.add_argument('-dbin', dest='dbin', help='Decimal To Binary ')

    parser.add_argument('-doctal', dest='doctal', help='Decimal to Octal ')

    parser.add_argument('-dhex', dest='dhex', help='Decimal to Hexadecimal')

    parser.add_argument('-ord', dest='ord',
                        help="Letter To ASCII               Example  -ord aaaaaa  , -ord=\"aaa aaa\"")

    parser.add_argument('-chr', dest='chr',
                        help="ASCII  To Letter              Example  -chr 105     ,  -chr = \"101 101\" ")

    options = parser.parse_args()

    if options.md:
        s = options.md
        md5(s)

    elif options.sh:
        s = options.sh
        sh1(s)

    elif options.b64:
        s = options.b64
        stringToB64(s)

    elif options.b32:
        s = options.b32
        stringToB32(s)

    elif options.b16:
        s = options.b16
        stringToB16(s)

    elif options.b85_1:
        s = options.b85_1
        stringTobase85_1(s)

    elif options.b85_2:
        s = options.b85_2
        stringTobase85_2(s)

    elif options.b36:
        s = options.b36
        stringTobase36(s)

    elif options.b58:
        s = options.b58
        stringTobase58(s)

    elif options.b91:
        s = options.b91
        stringTobase91(s)

    elif options.db85_1:
        s = options.db85_1
        base85_1Tostring(s)

    elif options.db85_2:
        s = options.db85_2
        base85_2Tostring(s)

    elif options.db36:
        s = options.db36
        base36Tostring(s)

    elif options.db58:
        s = options.db58
        base58Tostring(s)

    elif options.db91:
        s = options.db91
        base91Tostring(s)

    # elif options.dbfamily:
    #
    #     s = options.dbfamily
    #
    #     basefamily(s)

    elif options.db64:
        s = options.db64
        b64ToString(s)

    elif options.db32:
        s = options.db32
        b32ToString(s)

    elif options.db16:
        s = options.db16
        b16ToString(s)

    elif options.urlen:
        s = options.urlen
        urlEncode(s)

    elif options.urlde:
        s = options.urlde
        urlDecode(s)

    elif options.bin:
        s = options.bin
        binToDec(s)

    elif options.octal:
        s = options.octal
        octToDec(s)

    elif options.hex:
        s = options.hex
        hexToDec(s)

    elif options.dbin:
        s = options.dbin
        decToBin(s)

    elif options.doctal:
        s = options.doctal
        decToOct(s)

    elif options.dhex:
        s = options.dhex
        decToHex(s)

    elif options.doctal:
        s = options.doctal
        decToOct(s)

    elif options.dhex:
        s = options.dhex
        decToHex(s)

    elif options.ord:
        s = options.ord
        lettToASCII(s)

    elif options.chr:
        s = options.chr
        asciiToLett(s)

    else:

        helpInfo()


def helpInfo():
    print("""
       -m      MD5 encryption(32-bit lowercase)
       -s      SH1 encryption
       -h      Show help information
       -b64    Base64 encode
       -b32    Base32 encode
       -b16    Base16 encode
       -b85_1  Base85_1 encode
       -b85_2  Base85_2 encode
       -b36    Base36 encode
       -b58    Base58 encode
       -b91    Base91 encode
       -db64   Base64 decode
       -db32   Base32 decode
       -db16   Base16 decode
       -db85_1 Base85_1 decode
       -db85_2 Base85_2 decode
       -db36   Base36 decode
       -db58   Base58 decode
       -db91   Base91 decode
       -urlen  URL encode
       -urlde  URL decode
       -bin    Binary To Decimal
       -octal  Octal Decimal to Decimal
       -hex    Hexadecimal to Decimal
       -dbin   Decimal To Binary 
       -doctal Decimal to Octal 
       -dhex   Decimal to Hexadecimal
       -ord    Letter To ASCII      attention：   Example  -ord asdfasfa      -ord="dfafs afasfa  asfasf"
       -chr    ASCII  To Letters    attention：   Example  -chr 105           -chr="102 258 654"
""")


# 進行MD5加密

def md5(s):
    original = s

    md = hashlib.md5()

    s = s.encode(encoding='utf-8')

    md.update(s)

    print('Original:' + original)

    print('Md5 Encryption:' + md.hexdigest())


# 進行sh1加密

def sh1(s):
    original = s

    sh = hashlib.sha1()

    # s = s.encode(encoding='utf-8')

    print('Original:' + original)

    print('SH1 Encryption:' + sh.hexdigest())


# 將字串轉換為base64編碼格式

def stringToB64(s):
    encode = base64.b64encode(s)

    print('Original:' + s)

    print('Base64 encode:' + str(encode))


# 將base64編碼格式轉化為正常的字符型別

def b64ToString(s):
    decode = base64.b64decode(s)

    # print('Base64:' + s)

    print('Base64 decode:' + str(decode))


# 將字串轉為b32編碼格式

def stringToB32(s):
    encode = base64.b32encode(s)

    print('Original:' + s)

    print('Base32 encode:' + str(encode))


# 將base32編碼格式轉化為正常的字符型別

def b32ToString(s):
    decode = base64.b32decode(s)

    # print('Base32:' + s)

    print('Base32 decode:' + str(decode))


# 將字串轉為base16編碼格式

def stringToB16(s):
    encode = base64.b16encode(s)

    print('Original:' + s)

    print('Base16 encode:' + str(encode))


# 將base16編碼格式轉化為正常的字符型別

def b16ToString(s):
    decode = base64.b16decode(s)

    # print('Base16:' + s)

    print('Base16 decode:' + str(decode))


# 將字串轉為base85的第一個種類的編碼格式

def stringTobase85_1(s):
    encode = base64.a85encode(s)

    print('Original:' + s)

    print('Base85_1 encode:' + str(encode))


# 將base85的第一個種類的編碼格式轉化為正常的字符型別

def base85_1Tostring(s):
    decode = base64.a85decode(s)

    # print('Base85_1:' + s)

    print('Base85_1 decode:' + str(decode))


# 將字串轉為base85的第二個種類的編碼格式

def stringTobase85_2(s):
    encode = base64.b85encode(s)

    print('Original:' + s)

    print('Base85_2 encode:' + str(encode))


# 將base85的第一個種類的編碼格式轉化為正常的字符型別

def base85_2Tostring(s):
    decode = base64.b85decode(s)

    # print('Base85_2:' + s)

    print('Base85_2 decode:' + str(decode))


# 將字串轉為base36編碼格式

def stringTobase36(s):
    encode = base36.loads(s)

    print('Original:' + s)

    print('Base36 encode:' + str(encode))


# 將base36編碼格式轉化為正常的字符型別

def base36Tostring(s):
    decode = base36.dumps(int(s))

    # print('Base36:' + s)

    print('Base36 decode:' + str(decode))


# 將字串轉化為base58編碼格式

def stringTobase58(s):
    encode = base58.b58encode(str(s))

    print('Original:' + s)

    print('Base58 encode:' + str(encode))


# 將base58編碼格式轉化為正常的字符型別

def base58Tostring(s):
    encode = base58.b58decode(s)

    print('Base58 decode:' + str(encode))


# 將字串轉化為base91編碼格式

def stringTobase91(s):
    encode = base91.encode(s)

    print('Original:' + s)

    print('Base91 encode:' + str(encode))


# 將base58編碼格式轉化為正常的字符型別

def base91Tostring(s):
    decode = base91.decode(s)

    # print('Base91:' + s)

    print('Base91 decode:' + str(decode))


# 將字串轉為base全家桶編碼格式

# def basefamily(s):
#     b64ToString(s)
#     b32ToString(s)
#     b16ToString(s)
#     base58Tostring(s)
#     base91Tostring(s)
#     base36Tostring(s)
#     base85_1Tostring(s)
#     base85_2Tostring(s)


# 進行url編碼

def urlEncode(s):
    encode = quote(s)

    print('Original:' + s)

    print('URL encode:' + encode)


# 進行url編碼

def urlDecode(s):
    decode = unquote(s)

    print('URL encode:' + s)

    print('URL decode:' + decode)


# 將二進制轉化為十進制

def binToDec(s):
    result = int(s, 2)

    print('Binary :' + str(s))

    print('Decimal :' + str(result))


# 將八進制轉化為十進制

def octToDec(s):
    result = int(s, 8)

    print('Octal :' + str(s))

    print('Decimal :' + str(result))


# 將十六進制轉化為十進制

def hexToDec(s):
    result = int(s, 16)

    print('Hex :' + str(s))

    print('Decimal :' + str(result))


# 將十進制轉化為二進制

def decToBin(s):
    s = int(s)

    result = bin(s)

    print('Decimal:' + str(s))

    print('Binary:' + str(result))


# 將十進制轉化為八進制

def decToOct(s):
    s = int(s)

    result = oct(s)

    print('Decimal :' + str(s))

    print('Octal :' + str(result))


# 將十進制轉化為十六進制

def decToHex(s):
    s = int(s)

    result = hex(s)

    print('Decimal :' + str(s))

    print('Hex :' + str(result))


# 將字母轉化為對應的ASCII

def lettToASCII(s):
    print('Letters:' + s)

    result = ''

    for i in s:
        result = result + str(ord(i)) + ' '

    print('ASCII  :' + result)


# 將ASCII轉化為對應的字母以及字符


def asciiToLett(s):
    list = s.split(' ')

    result = ''

    print('ASCII    :' + s)

    for i in list:
        i = int(i)

        result = result + chr(i)

    print('Letters  :' + result)


if __name__ == '__main__':
    menu()

測驗與總結

以下展示一些頁面和測驗用例，以及其中出現的一些問題

此為啟動提示界面

接下來是base91的解碼：

此為md5的加密（此處需要注意的是提供的是32小寫的加密資料）

特別還需要注意的是將字母轉化為對應的ASCII的時候如果您輸入的是字母是用空格分開的時候需要添加雙引號，如果是一段字串則不需要添加雙引號

python ctf_crypto_tool.py -ord "Force is the author"

python ctf_crypto_tool.py -ord abaaba

否則會出現報錯（由于時間關系我沒進行報錯的例外處理，筆者可以自行添加）

同樣的，將ASCII轉化為對應的字母以及字符同上原理， 在提示資訊的地方已經給出了提示和使用示例，

出現的一些問題：

目前筆者測驗了base64、32、16、36、58、91的解密，發現base58的解密在用網上在線網站得到的base58測驗集進行測驗的時候會出現例如這樣的情況


目前筆者的猜測可能是我使用的base58這個第三方庫和在線網站背后的解碼原理不相同（僅個人猜測，望讀者給予解答，感謝）
由于時間問題就未能仔細往下研究，待考試結束后會繼續研究base全家桶并把之前的目的實作，
python這門語言十分的好玩簡潔有趣，望能堅持學習下去并能不斷實作一些有趣的案例加強自己的學習興趣，