Unix-style user accounts (passwd, groups, permissions) with a web-friendly Python API.

0 downloads

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

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

danq9 Add comprehensive FAQ section 369661c 1 year ago History
passwd.py · 14.1 KB · 492 lines
1"""
2User and authentication management mirroring Unix /etc/passwd, /etc/shadow, /etc/group
3"""
4
5import os
6from datetime import datetime
7from pathlib import Path
8from typing import Optional, List, Dict, Any
9from dataclasses import dataclass
10
11from argon2 import PasswordHasher
12from argon2.exceptions import VerifyMismatchError, VerificationError, InvalidHashError
13
14from .tsv_db import Database
15
16
17@dataclass
18class 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
29class 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