skill-sentry-cli 2.0.0__py3-none-any.whl

skill_sentry_cli/core/sandbox/assets/masquerade.c

@@ -0,0 +1,484 @@
+/*
+ * SkillSentry sandbox masquerade + telemetry shim.
+ *
+ * Responsibilities:
+ *   1. hide /.dockerenv from stat/access/open (the bind mount still exists),
+ *   2. redirect reads of /proc/{1,self}/cgroup and mountinfo to sanitised
+ *      files generated by run_skill.sh,
+ *   3. append JSONL canary-read and probe events to the monitor log,
+ *   4. observe getenv() of canary values and probe command execution.
+ *
+ * It is intentionally small and defensive: no libc calls are made from the
+ * logging path (raw syscalls only) so a failed log write cannot recurse.
+ *
+ * Build (inside the sandbox image):
+ *   gcc -shared -fPIC -O2 -Wall -Wextra -o masquerade.so masquerade.c -ldl
+ */
+
+#define _GNU_SOURCE
+#define _LARGEFILE64_SOURCE
+#include <dlfcn.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
+#include <linux/stat.h>
+#include <time.h>
+#include <unistd.h>
+
+#define LOG_PATH "/tmp/skillsentry/events.jsonl"
+#define FAKE_CGROUP "/tmp/skillsentry/cgroup"
+#define FAKE_MOUNTINFO "/tmp/skillsentry/mountinfo"
+#define CANARY_ROOT "/home/sandbox/"
+#define DOCKERENV "/.dockerenv"
+
+static void json_escape(const char *src, char *dst, size_t cap) {
+    size_t out = 0;
+    if (cap == 0) {
+        return;
+    }
+    if (src == NULL) {
+        dst[0] = '\0';
+        return;
+    }
+    for (size_t i = 0; src[i] != '\0' && out + 7 < cap; i++) {
+        unsigned char c = (unsigned char)src[i];
+        switch (c) {
+            case '"': dst[out++] = '\\'; dst[out++] = '"'; break;
+            case '\\': dst[out++] = '\\'; dst[out++] = '\\'; break;
+            case '\n': dst[out++] = '\\'; dst[out++] = 'n'; break;
+            case '\r': dst[out++] = '\\'; dst[out++] = 'r'; break;
+            case '\t': dst[out++] = '\\'; dst[out++] = 't'; break;
+            default:
+                if (c < 0x20) {
+                    int written = snprintf(dst + out, cap - out, "\\u%04x", c);
+                    if (written > 0) {
+                        out += (size_t)written;
+                    }
+                } else {
+                    dst[out++] = (char)c;
+                }
+        }
+    }
+    dst[out] = '\0';
+}
+
+static int hex8(const char *value) {
+    if (value == NULL) {
+        return 0;
+    }
+    for (int i = 0; i < 8; i++) {
+        char c = value[i];
+        if (!((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') ||
+              (c >= 'A' && c <= 'F'))) {
+            return 0;
+        }
+    }
+    return 1;
+}
+
+static void marker_from(const char *text, char out[14]) {
+    out[0] = '\0';
+    if (text == NULL) {
+        return;
+    }
+    const char *cursor = text;
+    while ((cursor = strstr(cursor, "SKS")) != NULL) {
+        if (cursor[3] == '-' && hex8(cursor + 4)) {
+            snprintf(out, 14, "SKS-%.8s", cursor + 4);
+            return;
+        }
+        if (hex8(cursor + 3)) {
+            snprintf(out, 14, "SKS-%.8s", cursor + 3);
+            return;
+        }
+        cursor += 3;
+    }
+}
+
+static void log_event(const char *event_type, const char *path,
+                      const char *marker, const char *channel, int implicit) {
+    struct timespec now;
+    struct tm utc;
+    char stamp[32];
+    char esc_path[512];
+    char esc_marker[32];
+    char esc_process[128];
+    char line[1024];
+    const char *process = program_invocation_short_name;
+
+    if (event_type == NULL) {
+        return;
+    }
+    if (process == NULL || process[0] == '\0') {
+        process = "unknown";
+    }
+    if (clock_gettime(CLOCK_REALTIME, &now) != 0) {
+        now.tv_sec = 0;
+        now.tv_nsec = 0;
+    }
+    if (gmtime_r(&now.tv_sec, &utc) == NULL) {
+        memset(&utc, 0, sizeof(utc));
+    }
+    snprintf(stamp, sizeof(stamp), "%04d-%02d-%02dT%02d:%02d:%02d.%03ldZ",
+             utc.tm_year + 1900, utc.tm_mon + 1, utc.tm_mday,
+             utc.tm_hour, utc.tm_min, utc.tm_sec, now.tv_nsec / 1000000);
+    json_escape(path, esc_path, sizeof(esc_path));
+    json_escape(marker, esc_marker, sizeof(esc_marker));
+    json_escape(process, esc_process, sizeof(esc_process));
+
+    snprintf(line, sizeof(line),
+             "{\"ts\":\"%s\",\"event_type\":\"%s\",\"path\":\"%s\","
+             "\"marker\":\"%s\",\"process\":\"%s\",\"detail\":{\"channel\":\"%s\","
+             "\"implicit\":%s}}\n",
+             stamp, event_type, esc_path, esc_marker, esc_process,
+             channel == NULL ? "" : channel, implicit ? "true" : "false");
+
+    int fd = (int)syscall(SYS_openat, AT_FDCWD, LOG_PATH,
+                          O_WRONLY | O_CREAT | O_APPEND | O_CLOEXEC, 0600);
+    if (fd >= 0) {
+        size_t remaining = strlen(line);
+        while (remaining > 0) {
+            ssize_t written = syscall(SYS_write, fd, line, remaining);
+            if (written <= 0) {
+                break;
+            }
+            remaining -= (size_t)written;
+        }
+        syscall(SYS_close, fd);
+    }
+}
+
+static int is_dockerenv(const char *path) {
+    return path != NULL && strcmp(path, DOCKERENV) == 0;
+}
+
+static int is_canary_path(const char *path) {
+    return path != NULL && strncmp(path, CANARY_ROOT, strlen(CANARY_ROOT)) == 0;
+}
+
+static int is_probe_path(const char *path) {
+    if (path == NULL) {
+        return 0;
+    }
+    if (strcmp(path, DOCKERENV) == 0 ||
+        strcmp(path, "/proc/1/cgroup") == 0 ||
+        strcmp(path, "/proc/self/cgroup") == 0 ||
+        strcmp(path, "/proc/1/mountinfo") == 0 ||
+        strcmp(path, "/proc/self/mountinfo") == 0 ||
+        strcmp(path, "/proc/bus/input/devices") == 0 ||
+        strcmp(path, "/dev/kmsg") == 0) {
+        return 1;
+    }
+    return strncmp(path, "/sys/class/dmi/id/", 18) == 0 ||
+           strncmp(path, "/sys/hypervisor/", 16) == 0 ||
+           strncmp(path, "/proc/bus/input/", 16) == 0;
+}
+
+static const char *redirect_path(const char *path) {
+    if (path == NULL) {
+        return path;
+    }
+    if (strcmp(path, "/proc/1/cgroup") == 0 ||
+        strcmp(path, "/proc/self/cgroup") == 0) {
+        return FAKE_CGROUP;
+    }
+    if (strcmp(path, "/proc/1/mountinfo") == 0 ||
+        strcmp(path, "/proc/self/mountinfo") == 0) {
+        return FAKE_MOUNTINFO;
+    }
+    return path;
+}
+
+static int reads_content(int flags) {
+    return (flags & O_ACCMODE) != O_WRONLY;
+}
+
+static void log_path_access(const char *path, int flags, int is_read) {
+    if (is_dockerenv(path)) {
+        log_event("probe_detected", path, NULL, "path", 0);
+        return;
+    }
+    if (is_probe_path(path)) {
+        log_event("probe_detected", path, NULL, "path", 0);
+    }
+    if (is_read && is_canary_path(path)) {
+        log_event("canary_read", path, NULL, "file", 0);
+    }
+}
+
+static int is_command_probe(const char *path) {
+    const char *base = path;
+    if (path == NULL) {
+        return 0;
+    }
+    const char *slash = strrchr(path, '/');
+    if (slash != NULL) {
+        base = slash + 1;
+    }
+    return strcmp(base, "df") == 0 || strcmp(base, "mount") == 0 ||
+           strcmp(base, "lsblk") == 0 ||
+           strcmp(base, "systemd-detect-virt") == 0 ||
+           strcmp(base, "dmidecode") == 0 || strcmp(base, "lscpu") == 0;
+}
+
+typedef int (*open_fn)(const char *, int, ...);
+typedef int (*openat_fn)(int, const char *, int, ...);
+typedef FILE *(*fopen_fn)(const char *, const char *);
+typedef int (*stat_fn)(const char *, struct stat *);
+typedef int (*lstat_fn)(const char *, struct stat *);
+typedef int (*stat64_fn)(const char *, struct stat64 *);
+typedef int (*lstat64_fn)(const char *, struct stat64 *);
+typedef int (*fstatat_fn)(int, const char *, struct stat *, int);
+typedef int (*xstat_fn)(int, const char *, struct stat *);
+typedef int (*lxstat_fn)(int, const char *, struct stat *);
+typedef int (*xstat64_fn)(int, const char *, struct stat64 *);
+typedef int (*lxstat64_fn)(int, const char *, struct stat64 *);
+typedef int (*statx_fn)(int, const char *, int, unsigned int, struct statx *);
+typedef int (*access_fn)(const char *, int);
+typedef char *(*getenv_fn)(const char *);
+typedef int (*execve_fn)(const char *, char *const[], char *const[]);
+
+#define RESOLVE_OR(name, type, fallback) \
+    static type real_##name = NULL; \
+    if (real_##name == NULL) { real_##name = (type)dlsym(RTLD_NEXT, #name); } \
+    if (real_##name == NULL) { errno = ENOSYS; return fallback; }
+
+static int do_open(const char *path, int flags, mode_t mode) {
+    log_path_access(path, flags, reads_content(flags));
+    if (is_dockerenv(path)) {
+        errno = ENOENT;
+        return -1;
+    }
+    RESOLVE_OR(open, open_fn, -1);
+    return real_open(redirect_path(path), flags, mode);
+}
+
+int open(const char *path, int flags, ...) {
+    mode_t mode = 0;
+    if (flags & O_CREAT) {
+        va_list args;
+        va_start(args, flags);
+        mode = (mode_t)va_arg(args, int);
+        va_end(args);
+    }
+    return do_open(path, flags, mode);
+}
+
+int open64(const char *path, int flags, ...) {
+    mode_t mode = 0;
+    if (flags & O_CREAT) {
+        va_list args;
+        va_start(args, flags);
+        mode = (mode_t)va_arg(args, int);
+        va_end(args);
+    }
+    return do_open(path, flags, mode);
+}
+
+int openat(int dirfd, const char *path, int flags, ...) {
+    mode_t mode = 0;
+    if (flags & O_CREAT) {
+        va_list args;
+        va_start(args, flags);
+        mode = (mode_t)va_arg(args, int);
+        va_end(args);
+    }
+    log_path_access(path, flags, reads_content(flags));
+    if (is_dockerenv(path)) {
+        errno = ENOENT;
+        return -1;
+    }
+    RESOLVE_OR(openat, openat_fn, -1);
+    return real_openat(dirfd, redirect_path(path), flags, mode);
+}
+
+int openat64(int dirfd, const char *path, int flags, ...) {
+    mode_t mode = 0;
+    if (flags & O_CREAT) {
+        va_list args;
+        va_start(args, flags);
+        mode = (mode_t)va_arg(args, int);
+        va_end(args);
+    }
+    log_path_access(path, flags, reads_content(flags));
+    if (is_dockerenv(path)) {
+        errno = ENOENT;
+        return -1;
+    }
+    RESOLVE_OR(openat, openat_fn, -1);
+    return real_openat(dirfd, redirect_path(path), flags, mode);
+}
+
+FILE *fopen(const char *path, const char *mode) {
+    int is_read = mode != NULL && (mode[0] == 'r' || strchr(mode, '+') != NULL);
+    log_path_access(path, O_RDONLY, is_read);
+    if (is_dockerenv(path)) {
+        errno = ENOENT;
+        return NULL;
+    }
+    RESOLVE_OR(fopen, fopen_fn, NULL);
+    return real_fopen(redirect_path(path), mode);
+}
+
+FILE *fopen64(const char *path, const char *mode) {
+    return fopen(path, mode);
+}
+
+int stat(const char *path, struct stat *buf) {
+    log_path_access(path, O_RDONLY, 0);
+    if (is_dockerenv(path)) {
+        errno = ENOENT;
+        return -1;
+    }
+    RESOLVE_OR(stat, stat_fn, -1);
+    return real_stat(redirect_path(path), buf);
+}
+
+int lstat(const char *path, struct stat *buf) {
+    log_path_access(path, O_RDONLY, 0);
+    if (is_dockerenv(path)) {
+        errno = ENOENT;
+        return -1;
+    }
+    RESOLVE_OR(lstat, lstat_fn, -1);
+    return real_lstat(redirect_path(path), buf);
+}
+
+/* glibc and dash may call the large-file or versioned stat entry points
+ * instead of stat()/lstat().  Without these wrappers a plain shell
+ * ``test -e /.dockerenv`` bypasses the masquerade. */
+int stat64(const char *path, struct stat64 *buf) {
+    log_path_access(path, O_RDONLY, 0);
+    if (is_dockerenv(path)) {
+        errno = ENOENT;
+        return -1;
+    }
+    RESOLVE_OR(stat64, stat64_fn, -1);
+    return real_stat64(redirect_path(path), buf);
+}
+
+int lstat64(const char *path, struct stat64 *buf) {
+    log_path_access(path, O_RDONLY, 0);
+    if (is_dockerenv(path)) {
+        errno = ENOENT;
+        return -1;
+    }
+    RESOLVE_OR(lstat64, lstat64_fn, -1);
+    return real_lstat64(redirect_path(path), buf);
+}
+
+int fstatat(int dirfd, const char *path, struct stat *buf, int flags) {
+    log_path_access(path, O_RDONLY, 0);
+    if (is_dockerenv(path)) {
+        errno = ENOENT;
+        return -1;
+    }
+    RESOLVE_OR(fstatat, fstatat_fn, -1);
+    return real_fstatat(dirfd, redirect_path(path), buf, flags);
+}
+
+int newfstatat(int dirfd, const char *path, struct stat *buf, int flags) {
+    return fstatat(dirfd, path, buf, flags);
+}
+
+int statx(int dirfd, const char *path, int flags, unsigned int mask, struct statx *buf) {
+    log_path_access(path, O_RDONLY, 0);
+    if (is_dockerenv(path)) {
+        errno = ENOENT;
+        return -1;
+    }
+    RESOLVE_OR(statx, statx_fn, -1);
+    return real_statx(dirfd, redirect_path(path), flags, mask, buf);
+}
+
+int __xstat(int version, const char *path, struct stat *buf) {
+    log_path_access(path, O_RDONLY, 0);
+    if (is_dockerenv(path)) {
+        errno = ENOENT;
+        return -1;
+    }
+    RESOLVE_OR(__xstat, xstat_fn, -1);
+    return real___xstat(version, redirect_path(path), buf);
+}
+
+int __lxstat(int version, const char *path, struct stat *buf) {
+    log_path_access(path, O_RDONLY, 0);
+    if (is_dockerenv(path)) {
+        errno = ENOENT;
+        return -1;
+    }
+    RESOLVE_OR(__lxstat, lxstat_fn, -1);
+    return real___lxstat(version, redirect_path(path), buf);
+}
+
+int __xstat64(int version, const char *path, struct stat64 *buf) {
+    log_path_access(path, O_RDONLY, 0);
+    if (is_dockerenv(path)) {
+        errno = ENOENT;
+        return -1;
+    }
+    RESOLVE_OR(__xstat64, xstat64_fn, -1);
+    return real___xstat64(version, redirect_path(path), buf);
+}
+
+int __lxstat64(int version, const char *path, struct stat64 *buf) {
+    log_path_access(path, O_RDONLY, 0);
+    if (is_dockerenv(path)) {
+        errno = ENOENT;
+        return -1;
+    }
+    RESOLVE_OR(__lxstat64, lxstat64_fn, -1);
+    return real___lxstat64(version, redirect_path(path), buf);
+}
+
+int access(const char *path, int mode) {
+    log_path_access(path, O_RDONLY, 0);
+    if (is_dockerenv(path)) {
+        errno = ENOENT;
+        return -1;
+    }
+    RESOLVE_OR(access, access_fn, -1);
+    return real_access(redirect_path(path), mode);
+}
+
+int faccessat(int dirfd, const char *path, int mode, int flags) {
+    (void)dirfd;
+    (void)flags;
+    return access(path, mode);
+}
+
+char *getenv(const char *name) {
+    RESOLVE_OR(getenv, getenv_fn, NULL);
+    char *value = real_getenv(name);
+    if (value != NULL && strstr(value, "SKS") != NULL) {
+        char marker[14];
+        marker_from(value, marker);
+        if (marker[0] != '\0') {
+            char path[256];
+            snprintf(path, sizeof(path), "env:%s", name == NULL ? "" : name);
+            log_event("canary_read", path, marker, "env", 1);
+        }
+    }
+    return value;
+}
+
+char *secure_getenv(const char *name) {
+    return getenv(name);
+}
+
+int execve(const char *path, char *const argv[], char *const envp[]) {
+    (void)argv;
+    (void)envp;
+    if (is_command_probe(path)) {
+        log_event("probe_detected", path, NULL, "command", 0);
+    }
+    RESOLVE_OR(execve, execve_fn, -1);
+    return real_execve(path, argv, envp);
+}

skill_sentry_cli/core/sandbox/assets/run_skill.sh

@@ -0,0 +1,41 @@
+#!/bin/sh
+# Skill entrypoint used when the package does not supply an explicit command.
+# The runner uploads this file into the container's writable /tmp tmpfs.
+set -u
+umask 077
+export HOME="${HOME:-/home/sandbox}"
+cd /skill || exit 1
+
+# A declared entrypoint is authoritative.  Never fall through to a different
+# script (or exit 0) when the manifest asked for something that is missing.
+if [ -n "${SKILLSENTRY_ENTRYPOINT:-}" ]; then
+    if [ ! -f "$SKILLSENTRY_ENTRYPOINT" ]; then
+        echo "skillsentry: declared entrypoint not found: $SKILLSENTRY_ENTRYPOINT" >&2
+        exit 127
+    fi
+    # Args are deliberately word-split here: the manifest is untrusted and the
+    # sandbox is the execution boundary.  The engine prefers an explicit argv
+    # and only uses this path for compatibility.
+    # shellcheck disable=SC2086
+    exec "$SKILLSENTRY_ENTRYPOINT" ${SKILLSENTRY_ENTRYPOINT_ARGS:-}
+fi
+
+if [ "${SKILLSENTRY_DECLARED_ENTRYPOINT:-0}" = "1" ]; then
+    echo "skillsentry: manifest declared an entrypoint but no command was supplied" >&2
+    exit 127
+fi
+
+if [ -x ./scripts/run.sh ]; then
+    exec ./scripts/run.sh "$@"
+fi
+if [ -x ./run.sh ]; then
+    exec ./run.sh "$@"
+fi
+if [ -f ./scripts/run.py ]; then
+    exec python ./scripts/run.py "$@"
+fi
+if [ -f ./main.py ]; then
+    exec python ./main.py "$@"
+fi
+# A package with only a SKILL.md is a valid, inert skill.
+exit 0

skill_sentry_cli/core/sandbox/assets/sinkhole_sidecar.py

@@ -0,0 +1,171 @@
+"""Inert DNS + HTTP sinkhole sidecar (stdlib only, runs inside Docker)."""
+
+from __future__ import annotations
+
+import base64
+import contextlib
+import json
+import os
+import socket
+import struct
+import sys
+import threading
+from datetime import UTC, datetime
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+ANSWER_IP = os.environ.get("SKILLSENTRY_SIDECAR_IP", "172.30.77.2")
+DNS_PORT = int(os.environ.get("SKILLSENTRY_DNS_PORT", "53"))
+HTTP_PORT = int(os.environ.get("SKILLSENTRY_HTTP_PORT", "80"))
+MAX_BODY = 2_000_000
+
+
+def _stamp() -> str:
+    now = datetime.now(UTC)
+    return now.strftime("%Y-%m-%dT%H:%M:%S.") + f"{now.microsecond // 1000:03d}Z"
+
+
+def _emit(payload: dict) -> None:
+    sys.stdout.write(json.dumps(payload, separators=(",", ":")) + "\n")
+    sys.stdout.flush()
+
+
+def _question_end(data: bytes) -> int | None:
+    if len(data) < 12:
+        return None
+    offset = 12
+    while offset < len(data):
+        length = data[offset]
+        offset += 1
+        if length == 0:
+            return offset + 4 if offset + 4 <= len(data) else None
+        if length & 0xC0 or offset + length > len(data):
+            return None
+        offset += length
+    return None
+
+
+def _qname(data: bytes) -> str:
+    labels: list[str] = []
+    offset = 12
+    while offset < len(data):
+        length = data[offset]
+        offset += 1
+        if length == 0:
+            break
+        if length & 0xC0 or offset + length > len(data):
+            return ""
+        labels.append(data[offset : offset + length].decode("ascii", "replace"))
+        offset += length
+    return ".".join(labels) or "."
+
+
+def _response(query: bytes) -> bytes:
+    if len(query) < 12:
+        return b""
+    end = _question_end(query)
+    if end is None:
+        return b""
+    qtype = struct.unpack("!H", query[end - 4 : end - 2])[0]
+    answer = b""
+    ancount = 0
+    if qtype == 1:
+        try:
+            packed = socket.inet_aton(ANSWER_IP)
+        except OSError:
+            packed = b"\xac\x1eM\x02"
+        answer = b"\xc0\x0c" + struct.pack("!HHIH", 1, 1, 60, 4) + packed
+        ancount = 1
+    flags = 0x8000 | 0x0100 | 0x0080
+    return query[:2] + struct.pack("!HHHHH", flags, 1, ancount, 0, 0) + query[12:end] + answer
+
+
+def dns_loop(sock: socket.socket | None = None) -> None:
+    if sock is None:
+        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        sock.bind(("0.0.0.0", DNS_PORT))
+    while True:
+        try:
+            data, peer = sock.recvfrom(4096)
+        except OSError:
+            continue
+        qname = _qname(data)
+        if not qname:
+            continue
+        end = _question_end(data)
+        qtype = struct.unpack("!H", data[end - 4 : end - 2])[0] if end else 0
+        _emit(
+            {
+                "ts": _stamp(),
+                "protocol": "dns",
+                "query_or_url": qname[:4096],
+                "body_b64": base64.b64encode(data[:MAX_BODY]).decode("ascii"),
+                "headers": {},
+                "client": f"{peer[0]}:{peer[1]}",
+                "responder_action": "fake-A" if qtype == 1 else "NOERROR",
+            }
+        )
+        with contextlib.suppress(OSError):
+            sock.sendto(_response(data), peer)
+
+
+class Handler(BaseHTTPRequestHandler):
+    def log_message(self, fmt, *args):
+        return
+
+    def _handle(self) -> None:
+        raw_length = self.headers.get("Content-Length", "0")
+        try:
+            length = max(0, min(int(raw_length), MAX_BODY))
+        except ValueError:
+            length = 0
+        body = self.rfile.read(length) if length else b""
+        host = self.headers.get("Host", "")
+        url = f"http://{host}{self.path}" if host else self.path
+        _emit(
+            {
+                "ts": _stamp(),
+                "protocol": "http",
+                "query_or_url": f"{self.command} {url}"[:4096],
+                "body_b64": base64.b64encode(body).decode("ascii") if body else None,
+                "headers": {str(k)[:100]: str(v)[:1000] for k, v in self.headers.items()},
+                "client": f"{self.client_address[0]}:{self.client_address[1]}",
+                "responder_action": "200+secondary",
+            }
+        )
+        encoded = b'{"status":"ok","data":"inert"}'
+        self.send_response(200)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(encoded)))
+        self.send_header("Connection", "close")
+        self.end_headers()
+        self.wfile.write(encoded)
+
+    do_GET = _handle
+    do_POST = _handle
+    do_PUT = _handle
+    do_PATCH = _handle
+    do_DELETE = _handle
+    do_HEAD = _handle
+
+
+def main() -> None:
+    dns_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    dns_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    dns_sock.bind(("0.0.0.0", DNS_PORT))
+    threading.Thread(target=dns_loop, args=(dns_sock,), daemon=True).start()
+    server = ThreadingHTTPServer(("0.0.0.0", HTTP_PORT), Handler)
+    server.daemon_threads = True
+    _emit(
+        {
+            "event": "ready",
+            "dns_port": DNS_PORT,
+            "http_port": HTTP_PORT,
+            "ip": ANSWER_IP,
+        }
+    )
+    server.serve_forever()
+
+
+if __name__ == "__main__":
+    main()