ThomasMoreAI/legal-skills-open / br/criminal/skills/investigacao-policial-diegocamara89
investigacao-policial-diegocamara89
VerifiedSkill operacional para agentes de policia investigadores focada em producao de provas, estabelecimento de autoria e materialidade, e acompanhamento de diligencias. Use esta skill sempre que o usuario mencionar "o que devo coletar", "como provar autoria", "quais provas tenho", "o que esta pendente", "montar tabela de IPs", "cruzar IPs", "expandir suspeito", "expandir rede", "relatorio de diligencias", "cadeia de custodia", "como requisitar dados ao WhatsApp", "status da investigacao", "materialidade", "autoria", "laranja", "conta laranja", "IMEI", "cruzamento de fontes", "convergencia", "golpe do Pix", "golpe do falso advogado", "estelionato digital", "rastrear autor", "o que falta no IP", "pendencias da investigacao", "processar documentos em lote", "quem fez isso", "de onde veio o dinheiro", ou quando /investigacao for invocado. Aplicavel a qualquer tipo de fraude (estelionato, falso advogado, fraude eletronica, Pix, conta laranja, organizacao criminosa). NAO use esta skill para tipificacao penal, analise de prescricao ou fundamentacao juridica — essas ficam com a skill relatorio-final-ip. NAO use para catalogar quais diligencias existem por tipo penal — isso fica com a skill diligencias-iniciais. Mesmo que o usuario nao use essas palavras exatas, ative esta skill sempre que o contexto envolver acompanhamento ativo de uma investigacao de fraude em andamento.
| File | Kind | Size |
|---|---|---|
| LICENSE | other | 1.1 KB |
| SKILL.md | skill md | 29.3 KB |
| agents/extrator.md | markdown | 7.3 KB |
| agents/openai.yaml | config | 383 B |
| agents/validador.md | markdown | 8.2 KB |
| assets/template_pcrn_drcc.docx | binary | 91.1 KB |
| references/analise_vinculos.md | markdown | 7.0 KB |
| references/cadeia_custodia.md | markdown | 4.1 KB |
| references/categorias_prova.md | markdown | 7.8 KB |
| references/estabelecimento_autoria.md | markdown | 7.1 KB |
| references/expansao_rede.md | markdown | 6.7 KB |
| references/metodologia_ip.md | markdown | 8.5 KB |
| references/orquestracao.md | markdown | 14.1 KB |
| references/requisitos_judiciais.md | markdown | 4.2 KB |
| references/schemas_multiagente.md | markdown | 9.6 KB |
| scripts/auditoria.py | script | 10.0 KB |
| scripts/extrator_verificacao.py | script | 17.1 KB |
| scripts/gerar_docx_relatorio.py | script | 22.6 KB |
| scripts/pre_processador.py | script | 11.0 KB |
| templates/checklist_provas_fraude.md | markdown | 3.1 KB |
| templates/relatorio_diligencias.md | markdown | 2.9 KB |
| templates/relatorio_missao_policial.md | markdown | 12.0 KB |
| templates/tabela_ip_cruzamento.md | markdown | 2.6 KB |
scripts/auditoria.py
View on GitHub#!/usr/bin/env python3
"""
auditoria.py - Trilha de auditoria forense com hashes encadeados
Gera e mantem um log append-only onde cada registro inclui o hash SHA256
do registro anterior, formando uma cadeia verificavel (tamper-evident).
Atende aos requisitos da Lei 13.964/2019 (arts. 158-A a 158-F do CPP):
verificavel, auditavel e replicavel.
Uso:
# Registrar acao de agente
python auditoria.py --log caso_001.log --acao "Extracao de dados" \
--agente "extrator_bancario_01" --entrada dados.pdf --saida resultado.json
# Verificar integridade do log
python auditoria.py --log caso_001.log --verificar
# Exibir resumo do log
python auditoria.py --log caso_001.log --resumo
"""
import argparse
import hashlib
import json
import os
import sys
from datetime import datetime, timezone
from pathlib import Path
def _resolver_caminho(filepath, log_path=None):
"""Normaliza e tenta resolver um caminho de arquivo.
Tenta, em ordem:
1. Caminho como fornecido (absoluto ou relativo ao cwd)
2. Relativo ao diretorio do log (se log_path fornecido)
3. Normalizacao de separadores Windows/Unix
Retorna (path_resolvido, motivo_falha_ou_None).
"""
if not filepath:
return None, "caminho vazio"
# Normalizar separadores
normalizado = str(Path(filepath))
# Tentativa 1: caminho como fornecido (ja normalizado)
if os.path.exists(normalizado):
return normalizado, None
# Tentativa 2: relativo ao cwd
cwd_path = os.path.join(os.getcwd(), normalizado)
if os.path.exists(cwd_path):
return cwd_path, None
# Tentativa 3: relativo ao diretorio do log
if log_path:
log_dir = os.path.dirname(os.path.abspath(log_path))
log_rel = os.path.join(log_dir, normalizado)
if os.path.exists(log_rel):
return log_rel, None
return None, f"arquivo nao encontrado: '{filepath}' (tentado como absoluto, relativo ao cwd e relativo ao log)"
def calcular_hash_arquivo(filepath):
"""Calcula SHA256 de um arquivo."""
if not filepath or not os.path.exists(filepath):
return None
sha256 = hashlib.sha256()
with open(filepath, "rb") as f:
for bloco in iter(lambda: f.read(8192), b""):
sha256.update(bloco)
return sha256.hexdigest()
def calcular_hash_texto(texto):
"""Calcula SHA256 de uma string."""
return hashlib.sha256(texto.encode("utf-8")).hexdigest()
def obter_ultimo_hash(log_path):
"""Le o ultimo registro do log e retorna seu hash.
Retorna '0' * 64 se o log nao existe ou esta vazio (genesis block).
"""
if not os.path.exists(log_path) or os.path.getsize(log_path) == 0:
return "0" * 64
ultimo_registro = None
with open(log_path, "r", encoding="utf-8") as f:
for linha in f:
linha = linha.strip()
if linha:
ultimo_registro = linha
if not ultimo_registro:
return "0" * 64
return calcular_hash_texto(ultimo_registro)
def registrar(log_path, acao, agente, entrada=None, saida=None, modelo=None,
documentos=None):
"""Adiciona um registro ao log com hash encadeado."""
hash_anterior = obter_ultimo_hash(log_path)
registro = {
"timestamp": datetime.now(timezone.utc).isoformat(),
"acao": acao,
"agente": agente,
"hash_anterior": hash_anterior,
}
if modelo:
registro["modelo"] = modelo
if entrada:
path_resolvido, motivo = _resolver_caminho(entrada, log_path)
if path_resolvido:
registro["entrada"] = path_resolvido
registro["hash_entrada"] = calcular_hash_arquivo(path_resolvido)
else:
registro["entrada"] = entrada
registro["hash_entrada"] = calcular_hash_texto(entrada)
registro["entrada_aviso"] = motivo
if saida:
path_resolvido, motivo = _resolver_caminho(saida, log_path)
if path_resolvido:
registro["saida"] = path_resolvido
registro["hash_saida"] = calcular_hash_arquivo(path_resolvido)
else:
registro["saida"] = saida
registro["hash_saida"] = calcular_hash_texto(saida)
registro["saida_aviso"] = motivo
if documentos:
docs = []
for doc in documentos.split(","):
doc = doc.strip()
path_resolvido, motivo = _resolver_caminho(doc, log_path)
if path_resolvido:
h = calcular_hash_arquivo(path_resolvido)
docs.append({"arquivo": path_resolvido, "hash": h})
else:
docs.append({"arquivo": doc, "hash": "arquivo_nao_encontrado",
"aviso": motivo})
registro["documentos"] = docs
linha_json = json.dumps(registro, ensure_ascii=False, separators=(",", ":"))
with open(log_path, "a", encoding="utf-8") as f:
f.write(linha_json + "\n")
hash_registro = calcular_hash_texto(linha_json)
return {"status": "OK", "registro": registro, "hash_registro": hash_registro}
def verificar_integridade(log_path):
"""Verifica a cadeia de hashes do log.
Cada registro deve ter hash_anterior == SHA256 do registro anterior.
Se algum registro foi alterado ou removido, a cadeia quebra.
"""
if not os.path.exists(log_path):
return {"status": "ERRO", "erro": f"Log nao encontrado: {log_path}"}
with open(log_path, "r", encoding="utf-8") as f:
linhas = [l.strip() for l in f if l.strip()]
if not linhas:
return {"status": "OK", "registros": 0, "mensagem": "Log vazio"}
hash_esperado = "0" * 64
erros = []
for i, linha in enumerate(linhas):
try:
reg = json.loads(linha)
except json.JSONDecodeError:
erros.append({
"registro": i + 1,
"erro": "JSON invalido",
"linha": linha[:100],
})
continue
hash_anterior = reg.get("hash_anterior", "")
if hash_anterior != hash_esperado:
erros.append({
"registro": i + 1,
"erro": "Hash encadeado nao confere",
"esperado": hash_esperado,
"encontrado": hash_anterior,
"acao": reg.get("acao", "?"),
})
hash_esperado = calcular_hash_texto(linha)
if erros:
return {
"status": "COMPROMETIDO",
"registros": len(linhas),
"erros": erros,
"mensagem": f"Cadeia de hashes quebrada em {len(erros)} ponto(s). "
"O log pode ter sido adulterado.",
}
return {
"status": "INTEGRO",
"registros": len(linhas),
"hash_final": hash_esperado,
"mensagem": "Cadeia de hashes verificada com sucesso. Nenhuma adulteracao detectada.",
}
def resumo(log_path):
"""Exibe resumo do log: total de registros, agentes, periodo."""
if not os.path.exists(log_path):
return {"status": "ERRO", "erro": f"Log nao encontrado: {log_path}"}
with open(log_path, "r", encoding="utf-8") as f:
linhas = [l.strip() for l in f if l.strip()]
if not linhas:
return {"status": "OK", "registros": 0}
agentes = set()
acoes = []
primeiro_ts = None
ultimo_ts = None
for linha in linhas:
try:
reg = json.loads(linha)
agentes.add(reg.get("agente", "?"))
acoes.append(reg.get("acao", "?"))
ts = reg.get("timestamp")
if ts:
if not primeiro_ts:
primeiro_ts = ts
ultimo_ts = ts
except json.JSONDecodeError:
continue
return {
"status": "OK",
"registros": len(linhas),
"agentes": sorted(agentes),
"periodo": {"inicio": primeiro_ts, "fim": ultimo_ts},
"acoes": acoes,
}
def main():
parser = argparse.ArgumentParser(
description="Trilha de auditoria forense com hashes encadeados"
)
parser.add_argument("--log", required=True, help="Caminho do arquivo de log")
grupo = parser.add_mutually_exclusive_group(required=True)
grupo.add_argument("--verificar", action="store_true",
help="Verificar integridade do log")
grupo.add_argument("--resumo", action="store_true",
help="Exibir resumo do log")
grupo.add_argument("--acao", help="Descricao da acao a registrar")
parser.add_argument("--agente", help="ID do agente (ex: extrator_bancario_01)")
parser.add_argument("--entrada", help="Arquivo ou dado de entrada")
parser.add_argument("--saida", help="Arquivo ou dado de saida")
parser.add_argument("--modelo", help="ID do modelo IA usado")
parser.add_argument("--documentos",
help="Lista de documentos processados (separados por virgula)")
parser.add_argument(
"--formato", default="json", choices=["json", "texto"],
help="Formato de saida"
)
args = parser.parse_args()
if args.verificar:
resultado = verificar_integridade(args.log)
elif args.resumo:
resultado = resumo(args.log)
else:
if not args.agente:
parser.error("--agente e obrigatorio ao registrar uma acao")
resultado = registrar(
args.log, args.acao, args.agente,
entrada=args.entrada, saida=args.saida,
modelo=args.modelo, documentos=args.documentos,
)
if args.formato == "json":
print(json.dumps(resultado, ensure_ascii=False, indent=2))
else:
if resultado.get("status") == "INTEGRO":
print(f"OK: {resultado['registros']} registros, cadeia integra.")
elif resultado.get("status") == "COMPROMETIDO":
print(f"ALERTA: Cadeia comprometida em {len(resultado['erros'])} ponto(s)!")
elif resultado.get("status") == "OK":
print(f"Registrado: {resultado.get('registro', {}).get('acao', '?')}")
else:
print(f"ERRO: {resultado.get('erro', 'Falha desconhecida')}")
sys.exit(1)
if __name__ == "__main__":
main()
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis. | Stars: 472k | Updated | Claude CodeCodex | Verified | Install |
| diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness. | Stars: 323k | Updated | Claude CodeCodex | Verified | Install |
| dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies | Stars: 323k | Updated | Claude CodeCodex | Verified | Install |
| executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is available | Stars: 323k | Updated | Claude CodeCodex | Verified | Install |