1#!/usr/bin/env python3
2"""Exercise native OIDC over HTTP with independently verified RSA signatures."""
3import argparse
4import base64
5import hashlib
6import http.client
7import json
8import os
9from pathlib import Path
10import socket
11import sqlite3
12import subprocess
13import tempfile
14import time
15import urllib.parse
16import uuid
17from cryptography.hazmat.primitives import hashes
18from cryptography.hazmat.primitives.asymmetric import rsa, padding
19from cryptography.hazmat.primitives.kdf.argon2 import Argon2id
20
21
22def b64(value):
23 return base64.urlsafe_b64encode(value).decode().rstrip('=')
24
25
26def main():
27 parser = argparse.ArgumentParser()
28 parser.add_argument('--binary', type=Path, default=Path('dashboard/target/debug/home-dashboard'))
29 args = parser.parse_args()
30 origin = 'https://snowglobe.paperclover.net'
31 callback = 'https://shale.paperclover.net/-/callback'
32 actor, role = str(uuid.uuid4()), str(uuid.uuid4())
33 password, secret, proof = uuid.uuid4().hex, uuid.uuid4().hex, uuid.uuid4().hex + uuid.uuid4().hex
34 salt = os.urandom(16)
35 digest = Argon2id(salt=salt, length=32, iterations=5, lanes=1, memory_cost=7168).derive(password.encode())
36 export = {'rpId': 'auth.paperclover.net', 'roles': [{'id': role, 'name': 'infra-admin'}], 'users': [{
37 'id': actor, 'username': 'oidc-test', 'enabled': True, 'email': 'oidc-test@example.invalid', 'emailVerified': True,
38 'firstName': 'OIDC', 'lastName': 'Test', 'createdTimestamp': 1, 'requiredActions': [], 'attributes': {}, 'roles': [role],
39 'credentials': [{'id': str(uuid.uuid4()), 'type': 'password', 'createdDate': 1,
40 'credentialData': {'algorithm': 'argon2', 'hashIterations': 5, 'additionalParameters': {'type': ['id'], 'memory': ['7168'], 'parallelism': ['1']}},
41 'secretData': {'salt': base64.b64encode(salt).decode(), 'value': base64.b64encode(digest).decode()}}]}]}
42 with tempfile.TemporaryDirectory(prefix='dashboard-oidc-') as temporary:
43 data = Path(temporary).resolve()
44 (data / 'proof').write_text(proof)
45 (data / 'source.json').write_text(json.dumps(export))
46 environment = {**os.environ, 'SNOWGLOBE_DOMAIN': 'paperclover.net', 'SNOWGLOBE_DATA_DIR': str(data),
47 'SNOWGLOBE_PUBLIC_ORIGIN': origin, 'SNOWGLOBE_AUTH_RP_ID': 'auth.paperclover.net', 'SNOWGLOBE_FILE_ORIGIN': 'https://file.paperclover.net',
48 'SNOWGLOBE_WEB_DIR': str(Path('dashboard/dist').resolve()), 'SNOWGLOBE_PROXY_TOKEN_FILE': str(data / 'proof'), 'SNOWGLOBE_AUTH_REQUIRED': '1'}
49 binary = str(args.binary.resolve())
50 result = subprocess.run([binary, '--import-accounts', str(data / 'source.json')], env=environment, capture_output=True, text=True)
51 assert result.returncode == 0, result.stderr
52 def provision(client, redirects, aliases=None, status=0, guests=False, username=False):
53 result = subprocess.run([binary, '--oidc-client'], env=environment, capture_output=True, text=True,
54 input=json.dumps({'request': {'kind': 'client', 'clientId': client, 'name': client,
55 'redirectUris': redirects, 'usernameAliases': aliases or {}, 'allowGuests': guests, 'usernameRequired': username},
56 'existing': {'clientId': client, 'clientSecret': secret}}))
57 assert result.returncode == status, result.stderr
58 provision('shale', [callback], {'oidc-test': 'clover'}, guests=True, username=True)
59 provision('other', ['https://jelly.paperclover.net/callback'])
60 provision('bad', ['https://evil.example/callback'], status=1)
61 provision('bad', ['https://shale.paperclover.net/*'], status=1)
62 provision('shale-preview-bad', ['https://jelly.paperclover.net/-/callback'], guests=True, status=1)
63 provision('shale-dev', ['http://git1.localhost/-/callback'], guests=True, username=True)
64 provision('shale-dev', ['http://other.localhost/-/callback'], guests=True, status=1)
65 provision('shale', ['http://git1.localhost/-/callback'], guests=True, status=1)
66 with socket.socket() as available:
67 available.bind(('127.0.0.1', 0)); port = available.getsockname()[1]
68 environment['PORT'] = str(port)
69 log = (data / 'server.log').open('wb')
70 server = None
71 def start():
72 nonlocal server
73 server = subprocess.Popen([binary], env=environment, stdout=log, stderr=log)
74 deadline = time.monotonic() + 15
75 while True:
76 try:
77 with socket.create_connection(('127.0.0.1', port), timeout=.1): break
78 except OSError:
79 assert server.poll() is None, (data / 'server.log').read_text()[-1000:]
80 if time.monotonic() > deadline: raise AssertionError('dashboard did not start')
81 time.sleep(.05)
82 def stop():
83 server.terminate(); server.wait(timeout=10)
84 cookies = {}
85 def request(path, method='GET', body=None, status=200, extra=None, session=True, form=False):
86 headers = {'Snowglobe-Proxy-Token': proof, 'Host': 'snowglobe.paperclover.net', 'X-Snowglobe-Client-IP': '127.0.0.1'}
87 if body is not None: headers.update({'Origin': origin, 'Content-Type': 'application/x-www-form-urlencoded' if form else 'application/json'})
88 if session: headers['Cookie'] = '; '.join(f'{k}={v}' for k,v in cookies.items())
89 headers.update(extra or {})
90 connection = http.client.HTTPConnection('127.0.0.1', port, timeout=15)
91 content = (urllib.parse.urlencode(body) if form else json.dumps(body)) if body is not None else None
92 connection.request(method, path, body=content, headers=headers)
93 response = connection.getresponse(); content = response.read(); fields = dict(response.getheaders()); connection.close()
94 assert response.status == status, (path, response.status, content[:200])
95 if session and 'set-cookie' in fields:
96 key,value = fields['set-cookie'].split(';',1)[0].split('=',1); cookies[key] = value
97 return json.loads(content) if fields.get('content-type','').startswith('application/json') and content else fields
98 start()
99 try:
100 csrf = request('/auth/status')['csrf']
101 login = {'csrf': csrf, 'username': 'oidc-test', 'password': password, 'next': '/'}
102 request('/auth/password', 'POST', login)
103 metadata = request('/.well-known/openid-configuration', extra={'Snowglobe-Proxy-Token': 'wrong'})
104 assert metadata['issuer'] == origin and metadata['id_token_signing_alg_values_supported'] == ['RS256']
105 jwk = request('/auth/oidc/jwks')['keys'][0]
106 decode = lambda s: base64.urlsafe_b64decode(s + '=' * (-len(s) % 4))
107 key = rsa.RSAPublicNumbers(int.from_bytes(decode(jwk['e']), 'big'), int.from_bytes(decode(jwk['n']), 'big')).public_key()
108 verifier = b64(os.urandom(32))
109 authorize = {'client_id': 'shale', 'redirect_uri': callback, 'response_type': 'code',
110 'scope': 'openid profile email groups', 'state': 'fixture-state', 'nonce': 'fixture-nonce',
111 'code_challenge': b64(hashlib.sha256(verifier.encode()).digest()), 'code_challenge_method': 'S256'}
112 authorize_path = lambda values: '/auth/oidc/authorize?' + urllib.parse.urlencode(values)
113 request(authorize_path({**authorize, 'redirect_uri': 'https://evil.example/'}), status=400)
114 request(authorize_path(authorize) + '&client_id=other', status=400)
115 request(authorize_path({**authorize, 'scope': 'openid profile unknown'}), status=400)
116 assert request(authorize_path(authorize), session=False, status=302)['location'].startswith('/sign-in?next=')
117 denied = request(authorize_path({**authorize, 'prompt': 'none'}), session=False, status=302)['location']
118 assert urllib.parse.parse_qs(urllib.parse.urlparse(denied).query)['error'] == ['login_required']
119 def code(values=authorize):
120 location = request(authorize_path(values), status=302)['location']
121 result = urllib.parse.parse_qs(urllib.parse.urlparse(location).query)
122 assert result['state'] == ['fixture-state']
123 return result['code'][0]
124 exchange = {'client_id': 'shale', 'client_secret': secret, 'grant_type': 'authorization_code',
125 'redirect_uri': callback, 'code': code(), 'code_verifier': verifier}
126 for change in [{'client_secret': 'wrong'}, {'client_id': 'other'}, {'code_verifier': 'wrong'}, {'redirect_uri': 'https://evil.example/'}]:
127 request('/auth/oidc/token', 'POST', {**exchange, **change}, status=400, form=True)
128 other_basic = {'Authorization': 'Basic ' + base64.b64encode(('other:' + secret).encode()).decode()}
129 assert request('/auth/oidc/token', 'POST', {'client_id':'other','client_secret':secret,'grant_type':'authorization_code'}, extra=other_basic, status=400, form=True)['error'] == 'invalid_request'
130 basic_header = {'Authorization': 'Basic ' + base64.b64encode(('shale:' + secret).encode()).decode()}
131 request('/auth/oidc/token', 'POST', {**exchange, 'client_secret': 'different'}, extra=basic_header, status=400, form=True)
132 tokens = request('/auth/oidc/token', 'POST', exchange, extra=basic_header, form=True)
133 request('/auth/oidc/token', 'POST', exchange, status=400, form=True)
134 parts = tokens['id_token'].split('.')
135 key.verify(decode(parts[2]), (parts[0] + '.' + parts[1]).encode(), padding.PKCS1v15(), hashes.SHA256())
136 claims = json.loads(decode(parts[1])); assert claims['iss'] == origin and claims['sub'] == actor and claims['aud'] == 'shale'
137 assert claims['nonce'] == 'fixture-nonce' and claims['preferred_username'] == 'clover'
138 assert claims['groups'] == ['role:infra-admin'] and claims['email_verified'] is True
139 assert claims['at_hash'] == b64(hashlib.sha256(tokens['access_token'].encode()).digest()[:16])
140 bearer = lambda token: {'Authorization': 'Bearer ' + token}
141 assert request('/auth/oidc/userinfo', extra=bearer(tokens['access_token']))['sub'] == actor
142 refresh = {'client_id': 'shale', 'client_secret': secret, 'grant_type': 'refresh_token', 'refresh_token': tokens['refresh_token']}
143 rotated = request('/auth/oidc/token', 'POST', refresh, form=True)
144 request('/auth/oidc/userinfo', extra=bearer(tokens['access_token']), status=401)
145 request('/auth/oidc/token', 'POST', refresh, form=True, status=400)
146 request('/auth/oidc/userinfo', extra=bearer(rotated['access_token']), status=401)
147 request('/auth/oidc/token', 'POST', {**refresh, 'refresh_token': rotated['refresh_token']}, form=True, status=400)
148 # Shale uses a confidential client without PKCE; basic client auth also works.
149 unbound = {k:v for k,v in authorize.items() if not k.startswith('code_challenge')}
150 basic = {'Authorization': 'Basic ' + base64.b64encode(('shale:' + secret).encode()).decode()}
151 tokens = request('/auth/oidc/token', 'POST', {'grant_type': 'authorization_code', 'code': code(unbound), 'redirect_uri': callback}, extra=basic, form=True)
152 request('/auth/oidc/revoke', 'POST', {'token': tokens['refresh_token']}, extra=basic, form=True)
153 request('/auth/oidc/userinfo', extra=bearer(tokens['access_token']), status=401)
154 # Reauthentication must use a new session, even when a caller spoofs the continuation.
155 forced = request(authorize_path({**unbound, 'prompt': 'login', 'snow_reauth': '1'}), status=302)['location']
156 continuation = urllib.parse.parse_qs(urllib.parse.urlparse(forced).query)['next'][0]
157 assert request(continuation, status=302)['location'].startswith('/sign-in?next=')
158 request('/auth/password', 'POST', login)
159 resumed = request(continuation, status=302)['location']
160 assert 'code=' in resumed and resumed.startswith(callback)
161 tokens = request('/auth/oidc/token', 'POST', {**exchange, 'code': code()}, form=True)
162 # Account disabling is checked at the token endpoint, not only at sign-in.
163 disabled_code = code()
164 db = sqlite3.connect(data / 'accounts.sqlite')
165 db.execute("UPDATE users SET profile=json_set(profile,'$.enabled',json('false')) WHERE id=?", (actor,)); db.commit()
166 request('/auth/oidc/token', 'POST', {**exchange, 'code': disabled_code}, status=400, form=True)
167 request('/auth/oidc/userinfo', extra=bearer(tokens['access_token']), status=401)
168 db.execute("UPDATE users SET profile=json_set(profile,'$.enabled',json('true')) WHERE id=?", (actor,)); db.commit(); db.close()
169 stop(); start()
170 assert request('/auth/oidc/jwks')['keys'][0] == jwk
171 request('/auth/oidc/userinfo', extra=bearer(tokens['access_token']))
172 request('/auth/sign-out', 'POST', {})
173 request('/auth/oidc/userinfo', extra=bearer(tokens['access_token']), status=401)
174 request('/auth/oidc/token', 'POST', {**refresh, 'refresh_token': tokens['refresh_token']}, form=True, status=400)
175 # The real Shale client requests only openid; its registered mapping still supplies a username.
176 request('/auth/password', 'POST', login)
177 minimal = {**unbound, 'scope': 'openid'}
178 tokens = request('/auth/oidc/token', 'POST', {'grant_type': 'authorization_code', 'code': code(minimal), 'redirect_uri': callback}, extra=basic, form=True)
179 assert request('/auth/oidc/userinfo', extra=bearer(tokens['access_token'])) == {'sub': actor, 'preferred_username': 'clover'}
180 request('/auth/sign-out', 'POST', {})
181 # Provider UI is offered only for an exact registered Shale authorization request.
182 configured = subprocess.run([binary, '--guest-provider'], env=environment, capture_output=True, text=True,
183 input=json.dumps({'provider': 'github', 'clientId': 'fixture', 'clientSecret': secret}))
184 assert configured.returncode == 0, configured.stderr
185 target = authorize_path(minimal)
186 assert request('/auth/status')['service'] == 'snow globe'
187 assert request('/auth/status')['providers'] == []
188 assert request('/auth/status?' + urllib.parse.urlencode({'next': target}))['service'] == 'shale'
189 forged = target.replace(urllib.parse.quote(callback, safe=''), urllib.parse.quote('https://evil.example/callback', safe=''))
190 assert request('/auth/status?' + urllib.parse.urlencode({'next': forged}))['service'] == 'snow globe'
191 assert request('/auth/status?' + urllib.parse.urlencode({'next': target}))['providers'] == [{'id':'github','name':'GitHub'},{'id':'atproto','name':'AT / tangled / bsky'}]
192 request('/auth/guest/start/github?' + urllib.parse.urlencode({'next': '/'}), status=400)
193 started = request('/auth/guest/start/github?' + urllib.parse.urlencode({'next': target}), status=302)
194 external = urllib.parse.urlparse(started['location']); parameters = urllib.parse.parse_qs(external.query)
195 assert external.netloc == 'github.com' and parameters['scope'] == ['read:user'] and parameters['code_challenge_method'] == ['S256']
196 state = parameters['state'][0]
197 request('/auth/guest/callback/github?state=' + state, session=False, status=403)
198 request('/auth/guest/callback/astheno?state=' + state, status=403)
199 declined = request('/auth/guest/callback/github?' + urllib.parse.urlencode({'state':state,'error':'access_denied'}), status=302)['location']
200 assert 'guest_error=1' in declined
201 request('/auth/guest/callback/github?state=' + state, status=403)
202 # A guest's SSO cookie cannot open dashboard APIs, Files, credentials, or other OIDC clients.
203 guest, session_token = str(uuid.uuid4()), b64(os.urandom(32))
204 db = sqlite3.connect(data / 'accounts.sqlite')
205 profile = {'kind':'guest','guestProvider':'github','username':'guest-github-123','enabled':True,'email':None,'emailVerified':False,'firstName':'clover','lastName':None,'requiredActions':[]}
206 db.execute('INSERT INTO users(id,profile) VALUES (?,?)', (guest,json.dumps(profile)))
207 stamp = int(time.time()); session_hash = hashlib.sha256(session_token.encode()).hexdigest()
208 db.execute('INSERT INTO sessions VALUES (?,?,?,?,?,?,?,?)',(session_hash,guest,'dashboard',stamp+3600,'127.0.0.1',stamp,stamp,stamp)); db.commit()
209 cookies['__Host-snow-session'] = session_token
210 guest_csrf = request('/auth/status')['csrf']
211 request('/api/me', status=403)
212 assert request('/', status=302)['location'] == 'https://shale.paperclover.net/'
213 request('/auth/file/check', status=401)
214 request('/auth/passkey/register','POST',{'csrf':guest_csrf},status=403)
215 request(authorize_path({**unbound, 'client_id':'other','redirect_uri':'https://jelly.paperclover.net/callback'}), status=403)
216 tokens = request('/auth/oidc/token','POST',{'grant_type':'authorization_code','code':code(minimal),'redirect_uri':callback},extra=basic,form=True)
217 identity = request('/auth/oidc/userinfo',extra=bearer(tokens['access_token']))
218 assert identity == {'sub':guest,'preferred_username':'guest-github-123'}
219 provision('shale',[callback],{'oidc-test':'clover'},username=True)
220 request('/auth/oidc/userinfo',extra=bearer(tokens['access_token']),status=401)
221 request('/auth/oidc/token','POST',{'grant_type':'refresh_token','refresh_token':tokens['refresh_token']},extra=basic,form=True,status=400)
222 db.close()
223 print(json.dumps({'signature_nonce_alias_claims': 'passed', 'client_redirect_pkce_binding': 'passed',
224 'code_one_use': 'passed', 'refresh_rotation_reuse_revocation': 'passed', 'basic_client_auth': 'passed',
225 'forced_login': 'passed', 'disabled_account': 'passed', 'restart_key_persistence': 'passed', 'logout_revocation': 'passed',
226 'shale_openid_username_mapping': 'passed', 'guest_flow_cookie_and_provider_binding': 'passed', 'guest_scope_and_service_boundaries': 'passed'}))
227 finally:
228 if server and server.poll() is None: stop()
229 log.close()
230
231
232if __name__ == '__main__':
233 main()