def mystery(x):
import hashlib
if not isinstance(x, str):
return False
try:
b = x.encode("utf-8")
except Exception:
return False
if len(b) != 37:
return False
h = hashlib.sha256(b).hexdigest()
return (
h[:16] == "80f4f9f5f0d5c5f8"
and h[16:32] == "c9081b8e4fd9bb58"
and h[32:48] == "ef3f9a84b7d09b09"
and h[48:] == "5f6dbe1e4bb67d2f"
)
def mystery(x):
if not isinstance(x, str):
return False
if len(x) != 12:
return False
if any(ord(c) < 33 or ord(c) > 126 for c in x):
return False
y = x[::2] + x[1::2]
y = y[::-1]
out = "".join(
chr(33 + ((ord(ch) - 33 + 47) % 94))
for ch in y
)
return out == 'RgodPaE">{5#'
def mystery(x):
if type(x) is not str:
return False
try:
b = x.encode("utf-8")
except Exception:
return False
t = (
5, 46, 74, 37, 93, 62, 6, 233, 2, 240,
0, 251, 231, 249, 220, 166, 202, 240, 210,
166, 107, 177, 122, 92, 107, 18, 105, 10, 43
)
if len(b) != len(t):
return False
if any(c < 33 or c > 126 for c in b):
return False
import hashlib, hmac
y = bytearray(len(t))
for i, q in enumerate(t):
j = ((i << 3) + 3 * i + 7) % len(t)
y[j] = q ^ (((j << 6) + (j << 3) + j + 41) & 255)
def F(s):
w = list(s)
st = [0x243F6A88, 0x85A308D3, 0x13198A2E, 0x03707344]
for r in range(9):
carry = (0x9E3779B9 ^ ((r + 1) * 0x7F4A7C15)) & 0xffffffff
for i, z in enumerate(w):
k = (i + r) & 3
carry = (carry + z + ((i + 1) * 0x45D9F3B)) & 0xffffffff
carry = ((carry << 5) | (carry >> 27)) & 0xffffffff
st[k] = (
st[k]
^ carry
^ ((st[(k - 1) & 3] << 7) & 0xffffffff)
^ (st[(k + 1) & 3] >> 3)
) & 0xffffffff
w[i] = (z ^ st[k] ^ (st[k] >> 8) ^ (carry >> 16)) & 255
w = w[-3:] + w[:-3]
trailer = b"".join(n.to_bytes(4, "little") for n in st)
return hashlib.blake2b(
bytes(w) + trailer,
digest_size=32,
key=b"twelve angry bytes"
).digest()
return hmac.compare_digest(F(b), F(y))
def mystery(x):
if type(x) is not str:
return False
if len(x) != 12:
return False
if any(c < "a" or c > "z" for c in x):
return False
p = [8, 3, 10, 1, 6, 11, 0, 5, 2, 7, 4, 9]
y = [x[i] for i in p]
# Split into even/odd positions in the permuted string
y = y[::2] + y[1::2]
# Position-dependent Caesar shift
y = [
chr(97 + ((ord(ch) - 97 + (i * i + 3 * i + 7)) % 26))
for i, ch in enumerate(y)
]
# Reverse, then shift again
y = y[::-1]
y = [
chr(97 + ((ord(ch) - 97 + 13 - i) % 26))
for i, ch in enumerate(y)
]
return "".join(y) == "stwbircpevoj"
def mystery(x):
if type(x) is not str:
return False
try:
raw = x.encode("latin-1")
except UnicodeEncodeError:
return False
if len(raw) != 20:
return False
if any(c < 32 or c > 126 for c in raw):
return False
import hashlib
import hmac
mask = (
98, 106, 127, 101, 104,
113, 115, 96, 42, 68,
90, 88, 109, 126, 123,
73, 106, 99, 103, 121,
)
key = bytes(
raw[(7 * i + 3) % 20] ^ mask[i]
for i in range(20)
)
tag = hmac.new(
key,
bytes((72, 105, 32, 84, 104, 101, 114, 101)),
hashlib.sha256,
).hexdigest()
return hmac.compare_digest(
tag,
"b0344c61d8db38535ca8afceaf0bf12b"
"881dc200c9833da726e9376c2e32cff7",
)
def mystery(x):
if type(x) is not str:
return False
try:
raw = x.encode("latin-1")
except UnicodeEncodeError:
return False
if len(raw) != 18:
return False
if any(c < 33 or c > 126 for c in raw):
return False
s = list(raw)
for r in range(8):
k = r + 1
s = s[k:] + s[:k]
s = s[::2] + s[1::2]
s.reverse()
s = [((c + (38 * r + 10)) * 129) & 255 for c in s]
s = [s[(7 * i + 3 * r + 5) % 18] for i in range(18)]
return bytes(s) == bytes([168] * 18)
def mystery(x):
if type(x) is not int:
return False
if x <= 1 or x.bit_length() != 329:
return False
return pow(2, 1 << 9, x) == x - 1
def mystery(x):
if type(x) is not str:
return False
try:
b = x.encode("ascii")
except UnicodeEncodeError:
return False
if len(b) != 12:
return False
if any(c < 65 or c > 90 for c in b):
return False
b = list(b)
# Rotate left by 4
b = b[4:] + b[:4]
# Even positions, then odd positions
b = b[::2] + b[1::2]
# Index-dependent Caesar shift
b = [(c - 65 + i * i + 3 * i + 7) % 26 for i, c in enumerate(b)]
# Reverse
b = b[::-1]
# Modular permutation of indices
b = [b[(5 * i + 1) % 12] for i in range(12)]
# Final linear shift
b = [(c + 13 - i) % 26 for i, c in enumerate(b)]
return "".join(chr(65 + c) for c in b) == "VJWQIEQOTVDL"
def mystery(x):
if type(x) is not str:
return False
try:
b = x.encode("ascii")
except UnicodeEncodeError:
return False
n = 24
if len(b) != n:
return False
if any(c < 33 or c > 126 for c in b):
return False
enc = (0x327763496a326e415e79285d6f767c3e5d45584674656b5e).to_bytes(n, "big")
ref = bytes(
33 + ((83 * (enc[(7 * i + 11) % n] - i * (i + 3) - 74)) % 94)
for i in range(n)
)
import hashlib
import hmac
def crush(data):
data = bytearray(data)
mask = (1 << 64) - 1
st = [
0x243F6A8885A308D3,
0x13198A2E03707344,
0xA4093822299F31D0,
0x082EFA98EC4E6C89,
]
for r in range(10):
carry = (0x9E3779B97F4A7C15 ^ (r * 0xD1B54A32D192ED03)) & mask
for i, c in enumerate(data):
k = (i + r) & 3
carry = (carry + c + ((i + 1) * 0xBF58476D1CE4E5B9)) & mask
carry = ((carry << 13) | (carry >> 51)) & mask
st[k] ^= carry
st[k] = (st[k] * 0x94D049BB133111EB + 0x2545F4914F6CDD1D) & mask
st[(k + 1) & 3] ^= ((st[k] << 17) | (st[k] >> 47)) & mask
data[i] = (c + (st[k] >> ((i & 7) * 8)) + r + i) & 255
cut = st[r & 3] % n
data = data[cut:] + data[:cut]
data.reverse()
trailer = b"".join(z.to_bytes(8, "little") for z in st)
return hashlib.blake2s(
bytes(data) + trailer,
digest_size=32,
person=b"riddle42",
).digest()
return hmac.compare_digest(crush(b), crush(ref))
def mystery(x):
if type(x) is not str:
return False
try:
raw = x.encode("ascii")
except UnicodeEncodeError:
return False
if len(raw) != 15:
return False
if any(c < 97 or c > 122 for c in raw):
return False
b = [c - 97 for c in raw]
# 3x5 transpose: read columns instead of rows
rows = [b[i:i + 5] for i in range(0, 15, 5)]
b = [rows[r][c] for c in range(5) for r in range(3)]
# rotate left by 7
b = b[7:] + b[:7]
# index-dependent Caesar shift modulo 26
b = [(v + (2 * i * i + 3 * i + 5)) % 26 for i, v in enumerate(b)]
# reverse each 5-character block
b = b[0:5][::-1] + b[5:10][::-1] + b[10:15][::-1]
# final fixed permutation
p = [4, 1, 14, 3, 8, 0, 11, 6, 13, 2, 9, 5, 12, 7, 10]
b = [b[i] for i in p]
return bytes(b) == b"jrddflsultkgilb"