| 1 | """Disposable OAuth/PDS fixture. TLS files and listening address are supplied by Rust tests.""" |
| 2 | import base64 |
| 3 | import hashlib |
| 4 | import json |
| 5 | import html |
| 6 | import os |
| 7 | import secrets |
| 8 | import ssl |
| 9 | import subprocess |
| 10 | import sys |
| 11 | import tempfile |
| 12 | import time |
| 13 | from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer |
| 14 | from pathlib import Path |
| 15 | from urllib.parse import parse_qs, urlsplit, urlencode |
| 16 | from urllib.request import urlopen |
| 17 | |
| 18 | ISSUER = os.environ.get('ATPROTO_FIXTURE_ORIGIN', 'https://issuer.example.com') |
| 19 | PDS = os.environ.get('ATPROTO_FIXTURE_ORIGIN', 'https://pds.example.com') |
| 20 | DID = 'did:web:' + (urlsplit(os.environ['ATPROTO_FIXTURE_ORIGIN']).hostname if 'ATPROTO_FIXTURE_ORIGIN' in os.environ else 'alice.example.com') |
| 21 | AVATAR = base64.b64decode('iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAIAAAD8GO2jAAAAQklEQVR4nGNIcziOFf3fbYsVkaqeYdSCUQuGgAXUMgiX+lELRi0YChZQyyBc6kctGLVgKFhALYNwqR+1YNSCIWABALbxyFuikyXnAAAAAElFTkSuQmCC') |
| 22 | AVATAR_CID = 'bafkreifixtureavatar' |
| 23 | |
| 24 | |
| 25 | def decode(text): |
| 26 | return base64.urlsafe_b64decode(text + '=' * (-len(text) % 4)) |
| 27 | |
| 28 | |
| 29 | def signature_der(raw): |
| 30 | def integer(value): |
| 31 | value = value.lstrip(b'\0') or b'\0' |
| 32 | if value[0] & 128: |
| 33 | value = b'\0' + value |
| 34 | return b'\x02' + bytes([len(value)]) + value |
| 35 | value = integer(raw[:32]) + integer(raw[32:]) |
| 36 | return b'\x30' + bytes([len(value)]) + value |
| 37 | |
| 38 | |
| 39 | class Fixture(BaseHTTPRequestHandler): |
| 40 | seen = set() |
| 41 | flows = {} |
| 42 | mode = '' |
| 43 | nonce = 'fixture-nonce' |
| 44 | exchanged = False |
| 45 | |
| 46 | def log_message(self, *_): |
| 47 | pass |
| 48 | |
| 49 | def send(self, code, value, nonce=False, content_type='application/json'): |
| 50 | body = json.dumps(value).encode() |
| 51 | self.send_response(code) |
| 52 | self.send_header('Content-Type', content_type) |
| 53 | self.send_header('Content-Length', str(len(body))) |
| 54 | if nonce and self.mode != 'missing-nonce': |
| 55 | self.send_header('DPoP-Nonce', self.nonce) |
| 56 | self.end_headers() |
| 57 | self.wfile.write(body) |
| 58 | |
| 59 | def do_GET(self): |
| 60 | path = urlsplit(self.path).path |
| 61 | if path == '/.well-known/atproto-did': |
| 62 | body = DID.encode() |
| 63 | self.send_response(200) |
| 64 | self.send_header('Content-Length', str(len(body))) |
| 65 | self.end_headers() |
| 66 | self.wfile.write(body) |
| 67 | return |
| 68 | if path == '/authorize': |
| 69 | uri = parse_qs(urlsplit(self.path).query).get('request_uri', [''])[0] |
| 70 | if uri not in self.flows: |
| 71 | return self.send(400, {'error': 'expired_request'}) |
| 72 | body = ('<!doctype html><meta name="viewport" content="width=device-width"><title>Fixture account</title>' |
| 73 | '<h1>Disposable AT Protocol account</h1><p>This fixture never asks for a password.</p>' |
| 74 | '<form method="post" action="/decision"><input type="hidden" name="request_uri" value="'+html.escape(uri, quote=True)+'">' |
| 75 | '<button name="decision" value="approve">Continue as Fixture Alice</button> ' |
| 76 | '<button name="decision" value="cancel">Cancel</button></form>').encode() |
| 77 | self.send_response(200) |
| 78 | self.send_header('Content-Type', 'text/html; charset=utf-8') |
| 79 | self.send_header('Content-Length', str(len(body))) |
| 80 | self.end_headers() |
| 81 | self.wfile.write(body) |
| 82 | return |
| 83 | if path == '/fixture/mode': |
| 84 | type(self).exchanged = False |
| 85 | type(self).mode = parse_qs(urlsplit(self.path).query).get('mode', [''])[0] |
| 86 | return self.send(200, {}) |
| 87 | if path == '/.well-known/did.json': |
| 88 | return self.send(200, {'id': DID, 'alsoKnownAs': ['at://'+urlsplit(PDS).hostname] if 'ATPROTO_FIXTURE_ORIGIN' in os.environ else [], 'service': [{'id': '#atproto_pds', 'type': 'AtprotoPersonalDataServer', 'serviceEndpoint': 'https://127.0.0.1' if self.mode == 'private-pds' else PDS}]}, content_type='application/did+ld+json') |
| 89 | if path == '/.well-known/oauth-protected-resource': |
| 90 | return self.send(200, {'resource': PDS, 'authorization_servers': [ISSUER]}) |
| 91 | if path == '/.well-known/oauth-authorization-server': |
| 92 | return self.send(200, {'issuer': 'https://wrong.example.com' if self.mode == 'wrong-metadata-issuer' or (self.mode == 'changed-issuer' and self.exchanged) else ISSUER, |
| 93 | 'authorization_endpoint': ISSUER+'/authorize', 'token_endpoint': ISSUER+'/token'+('?tenant=fixture' if self.mode == 'endpoint-query' else ''), |
| 94 | 'pushed_authorization_request_endpoint': ISSUER+'/par', 'response_types_supported': ['code'], |
| 95 | 'grant_types_supported': ['authorization_code', 'refresh_token'], 'code_challenge_methods_supported': ['S256'], |
| 96 | 'token_endpoint_auth_methods_supported': ['none', 'private_key_jwt'], 'scopes_supported': ['atproto'], |
| 97 | 'dpop_signing_alg_values_supported': ['ES256'], 'require_pushed_authorization_requests': True, |
| 98 | 'authorization_response_iss_parameter_supported': True, 'client_id_metadata_document_supported': True}) |
| 99 | if path == '/xrpc/com.atproto.repo.getRecord': |
| 100 | query = parse_qs(urlsplit(self.path).query) |
| 101 | collection = query['collection'][0] |
| 102 | if self.mode == 'no-profiles' or (collection == 'sh.tangled.actor.profile' and self.mode == 'bluesky-only'): |
| 103 | return self.send(400, {'error': 'RecordNotFound'}) |
| 104 | return self.send(200, {'uri': f'at://{DID}/{collection}/self', 'value': {'$type': collection, 'displayName': 'Fixture Alice', 'avatar': {'$type': 'blob', 'ref': {'$link': AVATAR_CID}, 'mimeType': 'image/png', 'size': len(AVATAR)}}}) |
| 105 | if path == '/xrpc/com.atproto.sync.getBlob': |
| 106 | query = parse_qs(urlsplit(self.path).query) |
| 107 | if query.get('did') != [DID] or query.get('cid') != [AVATAR_CID]: |
| 108 | return self.send(404, {'error': 'BlobNotFound'}) |
| 109 | self.send_response(200) |
| 110 | self.send_header('Content-Type', 'image/png') |
| 111 | self.send_header('Content-Length', str(len(AVATAR))) |
| 112 | self.end_headers() |
| 113 | self.wfile.write(AVATAR) |
| 114 | return |
| 115 | if path == '/redirect': |
| 116 | self.send_response(302) |
| 117 | self.send_header('Location', 'https://127.0.0.1/private') |
| 118 | self.end_headers() |
| 119 | return |
| 120 | if path == '/oversized': |
| 121 | return self.send(200, {'data': 'a'*70000}) |
| 122 | return self.send(404, {'error': 'NotFound'}) |
| 123 | |
| 124 | def do_POST(self): |
| 125 | if self.path == '/decision': |
| 126 | form = parse_qs(self.rfile.read(min(int(self.headers['Content-Length']), 8192)).decode()) |
| 127 | uri = form.get('request_uri', [''])[0] |
| 128 | if uri not in self.flows: |
| 129 | return self.send(400, {'error': 'expired_request'}) |
| 130 | original, _ = self.flows[uri] |
| 131 | query = {'state': original['state'][0], 'iss': ISSUER} |
| 132 | query['code' if form.get('decision') == ['approve'] else 'error'] = uri if form.get('decision') == ['approve'] else 'access_denied' |
| 133 | self.send_response(302) |
| 134 | self.send_header('Location', original['redirect_uri'][0]+'?'+urlencode(query)) |
| 135 | self.end_headers() |
| 136 | return |
| 137 | try: |
| 138 | parts = self.headers['DPoP'].split('.') |
| 139 | header, claims = map(lambda v: json.loads(decode(v)), parts[:2]) |
| 140 | assert header['alg'] == 'ES256' and header['typ'] == 'dpop+jwt' |
| 141 | assert claims['htm'] == 'POST' and claims['htu'] == ISSUER+urlsplit(self.path).path |
| 142 | assert abs(claims['iat'] - time.time()) < 60 and claims['jti'] not in self.seen |
| 143 | self.seen.add(claims['jti']) |
| 144 | jwk = header['jwk'] |
| 145 | assert jwk['crv'] == 'P-256' and jwk['kty'] == 'EC' and 'd' not in jwk |
| 146 | public = bytes.fromhex('3059301306072a8648ce3d020106082a8648ce3d03010703420004') + decode(jwk['x']) + decode(jwk['y']) |
| 147 | with tempfile.TemporaryDirectory() as temp: |
| 148 | Path(temp, 'pub.der').write_bytes(public) |
| 149 | Path(temp, 'sig.der').write_bytes(signature_der(decode(parts[2]))) |
| 150 | checked = subprocess.run(['openssl', 'dgst', '-sha256', '-keyform', 'DER', '-verify', str(Path(temp, 'pub.der')), '-signature', str(Path(temp, 'sig.der'))], input='.'.join(parts[:2]).encode(), capture_output=True) |
| 151 | assert checked.returncode == 0 |
| 152 | form = parse_qs(self.rfile.read(int(self.headers['Content-Length'])).decode()) |
| 153 | expected_nonce = 'rotated-token-nonce' if self.mode == 'rotating-nonce' and self.path == '/token' else 'fixture-nonce' |
| 154 | type(self).nonce = expected_nonce |
| 155 | if claims.get('nonce') != expected_nonce: |
| 156 | return self.send(400, {'error': 'use_dpop_nonce'}, True) |
| 157 | if self.path == '/par': |
| 158 | assert form['scope'] == ['atproto'] and form['code_challenge_method'] == ['S256'] |
| 159 | assert form['login_hint'] == [DID] |
| 160 | if 'ATPROTO_FIXTURE_ORIGIN' in os.environ: |
| 161 | expected = os.environ['ATPROTO_FIXTURE_CLIENT_ORIGIN'].rstrip('/')+'/auth/guest/metadata/atproto' |
| 162 | assert form['client_id'] == [expected] |
| 163 | with urlopen(expected, timeout=10) as response: |
| 164 | metadata = json.load(response) |
| 165 | assert metadata['client_id'] == expected and metadata['dpop_bound_access_tokens'] is True |
| 166 | assert form['redirect_uri'][0] in metadata['redirect_uris'] |
| 167 | if len(self.flows) > 128: |
| 168 | self.flows.clear() |
| 169 | uri = 'urn:ietf:params:oauth:request_uri:'+secrets.token_hex(16) |
| 170 | self.flows[uri] = (form, jwk) |
| 171 | return self.send(201, {'request_uri': uri, 'expires_in': 300}, True) |
| 172 | if urlsplit(self.path).path == '/token': |
| 173 | original, original_jwk = self.flows.pop(form['code'][0]) |
| 174 | assert original_jwk == jwk |
| 175 | expected = base64.urlsafe_b64encode(hashlib.sha256(form['code_verifier'][0].encode()).digest()).decode().rstrip('=') |
| 176 | assert original['code_challenge'] == [expected] |
| 177 | assert original['client_id'] == form['client_id'] and original['redirect_uri'] == form['redirect_uri'] |
| 178 | type(self).exchanged = True |
| 179 | return self.send(200, {'sub': 'did:web:mallory.example.com' if self.mode == 'wrong-subject' else DID, |
| 180 | 'access_token': 'disposable-fixture-token', 'token_type': 'DPoP', 'scope': 'atproto'}, True) |
| 181 | return self.send(404, {}, True) |
| 182 | except Exception: |
| 183 | return self.send(400, {'error': 'fixture_validation_failed'}, True) |
| 184 | |
| 185 | |
| 186 | if __name__ == '__main__': |
| 187 | server = ThreadingHTTPServer((os.environ.get('ATPROTO_FIXTURE_BIND', '127.0.0.1'), int(os.environ.get('ATPROTO_FIXTURE_PORT', '0'))), Fixture) |
| 188 | if len(sys.argv) == 3: |
| 189 | tls = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER) |
| 190 | tls.load_cert_chain(sys.argv[1], sys.argv[2]) |
| 191 | server.socket = tls.wrap_socket(server.socket, server_side=True) |
| 192 | elif 'ATPROTO_FIXTURE_ORIGIN' not in os.environ or 'ATPROTO_FIXTURE_CLIENT_ORIGIN' not in os.environ: |
| 193 | raise SystemExit('Configure fixture and client HTTPS origins behind a TLS proxy, or pass a TLS certificate and key.') |
| 194 | print(server.server_port, flush=True) |
| 195 | server.serve_forever() |