"""Cofre de segredos do Publicador (tokens de acesso, refresh tokens, client secrets). Tudo fica num arquivo só (data/publisher/vault.bin): um JSON cifrado com a DPAPI do Windows (`CryptProtectData`, escopo do USUÁRIO). Só a mesma conta do Windows, nesta máquina, consegue abrir. Copiar o arquivo para outro PC ou outro usuário não adianta: lá ele não decifra. Nos testes, um cifrador falso é injetado (`Vault(path, cipher=...)`); a DPAPI real só existe no Windows. """ from __future__ import annotations import json import os import sys import threading from pathlib import Path from typing import Any, Protocol class VaultError(RuntimeError): """O cofre não abriu (arquivo de outro usuário/máquina, corrompido, ou DPAPI indisponível).""" class Cipher(Protocol): def protect(self, data: bytes) -> bytes: ... def unprotect(self, data: bytes) -> bytes: ... # Entropia extra: um segredo fixo do app que entra na cifra junto com a chave do usuário. Não é senha; só impede # que outro programa do mesmo usuário abra o arquivo chamando CryptUnprotectData "às cegas". _ENTROPY = b"CenaForge.Publisher.vault.v1" class DpapiCipher: """DPAPI via ctypes (crypt32.dll). Sem dependência externa.""" CRYPTPROTECT_UI_FORBIDDEN = 0x01 def __init__(self) -> None: if sys.platform != "win32": raise VaultError("O cofre do Publicador usa a DPAPI do Windows; este sistema não tem.") import ctypes from ctypes import wintypes class DataBlob(ctypes.Structure): _fields_ = [("cbData", wintypes.DWORD), ("pbData", ctypes.POINTER(ctypes.c_char))] self._ctypes = ctypes self._blob = DataBlob self._crypt32 = ctypes.WinDLL("crypt32", use_last_error=True) self._kernel32 = ctypes.WinDLL("kernel32", use_last_error=True) self._kernel32.LocalFree.argtypes = [ctypes.c_void_p] self._kernel32.LocalFree.restype = ctypes.c_void_p for fn in (self._crypt32.CryptProtectData, self._crypt32.CryptUnprotectData): fn.argtypes = [ctypes.POINTER(DataBlob), ctypes.c_void_p, ctypes.POINTER(DataBlob), ctypes.c_void_p, ctypes.c_void_p, wintypes.DWORD, ctypes.POINTER(DataBlob)] fn.restype = wintypes.BOOL def _to_blob(self, data: bytes): buffer = self._ctypes.create_string_buffer(data, len(data)) blob = self._blob(len(data), self._ctypes.cast(buffer, self._ctypes.POINTER(self._ctypes.c_char))) return blob, buffer # o buffer precisa continuar vivo enquanto o blob for usado def _call(self, fn, data: bytes, what: str) -> bytes: ctypes = self._ctypes in_blob, _keep_in = self._to_blob(data) entropy, _keep_entropy = self._to_blob(_ENTROPY) out_blob = self._blob() ok = fn(ctypes.byref(in_blob), None, ctypes.byref(entropy), None, None, self.CRYPTPROTECT_UI_FORBIDDEN, ctypes.byref(out_blob)) if not ok: code = ctypes.get_last_error() raise VaultError(f"A DPAPI do Windows não conseguiu {what} o cofre (erro {code}). O arquivo pode ser de " "outro usuário ou de outro computador.") try: return ctypes.string_at(out_blob.pbData, out_blob.cbData) finally: self._kernel32.LocalFree(out_blob.pbData) def protect(self, data: bytes) -> bytes: return self._call(self._crypt32.CryptProtectData, data, "cifrar") def unprotect(self, data: bytes) -> bytes: return self._call(self._crypt32.CryptUnprotectData, data, "abrir") class Vault: """Dicionário de segredos persistido cifrado. Chaves usadas: `app:` e `token:`.""" def __init__(self, path: Path, cipher: Cipher | None = None): self.path = path self._cipher = cipher self._lock = threading.RLock() @property def cipher(self) -> Cipher: if self._cipher is None: self._cipher = DpapiCipher() return self._cipher def _read(self) -> dict[str, Any]: if not self.path.is_file(): return {} raw = self.path.read_bytes() if not raw: return {} try: return json.loads(self.cipher.unprotect(raw).decode("utf-8")) except VaultError: raise except Exception as exc: # JSON quebrado ou cifra inválida raise VaultError("O cofre do Publicador está corrompido ou não pertence a este usuário do Windows.") from exc def _write(self, data: dict[str, Any]) -> None: self.path.parent.mkdir(parents=True, exist_ok=True) blob = self.cipher.protect(json.dumps(data, ensure_ascii=False).encode("utf-8")) tmp = self.path.with_suffix(".tmp") tmp.write_bytes(blob) os.replace(tmp, self.path) # troca atômica: nunca fica meio arquivo se o processo cair def get(self, key: str) -> Any: with self._lock: return self._read().get(key) def set(self, key: str, value: Any) -> None: with self._lock: data = self._read() data[key] = value self._write(data) def update(self, key: str, **fields: Any) -> dict: """Mescla campos no segredo `key` (ex.: gravar o refresh token novo do TikTok sem perder o resto).""" with self._lock: data = self._read() current = dict(data.get(key) or {}) current.update(fields) data[key] = current self._write(data) return current def delete(self, key: str) -> None: with self._lock: data = self._read() if key in data: del data[key] self._write(data) def keys(self) -> list[str]: with self._lock: return list(self._read().keys())