askrobots / dbbasic-accounts
Public
Unix-style user accounts (passwd, groups, permissions) with a web-friendly Python API.
passwd.py · 14.1 KB · 492 lines
| 1 | """ |
| 2 | User and authentication management mirroring Unix /etc/passwd, /etc/shadow, /etc/group |
| 3 | """ |
| 4 | |
| 5 | import os |
| 6 | from datetime import datetime |
| 7 | from pathlib import Path |
| 8 | from typing import Optional, List, Dict, Any |
| 9 | from dataclasses import dataclass |
| 10 | |
| 11 | from argon2 import PasswordHasher |
| 12 | from argon2.exceptions import VerifyMismatchError, VerificationError, InvalidHashError |
| 13 | |
| 14 | from .tsv_db import Database |
| 15 | |
| 16 | |
| 17 | @dataclass |
| 18 | class User: |
| 19 | """User object mirroring Unix user structure""" |
| 20 | username: str |
| 21 | uid: int |
| 22 | gid: int |
| 23 | fullname: str |
| 24 | homedir: str |
| 25 | shell: str |
| 26 | created: str |
| 27 | |
| 28 | |
| 29 | class PasswdDB: |
| 30 | """ |
| 31 | Unix-style user and authentication management using TSV files. |
| 32 | |
| 33 | Mirrors: |
| 34 | - /etc/passwd → passwd.tsv |
| 35 | - /etc/shadow → shadow.tsv |
| 36 | - /etc/group → group.tsv |
| 37 | """ |
| 38 | |
| 39 | def __init__(self, etc_dir: str = "./etc"): |
| 40 | """ |
| 41 | Initialize PasswdDB with directory for passwd/shadow/group files. |
| 42 | |
| 43 | Args: |
| 44 | etc_dir: Directory to store passwd.tsv, shadow.tsv, group.tsv (like /etc) |
| 45 | """ |
| 46 | self.etc_dir = Path(etc_dir) |
| 47 | self.etc_dir.mkdir(parents=True, exist_ok=True) |
| 48 | |
| 49 | self.passwd_path = self.etc_dir / "passwd.tsv" |
| 50 | self.shadow_path = self.etc_dir / "shadow.tsv" |
| 51 | self.group_path = self.etc_dir / "group.tsv" |
| 52 | |
| 53 | # Initialize databases |
| 54 | self._init_passwd() |
| 55 | self._init_shadow() |
| 56 | self._init_group() |
| 57 | |
| 58 | # Password hasher (Argon2id) |
| 59 | self.ph = PasswordHasher() |
| 60 | |
| 61 | def _init_passwd(self): |
| 62 | """Initialize passwd.tsv (like /etc/passwd)""" |
| 63 | if not self.passwd_path.exists(): |
| 64 | self.passwd_path.write_text("username\tuid\tgid\tfullname\thomedir\tshell\tcreated\n") |
| 65 | self.passwd_db = Database(str(self.passwd_path)) |
| 66 | |
| 67 | def _init_shadow(self): |
| 68 | """Initialize shadow.tsv (like /etc/shadow) - restricted permissions""" |
| 69 | if not self.shadow_path.exists(): |
| 70 | self.shadow_path.write_text("username\tpassword_hash\tlast_changed\tmin_age\tmax_age\twarn_age\tinactive\n") |
| 71 | # Set restricted permissions (like /etc/shadow) |
| 72 | try: |
| 73 | os.chmod(self.shadow_path, 0o600) |
| 74 | except: |
| 75 | pass # May fail on Windows |
| 76 | self.shadow_db = Database(str(self.shadow_path)) |
| 77 | |
| 78 | def _init_group(self): |
| 79 | """Initialize group.tsv (like /etc/group)""" |
| 80 | if not self.group_path.exists(): |
| 81 | # Create default 'users' group |
| 82 | self.group_path.write_text("groupname\tgid\tmembers\nusers\t100\t\n") |
| 83 | self.group_db = Database(str(self.group_path)) |
| 84 | |
| 85 | def _next_uid(self) -> int: |
| 86 | """Get next available UID (starting at 1000 like Linux)""" |
| 87 | users = self.passwd_db.select() |
| 88 | if not users: |
| 89 | return 1000 |
| 90 | return max(int(u['uid']) for u in users) + 1 |
| 91 | |
| 92 | def _next_gid(self) -> int: |
| 93 | """Get next available GID (starting at 100)""" |
| 94 | groups = self.group_db.select() |
| 95 | if not groups: |
| 96 | return 100 |
| 97 | return max(int(g['gid']) for g in groups) + 1 |
| 98 | |
| 99 | def useradd( |
| 100 | self, |
| 101 | username: str, |
| 102 | password: str, |
| 103 | fullname: str = "", |
| 104 | homedir: Optional[str] = None, |
| 105 | shell: str = "/bin/bash", |
| 106 | gid: Optional[int] = None, |
| 107 | groups: Optional[List[str]] = None |
| 108 | ) -> User: |
| 109 | """ |
| 110 | Add a new user (like Unix useradd). |
| 111 | |
| 112 | Args: |
| 113 | username: Username (unique) |
| 114 | password: Plain text password (will be hashed) |
| 115 | fullname: Full name (like GECOS field) |
| 116 | homedir: Home directory (defaults to /home/{username}) |
| 117 | shell: Login shell (defaults to /bin/bash) |
| 118 | gid: Primary group ID (defaults to 'users' group) |
| 119 | groups: Additional groups to add user to |
| 120 | |
| 121 | Returns: |
| 122 | User object |
| 123 | |
| 124 | Raises: |
| 125 | ValueError: If username already exists |
| 126 | """ |
| 127 | # Check if user exists |
| 128 | existing = self.passwd_db.select(where={'username': username}) |
| 129 | if existing: |
| 130 | raise ValueError(f"User '{username}' already exists") |
| 131 | |
| 132 | # Get next UID |
| 133 | uid = self._next_uid() |
| 134 | |
| 135 | # Get or create primary group |
| 136 | if gid is None: |
| 137 | users_group = self.group_db.select(where={'groupname': 'users'}) |
| 138 | if users_group: |
| 139 | gid = int(users_group[0]['gid']) |
| 140 | else: |
| 141 | gid = 100 |
| 142 | self.group_db.insert({'groupname': 'users', 'gid': str(gid), 'members': ''}) |
| 143 | |
| 144 | # Set homedir |
| 145 | if homedir is None: |
| 146 | homedir = f"/home/{username}" |
| 147 | |
| 148 | # Current timestamp |
| 149 | now = datetime.now().isoformat() |
| 150 | |
| 151 | # Add to passwd |
| 152 | self.passwd_db.insert({ |
| 153 | 'username': username, |
| 154 | 'uid': str(uid), |
| 155 | 'gid': str(gid), |
| 156 | 'fullname': fullname, |
| 157 | 'homedir': homedir, |
| 158 | 'shell': shell, |
| 159 | 'created': now |
| 160 | }) |
| 161 | |
| 162 | # Hash password and add to shadow |
| 163 | password_hash = self.ph.hash(password) |
| 164 | self.shadow_db.insert({ |
| 165 | 'username': username, |
| 166 | 'password_hash': password_hash, |
| 167 | 'last_changed': now, |
| 168 | 'min_age': '0', |
| 169 | 'max_age': '90', |
| 170 | 'warn_age': '7', |
| 171 | 'inactive': '14' |
| 172 | }) |
| 173 | |
| 174 | # Add to additional groups |
| 175 | if groups: |
| 176 | for group in groups: |
| 177 | self.usermod(username, add_groups=[group]) |
| 178 | |
| 179 | return User( |
| 180 | username=username, |
| 181 | uid=uid, |
| 182 | gid=gid, |
| 183 | fullname=fullname, |
| 184 | homedir=homedir, |
| 185 | shell=shell, |
| 186 | created=now |
| 187 | ) |
| 188 | |
| 189 | def getuser(self, username: str) -> Optional[User]: |
| 190 | """ |
| 191 | Get user by username. |
| 192 | |
| 193 | Args: |
| 194 | username: Username to look up |
| 195 | |
| 196 | Returns: |
| 197 | User object or None if not found |
| 198 | """ |
| 199 | users = self.passwd_db.select(where={'username': username}) |
| 200 | if not users: |
| 201 | return None |
| 202 | |
| 203 | u = users[0] |
| 204 | return User( |
| 205 | username=u['username'], |
| 206 | uid=int(u['uid']), |
| 207 | gid=int(u['gid']), |
| 208 | fullname=u['fullname'], |
| 209 | homedir=u['homedir'], |
| 210 | shell=u['shell'], |
| 211 | created=u['created'] |
| 212 | ) |
| 213 | |
| 214 | def authenticate(self, username: str, password: str) -> Optional[User]: |
| 215 | """ |
| 216 | Authenticate user with password. |
| 217 | |
| 218 | Args: |
| 219 | username: Username |
| 220 | password: Plain text password |
| 221 | |
| 222 | Returns: |
| 223 | User object if authentication succeeds, None otherwise |
| 224 | """ |
| 225 | # Get user |
| 226 | user = self.getuser(username) |
| 227 | if not user: |
| 228 | return None |
| 229 | |
| 230 | # Get password hash from shadow |
| 231 | shadow_entry = self.shadow_db.select(where={'username': username}) |
| 232 | if not shadow_entry: |
| 233 | return None |
| 234 | |
| 235 | password_hash = shadow_entry[0]['password_hash'] |
| 236 | |
| 237 | # Verify password |
| 238 | try: |
| 239 | self.ph.verify(password_hash, password) |
| 240 | |
| 241 | # Check if rehash needed (Argon2 params changed) |
| 242 | if self.ph.check_needs_rehash(password_hash): |
| 243 | self.passwd_user(username, password) |
| 244 | |
| 245 | return user |
| 246 | except (VerifyMismatchError, VerificationError, InvalidHashError): |
| 247 | return None |
| 248 | |
| 249 | def passwd(self, username: str, new_password: str) -> bool: |
| 250 | """ |
| 251 | Change user password (like Unix passwd). |
| 252 | |
| 253 | Args: |
| 254 | username: Username |
| 255 | new_password: New plain text password |
| 256 | |
| 257 | Returns: |
| 258 | True if password changed, False if user not found |
| 259 | """ |
| 260 | return self.passwd_user(username, new_password) |
| 261 | |
| 262 | def passwd_user(self, username: str, new_password: str) -> bool: |
| 263 | """ |
| 264 | Change user password (alias for passwd). |
| 265 | |
| 266 | Args: |
| 267 | username: Username |
| 268 | new_password: New plain text password |
| 269 | |
| 270 | Returns: |
| 271 | True if password changed, False if user not found |
| 272 | """ |
| 273 | # Check user exists |
| 274 | if not self.getuser(username): |
| 275 | return False |
| 276 | |
| 277 | # Hash new password |
| 278 | password_hash = self.ph.hash(new_password) |
| 279 | now = datetime.now().isoformat() |
| 280 | |
| 281 | # Update shadow entry |
| 282 | self.shadow_db.update( |
| 283 | where={'username': username}, |
| 284 | values={'password_hash': password_hash, 'last_changed': now} |
| 285 | ) |
| 286 | |
| 287 | return True |
| 288 | |
| 289 | def usermod( |
| 290 | self, |
| 291 | username: str, |
| 292 | fullname: Optional[str] = None, |
| 293 | homedir: Optional[str] = None, |
| 294 | shell: Optional[str] = None, |
| 295 | add_groups: Optional[List[str]] = None, |
| 296 | remove_groups: Optional[List[str]] = None |
| 297 | ) -> bool: |
| 298 | """ |
| 299 | Modify user (like Unix usermod). |
| 300 | |
| 301 | Args: |
| 302 | username: Username to modify |
| 303 | fullname: New full name |
| 304 | homedir: New home directory |
| 305 | shell: New shell |
| 306 | add_groups: Groups to add user to |
| 307 | remove_groups: Groups to remove user from |
| 308 | |
| 309 | Returns: |
| 310 | True if user modified, False if user not found |
| 311 | """ |
| 312 | # Check user exists |
| 313 | if not self.getuser(username): |
| 314 | return False |
| 315 | |
| 316 | # Update passwd fields |
| 317 | updates = {} |
| 318 | if fullname is not None: |
| 319 | updates['fullname'] = fullname |
| 320 | if homedir is not None: |
| 321 | updates['homedir'] = homedir |
| 322 | if shell is not None: |
| 323 | updates['shell'] = shell |
| 324 | |
| 325 | if updates: |
| 326 | self.passwd_db.update(where={'username': username}, values=updates) |
| 327 | |
| 328 | # Update group memberships |
| 329 | if add_groups: |
| 330 | for groupname in add_groups: |
| 331 | self._add_user_to_group(username, groupname) |
| 332 | |
| 333 | if remove_groups: |
| 334 | for groupname in remove_groups: |
| 335 | self._remove_user_from_group(username, groupname) |
| 336 | |
| 337 | return True |
| 338 | |
| 339 | def userdel(self, username: str) -> bool: |
| 340 | """ |
| 341 | Delete user (like Unix userdel). |
| 342 | |
| 343 | Args: |
| 344 | username: Username to delete |
| 345 | |
| 346 | Returns: |
| 347 | True if user deleted, False if user not found |
| 348 | """ |
| 349 | # Check user exists |
| 350 | if not self.getuser(username): |
| 351 | return False |
| 352 | |
| 353 | # Remove from passwd |
| 354 | self.passwd_db.delete(where={'username': username}) |
| 355 | |
| 356 | # Remove from shadow |
| 357 | self.shadow_db.delete(where={'username': username}) |
| 358 | |
| 359 | # Remove from all groups |
| 360 | all_groups = self.group_db.select() |
| 361 | for group in all_groups: |
| 362 | self._remove_user_from_group(username, group['groupname']) |
| 363 | |
| 364 | return True |
| 365 | |
| 366 | def groups(self, username: str) -> List[str]: |
| 367 | """ |
| 368 | Get groups for user (like Unix groups command). |
| 369 | |
| 370 | Args: |
| 371 | username: Username |
| 372 | |
| 373 | Returns: |
| 374 | List of group names |
| 375 | """ |
| 376 | user = self.getuser(username) |
| 377 | if not user: |
| 378 | return [] |
| 379 | |
| 380 | group_list = [] |
| 381 | all_groups = self.group_db.select() |
| 382 | |
| 383 | for group in all_groups: |
| 384 | # Check if user's primary group |
| 385 | if int(group['gid']) == user.gid: |
| 386 | group_list.append(group['groupname']) |
| 387 | # Check if user in members |
| 388 | elif username in group['members'].split(','): |
| 389 | group_list.append(group['groupname']) |
| 390 | |
| 391 | return group_list |
| 392 | |
| 393 | def groupadd(self, groupname: str, gid: Optional[int] = None) -> Dict[str, Any]: |
| 394 | """ |
| 395 | Add a new group (like Unix groupadd). |
| 396 | |
| 397 | Args: |
| 398 | groupname: Group name |
| 399 | gid: Group ID (auto-assigned if not provided) |
| 400 | |
| 401 | Returns: |
| 402 | Dict with groupname, gid, members |
| 403 | |
| 404 | Raises: |
| 405 | ValueError: If group already exists |
| 406 | """ |
| 407 | # Check if group exists |
| 408 | existing = self.group_db.select(where={'groupname': groupname}) |
| 409 | if existing: |
| 410 | raise ValueError(f"Group '{groupname}' already exists") |
| 411 | |
| 412 | # Get next GID if not provided |
| 413 | if gid is None: |
| 414 | gid = self._next_gid() |
| 415 | |
| 416 | # Add group |
| 417 | self.group_db.insert({ |
| 418 | 'groupname': groupname, |
| 419 | 'gid': str(gid), |
| 420 | 'members': '' |
| 421 | }) |
| 422 | |
| 423 | return {'groupname': groupname, 'gid': gid, 'members': []} |
| 424 | |
| 425 | def _add_user_to_group(self, username: str, groupname: str): |
| 426 | """Add user to group (internal helper)""" |
| 427 | # Get or create group |
| 428 | groups = self.group_db.select(where={'groupname': groupname}) |
| 429 | if not groups: |
| 430 | self.groupadd(groupname) |
| 431 | groups = self.group_db.select(where={'groupname': groupname}) |
| 432 | |
| 433 | group = groups[0] |
| 434 | members = [m for m in group['members'].split(',') if m] |
| 435 | |
| 436 | if username not in members: |
| 437 | members.append(username) |
| 438 | self.group_db.update( |
| 439 | where={'groupname': groupname}, |
| 440 | values={'members': ','.join(members)} |
| 441 | ) |
| 442 | |
| 443 | def _remove_user_from_group(self, username: str, groupname: str): |
| 444 | """Remove user from group (internal helper)""" |
| 445 | groups = self.group_db.select(where={'groupname': groupname}) |
| 446 | if not groups: |
| 447 | return |
| 448 | |
| 449 | group = groups[0] |
| 450 | members = [m for m in group['members'].split(',') if m and m != username] |
| 451 | |
| 452 | self.group_db.update( |
| 453 | where={'groupname': groupname}, |
| 454 | values={'members': ','.join(members)} |
| 455 | ) |
| 456 | |
| 457 | def list_users(self) -> List[User]: |
| 458 | """ |
| 459 | List all users. |
| 460 | |
| 461 | Returns: |
| 462 | List of User objects |
| 463 | """ |
| 464 | users = [] |
| 465 | for u in self.passwd_db.select(): |
| 466 | users.append(User( |
| 467 | username=u['username'], |
| 468 | uid=int(u['uid']), |
| 469 | gid=int(u['gid']), |
| 470 | fullname=u['fullname'], |
| 471 | homedir=u['homedir'], |
| 472 | shell=u['shell'], |
| 473 | created=u['created'] |
| 474 | )) |
| 475 | return users |
| 476 | |
| 477 | def list_groups(self) -> List[Dict[str, Any]]: |
| 478 | """ |
| 479 | List all groups. |
| 480 | |
| 481 | Returns: |
| 482 | List of dicts with groupname, gid, members |
| 483 | """ |
| 484 | groups = [] |
| 485 | for g in self.group_db.select(): |
| 486 | members = [m for m in g['members'].split(',') if m] |
| 487 | groups.append({ |
| 488 | 'groupname': g['groupname'], |
| 489 | 'gid': int(g['gid']), |
| 490 | 'members': members |
| 491 | }) |
| 492 | return groups |