askrobots / dbbasic-object-primitive
Public
Python functions as REST objects, with clustering, load balancing and state replication; no containers or orchestration.
auth.py · 12.9 KB · 455 lines
| 1 | """ |
| 2 | Auth System - Object Primitive Style |
| 3 | |
| 4 | A complete authentication system demonstrating: |
| 5 | - User registration with password hashing |
| 6 | - Login with session tokens |
| 7 | - Token validation |
| 8 | - User management |
| 9 | - All in Object Primitive style (self-logging, persistent state) |
| 10 | |
| 11 | Endpoints: |
| 12 | - POST /objects/advanced_auth - Register or login |
| 13 | - GET /objects/advanced_auth?token=xyz - Validate token |
| 14 | - PUT /objects/advanced_auth - Update user |
| 15 | - DELETE /objects/advanced_auth?token=xyz - Logout |
| 16 | |
| 17 | This demonstrates how to build auth WITHOUT using dbbasic-accounts |
| 18 | (which uses traditional class-based architecture). Instead, we use |
| 19 | Object Primitive patterns: _state_manager for persistence, _logger |
| 20 | for audit trails, and REST methods for the interface. |
| 21 | """ |
| 22 | |
| 23 | import hashlib |
| 24 | import secrets |
| 25 | import json |
| 26 | import time |
| 27 | from typing import Dict, Any, Optional |
| 28 | |
| 29 | # Object Primitive dependencies (injected by runtime) |
| 30 | _logger = None |
| 31 | _state_manager = None |
| 32 | |
| 33 | |
| 34 | def GET(request: Dict[str, Any]) -> Dict[str, Any]: |
| 35 | """ |
| 36 | Validate authentication token. |
| 37 | |
| 38 | Query params: |
| 39 | - token: Session token to validate |
| 40 | - user: Username to get info for (requires admin token) |
| 41 | |
| 42 | Returns: |
| 43 | - User info if token is valid |
| 44 | - Error if token is invalid or expired |
| 45 | """ |
| 46 | token = request.get('token', '') |
| 47 | username = request.get('user', '') |
| 48 | |
| 49 | if not token: |
| 50 | return {'status': 'error', 'message': 'Token required'} |
| 51 | |
| 52 | # Validate token |
| 53 | user_info = _validate_token(token) |
| 54 | if not user_info: |
| 55 | if _logger: |
| 56 | _logger.warning('Invalid token attempt', token=token[:8]) |
| 57 | return {'status': 'error', 'message': 'Invalid or expired token'} |
| 58 | |
| 59 | if _logger: |
| 60 | _logger.info('Token validated', username=user_info['username']) |
| 61 | |
| 62 | # If requesting another user's info, check admin permission |
| 63 | if username and username != user_info['username']: |
| 64 | if not user_info.get('is_admin', False): |
| 65 | return {'status': 'error', 'message': 'Admin access required'} |
| 66 | |
| 67 | # Get requested user |
| 68 | users = _get_users() |
| 69 | if username not in users: |
| 70 | return {'status': 'error', 'message': f'User not found: {username}'} |
| 71 | |
| 72 | user_data = users[username] |
| 73 | return { |
| 74 | 'status': 'ok', |
| 75 | 'user': { |
| 76 | 'username': username, |
| 77 | 'email': user_data.get('email', ''), |
| 78 | 'is_admin': user_data.get('is_admin', False), |
| 79 | 'created_at': user_data.get('created_at', ''), |
| 80 | } |
| 81 | } |
| 82 | |
| 83 | # Return current user info |
| 84 | return { |
| 85 | 'status': 'ok', |
| 86 | 'user': { |
| 87 | 'username': user_info['username'], |
| 88 | 'email': user_info.get('email', ''), |
| 89 | 'is_admin': user_info.get('is_admin', False), |
| 90 | 'token': token, |
| 91 | } |
| 92 | } |
| 93 | |
| 94 | |
| 95 | def POST(request: Dict[str, Any]) -> Dict[str, Any]: |
| 96 | """ |
| 97 | Register new user or login existing user. |
| 98 | |
| 99 | Body (JSON): |
| 100 | { |
| 101 | "action": "register" | "login", |
| 102 | "username": "alice", |
| 103 | "password": "secret123", |
| 104 | "email": "alice@example.com" // only for register |
| 105 | } |
| 106 | |
| 107 | Returns: |
| 108 | - Session token on success |
| 109 | - Error message on failure |
| 110 | """ |
| 111 | action = request.get('action', 'login') |
| 112 | username = request.get('username', '').strip() |
| 113 | password = request.get('password', '') |
| 114 | email = request.get('email', '').strip() |
| 115 | |
| 116 | # Validation |
| 117 | if not username or not password: |
| 118 | return {'status': 'error', 'message': 'Username and password required'} |
| 119 | |
| 120 | if action == 'register': |
| 121 | return _register_user(username, password, email) |
| 122 | elif action == 'login': |
| 123 | return _login_user(username, password) |
| 124 | else: |
| 125 | return {'status': 'error', 'message': f'Unknown action: {action}'} |
| 126 | |
| 127 | |
| 128 | def PUT(request: Dict[str, Any]) -> Dict[str, Any]: |
| 129 | """ |
| 130 | Update user information. |
| 131 | |
| 132 | Body (JSON): |
| 133 | { |
| 134 | "token": "xyz", |
| 135 | "email": "newemail@example.com", // optional |
| 136 | "password": "newpassword", // optional |
| 137 | "old_password": "oldpassword" // required if changing password |
| 138 | } |
| 139 | |
| 140 | Returns: |
| 141 | - Success message |
| 142 | - Error if unauthorized or validation fails |
| 143 | """ |
| 144 | token = request.get('token', '') |
| 145 | |
| 146 | if not token: |
| 147 | return {'status': 'error', 'message': 'Token required'} |
| 148 | |
| 149 | # Validate token |
| 150 | user_info = _validate_token(token) |
| 151 | if not user_info: |
| 152 | return {'status': 'error', 'message': 'Invalid or expired token'} |
| 153 | |
| 154 | username = user_info['username'] |
| 155 | users = _get_users() |
| 156 | |
| 157 | if username not in users: |
| 158 | return {'status': 'error', 'message': 'User not found'} |
| 159 | |
| 160 | user = users[username] |
| 161 | updated = False |
| 162 | |
| 163 | # Update email |
| 164 | new_email = request.get('email', '').strip() |
| 165 | if new_email: |
| 166 | user['email'] = new_email |
| 167 | updated = True |
| 168 | if _logger: |
| 169 | _logger.info('Email updated', username=username, email=new_email) |
| 170 | |
| 171 | # Update password |
| 172 | new_password = request.get('password', '') |
| 173 | old_password = request.get('old_password', '') |
| 174 | |
| 175 | if new_password: |
| 176 | # Verify old password |
| 177 | if not old_password: |
| 178 | return {'status': 'error', 'message': 'old_password required to change password'} |
| 179 | |
| 180 | if not _verify_password(old_password, user['password_hash']): |
| 181 | if _logger: |
| 182 | _logger.warning('Failed password change', username=username, reason='incorrect old password') |
| 183 | return {'status': 'error', 'message': 'Incorrect old password'} |
| 184 | |
| 185 | # Hash and save new password |
| 186 | user['password_hash'] = _hash_password(new_password) |
| 187 | updated = True |
| 188 | |
| 189 | if _logger: |
| 190 | _logger.warning('Password changed', username=username) |
| 191 | |
| 192 | if updated: |
| 193 | _save_users(users) |
| 194 | return {'status': 'ok', 'message': 'User updated'} |
| 195 | else: |
| 196 | return {'status': 'ok', 'message': 'No changes'} |
| 197 | |
| 198 | |
| 199 | def DELETE(request: Dict[str, Any]) -> Dict[str, Any]: |
| 200 | """ |
| 201 | Logout (invalidate token) or delete user account. |
| 202 | |
| 203 | Query params: |
| 204 | - token: Session token |
| 205 | - delete_account: If 'true', delete account (requires password confirmation) |
| 206 | - password: Required if delete_account=true |
| 207 | |
| 208 | Returns: |
| 209 | - Success message |
| 210 | - Error if unauthorized |
| 211 | """ |
| 212 | token = request.get('token', '') |
| 213 | |
| 214 | if not token: |
| 215 | return {'status': 'error', 'message': 'Token required'} |
| 216 | |
| 217 | # Validate token |
| 218 | user_info = _validate_token(token) |
| 219 | if not user_info: |
| 220 | return {'status': 'error', 'message': 'Invalid or expired token'} |
| 221 | |
| 222 | # Check if deleting account |
| 223 | delete_account = request.get('delete_account', '').lower() == 'true' |
| 224 | |
| 225 | if delete_account: |
| 226 | # Confirm password |
| 227 | password = request.get('password', '') |
| 228 | if not password: |
| 229 | return {'status': 'error', 'message': 'Password required to delete account'} |
| 230 | |
| 231 | users = _get_users() |
| 232 | username = user_info['username'] |
| 233 | |
| 234 | if username not in users: |
| 235 | return {'status': 'error', 'message': 'User not found'} |
| 236 | |
| 237 | if not _verify_password(password, users[username]['password_hash']): |
| 238 | if _logger: |
| 239 | _logger.warning('Failed account deletion', username=username, reason='incorrect password') |
| 240 | return {'status': 'error', 'message': 'Incorrect password'} |
| 241 | |
| 242 | # Delete user |
| 243 | del users[username] |
| 244 | _save_users(users) |
| 245 | |
| 246 | # Invalidate all tokens for this user |
| 247 | _invalidate_user_tokens(username) |
| 248 | |
| 249 | if _logger: |
| 250 | _logger.warning('Account deleted', username=username) |
| 251 | |
| 252 | return {'status': 'ok', 'message': f'Account {username} deleted'} |
| 253 | else: |
| 254 | # Just logout (invalidate token) |
| 255 | _invalidate_token(token) |
| 256 | |
| 257 | if _logger: |
| 258 | _logger.info('User logged out', username=user_info['username']) |
| 259 | |
| 260 | return {'status': 'ok', 'message': 'Logged out'} |
| 261 | |
| 262 | |
| 263 | # --- Internal Helper Functions --- |
| 264 | |
| 265 | def _register_user(username: str, password: str, email: str) -> Dict[str, Any]: |
| 266 | """Register a new user.""" |
| 267 | # Validation |
| 268 | if len(username) < 3: |
| 269 | return {'status': 'error', 'message': 'Username must be at least 3 characters'} |
| 270 | |
| 271 | if len(password) < 8: |
| 272 | return {'status': 'error', 'message': 'Password must be at least 8 characters'} |
| 273 | |
| 274 | if not email or '@' not in email: |
| 275 | return {'status': 'error', 'message': 'Valid email required'} |
| 276 | |
| 277 | # Check if user exists |
| 278 | users = _get_users() |
| 279 | if username in users: |
| 280 | if _logger: |
| 281 | _logger.warning('Registration failed', username=username, reason='already exists') |
| 282 | return {'status': 'error', 'message': 'Username already exists'} |
| 283 | |
| 284 | # Create user |
| 285 | users[username] = { |
| 286 | 'password_hash': _hash_password(password), |
| 287 | 'email': email, |
| 288 | 'is_admin': False, # First user could be admin, or set manually |
| 289 | 'created_at': int(time.time()), |
| 290 | } |
| 291 | |
| 292 | # Save users |
| 293 | _save_users(users) |
| 294 | |
| 295 | # Create session token |
| 296 | token = _create_token(username) |
| 297 | |
| 298 | if _logger: |
| 299 | _logger.info('User registered', username=username, email=email) |
| 300 | |
| 301 | return { |
| 302 | 'status': 'ok', |
| 303 | 'message': 'User registered', |
| 304 | 'token': token, |
| 305 | 'username': username, |
| 306 | } |
| 307 | |
| 308 | |
| 309 | def _login_user(username: str, password: str) -> Dict[str, Any]: |
| 310 | """Login existing user.""" |
| 311 | users = _get_users() |
| 312 | |
| 313 | if username not in users: |
| 314 | if _logger: |
| 315 | _logger.warning('Login failed', username=username, reason='not found') |
| 316 | # Don't reveal if user exists |
| 317 | return {'status': 'error', 'message': 'Invalid username or password'} |
| 318 | |
| 319 | user = users[username] |
| 320 | |
| 321 | # Verify password |
| 322 | if not _verify_password(password, user['password_hash']): |
| 323 | if _logger: |
| 324 | _logger.warning('Login failed', username=username, reason='incorrect password') |
| 325 | return {'status': 'error', 'message': 'Invalid username or password'} |
| 326 | |
| 327 | # Create session token |
| 328 | token = _create_token(username) |
| 329 | |
| 330 | if _logger: |
| 331 | _logger.info('User logged in', username=username) |
| 332 | |
| 333 | return { |
| 334 | 'status': 'ok', |
| 335 | 'message': 'Login successful', |
| 336 | 'token': token, |
| 337 | 'username': username, |
| 338 | 'is_admin': user.get('is_admin', False), |
| 339 | } |
| 340 | |
| 341 | |
| 342 | def _hash_password(password: str) -> str: |
| 343 | """Hash password with SHA-256 (simple, not bcrypt for now).""" |
| 344 | # In production, use bcrypt or argon2 |
| 345 | # For demo, using SHA-256 with salt |
| 346 | salt = 'object_primitive_salt' # In production, use per-user random salt |
| 347 | return hashlib.sha256(f'{salt}{password}'.encode()).hexdigest() |
| 348 | |
| 349 | |
| 350 | def _verify_password(password: str, password_hash: str) -> bool: |
| 351 | """Verify password matches hash.""" |
| 352 | return _hash_password(password) == password_hash |
| 353 | |
| 354 | |
| 355 | def _create_token(username: str) -> str: |
| 356 | """Create session token for user.""" |
| 357 | token = secrets.token_urlsafe(32) |
| 358 | |
| 359 | # Store token |
| 360 | tokens = _get_tokens() |
| 361 | tokens[token] = { |
| 362 | 'username': username, |
| 363 | 'created_at': int(time.time()), |
| 364 | 'expires_at': int(time.time()) + 86400, # 24 hours |
| 365 | } |
| 366 | _save_tokens(tokens) |
| 367 | |
| 368 | return token |
| 369 | |
| 370 | |
| 371 | def _validate_token(token: str) -> Optional[Dict[str, Any]]: |
| 372 | """Validate token and return user info.""" |
| 373 | tokens = _get_tokens() |
| 374 | |
| 375 | if token not in tokens: |
| 376 | return None |
| 377 | |
| 378 | token_data = tokens[token] |
| 379 | |
| 380 | # Check expiration |
| 381 | if token_data['expires_at'] < int(time.time()): |
| 382 | # Token expired, clean up |
| 383 | del tokens[token] |
| 384 | _save_tokens(tokens) |
| 385 | return None |
| 386 | |
| 387 | # Get user info |
| 388 | username = token_data['username'] |
| 389 | users = _get_users() |
| 390 | |
| 391 | if username not in users: |
| 392 | return None |
| 393 | |
| 394 | user = users[username] |
| 395 | return { |
| 396 | 'username': username, |
| 397 | 'email': user.get('email', ''), |
| 398 | 'is_admin': user.get('is_admin', False), |
| 399 | } |
| 400 | |
| 401 | |
| 402 | def _invalidate_token(token: str): |
| 403 | """Invalidate a specific token.""" |
| 404 | tokens = _get_tokens() |
| 405 | if token in tokens: |
| 406 | del tokens[token] |
| 407 | _save_tokens(tokens) |
| 408 | |
| 409 | |
| 410 | def _invalidate_user_tokens(username: str): |
| 411 | """Invalidate all tokens for a user.""" |
| 412 | tokens = _get_tokens() |
| 413 | to_delete = [t for t, data in tokens.items() if data['username'] == username] |
| 414 | for token in to_delete: |
| 415 | del tokens[token] |
| 416 | _save_tokens(tokens) |
| 417 | |
| 418 | |
| 419 | def _get_users() -> Dict[str, Any]: |
| 420 | """Get all users from state.""" |
| 421 | if _state_manager: |
| 422 | users_json = _state_manager.get('users', '{}') |
| 423 | return json.loads(users_json) |
| 424 | return {} |
| 425 | |
| 426 | |
| 427 | def _save_users(users: Dict[str, Any]): |
| 428 | """Save users to state.""" |
| 429 | if _state_manager: |
| 430 | _state_manager.set('users', json.dumps(users)) |
| 431 | |
| 432 | |
| 433 | def _get_tokens() -> Dict[str, Any]: |
| 434 | """Get all tokens from state.""" |
| 435 | if _state_manager: |
| 436 | tokens_json = _state_manager.get('tokens', '{}') |
| 437 | return json.loads(tokens_json) |
| 438 | return {} |
| 439 | |
| 440 | |
| 441 | def _save_tokens(tokens: Dict[str, Any]): |
| 442 | """Save tokens to state.""" |
| 443 | if _state_manager: |
| 444 | _state_manager.set('tokens', json.dumps(tokens)) |
| 445 | |
| 446 | |
| 447 | # Metadata for object introspection |
| 448 | __endpoint__ = { |
| 449 | 'name': 'Auth System', |
| 450 | 'description': 'Complete authentication system in Object Primitive style', |
| 451 | 'version': '1.0.0', |
| 452 | 'author': 'Object Primitive System', |
| 453 | 'methods': ['GET', 'POST', 'PUT', 'DELETE'], |
| 454 | 'state_keys': ['users', 'tokens'], |
| 455 | } |