Rad Be Damned

My friend seems to be communicating something but I can’t make out anything. Why do we live so close to Chernobyl anyways?

message.py
output.txt

Here’s the Python source:

1
import random
2
def find_leftmost_set_bit(plaintext):
3
    pos = 0
4
    while plaintext > 0:
5
        plaintext = plaintext >> 1
6
        pos += 1
7
    return pos
8

9
def encrypt(plaintext: str):
10
    enc_plaintext = ""
11

12
    for letter in plaintext:
13
        cp = int("10011", 2)
14
        cp_length = cp.bit_length()
15
        bin_letter, rem = ord(letter), ord(letter) * 2**(cp_length - 1)
16
        while (rem.bit_length() >= cp_length):
17
            first_pos = find_leftmost_set_bit(rem)
18
            rem = rem ^ (cp << (first_pos - cp_length))
19
        enc_plaintext += format(bin_letter, "08b") + format(rem, "0" + f"{cp_length - 1}" + "b")
20

21
    return enc_plaintext
22

23
def rad(text: str):
24
    corrupted_str = ""
25
    for ind in range(0, len(text), 12):
26
        bit_mask = 2 ** (random.randint(0, 11))
27
        snippet = int(text[ind : ind + 12], base = 2)
28
        rad_str = snippet ^ bit_mask
29
        corrupted_str += format(rad_str, "012b")
30
    return corrupted_str
31

32
def main():
33
    with open('flag.txt') as f:
34
        plaintext = f.read().strip()
35
    enc_plaintext = encrypt(plaintext)
36
    cor_text = rad(enc_plaintext)
37
    print(cor_text)
38

39
if __name__ == '__main__':
40
    main()

Basically, for every 12-bit string, the first 8 bits is equivalent to the ASCII code. The remaining 4 bits are deterministically calculated from the ASCII code of the original character. But, one random bit of the 12 is flipped.

To solve this, we can calculate the 4-bit codes of every possible character. Some of them will repeat since there are only 16 possible 4-bit codes and there are 128 ASCII characters. Therefore, for every 4-bit code, we will make an array of the possible ASCII characters.

Then, for every 12-bit string, we’ll take the first 8 bits and create a set of all the possible corresponding ASCII characters, flipping one of the bits each time. We’ll also take the last 4 bits and match it to the corresponding possible ASCII character set. We will then find the intersection of these two sets.

If a bit was flipped in the first 8 bits, the intersection of the 2 sets should produce the correct ASCII character. If a bit was flipped in the last 4 bits instead, the intersection of the 2 sets will be empty, in which case the 8 bits correspond to the correct ASCII character.

Thus, here is the solve script:

1
from Crypto.Util.number import *
2
import string
3

4
def find_leftmost_set_bit(plaintext):
5
    pos = 0
6
    while plaintext > 0:
7
        plaintext = plaintext >> 1
8
        pos += 1
9
    return pos
10

11
def encrypt(plaintext: str):
12
    enc_plaintext = ""
13

14
    for letter in plaintext:
15
        cp = int("10011", 2)
16
        cp_length = cp.bit_length()
17
        bin_letter, rem = ord(letter), ord(letter) * 2**(cp_length - 1)
18
        while (rem.bit_length() >= cp_length):
19
            first_pos = find_leftmost_set_bit(rem)
20
            rem = rem ^ (cp << (first_pos - cp_length))
21
        enc_plaintext += format(bin_letter, "08b") + format(rem, "0" + f"{cp_length - 1}" + "b")
22

23
    return enc_plaintext
24

25
ct = '011000001011010000111000011000111110011000111100011101001100001001100111011111110110011110010100011100010111011011111001010011011011010100011010001010011110010110010000001110111010001000011100011100011100010011111101010101101011110000110010001101100011011010100011001001010010001011011111011110000010001101100110010000110011011101110101010010111000011100011001010100011001001000111000001101010001011000100111010011000001011100011111111101010111010001001000001101000000001101011100010101101010101011011110011010100010010010010011010101010101010000010000001011011100011000011010010000111110001110011111011100011101010110001010010100100111001110011100011010101000011000101010001000101001001100011101111101100010010011100000010101111010011101101000011100100101001001000001010001111111010001001101111110100101011111001100'
26

27
a = []
28
b = []
29
for i in range(len(ct)//12):
30
    a.append(ct[i*12:i*12+8])
31
    b.append(ct[i*12+8:i*12+12])
32

33
charset = ''
34
for i in range(32, 128):
35
    charset += chr(i)
36

37
res = encrypt(charset)
38

39
d = dict()
40
for i in range(len(res)//12):
41
    s = res[i*12+8:i*12+12]
42
    if s not in d.keys():
43
        d[s] = list()
44
    d[s].append(charset[i])
45

46

47
flag = ''
48
for i in range(len(a)):
49
    x = int(a[i], 2)
50
    s = set()
51
    for j in range(8):
52
        s.add(chr(x ^ 1<<j))
53
    y = b[i]
54
    inter = s.intersection(set(d[y]))
55
    flag += str(inter)[2] if len(inter) > 0 else chr(x)
56

57
print(flag)

1
bcactf{yumMY-y311OWC4ke-x7CwKqQc5fLquE51V-jMUA-aG9sYS1jb21vLWVzdGFz}