BaseCTF2024 个人Writeup

from PIL import Image
import sys


def toasc(strr):
    return int(strr, 2)


# str1为所要提取的信息的长度（根据需要修改），str2为加密载体图片的路径，str3为提取文件的保存路径
def decode(str1, str2, str3):
    b = ""
    im = Image.open(str2)
    lenth = int(str1) * 8
    width, height = im.size[0], im.size[1]
    count = 0
    for h in range(height):
        for w in range(width):
            # 获得(w,h)点像素的值
            pixel = im.getpixel((w, h))
            # 此处余3，依次从R、G、B三个颜色通道获得最低位的隐藏信息
            if count % 3 == 0:
                count += 1
                b = b + str((mod(int(pixel[0]), 2)))
                if count == lenth:
                    break
            if count % 3 == 1:
                count += 1
                b = b + str((mod(int(pixel[1]), 2)))
                if count == lenth:
                    break
            if count % 3 == 2:
                count += 1
                b = b + str((mod(int(pixel[2]), 2)))
                if count == lenth:
                    break
        if count == lenth:
            break

    with open(str3, "w", encoding="utf-8") as f:
        for i in range(0, len(b), 8):
            # 以每8位为一组二进制，转换为十进制
            stra = toasc(b[i : i + 8])
            # 将转换后的十进制数视为ascii码，再转换为字符串写入到文件中
            # print((stra))
            f.write(chr(stra))
    print("sussess")


def plus(string):
    # Python zfill() 方法返回指定长度的字符串，原字符串右对齐，前面填充0。
    return string.zfill(8)


def get_key(strr):
    # 获取要隐藏的文件内容
    with open(strr, "rb") as f:
        s = f.read()
        string = ""
        for i in range(len(s)):
            # 逐个字节将要隐藏的文件内容转换为二进制，并拼接起来
            # 1.先用ord()函数将s的内容逐个转换为ascii码
            # 2.使用bin()函数将十进制的ascii码转换为二进制
            # 3.由于bin()函数转换二进制后，二进制字符串的前面会有"0b"来表示这个字符串是二进制形式，所以用replace()替换为空
            # 4.又由于ascii码转换二进制后是七位，而正常情况下每个字符由8位二进制组成，所以使用自定义函数plus将其填充为8位
            string = string + "" + plus(bin(s[i]).replace("0b", ""))
    # print(string)
    return string


def mod(x, y):
    return x % y


# str1为载体图片路径，str2为隐写文件，str3为加密图片保存的路径
def encode(str1, str2, str3):
    im = Image.open(str1)
    # 获取图片的宽和高
    width, height = im.size[0], im.size[1]
    print("width:" + str(width))
    print("height:" + str(height))
    count = 0
    # 获取需要隐藏的信息
    key = get_key(str2)
    keylen = len(key)
    for h in range(height):
        for w in range(width):
            pixel = im.getpixel((w, h))
            a = pixel[0]
            b = pixel[1]
            c = pixel[2]
            if count == keylen:
                break
            # 下面的操作是将信息隐藏进去
            # 分别将每个像素点的RGB值余2，这样可以去掉最低位的值
            # 再从需要隐藏的信息中取出一位，转换为整型
            # 两值相加，就把信息隐藏起来了
            a = a - mod(a, 2) + int(key[count])
            count += 1
            if count == keylen:
                im.putpixel((w, h), (a, b, c))
                break
            b = b - mod(b, 2) + int(key[count])
            count += 1
            if count == keylen:
                im.putpixel((w, h), (a, b, c))
                break
            c = c - mod(c, 2) + int(key[count])
            count += 1
            if count == keylen:
                im.putpixel((w, h), (a, b, c))
                break
            if count % 3 == 0:
                im.putpixel((w, h), (a, b, c))
    im.save(str3)


if __name__ == "__main__":
    if "-h" in sys.argv or "--help" in sys.argv or len(sys.argv) < 2:
        print("Usage: python test.py <cmd> [arg...] [opts...]")
        print("  cmds:")
        print("    encode image + flag -> image(encoded)")
        print("    decode length + image(encoded) -> flag")
        sys.exit(1)
    cmd = sys.argv[1]
    if cmd != "encode" and cmd != "decode":
        print("wrong input")
        sys.exit(1)
    str1 = sys.argv[2]
    str2 = sys.argv[3]
    str3 = sys.argv[4]
    if cmd != "encode" and cmd != "decode":
        print("Wrong cmd %s" % cmd)
        sys.exit(1)
    elif cmd == "encode":
        encode(str1, str2, str3)
    elif cmd == "decode":
        decode(str1, str2, str3)

original_string = "}67bf613763ca-50b3-4437-7a3a-b683fe51{FTCesaB"
print(original_string[::-1])

import base64
import hashlib

def abort(id):
    print('You failed test %d. Try again!' % id)
    exit(1)

print('Hello, Python!')
flag = input('Enter your flag: ')

if len(flag) != 38:
    abort(1)

if not flag.startswith('BaseCTF{'):
    abort(2)

if flag.find('Mp') != 10:
    abort(3)

if flag[-3:] * 8 != '3x}3x}3x}3x}3x}3x}3x}3x}':
    abort(4)

if ord(flag[-1]) != 125:
    abort(5)

if flag.count('_') // 2 != 2:
    abort(6)

if list(map(len, flag.split('_'))) != [14, 2, 6, 4, 8]:
    abort(7)

if flag[12:32:4] != 'lsT_n':
    abort(8)

if '😺'.join([c.upper() for c in flag[:9]]) != 'B😺A😺S😺E😺C😺T😺F😺{😺S':
    abort(9)

if not flag[-11].isnumeric() or int(flag[-11]) ** 5 != 1024:
    abort(10)

if base64.b64encode(flag[-7:-3].encode()) != b'MG1QbA==':
    abort(11)

if flag[::-7].encode().hex() != '7d4372733173':
    abort(12)

if set(flag[12::11]) != {'l', 'r'}:
    abort(13)

if flag[21:27].encode() != bytes([116, 51, 114, 95, 84, 104]):
    abort(14)

if sum(ord(c) * 2024_08_15 ** idx for idx, c in enumerate(flag[17:20])) != 41378751114180610:
    abort(15)

if not all([flag[0].isalpha(), flag[8].islower(), flag[13].isdigit()]):
    abort(16)

if '{whats} {up}'.format(whats=flag[13], up=flag[15]).replace('3', 'bro') != 'bro 1':
    abort(17)

if hashlib.sha1(flag.encode()).hexdigest() != 'e40075055f34f88993f47efb3429bd0e44a7f479':
    abort(18)

print('🎉 You are right!')
import this

import hashlib

flag='BaseCTF{}'

output=[]
for i in flag:
    my_md5=hashlib.md5()
    my_md5.update(i.encode())
    output.append(my_md5.hexdigest())
print("output =",output)
'''
output = ['9d5ed678fe57bcca610140957afab571', '0cc175b9c0f1b6a831c399e269772661', '03c7c0ace395d80182db07ae2c30f034', 'e1671797c52e15f763380b45e841ec32', '0d61f8370cad1d412f80b84d143e1257', 'b9ece18c950afbfa6b0fdbfa4ff731d3', '800618943025315f869e4e1f09471012', 'f95b70fdc3088560732a5ac135644506', '0cc175b9c0f1b6a831c399e269772661', 'a87ff679a2f3e71d9181a67b7542122c', '92eb5ffee6ae2fec3ad71c777531578f', '8fa14cdd754f91cc6554c9e71929cce7', 'a87ff679a2f3e71d9181a67b7542122c', 'eccbc87e4b5ce2fe28308fd9f2a7baf3', '0cc175b9c0f1b6a831c399e269772661', 'e4da3b7fbbce2345d7772b0674a318d5', '336d5ebc5436534e61d16e63ddfca327', 'eccbc87e4b5ce2fe28308fd9f2a7baf3', '8fa14cdd754f91cc6554c9e71929cce7', '8fa14cdd754f91cc6554c9e71929cce7', '45c48cce2e2d7fbdea1afc51c7c6ad26', '336d5ebc5436534e61d16e63ddfca327', 'a87ff679a2f3e71d9181a67b7542122c', '8f14e45fceea167a5a36dedd4bea2543', '1679091c5a880faf6fb5e6087eb1b2dc', 'a87ff679a2f3e71d9181a67b7542122c', '336d5ebc5436534e61d16e63ddfca327', '92eb5ffee6ae2fec3ad71c777531578f', '8277e0910d750195b448797616e091ad', '0cc175b9c0f1b6a831c399e269772661', 'c81e728d9d4c2f636f067f89cc14862c', '336d5ebc5436534e61d16e63ddfca327', '0cc175b9c0f1b6a831c399e269772661', '8fa14cdd754f91cc6554c9e71929cce7', 'c9f0f895fb98ab9159f51fd0297e236d', 'e1671797c52e15f763380b45e841ec32', 'e1671797c52e15f763380b45e841ec32', 'a87ff679a2f3e71d9181a67b7542122c', '8277e0910d750195b448797616e091ad', '92eb5ffee6ae2fec3ad71c777531578f', '45c48cce2e2d7fbdea1afc51c7c6ad26', '0cc175b9c0f1b6a831c399e269772661', 'c9f0f895fb98ab9159f51fd0297e236d', '0cc175b9c0f1b6a831c399e269772661', 'cbb184dd8e05c9709e5dcaedaa0495cf']
'''

import hashlib
import string


def generate_md5_dict():
    # 定义所有字符集，包括字母、数字和常见符号
    chars = (
        string.ascii_uppercase
        + string.ascii_lowercase
        + string.digits
        + "!\"#$%&'()*+,-./:;<=>?@[\\]_^`{|}~"  # 常见符号
    )

    # 初始化一个空字典来存储结果
    md5_dict = {}

    # 遍历所有字符
    for char in chars:
        # 计算MD5哈希值
        md5_hash = hashlib.md5(char.encode()).hexdigest()
        # 将MD5哈希值和字符存入字典
        md5_dict[md5_hash] = char

    return md5_dict


# 生成字典
md5_dictionary = generate_md5_dict()

# 打印字典
for md5_value, character in md5_dictionary.items():
    print(f"MD5: {md5_value} -> Character: {character}")

output = [
    "9d5ed678fe57bcca610140957afab571",
    "0cc175b9c0f1b6a831c399e269772661",
    "03c7c0ace395d80182db07ae2c30f034",
    "e1671797c52e15f763380b45e841ec32",
    "0d61f8370cad1d412f80b84d143e1257",
    "b9ece18c950afbfa6b0fdbfa4ff731d3",
    "800618943025315f869e4e1f09471012",
    "f95b70fdc3088560732a5ac135644506",
    "0cc175b9c0f1b6a831c399e269772661",
    "a87ff679a2f3e71d9181a67b7542122c",
    "92eb5ffee6ae2fec3ad71c777531578f",
    "8fa14cdd754f91cc6554c9e71929cce7",
    "a87ff679a2f3e71d9181a67b7542122c",
    "eccbc87e4b5ce2fe28308fd9f2a7baf3",
    "0cc175b9c0f1b6a831c399e269772661",
    "e4da3b7fbbce2345d7772b0674a318d5",
    "336d5ebc5436534e61d16e63ddfca327",
    "eccbc87e4b5ce2fe28308fd9f2a7baf3",
    "8fa14cdd754f91cc6554c9e71929cce7",
    "8fa14cdd754f91cc6554c9e71929cce7",
    "45c48cce2e2d7fbdea1afc51c7c6ad26",
    "336d5ebc5436534e61d16e63ddfca327",
    "a87ff679a2f3e71d9181a67b7542122c",
    "8f14e45fceea167a5a36dedd4bea2543",
    "1679091c5a880faf6fb5e6087eb1b2dc",
    "a87ff679a2f3e71d9181a67b7542122c",
    "336d5ebc5436534e61d16e63ddfca327",
    "92eb5ffee6ae2fec3ad71c777531578f",
    "8277e0910d750195b448797616e091ad",
    "0cc175b9c0f1b6a831c399e269772661",
    "c81e728d9d4c2f636f067f89cc14862c",
    "336d5ebc5436534e61d16e63ddfca327",
    "0cc175b9c0f1b6a831c399e269772661",
    "8fa14cdd754f91cc6554c9e71929cce7",
    "c9f0f895fb98ab9159f51fd0297e236d",
    "e1671797c52e15f763380b45e841ec32",
    "e1671797c52e15f763380b45e841ec32",
    "a87ff679a2f3e71d9181a67b7542122c",
    "8277e0910d750195b448797616e091ad",
    "92eb5ffee6ae2fec3ad71c777531578f",
    "45c48cce2e2d7fbdea1afc51c7c6ad26",
    "0cc175b9c0f1b6a831c399e269772661",
    "c9f0f895fb98ab9159f51fd0297e236d",
    "0cc175b9c0f1b6a831c399e269772661",
    "cbb184dd8e05c9709e5dcaedaa0495cf",
]

result = ""

for item in output:
    try:
        result += md5_dictionary[item]
    except KeyError:
        print(item)
        print(result)

print(result)

import httpx

client = httpx.Client()
url = "http://challenge.basectf.fun:30394/"

response = client.get(url)
print(response.text)
formula = response.text.split(" ")[-1].replace("?", "").replace("×", "*").replace("÷", "//")

while True:
    response = client.post(
        url,
        data={
            "answer": eval(formula)
        }
    )
    formula = response.text.split(" ")[-1].replace("?", "").replace("×", "*").replace("÷", "//")
    if "{" in response.text and "}" in response.text:
        print(response.text)
        break
    else:
        print(response.text)

from Crypto.Util.number import long_to_bytes
from Crypto.Cipher import AES
from Crypto.Util.Padding import unpad

# 已知的 key 和 ciphertext
key1 = 208797759953288399620324890930572736628
ciphertext = b'U\xcd\xf3\xb1 r\xa1\x8e\x88\x92Sf\x8a`Sk],\xa3(i\xcd\x11\xd0D\x1edd\x16[&\x92@^\xfc\xa9(\xee\xfd\xfb\x07\x7f:\x9b\x88\xfe{\xae'

# 将 key1 转换为字节
key = long_to_bytes(key1)

# 创建 AES 解密器
my_aes = AES.new(key=key, mode=AES.MODE_ECB)

# 解密并取消填充
plaintext = unpad(my_aes.decrypt(ciphertext), AES.block_size)

# 输出解密后的明文
print(plaintext.decode())

from Crypto.Util.number import *
import gmpy2
m=bytes_to_long(b'BaseCTF{th1s_is_fake_fl4g}')
e=65537
p=getPrime(512)
q=getPrime(512)
n=p*q
not_phi=(p+2)*(q+2)
c=pow(m,e,n)

print(n)
print(not_phi)
print(c)


'''
96557532552764825748472768984579682122986562613246880628804186193992067825769559200526147636851266716823209928173635593695093547063827866240583007222790344897976690691139671461342896437428086142262969360560293350630096355947291129943172939923835317907954465556018515239228081131167407674558849860647237317421
96557532552764825748472768984579682122986562613246880628804186193992067825769559200526147636851266716823209928173635593695093547063827866240583007222790384900615665394180812810697286554008262030049280213663390855887077502992804805794388166197820395507600028816810471093163466639673142482751115353389655533205
37077223015399348092851894372646658604740267343644217689655405286963638119001805842457783136228509659145024536105346167019011411567936952592106648947994192469223516127472421779354488529147931251709280386948262922098480060585438392212246591935850115718989480740299246709231437138646467532794139869741318202945
'''

from Crypto.Util.number import long_to_bytes
from sympy import mod_inverse

e = 65537
n = 96557532552764825748472768984579682122986562613246880628804186193992067825769559200526147636851266716823209928173635593695093547063827866240583007222790344897976690691139671461342896437428086142262969360560293350630096355947291129943172939923835317907954465556018515239228081131167407674558849860647237317421
not_phi = 96557532552764825748472768984579682122986562613246880628804186193992067825769559200526147636851266716823209928173635593695093547063827866240583007222790384900615665394180812810697286554008262030049280213663390855887077502992804805794388166197820395507600028816810471093163466639673142482751115353389655533205
c = 37077223015399348092851894372646658604740267343644217689655405286963638119001805842457783136228509659145024536105346167019011411567936952592106648947994192469223516127472421779354488529147931251709280386948262922098480060585438392212246591935850115718989480740299246709231437138646467532794139869741318202945

# 计算 φ(n)
phi_n = (3 * n - not_phi + 6) // 2
print("φ(n):", phi_n)

# 计算私钥 d
d = mod_inverse(e, phi_n)

if d:
    # 解密消息
    m = pow(c, d, n)
    
    # 将解密后的长整型数转换为字节
    flag_bytes = long_to_bytes(m)
    print("解密后的消息:", flag_bytes.decode())
else:
    print("无法计算私钥 d。")

import sqlite3
import json
import re
from tqdm import tqdm
from datetime import datetime, timezone, timedelta

# Create database file
with open("data.db", "w", encoding="utf8") as f:
    pass


def time2ts(TIME_STRING: str) -> int:
    """
    This is a function that can convert the time expression to timestamp

    Parameter:
        TIME_STRING(str): The time string

    Returns:
        int: The timestamp of the time string
    """
    time_str = TIME_STRING
    # Transfer timestring to datetime format time
    dt = datetime.fromisoformat(time_str)
    # Change time to UTC
    timestamp = dt.timestamp()
    return timestamp


def time2tsFromSubmission(TIME_STRING: str) -> int:
    # Transfet to datetime object
    dt_naive = datetime.strptime(TIME_STRING, "%Y/%m/%d %H:%M:%S")

    # Process timezone information
    timezone_offset = timedelta(hours=8)  # +08:00 UTC+8
    dt_with_timezone = dt_naive.replace(tzinfo=timezone(timezone_offset))

    # Change to timestamp
    timestamp = dt_with_timezone.timestamp()
    return timestamp


# Create database connection
conn = sqlite3.connect("data.db")


def importChallenges(challengeFilePath: str) -> None:
    # Create challenges table
    # id(PRIMARY), name, point, endat
    command = "CREATE TABLE challenges (id TEXT PRIMARY KEY, name TEXT, point INTEGER, endat TEXT);"
    cursor = conn.cursor()
    cursor.execute(command)
    conn.commit()

    # Read challenges from file
    with open(challengeFilePath, "r", encoding="utf8") as f:
        challenges = json.loads(f.read())

    # Insert challenges one by one
    for challenge in tqdm(challenges):
        challengeId = challenge["Id"]
        challengeName = challenge["Name"]
        challengePoints = challenge["Points"]
        challengeEndAt = time2ts(challenge["EndAt"])
        command = "INSERT INTO challenges (id, name, point, endat) VALUES (?, ?, ?, ?)"
        cursor.execute(
            command, (challengeId, challengeName, challengePoints, challengeEndAt)
        )
        conn.commit()


def importFlags(flagFilePath: str) -> None:
    # Create flags table
    # flag(PRIMARY), teamId, challengeId
    command = (
        "CREATE TABLE flags (flag TEXT PRIMARY KEY, teamId TEXT, challengeId TEXT)"
    )
    cursor = conn.cursor()
    cursor.execute(command)
    conn.commit()

    # Read flags from file
    with open(flagFilePath, "r", encoding="utf8") as f:
        flags = json.loads(f.read())

    # Insert flags on by one
    for flag in tqdm(flags):
        flagContent = flag["Flag"]
        flagTeam = flag["TeamId"]
        flagChallenge = flag["ChallengeId"]
        command = "INSERT INTO flags (flag, teamId, challengeId) VALUES (?, ?, ?)"
        cursor.execute(command, (flagContent, flagTeam, flagChallenge))
        conn.commit()


def importSubmissions(submissionFilePath: str) -> None:
    # Create submission table
    # team, challenge, flag, who, ip, time
    command = "CREATE TABLE submissions (team TEXT, challenge TEXT, flag TEXT, who TEXT, ip TEXT, time INGETER)"
    cursor = conn.cursor()
    cursor.execute(command)
    conn.commit()

    # Read submission from file
    with open("submissions.log", "r", encoding="utf8") as f:
        lines = f.readlines()

    # Extract data from line and insert into database
    # [2024/8/31 15:12:50 +08:00 INF] FlagChecker: 队伍 [Aida Bartoletti] 提交题目 [[Week2] ez_crypto] 的答案 [BaseCTF{400e0fde-cc12-3cf8-fbfd-32ae7bfd60e6}] <Merl.Smitham39> @ 108.237.78.233
    for line in tqdm(lines):
        # Extract time
        time = re.search(
            r"\[\d{4}/\d{1,2}/\d{1,2} \d{1,2}:\d{1,2}:\d{1,2} \+\d{2}:\d{2} INF\]", line
        )
        time = time.group().strip("[]") if time else ""
        time = time2tsFromSubmission(time.replace(" +08:00 INF", ""))
        # Extract team name
        team = re.search(r"队伍 \[(.+?)\]", line)
        team = team.group(1) if team else ""
        # Extract challenge name
        challenge = re.search(r"题目 \[\[Week\d\](.+?)\]", line)
        week = re.findall(r"\[Week\d\]", line)[0]
        challenge = week + " " + challenge.group(1).strip() if challenge else ""
        # Extract flag
        flag = re.search(r"BaseCTF\{[^\}]+\}", line)
        flag = flag.group() if flag else ""
        # Extract who submit the flag
        who = re.search(r"<([^<>]+)> @ \d+\.\d+\.\d+\.\d+$", line)
        who = who.group(1) if who else ""
        # Extract the ip address
        ip = re.search(r" @ (\d+\.\d+\.\d+\.\d+)", line)
        ip = ip.group(1) if ip else ""
        command = "INSERT INTO submissions (team, challenge, flag, who, ip, time) VALUES (?, ?, ?, ?, ?, ?)"
        cursor.execute(command, (team, challenge, flag, who, ip, time))
        conn.commit()


def importTeamsAndUsers(teamsFilePath: str) -> None:
    # Create teams table
    # id(PRIMARY), name, member1, member2
    command = "CREATE TABLE teams (id TEXT PRIMARY KEY, name TEXT, member1 TEXT, member2 TEXT)"
    cursor = conn.cursor()
    cursor.execute(command)
    command = "CREATE TABLE users (id TEXT PRIMARY KEY, name TEXT)"
    cursor.execute(command)
    conn.commit()

    # Read teams from file
    with open(teamsFilePath, "r", encoding="utf8") as f:
        teams = json.loads(f.read())

    # Insert team data into database
    for team in tqdm(teams):
        teamId = team["Id"]
        teamName = team["Name"]
        member1 = team["Members"][0]["Id"]
        member2 = None
        command = "INSERT INTO users (id, name) VALUES (?, ?)"
        cursor.execute(
            command, (team["Members"][0]["Id"], team["Members"][0]["UserName"])
        )
        if len(team["Members"]) == 2:
            member2 = team["Members"][1]["Id"]
            cursor.execute(
                command, (team["Members"][1]["Id"], team["Members"][1]["UserName"])
            )
        command = "INSERT INTO teams (id, name, member1, member2) VALUES (?, ?, ?, ?)"
        cursor.execute(command, (teamId, teamName, member1, member2))
        conn.commit()


if __name__ == "__main__":
    importChallenges("challenges.json")
    importFlags("flags.json")
    importSubmissions("submission.log")
    importTeamsAndUsers("teams.json")

import sqlite3
import hashlib

# Create sqlite3 connection
conn = sqlite3.connect("data.db")


def getChallengeExpireTimeFromName(challenge: str) -> int:
    # Function for getting expire time of the challenge
    cursor = conn.cursor()
    command = "SELECT endat FROM challenges WHERE name=?"
    cursor.execute(command, (challenge,))
    time = int(cursor.fetchone()[0].replace(".0", ""))
    return time


def getTeamSubmissionsFromTeamName(team_name: str) -> list:
    # Function for getting submission of the team
    cursor = conn.cursor()
    command = "SELECT time, challenge FROM submissions WHERE team=?"
    cursor.execute(command, (team_name,))
    submission_list = cursor.fetchall()
    return submission_list


def getChallengeIdFromName(challenge_name: str) -> str:
    # Function for getting challengeId from name
    cursor = conn.cursor()
    command = "SELECT id FROM challenges WHERE name=?"
    cursor.execute(command, (challenge_name,))
    challenge_id = cursor.fetchone()[0]
    return challenge_id


if __name__ == "__main__":
    # All the expire time are the same, so use one as all
    expire_time = getChallengeExpireTimeFromName("[Week3] ez_log")
    submission_list = getTeamSubmissionsFromTeamName("Damien Schroeder")
    # Get all expired challenges
    expired_challenge_list = []
    submission_list.sort(key=lambda x: x[0])  # Sort by submit time
    for submission in submission_list:
        if submission[0] > expire_time:
            print(submission[0], expire_time, submission[1])
            expired_challenge_list.append(submission[1])
    # Get all ids of expired challenges
    expired_challenge_id_list = []
    for challenge in expired_challenge_list:
        expired_challenge_id_list.append(getChallengeIdFromName(challenge))
    # Connect all the challenge ids with comma
    expired_challenge_id_string = ""
    for challenge_id in expired_challenge_id_list:
        if expired_challenge_id_string == "":
            expired_challenge_id_string += challenge_id
        else:
            expired_challenge_id_string += "," + challenge_id
    # Calculate MD5
    result = hashlib.md5(expired_challenge_id_string.encode()).hexdigest()
    print(f"BaseCTF\{{result}\}")