Challenge Overview

Challenge Name: Ancient Text Category: Crypto Points: 496 Flag Format: hack10{text} Author: hikki

The challenge provides an image containing two lines of unknown symbols. The story references Frieren, where ancient text is commonly shown as a fictional symbolic language.

The goal is to decrypt the inscription and recover the flag in lowercase format.

Initial Analysis

The provided image contains two lines of symbols. Important observations:

1. The text has clear spacing between words.

2. Some symbols repeat.

3. The challenge theme mentions Frieren, which hints that the symbols may represent an ancient/fantasy alphabet.

4. The text does not appear to be encrypted mathematically. It looks more like a substitution cipher.

The visible structure is:

[3 symbols] [4 symbols] [2 symbols]
[8 symbols]

In a CTF crypto challenge, a very common phrase matching the first line is:

the flag is

This matches the word lengths:

the  = 3 letters
flag = 4 letters
is   = 2 letters

Vulnerability / Weakness Identification

The weakness is that the “ancient text” is only a static substitution cipher.

Each symbol directly maps to one English character. Since word spacing is preserved, the message becomes easier to decode using pattern matching.

The first line gives a strong known-plaintext clue:

the flag is

Once that phrase is identified, the remaining symbols can be mapped and the second line can be decoded.

Exploitation Strategy

The solving strategy is:

1. Treat every unique symbol as one alphabet character.

2. Use the first line pattern to infer the phrase the flag is.

3. Build a partial substitution table from that known phrase.

4. Apply the same symbol mapping to the second line.

5. Decode the second line as the flag content.

6. Wrap the decoded text inside the required format:

hack10{decoded_text}

From decoding the second line, the plaintext becomes:

zoltraak

Proof of Concept

The inscription decodes to:

the flag is
zoltraak

Since the challenge says the flag format is:

hack10{text}

The final flag content is:

zoltraak

Therefore, the flag is:

hack10{zoltraak}

Full Python Solver

#!/usr/bin/env python3

"""
Ancient Text Solver
Hack@10 CTF

This solver demonstrates the substitution logic used to decode the challenge.

The first line is assumed to decode to:
    the flag is

From that known plaintext, we map each symbol/token to a letter.
Then we decode the second line.
"""

# The symbols are represented manually as tokens because the image symbols
# are handwritten and cannot be typed directly in a reliable way.
#
# Line 1 pattern:
#   THE FLAG IS
#
# Line 2 pattern:
#   ZOLTRAAK

line1_symbols = [
    "sym_t", "sym_h", "sym_e",
    "sym_f", "sym_l", "sym_a", "sym_g",
    "sym_i", "sym_s"
]

line1_plaintext = "theflagis"

line2_symbols = [
    "sym_z", "sym_o", "sym_l", "sym_t",
    "sym_r", "sym_a", "sym_a", "sym_k"
]

# Build known mapping from line 1
mapping = {}

for symbol, letter in zip(line1_symbols, line1_plaintext):
    mapping[symbol] = letter

# Add decoded symbols from visual/manual analysis of the second line
mapping.update({
    "sym_z": "z",
    "sym_o": "o",
    "sym_l": "l",
    "sym_t": "t",
    "sym_r": "r",
    "sym_a": "a",
    "sym_k": "k",
})

decoded_second_line = "".join(mapping[symbol] for symbol in line2_symbols)

flag = f"hack10{{{decoded_second_line}}}"

print("[+] Decoded text:")
print("the flag is")
print(decoded_second_line)

print("\n[+] Flag:")
print(flag)

Walkthrough

Save the script as:

solve.py

Run it with Python:

python3 solve.py

Expected output:

[+] Decoded text:
the flag is
zoltraak

[+] Flag:
hack10{zoltraak}

No external Python dependencies are required.

Flag

hack10{zoltraak}

Conclusion

The challenge is solved by recognizing that the unknown symbols are not strong cryptography, but a simple substitution-style writing system. The preserved word spacing and CTF context make the first line highly likely to be the flag is.

After mapping the symbols and decoding the second line, the recovered flag content is zoltraak.

The key lesson is: always check for simple encodings, substitution ciphers, and contextual clues before assuming a challenge requires complex cryptanalysis.