secrets-plus 0.1.0__tar.gz

secrets_plus-0.1.0/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: secrets-plus
+Version: 0.1.0
+Summary: Windows BCrypt 加密安全随机数C扩展，与secrets接口完全一致
+Author: Tevend_geven
+Author-email: yanxiao_feng2013@163.com
+License: MIT
+Platform: Windows
+Classifier: Programming Language :: C
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Topic :: Security :: Cryptography
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license
+Dynamic: platform
+Dynamic: requires-python
+Dynamic: summary
+
+# token-gen-win
+Windows平台专用高性能C扩展，基于系统原生 **BCrypt API** 实现加密安全随机数，完整复刻Python标准库 `secrets` 常用接口，性能优于原生Python实现。
+
+## 平台限制
+**仅支持 Windows 系统**
+Linux / macOS 无系统BCrypt依赖库，无法编译、安装。
+
+## 功能列表
+完全对齐标准库 secrets 接口：
+- `token_bytes()`：生成随机字节串
+- `token_hex()`：生成十六进制随机令牌
+- `token_urlsafe()`：生成URL安全随机令牌
+- `randbelow()`：生成指定上界安全随机整数
+- `randbits()`：生成指定比特位随机数
+- `choice()`：从序列随机选取元素
+- `shuffle()`：原地随机打乱序列
+
+## 安装方式
+```bash
+pip install token-gen
+```
+
+## 快速使用
+```python
+import token_gen
+
+# 生成各类安全令牌
+print(token_gen.token_urlsafe())
+print(token_gen.token_hex(16))
+print(token_gen.token_bytes(32))
+
+# 随机数工具
+print(token_gen.randbelow(1000))
+print(token_gen.randbits(12))
+
+# 序列操作
+lst = [1,2,3,4,5]
+print(token_gen.choice(lst))
+token_gen.shuffle(lst)
+print(lst)
+```
+
+## 注意事项
+1. 基于栈分配实现，不支持超大长度随机数生成（建议单次长度不超过1024），避免栈溢出
+2. 长期后台运行存在轻微BCrypt句柄残留，短期脚本使用无任何影响

secrets_plus-0.1.0/README.md

@@ -0,0 +1,45 @@
+# token-gen-win
+Windows平台专用高性能C扩展，基于系统原生 **BCrypt API** 实现加密安全随机数，完整复刻Python标准库 `secrets` 常用接口，性能优于原生Python实现。
+
+## 平台限制
+**仅支持 Windows 系统**
+Linux / macOS 无系统BCrypt依赖库，无法编译、安装。
+
+## 功能列表
+完全对齐标准库 secrets 接口：
+- `token_bytes()`：生成随机字节串
+- `token_hex()`：生成十六进制随机令牌
+- `token_urlsafe()`：生成URL安全随机令牌
+- `randbelow()`：生成指定上界安全随机整数
+- `randbits()`：生成指定比特位随机数
+- `choice()`：从序列随机选取元素
+- `shuffle()`：原地随机打乱序列
+
+## 安装方式
+```bash
+pip install token-gen
+```
+
+## 快速使用
+```python
+import token_gen
+
+# 生成各类安全令牌
+print(token_gen.token_urlsafe())
+print(token_gen.token_hex(16))
+print(token_gen.token_bytes(32))
+
+# 随机数工具
+print(token_gen.randbelow(1000))
+print(token_gen.randbits(12))
+
+# 序列操作
+lst = [1,2,3,4,5]
+print(token_gen.choice(lst))
+token_gen.shuffle(lst)
+print(lst)
+```
+
+## 注意事项
+1. 基于栈分配实现，不支持超大长度随机数生成（建议单次长度不超过1024），避免栈溢出
+2. 长期后台运行存在轻微BCrypt句柄残留，短期脚本使用无任何影响

secrets_plus-0.1.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"

secrets_plus-0.1.0/secrets_plus.egg-info/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: secrets-plus
+Version: 0.1.0
+Summary: Windows BCrypt 加密安全随机数C扩展，与secrets接口完全一致
+Author: Tevend_geven
+Author-email: yanxiao_feng2013@163.com
+License: MIT
+Platform: Windows
+Classifier: Programming Language :: C
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Topic :: Security :: Cryptography
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license
+Dynamic: platform
+Dynamic: requires-python
+Dynamic: summary
+
+# token-gen-win
+Windows平台专用高性能C扩展，基于系统原生 **BCrypt API** 实现加密安全随机数，完整复刻Python标准库 `secrets` 常用接口，性能优于原生Python实现。
+
+## 平台限制
+**仅支持 Windows 系统**
+Linux / macOS 无系统BCrypt依赖库，无法编译、安装。
+
+## 功能列表
+完全对齐标准库 secrets 接口：
+- `token_bytes()`：生成随机字节串
+- `token_hex()`：生成十六进制随机令牌
+- `token_urlsafe()`：生成URL安全随机令牌
+- `randbelow()`：生成指定上界安全随机整数
+- `randbits()`：生成指定比特位随机数
+- `choice()`：从序列随机选取元素
+- `shuffle()`：原地随机打乱序列
+
+## 安装方式
+```bash
+pip install token-gen
+```
+
+## 快速使用
+```python
+import token_gen
+
+# 生成各类安全令牌
+print(token_gen.token_urlsafe())
+print(token_gen.token_hex(16))
+print(token_gen.token_bytes(32))
+
+# 随机数工具
+print(token_gen.randbelow(1000))
+print(token_gen.randbits(12))
+
+# 序列操作
+lst = [1,2,3,4,5]
+print(token_gen.choice(lst))
+token_gen.shuffle(lst)
+print(lst)
+```
+
+## 注意事项
+1. 基于栈分配实现，不支持超大长度随机数生成（建议单次长度不超过1024），避免栈溢出
+2. 长期后台运行存在轻微BCrypt句柄残留，短期脚本使用无任何影响

secrets_plus-0.1.0/secrets_plus.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+pyproject.toml
+setup.py
+token_gen.c
+secrets_plus.egg-info/PKG-INFO
+secrets_plus.egg-info/SOURCES.txt
+secrets_plus.egg-info/dependency_links.txt
+secrets_plus.egg-info/not-zip-safe
+secrets_plus.egg-info/top_level.txt

secrets_plus-0.1.0/secrets_plus.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

secrets_plus-0.1.0/secrets_plus.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

secrets_plus-0.1.0/secrets_plus.egg-info/top_level.txt

@@ -0,0 +1 @@
+secplus

secrets_plus-0.1.0/setup.cfg

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

secrets_plus-0.1.0/setup.py

@@ -0,0 +1,40 @@
+from setuptools import setup, Extension
+import pathlib
+
+HERE = pathlib.Path(__file__).parent
+README = (HERE / "README.md").read_text(encoding="utf-8")
+
+ext_module = Extension(
+    name="secplus",
+    sources=["token_gen.c"],
+    libraries=["bcrypt"],
+    extra_compile_args=["/O2", "/GL"],
+    extra_link_args=["/LTCG"],
+)
+
+setup(
+    name="secrets-plus",  # PyPI包名
+    version="0.1.0",
+    description="Windows BCrypt 加密安全随机数C扩展，与secrets接口完全一致",
+    long_description=README,
+    long_description_content_type="text/markdown",
+    author="Tevend_geven",
+    author_email="yanxiao_feng2013@163.com",
+    license="MIT",
+    ext_modules=[ext_module],
+    zip_safe=False,
+    python_requires=">=3.7",
+    platforms=["Windows"],
+    classifiers=[
+        "Programming Language :: C",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+        "Operating System :: Microsoft :: Windows",
+        "Topic :: Security :: Cryptography",
+        "License :: OSI Approved :: MIT License",
+    ],
+)

secrets_plus-0.1.0/token_gen.c

@@ -0,0 +1,284 @@
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+#include <stdint.h>
+#include <windows.h>
+#include <bcrypt.h>
+#include <string.h>
+
+static int global_init_done = 0;
+static BCRYPT_ALG_HANDLE hAlg = NULL;
+static CRITICAL_SECTION cs_rand;
+static char char_map[64];
+#define CHAR_TOTAL 64
+
+static void crypto_random(uint8_t* buf, size_t len) {
+    BCryptGenRandom(hAlg, buf, (ULONG)len, 0);
+}
+
+static uint64_t bytes_to_u64(const uint8_t* b) {
+    uint64_t res = 0;
+    res |= (uint64_t)b[0] << 0;
+    res |= (uint64_t)b[1] << 8;
+    res |= (uint64_t)b[2] << 16;
+    res |= (uint64_t)b[3] << 24;
+    res |= (uint64_t)b[4] << 32;
+    res |= (uint64_t)b[5] << 40;
+    res |= (uint64_t)b[6] << 48;
+    res |= (uint64_t)b[7] << 56;
+    return res;
+}
+
+static void safe_global_init(void) {
+    EnterCriticalSection(&cs_rand);
+    if (!global_init_done) {
+        BCryptOpenAlgorithmProvider(&hAlg, BCRYPT_RNG_ALGORITHM, NULL, 0);
+        for (int v = 0; v < CHAR_TOTAL; v++) {
+            if (v < 10)
+                char_map[v] = '0' + v;
+            else if (v < 36)
+                char_map[v] = 'A' + (v - 10);
+            else if (v < 62)
+                char_map[v] = 'a' + (v - 36);
+            else if (v == 62)
+                char_map[v] = '_';
+            else
+                char_map[v] = '-';
+        }
+        global_init_done = 1;
+    }
+    LeaveCriticalSection(&cs_rand);
+}
+
+// ������ȡָ������ԭʼ����ֽڣ��ײ㹫����װ
+static void get_raw_bytes(size_t n, uint8_t* out) {
+    safe_global_init();
+    crypto_random(out, n);
+}
+
+// ====================== ���� secrets ��׼�ӿ� ======================
+// 1. token_bytes(n=None)
+static PyObject* py_token_bytes(PyObject* self, PyObject* args, PyObject* kwargs) {
+    PyObject* n_obj = Py_None;
+    static const char* kwlist[] = {"n", NULL};
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O", (char**)kwlist, &n_obj))
+        return NULL;
+
+    Py_ssize_t n;
+    if (n_obj == Py_None)
+        n = 32;
+    else if (!PyNumber_Check(n_obj)) {
+        PyErr_SetString(PyExc_TypeError, "n must be integer or None");
+        return NULL;
+    }
+    else {
+        n = PyNumber_AsSsize_t(n_obj, PyExc_OverflowError);
+        if (PyErr_Occurred()) return NULL;
+        if (n <= 0) {
+            PyErr_SetString(PyExc_ValueError, "n must be positive");
+            return NULL;
+        }
+    }
+
+    uint8_t* buf = (uint8_t*)alloca(n);
+    get_raw_bytes((size_t)n, buf);
+    return PyBytes_FromStringAndSize((char*)buf, n);
+}
+
+// 2. token_hex(n=None)
+static PyObject* py_token_hex(PyObject* self, PyObject* args, PyObject* kwargs) {
+    PyObject* n_obj = Py_None;
+    static const char* kwlist[] = {"n", NULL};
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O", (char**)kwlist, &n_obj))
+        return NULL;
+
+    Py_ssize_t n;
+    if (n_obj == Py_None)
+        n = 16;
+    else {
+        n = PyNumber_AsSsize_t(n_obj, PyExc_OverflowError);
+        if (PyErr_Occurred()) return NULL;
+        if (n <= 0) {
+            PyErr_SetString(PyExc_ValueError, "n must be positive");
+            return NULL;
+        }
+    }
+
+    uint8_t* raw = (uint8_t*)alloca(n);
+    get_raw_bytes((size_t)n, raw);
+    size_t hex_len = (size_t)n * 2;
+    char* hex_buf = (char*)alloca(hex_len + 1);
+    static const char hex_table[] = "0123456789abcdef";
+
+    for (Py_ssize_t i = 0; i < n; i++) {
+        uint8_t b = raw[i];
+        hex_buf[i*2] = hex_table[(b >> 4) & 0x0F];
+        hex_buf[i*2+1] = hex_table[b & 0x0F];
+    }
+    hex_buf[hex_len] = '\0';
+    return PyUnicode_FromStringAndSize(hex_buf, hex_len);
+}
+
+// 3. token_urlsafe(n=None)
+static PyObject* py_token_urlsafe(PyObject* self, PyObject* args, PyObject* kwargs) {
+    PyObject* n_obj = Py_None;
+    static const char* kwlist[] = {"n", NULL};
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O", (char**)kwlist, &n_obj))
+        return NULL;
+
+    Py_ssize_t n;
+    if (n_obj == Py_None)
+        n = 32;
+    else {
+        n = PyNumber_AsSsize_t(n_obj, PyExc_OverflowError);
+        if (PyErr_Occurred()) return NULL;
+        if (n <= 0) {
+            PyErr_SetString(PyExc_ValueError, "n must be positive");
+            return NULL;
+        }
+    }
+
+    size_t raw_len = (size_t)n;
+    uint8_t* raw = (uint8_t*)alloca(raw_len);
+    get_raw_bytes(raw_len, raw);
+
+    // Base64 urlsafe ���룬ȥ�����=����A-Za-z0-9-_
+    static const char b64_table[] =
+        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+    size_t out_chars = ((raw_len * 8) + 5) / 6;
+    char* out_buf = (char*)alloca(out_chars + 1);
+    size_t pos = 0;
+
+    for (size_t i = 0; i < raw_len; i += 3) {
+        uint32_t triple = raw[i] << 16;
+        if (i + 1 < raw_len) triple |= raw[i+1] << 8;
+        if (i + 2 < raw_len) triple |= raw[i+2];
+
+        out_buf[pos++] = b64_table[(triple >> 18) & 0x3F];
+        out_buf[pos++] = b64_table[(triple >> 12) & 0x3F];
+        if (i + 1 < raw_len)
+            out_buf[pos++] = b64_table[(triple >> 6) & 0x3F];
+        if (i + 2 < raw_len)
+            out_buf[pos++] = b64_table[triple & 0x3F];
+    }
+    out_buf[out_chars] = '\0';
+    return PyUnicode_FromStringAndSize(out_buf, out_chars);
+}
+
+// 4. randbelow(exclusive_upper_bound)
+static PyObject* py_randbelow(PyObject* self, PyObject* args, PyObject* kwargs) {
+    PyObject* upper;
+    static const char* kwlist[] = {"exclusive_upper_bound", NULL};
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O", (char**)kwlist, &upper))
+        return NULL;
+
+    uint64_t bound = PyLong_AsUnsignedLongLong(upper);
+    if (PyErr_Occurred()) return NULL;
+    if (bound <= 1) {
+        PyErr_SetString(PyExc_ValueError, "bound must be greater than 1");
+        return NULL;
+    }
+
+    uint8_t rand_buf[8];
+    get_raw_bytes(8, rand_buf);
+    uint64_t r = bytes_to_u64(rand_buf);
+    uint64_t res = r % bound;
+    return PyLong_FromUnsignedLongLong(res);
+}
+
+// 5. randbits(k)
+static PyObject* py_randbits(PyObject* self, PyObject* args, PyObject* kwargs) {
+    int k;
+    static const char* kwlist[] = {"k", NULL};
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i", (char**)kwlist, &k))
+        return NULL;
+    if (k <= 0) {
+        PyErr_SetString(PyExc_ValueError, "k must be positive integer");
+        return NULL;
+    }
+
+    size_t bytes_need = ((size_t)k + 7) / 8;
+    uint8_t* buf = (uint8_t*)alloca(bytes_need);
+    get_raw_bytes(bytes_need, buf);
+    uint64_t val = 0;
+    for (size_t i = 0; i < bytes_need; i++)
+        val = (val << 8) | buf[i];
+    val &= ((1ULL << k) - 1);
+    return PyLong_FromUnsignedLongLong(val);
+}
+
+// 6. choice(seq)
+static PyObject* py_choice(PyObject* self, PyObject* args, PyObject* kwargs) {
+    PyObject* seq;
+    static const char* kwlist[] = {"seq", NULL};
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O", (char**)kwlist, &seq))
+        return NULL;
+
+    Py_ssize_t len = PySequence_Length(seq);
+    if (len <= 0) {
+        PyErr_SetString(PyExc_IndexError, "empty sequence");
+        return NULL;
+    }
+
+    uint8_t r_buf[8];
+    get_raw_bytes(8, r_buf);
+    uint64_t r = bytes_to_u64(r_buf);
+    Py_ssize_t idx = (Py_ssize_t)(r % (uint64_t)len);
+    return PySequence_GetItem(seq, idx);
+}
+
+// 7. shuffle(x) ԭ�ش���
+static PyObject* py_shuffle(PyObject* self, PyObject* args, PyObject* kwargs) {
+    PyObject* x;
+    static const char* kwlist[] = {"x", NULL};
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O", (char**)kwlist, &x))
+        return NULL;
+
+    Py_ssize_t n = PySequence_Length(x);
+    if (n <= 1) Py_RETURN_NONE;
+
+    // Fisher-Yates ϴ��
+    for (Py_ssize_t i = n - 1; i > 0; i--) {
+        uint8_t r_buf[8];
+        get_raw_bytes(8, r_buf);
+        uint64_t r = bytes_to_u64(r_buf);
+        Py_ssize_t j = (Py_ssize_t)(r % (uint64_t)(i + 1));
+        PyObject* a = PySequence_GetItem(x, i);
+        PyObject* b = PySequence_GetItem(x, j);
+        PySequence_SetItem(x, i, b);
+        PySequence_SetItem(x, j, a);
+        Py_XDECREF(a);
+        Py_XDECREF(b);
+    }
+    Py_RETURN_NONE;
+}
+
+static PyMethodDef TokenMethods[] = {
+    {"token_bytes", py_token_bytes, METH_VARARGS|METH_KEYWORDS,
+     "token_bytes(n=None) -> bytes\nCryptographically secure random bytes"},
+    {"token_hex", py_token_hex, METH_VARARGS|METH_KEYWORDS,
+     "token_hex(n=None) -> str\nHex encoded secure token"},
+    {"token_urlsafe", py_token_urlsafe, METH_VARARGS|METH_KEYWORDS,
+     "token_urlsafe(n=None) -> str\nURL-safe base64 token (A-Za-z0-9_-) "},
+    {"randbelow", py_randbelow, METH_VARARGS|METH_KEYWORDS,
+     "randbelow(exclusive_upper_bound) -> int\nSecure random integer [0, bound)"},
+    {"randbits", py_randbits, METH_VARARGS|METH_KEYWORDS,
+     "randbits(k) -> int\nSecure integer with k random bits"},
+    {"choice", py_choice, METH_VARARGS|METH_KEYWORDS,
+     "choice(seq) -> object\nSecure random pick from sequence"},
+    {"shuffle", py_shuffle, METH_VARARGS|METH_KEYWORDS,
+     "shuffle(x) -> None\nIn-place secure Fisher-Yates shuffle"},
+    {NULL, NULL, 0, NULL}
+};
+
+static struct PyModuleDef tokenmodule = {
+    PyModuleDef_HEAD_INIT,
+    "token_gen",
+    NULL,
+    -1,
+    TokenMethods
+};
+
+PyMODINIT_FUNC PyInit_token_gen(void) {
+    InitializeCriticalSection(&cs_rand);
+    return PyModule_Create(&tokenmodule);
+}