From 101eca270061b70f92b318dc04f8b2d089e1a0b6 Mon Sep 17 00:00:00 2001 From: CyberSecurityUP Date: Sun, 4 Oct 2026 01:06:28 -0300 Subject: [PATCH] fix: wildcard-target probe, per-run provenance, qwen via Hermes, broad default web objective MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Wildcard target from a scope-file (target: "*.nasa.gov") was probed literally → "builder error" / target unreachable. It's now reduced to the apex (https://nasa.gov) for the seed, while the scope keeps *.nasa.gov so subdomain enumeration stays authorized. (The /target command already did this; the engagement-file meta path didn't.) - Provenance was a OnceLock ("first run wins"), so in the REPL every run after the first minted markers and the provenance line with the FIRST run's id (nasa run showing a rockstargames id). Now a RwLock that rebinds per run — each engagement gets its own id; the build fingerprint stays stable. - Nous/Hermes: qwen3.8-max / qwen3.8-omni-flash added to the provider list so `nous:qwen3.8-max` routes qwen through the Hermes portal (model name passes through `hermes chat -m --provider nous`). - Black-box `run` now gets a broad DEFAULT objective when none is set: a comprehensive WEB assessment grounded in OWASP Top 10 / ASVS / WSTG / CWE that traverses every applicable web vuln class then goes deep — web-only (this path loads only web vuln agents; mobile/binary are separate modes), so it never drifts into mobile/exe. 423 tests passing. Co-Authored-By: Claude Opus 4.8 --- neurosploit-rs/app/src/main.rs | 5 ++- neurosploit-rs/app/src/repl.rs | 13 ++++++- neurosploit-rs/crates/harness/src/models.rs | 5 ++- neurosploit-rs/crates/harness/src/pipeline.rs | 22 ++++++++++- .../crates/harness/src/provenance.rs | 39 +++++++++++-------- 5 files changed, 63 insertions(+), 21 deletions(-) diff --git a/neurosploit-rs/app/src/main.rs b/neurosploit-rs/app/src/main.rs index 78e1300..37b901a 100644 --- a/neurosploit-rs/app/src/main.rs +++ b/neurosploit-rs/app/src/main.rs @@ -1925,8 +1925,9 @@ fn handle_provenance(cmd: ProvCmd) -> anyhow::Result<()> { } // A marker carrying this build's fingerprint came from this binary; // one that does not still came from NeuroSploit, just elsewhere. - let mine = marks.iter().filter(|m| m.contains(&Provenance::process().build[..6])).count(); - println!(" \x1b[2m{mine} of them minted by this build ({}), the rest by another\x1b[0m", Provenance::process().build); + let bld = Provenance::process().build; + let mine = marks.iter().filter(|m| m.contains(&bld[..6.min(bld.len())])).count(); + println!(" \x1b[2m{mine} of them minted by this build ({bld}), the rest by another\x1b[0m"); } ProvCmd::Verify { dir } => { let dir = std::path::Path::new(&dir); diff --git a/neurosploit-rs/app/src/repl.rs b/neurosploit-rs/app/src/repl.rs index 605310a..02895b2 100644 --- a/neurosploit-rs/app/src/repl.rs +++ b/neurosploit-rs/app/src/repl.rs @@ -927,7 +927,18 @@ pub async fn repl(base: &Path, auth: SessionAuth) -> anyhow::Result<()> { // classes — so one YAML defines the whole engagement. if let Ok(text) = std::fs::read_to_string(path) { let meta = read_engagement_meta(&text); - if let Some(t) = meta.target { if s.policy.in_hard_scope(&t) { s.target = Some(t.clone()); println!(" \x1b[2m· target: {t}\x1b[0m"); } else { println!(" \x1b[33m⚠ file's target {t} is outside its own scope — ignored\x1b[0m"); } } + if let Some(t) = meta.target { + if s.policy.in_hard_scope(&t) { + // A wildcard target (`*.nasa.gov`) is not a + // host to probe — seed with the apex, since + // the scope already authorizes the subdomains. + let host = harness::scope::host_of(&t); + let seed = if let Some(apex) = host.strip_prefix("*.") { format!("https://{apex}") } + else if t.contains("://") { t.clone() } else { format!("https://{host}") }; + s.target = Some(seed.clone()); + println!(" \x1b[2m· target: {seed}\x1b[0m"); + } else { println!(" \x1b[33m⚠ file's target {t} is outside its own scope — ignored\x1b[0m"); } + } if !meta.models.is_empty() { s.models = meta.models.clone(); println!(" \x1b[2m· models: {}\x1b[0m", meta.models.join(", ")); } if let Some(f) = meta.focus { s.instructions = Some(f.clone()); println!(" \x1b[2m· focus: {f}\x1b[0m"); } if let Some(o) = meta.objective { s.objective = Some(o.clone()); println!(" \x1b[2m· objective: {o}\x1b[0m"); } diff --git a/neurosploit-rs/crates/harness/src/models.rs b/neurosploit-rs/crates/harness/src/models.rs index e73e141..14362dc 100644 --- a/neurosploit-rs/crates/harness/src/models.rs +++ b/neurosploit-rs/crates/harness/src/models.rs @@ -68,8 +68,11 @@ pub fn providers() -> Vec { // or (with --subscription) driven through the `hermes` CLI // (NousResearch/hermes-agent) on the user's OAuth Portal login // (`hermes setup --portal`) — 300+ routed frontier models, no key. + // The Hermes portal routes 300+ models, so the model name passes through + // (`hermes chat -m --provider nous`): `nous:qwen3.8-max` and other + // routed models work even though only the Hermes-family defaults are listed. Provider { key: "nous", label: "Nous Research (Hermes)", base_url: "https://inference-api.nousresearch.com/v1", env_key: "NOUS_API_KEY", kind: "cli", - models: vec!["Hermes-4-405B", "Hermes-4-70B", "DeepHermes-3-Mistral-24B-Preview"] }, + models: vec!["Hermes-4-405B", "Hermes-4-70B", "DeepHermes-3-Mistral-24B-Preview", "qwen3.8-max", "qwen3.8-omni-flash"] }, // Azure OpenAI (OpenAI-compatible). Set AZURE_OPENAI_ENDPOINT (e.g. // https://.openai.azure.com), optionally AZURE_OPENAI_API_VERSION // (default 2024-10-21), and use `azure:` as the model. diff --git a/neurosploit-rs/crates/harness/src/pipeline.rs b/neurosploit-rs/crates/harness/src/pipeline.rs index de0154e..7520b04 100644 --- a/neurosploit-rs/crates/harness/src/pipeline.rs +++ b/neurosploit-rs/crates/harness/src/pipeline.rs @@ -614,6 +614,16 @@ const DECISION_DOCTRINE: &str = "DECIDE WHERE TO ATTACK (analyse, then act):\n\ - Build PoCs when needed: for issues that need an artifact to prove (clickjacking → an HTML page that frames the target; CSRF → an auto-submitting HTML form; a multi-step or timing exploit → a script), WRITE the PoC to the run's PoC dir, run/validate it, and cite the file in the evidence.\n\ - Test control BYPASSES: when something returns 401/403/redirect or is 'blocked', try to bypass it (verb tampering, path/case/encoding normalization, X-Original-URL / X-Rewrite-URL / X-Forwarded-* headers, missing-vs-invalid token, direct object/API access) and confirm the bypass with the two requests.\n\n"; +/// Broad default objective for a black-box WEB engagement (used when the +/// operator set none). Grounds the run in the recognised web standards and asks +/// for full-breadth coverage so it traverses every applicable class, then goes +/// deep where signal is strong — without drifting off web (mobile/binary are +/// separate modes). +const DEFAULT_WEB_OBJECTIVE: &str = "Comprehensive black-box WEB application penetration test. \ +Methodology: OWASP Top 10 (2021), OWASP ASVS verification requirements, the OWASP Web Security Testing Guide, and CWE for classification. \ +COVER THE WHOLE SURFACE — traverse every web vulnerability class that the recon makes applicable (injection: SQL/NoSQL/command/SSTI/LDAP/XPath; XSS reflected/stored/DOM; access control: IDOR/BOLA/BFLA/privilege escalation/forced browsing; authentication & session: login, signup, password reset, MFA, OAuth/OIDC/SAML, JWT; SSRF; XXE; insecure deserialization; CSRF; open redirect; CORS; file upload/download & path traversal; business-logic & multi-step flow abuse; mass assignment; request smuggling; info disclosure & security misconfiguration; cryptographic failures; known-CVE components) — do not stop at the first class that yields something. \ +Then go DEEP where the signal is strong: prove impact with a real receipt, chain footholds into higher impact, and prioritise the authenticated surface and less-hardened subdomains. This is a WEB engagement only — do not attempt mobile/binary analysis."; + /// FREE EXPLORATION doctrine: the agent is NOT limited to its named vuln class. /// This is what stops a run collapsing into "only SQLi": every exploit agent is /// told to hunt the whole application with its own judgment and report ANY class @@ -777,9 +787,19 @@ fn write_meta(cfg: &RunConfig, p: &crate::probe::Probe, asset: &str) { } /// Black-box web engagement: recon → parallel exploit → N-model vote → report. -pub async fn run(cfg: RunConfig, lib: &Library, pool: &ModelPool, tx: Sender) -> RunOutput { +pub async fn run(mut cfg: RunConfig, lib: &Library, pool: &ModelPool, tx: Sender) -> RunOutput { pool.set_progress(tx.clone()); + // A broad DEFAULT objective for a black-box web engagement when the operator + // set none — so a plain `/run` already does a comprehensive web assessment + // grounded in OWASP Top 10 / ASVS / CWE and traverses every applicable web + // vuln class, instead of stopping at the first thing it finds. Web-only by + // construction: this `run` path loads only the web vuln agents (mobile/APK + // and container are separate modes), so it never drifts into mobile/binary. + if cfg.objective.as_deref().map(|o| o.trim().is_empty()).unwrap_or(true) { + cfg.objective = Some(DEFAULT_WEB_OBJECTIVE.to_string()); + } + // Authorization first. A supplied token that does not verify ends the run // here: proceeding would mean acting on a grant nobody can prove was // issued, which is the one failure this whole layer exists to prevent. diff --git a/neurosploit-rs/crates/harness/src/provenance.rs b/neurosploit-rs/crates/harness/src/provenance.rs index 7557788..7ef0345 100644 --- a/neurosploit-rs/crates/harness/src/provenance.rs +++ b/neurosploit-rs/crates/harness/src/provenance.rs @@ -48,7 +48,7 @@ fn now_secs() -> u64 { .unwrap_or(0) } -static PROCESS: std::sync::OnceLock = std::sync::OnceLock::new(); +static PROCESS: std::sync::RwLock> = std::sync::RwLock::new(None); /// Identity of one build of the engine, plus the run currently using it. #[derive(Debug, Clone, Serialize, Deserialize)] @@ -121,15 +121,18 @@ impl Provenance { /// made by that process agrees on which engagement it belongs to. Reading /// it before it is bound is fine — it mints an ad-hoc identity rather than /// failing, because an unattributed artifact is worse than a vague one. - pub fn process() -> &'static Provenance { - PROCESS.get_or_init(|| Provenance::for_run("")) + pub fn process() -> Provenance { + PROCESS.read().ok().and_then(|g| g.clone()).unwrap_or_else(|| Provenance::for_run("")) } - /// Bind this process to a run. First call wins: a run's identity must not - /// change underneath the markers already minted against it. - pub fn bind_run(run_id: &str) -> &'static Provenance { - let _ = PROCESS.set(Provenance::for_run(run_id)); - Provenance::process() + /// Bind this process to a run. In the REPL many engagements run in one + /// process, so this REPLACES the binding each run — otherwise every run + /// after the first would mint markers (and the provenance line) with the + /// FIRST run's id. Markers minted within a run use that run's provenance. + pub fn bind_run(run_id: &str) -> Provenance { + let p = Provenance::for_run(run_id); + if let Ok(mut g) = PROCESS.write() { *g = Some(p.clone()); } + p } /// Short identity string: what goes in a footer or a log line. @@ -393,14 +396,18 @@ mod tests { } #[test] - fn process_provenance_is_stable_once_bound() { - let a = Provenance::process().run.clone(); - let b = Provenance::process().run.clone(); - assert_eq!(a, b, "markers minted in one process must agree on the run"); - // Binding after the fact must not move the ground under markers that - // already went out. - let c = Provenance::bind_run("ns-9-other").run.clone(); - assert_eq!(a, c, "first identity wins"); + fn bind_run_rebinds_per_run_so_the_repl_gets_each_runs_id() { + // The REPL runs many engagements in one process; each run must bind its + // OWN id, or every run after the first mints markers/the provenance line + // with the FIRST run's id (the stale-provenance bug). + let a = Provenance::bind_run("ns-1-alpha").run.clone(); + assert_eq!(a, "ns-1-alpha"); + assert_eq!(Provenance::process().run, "ns-1-alpha", "process() reflects the bound run"); + let b = Provenance::bind_run("ns-2-bravo").run.clone(); + assert_eq!(b, "ns-2-bravo"); + assert_eq!(Provenance::process().run, "ns-2-bravo", "a later run rebinds"); + // The build fingerprint stays stable across rebinds. + assert_eq!(Provenance::process().build, Provenance::build_fingerprint()); } #[test]