| """SecureMed EC2 API. Cognito access tokens are verified on every protected request.""" |
| from __future__ import annotations |
|
|
| import os |
| import sqlite3 |
| import uuid |
| from contextlib import contextmanager |
| from datetime import datetime, timezone |
| from pathlib import Path |
|
|
| import httpx |
| import jwt |
| from fastapi import FastAPI, File, Form, Header, HTTPException, Query, Request, UploadFile |
| from fastapi.responses import FileResponse |
| from jwt import PyJWKClient |
|
|
| DB_PATH = Path(os.getenv('DATABASE_PATH', '/data/securemed.db')) |
| REGION = os.getenv('AWS_REGION', '') |
| POOL_ID = os.getenv('COGNITO_USER_POOL_ID', '') |
| CLIENT_ID = os.getenv('COGNITO_CLIENT_ID', '') |
| COGNITO_DOMAIN = os.getenv('COGNITO_DOMAIN', '').rstrip('/') |
| PUBLIC_CALLBACK_URL = os.getenv('PUBLIC_CALLBACK_URL', '') |
| DIAGNOSIS_URL = os.getenv('DIAGNOSIS_URL', 'http://diagnosis:8080/diagnose') |
| MAX_IMAGE_BYTES = 5 * 1024 * 1024 |
| ISSUER = f'https://cognito-idp.{REGION}.amazonaws.com/{POOL_ID}' |
| jwks = PyJWKClient(f'{ISSUER}/.well-known/jwks.json', cache_jwk_set=True, lifespan=300) |
| app = FastAPI(title='SecureMed', docs_url=None, redoc_url=None, openapi_url=None) |
|
|
|
|
| def connect(): |
| DB_PATH.parent.mkdir(parents=True, exist_ok=True) |
| db = sqlite3.connect(DB_PATH, timeout=10) |
| db.row_factory = sqlite3.Row |
| db.execute('PRAGMA foreign_keys=ON') |
| db.execute('PRAGMA busy_timeout=10000') |
| return db |
|
|
|
|
| @contextmanager |
| def database(): |
| db = connect() |
| try: |
| yield db |
| db.commit() |
| finally: |
| db.close() |
|
|
|
|
| def init_db(): |
| with database() as db: |
| db.executescript(''' |
| CREATE TABLE IF NOT EXISTS patients ( |
| patient_id TEXT PRIMARY KEY, name TEXT NOT NULL |
| ); |
| CREATE TABLE IF NOT EXISTS identities ( |
| sub TEXT PRIMARY KEY, role TEXT NOT NULL CHECK(role IN ('doctor','patient')), |
| patient_id TEXT UNIQUE REFERENCES patients(patient_id) |
| ); |
| CREATE TABLE IF NOT EXISTS diagnoses ( |
| id TEXT PRIMARY KEY, patient_id TEXT NOT NULL REFERENCES patients(patient_id), |
| diagnosis INTEGER NOT NULL CHECK(diagnosis BETWEEN 0 AND 3), |
| created_at TEXT NOT NULL |
| ); |
| CREATE INDEX IF NOT EXISTS diagnoses_patient ON diagnoses(patient_id, created_at); |
| ''') |
|
|
|
|
| @app.on_event('startup') |
| def startup(): |
| init_db() |
|
|
|
|
| def claims_from_request(authorization: str | None): |
| if not authorization or not authorization.startswith('Bearer '): |
| raise HTTPException(401, 'Authentication required') |
| token = authorization[7:].strip() |
| if not token or not REGION or not POOL_ID or not CLIENT_ID: |
| raise HTTPException(401, 'Invalid token') |
| try: |
| key = jwks.get_signing_key_from_jwt(token).key |
| claims = jwt.decode(token, key, algorithms=['RS256'], issuer=ISSUER, |
| options={'verify_aud': False, 'require': ['exp', 'iss', 'sub']}, leeway=30) |
| if claims.get('token_use') != 'access' or claims.get('client_id') != CLIENT_ID or not claims.get('sub'): |
| raise ValueError('Wrong token type or client') |
| return claims, token |
| except (jwt.PyJWTError, ValueError) as exc: |
| raise HTTPException(401, 'Invalid or expired token') from exc |
|
|
|
|
| def identity(authorization: str | None, required_role: str): |
| claims, token = claims_from_request(authorization) |
| groups = claims.get('cognito:groups', []) |
| if not isinstance(groups, list): |
| groups = [] |
| sub = claims['sub'] |
| with database() as db: |
| row = db.execute('SELECT role, patient_id FROM identities WHERE sub=?', (sub,)).fetchone() |
| if required_role == 'doctor': |
| if 'doctor' not in groups or not row or row['role'] != 'doctor': |
| raise HTTPException(403, 'Doctor access required') |
| else: |
| if 'doctor' in groups or (row and row['role'] != 'patient'): |
| raise HTTPException(403, 'Patient access required') |
| if not row: |
| |
| |
| |
| name = user_info_name(token, claims) |
| patient_id = 'P' + uuid.uuid4().hex[:12].upper() |
| db.execute('INSERT INTO patients(patient_id, name) VALUES (?, ?)', (patient_id, name)) |
| db.execute('INSERT INTO identities(sub, role, patient_id) VALUES (?, ?, ?)', |
| (sub, 'patient', patient_id)) |
| row = {'role': 'patient', 'patient_id': patient_id} |
| if row['role'] != required_role: |
| raise HTTPException(403, 'Forbidden') |
| return row['patient_id'] |
|
|
|
|
| def user_info_name(token: str, claims: dict) -> str: |
| if COGNITO_DOMAIN: |
| try: |
| response = httpx.get(f'{COGNITO_DOMAIN}/oauth2/userInfo', |
| headers={'Authorization': f'Bearer {token}'}, timeout=5) |
| response.raise_for_status() |
| info = response.json() |
| name = info.get('name') or info.get('given_name') or info.get('email') |
| if isinstance(name, str) and name.strip(): |
| return name.strip()[:100] |
| except (httpx.HTTPError, ValueError): |
| pass |
| return str(claims.get('username') or claims['sub'])[:100] |
|
|
|
|
| def patient_record(patient_id: str): |
| with database() as db: |
| patient = db.execute('SELECT patient_id, name FROM patients WHERE patient_id=?', (patient_id,)).fetchone() |
| if not patient: |
| raise HTTPException(404, 'Patient not found') |
| diagnoses = db.execute('SELECT diagnosis, created_at FROM diagnoses WHERE patient_id=? ORDER BY created_at, id', |
| (patient_id,)).fetchall() |
| return {'patient_id': patient['patient_id'], 'name': patient['name'], |
| 'diagnoses': [{'diagnosis': d['diagnosis'], 'created_at': d['created_at']} for d in diagnoses]} |
|
|
|
|
| async def scan(patient_id: str, image: UploadFile): |
| patient_record(patient_id) |
| data = await image.read(MAX_IMAGE_BYTES + 1) |
| if not data or len(data) > MAX_IMAGE_BYTES: |
| raise HTTPException(400, 'Image must be between 1 byte and 5 MiB') |
| if data.startswith(b'\x89PNG\r\n\x1a\n'): |
| content_type = 'image/png' |
| elif data.startswith(b'\xff\xd8\xff'): |
| content_type = 'image/jpeg' |
| else: |
| raise HTTPException(400, 'Only JPEG and PNG images are accepted') |
| try: |
| async with httpx.AsyncClient(timeout=35) as client: |
| response = await client.post(DIAGNOSIS_URL, content=data, headers={'Content-Type': content_type}) |
| if response.status_code == 400: |
| raise HTTPException(400, 'Unreadable image') |
| response.raise_for_status() |
| value = response.json().get('diagnosis') |
| if type(value) is not int or value not in range(4): |
| raise ValueError('Invalid diagnosis response') |
| except HTTPException: |
| raise |
| except (httpx.HTTPError, ValueError) as exc: |
| raise HTTPException(502, 'Diagnosis service unavailable') from exc |
| with database() as db: |
| db.execute('INSERT INTO diagnoses(id, patient_id, diagnosis, created_at) VALUES (?, ?, ?, ?)', |
| (str(uuid.uuid4()), patient_id, value, datetime.now(timezone.utc).isoformat())) |
| return value |
|
|
|
|
| @app.get('/') |
| def website(): |
| return FileResponse(Path(__file__).with_name('index.html'), media_type='text/html', headers={'Cache-Control': 'no-store'}) |
|
|
|
|
| @app.get('/api/health') |
| def health(): |
| with database() as db: |
| db.execute('SELECT 1').fetchone() |
| return {'status': 'ok'} |
|
|
|
|
| @app.get('/api/web-config') |
| def web_config(): |
| return {'domain': COGNITO_DOMAIN, 'client_id': CLIENT_ID, 'redirect_uri': PUBLIC_CALLBACK_URL} |
|
|
|
|
| @app.get('/api/doctor/patients/{patient_id}') |
| def doctor_patient(patient_id: str, authorization: str | None = Header(None)): |
| identity(authorization, 'doctor') |
| return patient_record(patient_id) |
|
|
|
|
| @app.post('/api/doctor/scan') |
| async def doctor_scan(image: UploadFile = File(...), patient_id: str | None = Form(None), |
| patient_id_query: str | None = Query(None, alias='patient_id'), |
| authorization: str | None = Header(None)): |
| identity(authorization, 'doctor') |
| target = patient_id or patient_id_query |
| if not target: |
| raise HTTPException(400, 'patient_id is required') |
| return {'patient_id': target, 'diagnosis': await scan(target, image)} |
|
|
|
|
| @app.get('/api/patient/me') |
| def patient_me(authorization: str | None = Header(None)): |
| return patient_record(identity(authorization, 'patient')) |
|
|
|
|
| @app.post('/api/patient/scan') |
| async def patient_scan(image: UploadFile = File(...), authorization: str | None = Header(None)): |
| patient_id = identity(authorization, 'patient') |
| return {'diagnosis': await scan(patient_id, image)} |
|
|
|
|
| @app.get('/api/patient/diagnosis') |
| def patient_diagnosis(name: str = Query(..., min_length=1, max_length=100), |
| authorization: str | None = Header(None)): |
| patient_id = identity(authorization, 'patient') |
| record = patient_record(patient_id) |
| if name != record['name']: |
| raise HTTPException(403, 'Forbidden') |
| return record |
|
|
