Cryptordle

Just guess the word in 6 tries. What do you mean it’s hard?

By oops (former ISSS officer)

Officer in charge: jyu

nc betta.utctf.live 7496

We’re provided a Python source file:

1
#!/usr/bin/env python3
2
import random
3

4
wordlist = open('/src/wordlist.txt', 'r').read().split('\n')
5

6
for word in wordlist:
7
    assert len(word) == 5
8
    for letter in word:
9
        assert letter in 'abcdefghijklmnopqrstuvwxyz'
10

11
for attempt in range(3):
12
    answer = random.choice(wordlist)
13
    num_guesses = 0
14
    while True:
15
        num_guesses += 1
16

17
        print("What's your guess?")
18
        guess = input().lower()
19

20
        assert len(guess) == 5
21
        for letter in guess:
22
            assert letter in 'abcdefghijklmnopqrstuvwxyz'
23

24
        if guess == answer:
25
            break
26

27
        response = 1
28
        for x in range(5):
29
            a = ord(guess[x]) - ord('a')
30
            b = ord(answer[x]) - ord('a')
31
            response = (response * (a-b)) % 31
32
        print(response)
33
    if num_guesses > 6:
34
        print("Sorry, you took more than 6 tries. No flag for you :(")
35
        exit()
36
    else:
37
        print("Good job! Onward...")
38

39
if num_guesses <= 6:
40
    print('Nice! You got it :) Have a flag:')
41
    flag = open('/src/flag.txt', 'r').read()
42
    print(flag)
43
else:
44
    print("Sorry, you took more than 6 tries. No flag for you :(")

To be honest, when I solved this challenge, I somehow completely missed the PYthon source file. idk how, I’m blind I guess. Managed to solve it anyways with some observation skills :)

But regardless, the main observation here is that the number outputted for each guess is equivalent to the product of all the differences between the correct answer and the guess, character-by-character. Of course, this guess is equivalent to 0 if one of the characters is correct.

With some testing by sending the following guesses:

1
aaaaa
2
baaaa
3
caaaa
4
daaaa
5
etc. etc.

I realized that the guess changed by a fixed amount for each one-letter change. Knowing that a guess is 0 if one character is correct, we can very easily calculate the correct letter for that position given that fixed amount via the following program:

1
all_a = ?
2
change = ?
3
for i in range(1, 26):
4
    all_a -= change
5
    all_a %= 31
6
    if all_a == 0:
7
        print(chr(ord('a') + i))

Naturally, this lead me to consider sending the following guesses:

1
aaaaa
2
baaaa
3
abaaa
4
aabaa
5
aaaba
6
aaaab

However, this would take up our 6 guesses, and we could only use 5 guesses before we needed to try to guess the actual word.

But, since I didn’t have the source file when I solved it (I assume there is a deterministic way to solve it with the source file), I simply cut the last string off, sending:

1
aaaaa
2
baaaa
3
abaaa
4
aabaa
5
aaaba

And then, since the wordlist includes actual words (which I had figured out once I solved one manually with >6 guesses), I just guessed the last character :)

Also, guessing was easier before because I actually did it when it was only 1 try.

Here’s the full implementation. Also, note that I ended up changing all a’s to all z’s in this script instead because having to solve 3 times in a row means a much higher likelihood that one word will contain an ‘a’. If it does, that makes most of the guesses return 0, which we don’t want!

1
from pwn import *
2
import solve2
3

4
p = remote('betta.utctf.live', 7496)
5

6
for i in range(3):
7
    p.recvline()
8
    p.sendline(b'b'*5)
9
    all_a = int(p.recvline().decode("ascii")[:-1])
10

11
    s = ''
12
    for j in range(4):
13
        p.recvline()
14
        payload = b'b'*j + b'c' + b'b'*(4-j)
15
        p.sendline(payload)
16
        x = int(p.recvline().decode("ascii")[:-1])
17
        if x == 0:
18
            print('0!!!')
19
            exit()
20
        res = solve2.s(all_a, (all_a - x) % 31)
21
        # print(res)
22
        s += res
23
    print(s)
24
    p.recvline()
25
    p.sendline(input().encode())
26

27
    print(p.recvline())
28

29
p.interactive()

solve2.py:

1
import string
2
def s(all_a, change):
3
    for i in range(1, 26):
4
        all_a -= change
5
        all_a %= 31
6
        if all_a == 0:
7
            return string.ascii_lowercase[(i + 1) % 26]

1
utflag{sometimes_pure_guessing_is_the_strat}