feat: snapshot Linux-first RMM MVP and pause handover
Rust development slice / linux (push) Failing after 1m10s

This commit is contained in:
BuTzZ
2026-11-12 22:06:25 +01:00
commit 6c3203d725
194 changed files with 49234 additions and 0 deletions
+42
View File
@@ -0,0 +1,42 @@
# Integrated server OIDC test (explicit local development fixture)
Prerequisites: native `cargo build -p rmm-server --locked`, normal migrations through
0011 applied to the existing development database, existing protected development
configuration/CA/job key, Python cryptography, existing web Playwright/Chromium and
the isolated certutil tool used by the browser harness. No external IdP is required.
Run `python3 tests/oidc/server_integration.py`. It starts its own ephemeral loopback
TLS provider and native API on an unused loopback port, and reaches the existing
development PostgreSQL container through its bridge address. It does not publish
PostgreSQL or restart the existing server/database. Private configuration is parsed
internally as data; no shell sourcing, credential stdout/argv or browser artifacts.
The only administrative fixtures are its own random restricted auth-state login
role, synthetic external identity routing row and explicit `human` membership row
in development tenant A. It grants no membership from OIDC groups/email. Those
fixtures and its own encrypted state rows are removed afterwards. It does **not**
write authorization/job/permit rows or positively invoke a plan approval endpoint.
The only approval-endpoint test uses a bearer and must be denied before plan lookup.
Actual latest standalone run: **35 assertions passed**, including a real Chromium
provider button/cross-site callback with normal CA validation and a temporary NSS
store. Browser interaction is visibly synthetic and uses explicit dev simulation.
The configured production-profile start/login check uses simulation false solely
to test configuration behavior against the mock; this is **not** external-provider,
human production-approval or Linux-VM acceptance.
Covered: code/PKCE/nonce/state, binding non-burning and callback replay, stable
mapping, final session/CSRF/logout, JWT resource audience/ID-token separation,
issuer/expiry/kid/rotation/scopes, actual MCP lifecycle/inventory call and insufficient
scope denial, persistent membership revocation, disabled external identity, foreign
tenant not-found, bearer+cookie approval denial, production dev-route disabling.
Harness corrections during implementation: avoid duplicate Python environment
keywords; do not route the dev-login JSON extractor in production; read MCP SSE to
its concrete JSON-RPC response instead of waiting for a long-lived stream to close.
No auth/approval check was disabled to make the harness pass.
Current backend configuration/routes/migration/provisioning contract is
`crates/server/OIDC.md`. Earlier `proto/BACKEND_CONTRACT.md` statements about absent
production auth describe the pre-OIDC backend increment, not this additive adapter.
The other Sync/root/APT contracts and native-execution gates are unchanged.
+31
View File
@@ -0,0 +1,31 @@
// Real Chromium navigation with an isolated NSS truststore, no TLS bypass/artifacts.
const { chromium } = require('../../web/node_modules/playwright');
(async () => {
const browser = await chromium.launch({
headless: true,
env: { ...process.env, HOME: process.env.RMM_OIDC_TEST_BROWSER_HOME },
args: ['--host-resolver-rules=MAP rmm-dev.internal 127.0.0.1', '--no-proxy-server'],
});
try {
const page = await browser.newPage();
await page.goto(process.env.RMM_OIDC_TEST_ORIGIN + '/auth/oidc/login');
await page.getByRole('button', { name: 'Authorize simulated test login' }).click();
await page.waitForURL(process.env.RMM_OIDC_TEST_ORIGIN + '/');
const result = await page.evaluate(async () => {
const session = await fetch('/auth/session');
const value = await session.json();
return { status: session.status, simulation: value.testsimulation, principal: value.principal, csrf: Boolean(value.csrf_token) };
});
if (result.status !== 200 || result.simulation !== true || !result.csrf || result.principal !== process.env.RMM_OIDC_TEST_PRINCIPAL) throw new Error('browser contract failed');
const cookies = await page.context().cookies();
const session = cookies.find(c => c.name === '__Host-rmm_session');
if (!session || !session.httpOnly || !session.secure || session.sameSite !== 'Strict' || cookies.some(c => c.name === '__Host-rmm_oidc_binding')) throw new Error('cookie contract failed');
const logout = await page.evaluate(async () => {
const s = await (await fetch('/auth/session')).json();
const response = await fetch('/auth/logout', { method: 'POST', headers: { 'X-CSRF-Token': s.csrf_token } });
return { logout: response.status, after: (await fetch('/auth/session')).status };
});
if (logout.logout !== 204 || logout.after !== 401) throw new Error('logout contract failed');
console.log('PASS real Chromium OIDC code/PKCE/nonce/state + cross-site Lax callback, strict final session, simulated-test label and logout; no job approval');
} finally { await browser.close(); }
})().catch(() => { console.error('FAIL OIDC browser test (private details suppressed)'); process.exitCode = 1; });
+317
View File
@@ -0,0 +1,317 @@
#!/usr/bin/env python3
"""Actual TLS mock IdP + native server + existing dev PostgreSQL, no approvals/VM effects.
Only creates/removes its own identity/membership and separate login role fixture.
No direct API/DB approval is performed. Requires normal migrations already applied.
"""
import base64
import datetime
import hashlib
import http.client
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
import json
import os
from pathlib import Path
import secrets
import shutil
import socket
import ssl
import subprocess
import sys
import tempfile
import threading
import time
import urllib.parse
import uuid
from cryptography import x509
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import padding, rsa
from cryptography.x509.oid import NameOID
ROOT = Path(__file__).resolve().parents[2]
STAGE = 'initial setup'
sys.path.insert(0, str(ROOT / 'tests'))
from local_integration import sql, STATE, CA, A, B
def encoded(value):
return base64.urlsafe_b64encode(value).decode().rstrip('=')
def private(path, data):
path.write_bytes(data if isinstance(data, bytes) else data.encode())
path.chmod(0o600)
return str(path)
def quiet(args, **kwargs):
result = subprocess.run(args, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, **kwargs)
if result.returncode:
raise RuntimeError('private subprocess failed')
class Idp:
def __init__(self, folder):
self.lock = threading.Lock()
self.key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
self.kid = 'initial'
self.subject = 'synthetic-oidc-' + uuid.uuid4().hex
self.codes, self.requests = {}, {}
self.jwks, self.exchanges = 0, 0
self.bad_nonce = False
ca_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
name = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, 'Isolated OIDC mock CA')])
now = datetime.datetime.now(datetime.timezone.utc)
ca = (x509.CertificateBuilder().subject_name(name).issuer_name(name).public_key(ca_key.public_key())
.serial_number(x509.random_serial_number()).not_valid_before(now-datetime.timedelta(minutes=1))
.not_valid_after(now+datetime.timedelta(days=1)).add_extension(x509.BasicConstraints(ca=True,path_length=0),critical=True)
.sign(ca_key,hashes.SHA256()))
leaf_key = rsa.generate_private_key(public_exponent=65537,key_size=2048)
leaf = (x509.CertificateBuilder().subject_name(x509.Name([x509.NameAttribute(NameOID.COMMON_NAME,'localhost')]))
.issuer_name(name).public_key(leaf_key.public_key()).serial_number(x509.random_serial_number())
.not_valid_before(now-datetime.timedelta(minutes=1)).not_valid_after(now+datetime.timedelta(days=1))
.add_extension(x509.SubjectAlternativeName([x509.DNSName('localhost')]),critical=False)
.add_extension(x509.ExtendedKeyUsage([x509.oid.ExtendedKeyUsageOID.SERVER_AUTH]),critical=False).sign(ca_key,hashes.SHA256()))
self.ca = private(folder/'mock-ca.pem',ca.public_bytes(serialization.Encoding.PEM))
cert = private(folder/'mock.pem',leaf.public_bytes(serialization.Encoding.PEM))
key = private(folder/'mock.key',leaf_key.private_bytes(serialization.Encoding.PEM,serialization.PrivateFormat.PKCS8,serialization.NoEncryption()))
idp = self
class Handler(BaseHTTPRequestHandler):
def log_message(self, *_): pass
def respond(self, status, value=None, location=None, html=None):
body = html.encode() if html else json.dumps(value or {}).encode()
self.send_response(status)
self.send_header('Content-Type','text/html' if html else 'application/json')
self.send_header('Content-Length',str(len(body)))
self.send_header('Cache-Control','no-store')
if location: self.send_header('Location',location)
self.end_headers();self.wfile.write(body)
def do_GET(self):
u = urllib.parse.urlsplit(self.path)
if u.path == '/.well-known/openid-configuration':
self.respond(200,{'issuer':idp.issuer,'authorization_endpoint':idp.issuer+'authorize','token_endpoint':idp.issuer+'token','jwks_uri':idp.issuer+'jwks','response_types_supported':['code'],'id_token_signing_alg_values_supported':['RS256'],'code_challenge_methods_supported':['S256'],'token_endpoint_auth_methods_supported':['client_secret_post']})
elif u.path == '/jwks':
with idp.lock:
idp.jwks += 1
key = idp.key.public_key().public_numbers()
self.respond(200,{'keys':[{'kty':'RSA','alg':'RS256','use':'sig','kid':idp.kid,'n':encoded(key.n.to_bytes((key.n.bit_length()+7)//8,'big')),'e':encoded(key.e.to_bytes(3,'big'))}]})
elif u.path == '/authorize':
q = dict(urllib.parse.parse_qsl(u.query))
if q.get('client_id')!='rmm-browser' or q.get('redirect_uri')!=idp.redirect or q.get('code_challenge_method')!='S256': return self.respond(400)
request_id = secrets.token_hex(24)
with idp.lock: idp.requests[request_id] = q
self.respond(200,html=f'<h1>SIMULATED local OIDC test principal, no human acceptance</h1><form action="/approve" method="post"><input type="hidden" name="request" value="{request_id}"><button>Authorize simulated test login</button></form>')
else: self.respond(404)
def do_POST(self):
size = int(self.headers.get('Content-Length','0'))
if size>16384: return self.respond(413)
q = dict(urllib.parse.parse_qsl(self.rfile.read(size).decode()))
if self.path == '/approve':
with idp.lock:
request = idp.requests.pop(q.get('request'),None)
if request is None: return self.respond(400)
code = secrets.token_hex(32); idp.codes[code] = request
return self.respond(303,location=idp.redirect+'?'+urllib.parse.urlencode({'code':code,'state':request['state']}))
if self.path != '/token': return self.respond(404)
with idp.lock:
idp.exchanges += 1
request = idp.codes.pop(q.get('code'),None)
if request is None or q.get('client_secret')!=idp.secret or q.get('redirect_uri')!=idp.redirect or q.get('client_id')!='rmm-browser' or q.get('grant_type')!='authorization_code' or encoded(hashlib.sha256(q.get('code_verifier','').encode()).digest())!=request['code_challenge']: return self.respond(400)
value = idp.token(aud='rmm-browser',typ='JWT',nonce='invalid' if idp.bad_nonce else request['nonce'])
self.respond(200,{'id_token':value,'token_type':'Bearer','access_token':'unused'})
self.server = ThreadingHTTPServer(('127.0.0.1',0),Handler)
self.issuer = f'https://localhost:{self.server.server_port}/'
ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER);ctx.load_cert_chain(cert,key)
self.server.socket = ctx.wrap_socket(self.server.socket,server_side=True)
self.thread = threading.Thread(target=self.server.serve_forever,daemon=True);self.thread.start()
self.secret = secrets.token_hex(32)
def token(self, aud='https://rmm.example/mcp', typ='at+jwt', **overrides):
claims = {'iss':self.issuer,'sub':self.subject,'aud':aud,'exp':int(time.time())+300,'iat':int(time.time()),'nbf':int(time.time())-1,'jti':uuid.uuid4().hex,'client_id':'rmm-mcp','scope':'inventory:read operations:read plans:approve'}
claims.update(overrides)
header = {'alg':'RS256','kid':self.kid,'typ':typ}
body = encoded(json.dumps(header,separators=(',',':')).encode())+'.'+encoded(json.dumps(claims,separators=(',',':')).encode())
return body+'.'+encoded(self.key.sign(body.encode(),padding.PKCS1v15(),hashes.SHA256()))
def main():
global STAGE
env = {}
for line in (STATE/'.env').read_text().splitlines():
if line and not line.startswith('#'):
name,value=line.split('=',1);env[name]=value
result = subprocess.run(['docker','inspect','--format','{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}','rust-discovery-dev-postgres-1'],capture_output=True,text=True,check=True)
address = result.stdout.strip()
socket.inet_aton(address)
role = 'oidc_test_' + secrets.token_hex(8)
password = secrets.token_hex(32)
principal = None
process = None
idp = None
state_key_ref = None
assertions = 0
def check(value, label):
nonlocal assertions
if not value: raise RuntimeError(label)
assertions += 1;print('PASS',label)
with tempfile.TemporaryDirectory(prefix='oidc-server-',dir=STATE) as folder_name:
folder = Path(folder_name);folder.chmod(0o700)
try:
idp = Idp(folder)
with socket.socket() as sock:
sock.bind(('127.0.0.1',0));port=sock.getsockname()[1]
origin = f'https://rmm-dev.internal:{port}'
idp.redirect = origin+'/auth/oidc/callback'
principal = 'oidc:'+hashlib.sha256(json.dumps([idp.issuer,idp.subject],separators=(',',':')).encode()).hexdigest()
# Only identity routing/membership fixtures; never authorization/job writes.
sql(f"CREATE ROLE {role} LOGIN PASSWORD '{password}' NOSUPERUSER NOBYPASSRLS; GRANT USAGE ON SCHEMA rmm_oidc_auth TO {role}; GRANT SELECT,INSERT,DELETE ON rmm_oidc_auth.login_states TO {role}; INSERT INTO oidc_principals VALUES('{principal}','{idp.issuer}','{idp.subject}',ARRAY['{A}']::uuid[],false); INSERT INTO memberships VALUES('{A}','{principal}','human',ARRAY['inventory:read','operations:read','plans:approve'],NULL);")
app = urllib.parse.urlsplit(env['DATABASE_URL'])
def database_url(user, pwd): return urllib.parse.urlunsplit(('postgres',f'{user}:{pwd}@{address}:5432','/rmm','',''))
cfg = {'issuer':idp.issuer,'browser_client_id':'rmm-browser','client_secret_ref':private(folder/'client-secret',idp.secret),'redirect_uri':idp.redirect,'mcp_audience':'https://rmm.example/mcp','mcp_client_ids':['rmm-mcp'],'auth_database_url_ref':private(folder/'auth-db',database_url(role,password)),'state_key_ref':private(folder/'state-key',encoded(secrets.token_bytes(32))),'extra_ca_file':idp.ca,'testsimulation':True}
config = private(folder/'oidc.json',json.dumps(cfg))
state_key_ref = cfg['state_key_ref']
server_env = dict(os.environ)
server_env.update(env)
server_env.update(RMM_PROFILE='development',RMM_DEV_AUTH='true',DATABASE_URL=database_url(app.username,app.password),RMM_TLS_DIR=str(STATE/'pki'),RMM_JOB_KEY_FILE=str(STATE/'jobs/ed25519.pem'),RMM_WEB_DIR=str(ROOT/'web/dist'),RMM_UI_ORIGIN=origin,RMM_OIDC_CONFIG_FILE=config,RMM_LISTEN_ADDR=f'127.0.0.1:{port}',RMM_SERVER_ROLE='api')
for name in ('RUST_LOG','RUST_BACKTRACE'): server_env.pop(name,None)
def start():
nonlocal process
process=subprocess.Popen([str(ROOT/'target/debug/rmm-server')],env=server_env,stdout=subprocess.DEVNULL,stderr=subprocess.DEVNULL)
for _ in range(100):
if process.poll() is not None: raise RuntimeError('configured server failed startup')
try:
if request('/healthz')[0]==200:return
except (OSError,ssl.SSLError):pass
time.sleep(.1)
raise RuntimeError('configured server did not become ready')
def request(path, method='GET', body=None, headers=None):
connection=http.client.HTTPSConnection('rmm-dev.internal',port,context=ssl.create_default_context(cafile=str(CA)),timeout=15)
def connect():
connection.sock=connection._context.wrap_socket(socket.create_connection(('127.0.0.1',port),timeout=15),server_hostname='rmm-dev.internal')
connection.connect=connect
h=dict(headers or {})
if body is not None:h['Content-Type']='application/json'
connection.request(method,path,body=None if body is None else json.dumps(body),headers=h)
response=connection.getresponse();items=response.getheaders();status=response.status
if 'text/event-stream' in response.getheader('Content-Type',''):
data=b''
while True:
line=response.readline()
if not line:break
if line.startswith(b'data:') and line[5:].strip():
value=json.loads(line[5:])
if 'result' in value or 'error' in value:
data=json.dumps(value).encode();break
else:data=response.read()
connection.close()
return status,items,data
def flow():
status,headers,_=request('/auth/oidc/login');check(status==303,'configured login starts real OIDC flow')
h=dict(headers);binding=h['set-cookie'].split(';')[0]
q=dict(urllib.parse.parse_qsl(urllib.parse.urlsplit(h['location']).query))
with idp.lock:
code=secrets.token_hex(32);idp.codes[code]=q
return '/auth/oidc/callback?'+urllib.parse.urlencode({'code':code,'state':q['state']}),binding
STAGE = 'configured native server startup'
start()
STAGE = 'HTTP OIDC contracts'
check(json.loads(request('/auth/config')[2])['oidc_login_url']=='/auth/oidc/login','UI discovery exposes nonempty OIDC login URL')
callback,binding=flow()
check(request(callback,headers={'Cookie':'__Host-rmm_oidc_binding=wrong'})[0]==401,'wrong binding rejected without burning correct state')
status,headers,_=request(callback,headers={'Cookie':binding})
check(status==303,'real token exchange validates signature nonce and PKCE')
cookies=[v.split(';')[0] for k,v in headers if k.lower()=='set-cookie' and v.startswith('__Host-rmm_session=')]
cookie=cookies[0]
check(request(callback,headers={'Cookie':binding})[0]==401,'consumed callback state cannot be replayed')
status,_,raw=request('/auth/session',headers={'Cookie':cookie});session=json.loads(raw)
check(status==200 and session['principal']==principal and session['testsimulation'] is True,'OIDC identity uses stable mapped principal and explicit dev simulation')
csrf={'Cookie':cookie,'Origin':origin,'X-CSRF-Token':session['csrf_token']}
check(request('/auth/logout','POST',{},headers={'Cookie':cookie})[0]==403,'OIDC cookie mutations require Origin and CSRF')
access=idp.token()
bearer={'Authorization':'Bearer '+access}
check(request(f'/api/v1/tenants/{A}/devices',headers=bearer)[0]==200,'resource JWT combines scopes with current persistent membership')
check(request(f'/api/v1/tenants/{B}/devices',headers=bearer)[0]==404,'foreign tenant uses same not-found boundary')
approval=f'/api/v1/tenants/{A}/operation-plans/{uuid.uuid4()}/authorizations'
check(request(approval,'POST',{'plan_hash':'0'*64},headers={**csrf,**bearer})[0]==403,'bearer cannot borrow valid browser cookie to approve even with membership and scope')
for token,label,expected in [(idp.token(aud='rmm-browser',typ='JWT'),'ID token',401),(idp.token(aud='rmm-browser'),'browser audience access token',401),(idp.token(iss='https://attacker.example/'),'wrong issuer',401),(idp.token(exp=int(time.time())-30),'expired token',401),(idp.token(scope='operations:read'),'missing scope',403),(idp.token(sub='unmapped-subject'),'unmapped identity',403)]:
check(request(f'/api/v1/tenants/{A}/devices',headers={'Authorization':'Bearer '+token})[0]==expected,label+' rejected')
oldkid=idp.kid;idp.kid='unknown-kid'
unknown=idp.token();idp.kid=oldkid
check(request(f'/api/v1/tenants/{A}/devices',headers={'Authorization':'Bearer '+unknown})[0]==401,'unknown kid rejected')
with idp.lock:idp.key=rsa.generate_private_key(public_exponent=65537,key_size=2048);idp.kid='rotated'
time.sleep(1.1)
check(request(f'/api/v1/tenants/{A}/devices',headers={'Authorization':'Bearer '+idp.token()})[0]==200,'real JWKS rotation refreshes configured issuer keys')
mcp={'Authorization':'Bearer '+idp.token(),'Accept':'application/json, text/event-stream','MCP-Protocol-Version':'2025-11-25'}
initialize={'jsonrpc':'2.0','id':1,'method':'initialize','params':{'protocolVersion':'2025-11-25','capabilities':{},'clientInfo':{'name':'oidc-test','version':'1'}}}
status,headers,_=request('/mcp','POST',initialize,headers=mcp)
check(status==200,'real MCP transport accepts targeted OAuth JWT')
session_id = next((v for k,v in headers if k.lower()=='mcp-session-id'),None)
if session_id:mcp['Mcp-Session-Id']=session_id
check(request('/mcp','POST',{'jsonrpc':'2.0','method':'notifications/initialized'},headers=mcp)[0]==202,'OIDC MCP initialized lifecycle')
call={'jsonrpc':'2.0','id':2,'method':'tools/call','params':{'name':'inventory.list_devices','arguments':{'tenant_id':A}}}
def result_json(raw):
text=raw.decode()
if text.startswith('event:') or text.startswith('data:'):
text=next(line[5:].strip() for line in text.splitlines() if line.startswith('data:'))
return json.loads(text)
status,_,raw=request('/mcp','POST',call,headers=mcp)
check(status==200 and not result_json(raw)['result'].get('isError',False),'actual OIDC MCP inventory tool uses current scoped identity')
restricted={**mcp,'Authorization':'Bearer '+idp.token(scope='operations:read')}
status,_,raw=request('/mcp','POST',call,headers=restricted)
check(status==200 and result_json(raw)['result'].get('isError',False),'MCP tool rejects insufficient access scope despite membership')
sql(f"UPDATE memberships SET revoked_at=now() WHERE principal='{principal}';")
check(request(f'/api/v1/tenants/{A}/devices',headers={'Authorization':'Bearer '+idp.token()})[0]==403 and request('/auth/session',headers={'Cookie':cookie})[0]==403,'membership revocation immediately affects JWT and browser session')
sql(f"UPDATE memberships SET revoked_at=NULL WHERE principal='{principal}'; UPDATE oidc_principals SET disabled=true WHERE principal='{principal}';")
check(request(f'/api/v1/tenants/{A}/devices',headers={'Authorization':'Bearer '+idp.token()})[0]==403,'disabled persistent external identity is denied')
sql(f"UPDATE oidc_principals SET disabled=false WHERE principal='{principal}';")
check(request('/mcp','POST',initialize,headers={'Authorization':'Bearer '+idp.token(aud='rmm-browser',typ='JWT'),'Accept':'application/json, text/event-stream'})[0]==401,'MCP rejects browser ID token')
check(request('/auth/logout','POST',{},headers=csrf)[0]==204 and request('/auth/session',headers={'Cookie':cookie})[0]==401,'local logout invalidates opaque RMM session')
idp.bad_nonce=True
callback,binding=flow()
check(request(callback,headers={'Cookie':binding})[0]==401,'nonce mismatch rejects signed ID token')
idp.bad_nonce=False
callback,binding=flow()
with idp.lock:
for value in idp.codes.values():value['code_challenge']='invalid-pkce'
check(request(callback,headers={'Cookie':binding})[0]==401,'provider-enforced PKCE failure rejects callback')
# Isolated real-browser truststore: never disable TLS or modify host roots.
home=folder/'browser-home';nss=home/'.pki/nssdb';nss.mkdir(parents=True,mode=0o700)
cache=ROOT/'web/node_modules/.cache'
certutil=shutil.which('certutil') or str(cache/'nss-tools/root/usr/bin/certutil')
quiet([certutil,'-N','-d','sql:'+str(nss),'--empty-password'])
for label,path in [('RMM server CA',str(CA)),('OIDC ephemeral CA',idp.ca)]:quiet([certutil,'-A','-d','sql:'+str(nss),'-n',label,'-t','C,,','-i',path])
browser_env={k:v for k,v in os.environ.items() if k not in ('DEBUG','PWDEBUG','NODE_DEBUG','RUST_LOG')}
browser_env.update(PLAYWRIGHT_BROWSERS_PATH=str(cache/'playwright-browsers'),RMM_OIDC_TEST_BROWSER_HOME=str(home),RMM_OIDC_TEST_ORIGIN=origin,RMM_OIDC_TEST_PRINCIPAL=principal)
STAGE = 'isolated Chromium OIDC flow'
quiet(['node',str(ROOT/'tests/oidc/browser.cjs')],env=browser_env,timeout=90)
check(True,'real Chromium UI OIDC authorization and cross-site callback, verified TLS and logout passed')
check(sql(f"SELECT count(*) FROM authorizations WHERE principal='{principal}';")=='0','no direct API/DB or browser plan authorization performed')
process.terminate();process.wait(timeout=10);process=None
cfg['testsimulation']=False;private(folder/'oidc.json',json.dumps(cfg))
server_env.update(RMM_PROFILE='production',RMM_DEV_AUTH='false')
for name in ('RMM_VIEWER_A','RMM_VIEWER_B','RMM_DEV_USERNAME','RMM_DEV_PASSWORD','RMM_OPERATOR_A','RMM_OPERATOR_B'):server_env.pop(name,None)
STAGE = 'configured production profile'
start()
STAGE = 'production dev-route denial'
check(request('/auth/dev/login','POST',{},headers={'Origin':origin})[0]==404,'configured production OIDC starts while dev login stays disabled')
STAGE = 'production non-simulated session'
callback,binding=flow()
status,headers,_=request(callback,headers={'Cookie':binding})
cookies=[v.split(';')[0] for k,v in headers if k.lower()=='set-cookie' and v.startswith('__Host-rmm_session=')]
check(status==303 and json.loads(request('/auth/session',headers={'Cookie':cookies[0]})[2])['testsimulation'] is False,'production OIDC session is non-simulated by server configuration, no role/group auto-grant')
print(f'OIDC server integration: {assertions} assertions passed; actual mock TLS/PG/Chromium only, no external IdP or production acceptance')
finally:
if process is not None:
process.terminate();process.wait(timeout=10)
if idp is not None:idp.server.shutdown();idp.server.server_close()
if principal is not None:
if state_key_ref is not None:
sql("DELETE FROM rmm_oidc_auth.login_states WHERE encryption_key_ref='"+state_key_ref.replace("'","''")+"';")
sql(f"DELETE FROM memberships WHERE principal='{principal}'; DELETE FROM oidc_principals WHERE principal='{principal}'; DROP OWNED BY {role}; DROP ROLE IF EXISTS {role};")
if __name__=='__main__':
try:main()
except Exception:
print('FAIL OIDC integration: '+STAGE+' (private details suppressed)',file=sys.stderr);sys.exit(1)