Understanding the Encryption#

Step 1: Setting up the variables

• LOWERCASE_OFFSET = ord("a") → This is 97, used to convert letters to numbers
• ALPHABET = string.ascii_lowercase[:16] → This creates a reduced alphabet: a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p (only 16 characters)

Step 2: The b16_encode function

This function converts plaintext to a special base-16 format. Here’s what it does step-by-step:

1. Takes each character from the flag
2. Converts it to 8 binary digits (its ASCII value in binary)
3. Splits those 8 digits into two groups of 4 digits each
4. Treats each group as a number (0-15)
5. Maps each number to a letter (a=0, b=1, c=2… p=15)
6. Combines these two letters to encode one character

Example: Encoding the letter ‘a’

• ASCII value: 97
• Binary form: 01100001
• First 4 bits: 0110 = 6 in decimal → maps to letter g
• Last 4 bits: 0001 = 1 in decimal → maps to letter b
• Final encoded result: gb (represents the original ‘a’)

Step 3: The shift function

This function applies a simple shift cipher (like the traditional Caesar cipher):

• Takes an encoded character and a key character
• Converts each to a number (a=0, b=1, c=2… p=15)
• Adds the two numbers together
• Uses modulo 16 to wrap around if needed (so it stays in the a-p range)
• Converts the result back to a letter

Example: Shifting ‘g’ with key ‘c’

• ‘g’ = 6, ‘c’ = 2
• 6 + 2 = 8
• 8 maps to letter ‘i’
• Result: ‘i’

Step 4: Encryption process The algorithm:

1. Encodes the flag using b16_encode
2. For each character in the encoded message, shifts it by the key
3. Since len(key) == 1, the same single key character is used for all positions

Key Weakness#

The assertion assert len(key) == 1 tells us the key is only 1 character long. This means there are only 16 possible keys (a through p). We can brute-force all of them!

Creating the Decryption Script#

My solution:

1
import string
2

3
LOWERCASE_OFFSET = ord("a")
4
ALPHABET = string.ascii_lowercase[:16]
5

6
def b16_decode(enc):
7
    """Converts base-16 encoded text back to plaintext"""
8
    dec = ""
9
    for i in range(0, len(enc), 2):
10
        # Get two characters from the encoded message
11
        c1 = ALPHABET.index(enc[i])
12
        c2 = ALPHABET.index(enc[i + 1])
13

14
        # Combine the two 4-bit values back into 8 bits
15
        byte_value = (c1 << 4) + c2
16

17
        # Convert back to ASCII character
18
        dec += chr(byte_value)
19
    return dec
20

21
def unshift(c, k):
22
    """Reverses the shift operation"""
23
    t1 = ord(c) - LOWERCASE_OFFSET
24
    t2 = ord(k) - LOWERCASE_OFFSET
25
    # Subtract instead of add, and use modulo to handle negative numbers
26
    return ALPHABET[(t1 - t2) % len(ALPHABET)]
27

28
def decrypt(ciphertext, key):
29
    dec = ""
30
    for i, c in enumerate(ciphertext):
31
        # Reverse the shift
32
        dec += unshift(c, key[i % len(key)])
33
    return b16_decode(dec)
34

35
# The encrypted message from the challenge
36
encrypted = "fegdeogdgecoeocgcgchcfcffccfca"
37

38
# Try all 16 possible keys (a through p)
39
for key_char in ALPHABET:
40
    try:
41
        result = decrypt(encrypted, key_char)
42
        print(f"Key: {key_char} →  picoCTF{{{result}}}")
43
    except:
44
        print(f"Key: {key_char} → Invalid result")

Output#

Most will produce unreadable gibberish, but one will show readable text that makes sense :

1
$ python solve.py
2
Key: a → picoCTF{TcNcd.N&&'%%R% }
3
Key: b → picoCTF{CR=RS=A}
4
Key: c → picoCTF{2A,AB,0}
5
Key: d → picoCTF{!01ûóôòò/òý}
6
Key: e → picoCTF{/ê ââãáááì}
7
Key: f → picoCTF{ùÙùÑÑÒÐÐ ÈèÀÀÁÏÏüÏÊ}
8
Key: g → picoCTF{þýÐýþ¿Ðç翾¾ê¾¹}
9
Key: h → picoCTF{íüÃ, üý·Ã, ¿¿°¾¾ë¾¹}
10
Key: i → picoCTF{ÜëÆëì¦Æ®®¯­­Ú­¨}
11
Key: j → picoCTF{ËÚµÚÛµÉ}
12
Key: k → picoCTF{ºÉ¤Éʤ¸}
13
Key: l → picoCTF{©¸¸¹s{{|zz§zu}
14
Key: m → picoCTF{§§¨bjjkiiid}
15
Key: n → picoCTF{qQqYYZXXXS}
16
Key: o → picoCTF{v`@`HHIGGtGB}
17
Key: p → picoCTF{et_tu_77866c61}

Finding the Correct Flag#

Looking at all 16 results, only one contains readable words and valid characters:

picoCTF{et_tu_77866c61}

âš¡ Raikiri

🎉 Flag pwned!

💡 TL;DR / Lesson Learned

✅ Base-16 encoding converts data using only 16 symbols (0-15, represented as a-p)
✅ Single-character keys are extremely weak - only 16 possibilities to brute-force
✅ Combining two weak ciphers doesn’t create strong encryption - both layers must be broken
✅ Always read the code for clues - the assert statements revealed the key length was just 1
✅ Brute-force is valid when key space is small - with 16 possibilities, trying them all is practical
✅ Look for readable output - the correct flag stands out from gibberish immediately