Natuurlijk! Hier is een overzicht en een basisvoorbeeld van hoe je een Python-script kunt maken dat RBAC implementeert: 1. Structuur van de rolbeheerstructuur: - Definieer een set rollen, bijvoorbeeld als klassen of eenvoudige data-structuren. - Koppel permissies aan elke rol, bijvoorbeeld in een dictionary. - Beheer gebruikers en hun toegewezen rollen. 2. Gebruikersauthenticatie: - Voor eenvoud kun je gebruikers en wachtwoorden opslaan in een gegevensstructuur. - Authenticatie controleert gebruikersnaam en wachtwoord. 3. Toegangscontrole: - Controleer of de gebruiker de juiste rol(en) heeft voor een bepaalde actie. - Dwing de controle af bij elke bewerking die beveiligd moet worden. Hier is een basisvoorbeeld in Python: ```python # Definieer rollen en permissies rollen_permissies = { 'admin': {'lees', 'schrijf', 'verwijder'}, 'editor': {'lees', 'schrijf'}, 'viewer': {'lees'} } # Gebruikers met bijbehorende wachtwoorden en rollen gebruikers = { 'alice': {'wachtwoord': 'pass123', 'rollen': ['admin']}, 'bob': {'wachtwoord': 'pass456', 'rollen': ['editor']}, 'carol': {'wachtwoord': 'pass789', 'rollen': ['viewer']} } # Functie voor authenticatie def authenticate(gebruikersnaam, wachtwoord): gebruiker = gebruikers.get(gebruikersnaam) if gebruiker and gebruiker['wachtwoord'] == wachtwoord: return gebruiker else: return None # Functie om permissies te controleren def heeft_toegang(gebruiker, permissie): for rol in gebruiker['rollen']: if permissie in rollen_permissies.get(rol, set()): return True return False # Voorbeeldgebruik def main(): gebruikersnaam = input('Gebruikersnaam: ') wachtwoord = input('Wachtwoord: ') gebruiker = authenticate(gebruikersnaam, wachtwoord) if gebruiker: print(f'Welkom, {gebruikersnaam}!') # Voorbeeldactie: toegang tot een bewerking if heeft_toegang(gebruiker, 'schrijf'): print('Je hebt toestemming om te schrijven.') else: print('Toegang geweigerd voor schrijven.') else: print('Ongeldige gebruikersnaam of wachtwoord.') if __name__ == '__main__': main() ``` **Samenvatting:** - Definieer rollen en hun permissies. - Beheer gebruikers met hun wachtwoorden en toegewezen rollen. - Implementeer authenticatie om gebruikers te verifiëren. - Controleer of een gebruiker de benodigde permissie heeft voordat je een actie toestaat. Voor een productie-omgeving wordt het aanbevolen om: - Wachtwoorden te hashen (bijvoorbeeld met bcrypt). - Een database te gebruiken voor gebruikers en rollen. - Een meer geavanceerd toegangscontrolemechanisme te implementeren. Wil je dat ik dit script uitbreid of aanpas voor jouw specifieke situatie?

Hier is een gestructureerde aanpak voor RBAC-implementatie in Python: ## 1. Basisklassenstructuur ```python class Permission: def __init__(self, name, description=""): self.name = name self.description = description class Role: def __init__(self, name, description=""): self.name = name self.description = description self.permissions = set() def add_permission(self, permission): self.permissions.add(permission) def has_permission(self, permission_name): return any(p.name == permission_name for p in self.permissions) class User: def __init__(self, username, password_hash=None): self.username = username self.password_hash = password_hash self.roles = set() def add_role(self, role): self.roles.add(role) def has_permission(self, permission_name): for role in self.roles: if role.has_permission(permission_name): return True return False ``` ## 2. RBAC Manager Klasse ```python import hashlib import json from typing import Dict, Set class RBACManager: def __init__(self): self.users: Dict[str, User] = {} self.roles: Dict[str, Role] = {} self.permissions: Dict[str, Permission] = {} def create_permission(self, name, description=""): permission = Permission(name, description) self.permissions[name] = permission return permission def create_role(self, name, description=""): role = Role(name, description) self.roles[name] = role return role def create_user(self, username, password): password_hash = self._hash_password(password) user = User(username, password_hash) self.users[username] = user return user def assign_role_to_user(self, username, role_name): if username in self.users and role_name in self.roles: self.users[username].add_role(self.roles[role_name]) def assign_permission_to_role(self, role_name, permission_name): if role_name in self.roles and permission_name in self.permissions: self.roles[role_name].add_permission(self.permissions[permission_name]) def authenticate_user(self, username, password): if username in self.users: user = self.users[username] return user.password_hash == self._hash_password(password) return False def check_permission(self, username, permission_name): if username in self.users: return self.users[username].has_permission(permission_name) return False def _hash_password(self, password): return hashlib.sha256(password.encode()).hexdigest() ``` ## 3. Gebruiksvoorbeeld ```python # Initialisatie rbac = RBACManager() # Permissies aanmaken rbac.create_permission("read_data", "Toestemming om data te lezen") rbac.create_permission("write_data", "Toestemming om data te schrijven") rbac.create_permission("delete_data", "Toestemming om data te verwijderen") rbac.create_permission("manage_users", "Toestemming om gebruikers te beheren") # Rollen definiëren admin_role = rbac.create_role("admin", "Beheerder met volledige toegang") editor_role = rbac.create_role("editor", "Redacteur met schrijftoegang") viewer_role = rbac.create_role("viewer", "Lezer met alleen-lezen toegang") # Permissies toewijzen aan rollen rbac.assign_permission_to_role("admin", "read_data") rbac.assign_permission_to_role("admin", "write_data") rbac.assign_permission_to_role("admin", "delete_data") rbac.assign_permission_to_role("admin", "manage_users") rbac.assign_permission_to_role("editor", "read_data") rbac.assign_permission_to_role("editor", "write_data") rbac.assign_permission_to_role("viewer", "read_data") # Gebruikers aanmaken rbac.create_user("alice", "wachtwoord123") rbac.create_user("bob", "veiligwachtwoord") rbac.create_user("charlie", "mijngeheim") # Rollen toewijzen aan gebruikers rbac.assign_role_to_user("alice", "admin") rbac.assign_role_to_user("bob", "editor") rbac.assign_role_to_user("charlie", "viewer") # Toegang controleren print(rbac.check_permission("alice", "delete_data")) # True print(rbac.check_permission("bob", "delete_data")) # False print(rbac.check_permission("charlie", "read_data")) # True ``` ## 4. Decorator voor toegangscontrole ```python from functools import wraps def require_permission(permission_name): def decorator(func): @wraps(func) def wrapper(self, *args, **kwargs): if not self.rbac.check_permission(self.current_user, permission_name): raise PermissionError(f"Toegang geweigerd. Vereiste permissie: {permission_name}") return func(self, *args, **kwargs) return wrapper return decorator # Gebruik in je applicatie class DataService: def __init__(self, rbac_manager, current_user): self.rbac = rbac_manager self.current_user = current_user @require_permission("read_data") def get_data(self): return "Geheime data" @require_permission("write_data") def update_data(self, new_data): return f"Data bijgewerkt: {new_data}" ``` ## 5. Persistentie (Opslaan/Laden) ```python import pickle class PersistentRBACManager(RBACManager): def save_to_file(self, filename): with open(filename, 'wb') as f: pickle.dump({ 'users': self.users, 'roles': self.roles, 'permissions': self.permissions }, f) def load_from_file(self, filename): with open(filename, 'rb') as f: data = pickle.load(f) self.users = data['users'] self.roles = data['roles'] self.permissions = data['permissions'] ``` ## Belangrijke overwegingen: 1. **Beveiliging**: Gebruik altijd gehashte wachtwoorden (overweeg bcrypt) 2. **Sessiebeheer**: Implementeer sessies voor ingelogde gebruikers 3. **Logging**: Log toegangspogingen voor auditing 4. **Caching**: Cache gebruikerspermissies voor betere prestaties 5. **Middleware**: Voor web-apps, gebruik middleware voor toegangscontrole Deze structuur biedt een solide basis voor RBAC in je Python-applicatie met duidelijke scheiding van verantwoordelijkheden en flexibele uitbreidingsmogelijkheden.