forensic-cli 1.4.6__tar.gz → 1.5.3__tar.gz

{forensic_cli-1.4.6/src/forensic_cli.egg-info → forensic_cli-1.5.3}/PKG-INFO

@@ -1,9 +1,7 @@
 Metadata-Version: 2.4
 Name: forensic-cli
-Version: 1.4.6
+Version: 1.5.3
 Summary: DevKit Forense - CLI para análise de navegadores e rede
-Home-page: https://github.com/ErickG123/devkit_forense
-Author: Erick Gabriel dos Santos Alves
 Author-email: Erick Gabriel dos Santos Alves <erickgabrielalves0@gmail.com>
 License: MIT
 Project-URL: Changelog, https://erickg123.github.io/devkit_forense/
@@ -88,10 +86,10 @@ Requires-Dist: urllib3==2.5.0
 Requires-Dist: websocket-client==1.8.0
 Requires-Dist: wsproto==1.2.0
 Requires-Dist: yarg==0.1.10
-Dynamic: author
-Dynamic: home-page
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: ruff>=0.3.0; extra == "dev"
 Dynamic: license-file
-Dynamic: requires-python
 
 # DevKit Forense – Ferramenta Educacional de Perícia Digital
 

{forensic_cli-1.4.6 → forensic_cli-1.5.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "forensic-cli"
-version = "1.4.6"
+version = "1.5.3"
 description = "DevKit Forense - CLI para análise de navegadores e rede"
 readme = "README.md"
 license = {text = "MIT"}
@@ -13,7 +13,6 @@ authors = [
 ]
 requires-python = ">=3.11"
 keywords = ["forensics", "cli", "network", "browser"]
-
 dependencies = [
     "altgraph==0.17.4",
     "annotated-types==0.7.0",
@@ -91,14 +90,44 @@ dependencies = [
     "yarg==0.1.10"
 ]
 
-[tool.setuptools.packages.find]
-where = ["src"]
-include = ["cli*", "core*"]
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "ruff>=0.3.0"
+]
 
 [project.scripts]
-forensic-cli = "cli.main:app"
+forensic-cli = "main:_build_cli"
 
 [project.urls]
 Changelog = "https://erickg123.github.io/devkit_forense/"
 Source = "https://github.com/ErickG123/devkit_forense"
 Issues = "https://github.com/ErickG123/devkit_forense/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["network*", "browser*", "mail*", "shared*", "api*", "app*"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+
+[tool.ruff.lint]
+# Habilita checagens de Erros, Funções, Isort (ordenação de imports) e Warnings
+select = ["E", "F", "I", "W"]
+ignore = []
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+
+[tool.commitizen]
+name = "cz_conventional_commits"
+version = "1.5.3"
+version_files = [
+    "pyproject.toml:version",
+    "src/shared/__init__.py:__version__"
+]
+tag_format = "v$version"
+update_changelog_on_bump = true
+changelog_incremental = true

forensic_cli-1.5.3/src/api/main.py

@@ -0,0 +1,29 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from api.routers import network
+
+app = FastAPI(
+    title="ForenseLab API",
+    description="API REST do DevKit Forense para análise de evidências digitais.",
+    version="1.0.0",
+)
+
+# Configuração de CORS para permitir consumo pelo Dashboard SPA
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Em produção, restringir para o domínio da Vercel
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Registro dos Roteadores baseados em features
+app.include_router(network.router, prefix="/api/network", tags=["Network"])
+# app.include_router(browser.router, prefix="/api/browser", tags=["Browser"])
+# app.include_router(email.router, prefix="/api/email", tags=["Email"])
+
+
+@app.get("/")
+def root():
+    return {"message": "ForenseLab API está online e operante!"}

forensic_cli-1.5.3/src/api/routers/__init__.py

@@ -0,0 +1 @@
+# API routers package

forensic_cli-1.5.3/src/api/routers/executions.py

@@ -0,0 +1,56 @@
+from datetime import datetime
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+
+import shared.orm as orm
+from api.utils.db import get_db
+from shared.schemas import ExecutionCreateSchema, ExecutionSchema
+
+router = APIRouter(prefix="/executions", tags=["Executions"])
+
+
+@router.post("/start", response_model=ExecutionSchema)
+def start_execution(payload: ExecutionCreateSchema, db: Session = Depends(get_db)):
+    func = db.query(orm.Functionality).filter(orm.Functionality.id == payload.func_id).first()
+    if not func:
+        raise HTTPException(status_code=404, detail="Funcionalidade não encontrada")
+
+    execution = orm.Execution(
+        functionality_id=func.id,
+        network=payload.network,
+        status="started",
+        cli_version=payload.cli_version,
+    )
+    db.add(execution)
+    db.commit()
+    db.refresh(execution)
+
+    return execution
+
+
+@router.post("/finish", response_model=ExecutionSchema)
+def finish_execution(payload: ExecutionCreateSchema, db: Session = Depends(get_db)):
+    execution = (
+        db.query(orm.Execution)
+        .filter(
+            orm.Execution.functionality_id == payload.func_id,
+            orm.Execution.network == payload.network,
+            orm.Execution.status == "started",
+        )
+        .first()
+    )
+
+    if not execution:
+        raise HTTPException(status_code=404, detail="Execução não encontrada")
+
+    execution.status = "finished"
+    execution.finished_at = datetime.utcnow()
+    execution.cli_version = payload.cli_version
+
+    result = orm.Result(execution_id=execution.id, data=payload.data)
+    db.add(result)
+    db.commit()
+    db.refresh(execution)
+
+    return execution

forensic_cli-1.5.3/src/api/routers/functionalities.py

@@ -0,0 +1,101 @@
+import json
+import os
+from datetime import datetime
+from pathlib import Path
+
+from fastapi import APIRouter, BackgroundTasks, Depends, HTTPException
+from sqlalchemy.orm import Session
+
+import shared.orm as orm
+import shared.schemas as schemas
+from api.utils.db import get_db
+from shared.db import SessionLocal
+from shared.registry import FUNCTIONALITIES
+
+router = APIRouter(prefix="/functionalities", tags=["Functionalities"])
+
+
+@router.post("/", response_model=schemas.Functionality)
+def create_functionality(functionality: schemas.FunctionalityCreate, db: Session = Depends(get_db)):
+    db_func = orm.Functionality(
+        name=functionality.name,
+        description=functionality.description,
+        module_id=functionality.module_id,
+    )
+    db.add(db_func)
+    db.commit()
+    db.refresh(db_func)
+    return db_func
+
+
+@router.get("/", response_model=list[schemas.Functionality])
+def get_functionalities(db: Session = Depends(get_db)):
+    return db.query(orm.Functionality).all()
+
+
+@router.get("/{func_id}/results", response_model=list[schemas.Result])
+def get_results_by_functionality(func_id: str, db: Session = Depends(get_db)):
+    executions = db.query(orm.Execution).filter(orm.Execution.functionality_id == func_id).all()
+    results = []
+    for exe in executions:
+        if exe.result:
+            results.append(exe.result)
+    return results
+
+
+@router.post("/{func_id}/run")
+def run_functionality(
+    func_id: str,
+    network: str = None,
+    background_tasks: BackgroundTasks = None,
+    usuario: str = "Usuário Anônimo",
+    db: Session = Depends(get_db),
+):
+    func_obj = db.query(orm.Functionality).filter(orm.Functionality.id == func_id).first()
+    if not func_obj:
+        raise HTTPException(status_code=404, detail="Funcionalidade não encontrada")
+
+    func_name = func_obj.name
+    if func_name not in FUNCTIONALITIES:
+        raise HTTPException(status_code=400, detail=f"Funcionalidade '{func_name}' não registrada")
+
+    def execute_core():
+        try:
+            output_dir = Path(__file__).parent.parent / "cli_output"
+            os.makedirs(output_dir, exist_ok=True)
+
+            func = FUNCTIONALITIES[func_name]
+
+            if func_name == "network_map":
+                result_data = func(network, str(output_dir))
+            else:
+                result_data = func(usuario=usuario, output_dir=str(output_dir))
+
+            db_session = SessionLocal()
+            execution = orm.Execution(
+                functionality_id=func_obj.id,
+                network=network or "N/A",
+                status="started",
+                started_at=datetime.utcnow(),
+            )
+            db_session.add(execution)
+            db_session.commit()
+            db_session.refresh(execution)
+
+            result = orm.Result(
+                execution_id=execution.id,
+                data=json.dumps(result_data, ensure_ascii=False),
+                created_at=datetime.utcnow(),
+            )
+            db_session.add(result)
+            db_session.commit()
+            db_session.refresh(result)
+            db_session.close()
+
+            print(f"✅ {func_name} executado com sucesso!")
+
+        except Exception as e:
+            print(f"❌ Erro ao executar {func_name}: {e}")
+
+    background_tasks.add_task(execute_core)
+    return {"status": "execução iniciada em background", "funcionalidade": func_name}

forensic_cli-1.5.3/src/api/routers/modules.py

@@ -0,0 +1,24 @@
+from typing import List
+
+from fastapi import APIRouter, Depends
+from sqlalchemy.orm import Session
+
+import shared.orm as orm
+import shared.schemas as schemas
+from api.utils.db import get_db
+
+router = APIRouter(prefix="/modules", tags=["Modules"])
+
+
+@router.post("/", response_model=schemas.Module)
+def create_module(module: schemas.ModuleCreate, db: Session = Depends(get_db)):
+    db_module = orm.Module(name=module.name, description=module.description)
+    db.add(db_module)
+    db.commit()
+    db.refresh(db_module)
+    return db_module
+
+
+@router.get("/", response_model=List[schemas.Module])
+def get_modules(db: Session = Depends(get_db)):
+    return db.query(orm.Module).all()

forensic_cli-1.5.3/src/api/routers/network.py

@@ -0,0 +1,21 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from network.port_scanner import scan_host
+
+router = APIRouter()
+
+
+class ScanRequest(BaseModel):
+    target: str
+    ports: str = "21,22,80,443,8080"
+
+
+@router.post("/scan")
+def run_port_scan(request: ScanRequest):
+    try:
+        # A chamada ao Core que agora retorna um dicionário limpo
+        results = scan_host(target=request.target, ports=request.ports)
+        return {"target": request.target, "status": "success", "data": results}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

forensic_cli-1.5.3/src/api/routers/reports.py

@@ -0,0 +1,24 @@
+from typing import List
+
+from fastapi import APIRouter, Depends
+from sqlalchemy.orm import Session
+
+import shared.orm as orm
+import shared.schemas as schemas
+from api.utils.db import get_db
+
+router = APIRouter(prefix="/reports", tags=["Reports"])
+
+
+@router.post("/reports/", response_model=schemas.Report)
+def create_report(report: schemas.ReportCreate, db: Session = Depends(get_db)):
+    db_report = orm.Report(result_id=report.result_id, file_path=report.file_path)
+    db.add(db_report)
+    db.commit()
+    db.refresh(db_report)
+    return db_report
+
+
+@router.get("/reports/", response_model=List[schemas.Report])
+def get_reports(db: Session = Depends(get_db)):
+    return db.query(orm.Report).all()

forensic_cli-1.5.3/src/api/routers/results.py

@@ -0,0 +1,29 @@
+from typing import List
+
+from fastapi import APIRouter, Depends
+from sqlalchemy.orm import Session
+
+import shared.orm as orm
+import shared.schemas as schemas
+from api.utils.db import get_db
+
+router = APIRouter(prefix="/results", tags=["Results"])
+
+
+@router.post("/results/", response_model=schemas.Result)
+def create_result(result: schemas.ResultCreate, db: Session = Depends(get_db)):
+    db_result = orm.Result(functionality_id=result.functionality_id, data=result.data)
+    db.add(db_result)
+    db.commit()
+    db.refresh(db_result)
+    return db_result
+
+
+@router.get("/results/", response_model=List[schemas.Result])
+def get_results(db: Session = Depends(get_db)):
+    return db.query(orm.Result).all()
+
+
+@router.get("/results/{result_id}/reports", response_model=List[schemas.Report])
+def get_reports_by_result(result_id: str, db: Session = Depends(get_db)):
+    return db.query(orm.Report).filter(orm.Report.result_id == result_id).all()

forensic_cli-1.5.3/src/api/utils/db.py

@@ -0,0 +1,9 @@
+from shared.db import SessionLocal
+
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

forensic_cli-1.5.3/src/app/main.py

@@ -0,0 +1,75 @@
+import json
+
+from flask import Flask, current_app, flash, redirect, render_template, request, url_for
+
+from .utils.converter import convert_hosts_to_graph
+
+app = Flask(__name__, template_folder="templates", static_folder="static")
+app.secret_key = "troque_essa_chave_em_producao"
+app.config["MAX_CONTENT_LENGTH"] = 8 * 1024 * 1024
+
+
+@app.route("/", methods=["GET"])
+def index():
+    return render_template("index.html", nodes_json="[]", edges_json="[]", filename=None)
+
+
+@app.route("/upload", methods=["POST"])
+def upload():
+    file = request.files.get("file")
+    if not file:
+        flash("Nenhum arquivo enviado.", "error")
+        return redirect(url_for("index"))
+
+    try:
+        data = json.load(file)
+    except Exception as e:
+        flash(f"Erro ao parsear JSON: {e}", "error")
+        current_app.logger.exception("Erro ao parsear JSON no upload")
+        return redirect(url_for("index"))
+
+    hosts = []
+    if isinstance(data, list):
+        hosts = data
+    elif isinstance(data, dict):
+        candidates = [v for v in data.values() if isinstance(v, list)]
+        if len(candidates) == 1:
+            hosts = candidates[0]
+        else:
+            hosts = (
+                data.get("hosts")
+                or data.get("results")
+                or data.get("items")
+                or data.get("network")
+                or candidates[0]
+                or []
+            )
+
+    nodes, edges = convert_hosts_to_graph(hosts)
+    node_count = len(nodes)
+    edge_count = len(edges)
+
+    current_app.logger.info(
+        f"[UPLOAD] file={getattr(file, 'filename', None)} hosts_found={len(hosts)} nodes={node_count} edges={edge_count}"
+    )
+
+    if node_count == 0:
+        flash(
+            "Upload processado, porém nenhum nó foi gerado. Verifique o formato do JSON (veja logs do servidor).",
+            "warning",
+        )
+    else:
+        flash(f"Upload OK — nodes: {node_count}, edges: {edge_count}", "success")
+
+    return render_template(
+        "index.html",
+        nodes_json=nodes,
+        edges_json=edges,
+        filename=getattr(file, "filename", None),
+        node_count=node_count,
+        edge_count=edge_count,
+    )
+
+
+if __name__ == "__main__":
+    app.run(debug=True, host="0.0.0.0", port=8080)

forensic_cli-1.5.3/src/app/utils/converter.py

@@ -0,0 +1,144 @@
+import html
+import ipaddress
+import json
+
+
+def is_ip(addr: str) -> bool:
+    try:
+        ipaddress.ip_address(addr)
+        return True
+    except Exception:
+        return False
+
+
+def convert_hosts_to_graph(hosts):
+    nodes = []
+    edges = []
+    nodes_map = {}
+
+    def add_node(node_id, label=None, title=None, group="unknown", value=15, raw=None):
+        node_id = str(node_id)
+        if node_id in nodes_map:
+            return
+        node = {
+            "id": node_id,
+            "label": label or node_id,
+            "title": title or "",
+            "group": group,
+            "value": value,
+        }
+        if raw:
+            node["raw"] = raw
+        nodes.append(node)
+        nodes_map[node_id] = node
+
+    for item in hosts:
+        ip = (
+            item.get("host")
+            or item.get("ip")
+            or item.get("address")
+            or item.get("ipv4")
+            or item.get("ip_address")
+        )
+        if not ip:
+            tr = item.get("traceroute") or item.get("trace") or item.get("hops")
+            if isinstance(tr, list) and tr:
+                for hop in reversed(tr):
+                    if isinstance(hop, dict):
+                        hopip = hop.get("ip") or hop.get("addr") or hop.get("address")
+                        if hopip and is_ip(str(hopip)):
+                            ip = hopip
+                            break
+                    elif isinstance(hop, str) and is_ip(hop):
+                        ip = hop
+                        break
+        if not ip:
+            continue
+        ip = str(ip)
+
+        hostname = item.get("hostname") or item.get("host_name") or item.get("name") or ""
+        mac = item.get("mac") or item.get("mac_address") or ""
+        vendor = item.get("vendor") or item.get("oui") or ""
+        open_ports = item.get("open_ports") or item.get("ports") or []
+        os_info = item.get("os_info") or {}
+        os_name = os_info.get("os") if isinstance(os_info, dict) else ""
+        ip_info = item.get("ip_info") or {}
+
+        details = [f"IP: {html.escape(ip)}"]
+        if hostname:
+            details.append(f"Hostname: {html.escape(str(hostname))}")
+        if mac:
+            details.append(f"MAC: {html.escape(str(mac))}")
+        if vendor:
+            details.append(f"Vendor: {html.escape(str(vendor))}")
+        if os_name:
+            details.append(f"OS: {html.escape(str(os_name))}")
+        if isinstance(open_ports, list) and open_ports:
+            ports_summary = ", ".join(str(p) for p in open_ports[:8])
+            details.append(f"Open ports: {html.escape(ports_summary)} ({len(open_ports)})")
+        if isinstance(ip_info, dict) and ip_info:
+            geo = ip_info.get("geo") or ip_info.get("country") or ip_info.get("region")
+            if geo:
+                details.append(f"IP info: {html.escape(str(geo))}")
+
+        pretty_json = json.dumps(item, indent=2, ensure_ascii=False)
+        html_title = "\n".join(details)
+
+        size = 15 + min(30, int(len(open_ports)) * 2) if open_ports else 15
+
+        group = "unknown"
+        if os_name:
+            on = os_name.lower()
+            if "win" in on:
+                group = "windows"
+            elif "linux" in on:
+                group = "linux"
+            elif "android" in on:
+                group = "android"
+            elif "embedded" in on or "router" in on:
+                group = "embedded"
+            else:
+                group = "other"
+
+        add_node(
+            ip, label=hostname or ip, title=html_title, group=group, value=size, raw=pretty_json
+        )
+
+        traceroute = item.get("traceroute") or item.get("trace") or []
+        if isinstance(traceroute, list) and traceroute:
+            prev = None
+            for hop in traceroute:
+                hop_ip = None
+                if isinstance(hop, dict):
+                    hop_ip = (
+                        hop.get("ip") or hop.get("addr") or hop.get("address") or hop.get("host")
+                    )
+                elif isinstance(hop, str):
+                    hop_ip = hop
+                if not hop_ip:
+                    continue
+                hop_ip = str(hop_ip)
+                if is_ip(hop_ip):
+                    add_node(
+                        hop_ip,
+                        label=hop_ip,
+                        title=f"Hop: {html.escape(hop_ip)}",
+                        group="hop",
+                        value=10,
+                    )
+                    if prev and is_ip(prev):
+                        edges.append({"from": prev, "to": hop_ip})
+                    prev = hop_ip
+            if prev and prev != ip:
+                edges.append({"from": prev, "to": ip})
+
+    if not edges and nodes:
+        hub_candidates = ["192.168.0.1", "192.168.1.1", "10.0.0.1"]
+        hub = next((c for c in hub_candidates if c in nodes_map), None)
+        if not hub:
+            hub = next(iter(nodes_map.keys()))
+        for nid in nodes_map:
+            if nid != hub:
+                edges.append({"from": hub, "to": nid})
+
+    return nodes, edges

forensic_cli-1.5.3/src/browser/__init__.py

@@ -0,0 +1 @@
+# browser feature package

forensic_cli-1.5.3/src/browser/api.py

@@ -0,0 +1,39 @@
+"""
+API Router da feature Browser.
+
+Expõe endpoints REST para extração de artefatos de navegadores.
+Os endpoints de extração são operações de longa duração — em produção
+considere movê-los para tarefas assíncronas (ex: Celery/BackgroundTasks).
+"""
+
+from fastapi import APIRouter
+
+from shared.logger import get_logger
+
+logger = get_logger(__name__)
+
+router = APIRouter()
+
+
+# ---------------------------------------------------------------------------
+# Health-check da feature
+# ---------------------------------------------------------------------------
+
+
+@router.get(
+    "/health",
+    summary="Browser Feature Health-check",
+    description="Confirma que o módulo de análise de navegadores está disponível.",
+)
+def browser_health():
+    return {
+        "feature": "browser",
+        "status": "online",
+        "endpoints_available": [
+            "GET  /browser/health",
+        ],
+        "note": (
+            "Os endpoints de extração (history, downloads, logins) operam sobre "
+            "o sistema de arquivos local e serão expostos em versões futuras da API."
+        ),
+    }