betaquant 0.6.0__tar.gz → 0.6.2__tar.gz

{betaquant-0.6.0 → betaquant-0.6.2}/Cargo.lock

@@ -37,7 +37,7 @@ checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06"
 
 [[package]]
 name = "betaquant"
-version = "0.6.0"
+version = "0.6.2"
 dependencies = [
  "anyhow",
  "base64",

{betaquant-0.6.0 → betaquant-0.6.2}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "betaquant"
-version = "0.6.0"
+version = "0.6.2"
 edition = "2024"
 authors = ["ZhaoJun"]
 readme = "README.md"

{betaquant-0.6.0 → betaquant-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: betaquant
-Version: 0.6.0
+Version: 0.6.2
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
@@ -28,6 +28,64 @@ Project-URL: repository, https://home.zhaojun.com
 pip install betaquant
 ```
 
+## 授权（License Token）
+
+betaquant 的算子受许可证（license）保护，**使用前需持有有效的 license token**。
+
+
+### 取得机器指纹（机器绑定用）
+
+```python
+import betaquant
+
+machine = betaquant.machine_fingerprint()   # 跨 Linux/Windows，机器绑定以它为准
+print(machine)
+```
+
+把该指纹提交给签发方，换取绑定到本机的 token。
+
+### 启用 token：算子入口自动鉴权（推荐）
+
+调用 `set_license_token` 把 token 设入进程级状态后，**每个算子入口都会自动鉴权**：
+未授权 / 过期 / 未设 token 时算子直接抛 `ValueError`，无需在每次调用前手写判断。
+
+
+```python
+import betaquant
+
+token = "<从签发方取得的 license key>"
+betaquant.set_license_token(token)   # 启动时一次
+
+result = betaquant.ts_ma(data, 3)     # 已授权 → 正常计算
+# 若 token 未设置 / 过期 / 该算子不在 allow，betaquant.ts_ma(...) 直接抛 ValueError
+```
+
+> 不调用 `set_license_token` 而直接调算子会抛 `ValueError`。这是与早期版本的关键区别：
+> 鉴权不再依赖调用方自觉判断，而是内嵌在每个算子入口。
+
+### 手动校验（可选）
+
+也可显式验签或单独判断某算子是否授权（不改变进程级 token 状态）：
+
+```python
+# 验签 + 校验（失败 / 过期 / 机器不符抛 ValueError），返回声明 dict
+claims = betaquant.verify_license(token, machine=machine)
+
+# 判断某算子是否被授权（token 无效 / 过期直接返回 False）
+if betaquant.license_allows(token, "ts_ma", machine=machine):
+    ...
+```
+
+授权语义（**默认拒绝**）：算子必须显式出现在 `allow`（或 `allow` 含 `"*"`）才放行；
+`deny` 优先级高于 `allow`。`allow=[]` 表示全部拒绝，并非不限制。
+
+> 过期判定使用本机系统时间，离线方案对“改系统时间”无法根治，属已知限制：用短有效期
+> + 定期换发缓解。
+
+更完整的端到端示例（签发 → 启用 token → 算子硬门禁 → 过期续期 → 机器绑定）见
+`encryptor/license/examples/demo.py`。签发方封装见 `encryptor/license`
+（`LicenseService`）。
+
 ## 使用
 
 ### 上下文设置

{betaquant-0.6.0 → betaquant-0.6.2}/README.md

@@ -12,6 +12,64 @@
 pip install betaquant
 ```
 
+## 授权（License Token）
+
+betaquant 的算子受许可证（license）保护，**使用前需持有有效的 license token**。
+
+
+### 取得机器指纹（机器绑定用）
+
+```python
+import betaquant
+
+machine = betaquant.machine_fingerprint()   # 跨 Linux/Windows，机器绑定以它为准
+print(machine)
+```
+
+把该指纹提交给签发方，换取绑定到本机的 token。
+
+### 启用 token：算子入口自动鉴权（推荐）
+
+调用 `set_license_token` 把 token 设入进程级状态后，**每个算子入口都会自动鉴权**：
+未授权 / 过期 / 未设 token 时算子直接抛 `ValueError`，无需在每次调用前手写判断。
+
+
+```python
+import betaquant
+
+token = "<从签发方取得的 license key>"
+betaquant.set_license_token(token)   # 启动时一次
+
+result = betaquant.ts_ma(data, 3)     # 已授权 → 正常计算
+# 若 token 未设置 / 过期 / 该算子不在 allow，betaquant.ts_ma(...) 直接抛 ValueError
+```
+
+> 不调用 `set_license_token` 而直接调算子会抛 `ValueError`。这是与早期版本的关键区别：
+> 鉴权不再依赖调用方自觉判断，而是内嵌在每个算子入口。
+
+### 手动校验（可选）
+
+也可显式验签或单独判断某算子是否授权（不改变进程级 token 状态）：
+
+```python
+# 验签 + 校验（失败 / 过期 / 机器不符抛 ValueError），返回声明 dict
+claims = betaquant.verify_license(token, machine=machine)
+
+# 判断某算子是否被授权（token 无效 / 过期直接返回 False）
+if betaquant.license_allows(token, "ts_ma", machine=machine):
+    ...
+```
+
+授权语义（**默认拒绝**）：算子必须显式出现在 `allow`（或 `allow` 含 `"*"`）才放行；
+`deny` 优先级高于 `allow`。`allow=[]` 表示全部拒绝，并非不限制。
+
+> 过期判定使用本机系统时间，离线方案对“改系统时间”无法根治，属已知限制：用短有效期
+> + 定期换发缓解。
+
+更完整的端到端示例（签发 → 启用 token → 算子硬门禁 → 过期续期 → 机器绑定）见
+`encryptor/license/examples/demo.py`。签发方封装见 `encryptor/license`
+（`LicenseService`）。
+
 ## 使用
 
 ### 上下文设置

{betaquant-0.6.0 → betaquant-0.6.2}/build.rs

@@ -218,6 +218,13 @@ fn build_py_bindings(functions: &[TaFunc]) -> Result<()> {
     write!(code, "{}", py_args)?;
     writeln!(code, "  ) -> PyResult<()> {{")?;
 
+    // license 硬门禁：算子入口先做鉴权，未授权 / 过期 / 未设置 token 直接抛 ValueError。
+    writeln!(
+      code,
+      "    crate::license::require_for(\"{}\").map_err(|e| PyValueError::new_err(e.to_string()))?;",
+      py_func_name
+    )?;
+
     writeln!(code, "    let ctx = ctx(py);")?;
 
     let arrays: Vec<(&String, &TaType)> = func

betaquant-0.6.2/python/betaquant/algo/__init__.py

@@ -0,0 +1,14 @@
+# Copyright 2026 MSD-RS Project LiJia
+# SPDX-License-Identifier: BSD-2-Clause
+
+from .manual import ts_ema
+from .algo_gen import *
+from ._algo import (
+    set_ctx,
+    reset_ctx,
+    verify_license,
+    license_allows,
+    machine_fingerprint,
+    set_license_token,
+    clear_license_token,
+)

{betaquant-0.6.0 → betaquant-0.6.2}/src/lib.rs

@@ -78,6 +78,8 @@ mod algo_impl {
     input: &'py Bound<'_, PyAny>,
     periods: usize,
   ) -> PyResult<()> {
+    crate::license::require_for("ts_ema")
+      .map_err(|e| PyValueError::new_err(e.to_string()))?;
     let ctx = ctx(py);
 
     if let Some((mut r, input)) = r
@@ -131,17 +133,17 @@ mod license_impl {
 
   /// 验签 + 校验 license key，成功返回声明 dict，失败抛 ValueError。
   ///
+  /// 机器绑定自动用本机指纹校验（betaquant 是客户端，永远校验本机）。
   /// 返回的 dict 含：sub / allow / deny / iat / exp / machine / kid。
   #[pyfunction]
-  #[pyo3(signature = (key, now=None, machine=None, check_expiry=true))]
+  #[pyo3(signature = (key, now=None, check_expiry=true))]
   pub fn verify_license<'py>(
     py: Python<'py>,
     key: &str,
     now: Option<i64>,
-    machine: Option<&str>,
     check_expiry: bool,
   ) -> PyResult<Bound<'py, PyDict>> {
-    let claims = license::verify(key, now, machine, check_expiry).map_err(to_pyerr)?;
+    let claims = license::verify(key, now, check_expiry).map_err(to_pyerr)?;
     let d = PyDict::new(py);
     d.set_item("sub", claims.sub)?;
     d.set_item("allow", PyList::new(py, &claims.allow)?)?;
@@ -154,17 +156,18 @@ mod license_impl {
   }
 
   /// 校验 key 后判断某算子是否可用；key 无效 / 过期直接视为不可用（返回 False）。
+  ///
+  /// 机器绑定自动用本机指纹校验。
   #[pyfunction]
-  #[pyo3(signature = (key, operator, now=None, machine=None, check_expiry=true))]
+  #[pyo3(signature = (key, operator, now=None, check_expiry=true))]
   pub fn license_allows<'py>(
     _py: Python<'py>,
     key: &str,
     operator: &str,
     now: Option<i64>,
-    machine: Option<&str>,
     check_expiry: bool,
   ) -> PyResult<bool> {
-    match license::verify(key, now, machine, check_expiry) {
+    match license::verify(key, now, check_expiry) {
       Ok(claims) => Ok(claims.allows(operator)),
       Err(_) => Ok(false),
     }
@@ -175,6 +178,22 @@ mod license_impl {
   pub fn machine_fingerprint<'py>(_py: Python<'py>) -> PyResult<String> {
     Ok(license::machine_fingerprint())
   }
+
+  /// 设置进程内 license token：验签通过后所有算子调用自动鉴权。
+  ///
+  /// 失败抛 ``ValueError``。机器绑定自动用本机指纹校验。
+  #[pyfunction]
+  pub fn set_license_token<'py>(_py: Python<'py>, key: &str) -> PyResult<()> {
+    license::set_token(key).map_err(to_pyerr)?;
+    Ok(())
+  }
+
+  /// 清空进程内 license token（主要用于测试 / 释放）。
+  #[pyfunction]
+  pub fn clear_license_token<'py>(_py: Python<'py>) -> PyResult<()> {
+    license::clear_token();
+    Ok(())
+  }
 }
 
 #[pymodule]
@@ -188,6 +207,8 @@ fn _algo(m: &Bound<'_, PyModule>) -> PyResult<()> {
   m.add_function(wrap_pyfunction!(license_impl::verify_license, m)?)?;
   m.add_function(wrap_pyfunction!(license_impl::license_allows, m)?)?;
   m.add_function(wrap_pyfunction!(license_impl::machine_fingerprint, m)?)?;
+  m.add_function(wrap_pyfunction!(license_impl::set_license_token, m)?)?;
+  m.add_function(wrap_pyfunction!(license_impl::clear_license_token, m)?)?;
   algo_impl::register_functions(m)?;
   Ok(())
 }

{betaquant-0.6.0 → betaquant-0.6.2}/src/license.rs

@@ -9,6 +9,7 @@
 //!
 //! 验签逻辑放在编译产物里（而非明文 Python），显著抬高 patch / 绕过门槛。
 
+use std::sync::{LazyLock, RwLock};
 use std::time::{SystemTime, UNIX_EPOCH};
 
 use base64::Engine;
@@ -20,6 +21,11 @@ use sha2::{Digest, Sha256};
 /// 编译期内嵌的 32 字节原始 Ed25519 公钥。换钥 = 替换此文件 + 重新编译。
 static PUBLIC_KEY_BYTES: &[u8] = include_bytes!("license/public_key.bin");
 
+/// 进程内当前生效的 license claims。`set_token` 写入，`require_for` 读取。
+/// 只在二进制内可见 / 可改，Python 侧无法 patch。
+static CURRENT_CLAIMS: LazyLock<RwLock<Option<Claims>>> =
+  LazyLock::new(|| RwLock::new(None));
+
 #[derive(Debug, thiserror::Error)]
 pub enum LicenseError {
   #[error("license key 格式错误（应为 payload.signature）")]
@@ -38,6 +44,10 @@ pub enum LicenseError {
   Expired,
   #[error("license 与当前机器不匹配")]
   MachineMismatch,
+  #[error("license token 未设置（请先调用 set_license_token）")]
+  NotSet,
+  #[error("算子 {0} 未授权")]
+  NotAllowed(String),
 }
 
 /// 反序列化的声明，字段与 Python 端 `License.to_dict()` 对应。
@@ -283,11 +293,11 @@ fn verifying_key() -> Result<VerifyingKey, LicenseError> {
 /// 验签 + 校验，返回可信 `Claims`。
 ///
 /// - `now`：当前 Unix 秒；`None` 取系统时间。便于测试。
-/// - `machine`：当前机器指纹；提供且声明绑定了机器时必须匹配。
+/// - 机器绑定：claims 未绑机器（`machine=None`）则不校验；绑了机器则必须与
+///   **本机指纹**一致（betaquant 是客户端，永远校验本机，无需外部传入）。
 pub fn verify(
   key: &str,
   now: Option<i64>,
-  machine: Option<&str>,
   check_expiry: bool,
 ) -> Result<Claims, LicenseError> {
   let key = key.trim();
@@ -317,9 +327,9 @@ pub fn verify(
     return Err(LicenseError::Expired);
   }
 
-  // 4) 机器绑定校验
-  if let (Some(bound), Some(cur)) = (claims.machine.as_deref(), machine) {
-    if bound != cur {
+  // 4) 机器绑定校验：未绑机器不校验；绑了则必须等于本机指纹
+  if let Some(bound) = claims.machine.as_deref() {
+    if bound != machine_fingerprint() {
       return Err(LicenseError::MachineMismatch);
     }
   }
@@ -327,6 +337,42 @@ pub fn verify(
   Ok(claims)
 }
 
+/// 设置进程内 license token：验签通过则缓存其 claims，供后续算子鉴权使用。
+///
+/// 机器绑定由 `verify` 自动用本机指纹校验（betaquant 是客户端，永远校验本机）。
+/// 失败会返回错误；调用方应把错误传给 Python 抛 ``ValueError``。
+pub fn set_token(key: &str) -> Result<Claims, LicenseError> {
+  let claims = verify(key, None, true)?;
+  let mut slot = CURRENT_CLAIMS
+    .write()
+    .map_err(|_| LicenseError::BadClaims)?;
+  *slot = Some(claims.clone());
+  Ok(claims)
+}
+
+/// 清空进程内 license token（主要用于测试）。
+pub fn clear_token() {
+  if let Ok(mut slot) = CURRENT_CLAIMS.write() {
+    *slot = None;
+  }
+}
+
+/// 算子鉴权钩子：每个算子入口调用。无 token / 过期 / 算子未授权都返 Err。
+///
+/// 这是 Rust 一侧"硬门禁"——校验在编译产物里，Python 改不了。
+pub fn require_for(operator: &str) -> Result<(), LicenseError> {
+  let slot = CURRENT_CLAIMS.read().map_err(|_| LicenseError::BadClaims)?;
+  let claims = slot.as_ref().ok_or(LicenseError::NotSet)?;
+  // 过期保护（带容差）：缓存的 claims 也可能跨过 exp。
+  if claims.is_expired(now_unix()) {
+    return Err(LicenseError::Expired);
+  }
+  if !claims.allows(operator) {
+    return Err(LicenseError::NotAllowed(operator.to_string()));
+  }
+  Ok(())
+}
+
 #[cfg(test)]
 mod tests {
   use super::*;
@@ -334,8 +380,8 @@ mod tests {
   // 注意：这些测试依赖内嵌公钥与对应私钥签发的 key，集成测试在 Python 端覆盖。
   #[test]
   fn rejects_garbage() {
-    assert!(verify("not-a-key", None, None, true).is_err());
-    assert!(verify("a.b.c", None, None, true).is_err());
-    assert!(verify("", None, None, true).is_err());
+    assert!(verify("not-a-key", None, true).is_err());
+    assert!(verify("a.b.c", None, true).is_err());
+    assert!(verify("", None, true).is_err());
   }
 }

betaquant-0.6.0/python/betaquant/algo/__init__.py

@@ -1,6 +0,0 @@
-# Copyright 2026 MSD-RS Project LiJia
-# SPDX-License-Identifier: BSD-2-Clause
-
-from .manual import ts_ema
-from .algo_gen import *
-from ._algo import set_ctx, reset_ctx, verify_license, license_allows, machine_fingerprint