Python functions as REST objects, with clustering, load balancing and state replication; no containers or orchestration.

0 downloads

Download zip
Clone
Clone with git
git clone https://gitstable.com/git/askrobots/dbbasic-object-primitive.git
HTTPS
https://gitstable.com/git/askrobots/dbbasic-object-primitive.git
SSH
ssh://git@gitstable.com:2222/askrobots/dbbasic-object-primitive.git

Cloning needs no sign-in. Pushing over HTTPS asks for your username and an access token. SSH needs your key under SSH keys.

Dan Q Consolidate duplicate QUICKSTARTs on the top-level file 503f830 7 months ago History
auth.py · 12.9 KB · 455 lines
1"""
2Auth System - Object Primitive Style
3
4A 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
11Endpoints:
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
17This demonstrates how to build auth WITHOUT using dbbasic-accounts
18(which uses traditional class-based architecture). Instead, we use
19Object Primitive patterns: _state_manager for persistence, _logger
20for audit trails, and REST methods for the interface.
21"""
22
23import hashlib
24import secrets
25import json
26import time
27from typing import Dict, Any, Optional
28
29# Object Primitive dependencies (injected by runtime)
30_logger = None
31_state_manager = None
32
33
34def 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
95def 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
128def 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
199def 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
265def _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
309def _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
342def _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
350def _verify_password(password: str, password_hash: str) -> bool:
351 """Verify password matches hash."""
352 return _hash_password(password) == password_hash
353
354
355def _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
371def _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
402def _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
410def _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
419def _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
427def _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
433def _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
441def _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}