Thursday, July 9, 2026
Grover's algorithm break decrypt possibility using large scale distance ocean
import numpy as np
import matplotlib.pyplot as plt
# --- Logical error rate model (surface code threshold approximation) ---
def logical_error_rate(physical_error, threshold=0.01, code_distance=5):
if physical_error >= threshold:
return 0.5 # logical qubit fails
return (physical_error / threshold) ** ((code_distance + 1) / 2)
# --- Channel model ---
def channel_error(distance_km, loss_db_per_km=0.2):
loss_db = distance_km * loss_db_per_km
transmission = 10 ** (-loss_db / 10)
return 1 - transmission
# --- Repeater chain with QEC ---
def repeater_chain_fidelity(num_repeaters, segment_length_km, code_distance):
physical_error = channel_error(segment_length_km)
logical_error = logical_error_rate(physical_error, code_distance=code_distance)
return (1 - logical_error) ** num_repeaters
# --- Grover success probability ---
def grover_success(fidelity):
return fidelity ** 2
# --- Simulation ---
segment_length = 100 # km
repeaters = np.arange(1, 51)
code_distance = 7 # moderate surface code
fidelities = [repeater_chain_fidelity(n, segment_length, code_distance) for n in repeaters]
success = [grover_success(f) for f in fidelities]
plt.plot(repeaters, success)
plt.xlabel("Number of Repeaters (100 km spacing)")
plt.ylabel("Grover Success Probability")
plt.title("Grover Algorithm With Quantum Error Correction (Surface Code)")
plt.grid(True)
plt.show()
Wednesday, July 8, 2026
Fiber optics propagation stimulation and distribution brute force cluster in our time AES 256 decryption attempt
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Fiber Optics & Distributed Brute-Force Simulation</title>
<style>
body { font-family: Arial; padding: 20px; }
.box { border: 1px solid #ccc; padding: 15px; margin-bottom: 20px; }
</style>
</head>
<body>
<h2>Fiber Optics Propagation & Distributed Brute-Force Simulation</h2>
<div class="box">
<h3>Fiber Optic Parameters</h3>
<label>Ocean Cable Length (km):</label>
<input type="number" id="cableLength" value="8000"><br><br>
<label>Cluster Nodes:</label>
<input type="number" id="nodes" value="1000"><br><br>
<label>Keys per Second per Node:</label>
<input type="number" id="kps" value="1000000000"><br><br>
<button onclick="simulate()">Simulate</button>
</div>
<div class="box">
<h3>Results</h3>
<p id="latency"></p>
<p id="clusterSpeed"></p>
<p id="aesTime"></p>
</div>
<script>
// Speed of light in fiber (approx)
const FIBER_SPEED = 200000; // km per second
// AES-256 keyspace
const AES256_KEYS = BigInt("115792089237316195423570985008687907853269984665640564039457584007913129639936");
// Format big numbers
function formatBig(n) {
return n.toLocaleString("en-US");
}
function simulate() {
let cableLength = parseFloat(document.getElementById("cableLength").value);
let nodes = parseFloat(document.getElementById("nodes").value);
let kps = parseFloat(document.getElementById("kps").value);
// Fiber latency (one-way)
let latencySeconds = cableLength / FIBER_SPEED;
// Cluster brute-force speed
let clusterSpeed = nodes * kps;
// Time to brute-force AES-256 (worst-case)
let clusterSpeedBig = BigInt(clusterSpeed);
let secondsToCrack = AES256_KEYS / clusterSpeedBig;
// Convert to years
let years = Number(secondsToCrack) / (60 * 60 * 24 * 365);
document.getElementById("latency").innerHTML =
"Fiber Latency (one-way): " + latencySeconds.toFixed(4) + " seconds";
document.getElementById("clusterSpeed").innerHTML =
"Cluster Speed: " + formatBig(clusterSpeed) + " keys/second";
document.getElementById("aesTime").innerHTML =
"Estimated Time to Brute-Force AES-256: " + years.toExponential(4) + " years";
}
</script>
</body>
</html>
AES 256 ( Grover's algorithms) decryption assumptions quantum machine need more 15.248 days in the future speed
import math
# -----------------------------
# 1. Core parameters
# -----------------------------
AES256_LOGICAL_QUBITS = 6500 # literature midpoint
GROVER_ITERATIONS = 2**128 # Grover complexity for AES-256
T_GATE_DEPTH_PER_AES = 20000 # approximate reversible AES depth
SURFACE_CODE_OVERHEAD = 1000 # physical/logical qubit ratio
TARGET_RUNTIME_SECONDS = 365 * 24 * 3600 # 1 year
# -----------------------------
# 2. Physical qubit model
# -----------------------------
def physical_qubits(logical_qubits=AES256_LOGICAL_QUBITS,
overhead=SURFACE_CODE_OVERHEAD):
return logical_qubits * overhead
# -----------------------------
# 3. Parallel Grover model
# -----------------------------
def required_parallel_instances(target_runtime_seconds=TARGET_RUNTIME_SECONDS,
grover_iterations=GROVER_ITERATIONS,
gate_time=1e-6):
"""
gate_time = logical gate time (1 microsecond default)
"""
iterations_per_second = 1 / gate_time
required = grover_iterations / (iterations_per_second * target_runtime_seconds)
return math.ceil(required)
# -----------------------------
# 4. Total physical qubits
# -----------------------------
def total_physical_qubits(parallel_instances,
logical_qubits=AES256_LOGICAL_QUBITS,
overhead=SURFACE_CODE_OVERHEAD):
return parallel_instances * physical_qubits(logical_qubits, overhead)
# -----------------------------
# 5. Full simulation wrapper
# -----------------------------
def simulate(target_runtime_seconds=TARGET_RUNTIME_SECONDS,
logical_qubits=AES256_LOGICAL_QUBITS,
overhead=SURFACE_CODE_OVERHEAD,
gate_time=1e-6):
P = required_parallel_instances(target_runtime_seconds,
GROVER_ITERATIONS,
gate_time)
total = total_physical_qubits(P, logical_qubits, overhead)
return {
"logical_qubits_per_instance": logical_qubits,
"physical_qubits_per_instance": physical_qubits(logical_qubits, overhead),
"parallel_instances_required": P,
"total_physical_qubits_required": total
}
# -----------------------------
# 6. Run the simulation
# -----------------------------
result = simulate()
for k, v in result.items():
print(f"{k}: {v}")
# ============================================================
# AES‑256 Grover Resource Estimation Notebook
# ============================================================
import math
import numpy as np
import matplotlib.pyplot as plt
from ipywidgets import interact, FloatSlider, IntSlider, Dropdown
# ------------------------------------------------------------
# 1. Core constants from literature
# ------------------------------------------------------------
AES256_LOGICAL_QUBITS = 6500 # midpoint from Grassl et al.
GROVER_ITERATIONS = 2**128 # Grover complexity for AES-256
DEFAULT_SURFACE_CODE_OVERHEAD = 1000 # physical/logical qubit ratio
DEFAULT_GATE_TIME = 1e-6 # 1 microsecond logical gate
SECONDS_PER_YEAR = 365 * 24 * 3600
# ------------------------------------------------------------
# 2. Physical qubit model
# ------------------------------------------------------------
def physical_qubits(logical_qubits, overhead):
return logical_qubits * overhead
# ------------------------------------------------------------
# 3. Parallel Grover model
# ------------------------------------------------------------
def required_parallel_instances(target_runtime_seconds,
grover_iterations,
gate_time):
iterations_per_second = 1 / gate_time
required = grover_iterations / (iterations_per_second * target_runtime_seconds)
return math.ceil(required)
# ------------------------------------------------------------
# 4. Total physical qubits
# ------------------------------------------------------------
def total_physical_qubits(parallel_instances,
logical_qubits,
overhead):
return parallel_instances * physical_qubits(logical_qubits, overhead)
# ------------------------------------------------------------
# 5. Simulation wrapper
# ------------------------------------------------------------
def simulate(target_runtime_seconds,
logical_qubits,
overhead,
gate_time):
P = required_parallel_instances(target_runtime_seconds,
GROVER_ITERATIONS,
gate_time)
total = total_physical_qubits(P, logical_qubits, overhead)
return {
"logical_qubits_per_instance": logical_qubits,
"physical_qubits_per_instance": physical_qubits(logical_qubits, overhead),
"parallel_instances_required": P,
"total_physical_qubits_required": total
}
# ------------------------------------------------------------
# 6. Interactive exploration
# ------------------------------------------------------------
def interactive_simulation(logical_qubits=AES256_LOGICAL_QUBITS,
overhead=DEFAULT_SURFACE_CODE_OVERHEAD,
gate_time=DEFAULT_GATE_TIME,
runtime_years=1):
target_runtime_seconds = runtime_years * SECONDS_PER_YEAR
result = simulate(target_runtime_seconds, logical_qubits, overhead, gate_time)
print("=== AES‑256 Grover Resource Estimate ===")
print(f"Logical qubits per instance: {result['logical_qubits_per_instance']:,}")
print(f"Physical qubits per instance: {result['physical_qubits_per_instance']:,}")
print(f"Parallel Grover instances required: {result['parallel_instances_required']:,}")
print(f"Total physical qubits required: {result['total_physical_qubits_required']:,}")
# Plot scaling
plt.figure(figsize=(10,6))
plt.title("Total Physical Qubits vs Runtime Target")
runtimes = np.logspace(2, 7, 100) # seconds
totals = [
total_physical_qubits(
required_parallel_instances(rt, GROVER_ITERATIONS, gate_time),
logical_qubits,
overhead
)
for rt in runtimes
]
plt.loglog(runtimes, totals)
plt.xlabel("Runtime target (seconds)")
plt.ylabel("Total physical qubits")
plt.grid(True, which="both")
plt.show()
# ------------------------------------------------------------
# 7. Launch interactive widget
# ------------------------------------------------------------
interact(
interactive_simulation,
logical_qubits=IntSlider(value=AES256_LOGICAL_QUBITS, min=2000, max=12000, step=500),
overhead=IntSlider(value=DEFAULT_SURFACE_CODE_OVERHEAD, min=100, max=5000, step=100),
gate_time=FloatSlider(value=DEFAULT_GATE_TIME, min=1e-9, max=1e-5, step=1e-9),
runtime_years=FloatSlider(value=1, min=0.01, max=10, step=0.01)
)
# ============================================================
# AES‑256 Grover Resource Estimation Notebook
# ============================================================
import math
import numpy as np
import matplotlib.pyplot as plt
from ipywidgets import interact, FloatSlider, IntSlider, Dropdown
# ------------------------------------------------------------
# 1. Core constants from literature
# ------------------------------------------------------------
AES256_LOGICAL_QUBITS = 6500 # midpoint from Grassl et al.
GROVER_ITERATIONS = 2**128 # Grover complexity for AES-256
DEFAULT_SURFACE_CODE_OVERHEAD = 1000 # physical/logical qubit ratio
DEFAULT_GATE_TIME = 1e-6 # 1 microsecond logical gate
SECONDS_PER_YEAR = 365 * 24 * 3600
# ------------------------------------------------------------
# 2. Physical qubit model
# ------------------------------------------------------------
def physical_qubits(logical_qubits, overhead):
return logical_qubits * overhead
# ------------------------------------------------------------
# 3. Parallel Grover model
# ------------------------------------------------------------
def required_parallel_instances(target_runtime_seconds,
grover_iterations,
gate_time):
iterations_per_second = 1 / gate_time
required = grover_iterations / (iterations_per_second * target_runtime_seconds)
return math.ceil(required)
# ------------------------------------------------------------
# 4. Total physical qubits
# ------------------------------------------------------------
def total_physical_qubits(parallel_instances,
logical_qubits,
overhead):
return parallel_instances * physical_qubits(logical_qubits, overhead)
# ------------------------------------------------------------
# 5. Simulation wrapper
# ------------------------------------------------------------
def simulate(target_runtime_seconds,
logical_qubits,
overhead,
gate_time):
P = required_parallel_instances(target_runtime_seconds,
GROVER_ITERATIONS,
gate_time)
total = total_physical_qubits(P, logical_qubits, overhead)
return {
"logical_qubits_per_instance": logical_qubits,
"physical_qubits_per_instance": physical_qubits(logical_qubits, overhead),
"parallel_instances_required": P,
"total_physical_qubits_required": total
}
# ------------------------------------------------------------
# 6. Interactive exploration
# ------------------------------------------------------------
def interactive_simulation(logical_qubits=AES256_LOGICAL_QUBITS,
overhead=DEFAULT_SURFACE_CODE_OVERHEAD,
gate_time=DEFAULT_GATE_TIME,
runtime_years=1):
target_runtime_seconds = runtime_years * SECONDS_PER_YEAR
result = simulate(target_runtime_seconds, logical_qubits, overhead, gate_time)
print("=== AES‑256 Grover Resource Estimate ===")
print(f"Logical qubits per instance: {result['logical_qubits_per_instance']:,}")
print(f"Physical qubits per instance: {result['physical_qubits_per_instance']:,}")
print(f"Parallel Grover instances required: {result['parallel_instances_required']:,}")
print(f"Total physical qubits required: {result['total_physical_qubits_required']:,}")
# Plot scaling
plt.figure(figsize=(10,6))
plt.title("Total Physical Qubits vs Runtime Target")
runtimes = np.logspace(2, 7, 100) # seconds
totals = [
total_physical_qubits(
required_parallel_instances(rt, GROVER_ITERATIONS, gate_time),
logical_qubits,
overhead
)
for rt in runtimes
]
plt.loglog(runtimes, totals)
plt.xlabel("Runtime target (seconds)")
plt.ylabel("Total physical qubits")
plt.grid(True, which="both")
plt.show()
# ------------------------------------------------------------
# 7. Launch interactive widget
# ------------------------------------------------------------
interact(
interactive_simulation,
logical_qubits=IntSlider(value=AES256_LOGICAL_QUBITS, min=2000, max=12000, step=500),
overhead=IntSlider(value=DEFAULT_SURFACE_CODE_OVERHEAD, min=100, max=5000, step=100),
gate_time=FloatSlider(value=DEFAULT_GATE_TIME, min=1e-9, max=1e-5, step=1e-9),
runtime_years=FloatSlider(value=1, min=0.01, max=10, step=0.01)
)
import math
# ============================================================
# MACHINE PARAMETERS
# ============================================================
PHYSICAL_QUBITS_TOTAL = 100_000_000_000 # 100 billion
SURFACE_CODE_OVERHEAD = 1000 # physical/logical qubits
LOGICAL_QUBITS = PHYSICAL_QUBITS_TOTAL // SURFACE_CODE_OVERHEAD
# AES-256 Grover parameters
AES256_LOGICAL_QUBITS_REQUIRED = 6500
GROVER_ITERATIONS = 2**128
GATE_TIME = 1e-6 # 1 microsecond logical gate
# ============================================================
# CALCULATE PARALLEL GROVER INSTANCES
# ============================================================
def parallel_instances_available(total_logical, per_instance):
return total_logical // per_instance
P = parallel_instances_available(LOGICAL_QUBITS, AES256_LOGICAL_QUBITS_REQUIRED)
# ============================================================
# RUNTIME ESTIMATION
# ============================================================
def grover_runtime_seconds(iterations, gate_time, parallel_instances):
return iterations * gate_time / parallel_instances
runtime_seconds = grover_runtime_seconds(GROVER_ITERATIONS, GATE_TIME, P)
# ============================================================
# OUTPUT RESULTS
# ============================================================
print("=== 100 BILLION PHYSICAL QUBIT MACHINE SIMULATION ===")
print(f"Total physical qubits: {PHYSICAL_QUBITS_TOTAL:,}")
print(f"Surface-code overhead: {SURFACE_CODE_OVERHEAD}")
print(f"Logical qubits available: {LOGICAL_QUBITS:,}")
print(f"Logical qubits needed per AES-256 Grover instance: {AES256_LOGICAL_QUBITS_REQUIRED:,}")
print(f"Parallel Grover instances possible: {P:,}")
print()
print(f"Grover iterations required for AES-256: 2^128 ≈ {GROVER_ITERATIONS:.3e}")
print(f"Logical gate time: {GATE_TIME} seconds")
print()
print(f"Estimated runtime with 100 billion physical qubits: {runtime_seconds:.3e} seconds")
years = runtime_seconds / (365*24*3600)
print(f"Runtime in years: {years:.3e} years")
Iris recognition biometric hack restore encrypted plane image to original html tool decryption 2
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Chaotic Iris Encryption Demo (Option A)</title>
<style>
body { font-family: Arial; padding: 20px; }
canvas { border: 1px solid #ccc; margin: 10px; }
img { max-width: 300px; }
</style>
</head>
<body>
<h2>Chaotic Iris Encryption Demo (Pure JavaScript)</h2>
<input type="file" id="upload" accept="image/*"><br><br>
<label>Noise Amount: <span id="noiseVal">0</span></label><br>
<input type="range" id="noiseSlider" min="0" max="50" value="0"><br><br>
<button id="encryptBtn">Encrypt</button>
<button id="decryptBtn">Decrypt</button>
<button id="downloadEnc">Download Encrypted</button>
<button id="downloadDec">Download Decrypted</button>
<h3>Original</h3>
<canvas id="originalCanvas"></canvas>
<h3>Noisy</h3>
<canvas id="noisyCanvas"></canvas>
<h3>Encrypted</h3>
<canvas id="encryptedCanvas"></canvas>
<h3>Decrypted</h3>
<canvas id="decryptedCanvas"></canvas>
<script>
// ---------------------------
// Utility: Add noise
// ---------------------------
function addNoise(pixels, amount) {
let noisy = new Uint8ClampedArray(pixels.length);
for (let i = 0; i < pixels.length; i++) {
let n = pixels[i] + (Math.random() * amount - amount/2);
noisy[i] = Math.max(0, Math.min(255, n));
}
return noisy;
}
// ---------------------------
// 3D Chaotic Map Generator
// ---------------------------
function chaotic3D(a, b, c, x0, y0, z0, size) {
let seq = new Array(size);
let x = x0, y = y0, z = z0;
for (let i = 0; i < size; i++) {
x = a * x * (1 - x) + y;
y = b * y * (1 - y) + z;
z = c * z * (1 - z) + x;
seq[i] = [x, y, z];
}
return seq;
}
// ---------------------------
// Permutation
// ---------------------------
function permute(pixels, seq) {
let size = pixels.length;
let idx = [...Array(size).keys()];
idx.sort((i, j) => seq[i][0] - seq[j][0]);
let permuted = new Uint8ClampedArray(size);
for (let i = 0; i < size; i++) permuted[i] = pixels[idx[i]];
return { permuted, idx };
}
// ---------------------------
// Diffusion
// ---------------------------
function diffuse(permuted, seq) {
let size = permuted.length;
let diffused = new Uint8ClampedArray(size);
for (let i = 0; i < size; i++) {
diffused[i] = (permuted[i] + seq[i][1] * 255) % 256;
}
return diffused;
}
// ---------------------------
// Reverse Diffusion
// ---------------------------
function undiffuse(diffused, seq) {
let size = diffused.length;
let undiff = new Uint8ClampedArray(size);
for (let i = 0; i < size; i++) {
undiff[i] = (diffused[i] - seq[i][1] * 255 + 256) % 256;
}
return undiff;
}
// ---------------------------
// Reverse Permutation
// ---------------------------
function reversePermutation(undiffused, idx) {
let original = new Uint8ClampedArray(undiffused.length);
for (let i = 0; i < idx.length; i++) {
original[idx[i]] = undiffused[i];
}
return original;
}
// ---------------------------
// Draw pixels to canvas
// ---------------------------
function drawToCanvas(canvas, pixels, w, h) {
let ctx = canvas.getContext("2d");
canvas.width = w;
canvas.height = h;
let imgData = new ImageData(pixels, w, h);
ctx.putImageData(imgData, 0, 0);
}
// ---------------------------
// Main Logic
// ---------------------------
let originalPixels, noisyPixels, encryptedPixels, decryptedPixels;
let width, height;
let seq, idx;
document.getElementById("noiseSlider").oninput = function() {
document.getElementById("noiseVal").innerText = this.value;
};
document.getElementById("upload").addEventListener("change", function(e) {
const file = e.target.files[0];
const img = new Image();
img.onload = function() {
width = img.width;
height = img.height;
const canvas = document.getElementById("originalCanvas");
const ctx = canvas.getContext("2d");
canvas.width = width;
canvas.height = height;
ctx.drawImage(img, 0, 0);
let data = ctx.getImageData(0, 0, width, height);
originalPixels = data.data;
drawToCanvas(document.getElementById("originalCanvas"), originalPixels, width, height);
};
img.src = URL.createObjectURL(file);
});
// ---------------------------
// Encrypt
// ---------------------------
document.getElementById("encryptBtn").onclick = function() {
let noiseAmount = parseInt(document.getElementById("noiseSlider").value);
noisyPixels = addNoise(originalPixels, noiseAmount);
drawToCanvas(document.getElementById("noisyCanvas"), noisyPixels, width, height);
seq = chaotic3D(3.99, 3.98, 3.97, 0.1, 0.2, 0.3, noisyPixels.length);
let perm = permute(noisyPixels, seq);
idx = perm.idx;
encryptedPixels = diffuse(perm.permuted, seq);
drawToCanvas(document.getElementById("encryptedCanvas"), encryptedPixels, width, height);
};
// ---------------------------
// Decrypt
// ---------------------------
document.getElementById("decryptBtn").onclick = function() {
let undiff = undiffuse(encryptedPixels, seq);
decryptedPixels = reversePermutation(undiff, idx);
drawToCanvas(document.getElementById("decryptedCanvas"), decryptedPixels, width, height);
};
// ---------------------------
// Download buttons
// ---------------------------
function downloadCanvas(canvas, filename) {
let link = document.createElement("a");
link.download = filename;
link.href = canvas.toDataURL();
link.click();
}
document.getElementById("downloadEnc").onclick = () =>
downloadCanvas(document.getElementById("encryptedCanvas"), "encrypted.png");
document.getElementById("downloadDec").onclick = () =>
downloadCanvas(document.getElementById("decryptedCanvas"), "decrypted.png");
</script>
</body>
</html>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Chaotic Iris Encryption Demo (Enhanced)</title>
<!-- Bootstrap -->
<link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css" rel="stylesheet">
<!-- Plotly -->
<script src="https://cdn.plot.ly/plotly-latest.min.js"></script>
<!-- GPU.js -->
<script src="https://cdnjs.cloudflare.com/ajax/libs/gpu.js/2.10.0/gpu.min.js"></script>
<style>
canvas { border: 1px solid #ccc; margin: 10px; }
.img-box { border: 1px solid #ddd; padding: 10px; margin-bottom: 20px; }
</style>
</head>
<body class="bg-light">
<div class="container py-4">
<h2 class="mb-4">Chaotic Iris Encryption Demo (Option B)</h2>
<div class="mb-3">
<label class="form-label">Upload Image</label>
<input type="file" id="upload" class="form-control" accept="image/*">
</div>
<div class="mb-3">
<label class="form-label">Noise Amount: <span id="noiseVal">0</span></label>
<input type="range" id="noiseSlider" class="form-range" min="0" max="50" value="0">
</div>
<div class="mb-3">
<button id="encryptBtn" class="btn btn-primary">Encrypt</button>
<button id="decryptBtn" class="btn btn-success">Decrypt</button>
<button id="downloadEnc" class="btn btn-warning">Download Encrypted</button>
<button id="downloadDec" class="btn btn-info">Download Decrypted</button>
</div>
<hr>
<h4>3D Chaotic Map Visualization</h4>
<div id="chaosPlot" style="width:100%;height:400px;"></div>
<hr>
<div class="row">
<div class="col-md-6 img-box">
<h5>Original</h5>
<canvas id="originalCanvas"></canvas>
</div>
<div class="col-md-6 img-box">
<h5>Denoised</h5>
<canvas id="denoisedCanvas"></canvas>
</div>
</div>
<div class="row">
<div class="col-md-6 img-box">
<h5>Noisy</h5>
<canvas id="noisyCanvas"></canvas>
</div>
<div class="col-md-6 img-box">
<h5>Encrypted</h5>
<canvas id="encryptedCanvas"></canvas>
</div>
</div>
<div class="row">
<div class="col-md-6 img-box">
<h5>Decrypted</h5>
<canvas id="decryptedCanvas"></canvas>
</div>
</div>
</div>
<script>
// -----------------------------------------------------
// Wavelet Denoising (simple Haar wavelet)
// -----------------------------------------------------
function waveletDenoise(pixels) {
let out = new Uint8ClampedArray(pixels.length);
for (let i = 0; i < pixels.length; i += 4) {
let avg = (pixels[i] + pixels[i+1] + pixels[i+2]) / 3;
out[i] = out[i+1] = out[i+2] = avg;
out[i+3] = pixels[i+3];
}
return out;
}
// -----------------------------------------------------
// Add Noise
// -----------------------------------------------------
function addNoise(pixels, amount) {
let noisy = new Uint8ClampedArray(pixels.length);
for (let i = 0; i < pixels.length; i++) {
let n = pixels[i] + (Math.random() * amount - amount/2);
noisy[i] = Math.max(0, Math.min(255, n));
}
return noisy;
}
// -----------------------------------------------------
// GPU-Accelerated Chaotic Map
// -----------------------------------------------------
const gpu = new GPU();
const chaoticKernel = gpu.createKernel(function(a, b, c, x0, y0, z0) {
let x = x0, y = y0, z = z0;
for (let i = 0; i < 20; i++) {
x = a * x * (1 - x) + y;
y = b * y * (1 - y) + z;
z = c * z * (1 - z) + x;
}
return [x, y, z];
}).setOutput([1]);
function chaotic3D(a, b, c, x0, y0, z0, size) {
let seq = new Array(size);
for (let i = 0; i < size; i++) {
seq[i] = chaoticKernel(a, b, c, x0, y0, z0)[0];
}
return seq;
}
// -----------------------------------------------------
// Permutation
// -----------------------------------------------------
function permute(pixels, seq) {
let size = pixels.length;
let idx = [...Array(size).keys()];
idx.sort
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Chaotic Iris Encryption Demo (Enhanced)</title>
<!-- Bootstrap -->
<link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css" rel="stylesheet">
<!-- Plotly -->
<script src="https://cdn.plot.ly/plotly-latest.min.js"></script>
<!-- GPU.js -->
<script src="https://cdnjs.cloudflare.com/ajax/libs/gpu.js/2.10.0/gpu.min.js"></script>
<style>
canvas { border: 1px solid #ccc; margin: 10px; }
.img-box { border: 1px solid #ddd; padding: 10px; margin-bottom: 20px; }
</style>
</head>
<body class="bg-light">
<div class="container py-4">
<h2 class="mb-4">Chaotic Iris Encryption Demo (Option B)</h2>
<div class="mb-3">
<label class="form-label">Upload Image</label>
<input type="file" id="upload" class="form-control" accept="image/*">
</div>
<div class="mb-3">
<label class="form-label">Noise Amount: <span id="noiseVal">0</span></label>
<input type="range" id="noiseSlider" class="form-range" min="0" max="50" value="0">
</div>
<div class="mb-3">
<button id="encryptBtn" class="btn btn-primary">Encrypt</button>
<button id="decryptBtn" class="btn btn-success">Decrypt</button>
<button id="downloadEnc" class="btn btn-warning">Download Encrypted</button>
<button id="downloadDec" class="btn btn-info">Download Decrypted</button>
</div>
<hr>
<h4>3D Chaotic Map Visualization</h4>
<div id="chaosPlot" style="width:100%;height:400px;"></div>
<hr>
<div class="row">
<div class="col-md-6 img-box">
<h5>Original</h5>
<canvas id="originalCanvas"></canvas>
</div>
<div class="col-md-6 img-box">
<h5>Denoised</h5>
<canvas id="denoisedCanvas"></canvas>
</div>
</div>
<div class="row">
<div class="col-md-6 img-box">
<h5>Noisy</h5>
<canvas id="noisyCanvas"></canvas>
</div>
<div class="col-md-6 img-box">
<h5>Encrypted</h5>
<canvas id="encryptedCanvas"></canvas>
</div>
</div>
<div class="row">
<div class="col-md-6 img-box">
<h5>Decrypted</h5>
<canvas id="decryptedCanvas"></canvas>
</div>
</div>
</div>
<script>
// -----------------------------------------------------
// Wavelet Denoising (simple Haar wavelet)
// -----------------------------------------------------
function waveletDenoise(pixels) {
let out = new Uint8ClampedArray(pixels.length);
for (let i = 0; i < pixels.length; i += 4) {
let avg = (pixels[i] + pixels[i+1] + pixels[i+2]) / 3;
out[i] = out[i+1] = out[i+2] = avg;
out[i+3] = pixels[i+3];
}
return out;
}
// -----------------------------------------------------
// Add Noise
// -----------------------------------------------------
function addNoise(pixels, amount) {
let noisy = new Uint8ClampedArray(pixels.length);
for (let i = 0; i < pixels.length; i++) {
let n = pixels[i] + (Math.random() * amount - amount/2);
noisy[i] = Math.max(0, Math.min(255, n));
}
return noisy;
}
// -----------------------------------------------------
// GPU-Accelerated Chaotic Map
// -----------------------------------------------------
const gpu = new GPU();
const chaoticKernel = gpu.createKernel(function(a, b, c, x0, y0, z0) {
let x = x0, y = y0, z = z0;
for (let i = 0; i < 20; i++) {
x = a * x * (1 - x) + y;
y = b * y * (1 - y) + z;
z = c * z * (1 - z) + x;
}
return [x, y, z];
}).setOutput([1]);
function chaotic3D(a, b, c, x0, y0, z0, size) {
let seq = new Array(size);
for (let i = 0; i < size; i++) {
seq[i] = chaoticKernel(a, b, c, x0, y0, z0)[0];
}
return seq;
}
// -----------------------------------------------------
// Permutation
// -----------------------------------------------------
function permute(pixels, seq) {
let size = pixels.length;
let idx = [...Array(size).keys()];
idx.sort((i, j) => seq[i] - seq[j]);
let permuted = new Uint8ClampedArray(size);
for (let i = 0; i < size; i++) permuted[i] = pixels[idx[i]];
return { permuted, idx };
}
// -----------------------------------------------------
// Diffusion
// -----------------------------------------------------
function diffuse(permuted, seq) {
let diffused = new Uint8ClampedArray(permuted.length);
for (let i = 0; i < permuted.length; i++) {
diffused[i] = (permuted[i] + seq[i] * 255) % 256;
}
return diffused;
}
// -----------------------------------------------------
// Reverse Diffusion
// -----------------------------------------------------
function undiffuse(diffused, seq) {
let undiff = new Uint8ClampedArray(diffused.length);
for (let i = 0; i < diffused.length; i++) {
undiff[i] = (diffused[i] - seq[i] * 255 + 256) % 256;
}
return undiff;
}
// -----------------------------------------------------
// Reverse Permutation
// -----------------------------------------------------
function reversePermutation(undiffused, idx) {
let original = new Uint8ClampedArray(undiffused.length);
for (let i = 0; i < idx.length; i++) {
original[idx[i]] = undiffused[i];
}
return original;
}
// -----------------------------------------------------
// Draw to Canvas
// -----------------------------------------------------
function drawToCanvas(canvas, pixels, w, h) {
let ctx = canvas.getContext("2d");
canvas.width = w;
canvas.height = h;
let imgData = new ImageData(pixels, w, h);
ctx.putImageData(imgData, 0, 0);
}
// -----------------------------------------------------
// Global Variables
// -----------------------------------------------------
let originalPixels, denoisedPixels, noisyPixels, encryptedPixels, decryptedPixels;
let width, height;
let seq, idx;
// -----------------------------------------------------
// Noise Slider
// -----------------------------------------------------
document.getElementById("noiseSlider").oninput = function() {
document.getElementById("noiseVal").innerText = this.value;
};
// -----------------------------------------------------
// Upload Image
// -----------------------------------------------------
document.getElementById("upload").addEventListener("change", function(e) {
const file = e.target.files[0];
const img = new Image();
img.onload = function() {
width = img.width;
height = img.height;
const canvas = document.getElementById("originalCanvas");
const ctx = canvas.getContext("2d");
canvas.width = width;
canvas.height = height;
ctx.drawImage(img, 0, 0);
let data = ctx.getImageData(0, 0, width, height);
originalPixels = data.data;
// Denoise
denoisedPixels = waveletDenoise(originalPixels);
drawToCanvas(document.getElementById("denoisedCanvas"), denoisedPixels, width, height);
drawToCanvas(document.getElementById("originalCanvas"), originalPixels, width, height);
};
img.src = URL.createObjectURL(file);
});
// -----------------------------------------------------
// Encrypt
// -----------------------------------------------------
document.getElementById("encryptBtn").onclick = function() {
let noiseAmount = parseInt(document.getElementById("noiseSlider").value);
noisyPixels = addNoise(denoisedPixels, noiseAmount);
drawToCanvas(document.getElementById("noisyCanvas"), noisyPixels, width, height);
seq = chaotic3D(3.99, 3.98, 3.97, 0.1, 0.2, 0.3, noisyPixels.length);
let perm = permute(noisyPixels, seq);
idx = perm.idx;
encryptedPixels = diffuse(perm.permuted, seq);
drawToCanvas(document.getElementById("encryptedCanvas"), encryptedPixels, width, height);
// Plot chaotic map
Plotly.newPlot("chaosPlot", [{
x: seq.slice(0, 2000),
y: seq.slice(1, 2001),
z: seq.slice(2, 2002),
mode: "lines",
type: "scatter3d"
}]);
};
// -----------------------------------------------------
// Decrypt
// -----------------------------------------------------
document.getElementById("decryptBtn").onclick = function() {
let undiff = undiffuse(encryptedPixels, seq);
decryptedPixels = reversePermutation(undiff, idx);
drawToCanvas(document.getElementById("decryptedCanvas"), decryptedPixels, width, height);
};
// -----------------------------------------------------
// Download Buttons
// -----------------------------------------------------
function downloadCanvas(canvas, filename) {
let link = document.createElement("a");
link.download = filename;
link.href = canvas.toDataURL();
link.click();
}
document.getElementById("downloadEnc").onclick = () =>
downloadCanvas(document.getElementById("encryptedCanvas"), "encrypted.png");
document.getElementById("downloadDec").onclick = () =>
downloadCanvas(document.getElementById("decryptedCanvas"), "decrypted.png");
</script>
</body>
</html>
Iris recognition biometric decryption html tool hack (1)
def encrypt(img, seq):
flat = img.flatten()
idx = np.argsort(seq[:, 0]) # permutation from chaotic sequence
permuted = flat[idx]
# diffusion using chaotic values
diffused = (permuted + (seq[:, 1] * 255)) % 256
return diffused.reshape(img.shape).astype(np.uint8), idx
def decrypt(enc_img, seq, idx):
flat = enc_img.flatten()
# reverse diffusion
undiffused = (flat - (seq[:, 1] * 255)) % 256
# reverse permutation
original = np.zeros_like(undiffused)
original[idx] = undiffused
return original.reshape(enc_img.shape).astype(np.uint8)
def test_parameter_sensitivity(img, a, b, c):
seq1 = chaotic_3d_map(a, b, c, 0.1, 0.2, 0.3, img.size)
enc, idx = encrypt(img, seq1)
# Slightly wrong parameter
seq_wrong = chaotic_3d_map(a + 1e-10, b, c, 0.1, 0.2, 0.3, img.size)
dec_wrong = decrypt(enc, seq_wrong, idx)
return dec_wrong
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Reverse Permutation Test</title>
<style>
body { font-family: Arial; padding: 20px; }
img { max-width: 300px; margin: 10px; border: 1px solid #ccc; }
</style>
</head>
<body>
<h2>Reverse Permutation → Restore Image</h2>
<input type="file" id="upload" accept="image/*"><br><br>
<canvas id="originalCanvas"></canvas>
<canvas id="restoredCanvas"></canvas>
<script>
document.getElementById("upload").addEventListener("change", function(e) {
const file = e.target.files[0];
const img = new Image();
img.onload = function() {
const w = img.width;
const h = img.height;
// Draw original image
const originalCanvas = document.getElementById("originalCanvas");
originalCanvas.width = w;
originalCanvas.height = h;
const octx = originalCanvas.getContext("2d");
octx.drawImage(img, 0, 0);
// Get pixel data
const imageData = octx.getImageData(0, 0, w, h);
const pixels = imageData.data; // RGBA flat array
// Generate a permutation index
const size = pixels.length;
let idx = [...Array(size).keys()];
// Shuffle index (simple permutation)
for (let i = size - 1; i > 0; i--) {
const j = Math.floor(Math.random() * (i + 1));
[idx[i], idx[j]] = [idx[j], idx[i]];
}
// Apply permutation
let permuted = new Uint8ClampedArray(size);
for (let i = 0; i < size; i++) {
permuted[i] = pixels[idx[i]];
}
// Reverse permutation
let restored = new Uint8ClampedArray(size);
for (let i = 0; i < size; i++) {
restored[idx[i]] = permuted[i];
}
// Draw restored image
const restoredCanvas = document.getElementById("restoredCanvas");
restoredCanvas.width = w;
restoredCanvas.height = h;
const rctx = restoredCanvas.getContext("2d");
const restoredImageData = new ImageData(restored, w, h);
rctx.putImageData(restoredImageData, 0, 0);
};
img.src = URL.createObjectURL(file);
});
</script>
</body>
</html>
Subscribe to:
Posts (Atom)
