From 260b480df6418dede84fbab50a19d12d1bc6f221 Mon Sep 17 00:00:00 2001 From: AlexRV12 <71396855+AlexRV12@users.noreply.github.com> Date: Thu, 12 Nov 2026 16:42:11 +0100 Subject: [PATCH] fix: refuse a hub path named by a member without the code capability (#12381) --- backend/tests/hub_named_path.rs | 165 +++++++++++++++++++++++++++ backend/windmill-api/src/apps.rs | 6 +- backend/windmill-common/src/jobs.rs | 26 ++++- backend/windmill-common/src/roles.rs | 4 +- 4 files changed, 196 insertions(+), 5 deletions(-) create mode 100644 backend/tests/hub_named_path.rs diff --git a/backend/tests/hub_named_path.rs b/backend/tests/hub_named_path.rs new file mode 100644 index 0000000000..72530e7b4e --- /dev/null +++ b/backend/tests/hub_named_path.rs @@ -0,0 +1,165 @@ +//! A Hub path named at run time is refused to a member whose role cannot write code, on every +//! route that takes one. + +use serde_json::json; +use sqlx::{Pool, Postgres}; +use windmill_common::{ + jobs::{check_can_name_runnable, RunOrigin}, + runnable_ref::RunnableRef, +}; +use windmill_test_utils::*; + +const DEV: &str = "SECRET_TOKEN_2"; +const OP: &str = "OPERATOR_TOKEN"; +const HUB_ID: i32 = 990000792; +const REFUSAL: &str = "Hub scripts and flows require a role that can write code"; + +#[sqlx::test(fixtures("base"))] +async fn a_hub_path_named_without_code_is_refused(db: Pool) -> anyhow::Result<()> { + initialize_tracing().await; + let server = ApiServer::start(db.clone()).await?; + let port = server.addr.port(); + let ws = format!("http://localhost:{port}/api/w/test-workspace"); + let hub_path = format!("hub/{HUB_ID}/test/echo"); + + let hub_dir = &*windmill_common::worker::HUB_CACHE_DIR; + tokio::fs::create_dir_all(hub_dir).await?; + tokio::fs::write( + format!("{hub_dir}/{HUB_ID}"), + json!({ + "content": "echo ok", "lockfile": null, "language": "bash", + "schema": {}, "summary": null, + }) + .to_string(), + ) + .await?; + + sqlx::raw_sql( + "INSERT INTO password(email, password_hash, login_type, super_admin, verified, name) + VALUES ('op@windmill.dev', 'x', 'password', false, true, 'Op'); + INSERT INTO usr(workspace_id, email, username, is_admin, operator, role) + VALUES ('test-workspace', 'op@windmill.dev', 'op', false, true, 'Operator'); + INSERT INTO token(token_hash, token_prefix, token, email, label, super_admin) + VALUES (encode(sha256('OPERATOR_TOKEN'::bytea), 'hex'), 'OPERATOR_T', 'OPERATOR_TOKEN', + 'op@windmill.dev', 'op', false); + INSERT INTO app (id, workspace_id, path, summary, policy, versions) + VALUES (999792, 'test-workspace', 'u/test-user/vapp', '', + '{\"execution_mode\": \"viewer\", \"triggerables_v2\": {}}'::jsonb, '{}');", + ) + .execute(&db) + .await?; + // What a schedule with a handler pushes for a Hub script: batch rerun reaches its path. + for (id, user) in [ + ("2aa0c0de-0000-4000-8000-000000000791", "test-user-2"), + ("2aa0c0de-0000-4000-8000-000000000792", "op"), + ] { + sqlx::query( + "INSERT INTO v2_job(id, workspace_id, kind, runnable_path, created_by, permissioned_as, + permissioned_as_email, args, raw_flow) + VALUES ($1::uuid, 'test-workspace', 'singlestepflow', $2, $3, 'u/' || $3, '', '{}', + jsonb_build_object('modules', jsonb_build_array(jsonb_build_object( + 'id', 'a', 'value', jsonb_build_object('type', 'script', 'path', $2::text)))))", + ) + .bind(id) + .bind(&hub_path) + .bind(user) + .execute(&db) + .await?; + } + + let client = reqwest::Client::new(); + let send = |token: &'static str, route: &'static str| { + let (ws, client, hub_path) = (ws.clone(), client.clone(), hub_path.clone()); + let rerun_id = if token == OP { "792" } else { "791" }; + async move { + let req = + match route { + "run/p" => client + .post(format!("{ws}/jobs/run/p/{hub_path}")) + .json(&json!({})), + "run_wait_result/p POST" => client + .post(format!("{ws}/jobs/run_wait_result/p/{hub_path}")) + .json(&json!({})), + "run_wait_result/p GET" => { + client.get(format!("{ws}/jobs/run_wait_result/p/{hub_path}")) + } + "run_and_stream/p POST" => client + .post(format!("{ws}/jobs/run_and_stream/p/{hub_path}")) + .json(&json!({})), + "run_and_stream/p GET" => { + client.get(format!("{ws}/jobs/run_and_stream/p/{hub_path}")) + } + "dynamic_select" => client + .post(format!("{ws}/jobs/run/dynamic_select")) + .json(&json!({ "entrypoint_function": "main", "runnable_ref": + { "source": "deployed", "path": hub_path, "runnable_kind": "script" } })), + "batch_rerun" => client.post(format!("{ws}/jobs/run/batch_rerun_jobs")).json( + &json!({ + "job_ids": [format!("2aa0c0de-0000-4000-8000-000000000{rerun_id}")], + "script_options_by_path": { hub_path: { "use_latest_version": true } }, + "flow_options_by_path": {}, + }), + ), + "app component" => client + .post(format!("{ws}/apps_u/execute_component/u/test-user/vapp")) + .json(&json!({ + "component": "a", "path": format!("script/{hub_path}"), "args": {} + })), + // A flow at `hub/123` has no Hub id, so only the path marks it as Hub; the + // developer gets past the check to the workspace lookup, which finds none. + "app component flow" => client + .post(format!("{ws}/apps_u/execute_component/u/test-user/vapp")) + .json(&json!({ "component": "a", "path": "flow/hub/123", "args": {} })), + _ => unreachable!(), + }; + let resp = req.bearer_auth(token).send().await.unwrap(); + let status = resp.status(); + (status, resp.text().await.unwrap()) + } + }; + + let routes = [ + "run/p", + "run_wait_result/p POST", + "run_wait_result/p GET", + "run_and_stream/p POST", + "run_and_stream/p GET", + "dynamic_select", + "batch_rerun", + "app component", + "app component flow", + ]; + in_test_worker( + &db, + async { + for route in routes { + let (status, body) = send(OP, route).await; + // Batch rerun reports every failure as the same "Couldn't re-run" line. + let refused = (status == 403 && body.contains(REFUSAL)) + || (route == "batch_rerun" && body.starts_with("Error: ")); + assert!(refused, "op on {route}: {status} {body}"); + + let (status, body) = send(DEV, route).await; + let ran = if route == "app component flow" { + status == 404 && body.contains("flow not found") + } else { + status.is_success() && !body.contains("Error") + }; + assert!(ran, "dev on {route}: {status} {body}"); + } + }, + port, + ) + .await; + + let op = windmill_api_auth::ApiAuthed { + email: "op@windmill.dev".into(), + username: "op".into(), + is_operator: true, + ..Default::default() + }; + let preset = RunnableRef::from_path("hub/2431/slack/schedule-error-handler-slack", false)?; + let origin = RunOrigin::NamedBy(op.to_authed_ref()); + check_can_name_runnable(&origin, &preset, &db, "test-workspace").await?; + Ok(()) +} diff --git a/backend/windmill-api/src/apps.rs b/backend/windmill-api/src/apps.rs index b79a655659..672e7b2b2e 100644 --- a/backend/windmill-api/src/apps.rs +++ b/backend/windmill-api/src/apps.rs @@ -4684,9 +4684,9 @@ async fn execute_component( // A builder testing the app it is composing only ever previews a deployed runnable // (`path`), confined below to what it may read. Inline `raw_code`, which an `id` also // requires, is authoring code, so it stays closed to every operator. So is a hub - // path, which `require_path_read_access_for_preview` admits for everyone and - // `runnable_ref_to_payload` then downloads and enqueues: it is exactly the - // unreviewed code the composition check refuses in a flow. + // path, which `require_path_read_access_for_preview` admits for everyone, and which + // `check_can_name_runnable` also refuses further on: it is exactly the unreviewed + // code the composition check refuses in a flow. let previews_hub = preview_path.is_some_and(|p| p.starts_with("hub/")); let caps = caller_capabilities(&db, &w_id, authed).await?; if !caps.code diff --git a/backend/windmill-common/src/jobs.rs b/backend/windmill-common/src/jobs.rs index b6bb6d1b70..c944485b19 100644 --- a/backend/windmill-common/src/jobs.rs +++ b/backend/windmill-common/src/jobs.rs @@ -177,9 +177,31 @@ impl ChosenBy { } } +/// Refuses a Hub script or flow named by a member whose role cannot write code, preset handlers +/// excepted. Gated on the path, not `hub_id()`: a flow at `hub/123` has none. +pub async fn check_can_name_runnable( + origin: &RunOrigin<'_>, + runnable: &RunnableRef, + db: &DB, + w_id: &str, +) -> error::Result<()> { + let RunOrigin::NamedBy(authed) = origin else { + return Ok(()); + }; + if !runnable.path().starts_with("hub/") || runnable.preset_handler().is_some() { + return Ok(()); + } + if crate::roles::caller_capabilities(db, w_id, authed).await?.code { + return Ok(()); + } + Err(Error::PermissionDenied( + "Hub scripts and flows require a role that can write code. Ask a developer to deploy it to the workspace.".to_string(), + )) +} + pub async fn script_path_to_payload<'e>( script: &RunnableRef, - _origin: RunOrigin<'_>, + origin: RunOrigin<'_>, db_authed: Option>>, db: DB, w_id: &str, @@ -192,6 +214,7 @@ pub async fn script_path_to_payload<'e>( Option, Option, )> { + check_can_name_runnable(&origin, script, &db, w_id).await?; let script_path = script.path(); let (job_payload, tag, delete_after_use, delete_after_secs, script_timeout, on_behalf_of) = if let Some(hub_id) = script.hub_id() { @@ -284,6 +307,7 @@ pub async fn runnable_ref_to_payload( let (payload, tag, _, _, _, on_behalf_of) = if !runnable.is_flow() { script_path_to_payload(runnable, origin, None, db.clone(), w_id, Some(true)).await? } else { + check_can_name_runnable(&origin, runnable, db, w_id).await?; let path = runnable.path().to_string(); if let Some(hub_id) = runnable.hub_id() { let hub_flow = get_full_hub_flow_by_id(hub_id, &HTTP_CLIENT, Some(db)).await?; diff --git a/backend/windmill-common/src/roles.rs b/backend/windmill-common/src/roles.rs index c2de5520c0..1f7822437a 100644 --- a/backend/windmill-common/src/roles.rs +++ b/backend/windmill-common/src/roles.rs @@ -86,7 +86,9 @@ impl RoleVisibility { pub struct RoleCapabilities { /// Author scripts and run code of one's own on a worker: script previews, dependency jobs, /// dynamic selects, resolving a job's code, data table migrations. `Full` flows or apps - /// require it, since both carry inline code. Previews also need `run`. + /// require it, since both carry inline code. Previews also need `run`. Also required to name + /// a Hub script or flow at run time (preset handlers excepted), see + /// [`crate::jobs::check_can_name_runnable`]. pub code: bool, pub flows: AuthorLevel, pub apps: AuthorLevel,