flag format: 0xV01D{...} giải rồi viết write up ch...

python
from pathlib import Path
p=Path('/mnt/data/challenge.txt')
data=p.read_bytes()
len(data), data[:200], data[-200:]

(6238,
 b'In the beginning, there was nothing.\nThen nothing whispered: let there be layers upon layers.\nSome say the answer lies within the silence between words.\nOthers believe it hides in plain sight, staring',
 b"n0t_qu1te_lol}\nOr perhaps it was never here at all.\nThe void speaks in whispers you cannot hear with your ears.\nListen with your tools. All of them. Every. Single. One.\nGood luck. You'll need it. \xf0\x9f\x98\x88")

python
text=p.read_text('utf-8')
len(text), text[:500]


(2779,
 "In the beginning, there was nothing.\nThen nothing whispered: let there be layers upon layers.\nSome say the answer lies within the silence between words.\nOthers believe it hides in plain sight, staring back at you.\nThe number 677 means everything. Or maybe nothing. Who knows?\nDecoded message: dGhpcyBpcyBub3QgdGhlIHdheSBsb2wgdHJ5IGhhcmRlcg==\nSeek and you shall find. Or maybe you won't. HAHAHAHA.\nThe wise man once said: U NEED TO DO 677.\u200b\u200b\u200c\u200c\u200b\u200b\u200c\u200c\u200d\u200b\u200b\u200c\u200c\u200b\u200c\u200b\u200c\u200d\u200b\u200b\u200c\u200c\u200b\u200b\u200b\u200c\u200d\u200b\u200b\u200c\u200c\u200b\u200b\u200b\u200b\u200d\u200b\u200b\u200c\u200c\u200b\u200b\u200b\u200c\u200d\u200b\u200b\u200c\u200c\u200b\u200b\u200b\u200b\u200d\u200b\u200b\u200c\u200c\u200b\u200b\u200c\u200b")

python
from collections import Counter
cnt=Counter(text)
for ch,c in cnt.items():
    if ord(ch)>127 or ord(ch)<32 and ch not in '\n\t':
        print(hex(ord(ch)), repr(ch), c)
print("newlines", cnt['\n'])
# extract zero-width chars U+200B ZWSP, U+200C ZWNJ, U+200D ZWJ etc
zws=''.join(ch for ch in text if ch in '\u200b\u200c\u200d\ufeff\u2060')
len(zws), Counter(zws)


(1728, Counter({'\u200b': 808, '\u200c': 728, '\u200d': 192}))

python
seq=zws
groups=seq.split('\u200d')
len(groups), Counter(len(g) for g in groups), groups[:5], groups[-3:]


(193,
 Counter({8: 192, 0: 1}),
 ['\u200b\u200b\u200c\u200c\u200b\u200b\u200c\u200c',
  '\u200b\u200b\u200c\u200c\u200b\u200c\u200b\u200c',
  '\u200b\u200b\u200c\u200c\u200b\u200b\u200b\u200c',
  '\u200b\u200b\u200c\u200c\u200b\u200b\u200b\u200b',
  '\u200b\u200b\u200c\u200c\u200b\u200b\u200b\u200c'],
 ['\u200b\u200b\u200c\u200c\u200b\u200b\u200b\u200b',
  '\u200b\u200c\u200c\u200b\u200c\u200c\u200c\u200c',
  ''])

python
def decode_bits(map0):
    # map dict {zwsp:'0', zwnj:'1'} etc
    bits=[]
    for g in groups:
        if len(g)==8:
            bits.append(''.join(map0[ch] for ch in g))
    bs=bytes(int(b,2) for b in bits)
    return bs
for mapping in [ {'\u200b':'0','\u200c':'1'}, {'\u200b':'1','\u200c':'0'} ]:
    bs=decode_bits(mapping)
    print(mapping, bs[:100], bs)
    try: print(bs.decode('utf-8'))
    except Exception as e: print(e)

python
s=decode_bits({'\u200b':'0','\u200c':'1'}).decode()
len(s), s


(192,
 '35101021a8r432431nisli89itp1304654316e1t4785939f5xr2l87h8887n1nii25630wrfujy8rlir05m57242l14l9918740y9rc9920v9e35ws39066l107907e0027493ok1g06k69y0ma7rjw8s3n82d618957r3kgit871931mfv2h7wp6m1f10o')

python
import string, re, base64, binascii, codecs, math, itertools, collections
alph=string.digits+string.ascii_lowercase
def caesar_base36(s, shift):
    return ''.join(alph[(alph.index(c)-shift)%36] if c in alph else c for c in s)
for sh in [677%36, -(677%36), 1, -1, 26, -26, 29, 7]:
    print(sh, caesar_base36(s, sh)[:100])

python
for variant in ['std']:
    try:
        b=base64.b64decode(s, validate=True)
        print(len(b), b[:100])
        print(b.decode('utf-8','replace')[:200])
    except Exception as e:
        print("b64 err",e)
# base32? base36 decode? hex? 
try:
    print(bytes.fromhex(s[:100]))
except Exception as e: print("hex err", e)

python
lines=text.splitlines()
for i,line in enumerate(lines,1):
    # remove zero-width? 
    print(i, repr(line[-20:]), "last", repr(line[-1]), hex(ord(line[-1])))
print("lines", len(lines))
print("last chars no hidden?", ''.join(line[-1] for line in lines if line))
# last visible char ignoring zero width?
def last_visible(line):
    for ch in reversed(line):
        if ch not in '\u200b\u200c\u200d':
            return ch
key=''.join(last_visible(line) for line in lines if line)
key


'....?=..)))))}}}...😈'

python
import re, string, base64, binascii, itertools, math
def rail_fence_decrypt(cipher, rails):
    if rails == 1: return cipher
    # pattern of rail indices
    pattern = list(range(rails)) + list(range(rails-2,0,-1))
    rail_indices = [pattern[i % len(pattern)] for i in range(len(cipher))]
    counts = [rail_indices.count(r) for r in range(rails)]
    rails_str=[]
    idx=0
    for c in counts:
        rails_str.append(list(cipher[idx:idx+c])); idx+=c
    pos=[0]*rails
    out=[]
    for r in rail_indices:
        out.append(rails_str[r][pos[r]]); pos[r]+=1
    return ''.join(out)

def rail_fence_encrypt(plain, rails):
    if rails==1: return plain
    rails_arr=['']*rails
    pattern=list(range(rails))+list(range(rails-2,0,-1))
    for i,ch in enumerate(plain):
        rails_arr[pattern[i%len(pattern)]]+=ch
    return ''.join(rails_arr)

for r in range(2,21):
    dec=rail_fence_decrypt(s,r)
    enc=rail_fence_encrypt(s,r)
    for name,t in [('dec',dec),('enc',enc)]:
        if re.search(r'0xV01D|flag|0xv01d|v01d', t, re.I):
            print("found", r,name,t)
    print("r",r, "dec", dec[:80], "enc", enc[:80])

python
b=base64.b64decode(s)
def score_ascii(bs):
    return sum(32<=x<127 or x in (9,10,13) for x in bs)/len(bs)
best=[]
for k in range(256):
    x=bytes(c^k for c in b)
    best.append((score_ascii(x), k, x[:100]))
best=sorted(best, reverse=True)[:10]
for sc,k,x in best:
    print(sc,k,x)
    print(x.decode('latin1')[:120])

python
try:
    from Crypto.Cipher import AES
    from Crypto.Util.Padding import unpad
    print("pycryptodome ok")
except Exception as e:
    print("no crypto", e)

python
try:
    from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
    from cryptography.hazmat.backends import default_backend
    print("cryptography ok")
except Exception as e:
    print("no cryptography", e)

python
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.primitives import padding, hashes
from cryptography.hazmat.backends import default_backend
from hashlib import md5, sha256, sha1
def aes_decrypt(data,key,mode='ECB',iv=None):
    if mode=='ECB':
        cipher=Cipher(algorithms.AES(key), modes.ECB())
    elif mode=='CBC':
        cipher=Cipher(algorithms.AES(key), modes.CBC(iv or bytes(16)))
    dec=cipher.decryptor()
    return dec.update(data)+dec.finalize()
def try_keys():
    candidates=[]
    bases=[
        b"677", b"676", b"0xV01D", b"0xv01d", b"0xV01D Team", b"0xV01DTeam",
        b"U NEED TO DO 677", b"U NEED TO DO 677 HAHAHAHA", b"HAHAHAHA",
        b"last character of each line", b"trust me bro", b"what you see is not what you get",
        b"What You See Is Not What You Get", b"nothing", b"void", b"silence",
    ]
    # strings derived last chars
    for ks in [ ''.join(line[-1] for line in lines if line).encode('utf-8','ignore'),
               ''.join(last_visible(line) for line in lines if line).encode('utf-8','ignore')]:
        bases.append(ks)
    for base in bases:
        variants=[base]
        variants.append((base*16)[:16])
        variants.append((base*24)[:24])
        variants.append((base*32)[:32])
        variants.append(md5(base).digest())
        variants.append(sha256(base).digest())
        variants.append(sha1(base).digest()[:16])
        variants.append(base.ljust(16,b'\0')[:16])
        variants.append(base.ljust(24,b'\0')[:24])
        variants.append(base.ljust(32,b'\0')[:32])
        for key in variants:
            if len(key) in (16,24,32):
                for mode in ['ECB','CBC']:
                    for iv in [bytes(16), md5(base).digest(), b'677'*5+b'6'] if mode=='CBC' else [None]:
                        try:
                            pt=aes_decrypt(b,key,mode,iv)
                            sc=score_ascii(pt)
                            if sc>0.7 or b'0xV01D' in pt or b'flag' in pt.lower():
                                candidates.append((sc, base, len(key), mode, iv, pt[:200]))
                        except Exception as e: pass
    return sorted(candidates, reverse=True, key=lambda x:x[0])
cands=try_keys()
len(cands)


0

python
keys=[ ''.join(line[-1] for line in lines if line).encode('utf-8'),
       ''.join(last_visible(line) for line in lines if line).encode('utf-8'),
       b"677", b"HAHAHAHA", b"U NEED TO DO 677", b"0xV01D"]
for data_name,data in [('b64bytes', b), ('hidden_ascii', s.encode())]:
    print('---',data_name)
    for key in keys:
        x=bytes(c ^ key[i%len(key)] for i,c in enumerate(data))
        print("key",key[:40], "score", score_ascii(x), x[:120])
        if b'0xV01D' in x or b'flag' in x.lower(): print("FOUND",x)

python
sb=s.encode()
def english_score(bs):
    text=''.join(chr(b) if 32<=b<127 else ' ' for b in bs).lower()
    common=' etaoinshrdl{}_0123456789xv'
    return sum(text.count(c)*w for w,c in enumerate(common[::-1],1)) - 10*sum(b<32 or b>126 for b in bs)
best=[]
for k in range(256):
    x=bytes(c^k for c in sb)
    if all(32<=c<127 or c in (10,13,9) for c in x):
        best.append((english_score(x), k, x[:200]))
for score,k,x in sorted(best, reverse=True)[:20]:
    print(score,k,repr(x[:120]))

python
from collections import Counter
cnt=Counter(s)
print(cnt)
print(len(set(s)))
for k,v in cnt.most_common():
    print(k,v)

python
idx=text.find('\u200b')
print(idx, text[:idx][-100:], len(text[:idx]))
print("byte idx", data.find('\xe2\x80\x8b'.encode() if False else b'\xe2\x80\x8b'))

python
print(data.find(b'\xe2\x80\x8b'), data.find(b'\xe2\x80\x8c'), data.find(b'\xe2\x80\x8d'))
print(len(text[:idx].encode()))

python
print(data[430:480])
print([hex(b) for b in data[438:450]])
for ch in text[438:450]:
    print(hex(ord(ch)), ch.encode())

python
raw=Path('/mnt/data/challenge.txt').read_bytes()
print(len(raw), raw[430:480], raw.find(b'\xe2\x80\x8b'))
print(text.encode('utf-8')[430:480])

python
for mapping in [ {'\u200b':'0','\u200c':'1'}, {'\u200b':'1','\u200c':'0'}]:
    for rev in [False, True]:
        chars=[]
        for g in groups:
            if len(g)==8:
                bits=''.join(mapping[ch] for ch in g)
                if rev: bits=bits[::-1]
                chars.append(int(bits,2))
        bs=bytes(chars)
        print(mapping, "rev",rev, bs[:80], score_ascii(bs))
        try: print(bs.decode('utf-8')[:200])
        except Exception as e: print("decode err")

python
def shift_digits_letters(s, key):
    out=[]
    for i,c in enumerate(s):
        k=int(key[i%len(key)])
        if c.isdigit():
            out.append(str((int(c)-k)%10))
        elif c.isalpha():
            out.append(chr((ord(c)-97-k)%26+97))
        else: out.append(c)
    return ''.join(out)
print(shift_digits_letters(s,'677')[:200])
print(shift_digits_letters(s,'677'))
# Add instead
def shift_add(s, key):
    out=[]
    for i,c in enumerate(s):
        k=int(key[i%len(key)])
        if c.isdigit(): out.append(str((int(c)+k)%10))
        elif c.isalpha(): out.append(chr((ord(c)-97+k)%26+97))
        else: out.append(c)
    return ''.join(out)
print(shift_add(s,'677')[:200])

python
def caesar_letters(s, shift):
    out=[]
    for c in s:
        if c.islower(): out.append(chr((ord(c)-97-shift)%26+97))
        elif c.isupper(): out.append(chr((ord(c)-65-shift)%26+65))
        else: out.append(c)
    return ''.join(out)
for sh in [1,-1,677%26,-677%26,13,5,-5,7,-7]:
    print(sh, caesar_letters(s, sh)[:120])

python
def caesar_printable(s, shift):
    out=''
    for c in s:
        o=ord(c)
        if 32<=o<=126:
            out+=chr((o-32-shift)%95+32)
        else: out+=c
    return out
for sh in [677%95, -677%95, 677%36, -677%36]:
    print(sh, repr(caesar_printable(s,sh)[:120]))

python
for w in [8,16,24,32,48,64]:
    print("w",w)
    for i in range(0,len(s),w):
        print(s[i:i+w])
    print()

python
def columns_read(s,width):
    rows=[s[i:i+width] for i in range(0,len(s),width)]
    return ''.join(''.join(row[c] for row in rows if c<len(row)) for c in range(width))
for w in range(2,50):
    out=columns_read(s,w)
    if '0x' in out or '0xv' in out.lower() or 'flag' in out.lower() or 'v01' in out.lower():
        print(w,out)
# inspect common widths
for w in [8,12,16,24,32]:
    print("width",w, columns_read(s,w)[:200])

python
for step in range(2,50):
    for off in range(step):
        t=s[off::step]
        if '0x' in t.lower() or 'v01' in t.lower() or 'flag' in t.lower() or '{' in t:
            print(step,off,t)

python
n=int(s,36)
bs=n.to_bytes((n.bit_length()+7)//8,'big')
len(bs), bs[:100], score_ascii(bs)


(124,
 b'"rK\xa7\xc7I\xd6\xbd\xe0\x8b\x9a)No\xefT`\xa9\xc2\x967`;<\xc5\x8a\x03\xda\x1eX\x8e\xbdH\x91\x0f\xc7\xa2\xae*#\xff;j\xdf\xa5I\xae\xe9\xca\xeaQ\xfcDGj\xae\x14Y\x0b\x95\xff\x053J\x1b~<"\xad\x7f\xffz\x91\x0bw\x0c\x05\x83\xd0\xe1\xe6w\x91Z4\x11.1\xbc\xa5\xc7iG\xd2~=\x9e\xa6\xc5\xbc',
 0.3951612903225806)

python
chars=['\u200b','\u200c','\u200d']
for perm in itertools.permutations('012'):
    mp=dict(zip(chars,perm))
    trits=''.join(mp[ch] for ch in zws)
    for width in range(3,13):
        vals=[]
        ok=True
        for i in range(0,len(trits)-width+1,width):
            val=int(trits[i:i+width],3)
            if val>255: 
                ok=False
                break
            vals.append(val)
        if ok:
            bs=bytes(vals)
            sc=score_ascii(bs)
            if sc>0.85 or b'0x' in bs or b'flag' in bs.lower():
                print("perm",perm,"width",width,"len",len(bs),"score",sc, bs[:200])

python
for perm in itertools.permutations('012'):
    mp=dict(zip(chars,perm))
    trits=''.join(mp[ch] for ch in zws)
    for width in [5]:
        vals=[int(trits[i:i+width],3) for i in range(0,len(trits)-width+1,width)]
        bs=bytes(vals)
        sc=score_ascii(bs)
        if sc>0.5:
            print("perm",perm,"score",sc,bs[:200])
            print(bs.decode('latin1')[:200])

python
def rot47(text, n=47):
    out=''
    for c in text:
        o=ord(c)
        if 33 <= o <= 126:
            out += chr(33 + ((o-33+n) % 94))
        else:
            out += c
    return out
for n in [47, 677%94, -677%94, 13, 19, -19]:
    print(n, repr(rot47(s,n)[:120]))

python
alph='0123456789abcdefghijklmnopqrstuvwxyz'
def vigenere_base36(s,key,enc=False):
    out=[]
    for i,c in enumerate(s):
        if c in alph:
            k=alph.index(key[i%len(key)])
            idx=alph.index(c)
            out.append(alph[(idx + k if enc else idx-k)%len(alph)])
        else: out.append(c)
    return ''.join(out)
for k in ['677','u','void','0xv01d','hahaha']:
    print(k, vigenere_base36(s,k)[:120])
    print(k, vigenere_base36(s,k,enc=True)[:120])

python
for step in [2,3,4,5,6,7]:
    print("step",step)
    for off in range(step):
        print(off, s[off::step][:100])
    print()

python
letters=''.join(c for c in s if c.isalpha())
digits=''.join(c for c in s if c.isdigit())
len(letters), letters, len(digits), digits[:200]


(70,
 'arnisliitpetfxrlhnniiwrfujyrlirmllyrcvewsleokgkymarjwsndrkgitmfvhwpmfo',
 122,
 '35101021843243189130465431614785939528788871256308055724214991874099920935390661079070027493106690783826189573871931276110')

python
letters=''.join(c for c in s if c.isalpha())
digits=''.join(c for c in s if c.isdigit())
print(letters)
for sh in range(26):
    t=caesar_letters(letters, sh)
    if any(word in t for word in ['flag','the','you','try','void','this']):
        print("caesar",sh,t)
print("rail letters")
for r in range(2,15):
    dec=rail_fence_decrypt(letters,r)
    if any(w in dec for w in ['flag','the','you','try','void','this','xv']):
        print(r, dec)
    print(r, dec[:100])

python
digits=''.join(c for c in s if c.isdigit())
print(len(digits), digits)
# parse decimal ASCII maybe 2/3 digits
pairs=[int(digits[i:i+2]) for i in range(0,len(digits)-1,2)]
print(pairs[:50], bytes([x for x in pairs if x<256])[:50])
# 3-digit parse
trip=[int(digits[i:i+3]) for i in range(0,len(digits)-2,3)]
print(trip[:30], ''.join(chr(x) if 32<=x<127 else '?' for x in trip[:50]))
# apply with ascii from possible [32-126] greedy segmentation?

python
runs=re.findall(r'\d+|[a-z]+', s)
[(r, len(r)) for r in runs], len(runs)


([('35101021', 8),
  ('a', 1),
  ('8', 1),
  ('r', 1),
  ('432431', 6),
  ('nisli', 5),
  ('89', 2),
  ('itp', 3),
  ('1304654316', 10),
  ('e', 1),
  ('1', 1),
  ('t', 1),
  ('4785939', 7),
  ('f', 1),
  ('5', 1),
  ('xr', 2),
  ('2', 1),
  ('l', 1),
  ('87', 2),
  ('h', 1),
  ('8887', 4),
  ('n', 1),
  ('1', 1),
  ('nii', 3),
  ('25630', 5),
  ('wrfujy', 6),
  ('8', 1),
  ('rlir', 4),
  ('05', 2),
  ('m', 1),
  ('57242', 5),
  ('l', 1),
  ('14', 2),
  ('l', 1),
  ('9918740', 7),
  ('y', 1),
  ('9', 1),
  ('rc', 2),
  ('9920', 4),
  ('v', 1),
  ('9', 1),
  ('e', 1),
  ('35', 2),
  ('ws', 2),
  ('39066', 5),
  ('l', 1),
  ('107907', 6),
  ('e', 1),
  ('0027493', 7),
  ('ok', 2),
  ('1', 1),
  ('g', 1),
  ('06', 2),
  ('k', 1),
  ('69', 2),
  ('y', 1),
  ('0', 1),
  ('ma', 2),
  ('7', 1),
  ('rjw', 3),
  ('8', 1),
  ('s', 1),
  ('3', 1),
  ('n', 1),
  ('82', 2),
  ('d', 1),
  ('618957', 6),
  ('r', 1),
  ('3', 1),
  ('kgit', 4),
  ('871931', 6),
  ('mfv', 3),
  ('2', 1),
  ('h', 1),
  ('7', 1),
  ('wp', 2),
  ('6', 1),
  ('m', 1),
  ('1', 1),
  ('f', 1),
  ('10', 2),
  ('o', 1)],
 82)

python
bb=base64.b64decode(s)
print(len(bb), bb.hex())
# entropy, bytes distribution
print(Counter(bb).most_common(10))

python
# Generate possible key strings from line ends; test AES both modes, XOR combos
line_last_variants={}
for ignore_hidden in [False, True]:
    for include_emoji in [True, False]:
        chars=[]
        for line in lines:
            if not line: continue
            ch=last_visible(line) if ignore_hidden else line[-1]
            if not include_emoji and ord(ch)>127: continue
            chars.append(ch)
        name=f"lastvis{ignore_hidden}_emoji{include_emoji}"
        line_last_variants[name]=''.join(chars)
        print(name, repr(''.join(chars)), len(''.join(chars)), len(''.join(chars).encode()))
# subsets
for name,keystr in line_last_variants.items():
    print(name, keystr.encode())

python
from itertools import combinations
def try_aes_with_keys(keys):
    outs=[]
    for desc,key in keys:
        keyb=key if isinstance(key,bytes) else key.encode()
        for k in set([keyb[:16], keyb[-16:], keyb[:24], keyb[-24:], keyb[:32], keyb[-32:], md5(keyb).digest(), sha256(keyb).digest(), sha1(keyb).digest()[:16]]):
            if len(k) not in (16,24,32): continue
            for mode in ['ECB','CBC']:
                ivs=[None] if mode=='ECB' else [bytes(16), keyb[:16].ljust(16,b'\0'), keyb[-16:].rjust(16,b'\0'), md5(keyb).digest()]
                for iv in ivs:
                    try:
                        pt=aes_decrypt(bb,k,mode,iv)
                        # try unpad
                        pts=[pt]
                        try:


(10,
 [(0.4166666666666667,
   'lastvisFalse_emojiFalse',
   b'M\x13\xc1;\x07<b\xeb\xf8[\xbd\xb0\xa8\x1b\xba\xb3d$\x9f\xb7\x02A\x0f\x9e\x8fi\xcb\nRC\xda\xd0',
   'CBC',
   b'!v\x19\x91Ng\xaf\xa3\x89<\xa9\x02\x8f\xe3\x95\x85',
   b'\xe3\x06.V\xd1\xe5Ls0\x10\xbe\xb6\xae\x13$\xbbdv\xbea|\xb9!\x13\xfa\\c\x91\xc1\x96\x9aq\xc7 I<%\xd4Q\x98\x80A\xf8\xb2\x00\xe5\xde\xe9p\xe6G\xe7g\xa0\x9f\x89Q\xfaO\xde\xad\x1b\xca{Q\x84 C\x97\x88\xa2\xce\xb96\xb4\x96g.\xaa\xbe\xe6\x1f.K2\x1eR.\xfb\xca\xe4)%~\xc4\x19"\x0f_F!\x91\xb9\xca\x05\xe2\xb3q\x1c\x86\xae\xffiCn&>%\x89\x14\x82\xd1h\xa8\x0f\x002\xc4\xe49v\x81J\x81,\x1b\x14*\x81\\\x17\x8f\x08D'),
  (0.4097222222222222,
   'lastvisTrue_emojiFalse',
   b'.?=..)))))}}}...',
   'CBC',
   b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00',
   b'\xe6\xeb\xf3\xb4\xd6t.\xa8\xd2\xbe4\xfa\x0fa=\x1b\x11&\xee\xaaH\xc5\r5\xfd1dL\xde}\xa26\xdd\x07\x86h\x9e1\xc5\xb5\x8b\x124\x02\xe4\\ND\xc3\xe6\xea"\xefm\xf3\xadkl\xf2\xdf\xd8\xe2\xdbu\x1e\x94s\xf8\xeaY}\x0e\xfe\x1b>\xba6BSU\xe8eh\xcc\xc9"\r&\x00\xaba\xb5\x90R\xca\x9e\xf9\x8a\xce\x82\x91\xe7\x87\xef\x1e\x8d\x16tc\xf5\xee>bn\xcdCk\xe2\x03Yl\xb8\xa8\x8dTRyXF\x1a\x8c"9\xd4H\xbf\xb4\xf2\xa1\xcd>\xcc\x0bk'),
  (0.4027777777777778,
   'lastvisFalse_emojiFalse',
   b'....?=.)))))}}}.',
   'ECB',
   None,
   b"# \xf0\xe8o\xc8\xbaH\xce\x00e\xf8r\x00\x98\xdd\x870g.\xf7\x06)0\xbc\x0c\xe2\x9d}eW\xc6\x1d/\x1d\x84\xf4T\x97\x9f\x8a\x9b\xb8\\\xa7\xe3\xa2W\xc1\x05\x11\x8f)7\xff\x90\x96o\xe5[\xceIP\x04\xbbn|3\x88WY\xcd~\x8c\x01\x1a9'\xd4H^\xbd\x88\x1c_\x02\xc4\x83\x83\x87\xf4\x1eZ<YqSw\x08E\x1a\x949.\xb5\x0fD3\xfbg\xb0[\x1a\x99\xde\xfc\xdd \xe1d\x03\x99\x80\x15\xd2\x9c\x0c\xf7\x1bd\x9f\xb4g\x17\xdf<\x16j\xe3ZX[\xf8;"),
  (0.3680555555555556,
   'lastvisTrue_emojiTrue',
   b'\x8b\xe7.f\x1a\xa1\xca%F\xc4\xcbYU\x89f\xf8',
   'CBC',
   b'\xa7\x85\xf7\xf3:\x10\xedh\xbf\x89\x83+\xb2YC]',
   b",\xdf\xcf\x87\xc5\xee.\x88\x83;\xf9\x06\x86\x8c\xa9\x83L\xe4\x13%\xbc\xb0\xd0\x9f\x92\nN\xcb\xff+\xd0\xa6e*\x93\xd8{?\xae!n\x90\xdcC\xc4\xcf\xa6\x92A\xa2\xecp2h\x18S\xb9\xa7t\x19\x93\x8aA\x15\xd9-\xe8\x14\xad\xb6\xd4\xc2\x06\xaec&A\xd6\xb1<\xccjw~'Y]6\xbe6\x133\xd6\x84F\x9dj\xc7\xbb\xf93\xe7\xbc\x92B\x0e\x07\xb5XHZ8\x04\x9c\x90\xef\xeb\xb7^_\x84\xddh\xa4\xe2.\xdf}R4\xadK\xa7\x92\x80\xf8\x04\xb8\xb3\xf8\x19\x05{\xcf"),
  (0.3611111111111111,
   'lastvisFalse_emojiTrue_punctstrip',
   b"\xe3\xb0\xc4B\x98\xfc\x1c\x14\x9a\xfb\xf4\xc8\x99o\xb9$'\xaeA\xe4d\x9b\x93L\xa4\x95\x99\x1bxR\xb8U",
   'ECB',
   None,
   b'"Z3$Ew\xe9\x0e\x8b^D\x87\xef\xf7\xb5l~\xce.G\x18\xbd\xa2\xea\xc7\xba\x1c x\x00x\x13W\xfe\xda\xe3v`D~\xeb0\xa6\xa4\x05\x9aj\xf67j\x91k\x8e\x17\xa9\x93\xddq|\t\x86\x84\xd3\x03\x16\xael\xb7p\x03\xe9\xe3\xa46\xcf\x07=\x1a\x1b\x13\x9d\xf0Ns\xa06\xf3 \xdc\x08\xd2Q\x1d(\x97\xc7\xf0\xba\xdf\x8dk[\xff\xf9\x9f\x87\xe8X\x83\x1d\x97lu\xf0\xf9\xe7mTz\x84\xa4\xbb\x93\xf7l\xedPZo{\xae\xc4\xa2\xb0\xc3\x9c\xf2\xfb\x86\xf1T\xa5\xaf\xae')])

python
bits=''.join('0' if ch=='\u200b' else '1' if ch=='\u200c' else '' for ch in zws)
print(len(bits))
for width in [5,6,7,8]:
    for start in range(width):
        vals=[int(bits[i:i+width],2) for i in range(start, len(bits)-width+1, width)]
        # map 5-bit to a-z (0=a or 1=a), 7/8 ascii
        if width==5:
            for offset in [0,1]:
                txt=''.join(chr(v+ord('a')-offset) if 0+offset<=v<=25+offset else '?' for v in vals)
                if any(w in txt for w in ['flag','void','the','you','xv']):
                    print("w5",start,offset,txt[:300])
        else:
            bs=bytes(v for v in vals if 0<=v<256)
            sc=score_ascii(bs)
            if sc>0.7 or b'0x' in bs or b'flag' in bs.lower():
                print("width",width,"start",start,"score",sc,bs[:200], bs.decode('latin1')[:200])

python
texts5=[]
for start in range(5):
    vals=[int(bits[i:i+5],2) for i in range(start, len(bits)-5+1, 5)]
    for offset in [0,1]:
        txt=''.join(chr(v+ord('a')-offset) if 0+offset<=v<=25+offset else '?' for v in vals)
        texts5.append((start,offset,txt))
        print("start",start,"offset",offset,"len",len(txt),txt[:200])
        # Try Caesar shifts for words
        for sh in range(26):
            ca=caesar_letters(txt.replace('?',''), sh)
            if 'flag' in ca or 'the' in ca or 'you' in ca or 'void' in ca:
                print("  caesar",sh,ca[:200])

python
# Generate candidate phrases/substrings from visible text excluding hidden zero widths
visible=''.join(ch for ch in text if ch not in '\u200b\u200c\u200d')
# collect words and phrases
tokens=re.findall(r'[A-Za-z0-9_{}xV]+', visible)
cands=set()
for tok in tokens:
    cands.add(tok)
    cands.add(tok.lower())
    cands.add(tok.upper())
# ngrams up to 5 tokens
for ngram in range(2,8):
    for i in range(len(tokens)-ngram+1):
        phrase=' '.join(tokens[i:i+ngram])
        cands.add(phrase); cands.add(phrase.lower()); cands.add(phrase.upper())
        phrase2='_'.join(tokens[i:i+ngram])
        cands.add(phrase2); cands.add(phrase2.lower())
# exact lines/after colon
for line in visible.splitlines():
    cands.add(line.strip()); cands.add(line.strip().lower())
    if ':' in line:
        cands.add(line.split(':',1)[1].strip())
# plus punctuation variants around 677
for c in ['677','0677','677.','677 HAHAHAHA','U NEED TO DO 677.','U NEED TO DO 677','U_NEED_TO_DO_677','doneedtodo677','do677','DO677','do 677','DO 677','6776776776776776','6776776776776777','HAHAHAHA','HAHAHAHA.']:
    cands.add(c); cands.add(c.lower())
print(len(cands))
# Try AES keys from candidates direct if len 16/24/32, md5, sha, repeats, ljust with zeros/spaces
outs=[]
for cand in cands:
    base=cand.encode()
    variants=set()
    for L in [16,24,32]:
        if len(base)>=L: variants.add(base[:L]); variants.add(base[-L:])
        variants.add(base.ljust(L,b'\0')[:L]); variants.add(base.ljust(L,b' ')[:L])
        variants.add((base*((L//len(base))+1))[:L] if len(base)>0 else b'')
    variants.add(md5(base).digest())
    variants.add(sha256(base).digest())
    variants.add(sha1(base).digest()[:16])
    for key in variants:
        if len(key) not in (16,24,32): continue
        for mode in ['ECB','CBC']:
            ivs=[None] if mode=='ECB' else [bytes(16), md5(base).digest(), sha256(base).digest()[:16], base[:16].ljust(16,b'\0'), base[:16].ljust(16,b' ')]
            for iv in ivs:
                try:
                    pt=aes_decrypt(bb,key,mode,iv)
                    # unpad if possible
                    pts=[pt]
                    pad=pt[-1]
                    if pad<=16 and pad>0 and pt.endswith(bytes([pad])*pad): pts.append(pt[:-pad])
                    for ptt in pts:
                        sc=score_ascii(ptt)
                        # English score stricter
                        low=ptt.lower()
                        if b'0xv01d' in low or b'flag' in low or b'{' in ptt or sc>0.8:
                            outs.append((sc,cand,key,mode,iv,ptt[:300]))
                except Exception:
                    pass
print("outs",len(outs))
for item in sorted(outs, reverse=True, key=lambda x:x[0])[:30]:
    print("score",item[0],"cand",repr(item[1]),"key",item[2],"mode",item[3],"iv",item[4],"pt",item[5])