CenaForge: primeira versão pública
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>
This commit is contained in:
@@ -0,0 +1,150 @@
|
||||
"""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())
|
||||
Reference in New Issue
Block a user