Add local password-TOTP sessions and scoped revocable MCP tokens

This commit is contained in:
2026-11-17 20:05:28 +01:00
parent 7fe20df34f
commit 9fa0fb81ff
17 changed files with 1804 additions and 27 deletions
+112
View File
@@ -0,0 +1,112 @@
import { test, expect } from '../../web/node_modules/@playwright/test/index.js';
import { createServer, type ViteDevServer } from '../../web/node_modules/vite/dist/node/index.js';
import { resolve } from 'node:path';
// The actual component runs in Chromium. All API data and secrets in this test are synthetic.
let server: ViteDevServer;
let origin: string;
const tenant = '11111111-1111-4111-8111-111111111111';
const metadata = { token_id: '22222222-2222-4222-8222-222222222222', name: 'MCP client', principal: 'test-human',
scopes: ['inventory:read'], created_at: '2026-01-01T12:00:00Z', expires_at: '2030-01-01T12:00:00Z', last_used_at: null, revoked_at: null as string | null };
const syntheticSecret = 'synthetic-test-token-not-a-real-credential-123456789';
const endpoint = `/api/v1/tenants/${tenant}/mcp-tokens`;
const auth = { principal: { id: 'test-human', display_name: 'Test', simulated: false }, tenants: [{ tenant_id: tenant, name: 'Test' }],
csrf_token: 'synthetic-csrf', permissions: ['tokens:manage', 'inventory:read', 'operations:submit'] };
test.beforeAll(async () => {
server = await createServer({ root: resolve(__dirname, '../../web'), configFile: false, server: { host: '127.0.0.1', port: 0 }, logLevel: 'silent' });
await server.listen();
const address = server.httpServer!.address();
if (!address || typeof address === 'string') throw new Error('Missing local fixture address');
origin = `http://127.0.0.1:${address.port}`;
});
test.afterAll(async () => { await server?.close(); });
async function mount(page: import('../../web/node_modules/@playwright/test/index.js').Page) {
await page.route(`${origin}/fixture`, route => route.fulfill({ contentType: 'text/html', body: `<!doctype html><html lang="de"><body><div id="root"></div><script type="module">
import React from '/node_modules/.vite/deps/react.js';
import ReactDOM from '/node_modules/.vite/deps/react-dom_client.js';
import { McpTokenManagement } from '/src/mcp-token-management.tsx';
const root = ReactDOM.createRoot(document.getElementById('root'));
window.renderTokenFixture = session => root.render(React.createElement(McpTokenManagement, { auth: session, tenantId: '${tenant}' }));
window.renderTokenFixture(${JSON.stringify(auth)});
</script></body></html>` }));
await page.goto(`${origin}/fixture`);
}
test('creates with selected rights, displays once, copies, revokes and keeps secrets out of browser storage', async ({ page, context }) => {
let tokens: typeof metadata[] = [];
const posted: unknown[] = [];
await context.grantPermissions(['clipboard-read', 'clipboard-write'], { origin });
await page.route(`${origin}${endpoint}**`, async route => {
const req = route.request();
if (req.method() === 'GET') {
await route.fulfill({ json: { tokens, allowed_scopes: ['inventory:read', 'operations:submit'], default_scopes: ['inventory:read'] } });
} else {
expect(req.headers()['x-csrf-token']).toBe(auth.csrf_token);
if (req.url().endsWith('/revoke')) {
expect(req.postDataJSON()).toEqual({});
tokens = [{ ...metadata, revoked_at: new Date().toISOString() }];
await route.fulfill({ json: tokens[0] });
} else {
posted.push(req.postDataJSON()); tokens = [metadata];
await route.fulfill({ json: { ...metadata, token: syntheticSecret } });
}
}
});
await mount(page);
await expect(page.getByRole('checkbox', { name: /Inventar lesen/ })).toBeChecked();
await expect(page.getByRole('checkbox', { name: /Genehmigung einreichen/ })).not.toBeChecked();
await page.getByLabel('Name', { exact: true }).fill('MCP client');
await page.getByRole('button', { name: 'Token erstellen', exact: true }).click();
await expect(page.getByLabel('Einmaliger Token')).toHaveValue(syntheticSecret);
expect(posted).toHaveLength(1);
expect(posted[0]).toMatchObject({ name: 'MCP client', scopes: ['inventory:read'] });
await page.getByRole('button', { name: 'Token kopieren', exact: true }).click();
await expect(page.getByRole('status')).toHaveText('Token kopiert.');
expect(await page.evaluate(() => navigator.clipboard.readText())).toBe(syntheticSecret);
expect(await page.evaluate(() => [localStorage.length, sessionStorage.length])).toEqual([0, 0]);
await page.getByRole('button', { name: 'Tokenanzeige schließen' }).click();
await expect(page.getByLabel('Einmaliger Token')).toHaveCount(0);
await page.getByRole('button', { name: 'Tokenliste aktualisieren' }).click();
await expect(page.getByLabel('Einmaliger Token')).toHaveCount(0);
await page.getByRole('button', { name: 'Widerrufen', exact: true }).click();
await page.getByRole('button', { name: 'Widerruf bestätigen' }).click();
await expect(page.getByRole('status')).toContainText('widerrufen');
await expect(page.getByRole('button', { name: 'Widerrufen', exact: true })).toHaveCount(0);
});
test('clears a displayed secret on session switch and refuses a simulated management session', async ({ page }) => {
await page.route(`${origin}${endpoint}`, route => route.fulfill({ json: route.request().method() === 'GET'
? { tokens: [], allowed_scopes: ['inventory:read'], default_scopes: ['inventory:read'] }
: { ...metadata, token: syntheticSecret } }));
await mount(page);
await page.getByLabel('Name', { exact: true }).fill('MCP client');
await page.getByRole('button', { name: 'Token erstellen', exact: true }).click();
await expect(page.getByLabel('Einmaliger Token')).toHaveValue(syntheticSecret);
await page.evaluate(next => (window as unknown as { renderTokenFixture: (session: unknown) => void }).renderTokenFixture(next),
{ ...auth, csrf_token: 'new-session' });
await expect(page.getByLabel('Einmaliger Token')).toHaveCount(0);
await page.evaluate(next => (window as unknown as { renderTokenFixture: (session: unknown) => void }).renderTokenFixture(next),
{ ...auth, principal: { ...auth.principal, simulated: true } });
await expect(page.getByRole('heading', { name: 'MCP-Tokens', exact: true })).toHaveCount(0);
});
test('discards a late create response after the owning session changes', async ({ page }) => {
let created!: (route: import('../../web/node_modules/@playwright/test/index.js').Route) => void;
const pending = new Promise<import('../../web/node_modules/@playwright/test/index.js').Route>(resolve => { created = resolve; });
await page.route(`${origin}${endpoint}`, async route => {
if (route.request().method() === 'POST') { created(route); return; }
await route.fulfill({ json: { tokens: [], allowed_scopes: ['inventory:read'], default_scopes: ['inventory:read'] } });
});
await mount(page);
await page.getByLabel('Name', { exact: true }).fill('MCP client');
await page.getByRole('button', { name: 'Token erstellen', exact: true }).click();
const creation = await pending;
await page.evaluate(next => (window as unknown as { renderTokenFixture: (session: unknown) => void }).renderTokenFixture(next),
{ ...auth, csrf_token: 'replacement-session' });
await expect(page.getByLabel('Name', { exact: true })).toHaveValue('');
await creation.fulfill({ json: { ...metadata, token: syntheticSecret } });
await expect(page.getByLabel('Einmaliger Token')).toHaveCount(0);
await expect(page.getByRole('button', { name: 'Token erstellen', exact: true })).toBeEnabled();
});
+62
View File
@@ -0,0 +1,62 @@
#!/usr/bin/env python3
"""Exercise local MFA and MCP credentials against disposable PostgreSQL with tenant RLS."""
from pathlib import Path
import subprocess
import time
import uuid
ROOT = Path(__file__).resolve().parents[1]
def command(args, data=None, timeout=120):
result = subprocess.run(args, input=data, capture_output=True, timeout=timeout)
if result.returncode:
raise RuntimeError(result.stderr.decode(errors="replace")[-4000:])
return result.stdout
def main():
name = "rmm-mcp-token-" + uuid.uuid4().hex[:10]
command(["docker", "run", "-d", "--network", "none", "--name", name,
"-e", "POSTGRES_HOST_AUTH_METHOD=trust", "postgres:17.6-bookworm"])
try:
for _ in range(100):
ready = subprocess.run(["docker", "exec", name, "pg_isready", "-U", "postgres"],
capture_output=True)
if ready.returncode == 0 and b"init process complete" in command(["docker", "logs", name]):
break
time.sleep(0.2)
else:
raise RuntimeError("ISOLATED_POSTGRES_NOT_READY")
def sql(role, statement):
return command(["docker", "exec", "-i", name, "psql", "-XqAt", "-v",
"ON_ERROR_STOP=1", "-U", role, "-d", "postgres"], statement.encode())
sql("postgres", """CREATE ROLE rmm_migrator LOGIN NOSUPERUSER NOBYPASSRLS;
CREATE ROLE rmm_app LOGIN NOINHERIT NOSUPERUSER NOBYPASSRLS;
ALTER DATABASE postgres OWNER TO rmm_migrator;
ALTER SCHEMA public OWNER TO rmm_migrator;""")
for path in sorted((ROOT / "migrations").glob("*.sql")):
sql("rmm_migrator", path.read_text())
test_command = [
"docker", "run", "--rm", "--network", "container:" + name,
"--read-only", "--tmpfs", "/tmp:rw,size=512m",
"-v", str(ROOT) + ":/src:ro", "-w", "/src",
"-v", str(ROOT / "devstate/windows-server-contract/target") + ":/target",
"-e", "CARGO_TARGET_DIR=/target",
"-e", "RMM_TEST_REPAIR_ADMIN_URL=postgres://postgres@127.0.0.1/postgres",
"-e", "RMM_TEST_REPAIR_APP_URL=postgres://rmm_app@127.0.0.1/postgres",
"--entrypoint", "cargo", "rust-discovery-windows-tls-full:local",
"test", "--locked", "--offline", "-p", "rmm-server",
]
for test_filter in ("local_auth::tests", "mcp_tokens::tests"):
output = command([*test_command, test_filter, "--", "--include-ignored", "--nocapture"], timeout=300)
print(output.decode())
print("PASS all migrations under NOSUPERUSER/NOBYPASSRLS owner; local MFA and MCP tests in isolated PostgreSQL")
finally:
subprocess.run(["docker", "rm", "-f", name], capture_output=True)
if __name__ == "__main__":
main()