pyscriptc 0.1.0__py3-none-any.whl

pyscriptc/runtime/ps_hmac.c

@@ -0,0 +1,120 @@
+/* HMAC-MD5, SHA-1, SHA-256, SHA-384, and SHA-512.
+
+One call hashes the token. The block transform is the same code hashlib
+already uses. compare_digest is constant time when the lengths match.
+*/
+
+#include "ps_rt.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+extern PsBuf *ps_hash_md5(int64_t n, char *p);
+extern PsBuf *ps_hash_sha1(int64_t n, char *p);
+extern PsBuf *ps_hash_sha256(int64_t n, char *p);
+extern PsBuf *ps_hash_sha384(int64_t n, char *p);
+extern PsBuf *ps_hash_sha512(int64_t n, char *p);
+
+typedef struct PsHmac {
+    PsBuf key;
+    PsBuf msg;
+    int64_t alg;
+} PsHmac;
+
+static PsBuf *(*ps_hmac_hash(int64_t alg))(int64_t, char *) {
+    if (alg == 1) {
+        return ps_hash_md5;
+    }
+    if (alg == 2) {
+        return ps_hash_sha1;
+    }
+    if (alg == 3) {
+        return ps_hash_sha256;
+    }
+    if (alg == 4) {
+        return ps_hash_sha384;
+    }
+    if (alg == 5) {
+        return ps_hash_sha512;
+    }
+    ps_raise_cstr(PS_VALUE, "hmac algorithm is md5, sha1, sha256, sha384, or sha512");
+}
+
+static int ps_hmac_block(int64_t alg) {
+    if (alg == 4 || alg == 5) {
+        return 128;
+    }
+    return 64;
+}
+
+static void ps_hmac_mac(int64_t alg, const char *key, int64_t kn, const char *msg, int64_t mn, PsBuf *out) {
+    PsBuf *(*hash)(int64_t, char *) = ps_hmac_hash(alg);
+    int block = ps_hmac_block(alg);
+    uint8_t *pad;
+    uint8_t *inner;
+    uint8_t *keyed;
+    PsBuf *core;
+    PsBuf *digest;
+    int i;
+    if (kn > block) {
+        core = hash(kn, (char *)key);
+        kn = core->len;
+        key = core->data;
+    }
+    keyed = malloc((size_t)block);
+    inner = malloc((size_t)block + (size_t)mn);
+    if (keyed == NULL || inner == NULL) {
+        abort();
+    }
+    memset(keyed, 0, (size_t)block);
+    if (kn > 0) {
+        memcpy(keyed, key, (size_t)kn);
+    }
+    for (i = 0; i < block; i++) {
+        inner[i] = (uint8_t)(keyed[i] ^ 0x36);
+    }
+    if (mn > 0) {
+        memcpy(inner + block, msg, (size_t)mn);
+    }
+    core = hash((int64_t)block + mn, (char *)inner);
+    pad = malloc((size_t)block + (size_t)core->len);
+    if (pad == NULL) {
+        abort();
+    }
+    for (i = 0; i < block; i++) {
+        pad[i] = (uint8_t)(keyed[i] ^ 0x5c);
+    }
+    memcpy(pad + block, core->data, (size_t)core->len);
+    digest = hash((int64_t)block + core->len, (char *)pad);
+    ps_buf_copy(out, digest->data, digest->len);
+    free(keyed);
+    free(inner);
+    free(pad);
+}
+
+void ps_hmac_digest(int64_t kn, const char *key, int64_t mn, const char *msg, int64_t alg, PsBuf *out) {
+    ps_hmac_mac(alg, key, kn, msg, mn, out);
+}
+
+void ps_hmac_new(int64_t kn, const char *key, int64_t mn, const char *msg, int64_t alg, PsHmac *out) {
+    ps_hmac_hash(alg);
+    ps_buf_copy(&out->key, key, kn);
+    ps_buf_copy(&out->msg, msg, mn);
+    out->alg = alg;
+}
+
+void ps_hmac_finish(PsHmac *box, PsBuf *out) {
+    ps_hmac_mac(box->alg, box->key.data, box->key.len, box->msg.data, box->msg.len, out);
+}
+
+int32_t ps_hmac_compare(int64_t an, const char *a, int64_t bn, const char *b) {
+    unsigned char diff = 0;
+    int64_t i;
+    if (an != bn) {
+        return 0;
+    }
+    for (i = 0; i < an; i++) {
+        diff = (unsigned char)(diff | ((unsigned char)a[i] ^ (unsigned char)b[i]));
+    }
+    return diff == 0;
+}

pyscriptc/runtime/ps_io.c

@@ -0,0 +1,198 @@
+/* io.StringIO, io.BytesIO, and builtin open.
+
+Memory buffers start at position 0, so read() returns the initial value.
+File writes are flushed so a later open sees them. OS errors are RuntimeError.
+*/
+
+#include "ps_rt.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct PsIO {
+    int32_t kind;
+    int32_t closed;
+    PsGrow mem;
+    int64_t pos;
+    FILE *fp;
+} PsIO;
+
+static PsIO *ps_blank(int kind) {
+    PsIO *io = calloc(1, sizeof(PsIO));
+    if (io == NULL) {
+        abort();
+    }
+    io->kind = kind;
+    ps_grow_init(&io->mem);
+    return io;
+}
+
+static void ps_open_check(PsIO *io) {
+    if (io == NULL || io->closed) {
+        ps_raise_cstr(PS_VALUE, "I/O operation on closed file");
+    }
+}
+
+PsIO *ps_io_string(int64_t n, const char *s) {
+    PsIO *io = ps_blank(1);
+    if (n > 0) {
+        ps_grow_add(&io->mem, s, n);
+    }
+    return io;
+}
+
+PsIO *ps_io_bytes(int64_t n, const char *s) {
+    PsIO *io = ps_blank(2);
+    if (n > 0) {
+        ps_grow_add(&io->mem, s, n);
+    }
+    return io;
+}
+
+PsIO *ps_io_open(int64_t n, const char *path, int64_t mode) {
+    const char *how = NULL;
+    int kind = 3;
+    char *text;
+    FILE *fp;
+    PsIO *io;
+    if (mode == 1) {
+        how = "r";
+    } else if (mode == 2) {
+        how = "w";
+    } else if (mode == 3) {
+        how = "rb";
+        kind = 4;
+    } else if (mode == 4) {
+        how = "wb";
+        kind = 4;
+    } else if (mode == 5) {
+        how = "a";
+    } else if (mode == 6) {
+        how = "ab";
+        kind = 4;
+    } else {
+        ps_raise_cstr(PS_VALUE, "open mode is not lowered");
+    }
+    text = malloc((size_t)n + 1);
+    if (text == NULL) {
+        abort();
+    }
+    if (n > 0) {
+        memcpy(text, path, (size_t)n);
+    }
+    text[n] = '\0';
+    fp = fopen(text, how);
+    free(text);
+    if (fp == NULL) {
+        ps_raise_cstr(PS_RUNTIME, "open failed");
+    }
+    io = ps_blank(kind);
+    io->fp = fp;
+    return io;
+}
+
+static int ps_can_read(PsIO *io) {
+    if (io->kind == 1 || io->kind == 2) {
+        return 1;
+    }
+    return io->fp != NULL;
+}
+
+void ps_io_read(PsIO *io, PsBuf *out) {
+    ps_open_check(io);
+    if (!ps_can_read(io)) {
+        ps_raise_cstr(PS_VALUE, "read failed");
+    }
+    if (io->fp != NULL) {
+        long size;
+        char *buf;
+        if (fseek(io->fp, 0, SEEK_END) != 0) {
+            ps_raise_cstr(PS_RUNTIME, "read failed");
+        }
+        size = ftell(io->fp);
+        if (size < 0 || fseek(io->fp, 0, SEEK_SET) != 0) {
+            ps_raise_cstr(PS_RUNTIME, "read failed");
+        }
+        buf = malloc((size_t)size + 1);
+        if (buf == NULL) {
+            abort();
+        }
+        if (size > 0 && fread(buf, 1, (size_t)size, io->fp) != (size_t)size) {
+            free(buf);
+            ps_raise_cstr(PS_RUNTIME, "read failed");
+        }
+        buf[size] = '\0';
+        out->len = size;
+        out->data = buf;
+        return;
+    }
+    if (io->pos > io->mem.len) {
+        io->pos = io->mem.len;
+    }
+    ps_buf_copy(out, io->mem.data == NULL ? "" : io->mem.data + io->pos, io->mem.len - io->pos);
+    io->pos = io->mem.len;
+}
+
+int64_t ps_io_write(PsIO *io, int64_t n, const char *s) {
+    ps_open_check(io);
+    if (n < 0) {
+        ps_raise_code(PS_VALUE);
+    }
+    if (io->fp != NULL) {
+        if (n > 0 && fwrite(s, 1, (size_t)n, io->fp) != (size_t)n) {
+            ps_raise_cstr(PS_RUNTIME, "write failed");
+        }
+        if (fflush(io->fp) != 0) {
+            ps_raise_cstr(PS_RUNTIME, "write failed");
+        }
+        return n;
+    }
+    if (io->pos > io->mem.len) {
+        while (io->mem.len < io->pos) {
+            ps_grow_byte(&io->mem, '\0');
+        }
+    }
+    if (io->pos == io->mem.len) {
+        ps_grow_add(&io->mem, s, n);
+        io->pos = io->mem.len;
+        return n;
+    }
+    if (io->mem.cap < io->pos + n + 1) {
+        ps_grow_add(&io->mem, "", 0);
+        while (io->mem.cap < io->pos + n + 1) {
+            ps_grow_byte(&io->mem, '\0');
+            io->mem.len -= 1;
+        }
+    }
+    if (n > 0) {
+        memcpy(io->mem.data + io->pos, s, (size_t)n);
+    }
+    if (io->pos + n > io->mem.len) {
+        io->mem.len = io->pos + n;
+        io->mem.data[io->mem.len] = '\0';
+    }
+    io->pos += n;
+    return n;
+}
+
+void ps_io_close(PsIO *io) {
+    if (io->closed) {
+        return;
+    }
+    if (io->fp != NULL && fclose(io->fp) != 0) {
+        io->fp = NULL;
+        io->closed = 1;
+        ps_raise_cstr(PS_RUNTIME, "close failed");
+    }
+    io->fp = NULL;
+    io->closed = 1;
+}
+
+void ps_io_value(PsIO *io, PsBuf *out) {
+    ps_open_check(io);
+    if (io->fp != NULL) {
+        ps_raise_cstr(PS_VALUE, "getvalue is lowered for StringIO and BytesIO");
+    }
+    ps_buf_copy(out, io->mem.data == NULL ? "" : io->mem.data, io->mem.len);
+}

pyscriptc/runtime/ps_island.c

@@ -0,0 +1,272 @@
+/* Embedded CPython for the island modules.
+
+Linked only when the LLVM text calls one of these symbols. Py_InitializeEx
+runs on the first call, not at process start. Arguments and results stay in
+the scalar, str, bytes, and list set the rest of the runtime already uses.
+*/
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+
+#include "ps_rt.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+static void ps_island_fail(void) {
+    PyObject *typ = NULL;
+    PyObject *val = NULL;
+    PyObject *tb = NULL;
+    PyObject *text = NULL;
+    const char *msg = "island call failed";
+    PyErr_Fetch(&typ, &val, &tb);
+    PyErr_NormalizeException(&typ, &val, &tb);
+    if (val != NULL) {
+        text = PyObject_Str(val);
+        if (text != NULL) {
+            const char *got = PyUnicode_AsUTF8(text);
+            if (got != NULL) {
+                msg = got;
+            }
+        }
+    }
+    ps_raise_cstr(PS_RUNTIME, msg);
+}
+
+static void ps_island_ensure(void) {
+    if (Py_IsInitialized()) {
+        return;
+    }
+    Py_InitializeEx(0);
+    if (!Py_IsInitialized()) {
+        ps_raise_cstr(PS_RUNTIME, "CPython island failed to initialize");
+    }
+}
+
+static PyObject *ps_import(const char *name) {
+    PyObject *mod = PyImport_ImportModule(name);
+    if (mod == NULL) {
+        ps_island_fail();
+    }
+    return mod;
+}
+
+static void ps_take_unicode(PyObject *obj, PsBuf *out) {
+    Py_ssize_t n = 0;
+    const char *s = PyUnicode_AsUTF8AndSize(obj, &n);
+    if (s == NULL) {
+        ps_island_fail();
+    }
+    ps_buf_copy(out, s, (int64_t)n);
+}
+
+static void ps_take_bytes(PyObject *obj, PsBuf *out) {
+    char *s = NULL;
+    Py_ssize_t n = 0;
+    if (PyBytes_AsStringAndSize(obj, &s, &n) < 0) {
+        ps_island_fail();
+    }
+    ps_buf_copy(out, s, (int64_t)n);
+}
+
+void ps_island_check_output(PsSeq *args, PsBuf *out) {
+    PyObject *mod;
+    PyObject *fn;
+    PyObject *list;
+    PyObject *result;
+    int64_t i;
+    ps_island_ensure();
+    list = PyList_New((Py_ssize_t)args->len);
+    if (list == NULL) {
+        ps_island_fail();
+    }
+    for (i = 0; i < args->len; i++) {
+        PsBuf item;
+        PyObject *text;
+        memcpy(&item, (char *)args->data + (size_t)i * (size_t)args->elem, sizeof item);
+        text = PyUnicode_FromStringAndSize(item.data, (Py_ssize_t)item.len);
+        if (text == NULL || PyList_SetItem(list, (Py_ssize_t)i, text) < 0) {
+            ps_island_fail();
+        }
+    }
+    mod = ps_import("subprocess");
+    fn = PyObject_GetAttrString(mod, "check_output");
+    Py_DECREF(mod);
+    if (fn == NULL) {
+        Py_DECREF(list);
+        ps_island_fail();
+    }
+    result = PyObject_CallFunctionObjArgs(fn, list, NULL);
+    Py_DECREF(fn);
+    Py_DECREF(list);
+    if (result == NULL) {
+        ps_island_fail();
+    }
+    ps_take_bytes(result, out);
+    Py_DECREF(result);
+}
+
+void ps_island_hostname(PsBuf *out) {
+    PyObject *mod;
+    PyObject *result;
+    ps_island_ensure();
+    mod = ps_import("socket");
+    result = PyObject_CallMethod(mod, "gethostname", NULL);
+    Py_DECREF(mod);
+    if (result == NULL) {
+        ps_island_fail();
+    }
+    ps_take_unicode(result, out);
+    Py_DECREF(result);
+}
+
+int64_t ps_island_threads(void) {
+    PyObject *mod;
+    PyObject *result;
+    long value;
+    ps_island_ensure();
+    mod = ps_import("threading");
+    result = PyObject_CallMethod(mod, "active_count", NULL);
+    Py_DECREF(mod);
+    if (result == NULL) {
+        ps_island_fail();
+    }
+    value = PyLong_AsLong(result);
+    Py_DECREF(result);
+    if (value == -1 && PyErr_Occurred()) {
+        ps_island_fail();
+    }
+    return (int64_t)value;
+}
+
+void ps_island_thread_name(PsBuf *out) {
+    PyObject *mod;
+    PyObject *thread;
+    PyObject *name;
+    ps_island_ensure();
+    mod = ps_import("threading");
+    thread = PyObject_CallMethod(mod, "current_thread", NULL);
+    Py_DECREF(mod);
+    if (thread == NULL) {
+        ps_island_fail();
+    }
+    name = PyObject_GetAttrString(thread, "name");
+    Py_DECREF(thread);
+    if (name == NULL) {
+        ps_island_fail();
+    }
+    ps_take_unicode(name, out);
+    Py_DECREF(name);
+}
+
+void ps_island_cleandoc(int64_t n, const char *s, PsBuf *out) {
+    PyObject *mod;
+    PyObject *fn;
+    PyObject *text;
+    PyObject *result;
+    ps_island_ensure();
+    mod = ps_import("inspect");
+    fn = PyObject_GetAttrString(mod, "cleandoc");
+    Py_DECREF(mod);
+    if (fn == NULL) {
+        ps_island_fail();
+    }
+    text = PyUnicode_FromStringAndSize(s, (Py_ssize_t)n);
+    if (text == NULL) {
+        Py_DECREF(fn);
+        ps_island_fail();
+    }
+    result = PyObject_CallFunctionObjArgs(fn, text, NULL);
+    Py_DECREF(fn);
+    Py_DECREF(text);
+    if (result == NULL) {
+        ps_island_fail();
+    }
+    ps_take_unicode(result, out);
+    Py_DECREF(result);
+}
+
+static void ps_island_log(const char *level, int64_t n, const char *s) {
+    PyObject *mod;
+    PyObject *fn;
+    PyObject *text;
+    PyObject *result;
+    ps_island_ensure();
+    mod = ps_import("logging");
+    fn = PyObject_GetAttrString(mod, level);
+    Py_DECREF(mod);
+    if (fn == NULL) {
+        ps_island_fail();
+    }
+    text = PyUnicode_FromStringAndSize(s, (Py_ssize_t)n);
+    if (text == NULL) {
+        Py_DECREF(fn);
+        ps_island_fail();
+    }
+    result = PyObject_CallFunctionObjArgs(fn, text, NULL);
+    Py_DECREF(fn);
+    Py_DECREF(text);
+    Py_XDECREF(result);
+    if (result == NULL) {
+        ps_island_fail();
+    }
+}
+
+void ps_island_log_info(int64_t n, const char *s) { ps_island_log("info", n, s); }
+
+void ps_island_log_warning(int64_t n, const char *s) { ps_island_log("warning", n, s); }
+
+/* nativeprobe is a PyInit_* extension over libmix. Embedded CPython loads
+   it the same way a normal interpreter does. The direct path is ps_mix.c. */
+
+static int64_t ps_island_mix_call(const char *name, int64_t n, const char *data, int64_t times, int with_times) {
+    PyObject *mod;
+    PyObject *fn;
+    PyObject *buf;
+    PyObject *result;
+    PyObject *count;
+    int64_t value;
+    ps_island_ensure();
+    mod = ps_import("nativeprobe");
+    fn = PyObject_GetAttrString(mod, name);
+    Py_DECREF(mod);
+    if (fn == NULL) {
+        ps_island_fail();
+    }
+    buf = PyBytes_FromStringAndSize(data, (Py_ssize_t)n);
+    if (buf == NULL) {
+        Py_DECREF(fn);
+        ps_island_fail();
+    }
+    if (with_times) {
+        count = PyLong_FromLongLong(times);
+        if (count == NULL) {
+            Py_DECREF(fn);
+            Py_DECREF(buf);
+            ps_island_fail();
+        }
+        result = PyObject_CallFunctionObjArgs(fn, buf, count, NULL);
+        Py_DECREF(count);
+    } else {
+        result = PyObject_CallFunctionObjArgs(fn, buf, NULL);
+    }
+    Py_DECREF(fn);
+    Py_DECREF(buf);
+    if (result == NULL) {
+        ps_island_fail();
+    }
+    value = PyLong_AsLongLong(result);
+    Py_DECREF(result);
+    if (value == -1 && PyErr_Occurred()) {
+        ps_island_fail();
+    }
+    return value;
+}
+
+int64_t ps_island_mix_crc32(int64_t n, const char *data) {
+    return ps_island_mix_call("crc32", n, data, 0, 0);
+}
+
+int64_t ps_island_mix_crc32_n(int64_t n, const char *data, int64_t times) {
+    return ps_island_mix_call("crc32_n", n, data, times, 1);
+}