Skip to content

ThomasMoreAI/legal-skills-open / br/criminal/skills/investigacao-policial-diegocamara89

investigacao-policial-diegocamara89

Verified

Skill 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.

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()
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: 472kUpdated Claude CodeCodexVerifiedInstall
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: 323kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 323kUpdated Claude CodeCodexVerifiedInstall
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 availableStars: 323kUpdated Claude CodeCodexVerifiedInstall