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.

Gate server terminal, re-pair and move on workspace

Juan Denisfca18e905519
diff --git a/backend/app/api/servers.py b/backend/app/api/servers.py
index 12b1ee59..67485740 100644
--- a/backend/app/api/servers.py
+++ b/backend/app/api/servers.py
@@ -80,6 +80,16 @@ def _resolve_token_expiry(expires_in):
servers_bp = Blueprint('servers', __name__)
+def _get_operable_server(server_id):
+ """The server, if the current user may operate it; 404 otherwise, so a
+ non-member can't tell a foreign workspace's server from a missing one."""
+ from app.services.workspace_service import WorkspaceService
+ server = Server.query.get(server_id)
+ if not server or not WorkspaceService.can_access_server(get_current_user(), server):
+ raise not_found('server')
+ return server
+
+
def _get_external_base_url():
"""Return the public origin agents should use when this app sits behind a proxy."""
public_url = current_app.config.get('PUBLIC_URL') or os.environ.get('SERVERKIT_PUBLIC_URL')
@@ -435,9 +445,9 @@ def set_server_workspace(server_id):
from app.models.workspace import Workspace
from app.services.workspace_service import WorkspaceService
user = get_current_user()
- server = Server.query.get(server_id)
- if not server:
- raise not_found('server')
+ server = _get_operable_server(server_id)
+ if server.workspace_id and not WorkspaceService.can_write_in_workspace(user, server.workspace_id):
+ return jsonify({'error': "You have read-only access to this server's workspace"}), 403
target = (request.get_json() or {}).get('workspace_id')
if target in (None, '', 'default'):
@@ -677,9 +687,7 @@ def regenerate_token(server_id):
Body is optional; only ``expires_in`` is read (same semantics as
create_server).
"""
- server = Server.query.get(server_id)
- if not server:
- raise not_found('server')
+ server = _get_operable_server(server_id)
data = request.get_json(silent=True) or {}
expires_at = _resolve_token_expiry(data.get('expires_in'))
@@ -1744,6 +1752,7 @@ def create_terminal_session(server_id):
cols: Terminal width (default: 80)
rows: Terminal height (default: 24)
"""
+ _get_operable_server(server_id)
user_id = get_jwt_identity()
data = request.get_json() or {}
diff --git a/backend/app/services/workspace_service.py b/backend/app/services/workspace_service.py
index 69bd1a1d..ed72fd50 100644
--- a/backend/app/services/workspace_service.py
+++ b/backend/app/services/workspace_service.py
@@ -132,6 +132,21 @@ class WorkspaceService:
read-only access to it (workspace role caps capability, narrow-only)."""
return WorkspaceService.effective_role(user, workspace_id) != User.ROLE_VIEWER
+ @staticmethod
+ def can_access_server(user, server):
+ """Whether the user may operate *server*: admins always, otherwise only
+ servers outside any named workspace or in one they are a member of.
+ The Default workspace counts as none — servers created without a
+ context are stamped into it, and nobody is a member of it.
+ The one rule for both the REST routes and the Socket.IO rooms."""
+ if user.is_admin or not server.workspace_id:
+ return True
+ default = Workspace.query.filter_by(
+ slug=WorkspaceService.DEFAULT_WORKSPACE_SLUG).first()
+ if default is not None and server.workspace_id == default.id:
+ return True
+ return WorkspaceService.get_user_role(server.workspace_id, user.id) is not None
+
@staticmethod
def check_quota(workspace_id, current_count, quota_field):
"""Return an error string if a workspace quota would be exceeded,
diff --git a/backend/app/sockets.py b/backend/app/sockets.py
index 85dd7da8..ef10b41f 100644
--- a/backend/app/sockets.py
+++ b/backend/app/sockets.py
@@ -107,8 +107,7 @@ def _server_visible(user, server_id):
server = Server.query.populate_existing().filter_by(id=server_id).first()
if not server:
return False
- return (user.is_admin or not server.workspace_id
- or WorkspaceService.get_user_role(server.workspace_id, user.id) is not None)
+ return WorkspaceService.can_access_server(user, server)
def _room_allowed(user, room):
diff --git a/backend/tests/test_server_workspace_access.py b/backend/tests/test_server_workspace_access.py
new file mode 100644
index 00000000..8e247ff3
--- /dev/null
+++ b/backend/tests/test_server_workspace_access.py
@@ -0,0 +1,96 @@
+"""A developer outside a server's workspace must not operate it over REST —
+the same rule the Socket.IO server rooms and terminal already enforce."""
+from unittest.mock import patch
+
+import pytest
+
+
+def _mk_user(db, username, role):
+ from app.models import User
+ from werkzeug.security import generate_password_hash
+ u = User(email=f'{username}@t.local', username=username,
+ password_hash=generate_password_hash('x'), role=role, is_active=True)
+ db.session.add(u)
+ db.session.commit()
+ return u
+
+
+def _token(user_id):
+ from flask_jwt_extended import create_access_token
+ return {'Authorization': f'Bearer {create_access_token(identity=user_id)}'}
+
+
+def setup(app):
+ from app import db
+ from app.models.server import Server
+ from app.services.workspace_service import WorkspaceService
+ admin = _mk_user(db, 'swa_admin', 'admin')
+ member = _mk_user(db, 'swa_member', 'developer')
+ outsider = _mk_user(db, 'swa_outsider', 'developer')
+ ws = WorkspaceService.create_workspace({'name': 'SWA'}, admin.id)
+ WorkspaceService.add_member(ws.id, member.id)
+ mine = WorkspaceService.create_workspace({'name': 'SWA-out'}, outsider.id)
+ server = Server(name='swa-box', workspace_id=ws.id)
+ db.session.add(server)
+ db.session.commit()
+ return {'server': server.id, 'member': member.id, 'outsider': outsider.id,
+ 'admin': admin.id, 'own_ws': mine.id}
+
+
+_ROUTES = [
+ ('post', '/api/v1/servers/{sid}/terminal', {}),
+ ('post', '/api/v1/servers/{sid}/regenerate-token', {}),
+ ('put', '/api/v1/servers/{sid}/workspace', {'workspace_id': '{own_ws}'}),
+]
+
+
[email protected]('method,url,body', _ROUTES)
+def test_outsider_is_refused(client, setup, method, url, body):
+ from app.models.server import Server
+ body = {k: setup['own_ws'] if v == '{own_ws}' else v for k, v in body.items()}
+ before = Server.query.get(setup['server'])
+ token_hash, ws_id = before.registration_token_hash, before.workspace_id
+ with patch('app.api.servers.TerminalService.create_session',
+ return_value={'success': True}) as create:
+ resp = getattr(client, method)(url.format(sid=setup['server']), json=body,
+ headers=_token(setup['outsider']))
+ assert resp.status_code == 404
+ create.assert_not_called()
+ after = Server.query.get(setup['server'])
+ assert after.registration_token_hash == token_hash
+ assert after.workspace_id == ws_id
+
+
[email protected]('who', ['member', 'admin'])
+def test_member_and_admin_can_open_terminal(client, setup, who):
+ with patch('app.api.servers.TerminalService.create_session',
+ return_value={'success': True, 'session_id': 's1'}) as create:
+ resp = client.post(f"/api/v1/servers/{setup['server']}/terminal", json={},
+ headers=_token(setup[who]))
+ assert resp.status_code == 200
+ create.assert_called_once()
+
+
+def test_member_can_regenerate_token(client, setup):
+ resp = client.post(f"/api/v1/servers/{setup['server']}/regenerate-token",
+ json={}, headers=_token(setup['member']))
+ assert resp.status_code == 200
+ assert resp.get_json()['registration_token']
+
+
+def test_default_workspace_servers_stay_shared(client, setup):
+ """Servers created without a context land in the Default workspace, which
+ nobody joins — developers keep operating them."""
+ from app import db
+ from app.models.server import Server
+ from app.services.workspace_service import WorkspaceService
+ server = Server(name='swa-default',
+ workspace_id=WorkspaceService.ensure_default_workspace().id)
+ db.session.add(server)
+ db.session.commit()
+ with patch('app.api.servers.TerminalService.create_session',
+ return_value={'success': True, 'session_id': 's2'}):
+ resp = client.post(f'/api/v1/servers/{server.id}/terminal', json={},
+ headers=_token(setup['outsider']))
+ assert resp.status_code == 200