BLACK MASK

Tuesday, June 16, 2026

How can any newbie use developer tools of any browser (F12) to see the encoded text in an url ( SHA256 DECRYPTION)

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>

<head>

<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>

<label>Scalar k</label>

<button onclick="decodeAndRedirect()">Decode & Redirect</button>

<pre id="log">Waiting for ECC input…</pre>

</div>

// 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>

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)

Saturday, June 13, 2026

Future

https://m.youtube.com/watch?v=2pooRX40n6E&pp=iggCQAE%3D

Elliptic curve HTML decode site developer tools any browser

<!DOCTYPE html>

<head>

<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>

<label>Scalar k</label>

<button onclick="decodeAndTrigger()">Decode & Auto‑Open URL</button>

</div>

// 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

Search Webcams:
by www.online-camera.de