pentool 0.1.0__py3-none-any.whl

pentool/cli/proxy.py

@@ -0,0 +1,173 @@
+"""CLI-команды для управления прокси-сервером."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import sys
+from pathlib import Path
+
+
+import click
+
+from pentool.core.config import get_config
+from pentool.core.logging import get_logger, setup_logging
+
+logger = get_logger(__name__)
+
+
+@click.group()
+def proxy() -> None:
+    """Управление HTTP/HTTPS прокси-сервером."""
+
+
+@proxy.command("start")
+@click.option("--port", default=8080, show_default=True, help="Порт прокси.")
+@click.option("--host", default="127.0.0.1", show_default=True, help="Адрес для прослушивания.")
+@click.option("--cert-dir", default=None, help="Директория для CA-сертификатов.")
+@click.option("--db", "db_path", default=None, help="Путь к SQLite БД для логирования.")
+@click.option("--intercept", is_flag=True, default=False, help="Включить интерактивный перехват.")
+@click.option("--scope", default="", help="Список хостов через запятую (пусто = все).")
+def proxy_start(
+    port: int,
+    host: str,
+    cert_dir: str | None,
+    db_path: str | None,
+    intercept: bool,
+    scope: str,
+) -> None:
+    cfg = get_config()
+    setup_logging(cfg.log_file, cfg.log_level)
+
+    _cert_dir = cert_dir or cfg.cert_dir
+    _db_path = db_path or cfg.db_path
+
+    from pentool.api.proxy_api import ProxyAPI
+
+    api = ProxyAPI()
+    server = api.create_proxy(
+        host=host,
+        port=port,
+        cert_dir=_cert_dir,
+        db_path=_db_path,
+    )
+    server.intercept_enabled = intercept
+
+    if scope:
+        server.set_scope([h.strip() for h in scope.split(",") if h.strip()])
+
+    click.echo(f"Starting proxy on {host}:{port}")
+    click.echo(f"  CA certs  : {_cert_dir}")
+    click.echo(f"  Database  : {_db_path}")
+    click.echo(f"  Intercept : {'ON' if intercept else 'OFF'}")
+    if server.scope:
+        click.echo(f"  Scope     : {', '.join(server.scope)}")
+    else:
+        click.echo("  Scope     : ALL hosts")
+    click.echo("Press Ctrl+C to stop.\n")
+
+    # Инициализировать БД если нужно
+    from pentool.core.database import init_db_sync
+    try:
+        init_db_sync(_db_path)
+    except Exception as exc:
+        click.echo(f"Warning: could not init database: {exc}", err=True)
+
+    try:
+        asyncio.run(server.serve_forever())
+    except KeyboardInterrupt:
+        click.echo("\nProxy stopped.")
+
+
+@proxy.command("status")
+@click.option("--port", default=8080, show_default=True, help="Порт для проверки.")
+def proxy_status(port: int) -> None:
+    """Проверить, слушает ли прокси на указанном порту."""
+    import socket
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.settimeout(1.0)
+        result = s.connect_ex(("127.0.0.1", port))
+    if result == 0:
+        click.echo(f"Proxy is RUNNING on port {port}")
+    else:
+        click.echo(f"Proxy is NOT running on port {port}")
+
+
+@proxy.command("history")
+@click.option("--db", "db_path", default=None, help="Путь к SQLite БД.")
+@click.option("--limit", default=20, show_default=True, help="Количество записей.")
+@click.option("--method", default=None, help="Фильтр по методу (GET, POST, ...).")
+@click.option("--host", default=None, help="Фильтр по хосту (подстрока URL).")
+def proxy_history(
+    db_path: str | None,
+    limit: int,
+    method: str | None,
+    host: str | None,
+) -> None:
+    cfg = get_config()
+    _db_path = db_path or cfg.db_path
+
+    if not Path(_db_path).exists():
+        click.echo(f"Database not found: {_db_path}", err=True)
+        raise SystemExit(1)
+
+    async def _fetch() -> list:
+        from pentool.storage.http_storage import HttpStorage
+        storage = HttpStorage()
+        await storage.init_db(_db_path)
+        filters: dict = {}
+        if method:
+            filters["method"] = [method.upper()]
+        if host:
+            filters["host"] = host
+        return await storage.get_metadata_batch(
+            offset=0,
+            limit=limit,
+            filters=filters if filters else None,
+            order_by="id",
+            desc=True,
+        )
+
+    rows = asyncio.run(_fetch())
+
+    if not rows:
+        click.echo("No requests found.")
+        return
+
+    click.echo(f"{'ID':<6} {'METHOD':<8} {'STATUS':<8} {'URL'}")
+    click.echo("-" * 80)
+    for row in rows:
+        rid = row["id"]
+        meth = row.get("method", "-")
+        url = row.get("url", "-")
+        status = row.get("status_code")
+        status_str = str(status) if status else "-"
+        url_short = url[:60] + "..." if len(url) > 60 else url
+        click.echo(f"{rid:<6} {meth:<8} {status_str:<8} {url_short}")
+
+
+@proxy.command("ca-info")
+@click.option("--cert-dir", default=None, help="Директория CA-сертификатов.")
+def proxy_ca_info(cert_dir: str | None) -> None:
+    cfg = get_config()
+    _cert_dir = cert_dir or cfg.cert_dir
+    ca_cert = Path(_cert_dir) / "ca.crt"
+
+    if ca_cert.exists():
+        click.echo(f"CA certificate: {ca_cert}")
+    else:
+        from pentool.utils.cert import generate_ca_cert
+        cert_path, _ = generate_ca_cert(_cert_dir)
+        click.echo(f"CA certificate generated: {cert_path}")
+
+    click.echo("\nTo trust the CA certificate:")
+    click.echo("")
+    click.echo("  Linux (Ubuntu/Debian):")
+    click.echo(f"    sudo cp {ca_cert} /usr/local/share/ca-certificates/pentool-ca.crt")
+    click.echo("    sudo update-ca-certificates")
+    click.echo("")
+    click.echo("  macOS:")
+    click.echo(f"    sudo security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain {ca_cert}")
+    click.echo("")
+    click.echo("  Firefox / Chrome:")
+    click.echo("    Settings → Certificates → Import → select ca.crt → Trust for websites")

pentool/cli/scan.py

@@ -0,0 +1,115 @@
+"""CLI-команды сканирования: pentool scan active / passive / report."""
+
+from __future__ import annotations
+
+import asyncio
+import sys
+
+import click
+
+
+@click.group("scan")
+def scan() -> None:
+    """Модуль Scanner: сканирование уязвимостей."""
+
+
+@scan.command("active")
+@click.option("--url", "urls", required=True, multiple=True, help="Целевой URL (можно несколько).")
+@click.option(
+    "--checks", "check_names", default=None,
+    help="Проверки через запятую: missing_security_headers,info_leak",
+)
+@click.option("--output", "output", default=None, help="Сохранить findings в файл (json/csv/html).")
+@click.option("--concurrency", default=5, show_default=True, help="Параллельных потоков.")
+@click.option("--delay", default=0.0, show_default=True, help="Задержка между запросами (сек).")
+@click.pass_context
+def scan_active(
+    ctx: click.Context,
+    urls: tuple[str, ...],
+    check_names: str | None,
+    output: str | None,
+    concurrency: int,
+    delay: float,
+) -> None:
+    from pentool.api.scanner_api import ScannerAPI
+    from pentool.core.config import get_config
+
+    cfg = (ctx.obj or {}).get("config") or get_config()
+    names = [c.strip() for c in check_names.split(",")] if check_names else None
+
+    api = ScannerAPI(db_path=cfg.db_path)
+
+    findings = []
+
+    def on_finding(f) -> None:
+        findings.append(f)
+        sev = f.severity.upper()
+        click.echo(f"  [{sev}] {f.name} — {f.url}")
+
+    def on_progress(done: int, total: int) -> None:
+        click.echo(f"\r  Progress: {done}/{total}", nl=False)
+
+    async def _run() -> None:
+        await api.start_active_scan(
+            list(urls),
+            check_names=names,
+            on_finding=on_finding,
+            on_progress=on_progress,
+            concurrency=concurrency,
+            request_delay=delay,
+        )
+        # Ждём завершения задачи
+        if api._active_task:
+            await api._active_task
+
+    click.echo(f"Starting active scan on {len(urls)} target(s)...")
+    asyncio.run(_run())
+    click.echo(f"\nDone. Found {len(findings)} finding(s).")
+
+    if output:
+        fmt = "html"
+        if output.endswith(".json"):
+            fmt = "json"
+        elif output.endswith(".csv"):
+            fmt = "csv"
+        asyncio.run(api.generate_report(output, fmt))
+        click.echo(f"Report saved: {output}")
+
+
+@scan.command("passive")
+@click.option("--scope", default=None, help="Фильтр хоста (например *.example.com).")
+@click.pass_context
+def scan_passive(ctx: click.Context, scope: str | None) -> None:
+    click.echo(
+        "Passive scanning runs automatically while the proxy intercepts traffic.\n"
+        "Use the TUI (Scanner tab) to enable Passive mode and view findings."
+    )
+    if scope:
+        click.echo(f"Scope filter: {scope}")
+
+
+@scan.command("report")
+@click.option("--output", required=True, help="Путь к файлу отчёта.")
+@click.option(
+    "--format", "fmt", default="html",
+    type=click.Choice(["html", "json", "csv"], case_sensitive=False),
+    show_default=True,
+    help="Формат отчёта.",
+)
+@click.pass_context
+def scan_report(ctx: click.Context, output: str, fmt: str) -> None:
+    from pentool.api.scanner_api import ScannerAPI
+    from pentool.core.config import get_config
+
+    cfg = (ctx.obj or {}).get("config") or get_config()
+    api = ScannerAPI(db_path=cfg.db_path)
+
+    async def _run() -> None:
+        findings = await api.get_findings(limit=10000)
+        if not findings:
+            click.echo("No findings in database.")
+            return
+        await api.generate_report(output, fmt)
+        click.echo(f"Report saved: {output} ({len(findings)} findings)")
+
+    asyncio.run(_run())

pentool/core/__init__.py

@@ -0,0 +1 @@
+"""Пакет core: конфигурация, логирование, БД."""

pentool/core/config.py

@@ -0,0 +1,171 @@
+"""Управление конфигурацией приложения."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Callable
+
+import yaml
+
+
+DEFAULT_CONFIG_DIR = Path.home() / ".config" / "pentool"
+DEFAULT_CONFIG_PATH = DEFAULT_CONFIG_DIR / "config.yaml"
+
+# Тип колбэка: вызывается при изменении конфига
+ConfigObserver = Callable[[dict], None]
+
+
+@dataclass
+class Config:
+    """Конфигурация приложения с значениями по умолчанию."""
+
+    proxy_host: str = "127.0.0.1"
+    proxy_port: int = 8080
+    cert_dir: str = field(default_factory=lambda: str(DEFAULT_CONFIG_DIR / "certs"))
+    db_path: str = field(default_factory=lambda: str(DEFAULT_CONFIG_DIR / "pentool.db"))
+    log_file: str = field(default_factory=lambda: str(DEFAULT_CONFIG_DIR / "pentool.log"))
+    log_level: str = "INFO"
+    plugins_dir: str = field(default_factory=lambda: str(DEFAULT_CONFIG_DIR / "plugins"))
+    scope: list[str] = field(default_factory=list)
+    intercept_enabled: bool = False
+    recent_projects: list[str] = field(default_factory=list)
+    auto_save_enabled: bool = False
+    auto_save_interval: int = 5  # минуты
+    # ── Network / Scanner settings (Блок 4.10) ─────────────────────────────
+    default_user_agent: str = (
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+        "AppleWebKit/537.36 (KHTML, like Gecko) "
+        "Chrome/122.0.0.0 Safari/537.36"
+    )
+    request_timeout: int = 15         # секунды
+    connect_timeout: int = 10         # секунды
+    collaborator_url: str = ""        # Burp Collaborator / interactsh URL
+    max_redirects: int = 10
+    verify_ssl: bool = False          # проверка SSL-сертификатов в сканере
+    # ── Scanner request marking ─────────────────────────────────────────────
+    scan_marker_enabled: bool = False
+    scan_marker_name: str = "X-Scanner"
+    scan_marker_value: str = "pentool/1.0"
+
+    # Список наблюдателей — не сериализуется (R-16)
+    _observers: list[ConfigObserver] = field(default_factory=list, init=False, repr=False, compare=False)
+
+    def add_observer(self, cb: ConfigObserver) -> None:
+        """Подписаться на изменения конфигурации.
+
+        Args:
+            cb: Функция вида cb(changed_fields: dict) → None.
+        """
+        if cb not in self._observers:
+            self._observers.append(cb)
+
+    def remove_observer(self, cb: ConfigObserver) -> None:
+        """Отписаться от изменений конфигурации."""
+        try:
+            self._observers.remove(cb)
+        except ValueError:
+            pass
+
+    def notify_observers(self, changed_fields: dict) -> None:
+        """Уведомить всех наблюдателей об изменениях.
+
+        Args:
+            changed_fields: Словарь изменённых полей {name: new_value}.
+        """
+        for cb in list(self._observers):
+            try:
+                cb(changed_fields)
+            except Exception:
+                pass
+
+    def update(self, **kwargs: Any) -> None:
+        changed: dict = {}
+        for key, value in kwargs.items():
+            if hasattr(self, key) and not key.startswith("_"):
+                if getattr(self, key) != value:
+                    setattr(self, key, value)
+                    changed[key] = value
+        if changed:
+            self.notify_observers(changed)
+
+    def to_dict(self) -> dict[str, Any]:
+        """Преобразовать в словарь для сериализации."""
+        return {
+            "proxy_host": self.proxy_host,
+            "proxy_port": self.proxy_port,
+            "cert_dir": self.cert_dir,
+            "db_path": self.db_path,
+            "log_file": self.log_file,
+            "log_level": self.log_level,
+            "plugins_dir": self.plugins_dir,
+            "scope": self.scope,
+            "intercept_enabled": self.intercept_enabled,
+            "recent_projects": self.recent_projects,
+            "auto_save_enabled": self.auto_save_enabled,
+            "auto_save_interval": self.auto_save_interval,
+            "default_user_agent": self.default_user_agent,
+            "request_timeout": self.request_timeout,
+            "connect_timeout": self.connect_timeout,
+            "collaborator_url": self.collaborator_url,
+            "max_redirects": self.max_redirects,
+            "verify_ssl": self.verify_ssl,
+            "scan_marker_enabled": self.scan_marker_enabled,
+            "scan_marker_name": self.scan_marker_name,
+            "scan_marker_value": self.scan_marker_value,
+        }
+
+    def add_recent_project(self, path: str) -> None:
+        path = str(path)
+        if path in self.recent_projects:
+            self.recent_projects.remove(path)
+        self.recent_projects.insert(0, path)
+        self.recent_projects = self.recent_projects[:10]
+        try:
+            self.save()
+        except Exception:
+            pass
+
+    def save(self, path: str | Path = DEFAULT_CONFIG_PATH) -> None:
+        path = Path(path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with open(path, "w", encoding="utf-8") as f:
+            yaml.dump(self.to_dict(), f, default_flow_style=False, allow_unicode=True)
+
+    @classmethod
+    def load(cls, path: str | Path = DEFAULT_CONFIG_PATH) -> "Config":
+        path = Path(path)
+        if not path.exists():
+            return cls()
+        with open(path, "r", encoding="utf-8") as f:
+            data: dict[str, Any] = yaml.safe_load(f) or {}
+        cfg = cls()
+        for key, value in data.items():
+            if hasattr(cfg, key) and not key.startswith("_"):
+                setattr(cfg, key, value)
+        # Удалить несуществующие пути из recent_projects при загрузке
+        before = len(cfg.recent_projects)
+        cfg.recent_projects = [p for p in cfg.recent_projects if os.path.exists(p)]
+        if len(cfg.recent_projects) != before:
+            try:
+                cfg.save()
+            except Exception:
+                pass
+        return cfg
+
+
+# Глобальный экземпляр конфигурации (инициализируется при запуске)
+_config: Config | None = None
+
+
+def get_config() -> Config:
+    global _config
+    if _config is None:
+        _config = Config.load()
+    return _config
+
+
+def set_config(config: Config) -> None:
+    global _config
+    _config = config

pentool/core/crash_reporter.py

@@ -0,0 +1,75 @@
+"""Crash reporter — collects and sends anonymous crash reports."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import platform
+import sys
+import traceback
+from typing import Any
+
+
+def _get_metadata() -> dict[str, Any]:
+    """Collect anonymous metadata for crash report."""
+    try:
+        from pentool import __version__ as version
+    except Exception:
+        version = "unknown"
+    return {
+        "version": version,
+        "python": sys.version.split()[0],
+        "os": platform.system(),
+        "os_version": platform.release(),
+        "arch": platform.machine(),
+    }
+
+
+def _anonymize(text: str) -> str:
+    """Remove paths and potential tokens from traceback text."""
+    import re
+    # Remove absolute paths — keep only filename
+    text = re.sub(r'  File "([^"]+)"', lambda m: f'  File "{os.path.basename(m.group(1))}"', text)
+    # Remove anything that looks like a token/key (long hex strings)
+    text = re.sub(r'\b[A-Fa-f0-9]{32,}\b', '<TOKEN>', text)
+    return text
+
+
+async def send_crash_async(exc: BaseException, endpoint: str = "https://pentool.dev/api/crash") -> None:
+    """Send crash report asynchronously. Silently ignores any errors."""
+    try:
+        import aiohttp  # type: ignore[import]
+    except ImportError:
+        return  # aiohttp not available — skip silently
+
+    try:
+        tb_lines = traceback.format_exception(type(exc), exc, exc.__traceback__)
+        tb_text = _anonymize("".join(tb_lines))
+        payload = {
+            "traceback": tb_text,
+            "exception": type(exc).__name__,
+            **_get_metadata(),
+        }
+        timeout = aiohttp.ClientTimeout(total=8)
+        async with aiohttp.ClientSession(timeout=timeout) as session:
+            await session.post(endpoint, json=payload, ssl=False)
+    except Exception:
+        pass  # never propagate errors from crash reporter
+
+
+def send_crash(exc: BaseException) -> None:
+    """Fire-and-forget crash report from sync context."""
+    try:
+        from pentool.core.config import get_config
+        cfg = get_config()
+        if not getattr(cfg, "send_crash_reports", True):
+            return
+    except Exception:
+        pass
+
+    try:
+        loop = asyncio.new_event_loop()
+        loop.run_until_complete(send_crash_async(exc))
+        loop.close()
+    except Exception:
+        pass

pentool/core/database.py

@@ -0,0 +1,139 @@
+"""Работа с базой данных SQLite через aiosqlite."""
+
+from __future__ import annotations
+
+import asyncio
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import AsyncIterator
+
+import aiosqlite
+
+
+# DDL для создания таблиц
+_SCHEMA = """
+CREATE TABLE IF NOT EXISTS projects (
+    id          INTEGER PRIMARY KEY AUTOINCREMENT,
+    name        TEXT    NOT NULL,
+    path        TEXT    NOT NULL,
+    created_at  TEXT    NOT NULL DEFAULT (datetime('now')),
+    settings_json TEXT  DEFAULT '{}'
+);
+
+CREATE TABLE IF NOT EXISTS repeater_entries (
+    id                  INTEGER PRIMARY KEY AUTOINCREMENT,
+    project_id          INTEGER REFERENCES projects(id) ON DELETE CASCADE,
+    tab_name            TEXT    NOT NULL DEFAULT 'Tab',
+    method              TEXT    NOT NULL,
+    url                 TEXT    NOT NULL,
+    request_headers     TEXT    DEFAULT '',
+    request_body        TEXT    DEFAULT '',
+    response_status     INTEGER DEFAULT NULL,
+    response_headers    TEXT    DEFAULT '',
+    response_body       TEXT    DEFAULT '',
+    timestamp           TEXT    NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS intruder_results (
+    id                  INTEGER PRIMARY KEY AUTOINCREMENT,
+    project_id          INTEGER REFERENCES projects(id) ON DELETE CASCADE,
+    attack_id           TEXT    NOT NULL,
+    payload_values      TEXT    DEFAULT '[]',
+    request_raw         TEXT    DEFAULT '',
+    response_status     INTEGER DEFAULT NULL,
+    response_length     INTEGER DEFAULT NULL,
+    response_time_ms    INTEGER DEFAULT NULL,
+    error               TEXT    DEFAULT NULL,
+    timestamp           TEXT    NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS vulnerabilities (
+    id              INTEGER PRIMARY KEY AUTOINCREMENT,
+    project_id      INTEGER REFERENCES projects(id) ON DELETE CASCADE,
+    type            TEXT    NOT NULL,
+    name            TEXT    NOT NULL DEFAULT '',
+    severity        TEXT    NOT NULL DEFAULT 'info',
+    host            TEXT    NOT NULL,
+    url             TEXT    NOT NULL,
+    parameter       TEXT    DEFAULT '',
+    payload         TEXT    DEFAULT '',
+    evidence        TEXT    DEFAULT '',
+    description     TEXT    DEFAULT '',
+    cwe             TEXT    DEFAULT '',
+    remediation     TEXT    DEFAULT '',
+    mitre_attack    TEXT    DEFAULT '',
+    request_raw     TEXT    DEFAULT '',
+    response_raw    TEXT    DEFAULT '',
+    false_positive  INTEGER NOT NULL DEFAULT 0,
+    timestamp       TEXT    NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS site_map (
+    id              TEXT    PRIMARY KEY,
+    host            TEXT    NOT NULL,
+    path            TEXT    NOT NULL,
+    methods         TEXT    NOT NULL DEFAULT '[]',
+    request_count   INTEGER NOT NULL DEFAULT 0,
+    last_seen       TEXT    NOT NULL,
+    in_scope        INTEGER NOT NULL DEFAULT 0
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS idx_site_map_host_path ON site_map (host, path);
+"""
+
+
+async def init_db(db_path: str) -> None:
+    """Создать таблицы БД, если они не существуют.
+
+    Args:
+        db_path: Путь к файлу SQLite.
+    """
+    path = Path(db_path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    async with aiosqlite.connect(db_path) as db:
+        await db.executescript(_SCHEMA)
+        await db.commit()
+        # Миграция: добавляем новые колонки в vulnerabilities (для старых БД)
+        _new_vuln_cols = [
+            ("name",         "TEXT NOT NULL DEFAULT ''"),
+            ("payload",      "TEXT DEFAULT ''"),
+            ("description",  "TEXT DEFAULT ''"),
+            ("cwe",          "TEXT DEFAULT ''"),
+            ("remediation",  "TEXT DEFAULT ''"),
+            ("mitre_attack", "TEXT DEFAULT ''"),
+            ("request_raw",  "TEXT DEFAULT ''"),
+            ("response_raw", "TEXT DEFAULT ''"),
+        ]
+        for col_name, col_def in _new_vuln_cols:
+            try:
+                await db.execute(
+                    f"ALTER TABLE vulnerabilities ADD COLUMN {col_name} {col_def}"
+                )
+            except Exception:
+                pass  # Колонка уже существует — ожидаемо
+        await db.commit()
+
+
+@asynccontextmanager
+async def get_db(db_path: str) -> AsyncIterator[aiosqlite.Connection]:
+    """Контекстный менеджер для получения соединения с БД.
+
+    Args:
+        db_path: Путь к файлу SQLite.
+
+    Yields:
+        Объект соединения aiosqlite.Connection.
+    """
+    async with aiosqlite.connect(db_path) as db:
+        db.row_factory = aiosqlite.Row
+        await db.execute("PRAGMA foreign_keys = ON")
+        yield db
+
+
+def init_db_sync(db_path: str) -> None:
+    """Синхронная обёртка над init_db для использования в CLI.
+
+    Args:
+        db_path: Путь к файлу SQLite.
+    """
+    asyncio.run(init_db(db_path))