okay then help me with this.here flags are like KH...

python
data = bytes.fromhex("34 37 3e 2c 3c 2b 39 04 3b 3d 4c 36 37 1e 37 1d 2d 4e 2d 2d 18 3b 1a 29 48 4f 18 39 09 2f 1a 1c 33 4e 32 4e 1d 38 39 2a")
len(data), data[:10]


(40, b'47>,<+9\x04;=')

python
dec = bytes([b ^ 0x7f for b in data])
dec, len(dec), dec.decode('latin1')


(b'KHASCTF{DB3IHaHbR1RRgDeV70gFvPecL1M1bGFU',
 40,
 'KHASCTF{DB3IHaHbR1RRgDeV70gFvPecL1M1bGFU')

python
data41 = bytes.fromhex("34 37 3e 2c 3c 2b 39 04 3b 3d 4c 36 37 1e 37 1d 2d 4e 2d 2d 18 3b 1a 29 48 4f 18 39 09 2f 1a 1c 33 4e 32 4e 1d 38 39 2a 02")
len(data41), bytes([b^0x7f for b in data41]).decode('latin1')


(41, 'KHASCTF{DB3IHaHbR1RRgDeV70gFvPecL1M1bGFU}')

python
wav_path="/mnt/data/alice.wav"
with wave.open(wav_path,'rb') as wf:
    nchan=wf.getnchannels()
    sampwidth=wf.getsampwidth()
    fr=wf.getframerate()
    nframes=wf.getnframes()
    comptype=wf.getcomptype()
    compname=wf.getcompname()
    print(nchan,sampwidth,fr,nframes,comptype,compname)
    frames=wf.readframes(nframes)
len(frames), frames[:10]


(477700, b'\x80\x80\x80\x81\x80\x7f~||}')

python
data=np.frombuffer(frames,dtype=np.uint8)
data.shape, data[:20], data.min(), data.max(), data.mean()


((477700,),
 array([128, 128, 128, 129, 128, 127, 126, 124, 124, 125, 127, 130, 132,
        133, 132, 130, 126, 122, 120, 120], dtype=uint8),
 7,
 247,
 127.90085827925476)

python
def bits_to_bytes(bits):
    # bits is iterable of 0/1 length multiple of 8; msb first
    bits=np.array(bits,dtype=np.uint8)
    n=len(bits)//8
    bits=bits[:n*8].reshape(n,8)
    vals=(bits*np.array([128,64,32,16,8,4,2,1],dtype=np.uint8)).sum(axis=1)
    return bytes(vals.tolist())

lsb1 = data & 1
b1 = bits_to_bytes(lsb1)
# Search for readable substring
print(len(b1))
# find flag-like
for pat in [b"KHASCTF", b"CTF{", b"{", b"flag", b"FLAG"]:
    idx=b1.find(pat)
    print(pat, idx)
# show first 200 bytes printable
print(b1[:200])

python
def bits_to_bytes_lsbfirst(bits):
    bits=np.array(bits,dtype=np.uint8)
    n=len(bits)//8
    bits=bits[:n*8].reshape(n,8)
    weights=np.array([1,2,4,8,16,32,64,128],dtype=np.uint8)
    vals=(bits*weights).sum(axis=1)
    return bytes(vals.tolist())
b1r=bits_to_bytes_lsbfirst(lsb1)
for pat in [b"KHASCTF", b"CTF{", b"{", b"flag", b"FLAG", b"-----BEGIN"]:
    print(pat, b1r.find(pat))
print(b1r[:200])

python
def lsb_bits(data, k, within='lsb_to_msb'):
    mask=(1<<k)-1
    vals=data & mask
    bits=np.empty(len(vals)*k, dtype=np.uint8)
    idx=0
    for v in vals:
        if within=='lsb_to_msb':
            for i in range(k):
                bits[idx]= (v>>i)&1
                idx+=1
        else: # msb_to_lsb within k
            for i in range(k-1,-1,-1):
                bits[idx]= (v>>i)&1
                idx+=1
    return bits

def bitstream_to_bytes(bits, byte='msb_first'):
    if byte=='msb_first':
        return bits_to_bytes(bits)
    else:
        return bits_to_bytes_lsbfirst(bits)

def test_k(k):
    out=[]
    for within in ['lsb_to_msb','msb_to_lsb']:
        bits=lsb_bits(data,k,within=within)
        for byteorder in ['msb_first','lsb_first']:
            b=bitstream_to_bytes(bits, byte='msb_first' if byteorder=='msb_first' else 'lsb_first')
            # find interesting patterns
            idx=b.find(b'KHASCTF')
            idx2=b.find(b'-----BEGIN')
            idx3=b.find(b'CTF{')
            score=sum(32<=c<127 for c in b[:200]) # printable in first 200
            out.append((within,byteorder,idx,idx3,idx2,score,b[:60]))
    return out

for k in [1,2,3,4]:
    res=test_k(k)
    print("k",k)
    for r in res:
        within,byteorder,idx,idx3,idx2,score,preview=r
        if idx!=-1 or idx3!=-1 or idx2!=-1 or score>120:
            print(r)

python
import matplotlib.pyplot as plt, numpy as np

python
# create spectrogram
from scipy.signal import spectrogram
f, t, Sxx = spectrogram((data.astype(np.float32)-128)/128.0, fs=fr, nperseg=1024, noverlap=768)
Sxx_db=10*np.log10(Sxx+1e-12)
Sxx_db.shape, f.max(), t.max()


((513, 1863), 5525.0, 43.18407239819005)

python
import matplotlib
matplotlib.use("Agg")
plt.figure(figsize=(12,6))
plt.imshow(Sxx_db, aspect='auto', origin='lower', extent=[t.min(), t.max(), f.min(), f.max()])
plt.ylim(0,5000)
plt.xlabel("Time (s)")
plt.ylabel("Frequency (Hz)")
plt.title("Spectrogram")
out_path="/mnt/data/alice_spectrogram.png"
plt.savefig(out_path, dpi=200, bbox_inches='tight')
plt.close()
out_path


'/mnt/data/alice_spectrogram.png'

python
import matplotlib
matplotlib.use("Agg")
plt.figure(figsize=(12,6))
plt.imshow(Sxx_db, aspect='auto', origin='lower', extent=[t.min(), t.max(), f.min(), f.max()])
plt.ylim(0,5000)
plt.xlabel("Time (s)")
plt.ylabel("Frequency (Hz)")
plt.title("Spectrogram")
out_path="/mnt/data/alice_spectrogram.png"
plt.savefig(out_path, dpi=200, bbox_inches='tight')
plt.close()
out_path


'/mnt/data/alice_spectrogram.png'



<<ImageDisplayed>>

python
import numpy as np
from scipy.signal import butter, filtfilt, hilbert

x = (data.astype(np.float32)-128.0)/128.0
# bandpass 900-1100 Hz
low=900/(fr/2)
high=1100/(fr/2)
b,a=butter(4,[low,high],btype='band')
xf=filtfilt(b,a,x)
env=np.abs(hilbert(xf))
# smooth env
win=int(fr*0.02)  # 20ms window
if win<1: win=1
kernel=np.ones(win)/win
env_s=np.convolve(env,kernel,mode='same')
env_s[:10].mean(), env_s.max()


(0.10370493306539941, 0.9370639146332858)

python
np.percentile(env_s,[5,10,25,50,75,90,95,99])


array([2.58835328e-08, 4.93030725e-08, 1.62752073e-07, 5.00835170e-06,
       4.48823611e-04, 9.00047951e-01, 9.36939567e-01, 9.36948048e-01])

python
thr=0.3
on = env_s > thr
on.mean(), on[:100].sum()


(0.1775675109901612, 11)

python
# get run lengths and state changes
diff=np.diff(on.astype(np.int8))
starts=np.where(diff==1)[0]+1
ends=np.where(diff==-1)[0]+1
if on[0]:
    starts=np.r_[0,starts]
if on[-1]:
    ends=np.r_[ends,len(on)]
len(starts), len(ends), starts[:5], ends[:5]


(64,
 64,
 array([   89,  3465,  5153,  8529, 22033]),
 array([ 2443,  4131,  7507, 10883, 24387]))

python
dur = (ends-starts)/fr
gap = (starts[1:]-ends[:-1])/fr
np.percentile(dur,[0,10,25,50,75,90,100]), np.percentile(gap,[0,10,25,50,75,90,100])


(array([0.06027149, 0.06027149, 0.06027149, 0.06027149, 0.21303167,
        0.21303167, 0.21303167]),
 array([0.09248869, 0.09248869, 0.09248869, 0.09248869, 1.00904977,
        1.00904977, 2.91855204]))

python
np.unique(np.round(dur,3)), np.unique(np.round(gap,3))[:10], len(np.unique(np.round(gap,3)))


(array([0.06 , 0.213]), array([0.092, 1.009, 2.919]), 3)

python
codes=[]
current=""
for i,sym in enumerate(symbols):
    current+=sym
    if i < len(gaps):
        g=gaps[i]
        if g<0.3:
            continue
        elif g<2.0:
            codes.append(current); current=""
        else:
            codes.append(current); codes.append(' '); current=""
if current: codes.append(current)
codes[:20], len(codes)


(['-.--',
  '---',
  '..-',
  '.-',
  '.--.',
  '---',
  '...',
  '.-.',
  '.',
  ' ',
  '..',
  '-.',
  ' ',
  '-',
  '....',
  '.',
  ' ',
  '.-.',
  '.-',
  '-...'],
 28)

python
import struct, pathlib
b=pathlib.Path(wav_path).read_bytes()
# parse RIFF chunks
pos=0
riff=b[pos:pos+4]; pos+=4
size=struct.unpack('<I',b[pos:pos+4])[0]; pos+=4
wave=b[pos:pos+4]; pos+=4
chunks=[]
while pos+8<=len(b):
    cid=b[pos:pos+4]; pos+=4
    csize=struct.unpack('<I',b[pos:pos+4])[0]; pos+=4
    cdata=b[pos:pos+csize]; pos+=csize
    if csize%2==1: pos+=1
    chunks.append((cid.decode('ascii','ignore'),csize,pos))
    if cid==b'data':
        data_end=pos
        break
chunks, data_end, len(b)


([('fmt ', 16, 36), ('data', 477704, 477748)], 477748, 477748)