mirror of
https://github.com/allaunthefox/Research-Stack.git
synced 2026-07-31 03:05:21 +00:00
93 lines
3.3 KiB
Python
93 lines
3.3 KiB
Python
# ==============================================================================
|
|
# COPYRIGHT NO ONE EVERYWHERE LLC (WYOMING HOLDING COMPANY)
|
|
# PROJECT: SOVEREIGN STACK
|
|
# This artifact is entirely proprietary and cryptographically proven.
|
|
# Open-Source usage requires explicit permission from Brandon Scott Schneider.
|
|
# ==============================================================================
|
|
import random
|
|
import zlib
|
|
import math
|
|
|
|
# Invisible Unicode widths for encoding bits
|
|
INVISIBLE = ['\u200b', '\u200c', '\u200d'] # Zero-width space, non-joiner, joiner
|
|
BIT_TO_UNI = {'00': INVISIBLE[0], '01': INVISIBLE[1], '10': INVISIBLE[2], '11': INVISIBLE[0]+INVISIBLE[1]}
|
|
UNI_TO_BIT = {INVISIBLE[0]: '00', INVISIBLE[1]: '01', INVISIBLE[2]: '10', INVISIBLE[0]+INVISIBLE[1]: '11'}
|
|
|
|
# Golden ratio-based CRC polynomial (use fractional part as seed)
|
|
GOLDEN_POLY = int((math.modf((1.61803398875 % 1) * 1e8)[0])) | 0x1021 # Just for demo
|
|
|
|
SEGMENT_SIZE = 16 # bytes per UDP segment
|
|
|
|
|
|
def encode_message(msg):
|
|
# Convert to bits, then to invisible widths
|
|
bits = ''.join(f'{b:08b}' for b in msg.encode('utf-8'))
|
|
# Pad to multiple of 2
|
|
if len(bits) % 2:
|
|
bits += '0'
|
|
encoded = ''.join(BIT_TO_UNI[bits[i:i+2]] for i in range(0, len(bits), 2))
|
|
return encoded
|
|
|
|
def decode_message(encoded):
|
|
# Map invisible widths back to bits
|
|
bits = ''
|
|
i = 0
|
|
while i < len(encoded):
|
|
for k, v in UNI_TO_BIT.items():
|
|
if encoded[i:i+len(k)] == k:
|
|
bits += v
|
|
i += len(k)
|
|
break
|
|
else:
|
|
i += 1 # skip unknown
|
|
# Convert bits to bytes
|
|
bytelist = [int(bits[i:i+8], 2) for i in range(0, len(bits), 8)]
|
|
return bytes(bytelist).decode('utf-8', errors='ignore')
|
|
|
|
def golden_crc(data):
|
|
# Use zlib.crc32 with golden poly as seed for demo
|
|
return zlib.crc32(data.encode('utf-8'), GOLDEN_POLY)
|
|
|
|
def segment_message(encoded):
|
|
# Split into segments, append CRC
|
|
segments = []
|
|
for i in range(0, len(encoded), SEGMENT_SIZE):
|
|
chunk = encoded[i:i+SEGMENT_SIZE]
|
|
crc = golden_crc(chunk)
|
|
segments.append((chunk, crc))
|
|
return segments
|
|
|
|
def introduce_errors(segments, bit_errors=2):
|
|
# Randomly flip up to bit_errors bits in each segment
|
|
corrupted = []
|
|
for chunk, crc in segments:
|
|
chunk_bytes = bytearray(chunk.encode('utf-8'))
|
|
for _ in range(random.randint(0, bit_errors)):
|
|
if not chunk_bytes:
|
|
continue
|
|
idx = random.randint(0, len(chunk_bytes)-1)
|
|
bit = 1 << random.randint(0, 7)
|
|
chunk_bytes[idx] ^= bit
|
|
corrupted.append((chunk_bytes.decode('utf-8', errors='ignore'), crc))
|
|
return corrupted
|
|
|
|
def phonon_graph_reassemble(segments):
|
|
# Try all segments, accept those with valid CRC
|
|
reassembled = ''
|
|
for chunk, crc in segments:
|
|
if golden_crc(chunk) == crc:
|
|
reassembled += chunk
|
|
return reassembled
|
|
|
|
if __name__ == '__main__':
|
|
msg = 'Hello, SCADA! This is a covert MSM tape.'
|
|
print('Original:', msg)
|
|
encoded = encode_message(msg)
|
|
segments = segment_message(encoded)
|
|
# Simulate UDP: shuffle and introduce errors
|
|
random.shuffle(segments)
|
|
corrupted = introduce_errors(segments)
|
|
# Reassemble
|
|
tape = phonon_graph_reassemble(corrupted)
|
|
decoded = decode_message(tape)
|
|
print('Decoded:', decoded)
|