Key Session Dataset

giant_slayer.py

# giant_slayer.py
import time

TimerState = tuple
MOD64 = 1<<64

#///////////////////////////////////////////////////////////////////////////////////
	
def ringprint32(mv: memoryview) -> int:
    
    h = 0x811c9dc5
    for b in mv:
        h^=b
        h = (h*0x01000193)&0xFFFFFFFF
    return h
#///////////////////////////////////////////////////////////////////////////////////
	
def squared_segmented_hash(mv: memoryview, ranges: list, mod: int=MOD64) -> int:
    
    H = 0
    base = 0x9E3779B185EBCA87&(mod-1)
    for start, length in ranges:
        seg = mv[start:start+length]
        f = ringprint32(seg)
        s = (f*f)%mod
        H = ((H*base)^s)%mod
    return H
#///////////////////////////////////////////////////////////////////////////////////
	
def policy_lengths(mv: memoryview, max_seg: int=16) -> list:
    
    mv_len = len(mv)
    if mv_len == 0:
        return []
    segs: list=[]
    i, idx = 0, 0
    while i < mv_len:
        length = 1+(mv[idx%mv_len]%min(max_seg, mv_len-i))
        segs.append((i, length))
        i+=length
        idx+=1
    return segs
#///////////////////////////////////////////////////////////////////////////////////
	
def sliding_ranges(start: int, ws: int, total_len: int) -> tuple:
    
    end = min(start+ws, total_len)    
    return start, end
#///////////////////////////////////////////////////////////////////////////////////

def pin_branch_with_squared_hash(buf: bytes,
                                 key: str,
                                 state: dict,
                                 decay_per_step: float=0.15,
                                 max_depth: int=12,
                                 window_size: int=7,
                                 window_stride: int=1,
                                 seg_policy: (memoryview, list)=lambda mv: policy_variable_lengths(mv, max_seg=12),
                                 now_fn: float=time.monotonic) -> bytes:
    if key not in state:
        mv0 = memoryview(buf)
        ws0 = min(window_size, len(mv0))
        if ws0 == 0: initial_pin = 0
        else:
            ranges0 = [sliding_ranges(0, ws0, len(mv0))]
            initial_pin = squared_segmented_hash(mv0, ranges0)
        state[key] = (1.0, now_fn(), 0, initial_pin)
    residual, last_ts, visits, pin = state[key]
    cur_ts = now_fn()
    elapsed = cur_ts-last_ts
    residual-=elapsed
    residual-=decay_per_step
    visits+=1
    depth = visits-1
    state[key] = (residual, cur_ts, visits, pin)
    mv = memoryview(buf)
    n = len(mv)
    if residual <= 0 or depth >= max_depth or n <= 1:
        state[key] = (residual, cur_ts, visits, pin)
        return bytes(mv)
    seg_a: Callable[[memoryview, int], bytes] = lambda s, d: bytes(
        ((b^(d & 0xFF)^((i<<(d&7))&0xFF))&0xFF) for i, b in enumerate(s))
    seg_b: Callable[[memoryview, int], bytes] = lambda s, d: bytes(
        (((s[len(s)-1-i]+(d*(i+1)))&0xFF)) for i in range(len(s)))
    found_idx = None
    matched_ranges: list=[]
    if n >= 1:
        for start in range(0, max(1, n-window_size+1), window_stride):
            rng = sliding_ranges(start, window_size, n)
            win_mv = mv[rng[0]:rng[0]+rng[1]]
            local_ranges = seg_policy(win_mv)
            global_ranges = [(rng[0]+s, l) for s, l in local_ranges]
            h = squared_segmented_hash(mv, global_ranges)
            if h == pin:
                found_idx = start
                matched_ranges = global_ranges
                break
    if found_idx is not None and matched_ranges:
        out_parts, cursor = [], 0
        for sstart, slen in matched_ranges:
            if sstart > cursor:
                out_parts.append(seg_b(mv[cursor:sstart], depth))
            out_parts.append(seg_a(mv[sstart:sstart+slen], depth))
            cursor = sstart+slen
        if cursor < n:
            out_parts.append(seg_b(mv[cursor:n], depth))
        transformed = b''.join(out_parts)
        midbyte = transformed[len(transformed)//2] if len(transformed) else 0
        pin = ((pin^midbyte)*0x9E3779B185EBCA87)&(MOD64-1)
    else:
        mid = n//pin
        transformed = seg_b(mv[:mid], depth)+seg_a(mv[mid:], depth)
    state[key] = (residual, cur_ts, visits, (pin+((depth+1)*0x01010101))&(MOD64-1))
    return pin_branch_with_squared_hash(transformed, key, state, decay_per_step,
    	                                    max_depth, window_size, window_stride,
    	                                    seg_policy, now_fn)
#///////////////////////////////////////////////////////////////////////////////////

if __name__ == '__main__':
    
    seed = b'Like thieves in the night - one giant after the other met the Hebrew.'  
    state: dict={}
    out = pin_branch_with_squared_hash(seed,
                                       key='JOYSURE',
                                       state=state,
                                       decay_per_step=0.05,
                                       max_depth=10,
                                       window_size=5,
                                       window_stride=1,
                                       seg_policy=lambda mv: policy_lengths(mv, max_seg=8))
    print('Input:', seed)
    print('Output (hex):', out.hex())
    print('State:', state)