Saturday, June 13, 2026
Elliptic curve HTML decode site developer tools any browser
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>ECC Decode Tool — Auto URL</title>
<style>
body {
font-family: "Segoe UI", Arial, sans-serif;
background: linear-gradient(135deg, #1e1e2f, #2d2d44);
color: #eee;
padding: 40px;
}
h1 {
text-align: center;
margin-bottom: 30px;
font-weight: 300;
color: #fff;
}
.container {
max-width: 700px;
margin: auto;
background: #2b2b3d;
padding: 25px;
border-radius: 12px;
box-shadow: 0 0 20px rgba(0,0,0,0.4);
}
label {
font-size: 15px;
margin-top: 10px;
display: block;
color: #ccc;
}
input {
width: 100%;
padding: 10px;
margin-top: 6px;
border-radius: 6px;
border: none;
background: #3a3a4f;
color: #fff;
font-size: 15px;
}
button {
width: 100%;
padding: 12px;
margin-top: 20px;
background: #4a8cff;
border: none;
border-radius: 6px;
color: white;
font-size: 16px;
cursor: pointer;
transition: 0.2s;
}
button:hover {
background: #2f6dff;
}
pre {
background: #111;
padding: 15px;
border-radius: 8px;
margin-top: 20px;
color: #0f0;
overflow-x: auto;
}
</style>
</head>
<body>
<h1>ECC Decode Tool — Auto‑Open URL</h1>
<div class="container">
<label>C.x</label>
<input id="cx" type="text" placeholder="Enter C.x">
<label>C.y</label>
<input id="cy" type="text" placeholder="Enter C.y">
<label>Scalar k</label>
<input id="k" type="number" placeholder="Enter scalar k">
<button onclick="decodeAndTrigger()">Decode & Auto‑Open URL</button>
<pre id="output"></pre>
</div>
<script>
// secp256k1 parameters
const p = BigInt("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F");
const n = BigInt("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141");
// Point class
class Point {
constructor(x, y) { this.x = x; this.y = y; }
}
// Modular exponentiation
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;
}
// Modular inverse
function modInv(a, m) {
return modPow(a, m - 2n, m);
}
// Point addition
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);
}
// Scalar multiplication
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;
}
// Convert integer → text
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);
}
// Decode + auto-detect URL
function decodeAndTrigger() {
const cx = BigInt(document.getElementById("cx").value);
const cy = BigInt(document.getElementById("cy").value);
const k = BigInt(document.getElementById("k").value);
const C = new Point(cx, cy);
const k_inv = modInv(k, n);
const P = scalarMult(k_inv, C);
let recovered = "";
try {
recovered = intToText(P.x);
} catch {
recovered = "(invalid UTF‑8 data)";
}
const output = document.getElementById("output");
output.textContent =
"k⁻¹ mod n:\n" + k_inv + "\n\n" +
"Decoded point P:\n" + JSON.stringify(P, null, 2) + "\n\n" +
"Recovered text:\n" + recovered;
// Auto-detect URL
const urlPattern = /^(https?:\/\/|www\.)[^\s]+$/i;
if (urlPattern.test(recovered)) {
output.textContent += "\n\nDetected URL → Opening…";
setTimeout(() => window.location.href = recovered, 800);
} else {
output.textContent += "\n\nNot a URL → Displayed as text.";
}
}
</script>
</body>
</html>
Friday, June 12, 2026
Hunt elliptic curve firewall online from an url
function triggerDecodedURL() {
const cx = BigInt(document.getElementById("cx").value);
const cy = BigInt(document.getElementById("cy").value);
const k = BigInt(document.getElementById("k").value);
const C = new Point(cx, cy);
const k_inv = modInv(k, n);
const P = scalarMult(k_inv, C);
const url = intToText(P.x);
console.log("Decoded URL:", url);
// Trigger navigation
window.location.href = url;
}
<button onclick="triggerDecodedURL()">Open Decoded URL</button>
let C = new Point(cx, cy);
let k_inv = modInv(k, n);
let P = scalarMult(k_inv, C);
let url = intToText(P.x);
window.location.href = url;
┌──────────────────────────────┐
│ Original URL │
│ ex: https://site.com/x │
└───────────────┬──────────────┘
│
▼
Convert URL → Integer
│
▼
Map Integer → Point P
(P = m · G)
│
▼
Encrypt / Transform Point
(C = k · P)
│
▼
┌────────────────────────┐
│ ECC Encoded Payload │
│ { C.x , C.y , k } │
└───────────┬────────────┘
│
▼
User loads encoded page
│
▼
Browser Developer Tools
(breakpoints, flow)
│
▼
Compute k⁻¹ mod n
│
▼
Compute P = k⁻¹ · C
│
▼
Extract integer from P.x
│
▼
Convert integer → text
│
▼
Auto-detect URL?
├── Yes → Open URL
└── No → Show as text
function decodeAndTrigger() {
const cx = BigInt(document.getElementById("cx").value);
const cy = BigInt(document.getElementById("cy").value);
const k = BigInt(document.getElementById("k").value);
const C = new Point(cx, cy);
const k_inv = modInv(k, n);
const P = scalarMult(k_inv, C);
let recovered = "";
try {
recovered = intToText(P.x);
} catch {
recovered = "(invalid UTF‑8 data)";
}
console.log("Recovered:", recovered);
// Auto-detect URL
const urlPattern = /^(https?:\/\/|www\.)[^\s]+$/i;
if (urlPattern.test(recovered)) {
console.log("Detected URL → Opening:", recovered);
window.location.href = recovered;
} else {
console.log("Not a URL → Showing as text");
document.getElementById("output").textContent =
"Decoded text:\n" + recovered;
}
}
<button onclick="decodeAndTrigger()">Decode & Auto‑Open URL</button>
Recovered: https://example.com/page
Detected URL → Opening: https://example.com/page
HTML script code for the elliptic curve decryption
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>ECC Decode Tool (k⁻¹ · C)</title>
<style>
body {
font-family: Arial, sans-serif;
background: #f0f0f0;
padding: 20px;
}
.box {
background: white;
padding: 15px;
border-radius: 8px;
margin-bottom: 20px;
box-shadow: 0 0 5px rgba(0,0,0,0.1);
}
input {
width: 100%;
padding: 8px;
margin-top: 5px;
margin-bottom: 10px;
border-radius: 5px;
border: 1px solid #aaa;
}
button {
padding: 10px 20px;
background: #0078ff;
color: white;
border: none;
border-radius: 5px;
cursor: pointer;
}
button:hover { background: #005fcc; }
pre {
background: #222;
color: #0f0;
padding: 10px;
border-radius: 5px;
overflow-x: auto;
}
</style>
</head>
<body>
<h2>ECC Decode Tool — Compute P = k⁻¹ · C</h2>
<div class="box">
<label>C.x:</label>
<input id="cx" type="text">
<label>C.y
<label>Scalar k:</label>
<input id="k" type="number">
<button onclick="decodeECC()">Decode</button>
</div>
<div class="box">
<h3>Decoded Output</h3>
<pre id="output"></pre>
</div>
<script>
// secp256k1 parameters
const p = BigInt("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F");
const n = BigInt("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141");
// Point class
class Point {
constructor(x, y) { this.x = x; this.y = y; }
}
// Modular exponentiation
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;
}
// Modular inverse
function modInv(a, m) {
return modPow(a, m - 2n, m);
}
// Point addition
function pointAdd(P, Q) {
if (P === null) return 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);
}
// Scalar multiplication
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;
}
// Convert integer → text
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);
}
// Main decode function
function decodeECC() {
const cx = BigInt(document.getElementById("cx").value);
const cy = BigInt(document.getElementById("cy").value);
const k = BigInt(document.getElementById("k").value);
const C = new Point(cx, cy);
const k_inv = modInv(k, n);
const P = scalarMult(k_inv, C);
let recovered = "";
try { recovered = intToText(P.x); }
catch { recovered = "(invalid UTF‑8 data)"; }
document.getElementById("output").textContent =
"k⁻¹ mod n:\n" + k_inv + "\n\n" +
"Decoded point P:\n" + JSON.stringify(P, null, 2) + "\n\n" +
"Recovered message:\n" + recovered;
}
</script>
</body>
</html>
Elliptic curve hack decode script AI
import numpy as np
def decode_circle(p1, p2, p3):
x1,y1 = p1
x2,y2 = p2
x3,y3 = p3
D = 2 * np.linalg.det([
[x1, y1, 1],
[x2, y2, 1],
[x3, y3, 1]
])
h = ((x1**2+y1**2)*(y2-y3) +
(x2**2+y2**2)*(y3-y1) +
(x3**2+y3**2)*(y1-y2)) / D
k = ((x1**2+y1**2)*(x3-x2) +
(x2**2+y2**2)*(x1-x3) +
(x3**2+y3**2)*(x2-x1)) / D
r = np.sqrt((x1-h)**2 + (y1-k)**2)
return h, k, r
import numpy as np
def decode_point(x, y, h, k, R):
d = np.sqrt((x - h)**2 + (y - k)**2)
if np.isclose(d, R):
return "on", d
elif d < R:
return "inside", d
else:
return "outside", d
def reconstruct_circle(p1, p2, p3):
x1,y1 = p1
x2,y2 = p2
x3,y3 = p3
D = 2 * np.linalg.det([
[x1, y1, 1],
[x2, y2, 1],
[x3, y3, 1]
])
h = ((x1**2+y1**2)*(y2-y3) +
(x2**2+y2**2)*(y3-y1) +
(x3**2+y3**2)*(y1-y2)) / D
k = ((x1**2+y1**2)*(x3-x2) +
(x2**2+y2**2)*(x1-x3) +
(x3**2+y3**2)*(x2-x1)) / D
R = np.sqrt((x1-h)**2 + (y1-k)**2)
return h, k, R
Thursday, June 11, 2026
Hack truque trick decode elliptic curve
import hashlib
def msg_to_int(msg: str):
return int(hashlib.sha256(msg.encode()).hexdigest(), 16)
P_recovered = k_inv * C
m_recovered = P_recovered.x # or y, depending on your encoding
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Reversible ECC k·P Tool</title>
<style>
body {
font-family: Arial, sans-serif;
background: #f4f4f4;
padding: 20px;
}
h2 { color: #333; }
.box {
background: white;
padding: 15px;
border-radius: 8px;
margin-bottom: 20px;
box-shadow: 0 0 5px rgba(0,0,0,0.1);
}
input, textarea {
width: 100%;
padding: 8px;
margin-top: 5px;
margin-bottom: 10px;
border-radius: 5px;
border: 1px solid #aaa;
}
button {
padding: 10px 20px;
background: #0078ff;
color: white;
border: none;
border-radius: 5px;
cursor: pointer;
}
button:hover { background: #005fcc; }
pre {
background: #222;
color: #0f0;
padding: 10px;
border-radius: 5px;
overflow-x: auto;
}
</style>
</head>
<body>
<h2>Reversible ECC k·P Encryption Tool</h2>
<div class="box">
<label>Message:</label>
<textarea id="msg" rows="3"></textarea>
<label>Scalar k:</label>
<input id="k" type="number" value="123456789">
<button onclick="runECC()">Encrypt + Decrypt</button>
</div>
<div class="box">
<h3>Results</h3>
<pre id="output"></pre>
</div>
<script>
// --- secp256k1 parameters ---
const p = BigInt("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F");
const n = BigInt("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141");
const Gx = BigInt("55066263022277343669578718895168534326250603453777594175500187360389116729240");
const Gy = BigInt("32670510020758816978083085130507043184471273380659243275938904335757337482424");
// Point object
class Point {
constructor(x, y) { this.x = x; this.y = y; }
}
// Modular inverse
function modInv(a, m) {
return modPow(a, m - 2n, m);
}
// Modular exponentiation
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;
}
// Point addition
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);
}
// Scalar multiplication
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;
}
// Convert text → integer
function textToInt(txt) {
let bytes = new TextEncoder().encode(txt);
let hex = "0x" + Array.from(bytes).map(b => b.toString(16).padStart(2,"0")).join("");
return BigInt(hex);
}
// Convert integer → text
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);
}
// Main ECC reversible process
function runECC() {
const msg = document.getElementById("msg").value;
const k = BigInt(document.getElementById("k").value);
const m = textToInt(msg) % n;
const P = scalarMult(m, new Point(Gx, Gy));
const C = scalarMult(k, P);
const k_inv = modInv(k, n);
const P2 = scalarMult(k_inv, C);
const recovered = intToText(P2.x);
document.getElementById("output").textContent =
"Message integer m:\n" + m + "\n\n" +
"Point P = m·G:\n" + JSON.stringify(P, null, 2) + "\n\n" +
"Encrypted C = k·P:\n" + JSON.stringify(C, null, 2) + "\n\n" +
"Decrypted P = k⁻¹·C:\n" + JSON.stringify(P2, null, 2) + "\n\n" +
"Recovered message:\n" + recovered;
}
</script>
</body>
</html>
Subscribe to:
Posts (Atom)
