1#!/usr/bin/env python3
2import argparse
3import base64
4import hashlib
5import http.client
6import json
7import os
8from pathlib import Path
9import socket
10import sqlite3
11import subprocess
12import tempfile
13import time
14import uuid
15from urllib.parse import quote
16from cryptography.hazmat.primitives import hashes
17from cryptography.hazmat.primitives.asymmetric import ec
18from cryptography.hazmat.primitives.kdf.argon2 import Argon2id
19
20
21def b64(value):
22 return base64.urlsafe_b64encode(value).decode().rstrip('=')
23
24
25def 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
37def 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
347if __name__ == '__main__':
348 main()