Exploit for jfp-console-poc

Name: Exploit for jfp-console-poc
Rating: 5 (7 reviews)
2026-06-19 | CVSS 6.0
## https://sploitus.com/exploit?id=205601AE-E7C0-5BA7-8522-8C321608314E
# JFP Console PoC

**Tamper-evident autonomous system governor with a live operator dashboard.**

JFP Console PoC is a Linux daemon that monitors system resources, executes governed interventions when safety thresholds are breached, and writes every action to a SHA-256 hash-chain proof log — optionally signed with Ed25519. A PySide6 operator console visualises metrics and events in real time and sends whitelisted control commands over a Unix socket.

The system is not AI-dependent. Every decision is deterministic, every intervention is gated by two independent policy layers, and every proof record is mathematically verifiable offline.

---

## Key properties

| Property | How it is enforced |
|---|---|
| **Two-layer governance** | Every action passes Governor (hard constitutional rules) and Supervisor (adaptive optimizer). Both must approve. |
| **Tamper-evident proof log** | SHA-256 hash chain. Any modification to any historical record breaks the chain. |
| **Optional Ed25519 signing** | Each record signed with daemon's private key. Public key verifiable offline. |
| **Safe-mode dry run** | `JFP_DRY_RUN=1` — no real system mutations. Default for development. |
| **Trigger streak guard** | Intervention only after N consecutive threshold breaches (prevents false positives from transient spikes). |
| **Auth-gated write ops** | All write operations require an operator token. Read-only methods are public. |
| **Process isolation** | Daemon runs as root. Console runs as unprivileged user. No `sudo` in the console. |

---

## Architecture

```
┌─────────────────────────────────────────────────────────┐
│  jfpd (daemon, root)                                    │
│                                                         │
│  ┌──────────┐     ┌───────────────┐   ┌─────────────┐  │
│  │ metrics  │────▶│  GovernorCon  │──▶│   Action    │  │
│  │ sampler  │     │  stitution    │   │   Executor  │  │
│  │ (1s tick)│     │  (hard rules) │   │  (allowlist)│  │
│  └──────────┘     └───────┬───────┘   └──────┬──────┘  │
│                           │                  │          │
│                   ┌───────▼───────┐          │          │
│                   │  Supervisor   │──────────┘          │
│                   │  (adaptive)   │                     │
│                   └───────────────┘                     │
│                                                         │
│  ┌────────────────────────────────────────┐             │
│  │  ProofLogger — SHA-256 chain + Ed25519 │             │
│  └────────────────────────────────────────┘             │
│                      │                                  │
│               Unix socket (AF_UNIX)                     │
│               JSON-RPC (8 methods)                      │
└──────────────────────┼──────────────────────────────────┘
                       │
┌──────────────────────▼──────────────────────────────────┐
│  jfp-console (PySide6, unprivileged user)               │
│                                                         │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐  │
│  │  MetricCards │  │  LiveCharts  │  │   Timeline   │  │
│  │  (8 panels)  │  │  CPU/RAM/T°  │  │  (events)    │  │
│  └──────────────┘  └──────────────┘  └──────────────┘  │
│                                                         │
│  [ENGAGE JFP HEALER] [UNLOCK SAFETY] [START BENCHMARK]  │
│  [STOP BENCHMARK]    [PANIC STOP]                       │
└─────────────────────────────────────────────────────────┘
```

### State machine

```
MONITORING ──(3× threshold hit)──▶ TRIGGERED
TRIGGERED  ──(gate: PASS)─────────▶ INTERVENTION
TRIGGERED  ──(gate: DENY)─────────▶ COOLDOWN
INTERVENTION ─────────────────────▶ COOLDOWN
COOLDOWN   ──(window elapsed)─────▶ MONITORING
```

---

## Quick start

Requires Python 3.10+ and Linux.

```bash
git clone 
cd JFP_Project

# 1. Create virtual environment and install dependencies
python3 -m venv .venv
.venv/bin/pip install -r requirements.txt

# 2. One-click launch (daemon + console, Ed25519 signing enabled)
./run-poc.sh
```

Or separately:

```bash
# Terminal 1 — daemon (dry-run, no signing)
./run-daemon.sh

# Terminal 2 — console
./run-console.sh
```

### Environment variables

| Variable | Default | Description |
|---|---|---|
| `JFP_DRY_RUN` | `1` | `1` = no real system mutations |
| `JFP_SOCKET_PATH` | `/run/jfpd.sock` | Unix socket path (`@name` for abstract) |
| `JFP_LOG_PATH` | `/var/log/jfp/jfp_proof.jsonl` | Proof log file |
| `JFP_OPERATOR_TOKEN` | `local-dev-token` | Auth token for write operations |
| `JFP_SIGNING_ENABLED` | `0` | `1` = enable Ed25519 signing |
| `JFP_SIGNING_KEY` | _(none)_ | Path to Ed25519 private key PEM |

---

## Demo benchmark flow

The console exposes a controlled memory-pressure scenario to demonstrate the full trigger → intervention → cooldown cycle without manual load generation.

1. Click **UNLOCK SAFETY** — activates a 120-second safety unlock window
2. Click **START DEMO BENCHMARK** — starts a bounded `stress --vm` process (65% RAM, 60s, process-group controlled)
3. Observe in the timeline: `TRIGGER_HIT` → `INTERVENTION_EXECUTED` → `COOLDOWN_COMPLETE`
4. Click **PANIC STOP** at any time — immediate SIGKILL on the benchmark process group

The **ENGAGE JFP HEALER** button sends `policy.set_profile powersave` via RPC — a manual governor override logged as `OPERATOR_PROFILE_SET`.

---

## RPC protocol

The daemon exposes a JSON-RPC interface over a Unix socket. See `shared/protocol.json` for the full schema.

**Request format:**

```json
{
  "id": "550e8400-...",
  "method": "health.ping",
  "params": {},
  "session_token": ""
}
```

**Response format:**

```json
{
  "id": "550e8400-...",
  "ok": true,
  "result": { ... },
  "error": null,
  "server_ts": "2026-04-01T12:00:00Z"
}
```

### Methods

| Method | Auth | Description |
|---|---|---|
| `health.ping` | no | Daemon state, governor profile, proof counter |
| `metrics.get_current` | no | Full snapshot: CPU, RAM, temp, load, PSI, governors |
| `events.get_recent` | no | Last N records from the proof log |
| `policy.set_profile` | **yes** | Set CPU governor profile (`powersave`, `balanced`, `performance`) |
| `benchmark.unlock` | **yes** | Activate safety unlock (TTL: 120s) |
| `benchmark.start` | **yes** | Start demo scenario (`memory_pressure`) |
| `benchmark.stop` | **yes** | Stop running benchmark |
| `panic.stop` | **yes** | Emergency stop — kills benchmark, sets `powersave` |

### Error codes

| Code | Meaning |
|---|---|
| `E_AUTH` | Missing or wrong session token |
| `E_INVALID_METHOD` | Unknown RPC method |
| `E_INVALID_PARAMS` | Bad parameter value (profile, mode, etc.) |
| `E_POLICY_DENY` | Action blocked by Governor or Supervisor |
| `E_RUNTIME` | Internal daemon error |

---

## Metrics collected

Every tick (1s) the daemon collects:

- **CPU** — utilization %, per-core frequency MHz
- **RAM** — used %, available MB, cached MB
- **Temperature** — per sensor (psutil + `/sys/class/thermal` + `/sys/class/hwmon` fallbacks)
- **Load average** — 1m / 5m / 15m
- **CPU governor** — per-core scaling governor
- **PSI** — Pressure Stall Information: cpu / memory / io (Linux 4.20+)
- **Sensor health** — which subsystems reported successfully

---

## Trigger thresholds (defaults)

| Trigger | Threshold | Action |
|---|---|---|
| RAM high | > 90% | Intervention after 3 consecutive hits |
| RAM critical | > 95% | Governor constitution activates immediately |
| Temperature | > 85°C | Intervention |
| PSI memory avg10 | > 20% | Intervention |
| Load avg / cores | > 1.0 | Intervention |
| Load factor | > 1.5× | Governor constitution (hard guard) |
| Temperature | > 92°C | Governor constitution (hard guard) |

---

## Proof log verification

The proof log at `.runtime/jfp_proof.jsonl` (or `/var/log/jfp/jfp_proof.jsonl` in production) is a JSONL file where every record links to the previous via SHA-256.

```bash
# Verify hash chain integrity (no signing)
.venv/bin/python tools/verify_chain.py .runtime/jfp_proof.jsonl
# PASS: chain_valid records=47 signed=no

# Verify hash chain + Ed25519 signatures
.venv/bin/python tools/verify_chain.py .runtime/jfp_proof.jsonl \
  --pubkey .runtime/keys/ed25519_public.pem
# PASS: chain_valid records=47 signed=yes

# Verify mathematical consistency of intervention claims
.venv/bin/python tools/verify_claims.py .runtime/jfp_proof.jsonl
# PASS: claims_valid interventions=3
```

See `docs/JFP_Manifest_Proof_Manual_v1.md` for a full explanation of the proof record format, field semantics, and hash computation.

---

## Tests

```bash
make test
# or
.venv/bin/pytest tests/ -v
```

```
tests/test_governor.py        27 passed   GovernorConstitution — all branches
tests/test_supervisor.py      16 passed   Supervisor — trend, recommend, approve
tests/test_actions.py         12 passed   ActionExecutor — dry-run, allowlists
tests/test_logger.py          12 passed   ProofLogger — chain, recovery, Ed25519
tests/test_verify_chain.py    11 passed   verify_chain.py CLI — valid/tamper/signed
tests/test_verify_claims.py   9  passed   verify_claims.py CLI — claim math
tests/test_rpc_integration.py 31 passed   Live daemon RPC — all 8 methods + auth

123 passed in ~12s
```

---

## Project structure

```
daemon/
├── jfpd.py          Main daemon — monitor loop, RPC server, state machine
├── governor.py      GovernorConstitution — hard constitutional rules
├── supervisor.py    Supervisor — adaptive optimizer (RAM trend, recommendations)
├── actions.py       ActionExecutor — allowlisted system actions
├── logger.py        ProofLogger — SHA-256 chain + Ed25519 signing
├── metrics.py       System metric snapshot (CPU/RAM/temp/PSI/governor)
└── jfpd.service     Hardened systemd unit template

console/
├── main_ui.py       PySide6 operator dashboard
└── api_client.py    JFPClient — Unix socket JSON-RPC with retry

tools/
├── gen_signing_key.py   Generate Ed25519 key pair
├── verify_chain.py      Offline hash-chain + signature verifier
└── verify_claims.py     Intervention claim consistency verifier

shared/
└── protocol.json        IPC contract schema

docs/
├── JFP_v1_Implementation_Spec.md      Architecture and determinism spec
└── JFP_Manifest_Proof_Manual_v1.md    Proof log format and verification guide

tests/
├── conftest.py                  Shared fixtures (live daemon subprocess)
├── test_governor.py             GovernorConstitution unit tests
├── test_supervisor.py           Supervisor unit tests
├── test_actions.py              ActionExecutor unit tests
├── test_logger.py               ProofLogger unit tests
├── test_verify_chain.py         verify_chain.py integration tests
├── test_verify_claims.py        verify_claims.py integration tests
└── test_rpc_integration.py      Live daemon RPC integration tests

scripts/
├── install_system.sh    System-wide installation (root)
└── uninstall_system.sh  Uninstallation (root)

packaging/
└── JFP_Console_POC.desktop    Linux desktop entry for installed mode
```

---

## System deployment

For production deployment (daemon runs as root, systemd-managed):

```bash
# Install to /opt/jfp, enable jfpd.service
sudo ./scripts/install_system.sh

# Remove
sudo ./scripts/uninstall_system.sh
```

The systemd unit (`daemon/jfpd.service`) includes hardening directives: `NoNewPrivileges`, `PrivateTmp`, `ProtectHome`, `ProtectSystem=strict`, `RestrictAddressFamilies=AF_UNIX`, `MemoryDenyWriteExecute`.

---

## License

MIT