114 lines
4.8 KiB
Python
114 lines
4.8 KiB
Python
"""
|
|
Painel de Clientes — monta os routers de CLIENTE, CLIENTE_CONTATO, o
|
|
gerador de chave manual, login/logoff, funcionários, minha conta e log.
|
|
Ver docs/superpowers/specs/2026-08-13-painel-clientes-web-design.md e
|
|
docs/superpowers/specs/2026-08-13-permissoes-login-sessao-design.md.
|
|
"""
|
|
from fastapi import Depends, FastAPI, Request
|
|
from fastapi.responses import RedirectResponse
|
|
from fastapi.staticfiles import StaticFiles
|
|
|
|
from . import session
|
|
from .asset_versao import ASSET_VERSAO
|
|
from .auth import NaoAutenticado, UsuarioLogado, exigir_login
|
|
from .csrf import CSRF_COOKIE_NAME, gerar_token
|
|
from .routers import auth, chave_manual, clientes, contatos, funcionarios, log, minha_conta
|
|
|
|
app = FastAPI(title="Painel de Clientes", docs_url=None, redoc_url=None, openapi_url=None)
|
|
app.mount("/static", StaticFiles(directory="app/static"), name="static")
|
|
app.include_router(auth.router)
|
|
app.include_router(clientes.router)
|
|
app.include_router(contatos.router)
|
|
app.include_router(chave_manual.router)
|
|
app.include_router(funcionarios.router)
|
|
app.include_router(minha_conta.router)
|
|
app.include_router(log.router)
|
|
|
|
|
|
@app.exception_handler(NaoAutenticado)
|
|
def _redirecionar_para_login(request: Request, exc: NaoAutenticado):
|
|
return RedirectResponse(url=f"/login?next={exc.caminho_original}", status_code=303)
|
|
|
|
|
|
@app.middleware("http")
|
|
async def csrf_cookie_middleware(request: Request, call_next):
|
|
"""
|
|
Garante que todo navegador que acessa o painel tenha um cookie
|
|
csrf_token (gerado uma vez, HttpOnly). Disponibiliza o valor em
|
|
request.state.csrf_token para os templates embutirem em formulários —
|
|
ver app/csrf.py para a validação do lado do POST.
|
|
"""
|
|
token_existente = request.cookies.get(CSRF_COOKIE_NAME)
|
|
precisa_definir_cookie = token_existente is None
|
|
request.state.csrf_token = token_existente or gerar_token()
|
|
|
|
response = await call_next(request)
|
|
|
|
if precisa_definir_cookie:
|
|
response.set_cookie(
|
|
CSRF_COOKIE_NAME, request.state.csrf_token, httponly=True, samesite="strict",
|
|
# Secure só quando a requisição já chegou em HTTPS — ver o
|
|
# comentário equivalente em app/routers/auth.py sobre o
|
|
# cookie de sessão (mesma razão, mesmo cuidado com proxy).
|
|
secure=request.url.scheme == "https",
|
|
)
|
|
return response
|
|
|
|
|
|
@app.middleware("http")
|
|
async def security_headers_middleware(request: Request, call_next):
|
|
"""
|
|
Cabeçalhos de resposta que não dependem de nenhuma lógica de negócio,
|
|
só reduzem a superfície de ataque do navegador: impedem o painel de
|
|
ser carregado dentro de um <iframe> de outro site (clickjacking),
|
|
impedem o navegador de tentar "adivinhar" um Content-Type diferente
|
|
do declarado, e restringem de onde a página pode carregar recursos.
|
|
|
|
CSP liberado para 'self' e 'unsafe-inline': os templates usam <script>
|
|
inline (tema, sidebar, máscaras do formulário de cliente) sem nonce, e
|
|
não carregam nada de CDN externo — então 'unsafe-inline' aqui não abre
|
|
mão de proteção nenhuma que já não estivesse ausente antes (o objetivo
|
|
desta CSP é bloquear script/estilo/frame de origem EXTERNA, o vetor
|
|
mais comum de um XSS injetado virar efeito prático, ex.: exfiltrar
|
|
cookie pra outro domínio ou carregar um script de terceiro).
|
|
"""
|
|
response = await call_next(request)
|
|
response.headers["X-Content-Type-Options"] = "nosniff"
|
|
response.headers["X-Frame-Options"] = "DENY"
|
|
response.headers["Referrer-Policy"] = "same-origin"
|
|
response.headers["Content-Security-Policy"] = (
|
|
"default-src 'self'; "
|
|
"script-src 'self' 'unsafe-inline'; "
|
|
"style-src 'self' 'unsafe-inline'; "
|
|
"img-src 'self' data:; "
|
|
"frame-ancestors 'none'; "
|
|
"base-uri 'self'; "
|
|
"form-action 'self'"
|
|
)
|
|
if request.url.scheme == "https":
|
|
response.headers["Strict-Transport-Security"] = "max-age=31536000; includeSubDomains"
|
|
return response
|
|
|
|
|
|
@app.middleware("http")
|
|
async def carregar_usuario_middleware(request: Request, call_next):
|
|
"""
|
|
Decodifica o cookie de sessão (se houver) e guarda o resultado em
|
|
request.state.usuario — só para os templates (base.html) decidirem o
|
|
que mostrar na navegação (ex: esconder "Funcionários" de quem não é
|
|
admin). NÃO é o mecanismo de proteção das rotas — isso continua sendo
|
|
Depends(exigir_login)/Depends(exigir_admin) em cada router.
|
|
"""
|
|
token = request.cookies.get(session.SESSION_COOKIE_NAME)
|
|
dados = session.ler_token(token)
|
|
request.state.usuario = (
|
|
UsuarioLogado(login=dados["login"], nome=dados["nome"], perfil=dados["perfil"]) if dados else None
|
|
)
|
|
request.state.asset_versao = ASSET_VERSAO
|
|
return await call_next(request)
|
|
|
|
|
|
@app.get("/")
|
|
def raiz(usuario: UsuarioLogado = Depends(exigir_login)):
|
|
return RedirectResponse(url="/clientes")
|