Skip to content

ServerKit is a lightweight, modern server control panel for managing web applications, databases, and services on your VPS or dedicated server. Built with Python/Flask backend and React frontend.

fix(api): close IDOR/authz gaps across deployment jobs, vaults, queues, docker, databases

Juan Denisd961bd23f081
diff --git a/backend/app/api/databases.py b/backend/app/api/databases.py
index 4cc82f9b..5f2481d1 100644
--- a/backend/app/api/databases.py
+++ b/backend/app/api/databases.py
@@ -1,6 +1,10 @@
# Bucket: PER-APP (plan 29 #9). The per-app docker DB read (/docker/app/<app_id>)
# gates on can_access_app; the bare-container docker routes have no app linkage
# and are system-level admin-only, matching their kill/drop siblings.
+# The host-level raw routes (engine lists, tables/structure, users/privileges,
+# backups list, and the raw query consoles) likewise have no app linkage and are
+# admin-only (Decision 7) — per-app managed-database flows go through the
+# /docker/app/<app_id> and /managed surfaces instead.
import logging
from flask import Blueprint, request, jsonify
@@ -50,6 +54,7 @@ def get_status():
@databases_bp.route('/mysql', methods=['GET'])
@jwt_required()
+@admin_required
def list_mysql_databases():
"""List MySQL databases.
@@ -115,6 +120,7 @@ def drop_mysql_database(name):
@databases_bp.route('/mysql/<name>/tables', methods=['GET'])
@jwt_required()
+@admin_required
def get_mysql_tables(name):
"""Get tables in a MySQL database.
@@ -157,6 +163,7 @@ def restore_mysql_database(name):
@databases_bp.route('/mysql/users', methods=['GET'])
@jwt_required()
+@admin_required
def list_mysql_users():
"""List MySQL users.
@@ -215,6 +222,7 @@ def drop_mysql_user(username):
@databases_bp.route('/mysql/users/<username>/privileges', methods=['GET'])
@jwt_required()
+@admin_required
def get_mysql_user_privileges(username):
"""Get privileges for a MySQL user.
@@ -270,6 +278,7 @@ def revoke_mysql_privileges(username):
@databases_bp.route('/postgresql', methods=['GET'])
@jwt_required()
+@admin_required
def list_pg_databases():
"""List PostgreSQL databases."""
databases = DatabaseService.pg_list_databases()
@@ -317,6 +326,7 @@ def drop_pg_database(name):
@databases_bp.route('/postgresql/<name>/tables', methods=['GET'])
@jwt_required()
+@admin_required
def get_pg_tables(name):
"""Get tables in a PostgreSQL database."""
tables = DatabaseService.pg_get_tables(name)
@@ -350,6 +360,7 @@ def restore_pg_database(name):
@databases_bp.route('/postgresql/users', methods=['GET'])
@jwt_required()
+@admin_required
def list_pg_users():
"""List PostgreSQL users."""
users = DatabaseService.pg_list_users()
@@ -433,6 +444,7 @@ def revoke_pg_privileges(username):
@databases_bp.route('/backups', methods=['GET'])
@jwt_required()
+@admin_required
def list_backups():
"""List all database backups."""
db_type = request.args.get('type')
@@ -453,6 +465,7 @@ def delete_backup(filename):
@databases_bp.route('/mysql/<name>/query', methods=['POST'])
@jwt_required()
+@admin_required
def execute_mysql_query(name):
"""Execute a query on a MySQL database.
@@ -493,6 +506,7 @@ def execute_mysql_query(name):
@databases_bp.route('/postgresql/<name>/query', methods=['POST'])
@jwt_required()
+@admin_required
def execute_pg_query(name):
"""Execute a query on a PostgreSQL database.
@@ -531,6 +545,7 @@ def execute_pg_query(name):
@databases_bp.route('/sqlite/query', methods=['POST'])
@jwt_required()
+@admin_required
def execute_sqlite_query():
"""Execute a query on a SQLite database file.
@@ -571,6 +586,7 @@ def execute_sqlite_query():
@databases_bp.route('/mysql/<name>/tables/<table>/structure', methods=['GET'])
@jwt_required()
+@admin_required
def get_mysql_table_structure(name, table):
"""Get the structure/schema of a MySQL table."""
root_password = request.headers.get('X-DB-Password')
@@ -580,6 +596,7 @@ def get_mysql_table_structure(name, table):
@databases_bp.route('/postgresql/<name>/tables/<table>/structure', methods=['GET'])
@jwt_required()
+@admin_required
def get_pg_table_structure(name, table):
"""Get the structure/schema of a PostgreSQL table."""
result = DatabaseService.pg_get_table_structure(name, table)
@@ -588,6 +605,7 @@ def get_pg_table_structure(name, table):
@databases_bp.route('/sqlite/tables/<table>/structure', methods=['GET'])
@jwt_required()
+@admin_required
def get_sqlite_table_structure(table):
"""Get the structure/schema of a SQLite table.
@@ -604,6 +622,7 @@ def get_sqlite_table_structure(table):
@databases_bp.route('/sqlite', methods=['GET'])
@jwt_required()
+@admin_required
def list_sqlite_databases():
"""List SQLite database files found in common locations."""
databases = DatabaseService.sqlite_list_databases()
@@ -612,6 +631,7 @@ def list_sqlite_databases():
@databases_bp.route('/sqlite/tables', methods=['GET'])
@jwt_required()
+@admin_required
def get_sqlite_tables():
"""Get tables in a SQLite database.
@@ -940,6 +960,7 @@ def _process_error_response(result):
@databases_bp.route('/mysql/processes', defaults={'engine': 'mysql'}, methods=['GET'])
@databases_bp.route('/postgresql/processes', defaults={'engine': 'postgresql'}, methods=['GET'])
@jwt_required()
+@admin_required
def list_host_db_processes(engine):
"""List live server processes on a host engine."""
target = {'engine': engine, 'password': request.headers.get('X-DB-Password')}
diff --git a/backend/app/api/deployment_jobs.py b/backend/app/api/deployment_jobs.py
index 6e6e5c85..d236dfe4 100644
--- a/backend/app/api/deployment_jobs.py
+++ b/backend/app/api/deployment_jobs.py
@@ -1,14 +1,39 @@
+# Bucket: PER-APP (plan 29 #9). App-linked job reads gate on the app-grant
+# seam (can_access_app); retries require can_operate_app. App-less jobs
+# (template installs, simulated deploys) are requester-or-admin only. The
+# job list is admin-only globally and app-access-gated when app_id is given.
"""Deployment job API endpoints."""
from flask import Blueprint, current_app, request, jsonify
-from flask_jwt_extended import jwt_required
+from flask_jwt_extended import jwt_required, get_jwt_identity
+from app.middleware.rbac import app_access_tier
+from app.models import User, Application
from app.models.deployment_job import DeploymentJob, DeploymentJobLog
from app.services.deployment_job_service import DeploymentJobService
+from app.services.resource_grant_service import ResourceGrantService
deployment_jobs_bp = Blueprint('deployment_jobs', __name__)
+def _job_visible_to(user, job):
+ """Read gate for one job: app-linked jobs follow the app's grant seam;
+ app-less jobs belong to their requester (or a panel admin)."""
+ if job.app_id:
+ app = Application.query.get(job.app_id)
+ return app is not None and ResourceGrantService.can_access_app(user, app)
+ return user.is_admin or job.requested_by == user.id
+
+
+def _job_operable_by(user, job):
+ """Operate gate (retry): app-linked jobs need member+ on the app; app-less
+ jobs stay requester-or-admin."""
+ if job.app_id:
+ app = Application.query.get(job.app_id)
+ return app is not None and ResourceGrantService.can_operate_app(user, app)
+ return user.is_admin or job.requested_by == user.id
+
+
@deployment_jobs_bp.route('/simulate', methods=['GET'])
@jwt_required()
def get_simulate_info():
@@ -51,10 +76,24 @@ def simulate_deployment():
@deployment_jobs_bp.route('', methods=['GET'])
@jwt_required()
def list_deployment_jobs():
+ """List deployment jobs. App-scoped queries require access to that app;
+ global queries (no app_id) are restricted to panel admins."""
+ current_user_id = get_jwt_identity()
+ user = User.query.get(current_user_id)
status = request.args.get('status')
target_server_id = request.args.get('server_id')
app_id = request.args.get('app_id', type=int)
limit = request.args.get('limit', 50, type=int)
+
+ if app_id:
+ app = Application.query.get(app_id)
+ if not app:
+ return jsonify({'error': 'Application not found'}), 404
+ if not user or app_access_tier(user, app) is None:
+ return jsonify({'error': 'Access denied'}), 403
+ elif not user or not user.is_admin:
+ return jsonify({'error': 'Access denied'}), 403
+
jobs = DeploymentJobService.list_jobs(
status=status,
target_server_id=target_server_id,
@@ -69,12 +108,14 @@ def list_deployment_jobs():
def get_deployment_job(job_id):
include_logs = request.args.get('logs', 'true').lower() == 'true'
include_plan = request.args.get('plan', 'false').lower() == 'true'
- job = DeploymentJobService.get_job(
- job_id, include_logs=include_logs, include_plan=include_plan
- )
+ job = DeploymentJob.query.get(job_id)
if not job:
return jsonify({'error': 'Deployment job not found'}), 404
- return jsonify({'job': job}), 200
+ user = User.query.get(get_jwt_identity())
+ if not user or not _job_visible_to(user, job):
+ return jsonify({'error': 'Access denied'}), 403
+ return jsonify({'job': job.to_dict(include_logs=include_logs,
+ include_plan=include_plan)}), 200
@deployment_jobs_bp.route('/<job_id>/retry', methods=['POST'])
@@ -82,7 +123,12 @@ def get_deployment_job(job_id):
def retry_deployment_job(job_id):
"""Retry a failed deployment job by cloning it and enqueuing a fresh run
(plan 51 D8). Only failed jobs may be retried."""
- from flask_jwt_extended import get_jwt_identity
+ job = DeploymentJob.query.get(job_id)
+ if not job:
+ return jsonify({'error': 'Deployment job not found'}), 404
+ user = User.query.get(get_jwt_identity())
+ if not user or not _job_operable_by(user, job):
+ return jsonify({'error': 'Access denied'}), 403
result = DeploymentJobService.retry_job(job_id, user_id=get_jwt_identity())
if not result.get('success'):
# Distinguish "no such job" from a state/enqueue error.
@@ -97,6 +143,9 @@ def get_deployment_job_logs(job_id):
job = DeploymentJob.query.get(job_id)
if not job:
return jsonify({'error': 'Deployment job not found'}), 404
+ user = User.query.get(get_jwt_identity())
+ if not user or not _job_visible_to(user, job):
+ return jsonify({'error': 'Access denied'}), 403
after_id = request.args.get('after_id', type=int)
query = DeploymentJobLog.query.filter_by(job_id=job_id)
diff --git a/backend/app/api/docker.py b/backend/app/api/docker.py
index d33b06f9..410e7e2e 100644
--- a/backend/app/api/docker.py
+++ b/backend/app/api/docker.py
@@ -49,8 +49,12 @@ def list_containers():
@docker_bp.route('/containers/<container_id>', methods=['GET'])
@jwt_required()
+@admin_required
def get_container(container_id):
- """Get container details."""
+ """Get container details.
+
+ Admin-only (Decision 7): raw inspect output includes the container's env
+ vars — i.e. app secrets — and there is no container→app linkage to gate on."""
container = DockerService.get_container(container_id)
if container:
return jsonify({'container': container}), 200
@@ -174,8 +178,12 @@ def remove_container(container_id):
@docker_bp.route('/containers/<container_id>/logs', methods=['GET'])
@jwt_required()
+@admin_required
def get_container_logs(container_id):
- """Get container logs."""
+ """Get container logs.
+
+ Admin-only (Decision 7): raw container logs can carry app secrets and there
+ is no container→app linkage to gate on; per-app logs go through apps.py."""
tail = request.args.get('tail', 100, type=int)
since = request.args.get('since')
result = DockerService.get_container_logs(container_id, tail, since)
diff --git a/backend/app/api/queue_bus.py b/backend/app/api/queue_bus.py
index 5a2d9024..70e0c715 100644
--- a/backend/app/api/queue_bus.py
+++ b/backend/app/api/queue_bus.py
@@ -34,6 +34,28 @@ def _ensure_group_mutable(group_slug):
raise QueueBusError('System queue groups are read-only', 403)
+def _ensure_group_accessible(group_slug):
+ """Reject message reads/acks against queue groups the caller doesn't own.
+
+ System-owned groups (jobs, notifications, webhook deliveries, ...) carry
+ internal payloads and are admin-only over the REST API — otherwise any user
+ could pop messages (visibility timeout) and stall internal processing, or
+ read/ack/kill them. User-owned groups are limited to the owning user (and
+ admins). Internal producers and consumers call ``QueueBusService`` directly
+ and are unaffected by this guard.
+ """
+ group = QueueBusService.get_group(group_slug)
+ if not group:
+ return # missing group — the service call below raises the 404
+ user = _current_user()
+ if _is_admin(user):
+ return
+ if (group.get('owner_type') == 'user' and user is not None
+ and group.get('owner_id') == str(user.id)):
+ return
+ raise QueueBusError('Access denied', 403)
+
+
def _handle_error(e):
if isinstance(e, QueueBusError):
return jsonify({'error': e.message}), e.status_code
@@ -228,6 +250,7 @@ def delete_queue(group_slug, queue_slug):
@jwt_required()
def list_messages(group_slug, queue_slug):
try:
+ _ensure_group_accessible(group_slug)
status = request.args.get('status')
limit = request.args.get('limit', 100, type=int)
offset = request.args.get('offset', 0, type=int)
@@ -274,6 +297,7 @@ def send_message(group_slug, queue_slug):
@jwt_required()
def receive_messages(group_slug, queue_slug):
try:
+ _ensure_group_accessible(group_slug)
data = request.get_json() or {}
visibility_timeout_ms = data.get('visibility_timeout_ms', 30000)
max_messages = data.get('max_messages', 1)
@@ -293,6 +317,7 @@ def receive_messages(group_slug, queue_slug):
@jwt_required()
def get_message(group_slug, queue_slug, message_id):
try:
+ _ensure_group_accessible(group_slug)
message = QueueBusService.get_message(group_slug, queue_slug, message_id)
if not message:
return jsonify({'error': 'Message not found'}), 404
@@ -305,6 +330,7 @@ def get_message(group_slug, queue_slug, message_id):
@jwt_required()
def complete_message(group_slug, queue_slug, message_id):
try:
+ _ensure_group_accessible(group_slug)
message = QueueBusService.complete(group_slug, queue_slug, message_id)
return jsonify({'message': message}), 200
except Exception as e:
@@ -315,6 +341,7 @@ def complete_message(group_slug, queue_slug, message_id):
@jwt_required()
def fail_message(group_slug, queue_slug, message_id):
try:
+ _ensure_group_accessible(group_slug)
data = request.get_json() or {}
message = QueueBusService.fail(
group_slug=group_slug,
diff --git a/backend/app/api/secrets_webhooks.py b/backend/app/api/secrets_webhooks.py
index 0267d877..44e96795 100644
--- a/backend/app/api/secrets_webhooks.py
+++ b/backend/app/api/secrets_webhooks.py
@@ -1,10 +1,10 @@
"""API endpoints for secrets manager and inbound webhook gateway."""
from datetime import datetime
-from functools import wraps
from flask import Blueprint, request
from flask_jwt_extended import get_jwt_identity, jwt_required
+from app.middleware.rbac import require_workspace_access, require_workspace_role
from app.services.secret_vault_service import SecretService, SecretVaultService
from app.services.webhook_gateway_service import WebhookGatewayService
from app.services.workspace_service import WorkspaceService
@@ -41,14 +41,63 @@ def _json_or_form() -> dict:
return {}
-def admin_required(fn):
- """Require an admin user (placeholder for role check)."""
- @wraps(fn)
- @jwt_required()
- def wrapper(*args, **kwargs):
- # Role checks can be added here when the auth system exposes roles.
- return fn(*args, **kwargs)
- return wrapper
+def _current_user():
+ return User.query.get(get_jwt_identity())
+
+
+# Workspace roles allowed to mutate vault/webhook resources and to expose secret
+# VALUES (reveal / regenerate-secret) — mirroring the admin-gated connection-URI
+# reveal in databases.py.
+_WS_WRITE_ROLES = ('owner', 'admin')
+
+
+def _ws_visible(workspace_id, roles=None):
+ """True when the caller is a panel admin or a workspace member (any role for
+ reads; owner/admin when `roles` is given)."""
+ user = _current_user()
+ guard = (require_workspace_role(workspace_id, user, roles) if roles
+ else require_workspace_access(workspace_id, user))
+ return guard is None
+
+
+def _vault_gate(vault_id, roles=None):
+ """Resolve a vault and enforce workspace authorization. Sealed-from-open:
+ a missing vault AND one the caller can't see both 404."""
+ vault = SecretVaultService.get_vault(vault_id)
+ if not vault or not _ws_visible(vault.workspace_id, roles):
+ return None, ({'error': 'Vault not found'}, 404)
+ return vault, None
+
+
+def _secret_gate(secret_id, roles=None):
+ """Resolve secret -> vault and enforce workspace authorization (404-sealed)."""
+ secret = SecretService.get_secret(secret_id)
+ if not secret:
+ return None, ({'error': 'Secret not found'}, 404)
+ vault, err = _vault_gate(secret.vault_id, roles)
+ if err:
+ return None, ({'error': 'Secret not found'}, 404)
+ return secret, None
+
+
+def _endpoint_gate(endpoint_id, roles=None):
+ """Resolve a webhook endpoint and enforce workspace authorization (404-sealed)."""
+ endpoint = WebhookGatewayService.get_endpoint(endpoint_id)
+ if not endpoint or not _ws_visible(endpoint.workspace_id, roles):
+ return None, ({'error': 'Endpoint not found'}, 404)
+ return endpoint, None
+
+
+def _delivery_gate(delivery_id, roles=None):
+ """Resolve delivery -> endpoint -> workspace and enforce authorization
+ (404-sealed)."""
+ delivery = WebhookGatewayService.get_delivery(delivery_id)
+ if not delivery or not delivery.endpoint:
+ return None, ({'error': 'Delivery not found'}, 404)
+ endpoint, err = _endpoint_gate(delivery.endpoint.id, roles)
+ if err:
+ return None, ({'error': 'Delivery not found'}, 404)
+ return delivery, None
# ---------- Secret Vaults ----------
@@ -92,17 +141,20 @@ def create_vault():
@bp.route('/vaults/<int:vault_id>', methods=['GET'])
@jwt_required()
def get_vault(vault_id):
- vault = SecretVaultService.get_vault(vault_id)
- if not vault:
- return {'error': 'Vault not found'}, 404
+ vault, err = _vault_gate(vault_id)
+ if err:
+ return err
return {'success': True, 'vault': vault.to_dict()}
@bp.route('/vaults/<int:vault_id>', methods=['PATCH'])
@jwt_required()
def update_vault(vault_id):
+ vault, err = _vault_gate(vault_id, roles=_WS_WRITE_ROLES)
+ if err:
+ return err
data = _json_or_form()
- result = SecretVaultService.update_vault(vault_id, name=data.get('name'), description=data.get('description'))
+ result = SecretVaultService.update_vault(vault.id, name=data.get('name'), description=data.get('description'))
if not result.get('success'):
return {'error': result.get('error')}, 404 if 'not found' in result.get('error', '').lower() else 409
return result
@@ -111,7 +163,10 @@ def update_vault(vault_id):
@bp.route('/vaults/<int:vault_id>', methods=['DELETE'])
@jwt_required()
def delete_vault(vault_id):
- result = SecretVaultService.delete_vault(vault_id)
+ vault, err = _vault_gate(vault_id, roles=_WS_WRITE_ROLES)
+ if err:
+ return err
+ result = SecretVaultService.delete_vault(vault.id)
if not result.get('success'):
return {'error': result.get('error')}, 404
return result
@@ -122,12 +177,18 @@ def delete_vault(vault_id):
@bp.route('/vaults/<int:vault_id>/secrets', methods=['GET'])
@jwt_required()
def list_secrets(vault_id):
- return {'success': True, 'secrets': SecretService.list_secrets(vault_id)}
+ vault, err = _vault_gate(vault_id)
+ if err:
+ return err
+ return {'success': True, 'secrets': SecretService.list_secrets(vault.id)}
@bp.route('/vaults/<int:vault_id>/secrets', methods=['POST'])
@jwt_required()
def create_secret(vault_id):
+ vault, err = _vault_gate(vault_id, roles=_WS_WRITE_ROLES)
+ if err:
+ return err
data = _json_or_form()
name = data.get('name')
value = data.get('value')
@@ -139,7 +200,7 @@ def create_secret(vault_id):
expires_at = datetime.fromisoformat(data['expires_at'])
except ValueError:
return {'error': 'Invalid expires_at format'}, 400
- result = SecretService.create_secret(vault_id, name, value, description=data.get('description'), expires_at=expires_at)
+ result = SecretService.create_secret(vault.id, name, value, description=data.get('description'), expires_at=expires_at)
if not result.get('success'):
return {'error': result.get('error')}, 409 if 'already exists' in result.get('error', '').lower() else 400
return result, 201
@@ -148,26 +209,32 @@ def create_secret(vault_id):
@bp.route('/vaults/<int:vault_id>/secrets/bulk', methods=['POST'])
@jwt_required()
def bulk_create_secrets(vault_id):
+ vault, err = _vault_gate(vault_id, roles=_WS_WRITE_ROLES)
+ if err:
+ return err
data = _json_or_form()
secrets_list = data.get('secrets', [])
if not isinstance(secrets_list, list):
return {'error': 'secrets must be a list'}, 400
- result = SecretService.bulk_create_or_update(vault_id, secrets_list)
+ result = SecretService.bulk_create_or_update(vault.id, secrets_list)
return result, 207
@bp.route('/secrets/<int:secret_id>', methods=['GET'])
@jwt_required()
def get_secret(secret_id):
- secret = SecretService.get_secret(secret_id)
- if not secret:
- return {'error': 'Secret not found'}, 404
+ secret, err = _secret_gate(secret_id)
+ if err:
+ return err
return {'success': True, 'secret': secret.to_dict(mask=True)}
@bp.route('/secrets/<int:secret_id>', methods=['PATCH'])
@jwt_required()
def update_secret(secret_id):
+ secret, err = _secret_gate(secret_id, roles=_WS_WRITE_ROLES)
+ if err:
+ return err
data = _json_or_form()
expires_at = None
if data.get('expires_at'):
@@ -176,7 +243,7 @@ def update_secret(secret_id):
except ValueError:
return {'error': 'Invalid expires_at format'}, 400
result = SecretService.update_secret(
- secret_id,
+ secret.id,
value=data.get('value'),
description=data.get('description'),
expires_at=expires_at,
@@ -190,7 +257,12 @@ def update_secret(secret_id):
@bp.route('/secrets/<int:secret_id>/reveal', methods=['POST'])
@jwt_required()
def reveal_secret(secret_id):
- result = SecretService.reveal_secret(secret_id)
+ # Secret VALUE exposure is a privileged op (owner/admin workspace role or
+ # panel admin), mirroring the admin-gated connection-URI reveal in databases.py.
+ secret, err = _secret_gate(secret_id, roles=_WS_WRITE_ROLES)
+ if err:
+ return err
+ result = SecretService.reveal_secret(secret.id)
if not result.get('success'):
return {'error': result.get('error')}, 404
return result
@@ -199,7 +271,10 @@ def reveal_secret(secret_id):
@bp.route('/secrets/<int:secret_id>', methods=['DELETE'])
@jwt_required()
def delete_secret(secret_id):
- result = SecretService.delete_secret(secret_id)
+ secret, err = _secret_gate(secret_id, roles=_WS_WRITE_ROLES)
+ if err:
+ return err
+ result = SecretService.delete_secret(secret.id)
if not result.get('success'):
return {'error': result.get('error')}, 404
return result
@@ -237,18 +312,21 @@ def create_webhook_endpoint():
@bp.route('/webhooks/endpoints/<int:endpoint_id>', methods=['GET'])
@jwt_required()
def get_webhook_endpoint(endpoint_id):
- endpoint = WebhookGatewayService.get_endpoint(endpoint_id)
- if not endpoint:
- return {'error': 'Endpoint not found'}, 404
+ endpoint, err = _endpoint_gate(endpoint_id)
+ if err:
+ return err
return {'success': True, 'endpoint': endpoint.to_dict()}
@bp.route('/webhooks/endpoints/<int:endpoint_id>', methods=['PATCH'])
@jwt_required()
def update_webhook_endpoint(endpoint_id):
+ endpoint, err = _endpoint_gate(endpoint_id, roles=_WS_WRITE_ROLES)
+ if err:
+ return err
data = _json_or_form()
result = WebhookGatewayService.update_endpoint(
- endpoint_id,
+ endpoint.id,
name=data.get('name'),
forward_url=data.get('forward_url'),
filter_paths=data.get('filter_paths'),
@@ -263,7 +341,11 @@ def update_webhook_endpoint(endpoint_id):
@bp.route('/webhooks/endpoints/<int:endpoint_id>/regenerate-secret', methods=['POST'])
@jwt_required()
def regenerate_webhook_secret(endpoint_id):
- result = WebhookGatewayService.regenerate_secret(endpoint_id)
+ # Returns a new signing secret in plaintext — privileged op like reveal.
+ endpoint, err = _endpoint_gate(endpoint_id, roles=_WS_WRITE_ROLES)
+ if err:
+ return err
+ result = WebhookGatewayService.regenerate_secret(endpoint.id)
if not result.get('success'):
return {'error': result.get('error')}, 404
return result
@@ -272,7 +354,10 @@ def regenerate_webhook_secret(endpoint_id):
@bp.route('/webhooks/endpoints/<int:endpoint_id>', methods=['DELETE'])
@jwt_required()
def delete_webhook_endpoint(endpoint_id):
- result = WebhookGatewayService.delete_endpoint(endpoint_id)
+ endpoint, err = _endpoint_gate(endpoint_id, roles=_WS_WRITE_ROLES)
+ if err:
+ return err
+ result = WebhookGatewayService.delete_endpoint(endpoint.id)
if not result.get('success'):
return {'error': result.get('error')}, 404
return result
@@ -281,15 +366,21 @@ def delete_webhook_endpoint(endpoint_id):
@bp.route('/webhooks/endpoints/<int:endpoint_id>/deliveries', methods=['GET'])
@jwt_required()
def list_webhook_deliveries(endpoint_id):
+ endpoint, err = _endpoint_gate(endpoint_id)
+ if err:
+ return err
limit = request.args.get('limit', 50, type=int)
status = request.args.get('status')
- return {'success': True, 'deliveries': WebhookGatewayService.list_deliveries(endpoint_id, limit=limit, status=status)}
+ return {'success': True, 'deliveries': WebhookGatewayService.list_deliveries(endpoint.id, limit=limit, status=status)}
@bp.route('/webhooks/deliveries/<int:delivery_id>/replay', methods=['POST'])
@jwt_required()
def replay_webhook_delivery(delivery_id):
- result = WebhookGatewayService.replay_delivery(delivery_id)
+ delivery, err = _delivery_gate(delivery_id, roles=_WS_WRITE_ROLES)
+ if err:
+ return err
+ result = WebhookGatewayService.replay_delivery(delivery.id)
if not result.get('success'):
return {'error': result.get('error')}, 404
return result
diff --git a/backend/app/api/shared_resources.py b/backend/app/api/shared_resources.py
index 4f0c66c4..21952fd6 100644
--- a/backend/app/api/shared_resources.py
+++ b/backend/app/api/shared_resources.py
@@ -8,12 +8,19 @@ plus a defense-in-depth pass through :func:`mask_sensitive`.
from flask import Blueprint, jsonify, request
from flask_jwt_extended import jwt_required
+from app.middleware.rbac import (
+ get_current_user, require_workspace_access, require_workspace_role,
+)
+from app.services.resource_grant_service import ResourceGrantService
from app.services.shared_resource_service import SharedResourceService
from app.models.shared_resource import SharedVariableGroup
from app.utils.sensitive_data_filter import mask_sensitive
shared_resources_bp = Blueprint('shared_resources', __name__)
+# Workspace roles allowed to mutate shared variable groups and attachments.
+_WRITE_ROLES = ['owner', 'admin', 'member']
+
def _bad(msg, code=400):
return jsonify({'error': msg}), code
@@ -27,6 +34,138 @@ def _require(data, *keys):
return None
+# ------------------------------------------------------------ authorization
+
+def _scope_workspace_id(scope_type, scope_id):
+ """Resolve a group scope to its owning workspace id, or None.
+
+ Hierarchy: Workspace ← Project ← Environment. A dangling or malformed
+ scope returns None so callers can deny without leaking what exists.
+ """
+ from app.models.workspace import Workspace
+ from app.models.project import Project
+ from app.models.environment import Environment
+ try:
+ sid = int(scope_id)
+ except (TypeError, ValueError):
+ return None
+ if scope_type == SharedVariableGroup.SCOPE_WORKSPACE:
+ ws = Workspace.query.get(sid)
+ return ws.id if ws else None
+ if scope_type == SharedVariableGroup.SCOPE_PROJECT:
+ project = Project.query.get(sid)
+ return project.workspace_id if project else None
+ if scope_type == SharedVariableGroup.SCOPE_ENVIRONMENT:
+ env = Environment.query.get(sid)
+ if not env:
+ return None
+ project = Project.query.get(env.project_id)
+ return project.workspace_id if project else None
+ return None
+
+
+def _resolve_app(resource_type, resource_id):
+ """Resolve an app-backed resource (application, wordpress) to its
+ Application, or None."""
+ from app.models.application import Application
+ from app.models.wordpress_site import WordPressSite
+ try:
+ rid = int(resource_id)
+ except (TypeError, ValueError):
+ return None
+ if resource_type == 'application':
+ return Application.query.get(rid)
+ if resource_type == 'wordpress':
+ site = WordPressSite.query.get(rid)
+ return Application.query.get(site.application_id) if site else None
+ return None
+
+
+def _check_scope(scope_type, scope_id, write=False):
+ """Authorize the current user against a variable-group scope.
+
+ Returns None when allowed, else a ``(response, status)`` tuple. Panel
+ admins bypass. 'application' scopes gate on can_access_app / can_edit_app;
+ workspace/project/environment scopes resolve to the owning workspace and
+ gate on membership (read) or write roles (mutation).
+ """
+ user = get_current_user()
+ if user is None:
+ return _bad('authentication required', 401)
+ if user.is_admin:
+ return None
+ if scope_type == 'application':
+ application = _resolve_app('application', scope_id)
+ if application is None:
+ return _bad('scope not found', 404)
+ allowed = (ResourceGrantService.can_edit_app(user, application) if write
+ else ResourceGrantService.can_access_app(user, application))
+ return None if allowed else _bad('access denied', 403)
+ workspace_id = _scope_workspace_id(scope_type, scope_id)
+ if workspace_id is None:
+ return _bad('scope not found', 404)
+ if write:
+ return require_workspace_role(workspace_id, user, _WRITE_ROLES)
+ return require_workspace_access(workspace_id, user)
+
+
+def _get_scoped_group(group_id, write=False):
+ """Fetch a group and authorize the caller against its scope.
+
+ Returns ``(group, None)`` on success or ``(None, response)`` to return.
+ """
+ group = SharedResourceService.get_group(group_id)
+ if not group:
+ return None, _bad('group not found', 404)
+ denied = _check_scope(group.scope_type, group.scope_id, write=write)
+ if denied:
+ return None, denied
+ return group, None
+
+
+def _check_resource_write(resource_type, resource_id):
+ """Authorize attaching/detaching a group to a target resource.
+
+ Attachments inject the group's variables into the target at deploy time,
+ so this fails closed: app-backed targets (application, wordpress) require
+ operate (member+) access; workspace-owned targets (database, server)
+ require a write role in their workspace; types with no ownership seam
+ ('service', ...) are admin-only.
+ """
+ user = get_current_user()
+ if user is None:
+ return _bad('authentication required', 401)
+ if user.is_admin:
+ return None
+ if resource_type in ('application', 'wordpress'):
+ application = _resolve_app(resource_type, resource_id)
+ if application is None:
+ return _bad('resource not found', 404)
+ if not ResourceGrantService.can_operate_app(user, application):
+ return _bad('access denied', 403)
+ return None
+ if resource_type == 'database':
+ from app.models.managed_database import ManagedDatabase
+ try:
+ row = ManagedDatabase.query.get(int(resource_id))
+ except (TypeError, ValueError):
+ row = None
+ if row is None:
+ return _bad('resource not found', 404)
+ if row.workspace_id is None:
+ return _bad('access denied', 403)
+ return require_workspace_role(row.workspace_id, user, _WRITE_ROLES)
+ if resource_type == 'server':
+ from app.models.server import Server
+ server = Server.query.get(str(resource_id))
+ if server is None:
+ return _bad('resource not found', 404)
+ if server.workspace_id is None:
+ return _bad('access denied', 403)
+ return require_workspace_role(server.workspace_id, user, _WRITE_ROLES)
+ return _bad('access denied', 403)
+
+
# ---------------------------------------------------------------- metadata
@shared_resources_bp.route('/resource-types', methods=['GET'])
@@ -100,9 +239,20 @@ def remove_tag():
@shared_resources_bp.route('/variable-groups', methods=['GET'])
@jwt_required()
def list_groups():
+ scope_type = request.args.get('scope_type')
+ scope_id = request.args.get('scope_id')
+ if scope_type and scope_id not in (None, ''):
+ denied = _check_scope(scope_type, scope_id)
+ if denied:
+ return denied
+ else:
+ # An unscoped listing spans every workspace — panel admins only.
+ user = get_current_user()
+ if user is None or not user.is_admin:
+ return _bad('admin access required', 403)
groups = SharedResourceService.list_groups(
- scope_type=request.args.get('scope_type'),
- scope_id=request.args.get('scope_id'),
+ scope_type=scope_type,
+ scope_id=scope_id,
)
return jsonify({'groups': [g.to_dict() for g in groups]})
@@ -114,6 +264,9 @@ def create_group():
missing = _require(data, 'scope_type', 'scope_id', 'name')
if missing:
return _bad(f'{missing} is required')
+ denied = _check_scope(data['scope_type'], data['scope_id'], write=True)
+ if denied:
+ return denied
try:
group = SharedResourceService.create_group(
data['scope_type'], data['scope_id'], data['name'],
@@ -127,9 +280,9 @@ def create_group():
@shared_resources_bp.route('/variable-groups/<int:group_id>', methods=['GET'])
@jwt_required()
def get_group(group_id):
- group = SharedResourceService.get_group(group_id)
- if not group:
- return _bad('group not found', 404)
+ group, denied = _get_scoped_group(group_id)
+ if denied:
+ return denied
payload = group.to_dict(include_variables=True, mask_secrets=True)
payload['attachments'] = [a.to_dict() for a in group.attachments]
return jsonify(mask_sensitive(payload))
@@ -138,10 +291,13 @@ def get_group(group_id):
@shared_resources_bp.route('/variable-groups/<int:group_id>', methods=['PUT'])
@jwt_required()
def update_group(group_id):
+ group, denied = _get_scoped_group(group_id, write=True)
+ if denied:
+ return denied
data = request.get_json() or {}
try:
group = SharedResourceService.update_group(
- group_id, name=data.get('name'), description=data.get('description')
+ group.id, name=data.get('name'), description=data.get('description')
)
except ValueError as e:
return _bad(str(e))
@@ -153,7 +309,10 @@ def update_group(group_id):
@shared_resources_bp.route('/variable-groups/<int:group_id>', methods=['DELETE'])
@jwt_required()
def delete_group(group_id):
- if not SharedResourceService.delete_group(group_id):
+ group, denied = _get_scoped_group(group_id, write=True)
+ if denied:
+ return denied
+ if not SharedResourceService.delete_group(group.id):
return _bad('group not found', 404)
return jsonify({'message': 'group deleted'})
@@ -163,12 +322,15 @@ def delete_group(group_id):
@shared_resources_bp.route('/variable-groups/<int:group_id>/variables', methods=['POST'])
@jwt_required()
def add_variable(group_id):
+ group, denied = _get_scoped_group(group_id, write=True)
+ if denied:
+ return denied
data = request.get_json() or {}
if data.get('key') in (None, ''):
return _bad('key is required')
try:
var = SharedResourceService.set_variable(
- group_id, data['key'], data.get('value', ''),
+ group.id, data['key'], data.get('value', ''),
is_secret=bool(data.get('is_secret', False)),
target_service=data.get('target_service') if 'target_service' in data else None,
)
@@ -183,13 +345,20 @@ def add_variable(group_id):
'/variable-groups/<int:group_id>/variables/<int:variable_id>', methods=['PUT'])
@jwt_required()
def update_variable(group_id, variable_id):
+ group, denied = _get_scoped_group(group_id, write=True)
+ if denied:
+ return denied
+ from app.models.shared_resource import SharedVariable
+ existing = SharedVariable.query.get(variable_id)
+ if not existing or existing.group_id != group.id:
+ return _bad('variable not found', 404)
data = request.get_json() or {}
_kwargs = {'value': data.get('value'), 'is_secret': data.get('is_secret')}
if 'target_service' in data:
# Only forward when the client sent it, so it's preserved otherwise.
_kwargs['target_service'] = data.get('target_service')
var = SharedResourceService.update_variable(variable_id, **_kwargs)
- if not var or var.group_id != group_id:
+ if not var:
return _bad('variable not found', 404)
return jsonify(var.to_dict(mask_secrets=True))
@@ -198,9 +367,12 @@ def update_variable(group_id, variable_id):
'/variable-groups/<int:group_id>/variables/<int:variable_id>', methods=['DELETE'])
@jwt_required()
def delete_variable(group_id, variable_id):
+ group, denied = _get_scoped_group(group_id, write=True)
+ if denied:
+ return denied
from app.models.shared_resource import SharedVariable
var = SharedVariable.query.get(variable_id)
- if not var or var.group_id != group_id:
+ if not var or var.group_id != group.id:
return _bad('variable not found', 404)
SharedResourceService.delete_variable(variable_id)
return jsonify({'message': 'variable deleted'})
@@ -215,8 +387,14 @@ def attach_group(group_id):
missing = _require(data, 'resource_type', 'resource_id')
if missing:
return _bad(f'{missing} is required')
+ group, denied = _get_scoped_group(group_id, write=True)
+ if denied:
+ return denied
+ denied = _check_resource_write(data['resource_type'], data['resource_id'])
+ if denied:
+ return denied
att = SharedResourceService.attach_group(
- group_id, data['resource_type'], data['resource_id']
+ group.id, data['resource_type'], data['resource_id']
)
if not att:
return _bad('group not found', 404)
@@ -230,8 +408,14 @@ def detach_group(group_id):
missing = _require(data, 'resource_type', 'resource_id')
if missing:
return _bad(f'{missing} is required')
+ group, denied = _get_scoped_group(group_id, write=True)
+ if denied:
+ return denied
+ denied = _check_resource_write(data['resource_type'], data['resource_id'])
+ if denied:
+ return denied
removed = SharedResourceService.detach_group(
- group_id, data['resource_type'], data['resource_id']
+ group.id, data['resource_type'], data['resource_id']
)
return jsonify({'detached': removed})
diff --git a/backend/tests/BASELINE_COUNT b/backend/tests/BASELINE_COUNT
index d3cf57bc..beb18d70 100644
--- a/backend/tests/BASELINE_COUNT
+++ b/backend/tests/BASELINE_COUNT
@@ -1 +1 @@
-3146
+3218
diff --git a/backend/tests/test_app_deploy_jobs.py b/backend/tests/test_app_deploy_jobs.py
index e0a20f16..34055e5c 100644
--- a/backend/tests/test_app_deploy_jobs.py
+++ b/backend/tests/test_app_deploy_jobs.py
@@ -281,11 +281,13 @@ class TestListJobsAppIdFilter:
def test_api_filter(self, app, client, auth_headers):
with app.app_context():
- j1 = _make_job(app_id=11)
- _make_job(app_id=22)
- j1_id = j1.id
- res = client.get('/api/v1/deployment-jobs?app_id=11', headers=auth_headers)
+ a1 = _make_app('filter-svc1')
+ a2 = _make_app('filter-svc2')
+ j1 = _make_job(app_id=a1.id)
+ _make_job(app_id=a2.id)
+ a1_id, j1_id = a1.id, j1.id
+ res = client.get(f'/api/v1/deployment-jobs?app_id={a1_id}', headers=auth_headers)
assert res.status_code == 200
jobs = res.get_json()['jobs']
assert [j['id'] for j in jobs] == [j1_id]
- assert jobs[0]['app_id'] == 11
+ assert jobs[0]['app_id'] == a1_id
diff --git a/backend/tests/test_deployment_jobs_authz.py b/backend/tests/test_deployment_jobs_authz.py
new file mode 100644
index 00000000..63533e19
--- /dev/null
+++ b/backend/tests/test_deployment_jobs_authz.py
@@ -0,0 +1,179 @@
+"""GHSA-6w78-q5vm-rfmh — deployment-job console endpoints must enforce
+app/requester-level authorization, not just authentication.
+
+- GET /api/v1/deployment-jobs?app_id=N (any app's deploy history leaked)
+- GET /api/v1/deployment-jobs/<id> (logs may contain build output)
+- GET /api/v1/deployment-jobs/<id>/logs (textbook IDOR on the log stream)
+- POST /api/v1/deployment-jobs/<id>/retry (unauthorized deploy trigger)
+
+App-linked jobs follow the app-grant seam (can_access_app for reads,
+can_operate_app for retries); app-less jobs (template installs, simulated
+deploys) are requester-or-admin only. The job list 403s for an app_id the
+caller can't reach and is admin-only when no app_id is given (mirrors
+deploy.py get_deployment_history).
+"""
+import pytest
+
+
+def job_rbac(app, scoping_rbac):
+ """One app-linked failed job (+log) on scoping_rbac's app, plus two
+ app-less jobs: one requested by the app owner, one by the foreign user."""
+ from types import SimpleNamespace
+ from app import db
+ from app.models import User
+ from app.models.deployment_job import DeploymentJob, DeploymentJobLog
+
+ owner = User.query.filter_by(username='scope_owner').first()
+ foreign = User.query.filter_by(username='scope_foreign').first()
+
+ app_job = DeploymentJob(
+ id='job-app-linked', kind='app_deploy', status='failed',
+ app_id=scoping_rbac.app_id, requested_by=owner.id,
+ )
+ owner_job = DeploymentJob(
+ id='job-owner-appless', kind='template_install', status='failed',
+ app_id=None, requested_by=owner.id,
+ )
+ foreign_job = DeploymentJob(
+ id='job-foreign-appless', kind='template_install', status='failed',
+ app_id=None, requested_by=foreign.id,
+ )
+ db.session.add_all([app_job, owner_job, foreign_job])
+ db.session.commit()
+ db.session.add(DeploymentJobLog(
+ job_id=app_job.id, level='info', message='DB_PASSWORD=hunter2'))
+ db.session.commit()
+
+ return SimpleNamespace(
+ app_job_id=app_job.id, owner_job_id=owner_job.id,
+ foreign_job_id=foreign_job.id, s=scoping_rbac,
+ )
+
+
+def no_enqueue(monkeypatch):
+ """Retry enqueues a real job run; stub both enqueue paths out."""
+ from app.services.deployment_job_service import DeploymentJobService
+ monkeypatch.setattr(DeploymentJobService, '_enqueue_app_deploy',
+ classmethod(lambda cls, job: None))
+ monkeypatch.setattr(DeploymentJobService, '_enqueue_install',
+ classmethod(lambda cls, job: None))
+
+
+# --------------------------------------------------------------------- list
+
+def test_list_jobs_app_scoped_requires_access(client, job_rbac):
+ """App-scoped listing folds every path to the app (app_access_tier), so
+ workspace member/viewer read it too; a foreign caller is denied."""
+ s = job_rbac.s
+ url = f'/api/v1/deployment-jobs?app_id={s.app_id}'
+ for persona in ('owner', 'member', 'viewer', 'admin'):
+ assert client.get(url, headers=getattr(s, persona)).status_code == 200, persona
+ assert client.get(url, headers=s.foreign).status_code == 403
+
+
+def test_list_jobs_global_admin_only(client, job_rbac):
+ s = job_rbac.s
+ assert client.get('/api/v1/deployment-jobs', headers=s.admin).status_code == 200
+ for persona in ('owner', 'member', 'viewer', 'foreign'):
+ assert client.get('/api/v1/deployment-jobs',
+ headers=getattr(s, persona)).status_code == 403, persona
+
+
+def test_list_jobs_unknown_app_404(client, job_rbac):
+ assert client.get('/api/v1/deployment-jobs?app_id=999999',
+ headers=job_rbac.s.admin).status_code == 404
+
+
+# ------------------------------------------------------------------- detail
+
+def test_job_detail_requires_app_access(client, job_rbac):
+ """Reads gate on can_access_app (owner/admin/any grant — workspace
+ membership alone does NOT confer it), so only owner and admin pass."""
+ s = job_rbac.s
+ url = f'/api/v1/deployment-jobs/{job_rbac.app_job_id}?logs=true'
+ for persona in ('owner', 'admin'):
+ assert client.get(url, headers=getattr(s, persona)).status_code == 200, persona
+ for persona in ('member', 'viewer', 'foreign'):
+ assert client.get(url, headers=getattr(s, persona)).status_code == 403, persona
+
+
+def test_job_detail_missing_404(client, job_rbac):
+ assert client.get('/api/v1/deployment-jobs/no-such-job',
+ headers=job_rbac.s.admin).status_code == 404
+
+
+def test_appless_job_detail_requester_or_admin(client, job_rbac):
+ """An app-less job belongs to its requester (or a panel admin)."""
+ s = job_rbac.s
+ url = f'/api/v1/deployment-jobs/{job_rbac.owner_job_id}'
+ assert client.get(url, headers=s.owner).status_code == 200
+ assert client.get(url, headers=s.admin).status_code == 200
+ for persona in ('member', 'viewer', 'foreign'):
+ assert client.get(url, headers=getattr(s, persona)).status_code == 403, persona
+
+
+def test_appless_job_detail_foreign_own_job(client, job_rbac):
+ """The foreign user reads its OWN app-less job; the app owner cannot."""
+ s = job_rbac.s
+ url = f'/api/v1/deployment-jobs/{job_rbac.foreign_job_id}'
+ assert client.get(url, headers=s.foreign).status_code == 200
+ assert client.get(url, headers=s.owner).status_code == 403
+
+
+# --------------------------------------------------------------------- logs
+
+def test_job_logs_require_app_access(client, job_rbac):
+ s = job_rbac.s
+ url = f'/api/v1/deployment-jobs/{job_rbac.app_job_id}/logs'
+ assert client.get(url, headers=s.owner).status_code == 200
+ assert client.get(url, headers=s.admin).status_code == 200
+ for persona in ('member', 'viewer', 'foreign'):
+ assert client.get(url, headers=getattr(s, persona)).status_code == 403, persona
+
+
+def test_job_logs_appless_requester_only(client, job_rbac):
+ s = job_rbac.s
+ url = f'/api/v1/deployment-jobs/{job_rbac.owner_job_id}/logs'
+ assert client.get(url, headers=s.owner).status_code == 200
+ assert client.get(url, headers=s.foreign).status_code == 403
+
+
+def test_job_logs_missing_404(client, job_rbac):
+ assert client.get('/api/v1/deployment-jobs/no-such-job/logs',
+ headers=job_rbac.s.admin).status_code == 404
+
+
+# -------------------------------------------------------------------- retry
+
+def test_retry_app_linked_requires_operate_access(client, job_rbac, no_enqueue):
+ """Retry is a mutation: can_operate_app (member+). Owner, workspace member
+ and panel admin pass; viewer and foreign are denied before any clone."""
+ s = job_rbac.s
+ url = f'/api/v1/deployment-jobs/{job_rbac.app_job_id}/retry'
+ for persona in ('owner', 'member', 'admin'):
+ assert client.post(url, headers=getattr(s, persona)).status_code == 202, persona
+ for persona in ('viewer', 'foreign'):
+ assert client.post(url, headers=getattr(s, persona)).status_code == 403, persona
+
+
+def test_retry_appless_requester_or_admin(client, job_rbac, no_enqueue):
+ s = job_rbac.s
+ url = f'/api/v1/deployment-jobs/{job_rbac.owner_job_id}/retry'
+ assert client.post(url, headers=s.owner).status_code == 202
+ assert client.post(url, headers=s.admin).status_code == 202
+ for persona in ('member', 'viewer', 'foreign'):
+ assert client.post(url, headers=getattr(s, persona)).status_code == 403, persona
+
+
+def test_retry_appless_foreign_own_job(client, job_rbac, no_enqueue):
+ s = job_rbac.s
+ url = f'/api/v1/deployment-jobs/{job_rbac.foreign_job_id}/retry'
+ assert client.post(url, headers=s.foreign).status_code == 202
+ assert client.post(url, headers=s.owner).status_code == 403
+
+
+def test_retry_missing_404(client, job_rbac, no_enqueue):
+ assert client.post('/api/v1/deployment-jobs/no-such-job/retry',
+ headers=job_rbac.s.admin).status_code == 404
diff --git a/backend/tests/test_raw_infra_authz.py b/backend/tests/test_raw_infra_authz.py
new file mode 100644
index 00000000..fd29dd7c
--- /dev/null
+++ b/backend/tests/test_raw_infra_authz.py
@@ -0,0 +1,137 @@
+"""GHSA-6w78-q5vm-rfmh — raw-infrastructure reads must not bypass the per-app
+gates. Two surfaces, both admin-only by the Decision 7 precedent (no app linkage
+to gate on, so they match their admin-only mutation siblings):
+
+- GET /api/v1/docker/containers/<id> (docker inspect leaks container env
+ vars — app secrets)
+- GET /api/v1/docker/containers/<id>/logs (raw logs of ANY container)
+- /api/v1/databases host-level raw routes (engine lists, tables/structure,
+ users/privileges, backups list, and
+ the raw mysql/postgresql/sqlite
+ query consoles — readonly SELECT
+ against ANY database is cross-app
+ data exfiltration)
+
+The per-app managed-database flow (GET /databases/docker/app/<app_id>, gated via
+can_access_app) must keep working for app members.
+"""
+from unittest.mock import patch
+
+import pytest
+
+from app.services.database_service import DatabaseService
+from app.services.docker_service import DockerService
+
+NON_ADMIN = ('owner', 'member', 'viewer', 'foreign')
+
+
+def _assert_admin_only(client, s, method, url, body=None):
+ """Every non-admin persona is 403; the admin passes the gate (the mocked
+ service layer answers 200)."""
+ kwargs = {'json': body} if body is not None else {}
+ for persona in NON_ADMIN:
+ resp = getattr(client, method)(url, headers=getattr(s, persona), **kwargs)
+ assert resp.status_code == 403, f'{persona} reached {url}'
+ resp = getattr(client, method)(url, headers=s.admin, **kwargs)
+ assert resp.status_code == 200, f'admin denied {url}: {resp.get_json()}'
+
+
+# --------------------------------------------------------------------------- #
+# docker.py — raw container inspect + logs
+# --------------------------------------------------------------------------- #
+
+def test_container_inspect_admin_only(client, scoping_rbac):
+ with patch.object(DockerService, 'get_container',
+ return_value={'Id': 'abc123', 'Config': {'Env': ['SECRET=x']}}):
+ _assert_admin_only(client, scoping_rbac, 'get', '/api/v1/docker/containers/abc123')
+
+
+def test_container_logs_admin_only(client, scoping_rbac):
+ with patch.object(DockerService, 'get_container_logs',
+ return_value={'success': True, 'logs': 'DB_PASSWORD=hunter2'}):
+ _assert_admin_only(client, scoping_rbac, 'get', '/api/v1/docker/containers/abc123/logs')
+
+
+def test_container_inspect_requires_auth(client):
+ assert client.get('/api/v1/docker/containers/abc123').status_code == 401
+
+
+# --------------------------------------------------------------------------- #
+# databases.py — raw query consoles
+# --------------------------------------------------------------------------- #
+
+def test_mysql_query_admin_only(client, scoping_rbac):
+ with patch.object(DatabaseService, 'mysql_execute_query',
+ return_value={'success': True, 'rows': []}):
+ _assert_admin_only(client, scoping_rbac, 'post',
+ '/api/v1/databases/mysql/wordpress/query',
+ body={'query': 'SELECT 1'})
+
+
+def test_pg_query_admin_only(client, scoping_rbac):
+ with patch.object(DatabaseService, 'pg_execute_query',
+ return_value={'success': True, 'rows': []}):
+ _assert_admin_only(client, scoping_rbac, 'post',
+ '/api/v1/databases/postgresql/appdb/query',
+ body={'query': 'SELECT 1'})
+
+
+def test_sqlite_query_admin_only(client, scoping_rbac):
+ with patch.object(DatabaseService, 'sqlite_execute_query',
+ return_value={'success': True, 'rows': []}):
+ _assert_admin_only(client, scoping_rbac, 'post',
+ '/api/v1/databases/sqlite/query',
+ body={'path': '/srv/app/db.sqlite', 'query': 'SELECT 1'})
+
+
+# --------------------------------------------------------------------------- #
+# databases.py — host-level metadata reads
+# --------------------------------------------------------------------------- #
+
[email protected]('url,patch_target', [
+ ('/api/v1/databases/mysql', 'mysql_list_databases'),
+ ('/api/v1/databases/mysql/appdb/tables', 'mysql_get_tables'),
+ ('/api/v1/databases/mysql/users', 'mysql_list_users'),
+ ('/api/v1/databases/mysql/users/root/privileges', 'mysql_get_user_privileges'),
+ ('/api/v1/databases/postgresql', 'pg_list_databases'),
+ ('/api/v1/databases/postgresql/appdb/tables', 'pg_get_tables'),
+ ('/api/v1/databases/postgresql/users', 'pg_list_users'),
+ ('/api/v1/databases/sqlite', 'sqlite_list_databases'),
+ ('/api/v1/databases/sqlite/tables?path=/srv/app/db.sqlite', 'sqlite_get_tables'),
+ ('/api/v1/databases/backups', 'list_backups'),
+])
+def test_host_metadata_reads_admin_only(client, scoping_rbac, url, patch_target):
+ with patch.object(DatabaseService, patch_target, return_value=[]):
+ _assert_admin_only(client, scoping_rbac, 'get', url)
+
+
[email protected]('url,patch_target', [
+ ('/api/v1/databases/mysql/appdb/tables/users/structure', 'mysql_get_table_structure'),
+ ('/api/v1/databases/postgresql/appdb/tables/users/structure', 'pg_get_table_structure'),
+ ('/api/v1/databases/sqlite/tables/users/structure?path=/srv/app/db.sqlite',
+ 'sqlite_get_table_structure'),
+])
+def test_table_structure_reads_admin_only(client, scoping_rbac, url, patch_target):
+ with patch.object(DatabaseService, patch_target,
+ return_value={'success': True, 'columns': []}):
+ _assert_admin_only(client, scoping_rbac, 'get', url)
+
+
+# --------------------------------------------------------------------------- #
+# Per-app managed-database flow stays member-readable (can_access_app gate)
+# --------------------------------------------------------------------------- #
+
+def test_per_app_databases_keep_can_access_app_gate(client, scoping_rbac):
+ """The scoping app is a PHP app, so a caller who PASSES the can_access_app
+ gate reaches the docker-type check (400); a foreign caller is denied (403)
+ before it. The gate itself must not have hardened into admin-only. (This
+ route's pre-existing gate is ResourceGrantService.can_access_app — owner,
+ panel admin, or an explicit resource grant; it does not fold bare workspace
+ membership, so member/viewer without a grant are 403 by design.)"""
+ url = f'/api/v1/databases/docker/app/{scoping_rbac.app_id}'
+ for persona in ('owner', 'admin'):
+ resp = client.get(url, headers=getattr(scoping_rbac, persona))
+ assert resp.status_code == 400, f'{persona}: {resp.status_code}'
+ assert client.get(url, headers=scoping_rbac.foreign).status_code == 403
+ assert client.get('/api/v1/databases/docker/app/999999',
+ headers=scoping_rbac.admin).status_code == 404
diff --git a/backend/tests/test_secrets_webhooks_authz.py b/backend/tests/test_secrets_webhooks_authz.py
new file mode 100644
index 00000000..e1723c75
--- /dev/null
+++ b/backend/tests/test_secrets_webhooks_authz.py
@@ -0,0 +1,248 @@
+"""GHSA-6w78-q5vm-rfmh class — secrets_webhooks by-id routes must enforce
+workspace authorization, not just authentication.
+
+- GET/PATCH/DELETE /api/v1/vaults/<id> (vault IDOR)
+- GET/POST /api/v1/vaults/<id>/secrets[...] (secret list/create IDOR)
+- GET/PATCH/DELETE /api/v1/secrets/<id> (secret IDOR)
+- POST /api/v1/secrets/<id>/reveal (PLAINTEXT exposure)
+- GET/PATCH/DELETE /api/v1/webhooks/endpoints/<id> (endpoint IDOR)
+- POST /api/v1/webhooks/endpoints/<id>/regenerate-secret
+- GET /api/v1/webhooks/endpoints/<id>/deliveries
+- POST /api/v1/webhooks/deliveries/<id>/replay
+
+Reads require workspace membership (any role); mutations and secret-VALUE
+exposure (reveal / regenerate-secret / replay) require the workspace
+owner/admin role or a panel admin. Missing resources AND resources the caller
+can't see both answer 404 (sealed-from-open, mirroring workspaces.py).
+"""
+import pytest
+from flask_jwt_extended import create_access_token
+from werkzeug.security import generate_password_hash
+
+
+def vault_rbac(app, scoping_rbac):
+ """One vault + secret + webhook endpoint + delivery, all scoped to
+ scoping_rbac's workspace, plus a workspace-'owner' persona (the scoping
+ fixture's member/viewer cover the lower workspace roles)."""
+ from types import SimpleNamespace
+ from app import db
+ from app.models import (Secret, SecretVault, User, WebhookDelivery,
+ WebhookEndpoint)
+ from app.services.workspace_service import WorkspaceService
+ from app.utils.crypto import encrypt_secret
+
+ ws_owner = User(email='[email protected]', username='scope_wsowner',
+ password_hash=generate_password_hash('x'),
+ role='developer', is_active=True)
+ db.session.add(ws_owner)
+ db.session.commit()
+ WorkspaceService.add_member(scoping_rbac.ws_id, ws_owner.id, role='owner')
+
+ vault = SecretVault(name='scope-vault', slug='scope-vault',
+ workspace_id=scoping_rbac.ws_id)
+ db.session.add(vault)
+ db.session.commit()
+
+ secret = Secret(vault_id=vault.id, name='API_KEY',
+ encrypted_value=encrypt_secret('hunter2'))
+ db.session.add(secret)
+
+ endpoint = WebhookEndpoint(name='scope-endpoint', slug='scope-endpoint',
+ secret='whsec', forward_url='http://forward.local/hook',
+ workspace_id=scoping_rbac.ws_id)
+ db.session.add(endpoint)
+ db.session.commit()
+
+ delivery = WebhookDelivery(endpoint_id=endpoint.id, event_id='evt-1',
+ payload='{"a": 1}', status='received')
+ db.session.add(delivery)
+ db.session.commit()
+
+ return SimpleNamespace(
+ vault_id=vault.id, secret_id=secret.id,
+ endpoint_id=endpoint.id, delivery_id=delivery.id,
+ ws_owner={'Authorization': f'Bearer {create_access_token(identity=ws_owner.id)}'},
+ s=scoping_rbac,
+ )
+
+
+# ------------------------------- reads ----------------------------------- #
+
+def test_vault_read_requires_membership(client, vault_rbac):
+ s = vault_rbac.s
+ url = f'/api/v1/vaults/{vault_rbac.vault_id}'
+ for persona in ('ws_owner', 'member', 'viewer', 'admin'):
+ headers = getattr(vault_rbac, persona, None) or getattr(s, persona)
+ assert client.get(url, headers=headers).status_code == 200, persona
+ assert client.get(url, headers=s.foreign).status_code == 404
+
+
+def test_vault_read_missing_404(client, vault_rbac):
+ assert client.get('/api/v1/vaults/999999',
+ headers=vault_rbac.s.admin).status_code == 404
+
+
+def test_secret_list_requires_membership(client, vault_rbac):
+ s = vault_rbac.s
+ url = f'/api/v1/vaults/{vault_rbac.vault_id}/secrets'
+ assert client.get(url, headers=s.viewer).status_code == 200
+ assert client.get(url, headers=s.foreign).status_code == 404
+
+
+def test_secret_read_requires_membership(client, vault_rbac):
+ s = vault_rbac.s
+ url = f'/api/v1/secrets/{vault_rbac.secret_id}'
+ for persona in ('member', 'viewer', 'admin'):
+ assert client.get(url, headers=getattr(s, persona)).status_code == 200, persona
+ assert client.get(url, headers=s.foreign).status_code == 404
+
+
+def test_endpoint_read_requires_membership(client, vault_rbac):
+ s = vault_rbac.s
+ url = f'/api/v1/webhooks/endpoints/{vault_rbac.endpoint_id}'
+ assert client.get(url, headers=s.viewer).status_code == 200
+ assert client.get(url, headers=s.foreign).status_code == 404
+
+
+def test_deliveries_read_requires_membership(client, vault_rbac):
+ s = vault_rbac.s
+ url = f'/api/v1/webhooks/endpoints/{vault_rbac.endpoint_id}/deliveries'
+ assert client.get(url, headers=s.member).status_code == 200
+ assert client.get(url, headers=s.foreign).status_code == 404
+
+
+# --------------------- reveal (plaintext exposure) ------------------------ #
+
+def test_reveal_secret_privileged_only(client, vault_rbac):
+ """The most severe finding: plaintext of any secret in any vault was
+ returned to any authenticated user. Now owner/admin-level only."""
+ s = vault_rbac.s
+ url = f'/api/v1/secrets/{vault_rbac.secret_id}/reveal'
+ resp = client.post(url, headers=vault_rbac.ws_owner)
+ assert resp.status_code == 200
+ assert resp.get_json()['secret']['value'] == 'hunter2'
+ resp = client.post(url, headers=s.admin)
+ assert resp.status_code == 200
+ assert resp.get_json()['secret']['value'] == 'hunter2'
+ for persona in ('member', 'viewer', 'foreign'):
+ resp = client.post(url, headers=getattr(s, persona))
+ assert resp.status_code == 404, persona
+ assert 'hunter2' not in resp.get_data(as_text=True)
+
+
+# ----------------------------- mutations ---------------------------------- #
+
+def test_vault_update_requires_owner_role(client, vault_rbac):
+ s = vault_rbac.s
+ url = f'/api/v1/vaults/{vault_rbac.vault_id}'
+ assert client.patch(url, json={'description': 'd'},
+ headers=vault_rbac.ws_owner).status_code == 200
+ for persona in ('member', 'viewer', 'foreign'):
+ assert client.patch(url, json={'description': 'x'},
+ headers=getattr(s, persona)).status_code == 404, persona
+
+
+def test_vault_delete_requires_owner_role(client, vault_rbac):
+ s = vault_rbac.s
+ url = f'/api/v1/vaults/{vault_rbac.vault_id}'
+ for persona in ('member', 'viewer', 'foreign'):
+ assert client.delete(url, headers=getattr(s, persona)).status_code == 404, persona
+ assert client.delete(url, headers=s.admin).status_code == 200
+
+
+def test_secret_create_requires_owner_role(client, vault_rbac):
+ s = vault_rbac.s
+ url = f'/api/v1/vaults/{vault_rbac.vault_id}/secrets'
+ body = {'name': 'NEW_KEY', 'value': 'v'}
+ assert client.post(url, json=body, headers=vault_rbac.ws_owner).status_code == 201
+ for persona in ('member', 'viewer', 'foreign'):
+ assert client.post(url, json={'name': 'OTHER', 'value': 'v'},
+ headers=getattr(s, persona)).status_code == 404, persona
+
+
+def test_secret_bulk_requires_owner_role(client, vault_rbac):
+ s = vault_rbac.s
+ url = f'/api/v1/vaults/{vault_rbac.vault_id}/secrets/bulk'
+ body = {'secrets': [{'name': 'BULK_KEY', 'value': 'v'}]}
+ assert client.post(url, json=body, headers=vault_rbac.ws_owner).status_code == 207
+ assert client.post(url, json=body, headers=s.member).status_code == 404
+ assert client.post(url, json=body, headers=s.foreign).status_code == 404
+
+
+def test_secret_update_requires_owner_role(client, vault_rbac):
+ s = vault_rbac.s
+ url = f'/api/v1/secrets/{vault_rbac.secret_id}'
+ assert client.patch(url, json={'description': 'd'},
+ headers=vault_rbac.ws_owner).status_code == 200
+ for persona in ('member', 'viewer', 'foreign'):
+ assert client.patch(url, json={'value': 'pwned'},
+ headers=getattr(s, persona)).status_code == 404, persona
+
+
+def test_secret_delete_requires_owner_role(client, vault_rbac):
+ s = vault_rbac.s
+ url = f'/api/v1/secrets/{vault_rbac.secret_id}'
+ for persona in ('member', 'viewer', 'foreign'):
+ assert client.delete(url, headers=getattr(s, persona)).status_code == 404, persona
+ assert client.delete(url, headers=s.admin).status_code == 200
+
+
+def test_secret_missing_404(client, vault_rbac):
+ assert client.get('/api/v1/secrets/999999',
+ headers=vault_rbac.s.admin).status_code == 404
+ assert client.post('/api/v1/secrets/999999/reveal',
+ headers=vault_rbac.s.admin).status_code == 404
+
+
+# ------------------------- webhook gateway -------------------------------- #
+
+def test_endpoint_update_requires_owner_role(client, vault_rbac):
+ s = vault_rbac.s
+ url = f'/api/v1/webhooks/endpoints/{vault_rbac.endpoint_id}'
+ assert client.patch(url, json={'retry_count': 5},
+ headers=vault_rbac.ws_owner).status_code == 200
+ for persona in ('member', 'viewer', 'foreign'):
+ assert client.patch(url, json={'retry_count': 1},
+ headers=getattr(s, persona)).status_code == 404, persona
+
+
+def test_endpoint_regenerate_secret_privileged_only(client, vault_rbac):
+ """Returns a new signing secret in plaintext — owner/admin-level only."""
+ s = vault_rbac.s
+ url = f'/api/v1/webhooks/endpoints/{vault_rbac.endpoint_id}/regenerate-secret'
+ resp = client.post(url, headers=vault_rbac.ws_owner)
+ assert resp.status_code == 200
+ assert resp.get_json()['secret']
+ for persona in ('member', 'viewer', 'foreign'):
+ assert client.post(url, headers=getattr(s, persona)).status_code == 404, persona
+
+
+def test_endpoint_delete_requires_owner_role(client, vault_rbac):
+ s = vault_rbac.s
+ url = f'/api/v1/webhooks/endpoints/{vault_rbac.endpoint_id}'
+ for persona in ('member', 'viewer', 'foreign'):
+ assert client.delete(url, headers=getattr(s, persona)).status_code == 404, persona
+ assert client.delete(url, headers=s.admin).status_code == 200
+
+
+def test_endpoint_missing_404(client, vault_rbac):
+ admin = vault_rbac.s.admin
+ assert client.get('/api/v1/webhooks/endpoints/999999', headers=admin).status_code == 404
+ assert client.get('/api/v1/webhooks/endpoints/999999/deliveries',
+ headers=admin).status_code == 404
+
+
+def test_delivery_replay_requires_owner_role(client, vault_rbac, monkeypatch):
+ """Replay re-fires the payload at the forward URL — mutation-level gate.
+ The actual HTTP forward is stubbed out."""
+ from app.services.webhook_gateway_service import WebhookGatewayService
+ monkeypatch.setattr(WebhookGatewayService, '_forward',
+ classmethod(lambda cls, e, d, p, h: {'success': True, 'status': 200, 'body': ''}))
+ s = vault_rbac.s
+ url = f'/api/v1/webhooks/deliveries/{vault_rbac.delivery_id}/replay'
+ for persona in ('member', 'viewer', 'foreign'):
+ assert client.post(url, headers=getattr(s, persona)).status_code == 404, persona
+ assert client.post(url, headers=vault_rbac.ws_owner).status_code == 200
+ assert client.post('/api/v1/webhooks/deliveries/999999/replay',
+ headers=s.admin).status_code == 404
diff --git a/backend/tests/test_shared_queue_authz.py b/backend/tests/test_shared_queue_authz.py
new file mode 100644
index 00000000..9a397eb3
--- /dev/null
+++ b/backend/tests/test_shared_queue_authz.py
@@ -0,0 +1,277 @@
+"""GHSA-6w78-q5vm-rfmh-class — shared variable groups and the queue bus must
+enforce scope/ownership-level authorization, not just authentication.
+
+shared_resources (/api/v1/shared/variable-groups...):
+ - group reads gate on the group's scope (workspace membership / app access)
+ - group + variable mutations gate on workspace write roles (can_edit_app for
+ application scope)
+ - attach/detach additionally gate on the TARGET resource — attaching a group
+ injects its variables into the target at deploy time
+ - an unscoped group listing spans every workspace -> panel admins only
+
+queue_bus (/api/v1/queue/groups/<g>/queues/<q>/messages...):
+ - receive/complete/fail/list/get on system-owned groups are admin-only
+ (payload theft / internal-processing stalls otherwise)
+ - user-owned groups are limited to the owning user (and panel admins)
+"""
+import pytest
+
+G = '/api/v1/shared/variable-groups'
+Q = '/api/v1/queue/groups'
+
+
+def sr_rbac(app, scoping_rbac):
+ """A workspace-scoped variable group (+ one secret var) in scoping_rbac's
+ workspace, plus a second application owned by the foreign user."""
+ from types import SimpleNamespace
+ from app import db
+ from app.models import Application, User
+ from app.services.workspace_service import WorkspaceService
+ from app.services.shared_resource_service import SharedResourceService as S
+
+ # The scoping fixture's creator has no WorkspaceMember row (production adds
+ # one via WorkspaceService.create_workspace); add it so the owner persona
+ # resolves to the 'owner' workspace role.
+ owner = User.query.filter_by(username='scope_owner').first()
+ WorkspaceService.add_member(scoping_rbac.ws_id, owner.id, role='owner')
+
+ foreign = User.query.filter_by(username='scope_foreign').first()
+ foreign_app = Application(name='foreign-app', app_type='php',
+ user_id=foreign.id, root_path='/srv/foreign')
+ db.session.add(foreign_app)
+ db.session.commit()
+
+ group = S.create_group('workspace', str(scoping_rbac.ws_id), 'Shared Creds')
+ var = S.set_variable(group.id, 'API_TOKEN', 'secret-value', is_secret=True)
+
+ return SimpleNamespace(
+ s=scoping_rbac, group_id=group.id, var_id=var.id,
+ foreign_app_id=foreign_app.id,
+ )
+
+
+def qb(app, scoping_rbac):
+ """A system-owned queue with one internal message, plus a user-owned queue
+ owned by the scoping 'owner' persona with one message."""
+ from types import SimpleNamespace
+ from app.models import User
+ from app.queue_bus.service import QueueBusService
+
+ QueueBusService.reset_broker()
+
+ QueueBusService.ensure_queue('sys-group', 'sys-queue')
+ QueueBusService.send('sys-group', 'sys-queue', {'job': 'internal'})
+
+ owner = User.query.filter_by(username='scope_owner').first()
+ QueueBusService.create_group('user-group', name='User Group',
+ owner_type='user', owner_id=str(owner.id))
+ QueueBusService.create_queue('user-group', 'user-queue', name='User Queue')
+ QueueBusService.send('user-group', 'user-queue', {'hello': 'world'})
+
+ return SimpleNamespace(s=scoping_rbac)
+
+
+# ----------------------------------------------------------- shared resources
+
+def test_get_group_read_personas(client, sr_rbac):
+ """Anyone with a path to the workspace reads the (masked) group; a foreign
+ caller is denied."""
+ s = sr_rbac.s
+ url = f'{G}/{sr_rbac.group_id}'
+ for persona in ('owner', 'member', 'viewer', 'admin'):
+ assert client.get(url, headers=getattr(s, persona)).status_code == 200, persona
+ assert client.get(url, headers=s.foreign).status_code == 403
+
+
+def test_get_group_missing_404(client, sr_rbac):
+ assert client.get(f'{G}/999999', headers=sr_rbac.s.admin).status_code == 404
+
+
+def test_update_group_requires_write_role(client, sr_rbac):
+ s = sr_rbac.s
+ url = f'{G}/{sr_rbac.group_id}'
+ for persona in ('owner', 'member', 'admin'):
+ assert client.put(url, json={'description': 'x'},
+ headers=getattr(s, persona)).status_code == 200, persona
+ for persona in ('viewer', 'foreign'):
+ assert client.put(url, json={'description': 'x'},
+ headers=getattr(s, persona)).status_code == 403, persona
+
+
+def test_delete_group_requires_write_role(client, sr_rbac):
+ s = sr_rbac.s
+ url = f'{G}/{sr_rbac.group_id}'
+ for persona in ('viewer', 'foreign'):
+ assert client.delete(url, headers=getattr(s, persona)).status_code == 403, persona
+ assert client.delete(url, headers=s.owner).status_code == 200
+
+
+def test_add_variable_requires_write_role(client, sr_rbac):
+ s = sr_rbac.s
+ url = f'{G}/{sr_rbac.group_id}/variables'
+ assert client.post(url, json={'key': 'NEW', 'value': '1'},
+ headers=s.member).status_code == 201
+ for persona in ('viewer', 'foreign'):
+ assert client.post(url, json={'key': 'INJECTED', 'value': 'x'},
+ headers=getattr(s, persona)).status_code == 403, persona
+
+
+def test_update_and_delete_variable_require_write_role(client, sr_rbac):
+ s = sr_rbac.s
+ url = f'{G}/{sr_rbac.group_id}/variables/{sr_rbac.var_id}'
+ assert client.put(url, json={'value': 'pwned'}, headers=s.foreign).status_code == 403
+ assert client.delete(url, headers=s.viewer).status_code == 403
+ assert client.put(url, json={'value': 'changed'}, headers=s.owner).status_code == 200
+ assert client.delete(url, headers=s.owner).status_code == 200
+
+
+def test_attach_to_workspace_app(client, sr_rbac):
+ """Workspace write personas attach a workspace group to an app in the same
+ workspace; viewer/foreign cannot (group write or target write fails)."""
+ s = sr_rbac.s
+ url = f'{G}/{sr_rbac.group_id}/attach'
+ body = {'resource_type': 'application', 'resource_id': s.app_id}
+ assert client.post(url, json=body, headers=s.member).status_code == 201
+ assert client.post(url, json=body, headers=s.viewer).status_code == 403
+ assert client.post(url, json=body, headers=s.foreign).status_code == 403
+
+
+def test_attach_to_foreign_app_denied(client, sr_rbac):
+ """Even a workspace owner cannot attach their group to a foreign user's app
+ (deploy-time env-var injection into someone else's resource)."""
+ s = sr_rbac.s
+ url = f'{G}/{sr_rbac.group_id}/attach'
+ body = {'resource_type': 'application', 'resource_id': sr_rbac.foreign_app_id}
+ for persona in ('owner', 'member'):
+ assert client.post(url, json=body,
+ headers=getattr(s, persona)).status_code == 403, persona
+ # The panel admin may still wire it up deliberately.
+ assert client.post(url, json=body, headers=s.admin).status_code == 201
+
+
+def test_detach_requires_group_and_target_write(client, sr_rbac):
+ s = sr_rbac.s
+ body = {'resource_type': 'application', 'resource_id': s.app_id}
+ client.post(f'{G}/{sr_rbac.group_id}/attach', json=body, headers=s.owner)
+ url = f'{G}/{sr_rbac.group_id}/detach'
+ assert client.post(url, json=body, headers=s.foreign).status_code == 403
+ resp = client.post(url, json=body, headers=s.owner)
+ assert resp.status_code == 200
+ assert resp.get_json()['detached'] is True
+
+
+def test_create_group_requires_scope_write(client, sr_rbac):
+ s = sr_rbac.s
+ body = {'scope_type': 'workspace', 'scope_id': str(s.ws_id), 'name': 'New'}
+ assert client.post(G, json=body, headers=s.member).status_code == 201
+ assert client.post(G, json=body, headers=s.viewer).status_code == 403
+ assert client.post(G, json=body, headers=s.foreign).status_code == 403
+
+
+def test_create_group_application_scope_foreign_denied(client, sr_rbac):
+ """Application-scoped groups gate on can_edit_app; a foreign caller is
+ denied before the service validates the scope."""
+ s = sr_rbac.s
+ body = {'scope_type': 'application', 'scope_id': str(s.app_id), 'name': 'App'}
+ assert client.post(G, json=body, headers=s.foreign).status_code == 403
+ assert client.post(G, json=body, headers=s.viewer).status_code == 403
+
+
+def test_list_groups_scoped_requires_membership(client, sr_rbac):
+ s = sr_rbac.s
+ url = f'{G}?scope_type=workspace&scope_id={s.ws_id}'
+ for persona in ('owner', 'member', 'viewer', 'admin'):
+ assert client.get(url, headers=getattr(s, persona)).status_code == 200, persona
+ assert client.get(url, headers=s.foreign).status_code == 403
+
+
+def test_list_groups_unscoped_admin_only(client, sr_rbac):
+ """An unscoped listing spans every workspace — panel admins only (mirrors
+ the global deploy-history gate)."""
+ s = sr_rbac.s
+ assert client.get(G, headers=s.admin).status_code == 200
+ for persona in ('owner', 'member', 'viewer', 'foreign'):
+ assert client.get(G, headers=getattr(s, persona)).status_code == 403, persona
+
+
+# ------------------------------------------------------------------ queue bus
+
+def test_system_queue_receive_admin_only(client, qb):
+ """Non-admins must not pop messages from system queues (visibility-timeout
+ theft stalls jobs/notifications/webhook deliveries)."""
+ s = qb.s
+ url = f'{Q}/sys-group/queues/sys-queue/messages/receive'
+ for persona in ('owner', 'member', 'viewer', 'foreign'):
+ assert client.post(url, json={},
+ headers=getattr(s, persona)).status_code == 403, persona
+ resp = client.post(url, json={}, headers=s.admin)
+ assert resp.status_code == 200
+ assert resp.get_json()['messages'][0]['payload'] == {'job': 'internal'}
+
+
+def test_system_queue_list_and_get_admin_only(client, qb):
+ s = qb.s
+ base = f'{Q}/sys-group/queues/sys-queue'
+ assert client.get(f'{base}/messages', headers=s.admin).status_code == 200
+ for persona in ('owner', 'member', 'viewer', 'foreign'):
+ assert client.get(f'{base}/messages',
+ headers=getattr(s, persona)).status_code == 403, persona
+ msg_id = client.get(f'{base}/messages', headers=s.admin).get_json()['messages'][0]['id']
+ assert client.get(f'{base}/messages/{msg_id}', headers=s.admin).status_code == 200
+ assert client.get(f'{base}/messages/{msg_id}', headers=s.foreign).status_code == 403
+
+
+def test_system_queue_complete_and_fail_admin_only(client, qb):
+ s = qb.s
+ base = f'{Q}/sys-group/queues/sys-queue'
+ msg = client.post(f'{base}/messages/receive', json={},
+ headers=s.admin).get_json()['messages'][0]
+ assert client.post(f'{base}/messages/{msg["id"]}/complete', json={},
+ headers=s.foreign).status_code == 403
+ assert client.post(f'{base}/messages/{msg["id"]}/fail', json={},
+ headers=s.owner).status_code == 403
+ assert client.post(f'{base}/messages/{msg["id"]}/complete', json={},
+ headers=s.admin).status_code == 200
+
+
+def test_user_queue_owner_full_access(client, qb):
+ """The owning user keeps the pre-fix behavior on their own groups."""
+ s = qb.s
+ base = f'{Q}/user-group/queues/user-queue'
+ assert client.get(f'{base}/messages', headers=s.owner).status_code == 200
+ resp = client.post(f'{base}/messages/receive', json={}, headers=s.owner)
+ assert resp.status_code == 200
+ msg_id = resp.get_json()['messages'][0]['id']
+ assert client.get(f'{base}/messages/{msg_id}', headers=s.owner).status_code == 200
+ assert client.post(f'{base}/messages/{msg_id}/complete', json={},
+ headers=s.owner).status_code == 200
+
+
+def test_user_queue_other_users_denied(client, qb):
+ """A user-owned group's messages are not readable/ackable by other users."""
+ s = qb.s
+ base = f'{Q}/user-group/queues/user-queue'
+ for persona in ('member', 'viewer', 'foreign'):
+ headers = getattr(s, persona)
+ assert client.get(f'{base}/messages', headers=headers).status_code == 403, persona
+ assert client.post(f'{base}/messages/receive', json={},
+ headers=headers).status_code == 403, persona
+ msg_id = client.get(f'{base}/messages', headers=s.owner).get_json()['messages'][0]['id']
+ for persona in ('member', 'foreign'):
+ headers = getattr(s, persona)
+ assert client.get(f'{base}/messages/{msg_id}', headers=headers).status_code == 403, persona
+ assert client.post(f'{base}/messages/{msg_id}/complete', json={},
+ headers=headers).status_code == 403, persona
+ assert client.post(f'{base}/messages/{msg_id}/fail', json={},
+ headers=headers).status_code == 403, persona
+ # The panel admin still can.
+ assert client.get(f'{base}/messages', headers=s.admin).status_code == 200
+
+
+def test_missing_group_still_404(client, qb):
+ """The access guard defers to the service's 404 for unknown groups."""
+ resp = client.post(f'{Q}/nope/queues/nope/messages/receive', json={},
+ headers=qb.s.admin)
+ assert resp.status_code == 404