文件名：我不喜欢十六进制线索贯穿每个像素，每一步都是解密的关键 hint1：密码是关键\ hint...

创建于：2026年8月23日

问题

flag.png

文件名：我不喜欢十六进制
线索贯穿每个像素，每一步都是解密的关键
hint1：密码是关键
hint2：图片分辨率与密码息息相关
hint3：David Hilbert
获得flag
密码CTF

Python

python
from PIL import Image
img=Image.open('/mnt/data/flag.png')
img.mode, img.size, img.getbands()


('RGB', (2090, 518), ('R', 'G', 'B'))

Python

python
import numpy as np, collections, math, os, json, statistics
a=np.array(img)
a.shape, a.dtype, a.min(), a.max(), len(np.unique(a.reshape(-1,3),axis=0))


((518, 2090, 3), dtype('uint8'), np.uint8(0), np.uint8(255), 53881)

Python

python
img.info


{'jfif': 257, 'jfif_version': (1, 1), 'jfif_unit': 0, 'jfif_density': (1, 1)}

Python

python
import sympy as sp
n=2090*518
n, sp.factorint(n), math.sqrt(n)


(1082620, {2: 2, 5: 1, 7: 1, 11: 1, 19: 1, 37: 1}, 1040.4902690558908)

Python

python
from collections import Counter
pixels = a.reshape(-1,3)
# most common exact colors
cnt=Counter(map(tuple,pixels.tolist()))
cnt.most_common(20)[:20]


[((249, 249, 249), 376302),
 ((249, 249, 251), 12313),
 ((249, 249, 247), 12144),
 ((250, 248, 249), 10850),
 ((248, 250, 249), 10531),
 ((248, 249, 251), 9456),
 ((250, 249, 247), 9402),
 ((0, 1, 0), 6827),
 ((0, 0, 0), 6714),
 ((250, 248, 251), 5744),
 ((248, 250, 247), 5670),
 ((1, 0, 0), 5012),
 ((0, 2, 0), 4956),
 ((3, 0, 0), 4722),
 ((249, 248, 253), 4649),
 ((249, 250, 245), 4523),
 ((250, 250, 250), 4391),
 ((4, 0, 0), 4207),
 ((250, 249, 245), 4021),
 ((248, 249, 253), 3985)]

Python

python
gray=a.mean(axis=2)
bw=gray<128
bw.mean(), bw.sum(), bw.sum(axis=1)[:20], bw.sum(axis=0)[:20]


(np.float64(0.17412757939073728),
 np.int64(188514),
 array([440, 430, 410, 410, 411, 417, 435, 436, 473, 474, 515, 518, 472,
        473, 471, 484, 381, 382, 396, 405]),
 array([113, 109, 104, 104, 121, 123, 126, 125, 159, 167, 162, 162, 152,
        154, 151, 151, 130, 140, 137, 135]))

Python

python
int('CTF',36)


16611

Python

python
def sgn(x): return -1 if x<0 else (1 if x>0 else 0)
def generate2d(x,y,ax,ay,bx,by):
    w=abs(ax+ay); h=abs(bx+by)
    dax,day=sgn(ax),sgn(ay); dbx,dby=sgn(bx),sgn(by)
    if h==1:
        for _ in range(w):
            yield x,y; x+=dax; y+=day
        return
    if w==1:
        for _ in range(h):
            yield x,y; x+=dbx; y+=dby
        return
    ax2,ay2=ax//2,ay//2; bx2,by2=bx//2,by//2
    w2=abs(ax2+ay2); h2=abs(bx2+by2)
    if 2*w > 3*h:
        if (w2%2) and (w>2):
            ax2+=dax; ay2+=day
        yield from generate2d(x,y,ax2,ay2,bx,by)
        yield from generate2d(x+ax2,y+ay2,ax-ax2,ay-ay2,bx,by)
    else:
        if (h2%2) and (h>2):
            bx2+=dbx; by2+=dby
        yield from generate2d(x,y,bx2,by2,ax2,ay2)
        yield from generate2d(x+bx2,y+by2,ax,ay,bx-bx2,by-by2)
        yield from generate2d(x+(ax-dax)+(bx2-dbx),y+(ay-day)+(by2-dby),
                              -bx2,-by2,-(ax-ax2),-(ay-ay2))
def gilbert2d(w,h):
    if w>=h: yield from generate2d(0,0,w,0,0,h)
    else: yield from generate2d(0,0,0,h,w,0)
coords=np.array(list(gilbert2d(img.width,img.height)),dtype=np.int32)
coords.shape, coords.min(0), coords.max(0), len(np.unique(coords,axis=0))


((1082620, 2),
 array([0, 0], dtype=int32),
 array([2089,  517], dtype=int32),
 1082620)

Python

python
ys=coords[:,1]; xs=coords[:,0]
vals=gray[ys,xs]
bits=(vals<128).astype(np.uint8)
# pack variants
def pack_bits(bits, bitorder='big'):
    return np.packbits(bits, bitorder=bitorder).tobytes()
streams={}
for rev in [False,True]:
    bb=bits[::-1] if rev else bits
    for inv in [False,True]:
        bbb=1-bb if inv else bb
        for order in ['big','little']:
            data=pack_bits(bbb,order)
            streams[(rev,inv,order)]=data
# check ASCII ratio and common magic after xor CTF, raw
magics=[b'flag{',b'CTF{',b'PK\x03\x04',b'\x89PNG',b'GIF8',b'%PDF',b'Rar!',b'7z\xbc\xaf\x27\x1c',b'BM',b'\xff\xd8\xff']
key=b'CTF'
hits=[]
for k,data in streams.items():
    for mode in ['raw','xor']:
        d=data if mode=='raw' else bytes(c^key[i%3] for i,c in enumerate(data))
        for m in magics:
            pos=d.find(m)
            if pos>=0: hits.append((k,mode,m,pos))
hits[:50], len(hits)


([((True, False, 'big'), 'xor', b'CTF{', 102414),
  ((True, False, 'little'), 'xor', b'CTF{', 91608)],
 2)

Python

python
for k,mode,m,pos in hits:
    data=streams[k]
    d=bytes(c^key[i%3] for i,c in enumerate(data))
    print(k,pos,d[pos-100:pos+300])

Python

python
# dark fraction in margins vs central likely 2048x512 centered
margins = {
'top3': bw[:3].mean(), 'bottom3':bw[-3:].mean(),
'left21':bw[:, :21].mean(), 'right21':bw[:,-21:].mean(),
'center':bw[3:-3,21:-21].mean()
}
margins


{'top3': np.float64(0.20414673046251994),
 'bottom3': np.float64(0.17719298245614035),
 'left21': np.float64(0.2616289759146902),
 'right21': np.float64(0.3054789483360912),
 'center': np.float64(0.1717090606689453)}

Python

python
col_dark=bw.mean(axis=0)
row_dark=bw.mean(axis=1)
# lowest dark columns and sequences <0.05
def runs(mask):
    out=[]; s=None
    for i,v in enumerate(mask):
        if v and s is None:s=i
        if not v and s is not None:
            out.append((s,i-1)); s=None
    if s is not None:out.append((s,len(mask)-1))
    return out
for thr in [0.02,0.05,0.1,0.15]:
    rs=runs(col_dark<thr)
    print(thr, sorted(rs,key=lambda t:t[1]-t[0], reverse=True)[:20])

Python

python
import importlib.util, sys, os, math, numpy as np
print(importlib.util.find_spec('hilbertcurve'))

Python

python
# test hypothesized gaps
regions=[]
for name,(x0,x1) in {
'leftmargin':(0,3),'gap1':(515,527),'gap2':(1039,1051),'gap3':(1563,1575),'rightmargin':(2087,2090)
}.items():
    regions.append((name,bw[:,x0:x1].mean()))
regions, [('top',bw[:3].mean()),('bottom',bw[-3:].mean())]


([('leftmargin', np.float64(0.2097812097812098)),
  ('gap1', np.float64(0.13915701415701415)),
  ('gap2', np.float64(0.1920849420849421)),
  ('gap3', np.float64(0.19031531531531531)),
  ('rightmargin', np.float64(0.2927927927927928))],
 [('top', np.float64(0.20414673046251994)),
  ('bottom', np.float64(0.17719298245614035))])

Python

python
gray_u = np.round(a.mean(2)).astype(np.uint8)
hist=np.bincount(gray_u.ravel(), minlength=256)
[(i,int(hist[i])) for i in np.argsort(hist)[-30:][::-1]]


[(np.int64(249), 467019),
 (np.int64(250), 88563),
 (np.int64(248), 83443),
 (np.int64(247), 38838),
 (np.int64(251), 38727),
 (np.int64(1), 31929),
 (np.int64(2), 28585),
 (np.int64(246), 24749),
 (np.int64(252), 23336),
 (np.int64(3), 19632),
 (np.int64(0), 18553),
 (np.int64(253), 18036),
 (np.int64(245), 17688),
 (np.int64(4), 14732),
 (np.int64(244), 12652),
 (np.int64(254), 10952),
 (np.int64(5), 10920),
 (np.int64(243), 9085),
 (np.int64(6), 8158),
 (np.int64(242), 6469),
 (np.int64(7), 6282),
 (np.int64(241), 4642),
 (np.int64(255), 4595),
 (np.int64(8), 4402),
 (np.int64(240), 3353),
 (np.int64(9), 3180),
 (np.int64(10), 2547),
 (np.int64(239), 2460),
 (np.int64(11), 2056),
 (np.int64(238), 2025)]

Python

python
def corr_shift(arr, dx, dy):
    H,W=arr.shape
    a1=arr[max(0,dy):H+min(0,dy), max(0,dx):W+min(0,dx)]
    a2=arr[max(0,-dy):H-min(0,dy), max(0,-dx):W-min(0,dx)]
    return np.corrcoef(a1.ravel(),a2.ravel())[0,1], np.mean(a1==a2)
for d in [(1,0),(0,1),(2,0),(0,2),(4,0),(0,4),(8,0),(0,8),(16,0),(0,16)]:
    print(d,corr_shift(bw.astype(np.uint8),*d))

Python

python
def corr_shift(arr, dx, dy):
    H,W=arr.shape
    x0a=max(dx,0); x1a=W+min(dx,0)
    y0a=max(dy,0); y1a=H+min(dy,0)
    x0b=max(-dx,0); x1b=W-min(dx,0)
    y0b=max(-dy,0); y1b=H-min(dy,0)
    a1=arr[y0a:y1a, x0a:x1a]
    a2=arr[y0b:y1b, x0b:x1b]
    return np.corrcoef(a1.ravel(),a2.ravel())[0,1], np.mean(a1==a2)
for d in [(1,0),(0,1),(2,0),(0,2),(4,0),(0,4),(8,0),(0,8),(16,0),(0,16)]:
    print(d,corr_shift(bw.astype(np.uint8),*d))

Python

python
def corr_shift2(arr, dx, dy):
    H,W=arr.shape
    y_start=max(0,dy); y_end=min(H,H+dy)
    x_start=max(0,dx); x_end=min(W,W+dx)
    a1=arr[y_start:y_end, x_start:x_end]
    a2=arr[y_start-dy:y_end-dy, x_start-dx:x_end-dx]
    return np.corrcoef(a1.ravel(),a2.ravel())[0,1], np.mean(a1==a2), a1.shape
for d in [(1,0),(0,1),(2,0),(0,2),(4,0),(0,4),(8,0),(0,8),(16,0),(0,16)]:
    print(d,corr_shift2(bw.astype(np.uint8),*d))

Python

python
# binary edge discontinuity between adjacent cols/rows
col_diff=np.mean(bw[:,1:]!=bw[:,:-1], axis=0) # boundary between x and x+1, index x
row_diff=np.mean(bw[1:,:]!=bw[:-1,:], axis=1)
# autocorrelation / periodic avg by modulo for candidate block sizes
def boundary_score(diff, k):
    # compare means at boundaries positions k-1,2k-1...
    idx=np.arange(len(diff))
    b=((idx+1)%k==0)
    return diff[b].mean()-diff[~b].mean(), diff[b].mean(), diff[~b].mean()
scores=[]
for k in range(2,129):
    sc=boundary_score(col_diff,k)[0]+boundary_score(row_diff,k)[0]
    scores.append((sc,k,boundary_score(col_diff,k),boundary_score(row_diff,k)))
sorted(scores, reverse=True)[:20]


[(np.float64(0.13263274828188518),
  2,
  (np.float64(0.06311481597325519),
   np.float64(0.08432632139528692),
   np.float64(0.021211505422031738)),
  (np.float64(0.06951793230862999),
   np.float64(0.08648418085382589),
   np.float64(0.01696624854519591))),
 (np.float64(0.1217409265882387),
  65,
  (np.float64(-0.004316060800018021),
   np.float64(0.048503861003861004),
   np.float64(0.052819921803879025)),
  (np.float64(0.1260569873882567),
   np.float64(0.17600820232399178),
   np.float64(0.04995121493573506))),
 (np.float64(0.12015058888620991),
  98,
  (np.float64(0.07597463942448743),
   np.float64(0.1279646993932708),
   np.float64(0.05199005996878337)),
  (np.float64(0.044175949461722486),
   np.float64(0.0954066985645933),
   np.float64(0.051230749102870815))),
 (np.float64(0.09866587167523161),
  26,
  (np.float64(0.033394764582544575),
   np.float64(0.08486969111969112),
   np.float64(0.05147492653714654)),
  (np.float64(0.06527110709268703),
   np.float64(0.11453034500125912),
   np.float64(0.04925923790857209))),
 (np.float64(0.08964584749570102),
  66,
  (np.float64(0.04133322100969991),
   np.float64(0.09347365798978703),
   np.float64(0.05214043698008712)),
  (np.float64(0.04831262648600111),
   np.float64(0.09931647300068354),
   np.float64(0.05100384651468243))),
 (np.float64(0.08808510537132627),
  82,
  (np.float64(0.04813107958456798),
   np.float64(0.10030888030888033),
   np.float64(0.05217780072431235)),
  (np.float64(0.03995402578675829),
   np.float64(0.09114832535885166),
   np.float64(0.05119429957209337))),
 (np.float64(0.08731339816893288),
  94,
  (np.float64(0.033861132917736694),
   np.float64(0.08625833625833626),
   np.float64(0.052397203340599566)),
  (np.float64(0.05345226525119619),
   np.float64(0.10459330143540671),
   np.float64(0.05114103618421052))),
 (np.float64(0.08227866923030201),
  78,
  (np.float64(0.0253009197507501),
   np.float64(0.07773982773982774),
   np.float64(0.05243890798907764)),
  (np.float64(0.05697774947955191),
   np.float64(0.10797448165869217),
   np.float64(0.050996732179140254))),
 (np.float64(0.08039148855795372),
  10,
  (np.float64(0.03426335005282376),
   np.float64(0.08360558360558362),
   np.float64(0.049342233552759865)),
  (np.float64(0.046128138505129965),
   np.float64(0.09323576320480345),
   np.float64(0.04710762469967349))),
 (np.float64(0.07742598790256394),
  52,
  (np.float64(0.03271823905059629),
   np.float64(0.08484555984555983),
   np.float64(0.052127320794963544)),
  (np.float64(0.044707748851967655),
   np.float64(0.09558745348219032),
   np.float64(0.050879704630222664))),
 (np.float64(0.07616298529792143),
  6,
  (np.float64(0.038216203700269534),
   np.float64(0.08460369236231305),
   np.float64(0.046387488662043515)),
  (np.float64(0.037946781597651885),
   np.float64(0.08329253365973073),
   np.float64(0.045345752062078845))),
 (np.float64(0.07435562441362889),
  22,
  (np.float64(0.03660808350458008),
   np.float64(0.087714614310359),
   np.float64(0.05110653080577892)),
  (np.float64(0.037747540909048805),
   np.float64(0.08772623257749117),
   np.float64(0.04997869166844236))),
 (np.float64(0.07208618201789971),
  4,
  (np.float64(0.04335457963079379),
   np.float64(0.08527493010251631),
   np.float64(0.041920350471722524)),
  (np.float64(0.028731602387105926),
   np.float64(0.07322057787174066),
   np.float64(0.044488975484634735))),
 (np.float64(0.0715236553520614),
  70,
  (np.float64(0.030278698038992635),
   np.float64(0.08261216881906536),
   np.float64(0.05233347078007272)),
  (np.float64(0.04124495731306877),
   np.float64(0.0923444976076555),
   np.float64(0.051099540294586736))),
 (np.float64(0.06944366600500912),
  30,
  (np.float64(0.02935275691410001),
   np.float64(0.08113703765877679),
   np.float64(0.05178428074467678)),
  (np.float64(0.04009090909090911),
   np.float64(0.09043062200956939),
   np.float64(0.05033971291866028))),
 (np.float64(0.06816999640017349),
  54,
  (np.float64(0.03195674494655735),
   np.float64(0.08412924202397885),
   np.float64(0.052172497077421505)),
  (np.float64(0.036213251453616147),
   np.float64(0.08724082934609251),
   np.float64(0.05102757789247636))),
 (np.float64(0.06604692973709886),
  90,
  (np.float64(0.042646062512218474),
   np.float64(0.09493033406076883),
   np.float64(0.05228427154855035)),
  (np.float64(0.023400867224880377),
   np.float64(0.07483253588516746),
   np.float64(0.05143166866028708))),
 (np.float64(0.06463790530028826),
  14,
  (np.float64(0.03394894434816942),
   np.float64(0.08428130911352387),
   np.float64(0.05033236476535445)),
  (np.float64(0.03068896095211885),
   np.float64(0.0802099946836789),
   np.float64(0.04952103373156005))),
 (np.float64(0.06416887763294218),
  20,
  (np.float64(0.03356215572840258),
   np.float64(0.08464508464508465),
   np.float64(0.05108292891668207)),
  (np.float64(0.030606721904539613),
   np.float64(0.0807846889952153),
   np.float64(0.05017796709067569))),
 (np.float64(0.06285106688733996),
  38,
  (np.float64(0.02768440606278441),
   np.float64(0.07972257972257969),
   np.float64(0.05203817365979528)),
  (np.float64(0.03516666082455556),
   np.float64(0.08594037541405962),
   np.float64(0.05077371458950406)))]

Python

python
# dark fractions around boundaries in logical image
col2=b2.mean(0); row2=b2.mean(1)
for x in [255,256,511,512,767,768,1023,1024,1044]:
    print("x",x,col2[x] if x<1045 else None)
print("last columns means", col2[1024:].round(3))
print("last rows", row2[256:].round(3))

Python

python
def rot(n,x,y,rx,ry):
    if ry==0:
        if rx==1:
            x=n-1-x
            y=n-1-y
        x,y=y,x
    return x,y

def d2xy(n,d):
    x=y=0
    t=d
    s=1
    while s<n:
        rx=1 & (t//2)
        ry=1 & (t ^ rx)
        x,y=rot(s,x,y,rx,ry)
        x += s*rx
        y += s*ry
        t//=4
        s*=2
    return x,y

coords256=np.array([d2xy(256,d) for d in range(256*256)],dtype=np.int16)
coords256[:10], coords256[-5:], coords256.min(0), coords256.max(0)


(array([[0, 0],
        [1, 0],
        [1, 1],
        [0, 1],
        [0, 2],
        [0, 3],
        [1, 3],
        [1, 2],
        [2, 2],
        [2, 3]], dtype=int16),
 array([[255,   2],
        [255,   1],
        [254,   1],
        [254,   0],
        [255,   0]], dtype=int16),
 array([0, 0], dtype=int16),
 array([255, 255], dtype=int16))

Python

python
# core logical region
core=b2[:256,:1024]
streams_tiles=[]
for j in range(4):
    tile=core[:,j*256:(j+1)*256]
    xs=coords256[:,0]; ys=coords256[:,1]
    bits_tile=tile[ys,xs].astype(np.uint8)
    streams_tiles.append(bits_tile)
bits4=np.concatenate(streams_tiles)
for inv in [0,1]:
    for order in ['big','little']:
        data=np.packbits(bits4^inv, bitorder=order).tobytes()
        print(inv,order, data[:32], sum(32<=c<127 for c in data[:500])/500)
        for m in [b'flag{',b'CTF{',b'PK\x03\x04',b'\x89PNG',b'GIF8',b'%PDF',b'BM',b'JFIF',b'7z\xbc',b'Rar!']:
            p=data.find(m)
            if p>=0

Python

python
import sympy as sp, math
sp.factorint(16611), 1045*259, (1045<<8)+259


({3: 1, 7: 2, 113: 1}, 270655, 267779)

Python

python
blk=bw.reshape(259,2,1045,2)
sums=blk.sum((1,3))
np.unique(sums, return_counts=True), np.mean((sums==0)|(sums==4))


((array([0, 1, 2, 3, 4]), array([218348,    458,   9548,    244,  42057])),
 np.float64(0.9621289094973305))

Python

python
col_diff2=np.mean(b2[:,1:]!=b2[:,:-1], axis=0)
row_diff2=np.mean(b2[1:,:]!=b2[:-1,:], axis=1)
scores2=[]
for k in range(2,130):
    sc=boundary_score(col_diff2,k)[0]+boundary_score(row_diff2,k)[0]
    scores2.append((sc,k,boundary_score(col_diff2,k),boundary_score(row_diff2,k)))
sorted(scores2, reverse=True)[:30]


[(np.float64(0.16752509380555664),
  65,
  (np.float64(-2.81688024879323e-06),
   np.float64(0.0929054054054054),
   np.float64(0.0929082222856542)),
  (np.float64(0.16752791068580541),
   np.float64(0.2574162679425837),
   np.float64(0.08988835725677831))),
 (np.float64(0.09245488335434786),
  73,
  (np.float64(-0.00891297479369603),
   np.float64(0.08411472697186981),
   np.float64(0.09302770176556584)),
  (np.float64(0.10136785814804389),
   np.float64(0.1920255183413078),
   np.float64(0.0906576601932639))),
 (np.float64(0.09175066797429823),
  81,
  (np.float64(-0.0015488910837747893),
   np.float64(0.0913770913770914),
   np.float64(0.09292598246086618)),
  (np.float64(0.09329955905807302),
   np.float64(0.18405103668261566),
   np.float64(0.09075147762454264))),
 (np.float64(0.08162501021262232),
  89,
  (np.float64(-0.011953040026612141),
   np.float64(0.08108108108108109),
   np.float64(0.09303412110769323)),
  (np.float64(0.09357805023923446),
   np.float64(0.184688995215311),
   np.float64(0.09111094497607655))),
 (np.float64(0.07834931542589059),
  49,
  (np.float64(0.06016825371664081),
   np.float64(0.15186615186615185),
   np.float64(0.09169789814951104)),
  (np.float64(0.018181061709249782),
   np.float64(0.10966507177033494),
   np.float64(0.09148401006108516))),
 (np.float64(0.04987934139648935),
  77,
  (np.float64(-0.005660577920519744),
   np.float64(0.08731808731808731),
   np.float64(0.09297866523860705)),
  (np.float64(0.05553991931700909),
   np.float64(0.14673046251993618),
   np.float64(0.09119054320292709))),
 (np.float64(0.048481422026529844),
  98,
  (np.float64(0.054720207911697294),
   np.float64(0.14710424710424713),
   np.float64(0.09238403919254984)),
  (np.float64(-0.00623878588516745),
   np.float64(0.08564593301435407),
   np.float64(0.09188471889952152))),
 (np.float64(0.046969549152617904),
  69,
  (np.float64(-0.016961401217960984),
   np.float64(0.0761904761904762),
   np.float64(0.09315187740843718)),
  (np.float64(0.06393095037057889),
   np.float64(0.1550239234449761),
   np.float64(0.0910929730743972))),
 (np.float64(0.04043289621572099),
  97,
  (np.float64(-0.004924460243609166),
   np.float64(0.08803088803088803),
   np.float64(0.0929553482744972)),
  (np.float64(0.04535735645933016),
   np.float64(0.1368421052631579),
   np.float64(0.09148474880382775))),
 (np.float64(0.03492306864144766),
  93,
  (np.float64(-0.009469873942284393),
   np.float64(0.08353808353808354),
   np.float64(0.09300795748036793)),
  (np.float64(0.044392942583732053),
   np.float64(0.13588516746411483),
   np.float64(0.09149222488038278))),
 (np.float64(0.02824523593120548),
  123,
  (np.float64(0.05762995483072701),
   np.float64(0.15009652509652507),
   np.float64(0.09246657026579806)),
  (np.float64(-0.02938471889952153),
   np.float64(0.06267942583732057),
   np.float64(0.0920641447368421))),
 (np.float64(0.02655245729473417),
  105,
  (np.float64(-0.0024098632794285063),
   np.float64(0.09051909051909052),
   np.float64(0.09292895379851902)),
  (np.float64(0.028962320574162675),
   np.float64(0.12057416267942583),
   np.float64(0.09161184210526316))),
 (np.float64(0.025728521935275125),
  13,
  (np.float64(0.0017740992326054639),
   np.float64(0.09454633204633205),
   np.float64(0.09277223281372658)),
  (np.float64(0.02395442270266966),
   np.float64(0.11402669352807858),
   np.float64(0.09007227082540892))),
 (np.float64(0.017643049185241275),
  75,
  (np.float64(-0.001750890208698147),
   np.float64(0.09117909117909119),
   np.float64(0.09292998138778934)),
  (np.float64(0.01939393939393942),
   np.float64(0.11100478468899522),
   np.float64(0.0916108452950558))),
 (np.float64(0.017507028693950863),
  41,
  (np.float64(0.0173133627108112),
   np.float64(0.10980694980694981),
   np.float64(0.09249358709613861)),
  (np.float64(0.00019366598313966255),
   np.float64(0.0920255183413078),
   np.float64(0.09183185235816814))),
 (np.float64(0.016598128682152012),
  85,
  (np.float64(-0.03442354314447337),
   np.float64(0.058880308880308894),
   np.float64(0.09330385202478227)),
  (np.float64(0.051021671826625384),
   np.float64(0.14226475279106857),
   np.float64(0.09124308096444318))),
 (np.float64(0.015719659784010936),
  33,
  (np.float64(0.002058923372173685),
   np.float64(0.09490596587370781),
   np.float64(0.09284704250153412)),
  (np.float64(0.013660736411837252),
   np.float64(0.10512645249487354),
   np.float64(0.09146571608303629))),
 (np.float64(0.014012430641213602),
  47,
  (np.float64(-7.006269237187779e-05),
   np.float64(0.09283959283959285),
   np.float64(0.09290965553196473)),
  (np.float64(0.01408249333358548),
   np.float64(0.10564593301435406),
   np.float64(0.09156343968076858))),
 (np.float64(0.013835359906086836),
  39,
  (np.float64(-0.0026870066162796996),
   np.float64(0.09028809028809029),
   np.float64(0.09297509690436999)),
  (np.float64(0.016522366522366536),
   np.float64(0.10797448165869218),
   np.float64(0.09145211513632565))),
 (np.float64(0.013681411770391727),
  67,
  (np.float64(-0.015394486531512777),
   np.float64(0.07773487773487772),
   np.float64(0.0931293642663905)),
  (np.float64(0.029075898301904504),
   np.float64(0.12057416267942583),
   np.float64(0.09149826437752133))),
 (np.float64(0.013624206369354463),
  79,
  (np.float64(0.009075937300961526),
   np.float64(0.10187110187110185),
   np.float64(0.09279516457014032)),
  (np.float64(0.004548269068392938),
   np.float64(0.0963317384370016),
   np.float64(0.09178346936860866))),
 (np.float64(0.012197755066390661),
  113,
  (np.float64(-0.007602633689590216),
   np.float64(0.08537108537108537),
   np.float64(0.09297371906067559)),
  (np.float64(0.019800388755980877),
   np.float64(0.11148325358851675),
   np.float64(0.09168286483253588))),
 (np.float64(0.011554566152678275),
  109,
  (np.float64(-0.0019771324119150224),
   np.float64(0.09094809094809095),
   np.float64(0.09292522336000597)),
  (np.float64(0.013531698564593297),
   np.float64(0.10526315789473684),
   np.float64(0.09173145933014354))),
 (np.float64(0.009771895446938697),
  61,
  (np.float64(0.02237785558708863),
   np.float64(0.11492164433340903),
   np.float64(0.0925437887463204)),
  (np.float64(-0.012605960140149933),
   np.float64(0.07942583732057416),
   np.float64(0.0920317974607241))),
 (np.float64(0.0096101638893058),
  91,
  (np.float64(-0.0034393277374884512),
   np.float64(0.0895050895050895),
   np.float64(0.09294441724257795)),
  (np.float64(0.013049491626794252),
   np.float64(0.10478468899521531),
   np.float64(0.09173519736842106))),
 (np.float64(0.009319653213046217),
  27,
  (np.float64(0.0006956836505858377),
   np.float64(0.09357854094696201),
   np.float64(0.09288285729637617)),
  (np.float64(0.008623969562460379),
   np.float64(0.10015948963317385),
   np.float64(0.09153552007071347))),
 (np.float64(0.008617037051774648),
  125,
  (np.float64(0.017749064563736372),
   np.float64(0.11052123552123552),
   np.float64(0.09277217095749915)),
  (np.float64(-0.009132027511961724),
   np.float64(0.08277511961722488),
   np.float64(0.0919071471291866))),
 (np.float64(0.00819139721052678),
  26,
  (np.float64(0.00044878401452107253),
   np.float64(0.09333976833976834),
   np.float64(0.09289098432524727)),
  (np.float64(0.007742613196005707),
   np.float64(0.09930887825624667),
   np.float64(0.09156626506024096))),
 (np.float64(0.0076940770014777005),
  121,
  (np.float64(0.02261258776702793),
   np.float64(0.11534749034749035),
   np.float64(0.09273490258046242)),
  (np.float64(-0.01491851076555023),
   np.float64(0.07703349282296651),
   np.float64(0.09195200358851674))),
 (np.float64(0.0042360366076071715),
  95,
  (np.float64(0.0013128906745928093),
   np.float64(0.09420849420849421),
   np.float64(0.0928956035339014)),
  (np.float64(0.002923145933014362),
   np.float64(0.09473684210526316),
   np.float64(0.0918136961722488)))]

Python

python
seps=[3+64+i*65 for i in range(15)]  # after each tile: 67,132...
seps[:5],seps[-3:], [round(float(col2[x]),3) for x in seps[:10]], np.mean([col2[x] for x in seps])


([67, 132, 197, 262, 327],
 [847, 912, 977],
 [0.166, 0.178, 0.208, 0.162, 0.073, 0.108, 0.097, 0.174, 0.12, 0.143],
 np.float64(0.16036036036036036))

Python

python
[(i,float(row_diff2[i])) for i in range(len(row_diff2)) if i in [63,64,65,128,129,130,193,194,195,255,256]]


[(63, 0.03253588516746411),
 (64, 0.2784688995215311),
 (65, 0.04880382775119617),
 (128, 0.028708133971291867),
 (129, 0.2535885167464115),
 (130, 0.06794258373205742),
 (193, 0.05167464114832536),
 (194, 0.24019138755980862),
 (195, 0.042105263157894736),
 (255, 0.05741626794258373),
 (256, 0.07751196172248803)]

Python

python
# top column-only periods
col_scores=[]
for k in range(2,130):
    sc=boundary_score(col_diff2,k)
    col_scores.append((sc[0],k,sc[1],sc[2]))
sorted(col_scores, reverse=True)[:30]


[(np.float64(0.06016825371664081),
  49,
  np.float64(0.15186615186615185),
  np.float64(0.09169789814951104)),
 (np.float64(0.05762995483072701),
  123,
  np.float64(0.15009652509652507),
  np.float64(0.09246657026579806)),
 (np.float64(0.054720207911697294),
  98,
  np.float64(0.14710424710424713),
  np.float64(0.09238403919254984)),
 (np.float64(0.024164945676573554),
  82,
  np.float64(0.11679536679536677),
  np.float64(0.09263042111879322)),
 (np.float64(0.02261258776702793),
  121,
  np.float64(0.11534749034749035),
  np.float64(0.09273490258046242)),
 (np.float64(0.02237785558708863),
  61,
  np.float64(0.11492164433340903),
  np.float64(0.0925437887463204)),
 (np.float64(0.019973381057601783),
  90,
  np.float64(0.11267111267111268),
  np.float64(0.0926977316135109)),
 (np.float64(0.019659410963758797),
  112,
  np.float64(0.1123981123981124),
  np.float64(0.0927387014343536)),
 (np.float64(0.018465605699648224),
  102,
  np.float64(0.11119691119691118),
  np.float64(0.09273130549726295)),
 (np.float64(0.01792848749370489),
  115,
  np.float64(0.11068211068211069),
  np.float64(0.0927536231884058)),
 (np.float64(0.017749064563736372),
  125,
  np.float64(0.11052123552123552),
  np.float64(0.09277217095749915)),
 (np.float64(0.01749021497327405),
  94,
  np.float64(0.11021411021411023),
  np.float64(0.09272389524083618)),
 (np.float64(0.0173133627108112),
  41,
  np.float64(0.10980694980694981),
  np.float64(0.09249358709613861)),
 (np.float64(0.016776359923078063),
  119,
  np.float64(0.10955598455598456),
  np.float64(0.0927796246329065)),
 (np.float64(0.013371893680774002),
  120,
  np.float64(0.10617760617760619),
  np.float64(0.09280571249683219)),
 (np.float64(0.013332282720037836),
  66,
  np.float64(0.10604890604890606),
  np.float64(0.09271662332886822)),
 (np.float64(0.012005543620329628),
  62,
  np.float64(0.10472972972972974),
  np.float64(0.09272418610940011)),
 (np.float64(0.01142648439945737),
  117,
  np.float64(0.10424710424710425),
  np.float64(0.09282061984764688)),
 (np.float64(0.011422705030847094),
  45,
  np.float64(0.10407923451401711),
  np.float64(0.09265652948317002)),
 (np.float64(0.0094994137547329),
  99,
  np.float64(0.1023166023166023),
  np.float64(0.09281718856186941)),
 (np.float64(0.009448722777092092),
  60,
  np.float64(0.10220304337951396),
  np.float64(0.09275432060242186)),
 (np.float64(0.009075937300961526),
  79,
  np.float64(0.10187110187110185),
  np.float64(0.09279516457014032)),
 (np.float64(0.008719744889957678),
  100,
  np.float64(0.10154440154440156),
  np.float64(0.09282465665444388)),
 (np.float64(0.008508370477482444),
  127,
  np.float64(0.10135135135135136),
  np.float64(0.09284298087386891)),
 (np.float64(0.007623974420849444),
  52,
  np.float64(0.10038610038610041),
  np.float64(0.09276212596525096)),
 (np.float64(0.007623974420849403),
  51,
  np.float64(0.10038610038610038),
  np.float64(0.09276212596525098)),
 (np.float64(0.007550241592794785),
  104,
  np.float64(0.10038610038610038),
  np.float64(0.0928358587933056)),
 (np.float64(0.007535665836824135),
  124,
  np.float64(0.1003861003861004),
  np.float64(0.09285043454927626)),
 (np.float64(0.007300028381859183),
  72,
  np.float64(0.10011031439602869),
  np.float64(0.0928102860141695)),
 (np.float64(0.005601069430856656),
  101,
  np.float64(0.09845559845559845),
  np.float64(0.0928545290247418))]

Python

python
# top 50 col boundary peaks
peaks=sorted([(float(v),i) for i,v in enumerate(col_diff2)], reverse=True)[:80]
peaks[:30]


[(0.4362934362934363, 130),
 (0.3667953667953668, 783),
 (0.36293436293436293, 122),
 (0.3552123552123552, 392),
 (0.3552123552123552, 114),
 (0.30115830115830117, 126),
 (0.2857142857142857, 905),
 (0.2857142857142857, 522),
 (0.2702702702702703, 375),
 (0.26640926640926643, 718),
 (0.26640926640926643, 142),
 (0.26640926640926643, 118),
 (0.2625482625482625, 1036),
 (0.2625482625482625, 473),
 (0.2625482625482625, 294),
 (0.2625482625482625, 245),
 (0.2548262548262548, 195),
 (0.2471042471042471, 848),
 (0.2471042471042471, 555),
 (0.2471042471042471, 367),
 (0.2471042471042471, 359),
 (0.24324324324324326, 620),
 (0.23938223938223938, 734),
 (0.23938223938223938, 662),
 (0.23938223938223938, 660),
 (0.23552123552123552, 791),
 (0.23552123552123552, 73),
 (0.23552123552123552, 65),
 (0.23552123552123552, 7),
 (0.23166023166023167, 664)]

Python

python
def best_period_phase(diff, k):
    vals=[]
    for phase in range(k):
        mask=(np.arange(len(diff))%k)==phase
        if mask.sum()<2: continue
        vals.append((diff[mask].mean()-diff[~mask].mean(), phase, diff[mask].mean(),mask.sum()))
    return max(vals)
for k in range(40,70):
    sc=best_period_phase(col_diff2,k)
    if sc[0]>0.03:
        print(k,sc)

Python

python
for k in [64,65,66]:
    print(k,best_period_phase(row_diff2,k))

Python

python
# Re-load arrays from file, recompute b2 robustly
from PIL import Image
import numpy as np, os, math
img=Image.open('/mnt/data/flag.png').convert('RGB')
a=np.array(img); gray=a.mean(2); bw=gray<128
b2=bw.reshape(259,2,1045,2).mean((1,3))>0.5
for x0,x1 in [(259,262),(521,524),(783,786)]:
    print((x0,x1), b2[:,x0:x1].mean(), [round(float(b2[:,x].mean()),3) for x in range(x0,x1)])
# edge diffs at panel boundaries
col_diff2=np.mean(b2[:,1:]!=b2[:,:-1],axis=0)
for i in range(250,270):
    if col_diff2[i]>0.15: print("around259",i,col_diff2[i])
for i in range(515,530):
    if col_diff2[i]>0.15: print("around522",i,col_diff2[i])
for i in range(775

Python

python
import numpy as np, itertools, math, re, os, statistics
key=b'CTF'
bits7=np.concatenate([np.array([(c>>i)&1 for i in range(6,-1,-1)],dtype=np.uint8) for c in key])
bits8=np.unpackbits(np.frombuffer(key,dtype=np.uint8))
bits7, bits8, ''.join(map(str,bits7))


(array([1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0],
       dtype=uint8),
 array([0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1,
        1, 0], dtype=uint8),
 '100001110101001000110')

Python

python
# search exact 7-bit CTF pattern horizontally and vertically in b2 and inversion
def find_pattern_1d(arr, pat):
    # boolean array -> positions exact
    n=len(pat)
    if len(arr)<n: return []
    # use sliding windows vectorized
    from numpy.lib.stride_tricks import sliding_window_view
    w=sliding_window_view(arr.astype(np.uint8), n)
    return np.where((w==pat).all(axis=1))[0].tolist()

hits=[]
for inv in [0,1]:
    pat=bits7^inv
    for y in range(b2.shape[0]):
        ps=find_pattern_1d(b2[y].astype(np.uint8),pat)
        for x in ps[:10]:
            hits.append(('row',inv,x,y))
    for x in range(b2.shape[1]):
        ps=find_pattern_1d(b2[:,x].astype(np.uint8),pat)


(0, [])

Python

python
# reconstruct generalized hilbert function quickly
def sgn(x): return -1 if x<0 else (1 if x>0 else 0)
def generate2d(x,y,ax,ay,bx,by):
    w=abs(ax+ay); h=abs(bx+by)
    dax,day=sgn(ax),sgn(ay); dbx,dby=sgn(bx),sgn(by)
    if h==1:
        for _ in range(w):
            yield x,y; x+=dax; y+=day
        return
    if w==1:
        for _ in range(h):
            yield x,y; x+=dbx; y+=dby
        return
    ax2,ay2=ax//2,ay//2; bx2,by2=bx//2,by//2
    w2=abs(ax2+ay2); h2=abs(bx2+by2)
    if 2*w>3*h:
        if (w2%2) and (w>2): ax2+=dax; ay2+=day
        yield from generate2d(x,y,ax2,ay2,bx,by)
        yield from generate2d(x+ax2,y+ay2,ax-ax2,ay-ay2,bx,by)
    else:
        if (h2%2) and (h>2): bx2+=dbx; by2+=dby
        yield from generate2d(x,y,bx2,by2,ax2,ay2)
        yield from generate2d(x+bx2,y+by2,ax,ay,bx-bx2,by-by2)
        yield from generate2d(x+(ax-dax)+(bx2-dbx),y+(ay-day)+(by2-dby),
                              -bx2,-by2,-(ax-ax2),-(ay-ay2))
def gilbert2d(W,H):
    if W>=H: yield from generate2d(0,0,W,0,0,H)
    else: yield from generate2d(0,0,0,H,W,0)

core=b2[:256,:1024]
coords=np.array(list(gilbert2d(1024,256)),dtype=np.int32)
bits=core[coords[:,1],coords[:,0]].astype(np.uint8)
def variants(bits):
    for rev in [0,1]:
        bb=bits[::-1] if rev else bits
        for inv in [0,1]:
            bbb=bb^inv
            for order in ['big','little']:
                yield (rev,inv,order), np.packbits(bbb,bitorder=order).tobytes()
magics=[b'flag{',b'CTF{',b'PK\x03\x04',b'\x89PNG',b'GIF8',b'%PDF',b'BM',b'Rar!',b'7z\xbc\xaf\x27\x1c',b'\xff\xd8\xff',b'SQLite',b'ELF']
key=b'CTF'
results=[]
for tag,data in variants(bits):
    transforms={'raw':data,
                'xorCTF':bytes(c^key[i%3] for i,c in enumerate(data)),
                'addCTF':bytes((c-key[i%3])&255 for i,c in enumerate(data))}
    for name,d in transforms.items():
        pr=sum((32<=c<127 or c in (9,10,13)) for c in d[:4096])/min(4096,len(d))
        for m in magics:
            p=d.find(m)
            if p>=0: results.append((tag,name,m,p,pr))
        # record best printable
        if pr>0.5: results.append((tag,name,b'printable',0,pr))
results[:50], len(results)


([((0, 0, 'big'), 'xorCTF', b'CTF{', 1692, 0.811279296875),
  ((0, 0, 'big'), 'xorCTF', b'BM', 15677, 0.811279296875),
  ((0, 0, 'big'), 'xorCTF', b'printable', 0, 0.811279296875),
  ((0, 0, 'little'), 'raw', b'\xff\xd8\xff', 27666, 0.097900390625),
  ((0, 0, 'little'), 'xorCTF', b'CTF{', 807, 0.8056640625),
  ((0, 0, 'little'), 'xorCTF', b'printable', 0, 0.8056640625),
  ((0, 1, 'big'), 'raw', b'\xff\xd8\xff', 5427, 0.08056640625),
  ((0, 1, 'little'), 'raw', b'\xff\xd8\xff', 2956, 0.085205078125),
  ((1, 0, 'big'), 'raw', b'\xff\xd8\xff', 5099, 0.081298828125),
  ((1, 0, 'big'), 'xorCTF', b'CTF{', 5136, 0.83154296875),
  ((1, 0, 'big'), 'xorCTF', b'printable', 0, 0.83154296875),
  ((1, 0, 'little'), 'xorCTF', b'CTF{', 2709, 0.84130859375),
  ((1, 0, 'little'), 'xorCTF', b'printable', 0, 0.84130859375),
  ((1, 1, 'big'), 'raw', b'\xff\xd8\xff', 29809, 0.070068359375),
  ((1, 1, 'little'), 'raw', b'\xff\xd8\xff', 19814, 0.0634765625)],
 15)

Python

python
# inspect xorCTF decrypted samples around CTF{ hits
for tag,data in variants(bits):
    if tag in [(0,0,'big'),(0,0,'little'),(1,0,'big'),(1,0,'little')]:
        d=bytes(c^key[i%3] for i,c in enumerate(data))
        # positions of CTF{
        pos=0
        print("TAG",tag,"first200",repr(d[:200]))
        while True:
            p=d.find(b'CTF{',pos)
            if p<0: break
            print(" hit",p,repr(d[max(0,p-100):p+300]))
            pos=p+1

Python

python
# reload b2 and diffs
from PIL import Image
import numpy as np, math, itertools, collections, statistics
img=Image.open('/mnt/data/flag.png').convert('RGB')
a=np.array(img); bw=a.mean(2)<128
b2=bw.reshape(259,2,1045,2).mean((1,3))>0.5
col_diff2=np.mean(b2[:,1:]!=b2[:,:-1],axis=0)
row_diff2=np.mean(b2[1:,:]!=b2[:-1,:],axis=1)
positions=list(range(32,len(col_diff2),49))
[(p,round(float(col_diff2[p]),3)) for p in positions], len(positions)


([(32, 0.197),
  (81, 0.185),
  (130, 0.436),
  (179, 0.174),
  (228, 0.189),
  (277, 0.077),
  (326, 0.108),
  (375, 0.27),
  (424, 0.062),
  (473, 0.263),
  (522, 0.286),
  (571, 0.139),
  (620, 0.243),
  (669, 0.069),
  (718, 0.266),
  (767, 0.181),
  (816, 0.158),
  (865, 0.035),
  (914, 0.22),
  (963, 0.147),
  (1012, 0.023)],
 21)

Python

python
positions65=list(range(3,len(col_diff2),65))
[(p,round(float(col_diff2[p]),3)) for p in positions65], len(positions65)


([(3, 0.189),
  (68, 0.1),
  (133, 0.054),
  (198, 0.073),
  (263, 0.042),
  (328, 0.062),
  (393, 0.108),
  (458, 0.05),
  (523, 0.062),
  (588, 0.042),
  (653, 0.22),
  (718, 0.266),
  (783, 0.367),
  (848, 0.247),
  (913, 0.143),
  (978, 0.224),
  (1043, 0.073)],
 17)

Python

python
from PIL import Image, ImageOps, ImageDraw
import numpy as np, math, itertools, os

# b2 bool black
def d2xy(n,d):
    def rot(n,x,y,rx,ry):
        if ry==0:
            if rx==1:
                x=n-1-x; y=n-1-y
            x,y=y,x
        return x,y
    x=y=0; t=d; s=1
    while s<n:
        rx=1&(t//2); ry=1&(t^rx)
        x,y=rot(s,x,y,rx,ry)
        x += s*rx; y += s*ry; t//=4; s*=2
    return x,y
hcoords=np.array([d2xy(8,i) for i in range(64)])

# function source tile extraction 16x4 of 65 after crop/pad
def make_final(xoff=0,pad_top=False,reverse=False,transform=0):
    # crop 1040 wide starting xoff
    src=b2[:,xoff:xoff+1040]
    # pad row to 260
    if pad_top:
        src=np.vstack([np.zeros((1,1040),bool),src])
    else:
        src=np.vstack([src,np.zeros((1,1040),bool)])
    tiles=[]
    for r in range(4):
        for c in range(16):
            tiles.append(src[r*65:(r+1)*65,c*65:(c+1)*65])
    if reverse:
        tiles=tiles[::-1]
    out=np.zeros((8*65,8*65),bool)
    coords=hcoords.copy()
    # symmetry transform of Hilbert target coords (x,y)
    x=coords[:,0].copy(); y=coords[:,1].copy()
    # D4: transform 0..7
    if transform==0: xx,yy=x,y
    elif transform==1: xx,yy=7-y,x
    elif transform==2: xx,yy=7-x,7-y
    elif transform==3: xx,yy=y,7-x
    elif transform==4: xx,yy=7-x,y
    elif transform==5: xx,yy=x,7-y
    elif transform==6: xx,yy=y,x
    elif transform==7: xx,yy=7-y,7-x
    for i,t in enumerate(tiles):
        out[yy[i]*65:(yy[i]+1)*65, xx[i]*65:(xx[i]+1)*65]=t
    return out

# make contact sheet for xoff 0..5, transform standard only first
thumbs=[]
labels=[]
for xoff in range(6):
    for padtop in [False,True]:
        arr=make_final(xoff,padtop,False,0)
        im=Image.fromarray((~arr*255).astype(np.uint8)).resize((260,260))
        thumbs.append(im); labels.append(f"x{xoff}{'T' if padtop else 'B'}")
sheet=Image.new('L',(6*300,2*300),255)
draw=ImageDraw.Draw(sheet)
for idx,im in enumerate(thumbs):
    col=idx%6; row=idx//6
    sheet.paste(im,(col*300,row*300+20))
    draw.text((col*300+5,row*300+2),labels[idx],fill=0)
sheet.save('/mnt/data/hilbert_tiles_test.png')
print('/mnt/data/hilbert_tiles_test.png')

Python

python
# define edge mismatch score across tile grid boundaries
def edge_score(arr, tile=65):
    H,W=arr.shape
    vals=[]
    for k in range(1,W//tile):
        x=k*tile
        vals.append(np.mean(arr[:,x-1]!=arr[:,x]))
    for k in range(1,H//tile):
        y=k*tile
        vals.append(np.mean(arr[y-1,:]!=arr[y,:]))
    return float(np.mean(vals)), vals

cands=[]
for xoff in range(6):
    for padtop in [False,True]:
        for rev in [False,True]:
            for tr in range(8):
                arr=make_final(xoff,padtop,rev,tr)
                s,_=edge_score(arr)
                cands.append((s,xoff,padtop,rev,tr))
sorted(cands)[:20]


[(0.19381868131868132, 2, True, False, 5),
 (0.19381868131868132, 2, True, True, 2),
 (0.19739010989010985, 2, True, False, 0),
 (0.19739010989010985, 2, True, True, 4),
 (0.2037087912087912, 1, True, False, 5),
 (0.2037087912087912, 1, True, True, 2),
 (0.20412087912087912, 3, True, False, 5),
 (0.20412087912087912, 3, True, True, 2),
 (0.20604395604395603, 0, True, False, 5),
 (0.20604395604395603, 0, True, True, 2),
 (0.20714285714285716, 1, True, False, 0),
 (0.20714285714285716, 1, True, True, 4),
 (0.20714285714285716, 3, True, False, 0),
 (0.20714285714285716, 3, True, True, 4),
 (0.20947802197802198, 2, False, False, 0),
 (0.20947802197802198, 2, False, True, 4),
 (0.2097527472527473, 0, True, False, 0),
 (0.2097527472527473, 0, True, True, 4),
 (0.21057692307692305, 2, True, False, 3),
 (0.21057692307692305, 2, True, True, 6)]

Python

python
from PIL import Image
import numpy as np, os, math, itertools, re, collections, statistics
img=Image.open('/mnt/data/flag.png').convert('L')
# Resize original directly to intended 1024x256 with bilinear/area and threshold
res_methods = {
    'nearest': Image.Resampling.NEAREST,
    'bilinear': Image.Resampling.BILINEAR,
    'box': Image.Resampling.BOX,
    'lanczos': Image.Resampling.LANCZOS
}
matrices={}
for name,method in res_methods.items():
    r=img.resize((1024,256),resample=method)
    arr=np.array(r)<128
    matrices[name]=arr
    print(name,arr.mean())

Python

python
def d2xy(n,d):
    x=y=0; t=d; s=1
    while s<n:
        rx=1&(t//2); ry=1&(t^rx)
        if ry==0:
            if rx==1:
                x=s-1-x; y=s-1-y
            x,y=y,x
        x += s*rx; y += s*ry
        t//=4; s*=2
    return x,y
coords=np.array([d2xy(256,i) for i in range(65536)],dtype=np.int16)

def transform_coords(coords, n, tr):
    x=coords[:,0]; y=coords[:,1]
    if tr==0: xx,yy=x,y
    elif tr==1: xx,yy=n-1-y,x
    elif tr==2: xx,yy=n-1-x,n-1-y
    elif tr==3: xx,yy=y,n-1-x
    elif tr==4: xx,yy=n-1-x,y
    elif tr==5: xx,yy=x,n-1-y
    elif tr==6: xx,yy=y,x
    elif tr==7: xx,yy=n-1-y,n-1-x
    return xx,yy

magics=[b'flag{',b'CTF{',b'ctf{',b'PK\x03\x04',b'\x89PNG\r\n\x1a\n',b'GIF89a',b'GIF87a',b'%PDF-',b'BM',b'Rar!',b'7z\xbc\xaf\x27\x1c',b'\xff\xd8\xff',b'SQLite format 3\x00',b'\x1f\x8b\x08']
key=b'CTF'
best=[]
hits=[]
for rname,mat in matrices.items():
    tiles=[mat[:,i*256:(i+1)*256] for i in range(4)]
    for tr in range(8):
        xx,yy=transform_coords(coords,256,tr)
        for rev in [0,1]:
            seqs=[]
            for tile in tiles:
                s=tile[yy,xx].astype(np.uint8)
                if rev:s=s[::-1]
                seqs.append(s)
            # tile order variants maybe normal/reverse
            for trev in [0,1]:
                seqall=np.concatenate(seqs[::-1] if trev else seqs)
                for inv in [0,1]:
                    sb=seqall^inv
                    for order in ['big','little']:
                        data=np.packbits(sb,bitorder=order).tobytes()
                        variants={'raw':data,
                                  'xorCTF':bytes(c^key[i%3] for i,c in enumerate(data))}
                        for mode,d in variants.items():
                            pr=sum(32<=c<127 or c in (9,10,13) for c in d)/len(d)
                            # score repeated known magic
                            for m in magics:
                                p=d.find(m)
                                if p>=0: hits.append((rname,tr,rev,trev,inv,order,mode,m,p,pr))
                            best.append((pr,rname,tr,rev,trev,inv,order,mode,d[:24]))
sorted(best,reverse=True)[:10], hits[:30], len(hits)


([(0.816680908203125,
   'bilinear',
   4,
   0,
   1,
   0,
   'big',
   'xorCTF',
   b'C\xab\xb9\xbd\xab\xb9_TFCTFCTFCTFCTFCTF'),
  (0.816680908203125,
   'bilinear',
   0,
   1,
   1,
   0,
   'big',
   'xorCTF',
   b'C\xab\xb9\xbd\xab\xb9_TFCTFCTFCTFCTFCTF'),
  (0.8165283203125,
   'bilinear',
   4,
   1,
   1,
   0,
   'little',
   'xorCTF',
   b'CZF\xbc\xab\xb9\xbc\xaby\xbb\xab\xbf\xbcSF\xb3\xa4\xb9\xbc+F\x05TF'),
  (0.8165283203125,
   'bilinear',
   4,
   1,
   0,
   0,
   'little',
   'xorCTF',
   b'CVFCTFCTFC\x84\xf9zTF\xc3\xabw\xbd\xab><\xc9\xb9'),
  (0.8165283203125,
   'bilinear',
   0,
   0,
   1,
   0,
   'little',
   'xorCTF',
   b'CZF\xbc\xab\xb9\xbc\xaby\xbb\xab\xbf\xbcSF\xb3\xa4\xb9\xbc+F\x05TF'),
  (0.8165283203125,
   'bilinear',
   0,
   0,
   0,
   0,
   'little',
   'xorCTF',
   b'CVFCTFCTFC\x84\xf9zTF\xc3\xabw\xbd\xab><\xc9\xb9'),
  (0.81640625,
   'bilinear',
   4,
   0,
   0,
   0,
   'big',
   'xorCTF',
   b'\xbc\xb49\xbc\xabFOT@#TFCTI\xbc\xab\xba\x03g\xd9\x83T\xb7'),
  (0.81640625,
   'bilinear',
   0,
   1,
   0,
   0,
   'big',
   'xorCTF',
   b'\xbc\xb49\xbc\xabFOT@#TFCTI\xbc\xab\xba\x03g\xd9\x83T\xb7'),
  (0.816070556640625,
   'bilinear',
   7,
   0,
   0,
   0,
   'little',
   'xorCTF',
   b'CTFCTFC_\x06A\xd4\x7f\xdc\xad\x7fCk\xba\xdc\xad\xb9\xb4\xeb&'),
  (0.816070556640625,
   'bilinear',
   5,
   1,
   0,
   0,
   'little',
   'xorCTF',
   b'CTHCTFCTFET\xd6H\x14%\x83\xab\x80\x83\xeb\xb9\xbe\xa8y')],
 [('nearest', 0, 0, 0, 0, 'big', 'xorCTF', b'CTF{', 9540, 0.808685302734375),
  ('nearest', 0, 0, 0, 0, 'little', 'xorCTF', b'CTF{', 765, 0.811492919921875),
  ('nearest',
   0,
   0,
   0,
   1,
   'big',
   'raw',
   b'\xff\xd8\xff',
   4028,
   0.063018798828125),
  ('nearest',
   0,
   0,
   0,
   1,
   'little',
   'raw',
   b'\xff\xd8\xff',
   21341,
   0.063629150390625),
  ('nearest', 0, 0, 1, 0, 'big', 'xorCTF', b'CTF{', 8874, 0.808258056640625),
  ('nearest',
   0,
   0,
   1,
   0,
   'little',
   'xorCTF',
   b'CTF{',
   7941,
   0.811309814453125),
  ('nearest',
   0,
   0,
   1,
   1,
   'big',
   'raw',
   b'\xff\xd8\xff',
   28604,
   0.063018798828125),
  ('nearest',
   0,
   0,
   1,
   1,
   'little',
   'raw',
   b'\xff\xd8\xff',
   5478,
   0.063629150390625),
  ('nearest', 0, 1, 0, 0, 'big', 'xorCTF', b'CTF{', 384, 0.81121826171875),
  ('nearest',
   0,
   1,
   0,
   0,
   'little',
   'xorCTF',
   b'CTF{',
   14877,
   0.808013916015625),
  ('nearest',
   0,
   1,
   0,
   1,
   'big',
   'raw',
   b'\xff\xd8\xff',
   19616,
   0.063629150390625),
  ('nearest',
   0,
   1,
   0,
   1,
   'little',
   'raw',
   b'\xff\xd8\xff',
   4161,
   0.063018798828125),
  ('nearest',
   0,
   1,
   0,
   1,
   'little',
   'xorCTF',
   b'CTF{',
   17733,
   0.165802001953125),
  ('nearest', 0, 1, 1, 0, 'big', 'xorCTF', b'CTF{', 4176, 0.811279296875),
  ('nearest', 0, 1, 1, 0, 'little', 'xorCTF', b'CTF{', 8919, 0.80859375),
  ('nearest',
   0,
   1,
   1,
   1,
   'big',
   'raw',
   b'\xff\xd8\xff',
   2711,
   0.063629150390625),
  ('nearest',
   0,
   1,
   1,
   1,
   'little',
   'raw',
   b'\xff\xd8\xff',
   28737,
   0.063018798828125),
  ('nearest',
   0,
   1,
   1,
   1,
   'little',
   'xorCTF',
   b'CTF{',
   2184,
   0.165557861328125),
  ('nearest', 1, 0, 0, 0, 'big', 'xorCTF', b'CTF{', 2364, 0.80926513671875),
  ('nearest', 1, 0, 0, 0, 'big', 'xorCTF', b'BM', 9293, 0.80926513671875),
  ('nearest', 1, 0, 0, 0, 'little', 'xorCTF', b'CTF{', 2271, 0.8079833984375),
  ('nearest', 1, 0, 1, 0, 'big', 'xorCTF', b'CTF{', 5028, 0.8094482421875),
  ('nearest',
   1,
   0,
   1,
   0,
   'little',
   'xorCTF',
   b'CTF{',
   10581,
   0.808074951171875),
  ('nearest', 1, 1, 0, 0, 'big', 'xorCTF', b'CTF{', 1353, 0.808074951171875),
  ('nearest', 1, 1, 0, 1, 'big', 'xorCTF', b'BM', 12882, 0.165069580078125),
  ('nearest', 1, 1, 1, 0, 'big', 'xorCTF', b'CTF{', 7218, 0.807830810546875),
  ('nearest', 1, 1, 1, 0, 'little', 'xorCTF', b'CTF{', 11679, 0.809326171875),
  ('nearest', 2, 0, 0, 0, 'big', 'xorCTF', b'CTF{', 3258, 0.808013916015625),
  ('nearest', 2, 0, 0, 0, 'little', 'xorCTF', b'CTF{', 9663, 0.80950927734375),
  ('nearest', 2, 0, 1, 0, 'big', 'xorCTF', b'CTF{', 11868, 0.808074951171875)],
 492)

Python

python
def adj_score(arr):
    # lower transition is smoother
    return float(np.mean(arr[:,1:]!=arr[:,:-1]) + np.mean(arr[1:,:]!=arr[:-1,:]))

cands=[]
outputs={}
for rname,mat in matrices.items():
    for tr in range(8):
        xx,yy=transform_coords(coords,256,tr)
        for mode in ['read_to_raster','raster_to_place']:
            out=np.zeros_like(mat)
            for j in range(4):
                tile=mat[:,j*256:(j+1)*256]
                if mode=='read_to_raster':
                    seq=tile[yy,xx]
                    out[:,j*256:(j+1)*256]=seq.reshape(256,256)
                else:
                    dst=np

[(0.3186440162116899, 'bilinear', 1, 'raster_to_place'),
 (0.3186440162116899, 'bilinear', 7, 'raster_to_place'),
 (0.31866310834267725, 'bilinear', 3, 'raster_to_place'),
 (0.31866310834267725, 'bilinear', 6, 'raster_to_place'),
 (0.3187255396110057, 'bilinear', 2, 'raster_to_place'),
 (0.3187255396110057, 'bilinear', 4, 'raster_to_place'),
 (0.31873699488959806, 'bilinear', 0, 'raster_to_place'),
 (0.31873699488959806, 'bilinear', 5, 'raster_to_place'),
 (0.32803203255275715, 'lanczos', 1, 'raster_to_place'),
 (0.32803203255275715, 'lanczos', 7, 'raster_to_place'),
 (0.32807021681473175, 'lanczos', 3, 'raster_to_place'),
 (0.32807021681473175, 'lanczos', 6, 'raster_to_place'),
 (0.32814034108878154, 'lanczos', 2, 'raster_to_place'),
 (0.32814034108878154, 'lanczos', 4, 'raster_to_place'),
 (0.328144159514979, 'lanczos', 0, 'raster_to_place'),
 (0.328144159514979, 'lanczos', 5, 'raster_to_place'),
 (0.3376875745716175, 'nearest', 1, 'raster_to_place'),
 (0.3376875745716175, 'nearest', 7, 'raster_to_place'),
 (0.3377143035549997, 'nearest', 3, 'raster_to_place'),
 (0.3377143035549997, 'nearest', 6, 'raster_to_place')]

Python

python
# Build 512 Hilbert coords
coords512=np.array([d2xy(512,i) for i in range(512*512)],dtype=np.int16)
def hilbert_place_from_rect(mat,tr=0,rev=False):
    seq=mat.reshape(-1)
    if rev: seq=seq[::-1]
    xx,yy=transform_coords(coords512,512,tr)
    out=np.zeros((512,512),dtype=bool)
    out[yy,xx]=seq
    return out
def hilbert_read_to_square(mat,tr=0,rev=False):
    # interpret mat flattened as 512x512 raster, then read along hilbert into square raster
    sq=mat.reshape(512,512)
    xx,yy=transform_coords(coords512,512,tr)
    seq=sq[yy,xx]
    if rev: seq=seq[::-1]
    return seq.reshape(512,512)

cands=[]
outs={}
for rname,mat in matrices.items():
    for tr in range(8):
        for rev in [False,True]:
            for mode in ['place','read']:
                out=hilbert_place_from_rect(mat,tr,rev) if mode=='place' else hilbert_read_to_square(mat,tr,rev)
                s=adj_score(out)
                cands.append((s,rname,tr,rev,mode))
                outs[(rname,tr,rev,mode)]=out
sorted(cands)[:20]


[(0.318894477739726, 'bilinear', 0, False, 'place'),
 (0.318894477739726, 'bilinear', 0, True, 'place'),
 (0.318894477739726, 'bilinear', 1, False, 'place'),
 (0.318894477739726, 'bilinear', 1, True, 'place'),
 (0.318894477739726, 'bilinear', 2, False, 'place'),
 (0.318894477739726, 'bilinear', 2, True, 'place'),
 (0.318894477739726, 'bilinear', 3, False, 'place'),
 (0.318894477739726, 'bilinear', 3, True, 'place'),
 (0.318894477739726, 'bilinear', 4, False, 'place'),
 (0.318894477739726, 'bilinear', 4, True, 'place'),
 (0.318894477739726, 'bilinear', 5, False, 'place'),
 (0.318894477739726, 'bilinear', 5, True, 'place'),
 (0.318894477739726, 'bilinear', 6, False, 'place'),
 (0.318894477739726, 'bilinear', 6, True, 'place'),
 (0.318894477739726, 'bilinear', 7, False, 'place'),
 (0.318894477739726, 'bilinear', 7, True, 'place'),
 (0.32818615459882583, 'lanczos', 0, False, 'place'),
 (0.32818615459882583, 'lanczos', 0, True, 'place'),
 (0.32818615459882583, 'lanczos', 1, False, 'place'),
 (0.32818615459882583, 'lanczos', 1, True, 'place')]

Python

python
# Use nearest 1024x256, flatten current raster as sequence maybe already Hilbert traversal?
mat=matrices['nearest']
seq=mat.reshape(-1).astype(np.uint8)
# variants of transition (xor consecutive), including prepend 0/first
for name,s in [('raster',seq)]:
    diff=np.empty_like(s); diff[0]=s[0]; diff[1:]=s[1:]^s[:-1]
    print(name,'ones',s.mean(),'diff ones',diff.mean())
    for bitsname,bitsv in [('raw',s),('diff',diff)]:
        for inv in [0,1]:
            for rev in [0,1]:
                bb=(bitsv[::-1] if rev else bitsv)^inv
                for order in ['big','little']:
                    data=np.packbits(bb,bitorder=order).tobytes()
                    pr=sum(32<=c<127 or c in (9,10,13) for c in data)/len(data)
                    # find common
                    hs=[]
                    for m in [b'flag{',b'CTF{',b'PK\x03\x04',b'\x89PNG',b'GIF8',b'%PDF',b'BM',b'base64']:
                        p=data.find(m)
                        if p>=0: hs.append((m,p))
                    if pr>0.5 or hs:
                        print(bitsname,inv,rev,order,pr,hs[:5],data[:30])

Python

python
from PIL import Image
import numpy as np, math, os, itertools, time
img=Image.open('/mnt/data/flag.png').convert('L')
# resample to likely intended 2048x512
arrs={}
for name,method in [('nearest',Image.Resampling.NEAREST),('bilinear',Image.Resampling.BILINEAR),('box',Image.Resampling.BOX)]:
    arrs[name]=np.array(img.resize((2048,512),resample=method))<128
    print(name,arrs[name].mean())

# generate hilbert coords 1024
def d2xy_vec(n):
    # loop Python ~1m okay maybe
    out=np.empty((n*n,2),dtype=np.int16 if n<=32768 else np.int32)
    for d in range(n*n):
        x=y=0; t=d; s=1
        while s<n:
            rx=1&(t//2); ry=1&(t^rx)
            if ry==0:
                if rx==1:
                    x=s-1-x; y=s-1-y
                x,y=y,x
            x += s*rx; y += s*ry
            t//=4; s*=2
        out[d]=(x,y)
    return out
t=time.time()
coords1024=d2xy_vec(1024)
print("coords",coords1024.shape,time.time()-t)

Python

python
def transform_coords_np(coords,n,tr):
    x=coords[:,0].astype(np.int32); y=coords[:,1].astype(np.int32)
    if tr==0: xx,yy=x,y
    elif tr==1: xx,yy=n-1-y,x
    elif tr==2: xx,yy=n-1-x,n-1-y
    elif tr==3: xx,yy=y,n-1-x
    elif tr==4: xx,yy=n-1-x,y
    elif tr==5: xx,yy=x,n-1-y
    elif tr==6: xx,yy=y,x
    elif tr==7: xx,yy=n-1-y,n-1-x
    return xx,yy
def adj_score(arr):
    return float(np.mean(arr[:,1:]!=arr[:,:-1]) + np.mean(arr[1:,:]!=arr[:-1,:]))

cands=[]
outs={}
for rname,mat in arrs.items():
    seq=mat.reshape(-1)
    # two basic directions: seq placed along Hilbert, or square reshape read along Hilbert to raster
    sq=seq.reshape(1024,1024)
    for tr in range(8):
        xx,yy=transform_coords_np(coords1024,1024,tr)
        for rev in [False,True]:
            s=seq[::-1] if rev else seq
            out=np.zeros((1024,1024),dtype=bool)
            out[yy,xx]=s
            sc=adj_score(out)
            cands.append((sc,rname,tr,rev,'place'))
            if len(outs)<10: pass
            # read hilbert from square reshape
            ss=sq[yy,xx]
            if rev: ss=ss[::-1]
            out2=ss.reshape(1024,1024)
            sc2=adj_score(out2)
            cands.append((sc2,rname,tr,rev,'read'))
sorted(cands)[:20]


[(0.2527588129276637, 'bilinear', 0, False, 'place'),
 (0.2527588129276637, 'bilinear', 0, True, 'place'),
 (0.2527588129276637, 'bilinear', 1, False, 'place'),
 (0.2527588129276637, 'bilinear', 1, True, 'place'),
 (0.2527588129276637, 'bilinear', 2, False, 'place'),
 (0.2527588129276637, 'bilinear', 2, True, 'place'),
 (0.2527588129276637, 'bilinear', 3, False, 'place'),
 (0.2527588129276637, 'bilinear', 3, True, 'place'),
 (0.2527588129276637, 'bilinear', 4, False, 'place'),
 (0.2527588129276637, 'bilinear', 4, True, 'place'),
 (0.2527588129276637, 'bilinear', 5, False, 'place'),
 (0.2527588129276637, 'bilinear', 5, True, 'place'),
 (0.2527588129276637, 'bilinear', 6, False, 'place'),
 (0.2527588129276637, 'bilinear', 6, True, 'place'),
 (0.2527588129276637, 'bilinear', 7, False, 'place'),
 (0.2527588129276637, 'bilinear', 7, True, 'place'),
 (0.2563529065860215, 'nearest', 0, False, 'place'),
 (0.2563529065860215, 'nearest', 0, True, 'place'),
 (0.2563529065860215, 'nearest', 1, False, 'place'),
 (0.2563529065860215, 'nearest', 1, True, 'place')]

Python

python
# load b2 logical
from PIL import Image
import numpy as np, math, itertools, os
img=Image.open('/mnt/data/flag.png').convert('RGB')
a=np.array(img)
bw=a.mean(2)<128
b2=bw.reshape(259,2,1045,2).mean((1,3))>0.5

def sgn(x): return -1 if x<0 else (1 if x>0 else 0)
def generate2d(x,y,ax,ay,bx,by):
    w=abs(ax+ay); h=abs(bx+by)
    dax,day=sgn(ax),sgn(ay); dbx,dby=sgn(bx),sgn(by)
    if h==1:
        for _ in range(w):
            yield x,y; x+=dax; y+=day
        return
    if w==1:
        for _ in range(h):
            yield x,y; x+=dbx; y+=dby
        return
    ax2,ay2=ax//2,ay//2; bx2,by2=bx//2,by//2
    w2=abs(ax2+ay2); h2=abs(bx2+by2)
    if 2*w > 3*h:
        if (w2%2) and (w>2):
            ax2+=dax; ay2+=day
        yield from generate2d(x,y,ax2,ay2,bx,by)
        yield from generate2d(x+ax2,y+ay2,ax-ax2,ay-ay2,bx,by)
    else:
        if (h2%2) and (h>2):
            bx2+=dbx; by2+=dby
        yield from generate2d(x,y,bx2,by2,ax2,ay2)
        yield from generate2d(x+bx2,y+by2,ax,ay,bx-bx2,by-by2)
        yield from generate2d(x+(ax-dax)+(bx2-dbx), y+(ay-day)+(by2-dby),
                              -bx2,-by2,-(ax-ax2),-(ay-ay2))
def gilbert2d(W,H):
    if W>=H: yield from generate2d(0,0,W,0,0,H)
    else: yield from generate2d(0,0,0,H,W,0)

coords=np.array(list(gilbert2d(1045,259)),dtype=np.int32)
coords.shape, coords.min(0), coords.max(0)


((270655, 2), array([0, 0], dtype=int32), array([1044,  258], dtype=int32))

Python

python
def adj_score(arr):
    return float(np.mean(arr[:,1:]!=arr[:,:-1]) + np.mean(arr[1:,:]!=arr[:-1,:]))
ys,xs=coords[:,1],coords[:,0]
# read along curve -> raster
A=b2[ys,xs].reshape(259,1045)
# raster -> place along curve
B=np.zeros_like(b2); B[ys,xs]=b2.reshape(-1)
print("orig",adj_score(b2),"A",adj_score(A),"B",adj_score(B))
Image.fromarray((~A*255).astype(np.uint8)).save('/mnt/data/gilbert_logical_A.png')
Image.fromarray((~B*255).astype(np.uint8)).save('/mnt/data/gilbert_logical_B.png')

Python

python
# connected components on b2 using scipy ndimage
import scipy.ndimage as ndi, numpy as np
lab,n=ndi.label(b2)
sizes=np.bincount(lab.ravel())[1:]
np.percentile(sizes,[50,75,90,95,99,99.5,99.9]), sizes.max(), n


(array([  4.   ,  19.   ,  51.   ,  85.   , 170.96 , 205.72 , 279.176]),
 np.int64(306),
 2353)

Python

python
# cumulative xor along generalized Hilbert on logical b2
cseq=b2[ys,xs].astype(np.uint8)
for init in [0,1]:
    # if c[i]=p[i]^p[i-1], p[-1]=init
    p=np.empty_like(cseq)
    prev=init
    for i,c in enumerate(cseq):
        prev ^= int(c)
        p[i]=prev
    out=np.zeros_like(b2); out[ys,xs]=p.astype(bool)
    print(init,out.mean(),adj_score(out))
    Image.fromarray((~out*255).astype(np.uint8)).save(f'/mnt/data/cumxor_gilbert_{init}.png')

Python

python
# cumulative xor raster
c=b2.reshape(-1).astype(np.uint8)
p=np.bitwise_xor.accumulate(c)
out=p.reshape(b2.shape).astype(bool)
print(out.mean(),adj_score(out))
Image.fromarray((~out*255).astype(np.uint8)).save('/mnt/data/cumxor_raster.png')

Python

python
# Test differential decode for intended 2048x512 -> square 1024
def cumxor_place(rect_bool, coords, N, init=0, reverse=False):
    c=rect_bool.reshape(-1).astype(np.uint8)
    if reverse: c=c[::-1]
    p=np.bitwise_xor.accumulate(c)
    if init: p ^= 1
    out=np.zeros((N,N),dtype=bool)
    out[coords[:,1],coords[:,0]]=p.astype(bool)
    return out

for rname in ['nearest','bilinear','box']:
    rect=arrs[rname]
    for rev in [False,True]:
        out=cumxor_place(rect,coords1024,1024,0,rev)
        print(rname,rev,out.mean(),adj_score(out))
        if rname=='nearest':
            Image.fromarray((~out*255).astype(np.uint8)).save(f'/mnt/data/cumxor_place

思考

Analyzed flag image grid and optimized jigsaw tile reconstruction

Worked for 25m 35s

回答

我已经把关键结构定位出来了，但目前还没可靠还原出最终 flag，所以不想编一个假的给你。

目前能确定的解题链是：

David Hilbert → Hilbert Curve（希尔伯特曲线）。它的特点正好对应“贯穿每个像素、每一步都是关键”：按 Hilbert 路径遍历/重排像素。
图片存在非常明显的 2×2 像素重复。降采样后真正的数据尺寸是 1045 × 259。
这个分辨率非常刻意：
- 1045 = 1024 + 21
- 259 = 256 + 3
密码给的是 CTF，恰好：
- CTF 有 3 个字符
- ASCII 每字符取 7 bit，则 3 × 7 = 21 bit
所以分辨率里多出来的 21 列 + 3 行 几乎可以确定是在编码/控制密码。
更关键的是，图片的第 64、129、194 行出现明显断点。也就是纵向实际上是：

64 像素 + 1 行 + 64 像素 + 1 行 + 64 像素 + 1 行 + 64 像素

去掉那 3 行以后正好得到 256 行。
横向同理，真正的有效数据应该是 1024 列，原图多出的 21 列 与 CTF 的 21 个 7-bit ASCII 位高度吻合。因此核心数据是：

1024 × 256 = 262144 = 512²

也就是说，去掉由密码控制的额外行/列以后，可以把数据重新组织成一个标准的 512 × 512 方阵——这正是 9 阶 Hilbert 曲线（2^9 = 512）最自然的输入。

所以我认为完整算法基本已经锁定为：

CTF → 7-bit ASCII（二进制而不是十六进制） → 利用密码确定/移除 21 列和 3 行 → 得到 1024×256 → reshape 为 512×512 → 按 9 阶 Hilbert Curve 做逆置换 → flag

其中“我不喜欢十六进制”也正好是在提示：** 别把密码按 hex 看，要看 binary**。

我现在缺的最后一步是确定 21 个密码控制列的精确删除/插入规则以及 Hilbert 的方向（扫描还是逆扫描）。因此目前还不能负责任地给出最终 flag{...}。如果这是原题文件而不是聊天软件重新压缩/转换后的预览图，发我原始附件文件会更稳——当前上传内容实际上已经被转换成 JPEG，原始像素信息可能受过有损压缩。

问题

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

思考

回答

分享这个问答