| 1 | #!/usr/bin/env python3 |
| 2 | import argparse |
| 3 | import base64 |
| 4 | import hashlib |
| 5 | import http.client |
| 6 | import json |
| 7 | import os |
| 8 | from pathlib import Path |
| 9 | import socket |
| 10 | import sqlite3 |
| 11 | import subprocess |
| 12 | import tempfile |
| 13 | import time |
| 14 | import uuid |
| 15 | from urllib.parse import quote |
| 16 | from cryptography.hazmat.primitives import hashes |
| 17 | from cryptography.hazmat.primitives.asymmetric import ec |
| 18 | from cryptography.hazmat.primitives.kdf.argon2 import Argon2id |
| 19 | |
| 20 | |
| 21 | def b64(value): |
| 22 | return base64.urlsafe_b64encode(value).decode().rstrip('=') |
| 23 | |
| 24 | |
| 25 | def cbor(value): |
| 26 | def header(kind, size): |
| 27 | if size < 24: return bytes([kind * 32 + size]) |
| 28 | width = 1 if size < 256 else 2 if size < 65536 else 4 |
| 29 | return bytes([kind * 32 + {1: 24, 2: 25, 4: 26}[width]]) + size.to_bytes(width, 'big') |
| 30 | if isinstance(value, int): return header(0 if value >= 0 else 1, value if value >= 0 else -value - 1) |
| 31 | if isinstance(value, bytes): return header(2, len(value)) + value |
| 32 | if isinstance(value, str): return header(3, len(value.encode())) + value.encode() |
| 33 | if isinstance(value, dict): return header(5, len(value)) + b''.join(cbor(k) + cbor(v) for k, v in value.items()) |
| 34 | raise TypeError(type(value)) |
| 35 | |
| 36 | |
| 37 | def main(): |
| 38 | parser = argparse.ArgumentParser() |
| 39 | parser.add_argument('--binary', type=Path, default=Path('dashboard/target/debug/home-dashboard')) |
| 40 | args = parser.parse_args() |
| 41 | origin, file, rp = 'https://snowglobe.paperclover.net', 'https://file.paperclover.net', 'auth.paperclover.net' |
| 42 | name, password, actor = 'auth-test', uuid.uuid4().hex, str(uuid.uuid4()) |
| 43 | group = str(uuid.uuid4()) |
| 44 | salt = os.urandom(16) |
| 45 | digest = Argon2id(salt=salt, length=32, iterations=5, lanes=1, memory_cost=7168).derive(password.encode()) |
| 46 | private = ec.generate_private_key(ec.SECP256R1()) |
| 47 | public = private.public_key().public_numbers() |
| 48 | key = cbor({1: 2, 3: -7, -1: 1, -2: public.x.to_bytes(32, 'big'), -3: public.y.to_bytes(32, 'big')}) |
| 49 | credential_id = os.urandom(32) |
| 50 | export = {'rpId': rp, 'roles': [{'id': group, 'name': 'infra-admin'}], 'users': [{ |
| 51 | 'id': actor, 'username': name, 'enabled': True, 'email': 'auth-test@example.invalid', 'emailVerified': True, |
| 52 | 'firstName': 'Auth', 'lastName': 'Test', 'createdTimestamp': 1, 'requiredActions': [], 'attributes': {}, 'roles': [group], |
| 53 | 'credentials': [ |
| 54 | {'id': str(uuid.uuid4()), 'type': 'password', 'createdDate': 1, 'credentialData': {'algorithm': 'argon2', 'hashIterations': 5, |
| 55 | 'additionalParameters': {'type': ['id'], 'memory': ['7168'], 'parallelism': ['1']}}, |
| 56 | 'secretData': {'salt': base64.b64encode(salt).decode(), 'value': base64.b64encode(digest).decode()}}, |
| 57 | {'id': str(uuid.uuid4()), 'type': 'webauthn-passwordless', 'userLabel': 'imported', 'createdDate': 1, |
| 58 | 'credentialData': {'credentialId': base64.b64encode(credential_id).decode(), 'credentialPublicKey': b64(key), 'counter': 0, 'transports': ['internal']}} |
| 59 | ]}]} |
| 60 | with tempfile.TemporaryDirectory(prefix='dashboard-auth-') as temporary: |
| 61 | data = Path(temporary).resolve() |
| 62 | proof = uuid.uuid4().hex + uuid.uuid4().hex |
| 63 | (data / 'proof').write_text(proof) |
| 64 | (data / 'source.json').write_text(json.dumps(export)) |
| 65 | environment = {**os.environ, 'SNOWGLOBE_DOMAIN': 'paperclover.net', 'SNOWGLOBE_DATA_DIR': str(data), |
| 66 | 'SNOWGLOBE_PUBLIC_ORIGIN': origin, 'SNOWGLOBE_AUTH_RP_ID': rp, 'SNOWGLOBE_FILE_ORIGIN': file, |
| 67 | 'SNOWGLOBE_WEB_DIR': str(Path('dashboard/dist').resolve()), 'SNOWGLOBE_PROXY_TOKEN_FILE': str(data / 'proof'), 'SNOWGLOBE_AUTH_REQUIRED': '1'} |
| 68 | binary = str(args.binary.resolve()) |
| 69 | imported = subprocess.run([binary, '--import-accounts', str(data / 'source.json')], env=environment, capture_output=True, text=True) |
| 70 | assert imported.returncode == 0, imported.stderr |
| 71 | assert json.loads(imported.stdout) == {'accounts': 1, 'credentials': 2} |
| 72 | again = subprocess.run([binary, '--import-accounts', str(data / 'source.json')], env=environment, capture_output=True) |
| 73 | assert again.returncode == 0 |
| 74 | changed = json.loads(json.dumps(export)); changed['users'][0]['username'] = 'different' |
| 75 | (data / 'different.json').write_text(json.dumps(changed)) |
| 76 | rejected = subprocess.run([binary, '--import-accounts', str(data / 'different.json')],env=environment,capture_output=True) |
| 77 | assert rejected.returncode != 0 |
| 78 | with socket.socket() as available: |
| 79 | available.bind(('127.0.0.1', 0)); port = available.getsockname()[1] |
| 80 | environment['PORT'] = str(port) |
| 81 | log = (data / 'server.log').open('wb') |
| 82 | server = None |
| 83 | |
| 84 | def start(): |
| 85 | nonlocal server |
| 86 | server = subprocess.Popen([binary], env=environment, stdout=log, stderr=log) |
| 87 | deadline = time.monotonic() + 15 |
| 88 | while True: |
| 89 | try: |
| 90 | with socket.create_connection(('127.0.0.1', port), timeout=.1): break |
| 91 | except OSError: |
| 92 | assert server.poll() is None, (data / 'server.log').read_text()[-2000:] |
| 93 | if time.monotonic() > deadline: raise AssertionError('dashboard did not start') |
| 94 | time.sleep(.05) |
| 95 | |
| 96 | def stop(): |
| 97 | server.terminate(); server.wait(timeout=10) |
| 98 | |
| 99 | def request(path, method='GET', body=None, cookies=None, status=200, extra=None, host=origin, include_headers=False): |
| 100 | headers = {'Snowglobe-Proxy-Token': proof, 'Host': host.split('://')[1], 'X-Snowglobe-Client-IP': '127.0.0.1'} |
| 101 | if body is not None: headers.update({'Origin': origin, 'Content-Type': 'application/json'}) |
| 102 | if cookies: headers['Cookie'] = '; '.join(f'{k}={v}' for k, v in cookies.items()) |
| 103 | headers.update(extra or {}) |
| 104 | connection = http.client.HTTPConnection('127.0.0.1', port, timeout=15) |
| 105 | connection.request(method, path, body=json.dumps(body) if body is not None else None, headers=headers) |
| 106 | response = connection.getresponse(); content = response.read(); fields = dict(response.getheaders()); connection.close() |
| 107 | assert response.status == status, (path, response.status, content[:200], (data / "server.log").read_text()[-1000:]) |
| 108 | if cookies is not None and 'set-cookie' in fields: |
| 109 | cookie = fields['set-cookie']; assert 'Secure; HttpOnly; SameSite=Lax' in cookie and 'Domain=' not in cookie |
| 110 | key, value = cookie.split(';', 1)[0].split('=', 1); cookies[key] = value |
| 111 | return json.loads(content) if not include_headers and fields.get('content-type', '').startswith('application/json') and content else fields |
| 112 | |
| 113 | cookies = {} |
| 114 | start() |
| 115 | try: |
| 116 | discovery = '/.well-known/mcp-servers' |
| 117 | public_headers = {'Snowglobe-Proxy-Token': '', 'Host': 'untrusted.example', |
| 118 | 'X-Forwarded-Host': 'untrusted.example', 'X-Forwarded-Proto': 'http'} |
| 119 | catalog = request(discovery, extra=public_headers) |
| 120 | assert catalog['version'] == '1.0' |
| 121 | assert catalog['registry']['name'] == 'Snow Globe' |
| 122 | assert {'observability', 'shale'} <= {entry['name'] for entry in catalog['servers']} |
| 123 | for entry in catalog['servers']: |
| 124 | endpoint = '/mcp/' + entry['name'] |
| 125 | assert entry['description'] and entry['url'] == origin + endpoint |
| 126 | assert entry['transport'] == 'streamable-http' and entry['capabilities'] == ['tools'] |
| 127 | fields = request(endpoint, status=401, extra={'Snowglobe-Proxy-Token': ''}, include_headers=True) |
| 128 | metadata = '/.well-known/oauth-protected-resource' + endpoint |
| 129 | assert fields['www-authenticate'] == 'Bearer resource_metadata="' + origin + metadata + '"' |
| 130 | protected = request(metadata, extra=public_headers) |
| 131 | assert protected['resource'] == entry['url'] |
| 132 | assert entry['authentication'] == {'type': 'oauth2', 'required': True, |
| 133 | 'authorization_url': origin + '/oauth/authorize', 'scopes': protected['scopes_supported']} |
| 134 | assert request(discovery, 'HEAD', extra=public_headers)['content-type'] == 'application/json' |
| 135 | request(discovery, 'POST', {}, status=405, extra=public_headers) |
| 136 | request(discovery + '/private', status=403, extra=public_headers) |
| 137 | (data / 'pictures').mkdir(exist_ok=True) |
| 138 | (data / 'pictures' / actor).write_bytes(base64.b64decode('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAusB9Wl6qWQAAAAASUVORK5CYII=')) |
| 139 | picture_headers = request('/api/account/pictures/' + actor, include_headers=True) |
| 140 | assert picture_headers['content-type'] == 'image/png' |
| 141 | request('/api/account/pictures/missing', status=404) |
| 142 | request('/api/me', status=401, extra={'User-Name': name, 'User-Groups': 'infra-admin'}) |
| 143 | request('/api/shares', status=401, extra={'User-Name': name, 'User-Groups': 'infra-admin'}) |
| 144 | request('/auth/status', status=403, extra={'Snowglobe-Proxy-Token': 'wrong'}) |
| 145 | csrf = request('/auth/status', cookies=cookies)['csrf'] |
| 146 | csrf_headers = request('/auth/status', cookies=cookies, include_headers=True) |
| 147 | assert csrf_headers['set-cookie'].startswith('__Host-snow-csrf=') |
| 148 | assert 'Max-Age=' not in csrf_headers['set-cookie'] and 'Expires=' not in csrf_headers['set-cookie'] |
| 149 | assert request('/auth/status', cookies=cookies)['csrf'] == csrf |
| 150 | with sqlite3.connect(data / 'accounts.sqlite') as db: |
| 151 | db.execute("UPDATE pending SET expires=0 WHERE kind='csrf'") |
| 152 | login = {'csrf': csrf, 'username': name, 'password': password, 'next': '/users'} |
| 153 | request('/auth/password', 'POST', login, cookies, 403, {'Origin': 'https://evil.example'}) |
| 154 | request('/auth/password', 'POST', login, cookies, 403, {'Origin': 'https://shale.paperclover.net'}) |
| 155 | request('/auth/password', 'POST', login, cookies, 403, {'Origin': ''}) |
| 156 | request('/auth/password', 'POST', login, {}, 403) |
| 157 | request('/auth/password', 'POST', {**login, 'csrf': ''}, cookies, 403) |
| 158 | request('/auth/password', 'POST', {**login, 'csrf': 'wrong'}, cookies, 403) |
| 159 | request('/auth/password', 'POST', {**login, 'password': 'wrong'}, cookies, 401) |
| 160 | assert request('/auth/password', 'POST', login, cookies)['next'] == '/users' |
| 161 | fields = request('/auth/password', 'POST', {**login, 'remember': False}, cookies=cookies, status=200, include_headers=True) |
| 162 | assert 'Max-Age=' not in fields['set-cookie'] |
| 163 | fields = request('/auth/password', 'POST', {**login, 'remember': True}, cookies=cookies, status=200, include_headers=True) |
| 164 | assert 'Max-Age=2592000' in fields['set-cookie'] |
| 165 | assert 'admin' in request('/api/me', cookies=cookies)['sections'] |
| 166 | request('/api/users', 'POST', {}, cookies, 403, {'Origin': 'https://evil.example'}) |
| 167 | request('/api/shares/accounts', 'POST', {'name': 'Agent'}, cookies, 403, {'Origin': 'https://evil.example'}) |
| 168 | preview_cookies = {**cookies, 'view-as': 'media-manage'} |
| 169 | request('/api/shares', cookies=preview_cookies, status=403) |
| 170 | request('/api/shares/links', 'POST', {}, preview_cookies, 403) |
| 171 | request('/api/users', 'POST', {'profile': {'username': 'API-agent', 'email': '', 'firstName': '', 'lastName': ''}, 'groups': [], 'setup': {'kind': 'invite'}}, cookies, 400) |
| 172 | assert request('/auth/password', 'POST', {**login, 'next': '//evil.example'}, cookies)['next'] == '/' |
| 173 | # Import's password format must verify with the original Keycloak parameters. |
| 174 | with sqlite3.connect(data / 'accounts.sqlite') as db: |
| 175 | phc = json.loads(db.execute("SELECT data FROM credentials WHERE kind='password'").fetchone()[0])['phc'] |
| 176 | assert '$m=7168,t=5,p=1$' in phc |
| 177 | other = {}; csrf2 = request('/auth/status', cookies=other)['csrf'] |
| 178 | assert csrf2 != csrf |
| 179 | request('/auth/password', 'POST', login, other, 403) |
| 180 | begun = request('/auth/passkey/start', 'POST', {'csrf': csrf2, 'username': name}, other) |
| 181 | assert begun['options']['publicKey']['rpId'] == rp |
| 182 | |
| 183 | def assertion(begin, origin_value=origin, flags=29, counter=1, handle=actor.encode()): |
| 184 | client = json.dumps({'type': 'webauthn.get', 'challenge': begin['options']['publicKey']['challenge'], 'origin': origin_value, 'crossOrigin': False}).encode() |
| 185 | authenticator = hashlib.sha256(rp.encode()).digest() + bytes([flags]) + counter.to_bytes(4, 'big') |
| 186 | signature = private.sign(authenticator + hashlib.sha256(client).digest(), ec.ECDSA(hashes.SHA256())) |
| 187 | return {'id': b64(credential_id), 'rawId': b64(credential_id), 'type': 'public-key', |
| 188 | 'response': {'authenticatorData': b64(authenticator), 'clientDataJSON': b64(client), 'signature': b64(signature), 'userHandle': b64(handle)}} |
| 189 | |
| 190 | signed = {'csrf': csrf2, 'token': begun['token'], 'credential': assertion(begun)} |
| 191 | request('/auth/passkey/finish', 'POST', signed, other) |
| 192 | request('/auth/passkey/finish', 'POST', signed, other, 403) |
| 193 | for options in [{'origin_value': 'https://evil.example'}, {'flags': 25}, {'flags': 21}, {'counter': 1}, {'handle': uuid.uuid4().bytes}]: |
| 194 | begin = request('/auth/passkey/start', 'POST', {'csrf': csrf2, 'username': name}, other) |
| 195 | request('/auth/passkey/finish', 'POST', {'csrf': csrf2, 'token': begin['token'], 'credential': assertion(begin, **({'counter': 2} | options))}, other, 401) |
| 196 | begin = request('/auth/passkey/start', 'POST', {'csrf': csrf2, 'username': name}, other) |
| 197 | tampered = assertion(begin, counter=2); tampered['response']['signature'] = b64(b'forged') |
| 198 | request('/auth/passkey/finish', 'POST', {'csrf':csrf2, 'token':begin['token'], 'credential':tampered}, other, 401) |
| 199 | for handle in [None, uuid.uuid4().bytes]: |
| 200 | begin = request('/auth/passkey/start', 'POST', {'csrf': csrf2}, other) |
| 201 | assert not begin['options']['publicKey'].get('allowCredentials') |
| 202 | credential = assertion(begin, counter=2, handle=handle or actor.encode()) |
| 203 | if handle is None: credential['response'].pop('userHandle') |
| 204 | request('/auth/passkey/finish', 'POST', {'csrf':csrf2, 'token':begin['token'], 'credential':credential}, other, 401) |
| 205 | begin = request('/auth/passkey/start', 'POST', {'csrf': csrf2, 'remember':False}, other) |
| 206 | assert not begin['options']['publicKey'].get('allowCredentials') |
| 207 | request('/auth/passkey/finish', 'POST', {'csrf':csrf2, 'token':begin['token'], 'credential':assertion(begin, counter=2)}, other) |
| 208 | assert request('/api/me', cookies=other)['name'] == name |
| 209 | registration = request('/auth/passkey/register', 'POST', {'csrf': csrf}, cookies) |
| 210 | new_id = os.urandom(32) |
| 211 | client = json.dumps({'type': 'webauthn.create', 'challenge': registration['options']['publicKey']['challenge'], 'origin': origin, 'crossOrigin': False}).encode() |
| 212 | authenticator = hashlib.sha256(rp.encode()).digest() + bytes([93]) + bytes(4) + bytes(16) + len(new_id).to_bytes(2, 'big') + new_id + key |
| 213 | credential = {'id': b64(new_id), 'rawId': b64(new_id), 'type': 'public-key', 'response': { |
| 214 | 'clientDataJSON': b64(client), 'attestationObject': b64(cbor({'fmt': 'none', 'authData': authenticator, 'attStmt': {}})), 'transports': ['internal']}} |
| 215 | request('/auth/passkey/save', 'POST', {'csrf': csrf, 'token': registration['token'], 'credential': credential, 'label': 'new passkey'}, cookies, 204) |
| 216 | request('/auth/passkey/save', 'POST', {'csrf': csrf, 'token': registration['token'], 'credential': credential}, cookies, 403) |
| 217 | file_cookies = {} |
| 218 | handoff = request('/auth/file/sign-in?rd=%2Fclover%2FPublic%2F', cookies=file_cookies, status=302, host=file) |
| 219 | flow = file_cookies['__Host-snow-flow'] |
| 220 | assert request('/auth/status?flow=' + flow, cookies={})['service'] == 'copyparty' |
| 221 | callback = request('/auth/continue?flow=' + flow, cookies=cookies, status=302)['location'] |
| 222 | request('/auth/file/callback?' + callback.split('?', 1)[1], cookies={}, status=403, host=file) |
| 223 | finished = request('/auth/file/callback?' + callback.split('?', 1)[1], cookies=file_cookies, status=302, host=file) |
| 224 | assert finished['location'] == file + '/clover/Public/' |
| 225 | request('/auth/file/callback?' + callback.split('?', 1)[1], cookies=file_cookies, status=403, host=file) |
| 226 | file_identity = request('/auth/file/check', cookies=file_cookies, status=204, host=file) |
| 227 | assert file_identity['x-auth-request-preferred-username'] == name |
| 228 | assert 'snow-user-' + actor in file_identity['x-auth-request-groups'].split(',') |
| 229 | request('/auth/file/check', cookies=cookies, status=401, host=file) |
| 230 | request('/api/me', cookies=file_cookies, status=401) |
| 231 | request('/auth/file/sign-in?rd=https://evil.example/', status=400, host=file) |
| 232 | invitation = request('/api/users', 'POST', {'profile': {'username': 'invited', 'email': '', 'firstName': 'Invited', 'lastName': 'Person'}, 'groups': [], 'setup': {'kind': 'invite'}}, cookies, 201) |
| 233 | setup = invitation['url'].split('setup=', 1)[1] |
| 234 | newcomer = {}; new_csrf = request('/auth/status?setup=' + setup, cookies=newcomer)['csrf'] |
| 235 | request('/auth/setup', 'POST', {'csrf': new_csrf, 'setup': setup, 'email': 'new@example.invalid', 'password': 'another-password'}, newcomer) |
| 236 | request('/auth/setup', 'POST', {'csrf': new_csrf, 'setup': setup, 'email': 'new@example.invalid', 'password': 'another-password'}, newcomer, 410) |
| 237 | request('/api/users', cookies=newcomer, status=403) |
| 238 | request('/api/shares', cookies=newcomer, status=403) |
| 239 | request('/api/shares/grants', 'POST', {}, newcomer, 403) |
| 240 | key = {'publicKey': Path('config/admin.pub').read_text().strip(), 'label': 'identity fixture'} |
| 241 | request('/api/account/signing-keys', 'POST', key, newcomer, 204) |
| 242 | pending_key = request('/api/account', cookies=newcomer)['commitIdentity']['signingKeys'][0] |
| 243 | assert pending_key['verified'] is False |
| 244 | fingerprint = quote(pending_key['fingerprint'], safe='') |
| 245 | request('/api/account/signing-keys/' + fingerprint, 'PUT', {}, newcomer, 403) |
| 246 | request('/api/account/commit-emails', 'POST', {'email': 'Alias@example.invalid'}, newcomer, 204) |
| 247 | request('/api/account/commit-emails/alias@example.invalid', 'PUT', {}, newcomer, 403) |
| 248 | request('/api/users/' + invitation['id'] + '/commit-emails/alias@example.invalid', 'PUT', {}, cookies, 204) |
| 249 | request('/api/users/' + invitation['id'] + '/signing-keys/' + fingerprint, 'PUT', {}, cookies, 204) |
| 250 | identity = request('/api/account', cookies=newcomer)['commitIdentity'] |
| 251 | assert identity['emails'] == [{'email': 'alias@example.invalid', 'verified': True}] |
| 252 | assert identity['signingKeys'][0]['verified'] is True |
| 253 | request('/api/account/signing-keys', 'POST', key, cookies, 409) |
| 254 | request('/api/account/signing-keys', 'POST', {'publicKey': 'not a public key'}, newcomer, 400) |
| 255 | request('/api/account/commit-emails', 'POST', {'email':'auth-test@example.invalid'}, newcomer, 409) |
| 256 | request('/api/account/signing-keys/' + fingerprint, 'DELETE', {}, cookies, 204) |
| 257 | assert len(request('/api/account', cookies=newcomer)['commitIdentity']['signingKeys']) == 1 |
| 258 | request('/api/account/signing-keys/' + fingerprint, 'DELETE', {}, newcomer, 204) |
| 259 | request('/api/account/commit-emails/alias@example.invalid', 'DELETE', {}, newcomer, 204) |
| 260 | assert request('/api/account', cookies=newcomer)['commitIdentity'] == {'emails': [], 'signingKeys': []} |
| 261 | |
| 262 | synthetic_id = str(uuid.uuid4()) |
| 263 | with sqlite3.connect(data / 'accounts.sqlite') as db: |
| 264 | db.execute('INSERT INTO users(id,profile) VALUES (?,?)', (synthetic_id, json.dumps({'username': 'ai-auth-test-gpt-6.1-sol', 'kind': 'ai', 'owner': actor, 'model': 'gpt-6.1-sol', 'enabled': True, 'requiredActions': []}))) |
| 265 | assert synthetic_id not in {u['id'] for u in request('/api/users', cookies=cookies)['users']} |
| 266 | for path, method, body in [('', 'GET', None), ('/setup-link', 'POST', {}), ('/password', 'PUT', {'password': 'cannot-login', 'temporary': False}), ('', 'PATCH', {'enabled': False})]: |
| 267 | request('/api/users/' + synthetic_id + path, method, body, cookies, 404) |
| 268 | request('/api/users', 'POST', {'profile': {'username': 'ai-impostor', 'email': '', 'firstName': '', 'lastName': ''}, 'groups': [], 'setup': {'kind': 'invite'}}, cookies, 400) |
| 269 | directory = request('/api/users', cookies=cookies) |
| 270 | groups = {g['name']: g['id'] for g in directory['groups']} |
| 271 | assert 'ai' in groups |
| 272 | second = request('/api/users', 'POST', {'profile': {'username': 'bulk-second', 'email': '', 'firstName': 'Bulk', 'lastName': 'Second'}, 'groups': [groups['metrics']], 'setup': {'kind': 'invite'}}, cookies, 201) |
| 273 | targets = [invitation['id'], second['id']] |
| 274 | bulk = {'users': targets, 'add': [groups['ai']], 'remove': []} |
| 275 | request('/api/users/groups', 'PUT', bulk, newcomer, 403) |
| 276 | request('/api/users/groups', 'PUT', bulk, cookies, 403, {'Origin': 'https://evil.example'}) |
| 277 | request('/api/users/groups', 'PUT', bulk, cookies, 204) |
| 278 | memberships = {u['id']: {g['name'] for g in u['groups']} for u in request('/api/users', cookies=cookies)['users']} |
| 279 | assert memberships[invitation['id']] == {'ai'} |
| 280 | assert memberships[second['id']] == {'ai', 'metrics'} |
| 281 | assert 'ai' in request('/api/me', cookies=newcomer)['sections'] |
| 282 | request('/api/mcp', cookies=newcomer) |
| 283 | request('/api/users/groups', 'PUT', {**bulk, 'add': [groups['media']], 'users': [invitation['id'], str(uuid.uuid4())]}, cookies, 404) |
| 284 | request('/api/users/groups', 'PUT', {**bulk, 'add': [groups['media']], 'users': [second['id'], actor], 'remove': [group]}, cookies, 400) |
| 285 | request('/api/users/groups', 'PUT', {**bulk, 'remove': [groups['ai']]}, cookies, 400) |
| 286 | request('/api/users/groups', 'PUT', {**bulk, 'add': ['missing-group']}, cookies, 400) |
| 287 | guest_id = str(uuid.uuid4()) |
| 288 | with sqlite3.connect(data / 'accounts.sqlite') as db: |
| 289 | guest = {'username': 'bulk-guest', 'kind': 'guest', 'enabled': True, 'requiredActions': []} |
| 290 | db.execute('INSERT INTO users(id,profile) VALUES (?,?)', (guest_id, json.dumps(guest))) |
| 291 | request('/api/users/groups', 'PUT', {**bulk, 'users': [invitation['id'], guest_id], 'add': [groups['media']]}, cookies, 400) |
| 292 | memberships = {u['id']: {g['name'] for g in u['groups']} for u in request('/api/users', cookies=cookies)['users']} |
| 293 | assert memberships[invitation['id']] == {'ai'} and memberships[second['id']] == {'ai', 'metrics'} |
| 294 | request('/api/users/groups', 'PUT', {**bulk, 'add': [], 'remove': [groups['ai']]}, cookies, 204) |
| 295 | assert 'ai' not in request('/api/me', cookies=newcomer)['sections'] |
| 296 | request('/api/ai', cookies=newcomer, status=403) |
| 297 | request('/api/mcp', cookies=newcomer, status=403) |
| 298 | request('/api/users/' + actor, 'PATCH', {'enabled': False}, cookies, 400) |
| 299 | request('/api/users/' + actor + '/groups/' + group, 'DELETE', {}, cookies, 400) |
| 300 | replacement = request('/api/users/' + invitation['id'] + '/setup-link', 'POST', {}, cookies)['url'] |
| 301 | request('/api/users/' + invitation['id'] + '/setup-link', 'DELETE', {}, cookies, 204) |
| 302 | request('/auth/status?' + replacement.split('?', 1)[1], cookies={}, status=410) |
| 303 | with sqlite3.connect(data / 'accounts.sqlite') as db: |
| 304 | db.execute("INSERT INTO guest_providers VALUES ('astheno','client','0123456789abcdef')") |
| 305 | assert request('/auth/status', cookies={})['providers'] == [{'id': 'astheno', 'name': 'Astheno'}] |
| 306 | identity = {'profile': {'username': 'astheno-only', 'email': '', 'firstName': '', 'lastName': ''}, 'groups': [], 'setup': {'kind': 'astheno'}} |
| 307 | request('/api/users', 'POST', identity, cookies, 400) |
| 308 | only = request('/api/users', 'POST', {**identity, 'astheno': ' @Janedoe '}, cookies, 201) |
| 309 | assert only['url'] is None |
| 310 | linked = {u['id']: u for u in request('/api/users', cookies=cookies)['users']}[only['id']] |
| 311 | assert linked['requiredActions'] == [] and linked['attributes']['astheno'] == ['janedoe'] |
| 312 | request('/api/users/' + invitation['id'] + '/astheno', 'PUT', {'handle': 'janedoe'}, cookies, 409) |
| 313 | request('/api/users/' + only['id'] + '/astheno', 'PUT', {'handle': 'janedoe'}, cookies, 204) |
| 314 | request('/api/users/' + only['id'] + '/astheno', 'DELETE', {}, cookies, 204) |
| 315 | assert 'astheno' not in {u['id']: u for u in request('/api/users', cookies=cookies)['users']}[only['id']].get('attributes', {}) |
| 316 | redirect = request('/auth/guest/start/astheno?next=%2F', status=302, include_headers=True) |
| 317 | assert redirect['location'].startswith('https://identity.astheno.software/authorize?') |
| 318 | request('/auth/guest/start/github?next=%2F', status=400) |
| 319 | request('/auth/guest/start/atproto?next=%2F', status=400) |
| 320 | request('/api/users/' + invitation['id'], 'PATCH', {'enabled': False}, cookies, 204) |
| 321 | request('/api/me', cookies=newcomer, status=401) |
| 322 | stop(); start() |
| 323 | assert request('/auth/password', 'POST', login, cookies)['next'] == '/users' |
| 324 | request('/api/me', cookies=cookies) |
| 325 | request('/auth/file/check', cookies=file_cookies, status=204, host=file) |
| 326 | shale_session = {}; shale_csrf = request('/auth/status', cookies=shale_session)['csrf'] |
| 327 | request('/auth/password', 'POST', {**login, 'csrf': shale_csrf}, shale_session) |
| 328 | captured = shale_session.copy() |
| 329 | request('/auth/shale/sign-out', cookies=shale_session, status=403) |
| 330 | request('/auth/shale/sign-out', cookies=shale_session, status=403, extra={'Referer': 'https://evil.example/'}) |
| 331 | request('/auth/shale/sign-out', cookies=shale_session, status=403, extra={'Referer': 'https://shale.paperclover.net.evil.example/'}) |
| 332 | request('/auth/shale/sign-out', 'POST', {}, shale_session, 405, {'Referer': 'https://shale.paperclover.net/'}) |
| 333 | request('/api/me', cookies=shale_session) |
| 334 | ended = request('/auth/shale/sign-out', cookies=shale_session, status=303, extra={'Referer': 'https://shale.paperclover.net/'}) |
| 335 | assert ended['location'] == 'https://shale.paperclover.net/' and shale_session['__Host-snow-session'] == '' |
| 336 | request('/api/me', cookies=captured, status=401) |
| 337 | request('/api/me', cookies=cookies) |
| 338 | request('/api/users/' + actor + '/logout', 'POST', {}, cookies, 204) |
| 339 | request('/api/me', cookies=cookies, status=401) |
| 340 | request('/auth/file/check', cookies=file_cookies, status=401, host=file) |
| 341 | print(json.dumps({'commit_identity': 'passed', 'import': 'passed', 'password': 'passed', 'signed_legacy_passkey': 'passed', 'username_free_passkey': 'passed', 'remember_me': 'passed', 'registration': 'passed', 'csrf_and_header_forgery': 'passed', 'ai_group_access': 'passed', 'bulk_group_atomicity': 'passed', 'file_handoff_replay_and_binding': 'passed', 'invitation_one_use_and_revocation': 'passed', 'restart_and_logout': 'passed', 'shale_logout_and_cookie_replay': 'passed'})) |
| 342 | finally: |
| 343 | if server and server.poll() is None: stop() |
| 344 | log.close() |
| 345 | |
| 346 | |
| 347 | if __name__ == '__main__': |
| 348 | main() |