Adaptive Neural Hashing Engine · v1.0.0 Released

Adaptive Neural
Chaotic Hashing

A secure, multi-stage experimental hashing framework. Combines bit-level feature extraction, neural parameter generation, and chaotic orbit state mixing.

pip install anch-hashInteractive Playground
Live Engine SimulatorInteractive Bifurcation Wave
OUTPUT_BITS = 256
import anch
digest = anch.hash("hello world")
ANCH Digest (256-bit Hex)SHANNON ENTROPY: ~4.2 bits/byte
································································
CHAOTIC ATTRACTOR ENGINESEED: 1715957781
LOGISTIC REGIME x[n+1] = r*x*(1-x)
Perturbation Seeds:
256
Bit Output Digest
0
Runtime Dependencies
5
Pipeline Stages
v1.0.0
PyPI Package Release
Architecture

The ANCH Pipeline

Seven modular stages transform raw input into a secure, reproducible 256-bit digest. Hover on any node to dissect the engine.

Input Data
Feature Extractor
Neural Parameter Gen
Chaotic Engine
Dynamic Permutation
Compression Engine
ANCH Digest (256-bit)
Input Data
String, bytes, or file path
# Accept strings, raw bytes, or file paths data = b"hello world"
Feature Extractor
Bit count · Entropy · Byte frequency · Bigrams
# feature.py extracts 134-float feature vector feats = extract_features(data) vec = build_feature_vector(feats)
Neural Parameter Gen
Seed · r-value · Rotations · Compression key
# neural.py — two dense layers, LCG weights params = generate_parameters(vec) # → seed, r_value, rotations, compression_key
Chaotic Engine
Logistic map → chaos byte stream
# chaos.py — logistic map x[n+1] = r·x·(1-x) chaos_b = generate_chaos_state(params, 128)
Dynamic Permutation
Bit shuffle · Word rotation · Diffusion
# permutation.py — Fisher-Yates bit shuffle state = apply_permutation(state, params, chaos_b)
Compression Engine
Dynamic S-Box · Feistel rounds · State folding
# compression.py — Dynamic S-Box + 4–16 Feistel rounds state = compress(state, params, chaos_b)
ANCH Digest (256-bit)
64-character hex · Constant-time verify
# Fold 64→32 bytes, finalize, hex-encode digest = finalize_digest(state, data) # → "7f91ac3b2d058e4f..." (64 chars)
Key Pillars

Engineered for Chaos & Adaptability

ANCH decouples fixed structures by dynamically altering hash schedules based on the features of the data itself.

neural.py

Neural Parameter Generation

A lightweight, dependency-free pseudo-neural transform derives every hash parameter from the input's feature vector — seed, chaos r-value, rotation schedule, and compression key.

Two dense linear layers with LCG-derived weights map a 134-float feature vector to 16 control control values. No external ML framework required.

chaos.py

Chaos Theory Engine

A multi-attractor chaos generator leveraging the chaotic regimes of Logistic, Tent, and Hénon maps to produce a pseudo-random byte stream extremely sensitive to initial states.

Adaptive selector triggers Logistic Map, Tent Map, or Hénon Map dynamically based on neural seed (seed % 3). Integrated periodic boundary wrapping.

permutation.py

Dynamic Permutation

Chaos-seeded Fisher-Yates shuffle reorders every bit in the state, while word-level rotation adds diffusion. A single input-bit change cascades across the entire 256-bit output.

Combines bit-level and word-level permutation in a single round for maximum diffusion with acceptable performance.

compression.py

Multi-round Compression

4–16 Feistel-style compression rounds (count determined by neural parameters) mix the 64-byte state. Each round features a dynamically generated S-Box mapping.

Combines Fisher-Yates dynamic S-Box generation using chaos bytes, Feistel mixing, butterfly cross-mixing, and a final fold to collapse 64→32 bytes.

feature.py

Feature Extraction

Extracts a rich 134-float feature vector from raw input: length, Hamming weight, Shannon entropy, byte-frequency distribution, mean, variance, and bigram hashes.

Optional NumPy acceleration provides 5x faster vectorized operations on large payloads, while preserving standard library pure-Python fallback.

benchmark.py

Built-in Benchmark Suite

BenchmarkSuite runs avalanche, entropy, collision, runtime, and SHA-256 comparison benchmarks with configurable sample counts and pretty console reporting.

Single-bit flip avalanche test, Shannon entropy distribution across random inputs, Fisher-Yates collision detection, per-size throughput.

core.py & CLI

Full CLI & HMAC API

Full CLI access to hash, verify, avalanche, entropy, and benchmark tools, paired with HMAC-ANCH support for keyed message authentication.

Added hmac_anch(key, message) and hmac_anch_verify(key, message, mac) with constant-time verification for secure integrity checks.

Pure Python 3.12

Zero Runtime Dependencies

The entire ANCH core is implemented in pure Python 3.12 stdlib — no NumPy, no cryptography library, no external packages. Just install and go.

Optional: rich for colored benchmark output. Web interface runs benchmark over connected local REST API.

Online Playground

Try ANCH Right Now

Interactive cryptography testing. Tune parameters or connect the backend to witness the real-time neural network parameter generator.

Python API server: Offline (Simulator Mode Active)
Tuning:
Chaos r parameter3.850
Feistel Rounds8 rounds
ANCH Simulated Hash Digest
29af9795cd8f7aebaf9e33801d57d7fac065245eab6e2cf1e4d9c44b11129b86
SHA-256 (Reference Mock)
332bfb44ee829316b9828363d20a98bc1ea37a183ec77de9485edc96f57aa491
Provided for structural size comparison
Digest Output Size
256 bits (32 bytes)
Shannon Entropy
5.1875 bits/byte
Input Size
11 bytes
Benchmarks

Performance Analysis

Transparency about mathematical trade-offs. ANCH trades raw microsecond speed for cryptographic adaptability.

● Benchmark API offline (Showing standard baseline report)
~48.7%
ideal target: ~50%
Avalanche Cascade
Mean bit-flip ratio after mutating a single input bit across test samples.
~7.954
ideal limit: 8.00
Digest Entropy
Shannon byte-level entropy scale. High entropy ensures resistance to correlation attacks.
0.00%
target ceiling: 0%
Collision Rate
Observed rate of duplicate hashes produced from different inputs.
~26.2 KB/s
pure Python stdlib
Throughput (64B)
Hashing speed throughput. Optional NumPy acceleration is active if packages are installed.

Speed Cost vs SHA-256

Average of 10 runs per input size on Python 3.12

Experimental
Input SizeANCH (ms)SHA-256 (ms)Overhead
16 B2.1 ms0.004 msFeasible cost
64 B2.4 ms0.005 msFeasible cost
256 B3.1 ms0.007 msFeasible cost
1 KB5.8 ms0.012 msFeasible cost
4 KB18.2 ms0.035 msModerate cost
16 KB68.5 ms0.12 msModerate cost
64 KB274 ms0.46 msHeavy overhead

The Mathematical Overhead

SHA-256 (Optimized C Block)
Fast static rounds, fixed permutation pathways
ANCH (Pseudo-Neural generation)
Dynamic parameter calculation per message
ANCH (Chaotic simulation rounds)
Iterative chaos sequence execution
Why is it slower? ANCH is designed to resist ASIC hashing hardware acceleration by dynamically constructing unique encryption schedules per input. This intentional complexity makes it excellent for dataset fingerprinting or payloads verification, but not suited for proof-of-work mining.
Developer Guide

Install & Integrate

Zero dependencies. Zero system bloat. Fully compatible with Python 3.12 and newer environments.

terminal_session
# Install the stable release directly from PyPI
$ pip install anch-hash

Engineered for Modern Enterprise Scenarios

File Integrity
Secure hash files before/after network transfer to verify byte-exact transmission and block MITM tampering.
Data Fingerprinting
Establish low-collision compact identifiers for unstructured JSON, APIs, or database rows.
Research & Academia
A playground for analyzing chaos theory bifurcations, neural weight mapping, and diffusion statistics.
API Verification
Fast, dependency-free payload verification middleware for microservices and webhook receivers.
Dataset Audits
Detect row-level perturbations, duplicates, or column modifications in large ML preprocessing pools.
Benchmarking
Direct compare mathematical features and performance limits of adaptive hashes against standard blocks.
Development Map

Where We're Headed

ANCH is evolving from a mathematical concept into an enterprise-ready adaptive cryptographic engine.

v0.1Foundation
  • Core Hash Engine (feature → neural → chaos → permutation → compression)
  • Pure Python 3.12, zero runtime dependencies
  • Public API: hash, verify, hash_file, avalanche, entropy, collision_test
  • Full CLI interface (anch hash, anch benchmark, …)
  • Comprehensive test suite (pytest)
  • pyproject.toml setup, pip-installable
  • Interactive showcase website
v0.2Optimization
  • Benchmark Suite interactive dashboard UI
  • REST API (FastAPI + Uvicorn) — POST /hash, /verify, /benchmark
  • Online Playground (server-side real ANCH hashing)
  • Performance: NumPy-accelerated feature extraction
  • MkDocs documentation site (Material theme)
  • GitHub Actions automated CI/CD pipeline
v0.3Cryptography
  • Multi-Chaotic Engine: Tent Map + Hénon Map
  • Adaptive Attractor selection (seed % 3)
  • Streaming hashing for large files / data pools
  • Dynamic S-Box key-schedule generation
  • HMAC-ANCH authentication mode support
  • Language bindings: JS/WASM or Rust ports
v1.0Final Scope
  • Full public framework production release
  • Complete developer SDK stable release