Gerador de vídeos narrativos (Godot + FFmpeg), painel Next.js, serviço de voz, Clipador de lives e Publicador para YouTube, TikTok e Instagram. Inclui a leitura das visualizações dos posts para o Dashboard e o botão "Publicar no <rede>" nos cartões das publicações. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
151 lines
5.7 KiB
Python
151 lines
5.7 KiB
Python
"""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:<platform>` e `token:<profileId>`."""
|
|
|
|
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())
|