Friday, June 26, 2026
Thursday, June 25, 2026
Wednesday, June 24, 2026
Tuesday, June 16, 2026
Developer tool online ready to calculate and decrypt SHA256
let lastDecodedPoint = null; // store P for later use
function convertIntToText() {
const terminal = document.getElementById("terminal");
if (!lastDecodedPoint) {
terminal.textContent += "\nNo decoded point available. Run decoder first.\n";
return;
}
terminal.textContent += "\nConverting P.x to text...\n";
let text = "(invalid UTF‑8)";
try {
text = intToText(lastDecodedPoint.x);
} catch {}
terminal.textContent += "Decoded text:\n" + text + "\n";
const urlPattern = /^(https?:\/\/|www\.)[^\s]+$/i;
if (urlPattern.test(text)) {
terminal.textContent += "This looks like a URL (but not opening it).\n";
} else {
terminal.textContent += "This is plain text.\n";
}
}
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>ECC Encoded URL Redirect</title>
<style>
body {
background: #0d0d0d;
color: #00ff99;
font-family: Consolas, monospace;
padding: 40px;
}
h1 {
text-align: center;
color: #00ffaa;
font-weight: 300;
margin-bottom: 30px;
}
.box {
max-width: 700px;
margin: auto;
background: #000;
border: 2px solid #00ff99;
padding: 25px;
border-radius: 10px;
}
label {
display: block;
margin-top: 15px;
color: #00ffaa;
}
input {
width: 100%;
padding: 10px;
background: #111;
border: 1px solid #00ff99;
color: #00ff99;
border-radius: 5px;
font-family: Consolas;
}
button {
margin-top: 20px;
width: 100%;
padding: 12px;
background: #00ff99;
color: #000;
font-weight: bold;
border: none;
border-radius: 5px;
cursor: pointer;
}
button:hover {
background: #00ffaa;
}
pre {
background: #000;
border: 1px solid #00ff99;
padding: 15px;
margin-top: 20px;
color: #00ff99;
overflow-x: auto;
border-radius: 5px;
}
</style>
</head>
<body>
<h1>ECC Encoded URL Redirect</h1>
<div class="box">
<label>C.x</label>
<input id="cx" placeholder="Paste C.x">
<label>C.y</label>
<input id="cy" placeholder="Paste C.y">
<label>Scalar k</label>
<input id="k" placeholder="Enter scalar k">
<button onclick="decodeAndRedirect()">Decode & Redirect</button>
<pre id="log">Waiting for ECC input…</pre>
</div>
<script>
// secp256k1 parameters
const p = BigInt("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F");
const n = BigInt("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141");
class Point {
constructor(x, y) { this.x = x; this.y = y; }
}
function modPow(base, exp, mod) {
let r = 1n;
base %= mod;
while (exp > 0) {
if (exp & 1n) r = (r * base) % mod;
base = (base * base) % mod;
exp >>= 1n;
}
return r;
}
function modInv(a, m) {
return modPow(a, m - 2n, m);
}
function pointAdd(P, Q) {
if (P === null) return Q;
if (Q === null) return P;
if (P.x === Q.x && P.y !== Q.y) return null;
let m;
if (P.x === Q.x && P.y === Q.y) {
m = (3n * P.x * P.x) * modInv(2n * P.y, p) % p;
} else {
m = (Q.y - P.y) * modInv(Q.x - P.x, p) % p;
}
const rx = (m*m - P.x - Q.x) % p;
const ry = (m*(P.x - rx) - P.y) % p;
return new Point((rx+p)%p, (ry+p)%p);
}
function scalarMult(k, P) {
let R = null;
let A = P;
while (k > 0n) {
if (k & 1n) R = pointAdd(R, A);
A = pointAdd(A, A);
k >>= 1n;
}
return R;
}
function intToText(x) {
let hex = x.toString(16);
if (hex.length % 2) hex = "0" + hex;
let bytes = new Uint8Array(hex.match(/.{1,2}/g).map(b => parseInt(b,16)));
return new TextDecoder().decode(bytes);
}
function decodeAndRedirect() {
const log = document.getElementById("log");
log.textContent = "Decoding ECC data…\n";
const cx = BigInt(document.getElementById("cx").value);
const cy = BigInt(document.getElementById("cy").value);
const k = BigInt(document.getElementById("k").value);
log.textContent += "Computing k⁻¹ mod n…\n";
const k_inv = modInv(k, n);
log.textContent += "Performing P = k⁻¹ · C…\n";
const C = new Point(cx, cy);
const P = scalarMult(k_inv, C);
log.textContent += "Recovered point P:\n" + JSON.stringify(P, null, 2) + "\n\n";
log.textContent += "Converting P.x to text…\n";
let text = "(invalid UTF‑8)";
try { text = intToText(P.x); } catch {}
log.textContent += "Decoded text:\n" + text + "\n\n";
const urlPattern = /^(https?:\/\/|www\.)[^\s]+$/i;
if (urlPattern.test(text)) {
log.textContent += "Detected URL → Redirecting…\n";
setTimeout(() => window.location.href = text, 1200);
} else {
log.textContent += "Not a URL. Displaying text only.\n";
}
}
</script>
</body>
</html>
<input id="cx" value="1234567890...">
<input id="cy" value="9876543210...">
<input id="k" value="12345">
const Cx = "123456789...";
const Cy = "987654321...";
const k = "12345";
Monday, June 15, 2026
Decode decrypt SHA 256
# ============================================================
# SECP256K1 REVERSIBLE DECODER
# P = k^{-1} · C → bytes
# ============================================================
# Curve parameters (secp256k1)
p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F
n = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
# Base point G (not needed for decoding, but included for completeness)
Gx = 55066263022277343669578718895168534326250603453777594175500187360389116729240
Gy = 32670510020758816978083085130507043184471273380659243275938904335757337482424
# ============================================================
# POINT STRUCTURE
# ============================================================
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
# ============================================================
# MODULAR ARITHMETIC
# ============================================================
def mod_inv(a, m):
"""Modular inverse using Fermat's little theorem."""
return pow(a, m - 2, m)
# ============================================================
# POINT ADDITION
# ============================================================
def point_add(P, Q):
if P is None:
return Q
if Q is None:
return P
if P.x == Q.x and P.y != Q.y:
return None
if P.x == Q.x and P.y == Q.y:
# Point doubling
m = (3 * P.x * P.x) * mod_inv(2 * P.y, p) % p
else:
# Point addition
m = (Q.y - P.y) * mod_inv(Q.x - P.x, p) % p
rx = (m * m - P.x - Q.x) % p
ry = (m * (P.x - rx) - P.y) % p
return Point(rx, ry)
# ============================================================
# SCALAR MULTIPLICATION
# ============================================================
def scalar_mult(k, P):
R = None
A = P
while k > 0:
if k & 1:
R = point_add(R, A)
A = point_add(A, A)
k >>= 1
return R
# ============================================================
# INTEGER → BYTES
# ============================================================
def int_to_bytes(x):
"""Convert integer back to bytes (binary block)."""
length = (x.bit_length() + 7) // 8
return x.to_bytes(length, "big")
# ============================================================
# DECODE A SINGLE ECC BLOCK
# ============================================================
def decode_block(Cx, Cy, k):
"""
Input:
Cx, Cy = encoded point coordinates
k = scalar used during encoding
Output:
raw bytes of the original block
"""
C = Point(Cx, Cy)
k_inv = mod_inv(k, n)
P = scalar_mult(k_inv, C)
return int_to_bytes(P.x)
# ============================================================
# DECODE A FULL BINARY FILE (multiple blocks)
# ============================================================
def decode_file(blocks, k):
"""
blocks = list of (Cx, Cy) tuples
k = scalar used during encoding
Returns:
full binary file as bytes
"""
output = b""
for Cx, Cy in blocks:
output += decode_block(Cx, Cy, k)
return output
# ============================================================
# EXAMPLE USAGE
# ============================================================
if __name__ == "__main__":
# Example encoded block (replace with real values)
Cx = 12345678901234567890
Cy = 98765432109876543210
k = 123456789
decoded = decode_block(Cx, Cy, k)
print("Decoded bytes:", decoded)
Subscribe to:
Posts (Atom)
