This is a Quantum-Secured Identity Layer for the Autonomous World, utilizing Quantum Hashing Mechanism and an Agent Identity Badge Rotation System to do so.
MARK-B.L.U. (Base Level Unification) represents a quantum-enhanced digital identity and secure communication framework built to safeguard autonomous and AI-driven infrastructures in high-assurance, and zero-trust environments.
At its fundamental core, MARK-B.L.U. fuses quantum randomness with classical cryptographic robustness to generate non-reproducible, evolving, time-variant digital identities for distributed intelligent agents. Each agent periodically receives a quantum-derived badge, which serves as a cryptographic identity token, rotating automatically to ensure forward secrecy and unlinkability.
The release of this technical repository marks the first formal public deployment of the MARK-B.L.U. backend, that is the foundation of a subsequent future-ready, enterprise-grade Quantum Identity Infrastructure (QII) designed to evolve with the post-quantum cybersecurity landscape, for securing the ever permeating and prevalent AI and Autonomous Infrastructure.
The architecture, in concept, provides a dynamic, verifiable identity system for autonomous AI agents that works in essentially two parts, with its hashing core and the additive badge rotation dynamic. Through both, it essentially:
- Generates cryptographic identities from the quantum measurements rather than mere algorithmic pseudorandomness;
- Rotates each identity badge periodically, preventing long-term tracking or replay attacks;
- By extension, enables authenticated, encrypted communication between agents using AES-256 keys derived from quantum badges;
- And supports centralized verification and auditing, allowing administrators to confirm badge authenticity and communication legitimacy.
The architecture thus acts as the trust backbone of an intelligent agent ecosystem, ensuring every autonomous process, drone, or “AI node” can be uniquely identified, verified, and secured without dependence on centralized trust or static credentials.
The MARK-B.L.U. 1.0 is intentionally kept to be modular, reproducible, and scalable, comprising three distinct yet synergistic layers:
- Quantum Layer — Generates physical randomness through 16-qubit parameterized circuits, ensuring information-theoretic unpredictability;
- Classical Layer — Converts quantum outputs into stable cryptographic badges and AES keys for efficient, interoperable security;
- Administrative Layer — Manages verification, auditing, and badge provenance, enabling retrospective proof of authenticity. This hybrid architecture ensures quantum-grade unpredictability with classical-grade deployability, making it both scientifically sound and eventually, industry practical.
The above does it for the conceptual basis of what MARK-B.L.U. is. As for how it works, the next section shall be an exclusive dive into that explicitly.
This architecture is a quantum-genesis alternative for the current identity methods, which is built for eventual deployment in actual high-octane, uncertain, and zero-trust environment applications. The entire architecture has two broad components; first being the quantum hashing mechanism responsible for generating quantum-derived cryptographic identities, and the other being the agent badge generation and rotation system built upon that quantum core.
| 
|
The 1.0 project at large has been structured for clarity, modularity, and extensibility. The reason for the election of the said approach was quite straightforward — to keep the project portable, and bolster non-complex interpretability and developmental efficiency for further advancement inputs. The novelty of MARK-B.L.U. lies in employing quantum measurement out-comes as the root entropy source for digital identity management, that yields information-theoretic unpredictability, irreversible collapse, and verifiable provenance while retaining classical operational practicality, for multi-nodal dynamic implementability.
At the foundation lies the quantum hashing engine, responsible for converting classical inputs into quantum-measured hash outputs. Each 16-qubit circuit undergoes:
- Hadamard Initialization — Establishes uniform superposition across all qubits.
- Entanglement Churning (CZ Gates) — Introduces quantum correlations for non-local dependencies.
- Seeded Rotations (RZ/RX) — Parameterized by a 512-bit QRNG seed, embedding unique, unrepeatable phase information.
- Measurement & Hashing — Collapses quantum amplitudes to produce a 16-bit raw output, which is then SHA-256 hashed into a 256-bit badge.
This process ensures that no two badges are ever statistically or physically identical, providing an identity layer underpinned by quantum indeterminacy rather than deterministic randomness.
Each agent is assigned a persistent serial ID (e.g., AGENT-001) paired with an ephemeral quantum badge. Badges are generated via the quantum hash engine and serve as the agent’s cryptographic identity credential during its current timeslot. This separation of stable ID and ephemeral badge ensures:
- Privacy through pseudonymity (agents cannot be persistently tracked);
- Security through entropy (each badge is physically unguessable);
- Auditability through metadata binding (every badge embeds serial and timeslot context).
MARK-B.L.U. employs temporal identity segmentation, where each timeslot (default = 5 minutes) triggers a new badge generation event:
Each rotation:
- Generates a fresh 512-bit QRNG seed
- Executes a new 16-qubit circuit.
- Derives a unique 256-bit badge.
- Stores the badge securely in the central database.
- Deletes the previous badge to maintain forward secrecy.
Overarching outcome is that even a total compromise of a current badge cannot decrypt or infer past communications, without access to badge history logs, an advantage unique to quantum-driven systems.
Once generated, the badge becomes the root of trust for encrypted communication. Encryption workflow:
Messages are encrypted using AES-256-CBC, with 128-bit random initialization vectors (IVs), PKCS#7 padding, and timeslot-bound authentication metadata. Decryption requires querying the badge corresponding to the sender’s timeslot, ensuring that only agents possessing the valid badge for that time window can communicate or authenticate successfully.
The centralized verification engine (SQLite, for 1.0) records every badge with agent serial, timeslot index, QRNG seed, and the generation timestamp. The administrators can replay badge generation by re-executing the quantum circuit using the stored seed, offering verifiable quantum provenance. This property, absent in classical systems, allows auditors or security teams to prove that a given badge originated from a legitimate, quantifiable quantum process.
MARK-B.L.U. was architected to deliver five principal cryptographic guarantees:
| Property | Mechanism | Benefit |
|---|---|---|
| Unpredictability | Quantum randomness from 16-qubit circuits | Information-theoretic security |
| Forward Secrecy | Time-bound badge rotation (5-min intervals) | Compromise of current badge doesn't affect past communications |
| Non-Repudiation | QRNG seed storage enables badge replay | Cryptographic proof of identity origin |
| Unlinkability | Ephemeral badges with no persistent identifiers | Prevents agent tracking across timeslots |
| Auditability | Centralized verification with quantum provenance | Compliance-grade forensic validation |
These principles make MARK-B.L.U. a quantum-resilient security layer for AI ecosystems.
MARK-BLU/
├── agent_system/ # Core identity, communication, and storage modules
│ ├── agent_identity.py # Quantum badge generation and agent lifecycle
│ ├── secure_communication.py # AES-256 encrypted messaging layer
│ ├── database_manager.py # SQLite backend with audit logging
│ └── admin_dashboard.py # Streamlit web interface
│
├── quantum_hash/ # Parameterized 16-qubit circuit logic
│ ├── input_encoder.py # Classical-to-quantum data encoding
│ ├── circuit_builder.py # Quantum circuit construction
│ └── hash_core.py # Quantum measurement and hashing
│
├── analysis/ # Cryptographic validation suite
│ ├── test_entropy.py # Shannon entropy verification
│ ├── test_collisions.py # Hash collision resistance testing
│ ├── test_avalanche.py # Avalanche effect measurement
│ └── test_bit_independence.py # Statistical independence checks
│
├── docs/ # Technical documentation and methodology
├── data/ # SQLite databases (development/production)
├── requirements.txt # Python dependencies
├── CHANGELOG.md # Version history
└── FUTURE_SCOPE.md # Roadmap and planned features
To test the robustness of the architecture, it was ran through four primary hash evaluation benchmarks. The results that follow, while still under refinement, showcase early evidence of desirable cryptographic properties like diffusion and randomness - even at the 1.0's level.
| Metric | Result | Interpretation |
|---|---|---|
| Shannon Entropy | 7.98/8.0 bits | Near-optimal randomness |
| Collision Rate | 0% (10,000 samples) | No hash collisions detected |
| Avalanche Effect | 49.8% bit flip rate | Excellent diffusion property |
| Bit Independence | χ² p-value > 0.05 | Statistically independent bits |
These metrics validate that the quantum hash function exhibits non-trivial entropy and diffusion properties suitable for cryptographic identity derivation within NISQ-era constraints.
| Feature | Impact |
|---|---|
| Quantum Entropy Integration | Information-theoretic security; non-predictable even by quantum adversaries |
| Identity Rotation | Enforces temporal isolation; eliminates static credential vulnerabilities |
| Auditable Provenance | Compliance-grade traceability and forensic validation |
| Low Infrastructure Overhead | Operable on standard CPUs via quantum simulators; scalable to real hardware |
| Interoperable Design | Python-based API integrates with agent frameworks, IoT networks, and security stacks |
git clone https://github.com/GENORROW/MARK-B.L.U..git
cd MARK-B.L.U.
python -m venv .venv
.venv\Scripts\activate # Windows | source .venv/bin/activate (macOS/Linux)
pip install -r requirements.txtfrom agent_system.database_manager import IdentityDatabase
from agent_system.agent_identity import Agent
from agent_system.secure_communication import SecureChannel
import time
db = IdentityDatabase("data/system.db")
db.initialize()
agent = Agent("AGENT-001")
timeslot = int(time.time() // 300)
identity = agent.generate_identity(timeslot=timeslot)
db.store_identity(identity)
channel = SecureChannel(db)
encrypted, iv = channel.encrypt_message("Status: Operational", identity)
decrypted = channel.decrypt_message(encrypted, iv, identity)
print(f"Badge: {identity.badge.hex()[:32]}...")
print(f"Decrypted: '{decrypted}'")Create config.yaml for production deployments:
system:
name: "MARK-B.L.U. Production"
environment: "production"
max_agents: 1000 # Tested up to 10,000 agents
log_level: "INFO" # DEBUG, INFO, WARNING, ERROR
security:
badge_update_interval: 300 # 5 minutes (300s) - adjust based on threat model
quantum_circuit_qubits: 16 # Fixed for current version
entangling_layers: 3 # Increases quantum correlation depth
encryption: "AES-256-CBC"
min_password_length: 12
session_timeout: 3600 # 1 hour
database:
path: "data/production.db"
backup_enabled: true
backup_interval: 3600 # 1 hour
backup_retention: 168 # 7 days (hours)
connection_pool_size: 10
quantum:
backend: "qasm_simulator" # Use 'ibmq_qasm_simulator' for IBM Quantum
shots: 1024 # Measurement samples per circuit
optimization_level: 3 # 0-3, higher = slower but better
monitoring:
enable_metrics: true
metrics_port: 9090
health_check_interval: 60Loading configuration:
import yaml
with open('config.yaml', 'r') as f:
config = yaml.safe_load(f)
# Apply settings
db = IdentityDatabase(db_path=config['database']['path'])| Operation | Latency | Throughput |
|---|---|---|
| Badge Generation | ~250ms | 4 badges/sec |
| Message Encryption | ~2ms | 500 ops/sec |
| Message Decryption | ~2ms | 500 ops/sec |
| Database Write | ~5ms | 200 ops/sec |
| Badge Verification | ~1ms | 1000 ops/sec |
Tested on: Intel i7-12700K, 32GB RAM, Python 3.11
Note: This repository contains the backend core only. The professional Streamlit-based administrative dashboard is maintained in a separate private repository for exclusive enterprise use.
- Real-time badge lifecycle monitoring
- Entropy and collision analytics
- Agent communication visualization
- Credential and audit management
- Security event logging
- Intuitive UI with authentication
Access: Dashboard repository available upon request for verified partners and enterprise clients.
Contact: enterprises@genorrow.com for dashboard access and enterprise licensing.
CREATE TABLE identities (
serial TEXT NOT NULL, -- Agent unique identifier (e.g., 'AGENT-001')
timeslot INTEGER NOT NULL, -- Time period index
badge BLOB NOT NULL, -- Quantum-generated badge (32 bytes)
qrng_seed BLOB NOT NULL, -- 512-bit QRNG seed for reproducibility
timestamp TEXT NOT NULL, -- ISO 8601 creation time
PRIMARY KEY (serial, timeslot)
);CREATE TABLE communications (
id INTEGER PRIMARY KEY AUTOINCREMENT,
sender_serial TEXT NOT NULL,
receiver_serial TEXT NOT NULL,
encrypted_message BLOB NOT NULL,
iv BLOB NOT NULL, -- AES initialization vector (16 bytes)
timeslot INTEGER NOT NULL,
timestamp TEXT NOT NULL,
FOREIGN KEY (sender_serial, timeslot) REFERENCES identities(serial, timeslot)
);CREATE TABLE admin_users (
username TEXT PRIMARY KEY,
password_hash TEXT NOT NULL, -- SHA-256 hashed
salt BLOB NOT NULL, -- 32-byte random salt
created_at TEXT NOT NULL,
last_login TEXT
);| Constraint | Impact | Mitigation |
|---|---|---|
| Simulated Quantum Circuits | ~250ms badge generation latency | Hardware quantum backend integration (Q1 2026) |
| Fixed 16-qubit Architecture | Limited entropy expansion | Parameterized qubit scaling in v2.0 |
| Single-node Database | Not geo-distributed | Multi-region replication planned |
| Statevector Simulation | Potential measurement bias | Real quantum hardware eliminates simulation artifacts |
| 5-minute Badge Rotation | Fixed temporal granularity | Configurable intervals in production config |
- Minimum: 2 CPU cores, 4GB RAM, 1GB disk
- Recommended: 4 CPU cores, 8GB RAM, 10GB disk (production)
- Network: <100ms latency for real-time badge verification
- Python: 3.9+ (tested up to 3.12)
from agent_system.database_manager import IdentityDatabase
from agent_system.agent_identity import Agent
import time
db = IdentityDatabase("data/system.db")
db.initialize()
agent = Agent("AGENT-001")
timeslot = int(time.time() // 300)
identity = agent.generate_identity(timeslot=timeslot)
db.store_identity(identity)
print(f"Serial: {identity.serial}")
print(f"Badge: {identity.badge.hex()[:32]}...")
print(f"Timeslot: {identity.timeslot}")from agent_system.secure_communication import SecureChannel
from agent_system.agent_identity import Agent
import time
db = IdentityDatabase("data/system.db")
channel = SecureChannel(db)
timeslot = int(time.time() // 300)
sender = Agent("AGENT-ALPHA")
sender_identity = sender.generate_identity(timeslot=timeslot)
db.store_identity(sender_identity)
message = "Mission update: Target acquired"
encrypted, iv = channel.encrypt_message(message, sender_identity)
decrypted = channel.decrypt_message(encrypted, iv, sender_identity)
print(f"Encrypted: {encrypted.hex()[:32]}...")
print(f"Decrypted: {decrypted}")
print(f"Match: {'✓' if decrypted == message else '✗'}")from agent_system.agent_identity import Agent
import time
db = IdentityDatabase("data/system.db")
agent = Agent("AGENT-001")
timeslot_1 = int(time.time() // 300)
identity_1 = agent.generate_identity(timeslot=timeslot_1)
db.store_identity(identity_1)
timeslot_2 = timeslot_1 + 1
identity_2 = agent.generate_identity(timeslot=timeslot_2)
db.store_identity(identity_2)
badge_diff = sum(b1 != b2 for b1, b2 in zip(identity_1.badge, identity_2.badge))
print(f"Badge rotation: {badge_diff}/32 bytes changed")
print(f"Forward secrecy: {'✓' if badge_diff > 28 else '✗'}")from agent_system.database_manager import IdentityDatabase
import time
db = IdentityDatabase("data/system.db")
agent = Agent("AGENT-001")
timeslot = int(time.time() // 300)
original = agent.generate_identity(timeslot=timeslot)
db.store_identity(original)
stored = db.get_identity(serial="AGENT-001", timeslot=timeslot)
print(f"Verification: {'✓ Valid' if stored.badge == original.badge else '✗ Invalid'}")FROM python:3.11-slim
WORKDIR /app
RUN apt-get update && apt-get install -y gcc g++ && rm -rf /var/lib/apt/lists/*
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
RUN mkdir -p /app/data
EXPOSE 8501
CMD ["streamlit", "run", "agent_system/admin_dashboard.py", "--server.port=8501", "--server.address=0.0.0.0"]docker build -t mark-blu:1.0 .
docker run -d --name mark-blu -p 8501:8501 -v $(pwd)/data:/app/data mark-blu:1.0apiVersion: apps/v1
kind: Deployment
metadata:
name: mark-blu
spec:
replicas: 3
selector:
matchLabels:
app: mark-blu
template:
spec:
containers:
- name: mark-blu
image: mark-blu:1.0
ports:
- containerPort: 8501
resources:
requests: {memory: "2Gi", cpu: "1000m"}
limits: {memory: "4Gi", cpu: "2000m"}
volumeMounts:
- name: data
mountPath: /data
volumes:
- name: data
persistentVolumeClaim:
claimName: mark-blu-pvckubectl apply -f k8s/deployment.yamlfrom flask import Flask, request, jsonify
from agent_system.database_manager import IdentityDatabase
from agent_system.agent_identity import Agent
import time
app = Flask(__name__)
db = IdentityDatabase("data/production.db")
db.initialize()
@app.route('/api/v1/agent/create', methods=['POST'])
def create_agent():
agent = Agent(request.json['serial'])
identity = agent.generate_identity(timeslot=int(time.time() // 300))
db.store_identity(identity)
return jsonify({'serial': identity.serial, 'badge': identity.badge.hex()}), 201
@app.route('/api/v1/agent/verify', methods=['POST'])
def verify_badge():
data = request.json
stored = db.get_identity(data['serial'], data['timeslot'])
return jsonify({'valid': stored.badge.hex() == data['badge']})
if __name__ == '__main__':
app.run(host='0.0.0.0', port=5000)- Python: 3.9+ (tested up to 3.12)
- RAM: 4GB minimum, 8GB recommended
- Disk: 1GB minimum, 10GB recommended (production)
- OS: Windows, macOS, Linux (Ubuntu 20.04+)
- Network: <100ms latency for real-time operations
Agent(serial: str)
def generate_identity(timeslot: int) -> AgentIdentity
# Generate quantum-derived identity for specified timeslotAgentIdentity
| Attribute | Type | Description |
|---|---|---|
serial |
str |
Agent identifier |
badge |
bytes |
Quantum badge (32 bytes) |
timeslot |
int |
Time period index |
timestamp |
str |
ISO 8601 creation time |
qrng_seed |
bytes |
512-bit QRNG seed |
IdentityDatabase(db_path: str)
def initialize() # Create database schema
def store_identity(identity: AgentIdentity) # Store badge
def get_identity(serial, timeslot) -> AgentIdentity # Retrieve badge
def get_current_identity(serial) -> AgentIdentity # Get latest badge
def log_communication(sender, receiver, ...) # Log encrypted message
def get_recent_communications(limit=100) # Query logsSecureChannel(database: IdentityDatabase)
def encrypt_message(message, identity) -> (bytes, bytes)
# Returns (ciphertext, iv)
def decrypt_message(ciphertext, iv, identity) -> str
# Returns plaintext or raises ValueErrorAdminAuth(db_path: str)
def create_admin(username, password) # SHA-256 hashed with 32-byte salt
def verify_admin(username, password) # Returns bool
def admin_exists(username) # Check if account existsSecurity: Change default credentials before production.
Production Checklist:
- Change default credentials (
AdminAuth.create_admin) - Enable HTTPS for dashboard
- Implement database backups (daily recommended)
- Configure firewall rules
- Enable audit logging
- Rotate passwords quarterly
- Monitor anomalies
- Keep dependencies updated
| Property | Implementation |
|---|---|
| Key Derivation | SHA-256(quantum_badge) → AES-256 key |
| Forward Secrecy | Time-bound badges prevent past decryption |
| Replay Prevention | Timeslot validation enforces temporal bounds |
| Non-Predictability | Quantum randomness (information-theoretic) |
| Auditability | QRNG seed storage enables verification |
pip install -r requirements.txt
streamlit run agent_system/admin_dashboard.py --server.port 8502from agent_system.database_manager import AdminAuth
auth = AdminAuth("data/system.db")
auth.create_admin("new_username", "new_password")Get-Process python,streamlit | Stop-Process -Force
Remove-Item data\system.db-wal, data\system.db-shm
streamlit run agent_system/admin_dashboard.pypip install --upgrade qiskit qiskit-aer
python -c "import qiskit; print(qiskit.__version__)"# Pre-generate badges for multiple timeslots
identities = [agent.generate_identity(timeslot=base + i) for i in range(12)]
# Create database indexes
import sqlite3
conn = sqlite3.connect("data/system.db")
conn.execute("CREATE INDEX IF NOT EXISTS idx_serial_timeslot ON identities(serial, timeslot)")
conn.commit()| Code | Meaning | Solution |
|---|---|---|
E001 |
Identity not found | Ensure badge generated for timeslot |
E002 |
Decryption failed | Verify correct identity used for key derivation |
E003 |
Database connection error | Check file permissions on data/ directory |
E004 |
Quantum backend failure | Update Qiskit or check system resources |
E005 |
Invalid timeslot | Timeslot must be positive integer |
If issues persist:
-
Check logs:
# Streamlit logs location # Windows: %USERPROFILE%\.streamlit\logs # macOS/Linux: ~/.streamlit/logs
-
Enable debug mode:
import logging logging.basicConfig(level=logging.DEBUG)
-
Contact support: enterprises@genorrow.com (include logs and error messages)
See CHANGELOG.md for complete version history.
Current Version: 1.0.0 (November 2025)
- Quantum identity generation (16-qubit circuits)
- Time-based badge rotation (5-minute intervals)
- AES-256-CBC encrypted messaging
- SQLite database with audit logging
- Streamlit administrative dashboard
- Complete API documentation
- Enterprise integration examples (Docker, Kubernetes, REST API)
- Cryptographic validation suite (entropy, collision, avalanche tests)
Email: enterprises@genorrow.com
Website: https://www.genorrow.com/MARK-B.L.U.
Documentation: See docs/ directory for technical deep-dives
For partnership opportunities or feature requests, contact us at the email above.
MIT License
MARK-B.L.U. — Quantum Identity Infrastructure for Autonomous Systems.
Enterprise licensing & secure deployments available upon request.
© 2025 GENORROW ENTERPRISES. All rights reserved.
Built for the "tomorrow" of autonomous infrastructure.