IT Days 2025 Capture the Flag: Unraveling the Challenges & Solutions

Hey everyone! I’m Ivan, the author of the challenges and the facilitator of the miniCTF event held during PUPSMB’s IT Days! This event was especially for the IT students of PUPSMB, designed to test and sharpen their problem-solving skills in cybersecurity. Today, I’ll be sharing the detailed solutions for all the challenges tackled during the competition. Whether you participated and want to review your approach or you’re just here to learn, this write-up will guide you through the thought process behind solving each challenge. Let’s dive in and break them down one by one!

Easy

1. BitstoBits

Ciphertext

Description

''.join([chr((ord(flag[i]) << 8) + ord(flag[i + 1])) for i in range(0, len(flag), 2)])

So basically, this Python expression encodes a string FLAG by processing it in pairs of characters, converting each pair into a single Unicode character. It does this by taking the ASCII value of the first character, shifting it left by 8 bits (essentially multiplying by 256), then adding the ASCII value of the second character. This forms a new integer, which is then converted into a character using chr(). Finally, all these transformed characters are joined into a single encoded string.

Solution

# Open and read the contents of the file "enc.txt"
encoded_flag = open("enc.txt").read()

# Initialize an empty string to store the decoded flag
flag = ""

# Iterate through each character in the encoded flag
for i in range(0, len(encoded_flag)):
    # Extract the first character by shifting right by 8 bits
    character1 = chr((ord(encoded_flag[i]) >> 8))
    
    # Extract the second character by encoding the character in UTF-16BE and taking the last byte
    character2 = chr(encoded_flag[i].encode('utf-16be')[-1])
    
    # Append the extracted characters to the flag
    flag += character1
    flag += character2

# Print the decoded flag
print("Flag: " + flag)

Output:

Flag: iSITE{16_b1tS_iS_bett3r}

2. Discord Detour

Description

A new Discord server has popped up, seemingly out of nowhere. Rumors say it holds the key to something important. We’ve heard whispers that the flag might be hidden somewhere within its channels. Can you navigate the server, explore its corners, and uncover the secret message?

When we open the discord server, it’s a bunch of gibberish series of text, but you know, this is the time for us to use specific keywords in order for us to get the flag.

Solution

Use CTRL^F and search for iSITE preffix, and scroll down (Lots of rabbit holes, so you need to test every single flag you captured.

After lot’s of bruteforcing/testing flag I’ve found, this one works!!

iSITE{i2_4Ng_d!sC0Rd_fL4G_N4_p4r4_SAu}

3. Image?

Description

Damn, I can’t open this image! Something’s wrong here, I guess.

When I try to open the PNG file, I’m unable to view its contents. Keep in mind that when working with images, it’s important to verify that the file’s signature is correct.

Solution

When I open the image file using hexeditor to view its file signature, I just noticed this

So I changed that to the original PNG signature

After that, I run the eog again,

iSITE{St3gSt3gSt3g}

4. LogOfJungle

Description

You’re given a server access log. Some of logs are weird. Can you recognize them?

The hint for this challenge is pretty straightforward, you just need to focus on the GET and PUT request!

Solution

After analyzing lots the log I found numerous base64 encoding strings. After that, since we only need to focus on GET and PUT request, I used grep to search for specific keyword like iSITE.

iSITE{y0u_c4ugHT_m3}

5. LogsOfSuspicion

Description

You’ve intercepted a log file from a web server, but something isn’t right. Can you please find it?

Solution

When you check the contents of the log file, you’ll find multiple records of login attempts. Upon closer inspection, you’ll notice that one particular IP address is repeatedly attempting to log in within very short time intervals. This pattern could indicate a brute-force attack or an automated script trying to gain access.

See the pattern?

And that’s the flag itself, xd. The IP!

iSITE{192.168.10.15}

6. MySecret

Description

iBOT discovered a pdf file to his system, but he can’t open it. Why? Can you help?

Solution

From the hint itself, “Sometimes, extensions are annoying”. It means that there’s something wrong about the file extension of the file, maybe it’s a photo, txt, etc.. Now if you use the command “file <filename>”, you will see the original format of the file and it’s a PNG! Not a PDF. Now all you need to do is to rename the file and change the extension to PNG to see the contents of that file.

iSITE{B4k4l_ak0}

7. NumbersOfDespair

Description

Numbers? or Places?

Solution

This is the given: 23 15 23 25 15 21 14 15 20 9 3 5 4

A sequence of numbers, did you notice anything? None of them go beyond 26, right? What could that imply? It suggests that the numbers might represent letter positions in the alphabet. If you substitute each number with its corresponding letter, you will form this word.

“WOWYOUNOTICED”

And that’s actually the flag!

iSITE{WOWYOUNOTICED}

8. OnandOff

Description

You’ve intercepted a mysterious file from a hacker group, but it looks like gibberish when you open it. Can you figure out what they’re hiding?

Solution

This is the given: 01101001 01010011 01001001 01010100 01000101 01111011 01011001 00110000 01110101 01011111 01101011 01001110 00110000 01110111 01011111 01101000 01001111 01010111 01011111 01110100 01101111 01011111 01100011 00110000 01101111 01101110 01110110 00110011 01110010 01110100 01011111 01101000 01110101 01101000 01111101

It’s obvious right? Binary! Very straightforward, you just need to convert it to ASCII.

iSITE{Y0u_kN0w_hOW_to_c0onv3rt_huh}

9. Rotate

Description

Huh? I can’t understand this. But a wise man told me <hint>

Solution

The hint is “Told me that I should rotate to the 13 place.” 13 place??? That’s the actual clue there, it means that you have to rotate at the 13th place in order to get the plaintext. This is clearly a ROT13 algorithm. All you need to do is to decode it with your favorite tool.

iSITE{ROt4te_by_13_pl4c3s}

10. Surprise

Ohhh someone send me a qrcode! Scan it!

Solution

If you scan the QR code or use zbari-mg to read the QR, you will see this:

NFJUSVCFPNJXK4TQOJUXGMZTGMZTGM35

It’s clearly a Base32!!!

iSITE{Surpris333333}

Medium

1. Allthatforaflag?

Description

Encoded with what?

Solution

The file’s content is gibberish but it’s actually a Base64 encoded 50x!! Now if you will use decoder applications or apps, it will not be advisable. You really need to make your own script in order for you to automate the decoding process.

import base64
import threading

def decode_base64(encoded_text, iterations):
    decoded_text = encoded_text.encode('utf-8')  # Convert to bytes
    for _ in range(iterations):
        decoded_text = base64.b64decode(decoded_text)  # Decode from base64
    return decoded_text.decode('utf-8')  # Convert back to string

def threaded_decoding(input_file, iterations):
    with open(input_file, 'r') as file:
        encoded_text = file.read()
    
    decoded_result = decode_base64(encoded_text, iterations)
    print("Decoded result:", decoded_result)
    return decoded_result

# Decode the result
output_file = "flag.txt"
decode_thread = threading.Thread(target=threaded_decoding, args=(output_file, 50))
decode_thread.start()
decode_thread.join()

Output

Decoded result: iSITE{t00_h4rd_f0R_m3_tO_n0t1c3d}

2. Dummyz

Description

I have this .bin file, but the content is non-sense. Is there anything useful here?

Solution

if you use cat to see the the contents if the .bin file, you’ll see nothing but unprintable characters. Now the hint “Be specific sometimes.” That’s a straightforward already, you will only need to use strings to print the printable characters and grep in order for you to get the flag.

strings isite.bin | grep “iSITE”

After that, you now have the flag

iSITE{Oh_NO_I'm_supP0s3d_to_b3_hidden}

3. iBOTLogin

Description

We’ve successfully captured iBOT’s Traffic, I wonder if there’s a login credential that we can use to gain access to one of iBOT’s accounts.

Solution

We are given a pcap file and our goal here is to find the login credentials of iBOT. If you will check the hex and the ASCII version of each http packet you will see the flag there.

iSITE{iBOT:i4mG0d123}

4. LostinGit

Description

Help!! I’m lost!

Solution

It’s all about the stashes, here’s the step for this challenge

Step 1: Recover lost commits

git reflog

Step 2: Check what stashes exist before applying or dropping them.

git stash list

Step 3: Check what modifications were stashed before applying them. (You will see the flag here)

git stash show -p stash@{0}

Output

iSITE{G1t_SK1llS_4r3_CruC14l}

5. MikuSoCute

Description

One of the cutest in Nakano sisters!

Solution

The description doesn’t reveal too much right? Xd. But the hint is very straightforward “MD”, which means? Metadata!!! If you use exiftool to see the metadata of the image, you will see this

There’s something in there….. And yes, that is the comment. It’s the flag but it’s ciphered. Now the author looks strange, 41?? Maybe the cipher is a caesar cipher and the shift value is 41. Now if we use cryptii for this one, this is the output

iSITE{t00_cut3_r1gHt?}

6. Randomize

Description

What is this txt file? So gibberish and some sort of RANDOM.

If you take a look at the lala.py, this is the content process of encryption

import random
def ce(txt, k):
    enco = []
    for i, char in enumerate(txt):
        enco_char = chr(ord(char) ^ (k + i))
        enco.append(enco_char)
    return ''.join(enco)
def main():
    strr = "Blehhhh"
    k = random.randint(1, 100)
    enco_res = ce(strr, k)
    with open("akjslausioaliahldoasaasaasaas.txt", "w") as f:
        f.write(enco_res)
if __name__ == "__main__":
    main()

The script defines a simple XOR-based encoding function that takes a string and a key, then encodes each character by XOR-ing its ASCII value with k + i, where i is the character's position in the string. The main function initializes a fixed string “Blehhhh”, generates a random key between 1and 100, encodes the string using ce, and writes the encoded result to a file named “ak…….txt”.

Solution

To reverse the encoding process, we need to decode the text using the same XOR operation. Since XOR is a reversible operation (A ^ B ^ B = A), we can apply the same function but with the encoded text as input. The decryption process involves reading the encoded content from the file, then applying chr(ord(char) ^ (k + i)) again using the same k value to retrieve the original characters. However, since k was randomly generated during encoding and not stored, decoding is impossible unless we know the exact k. If k were saved somewhere, we could simply pass the encoded text and k back into ce() to restore the original string. Alternatively, since k is limited to a range of 1 to 100, we can brute-force it by trying all possible values of k, applying the XOR operation in reverse for each, and checking which output produces a meaningful result. This method is computationally trivial given the small key space, making it an effective way to recover the original text even without knowing k.

def cd(txt, k):
    deco = []
    for i, char in enumerate(txt):
        deco_char = chr(ord(char) ^ (k + i))
        deco.append(deco_char)
    return ''.join(deco)

def is_valid_text(text):
    """ Check if the decrypted text is likely valid by filtering non-printable characters. """
    return all(32 <= ord(c) <= 126 for c in text)  # Only printable ASCII chars

def brute_force_decryption():
    with open("random.txt", "r") as f:
        enco_res = f.read()

    for k in range(1, 101):  # Try all k values from 1 to 100
        deco_res = cd(enco_res, k)
        if is_valid_text(deco_res):  # Check if output looks readable
            print(f"Possible key: {k} → Decrypted text: {deco_res}")

if __name__ == "__main__":
    brute_force_decryption()

Output

iSITE{r4nd0m_is_4lwAys_Gr34t}

Hard

1. EnigmaticBinary

The notorious hacker named iBOT has been discovered using a custom encryption tool to secure their communications. Your team managed to recover a binary file named enigmatic_binary and an encrypted file named encrypted_flag.txt. The binary seems to implement a unique encryption algorithm, but its inner workings are shrouded in mystery. Rumor has it that iBOT is known for his love of puzzles and anti-reversing techniques. Your mission is to reverse engineer the binary, uncover its secrets, and decrypt the flag before iBOT covers his tracks.

Encrypted text: <!”;S(.B7+’|7,e=s

Let’s analyze the binary file through Ghidra

As you can see here, the function FUN_0010123d takes an input, processes it using an XOR operation with a repeating key, and then increments each byte by one. The key used for XOR is embedded in the binary as 0x4f786148544f4269 “OxaHTOBi,”(Read it in reverse and replare O with r) and the loop applies it cyclically using modulo to determine the corresponding character. Each byte of the input is first XORed with the key and then incremented, making direct decryption impossible without reversing these steps. To recover the original data, we need to first subtract 1 from each byte and then XOR it again with the same key sequence. A simple script can be written to iterate over the encoded bytes, apply these reverse operations, and reconstruct the original plaintext, which is likely the flag.

Solution

def decrypt(data):
    key = "iBOTHaxOr"
    key_length = len(key)
    decrypted = bytearray()
    for i in range(len(data)):
        decrypted_byte = data[i] - 1  # Reverse the twist
        decrypted_byte ^= ord(key[i % key_length])  # XOR with key
        decrypted.append(decrypted_byte)
    return decrypted

with open("encrypted_flag.txt", "rb") as f:
    encrypted_data = f.read()

decrypted_data = decrypt(encrypted_data)
print(decrypted_data.decode())

Output

iSITE{wOw_your3_b3tter_th4n_iB0t}

2. iBOT_Encryption

Description

Doesn’t make sense right? You’re wrong! It’s iBOT’s Encryption algorithm! Can you crack it? By the way, I heard iBOT talking about “despair” earlier. Hope it can help you!

Encrypted Flag: [723075, 318153, 1937841, 1879995, 607383, 723075, 318153, 636306, 173538, 838767, 1937841, 1793226, 462768, 896613, 1706457, 28923, 636306, 260307, 404922, 780921, 173538, 665229, 2487378, 665229, 1359381, 578460, 173538, 1243689, 896613, 925536, 1127997, 1648611, 1446150, 0]

Let’s analyze the encrypt.py to understand how it was encrypted

from random import randint as r
import sys as s


def g1(g, x, p):
    return pow(g, x) % p


def e1(plaintext, key):
    c = []
    for c1 in plaintext:
        c.append(((ord(c1) * key * 311)))
    return c


def is_prime(p):
    v = 0
    for i in range(2, p + 1):
        if p % i == 0:
            v = v + 1
    return v <= 1


def d_xor_e(plaintext, text_key):
    c_t = ""
    k_l = len(text_key)
    for i, c in enumerate(plaintext[::-1]):
        k_c = text_key[i % k_l]
        c_t += chr(ord(c) ^ ord(k_c))
    return c_t


def d_xor_d(plaintext, text_key):
    c_t = ""
    k_l = len(text_key)

    for i, c in enumerate(plaintext[::-1]):
        k_c = text_key[i % k_l]
        c_t += chr(ord(c) ^ ord(k_c))

    plaintext = c_t
    c_t = ""

    for i, c in enumerate(plaintext[::-1]):
        k_c = text_key[i % k_l]
        c_t += chr(ord(c) ^ ord(k_c))

    plaintext = c_t
    c_t = ""

    for i, c in enumerate(plaintext[::-1]):
        k_c = text_key[i % k_l]
        c_t += chr(ord(c) ^ ord(k_c))

    return c_t


def t1(p_t, t_k):
    p = 97
    g = 31
    if not is_prime(p) and not is_prime(g):
        print("Enter prime numbers")
        return
    a = r(p-10, p)
    b = r(g-10, g)
    print(f"a = {a}")
    print(f"b = {b}")
    u = g1(g, a, p)
    v = g1(g, b, p)
    k = g1(v, a, p)
    b_k = g1(u, b, p)
    s_k = None
    if k == b_k:
        s_k = k
    else:
        print("Invalid key")
        return
    s_c = d_xor_e(p_t, t_k)
    c = e1(s_c, s_k)
    print(f'{c}')


def d1(c, k):
    p_t = ""
    for e_v in c:
        d_v = e_v // (k * 311)
        p_t += chr(d_v)
    return p_t


def t2():
    p = 97
    g = 31
    a = 94
    b = 29

    u = g1(g, a, p)
    v = g1(g, b, p)
    k = g1(v, a, p)
    b_k = g1(u, b, p)

    s_k = None
    if k == b_k:
        s_k = k
    else:
        print("Invalid key")
        return

    m = "BlehBlehBleh"
    t_k = "dedededededededededede"

    t1(m, t_k)


if __name__ == "__main__":
    t2()

I know, the name of functions and variables are random haha, but I designed it to make it more harder for participants. But basically, what it does is, it combines multiple encryption techniques, including XOR-based encryption, modular exponentiation, and a mathematical encoding scheme. It first establishes a shared key using a simplified Diffie-Hellman key exchange, where two numbers are raised to powers modulo a prime number. The plaintext is then transformed using an XOR function that applies a key repeatedly in a reversed sequence. After that, another encryption step multiplies each character’s ASCII value by a key and a constant value of 311. To decrypt, the encoded values must first be divided by the same constant and key, and the XOR operation must be reversed in the same manner. The script contains functions for checking if numbers are prime, generating keys, and processing encryption.

Solution

from random import randint as r

def g1(g, x, p):
    return pow(g, x) % p

def d1(c, k):
    p_t = ""
    for e_v in c:
        d_v = e_v // (k * 311)  # Reverse multiplication
        p_t += chr(d_v)
    return p_t

def d_xor_d(plaintext, text_key):
    c_t = ""
    k_l = len(text_key)

    for i, c in enumerate(plaintext[::-1]):
        k_c = text_key[i % k_l]
        c_t += chr(ord(c) ^ ord(k_c))

    plaintext = c_t
    c_t = ""

    for i, c in enumerate(plaintext[::-1]):
        k_c = text_key[i % k_l]
        c_t += chr(ord(c) ^ ord(k_c))

    plaintext = c_t
    c_t = ""

    for i, c in enumerate(plaintext[::-1]):
        k_c = text_key[i % k_l]
        c_t += chr(ord(c) ^ ord(k_c))

    return c_t  # Original message

def decrypt(ciphertext):
    # Given prime numbers used in Diffie-Hellman
    p = 97
    g = 31

    # The fixed values used in `t2()`
    a = 94
    b = 29

    # Compute the shared secret key
    u = g1(g, a, p)
    v = g1(g, b, p)
    k = g1(v, a, p)  # This is s_k, the shared key
    b_k = g1(u, b, p)

    if k != b_k:
        print("Key mismatch, decryption failed!")
        return

    s_k = k  # Secure key from Diffie-Hellman

    # text-key
    text_key = "despair"

    # Step 1: Reverse multiplicative encoding
    decrypted_stage1 = d1(ciphertext, s_k)

    # Step 2: Reverse XOR encryption
    plaintext = d_xor_d(decrypted_stage1, text_key)

    return plaintext

ciphertext = [723075, 318153, 1937841, 1879995, 607383, 723075, 318153, 636306, 173538, 838767, 1937841, 1793226, 462768, 896613, 1706457, 28923, 636306, 260307, 404922, 780921, 173538, 665229, 2487378, 665229, 1359381, 578460, 173538, 1243689, 896613, 925536, 1127997, 1648611, 1446150, 0]

decrypted_message = decrypt(ciphertext)
print("Decrypted Message:", decrypted_message)

This solution reverses the encryption process by first reconstructing the shared key using the given Diffie-Hellman parameters and then applying decryption steps. It starts by computing the shared key using modular exponentiation, ensuring both parties derive the same key. The ciphertext, which was originally encoded by multiplying each character’s ASCII value with the shared key and a constant, is first reversed by performing integer division to retrieve the original ASCII values. After this, the script undoes the XOR-based transformation by applying the XOR operation three times with the known text key, effectively restoring the original plaintext.

Output

Decrypted Message: iSITE{You_d3stroyed_my_3ncrypt10n}

3. SilentVault

Description

Deep within the digital abyss lies a vault, shrouded in mystery and guarded by iBOT, the enigmatic iSITE bot. Known for its love of intricate puzzles, iBOT has woven a web of cryptographic defenses to protect the vault’s secrets. Your mission is to outsmart iBOT, navigate its labyrinth of cryptographic locks, and uncover the hidden treasure.

We are given 2 files here: vault_encrypted.bin, vault_public_key.pem

Solution

This is a little bit complex now, xd. First we will need to extract the private_key.pem, but where?? Because we need the private key for the whole process of decryption.

Now if you list all the files, you will see a jpeg file called .grandma.jpeg. That’s where the private key is stored. Now to extract, we will use steghide, but this one has no passphrase

steghide extract -sf .grandma.jpg

head -c 256 vault_encrypted.bin > encrypted_aes_key.bin

First we need to extract the first 256 bytes of the vault_encrypted.bin file and saves them into a new file called encrypted_aes_key.bin. The -c 256 option tells head to read only the first 256 bytes. In RSA encryption, the ciphertext size is determined by the key size. For a 2048-bit RSA key, the encrypted output is 256 bytes. The first 256 bytes of vault_encrypted.bin contain the RSA-encrypted AES key, which must be isolated before it can be decrypted.

openssl pkeyutl -decrypt -inkey private_key.pem -in encrypted_aes_key.bin -out aes_key.bin

Second, we will use openssl to decrypt the RSA-encrypted AES key (encrypted_aes_key.bin) using the private key (private_key.pem). The -decrypt flag specifies decryption mode, while -inkey, -in, and -out specify the private key, input file, and output file, respectively. The AES key was encrypted using the RSA public key, so the corresponding private key is required to decrypt it. Without decrypting the AES key, you cannot proceed to decrypt the flag, making this step crucial.

tail -c +257 vault_encrypted.bin > encrypted_flag.bin

We will extract all bytes starting from the 257th byte of vault_encrypted.bin and saves them into a new file called encrypted_flag.bin. The -c +257 option tells tail to start reading from byte 257 to the end of the file. The first 256 bytes of vault_encrypted.bin contain the RSA-encrypted AES key, and the remaining bytes contain the AES-encrypted flag. Isolating the encrypted flag ensures that only the relevant data is decrypted in the next step.

openssl enc -d -aes-256-cbc -in encrypted_flag.bin -out flag.txt -kfile aes_key.bin

We will use openssl again to decrypt the AES-encrypted flag (encrypted_flag.bin) using the decrypted AES key (aes_key.bin). The -d flag specifies decryption mode, -aes-256-cbc specifies the encryption algorithm, and -in, -out, and -kfile specify the input file, output file, and key file, respectively. The flag was encrypted using AES-256-CBC, so the correct AES key is required to decrypt it. This step is the final hurdle to retrieving the flag, making it the most critical part of the solution.

At this point, the flag is now decrypted and saved as flag.txt

Output of flag.txt

iSITE{1t's_n0t_a_S3cr3t_4nym0re}

4. DoesItMatter

Description

Not all information is visible to the naked eye. Sometimes, the most important details are hidden beneath the surface, just like in life. People may seem fine on the outside, but inside, they could be struggling with things you don’t see. In this image, data is hidden in the smallest details. Try examining the least significant bits (LSB) of each pixel, you may find a pattern. Steghide is USELESS here. If something looks unusual, consider converting the extracted data into a readable format. Perhaps it’s something that can be scanned?

First, what is LSB?

Least Significant Bit (LSB) is the lowest-order bit in a binary number, representing the smallest value in the system’s place hierarchy. In digital systems, LSB is often used in steganography, where data is hidden by modifying the least significant bits of an image, audio, or video file, making the changes nearly imperceptible. In numerical operations, it plays a crucial role in determining whether a number is odd or even, as the LSB of an odd number is always 1, while for an even number, it is 0. Additionally, in bitwise operations and data transmission, LSB manipulation is a common technique for encoding information with minimal alteration to the original data.

In the challenge, this is the given image

At first glance, the image looks completely normal, but something is hidden beneath the surface — a QR code embedded within the image data. This is a classic case of LSB steganography, where data is concealed within the least significant bits of pixel values, making it invisible to the naked eye. To extract the hidden information, we need to analyze the least significant bits of each pixel and reconstruct the original data. But how do we do that? How do we get the LSB?

Solution

from PIL import Image
import numpy as np

# Open the cover-secret image
cover_secret = Image.open("doesitmatter.png").convert('L')

# Convert the image to a numpy array
data = np.array(cover_secret)

# Extract the least significant bit (LSB) from each pixel
# LSB of each pixel is the bit we embedded in the image
extracted_data = data & 1  # Extract LSB (this will return 0 or 1)

# Convert extracted data to 1-bit image (same size as the secret QR code image)
extracted_qr = Image.fromarray(extracted_data * 255)  # Multiply by 255 to get black and white (0 or 255)

# Save and show the extracted QR code
extracted_qr.save("extracted_qr.png")
extracted_qr.show()

My solution utilizes the PIL library to extract hidden data from an image using LSB steganography. First, the image is loaded and converted to grayscale to simplify pixel manipulation. The pixel data is then stored as a NumPy array, allowing for efficient bitwise operations. By performing a bitwise AND operation with 1, the script isolates the least significant bit of each pixel, revealing the embedded hidden data. Since LSB values are either 0 or 1, multiplying the result by 255 converts it into a clear black-and-white image, reconstructing the hidden QR code.

Here’s the content of the QR Code

Base64:>>>>

Here’s the plaintext

Right now, I’m drowning in this overwhelming feeling of depression, like the weight of the world is pressing down on me, leaving me trapped in a cage of loneliness. I can’t shake the thought that I’m not worth anything, not even love. Every day feels like a struggle to just exist, and I can’t help but wonder if anyone would even care if I disappeared. It’s hard to see through the darkness, to believe there’s a way out when it feels like I’m constantly falling. But deep down, even though it seems impossible, I know I have to keep going. Maybe the pain will fade one day, maybe I’ll find my way back to myself and realize that I’m worthy of something better. But for now, I’ll hold on to the one thing that keeps me going: my fight. And maybe, just maybe, hidden somewhere in the mess of my thoughts, there’s a flag waiting to be found:

iSITE{1_will_r1s3_ag4in}

I created the “DoesItMatter” challenge as a personal tribute to myself, a reminder of my battle against depression, my relentless search for meaning, and my struggle to understand my own existence. This challenge represents more than just a puzzle; it embodies the internal conflicts, the moments of doubt, and the resilience needed to push forward despite uncertainty. Just like uncovering hidden data within an image, I continue to peel back the layers of my own journey, seeking clarity and purpose in a world that often feels overwhelming^_^

That’s all! Thank you for taking the time to read through this, and to all the participants, I truly appreciate the effort, determination, and patience you put into solving the challenges I created. Seeing you all push your limits, think outside the box, and unravel the mysteries behind each challenge means a lot to me. Whether you solved them all or struggled along the way, your willingness to take on the challenge is what truly matters. Keep pushing forward, keep learning, and stay curious. Until next time! Thank you!