dsh-plugin-image-workbench 0.0.0-stage → 1.1.6

package/vendor/chatgpt2api/source/utils/sentinel.py

@@ -0,0 +1,159 @@
+"""OpenAI Sentinel Token (PoW) 生成与请求工具函数。
+
+用于密码登录、注册等需要 sentinel token 的流程。
+"""
+from __future__ import annotations
+
+import base64
+import json
+import random
+import time
+import uuid
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from curl_cffi.requests import Session
+
+
+class SentinelTokenGenerator:
+    """Sentinel Token 生成器（PoW - Proof of Work）。"""
+    MAX_ATTEMPTS = 500_000
+    ERROR_PREFIX = "wQ8Lk5FbGpA2NcR9dShT6gYjU7VxZ4D"
+
+    def __init__(self, device_id: str, ua: str):
+        self.device_id = device_id
+        self.user_agent = ua
+        self.sid = str(uuid.uuid4())
+
+    @staticmethod
+    def _fnv1a_32(text: str) -> str:
+        h = 2166136261
+        for ch in text:
+            h ^= ord(ch)
+            h = (h * 16777619) & 0xFFFFFFFF
+        h ^= h >> 16
+        h = (h * 2246822507) & 0xFFFFFFFF
+        h ^= h >> 13
+        h = (h * 3266489909) & 0xFFFFFFFF
+        h ^= h >> 16
+        return format(h & 0xFFFFFFFF, "08x")
+
+    def _get_config(self) -> list:
+        perf_now = random.uniform(1000, 50000)
+        return [
+            "1920x1080",
+            time.strftime("%a %b %d %Y %H:%M:%S GMT+0000 (Coordinated Universal Time)", time.gmtime()),
+            4294705152,
+            random.random(),
+            self.user_agent,
+            "https://sentinel.openai.com/sentinel/20260124ceb8/sdk.js",
+            None,
+            None,
+            "en-US",
+            random.random(),
+            random.choice(["vendorSub-undefined", "plugins-undefined", "mimeTypes-undefined", "hardwareConcurrency-undefined"]),
+            random.choice(["location", "implementation", "URL", "documentURI", "compatMode"]),
+            random.choice(["Object", "Function", "Array", "Number", "parseFloat", "undefined"]),
+            perf_now,
+            self.sid,
+            "",
+            random.choice([4, 8, 12, 16]),
+            time.time() * 1000 - perf_now,
+        ]
+
+    @staticmethod
+    def _b64(data) -> str:
+        return base64.b64encode(json.dumps(data, separators=(",", ":"), ensure_ascii=False).encode("utf-8")).decode("ascii")
+
+    def generate_requirements_token(self) -> str:
+        data = self._get_config()
+        data[3] = 1
+        data[9] = round(random.uniform(5, 50))
+        return "gAAAAAC" + self._b64(data)
+
+    def generate_token(self, seed: str, difficulty: str) -> str:
+        start = time.time()
+        data = self._get_config()
+        difficulty = str(difficulty or "0")
+        for i in range(self.MAX_ATTEMPTS):
+            data[3] = i
+            data[9] = round((time.time() - start) * 1000)
+            payload = self._b64(data)
+            if self._fnv1a_32(seed + payload)[: len(difficulty)] <= difficulty:
+                return "gAAAAAB" + payload + "~S"
+        return "gAAAAAB" + self.ERROR_PREFIX + self._b64(str(None))
+
+
+# ── 默认 User-Agent 和 sec-ch-ua ──────────────────────────────
+DEFAULT_SENTINEL_USER_AGENT = (
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+    "AppleWebKit/537.36 (KHTML, like Gecko) "
+    "Chrome/145.0.0.0 Safari/537.36"
+)
+DEFAULT_SENTINEL_SEC_CH_UA = '"Chromium";v="145", "Google Chrome";v="145", "Not/A)Brand";v="99"'
+
+
+def build_sentinel_token(
+    session: "Session",
+    device_id: str,
+    flow: str,
+    *,
+    user_agent: str = "",
+    sec_ch_ua: str = "",
+) -> tuple[str, str]:
+    """请求 sentinel token 并返回 (sentinel_header_value, oai_sc_cookie_value)。
+
+    Args:
+        session: curl_cffi Session 实例
+        device_id: 设备 ID
+        flow: 流程标识（如 "password_verify", "username_password_create" 等）
+        user_agent: 可选的 User-Agent 覆盖
+        sec_ch_ua: 可选的 sec-ch-ua 覆盖
+
+    Returns:
+        (openai-sentinel-token header value, oai-sc cookie value) 元组
+
+    Raises:
+        RuntimeError: sentinel 请求失败
+    """
+    ua = user_agent or DEFAULT_SENTINEL_USER_AGENT
+    ch_ua = sec_ch_ua or DEFAULT_SENTINEL_SEC_CH_UA
+    generator = SentinelTokenGenerator(device_id, ua)
+    resp = session.post(
+        "https://sentinel.openai.com/backend-api/sentinel/req",
+        data=json.dumps({"p": generator.generate_requirements_token(), "id": device_id, "flow": flow}),
+        headers={
+            "Content-Type": "text/plain;charset=UTF-8",
+            "Referer": "https://sentinel.openai.com/backend-api/sentinel/frame.html",
+            "Origin": "https://sentinel.openai.com",
+            "User-Agent": ua,
+            "sec-ch-ua": ch_ua,
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": '"Windows"',
+        },
+        timeout=20,
+        verify=False,
+    )
+
+    try:
+        data = resp.json() if resp.text else {}
+    except Exception:
+        fallback = json.dumps(
+            {"p": generator.generate_requirements_token(), "t": "", "c": "", "id": device_id, "flow": flow},
+            separators=(",", ":"),
+        )
+        return fallback, ""
+
+    token = str(data.get("token") or "").strip()
+    if resp.status_code != 200 or not token:
+        raise RuntimeError(f"sentinel_req_failed_{resp.status_code}")
+    pow_data = data.get("proofofwork") or {}
+    p_value = (
+        generator.generate_token(str(pow_data.get("seed") or ""), str(pow_data.get("difficulty") or "0"))
+        if pow_data.get("required") and pow_data.get("seed")
+        else generator.generate_requirements_token()
+    )
+    sentinel_value = json.dumps({"p": p_value, "t": "", "c": token, "id": device_id, "flow": flow}, separators=(",", ":"))
+    # oai-sc cookie = "0" + sentinel token "c" value (the challenge token from the server)
+    oai_sc_value = "0" + token
+    return sentinel_value, oai_sc_value

package/vendor/chatgpt2api/source/utils/turnstile.py

@@ -0,0 +1,184 @@
+import base64
+import json
+import random
+import time
+from typing import Any, Dict, Optional
+
+
+class OrderedMap:
+    def __init__(self) -> None:
+        self.keys = []
+        self.values = {}
+
+    def add(self, key: str, value: Any) -> None:
+        if key not in self.values:
+            self.keys.append(key)
+        self.values[key] = value
+
+
+def _turnstile_to_str(value: Any) -> str:
+    if value is None:
+        return "undefined"
+    if isinstance(value, float):
+        return str(value)
+    if isinstance(value, str):
+        special = {
+            "window.Math": "[object Math]",
+            "window.Reflect": "[object Reflect]",
+            "window.performance": "[object Performance]",
+            "window.localStorage": "[object Storage]",
+            "window.Object": "function Object() { [native code] }",
+            "window.Reflect.set": "function set() { [native code] }",
+            "window.performance.now": "function () { [native code] }",
+            "window.Object.create": "function create() { [native code] }",
+            "window.Object.keys": "function keys() { [native code] }",
+            "window.Math.random": "function random() { [native code] }",
+        }
+        return special.get(value, value)
+    if isinstance(value, list) and all(isinstance(item, str) for item in value):
+        return ",".join(value)
+    return str(value)
+
+
+def _xor_string(text: str, key: str) -> str:
+    if not key:
+        return text
+    return "".join(chr(ord(ch) ^ ord(key[i % len(key)])) for i, ch in enumerate(text))
+
+
+def solve_turnstile_token(dx: str, p: str) -> Optional[str]:
+    try:
+        decoded = base64.b64decode(dx).decode()
+        token_list = json.loads(_xor_string(decoded, p))
+    except Exception:
+        return None
+
+    process_map: Dict[Any, Any] = {}
+    start_time = time.time()
+    result = ""
+
+    def func_1(e: float, t: float) -> None:
+        process_map[e] = _xor_string(_turnstile_to_str(process_map[e]), _turnstile_to_str(process_map[t]))
+
+    def func_2(e: float, t: Any) -> None:
+        process_map[e] = t
+
+    def func_3(e: str) -> None:
+        nonlocal result
+        result = base64.b64encode(e.encode()).decode()
+
+    def func_5(e: float, t: float) -> None:
+        current = process_map[e]
+        incoming = process_map[t]
+        if isinstance(current, (list, tuple)):
+            process_map[e] = list(current) + [incoming]
+            return
+        if isinstance(current, (str, float)) or isinstance(incoming, (str, float)):
+            process_map[e] = _turnstile_to_str(current) + _turnstile_to_str(incoming)
+            return
+        process_map[e] = "NaN"
+
+    def func_6(e: float, t: float, n: float) -> None:
+        tv = process_map[t]
+        nv = process_map[n]
+        if isinstance(tv, str) and isinstance(nv, str):
+            value = f"{tv}.{nv}"
+            process_map[e] = "https://chatgpt.com/" if value == "window.document.location" else value
+
+    def func_7(e: float, *args: float) -> None:
+        target = process_map[e]
+        values = [process_map[arg] for arg in args]
+        if isinstance(target, str) and target == "window.Reflect.set":
+            obj, key_name, val = values
+            obj.add(str(key_name), val)
+        elif callable(target):
+            target(*values)
+
+    def func_8(e: float, t: float) -> None:
+        process_map[e] = process_map[t]
+
+    def func_14(e: float, t: float) -> None:
+        process_map[e] = json.loads(process_map[t])
+
+    def func_15(e: float, t: float) -> None:
+        process_map[e] = json.dumps(process_map[t])
+
+    def func_17(e: float, t: float, *args: float) -> None:
+        call_args = [process_map[arg] for arg in args]
+        target = process_map[t]
+        if target == "window.performance.now":
+            elapsed_ns = time.time_ns() - int(start_time * 1e9)
+            process_map[e] = (elapsed_ns + random.random()) / 1e6
+        elif target == "window.Object.create":
+            process_map[e] = OrderedMap()
+        elif target == "window.Object.keys":
+            if call_args and call_args[0] == "window.localStorage":
+                process_map[e] = [
+                    "STATSIG_LOCAL_STORAGE_INTERNAL_STORE_V4",
+                    "STATSIG_LOCAL_STORAGE_STABLE_ID",
+                    "client-correlated-secret",
+                    "oai/apps/capExpiresAt",
+                    "oai-did",
+                    "STATSIG_LOCAL_STORAGE_LOGGING_REQUEST",
+                    "UiState.isNavigationCollapsed.1",
+                ]
+        elif target == "window.Math.random":
+            process_map[e] = random.random()
+        elif callable(target):
+            process_map[e] = target(*call_args)
+
+    def func_18(e: float) -> None:
+        process_map[e] = base64.b64decode(_turnstile_to_str(process_map[e])).decode()
+
+    def func_19(e: float) -> None:
+        process_map[e] = base64.b64encode(_turnstile_to_str(process_map[e]).encode()).decode()
+
+    def func_20(e: float, t: float, n: float, *args: float) -> None:
+        if process_map[e] == process_map[t]:
+            target = process_map[n]
+            if callable(target):
+                target(*[process_map[arg] for arg in args])
+
+    def func_21(*_: Any) -> None:
+        return
+
+    def func_23(e: float, t: float, *args: float) -> None:
+        if process_map[e] is not None and callable(process_map[t]):
+            process_map[t](*args)
+
+    def func_24(e: float, t: float, n: float) -> None:
+        tv = process_map[t]
+        nv = process_map[n]
+        if isinstance(tv, str) and isinstance(nv, str):
+            process_map[e] = f"{tv}.{nv}"
+
+    process_map.update({
+        1: func_1,
+        2: func_2,
+        3: func_3,
+        5: func_5,
+        6: func_6,
+        7: func_7,
+        8: func_8,
+        9: token_list,
+        10: "window",
+        14: func_14,
+        15: func_15,
+        16: p,
+        17: func_17,
+        18: func_18,
+        19: func_19,
+        20: func_20,
+        21: func_21,
+        23: func_23,
+        24: func_24,
+    })
+
+    for token in token_list:
+        try:
+            fn = process_map.get(token[0])
+            if callable(fn):
+                fn(*token[1:])
+        except Exception:
+            continue
+    return result or None