Buckets:
| """ | |
| JWT Authentication für Zen-AI-Pentest API | |
| Integration mit dem neuen Auth-System: | |
| - JWTHandler für Token-Verwaltung | |
| - PasswordHasher für Passwort-Hashing | |
| - SQLAlchemy Models für User-Datenbank | |
| SECURITY NOTES: | |
| - All secrets are loaded from environment variables | |
| - Never commit actual secrets to version control | |
| - Use .env file locally, proper secret management in production | |
| """ | |
| import os | |
| import warnings | |
| from datetime import datetime, timedelta, timezone | |
| from typing import Dict, Optional | |
| ACCESS_TOKEN_EXPIRE_MINUTES = int(os.getenv("ACCESS_TOKEN_EXPIRE_MINUTES", "30")) | |
| ALGORITHM = os.getenv("JWT_ALGORITHM", "HS256") | |
| SECRET_KEY = os.getenv("JWT_SECRET_KEY", "your-secret-key-change-in-production") | |
| if not SECRET_KEY or SECRET_KEY == "your-secret-key-change-in-production": | |
| warnings.warn( | |
| "JWT_SECRET_KEY not set or using default value. Set JWT_SECRET_KEY environment variable in production.", | |
| RuntimeWarning, | |
| stacklevel=2, | |
| ) | |
| import jwt | |
| from fastapi import Depends, HTTPException, status | |
| from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer | |
| # Import new auth system components | |
| try: | |
| from auth import JWTHandler, PasswordHasher, TokenExpiredError, TokenInvalidError | |
| from database.auth_models import UserRole # noqa: F401 | |
| from database.auth_models import create_audit_log # noqa: F401 | |
| from database.auth_models import get_auth_db # noqa: F401 | |
| from database.auth_models import get_user_by_username # noqa: F401 | |
| NEW_AUTH_AVAILABLE = True | |
| except ImportError: | |
| NEW_AUTH_AVAILABLE = False | |
| # ============================================================================= | |
| # Configuration | |
| # ============================================================================= | |
| security = HTTPBearer() | |
| # Initialize auth components | |
| _jwt_handler: Optional[JWTHandler] = None | |
| _password_hasher: Optional[PasswordHasher] = None | |
| def get_jwt_handler() -> JWTHandler: | |
| """Get or create JWT handler instance""" | |
| global _jwt_handler | |
| if _jwt_handler is None: | |
| _jwt_handler = JWTHandler() | |
| return _jwt_handler | |
| def get_password_hasher() -> PasswordHasher: | |
| """Get or create password hasher instance""" | |
| global _password_hasher | |
| if _password_hasher is None: | |
| _password_hasher = PasswordHasher() | |
| return _password_hasher | |
| # ============================================================================= | |
| # Password Functions | |
| # ============================================================================= | |
| def _prehash_password(password: str) -> bytes: | |
| """Pre-hash long passwords to fit bcrypt's 72-byte limit. | |
| Note: SHA256 here is only used for length management, not security. | |
| The result is still hashed with bcrypt which provides strong security. | |
| """ | |
| encoded = password.encode("utf-8") | |
| if len(encoded) > 72: | |
| import hashlib | |
| return hashlib.sha256(encoded).digest() # nosec B303 - pre-hash only, not final hash | |
| return encoded | |
| def verify_password(plain_password: str, hashed_password: str) -> bool: | |
| """Verifiziert Passwort mit bcrypt""" | |
| if NEW_AUTH_AVAILABLE: | |
| return get_password_hasher().verify(plain_password, hashed_password) | |
| import bcrypt | |
| return bcrypt.checkpw(_prehash_password(plain_password), hashed_password.encode("utf-8")) | |
| def get_password_hash(password: str) -> str: | |
| """Hashed Passwort mit bcrypt""" | |
| if NEW_AUTH_AVAILABLE: | |
| return get_password_hasher().hash(password) | |
| import bcrypt | |
| return bcrypt.hashpw(_prehash_password(password), bcrypt.gensalt()).decode("utf-8") | |
| # ============================================================================= | |
| # JWT Token Functions | |
| # ============================================================================= | |
| def create_access_token(*args, **kwargs) -> str: | |
| """ | |
| Erstellt JWT Access Token. | |
| Supports both legacy api.auth.create_access_token(data: dict) | |
| and new api.auth.create_access_token(user_id, username, role, ...) | |
| """ | |
| # Legacy support: create_access_token(data: dict) or create_access_token(data={...}) | |
| if len(args) == 1 and isinstance(args[0], dict): | |
| data = args[0] | |
| elif kwargs.get("data") and isinstance(kwargs["data"], dict): | |
| data = kwargs["data"] | |
| else: | |
| data = None | |
| if data is not None: | |
| to_encode = data.copy() | |
| expires_delta = kwargs.get("expires_delta") | |
| if expires_delta: | |
| expire = datetime.now(timezone.utc) + expires_delta | |
| else: | |
| expire = datetime.now(timezone.utc) + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES) | |
| to_encode.setdefault("exp", expire) | |
| to_encode.setdefault("sub", to_encode.get("sub", "user")) | |
| return jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM) | |
| # New signature support | |
| user_id = kwargs.get("user_id") or (args[0] if len(args) > 0 else None) | |
| username = kwargs.get("username") or (args[1] if len(args) > 1 else None) | |
| role = kwargs.get("role") or (args[2] if len(args) > 2 else None) | |
| expires_delta = kwargs.get("expires_delta") | |
| if not user_id or not username or not role: | |
| raise ValueError("user_id, username, and role are required") | |
| handler = get_jwt_handler() | |
| from auth.config import get_config | |
| config = get_config().jwt | |
| if expires_delta is None: | |
| expires_delta = timedelta(minutes=config.access_token_expire_minutes) | |
| roles = [role] | |
| permissions = _get_permissions_for_role(role) | |
| return handler.create_access_token( | |
| user_id=user_id, | |
| roles=roles, | |
| permissions=permissions, | |
| ) | |
| def create_token_pair( | |
| user_id: str, | |
| username: str, | |
| role: str, | |
| ) -> Dict: | |
| """ | |
| Erstellt Access und Refresh Token Pair | |
| Returns: | |
| Dict mit access_token, refresh_token, token_type, expires_in | |
| """ | |
| handler = get_jwt_handler() | |
| roles = [role] | |
| permissions = _get_permissions_for_role(role) | |
| return handler.create_token_pair( | |
| user_id=user_id, | |
| roles=roles, | |
| permissions=permissions, | |
| ) | |
| def _get_permissions_for_role(role: str) -> list: | |
| """Get permissions list for a role""" | |
| permissions_map = { | |
| "super_admin": ["*"], | |
| "admin": [ | |
| "users:*", | |
| "scans:*", | |
| "findings:*", | |
| "reports:*", | |
| "system:*", | |
| "tools:*", | |
| ], | |
| "security_analyst": [ | |
| "scans:*", | |
| "findings:*", | |
| "reports:read", | |
| "reports:create", | |
| "tools:*", | |
| ], | |
| "user": [ | |
| "scans:create", | |
| "scans:read", | |
| "findings:read", | |
| "reports:read", | |
| "tools:limited", | |
| ], | |
| "viewer": [ | |
| "scans:read", | |
| "findings:read", | |
| "reports:read", | |
| ], | |
| } | |
| return permissions_map.get(role, []) | |
| def decode_token(token: str) -> Optional[Dict]: | |
| """Decodiert und validiert JWT Token""" | |
| try: | |
| # Try legacy PyJWT decode first (used by tests) | |
| payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM]) | |
| payload.setdefault("role", payload.get("role", "viewer")) | |
| return payload | |
| except jwt.ExpiredSignatureError: | |
| return None | |
| except jwt.InvalidTokenError: | |
| pass | |
| # Fallback to new auth handler | |
| if not NEW_AUTH_AVAILABLE: | |
| return None | |
| handler = get_jwt_handler() | |
| try: | |
| payload = handler.decode_token(token) | |
| return { | |
| "sub": payload.sub, | |
| "user_id": payload.sub, | |
| "username": payload.sub, | |
| "role": payload.roles[0] if payload.roles else "viewer", | |
| "roles": payload.roles, | |
| "permissions": payload.permissions, | |
| "exp": payload.exp.timestamp(), | |
| "jti": payload.jti, | |
| } | |
| except (TokenExpiredError, TokenInvalidError): | |
| return None | |
| # ============================================================================= | |
| # FastAPI Dependencies | |
| # ============================================================================= | |
| async def verify_token( | |
| credentials: HTTPAuthorizationCredentials = Depends(security), | |
| ) -> Dict: | |
| """ | |
| FastAPI Dependency für Token-Verifizierung | |
| """ | |
| token = credentials.credentials | |
| payload = decode_token(token) | |
| if payload is None: | |
| raise HTTPException( | |
| status_code=status.HTTP_401_UNAUTHORIZED, | |
| detail="Invalid or expired token", | |
| headers={"WWW-Authenticate": "Bearer"}, | |
| ) | |
| return payload | |
| async def get_current_user( | |
| credentials: HTTPAuthorizationCredentials = Depends(security), | |
| ) -> Dict: | |
| """ | |
| Alternative zu verify_token - gibt aktuellen User zurück | |
| Usage: | |
| @app.get("/me") | |
| async def get_me(user: Dict = Depends(get_current_user)): | |
| return user | |
| """ | |
| return await verify_token(credentials) | |
| def check_permissions(user: Dict, required_role: str) -> bool: | |
| """Prüft ob User die benötigte Rolle hat""" | |
| user_roles = user.get("roles", []) | |
| if not user_roles and user.get("role"): | |
| user_roles = [user["role"]] | |
| # Role hierarchy - supports both old and new role names | |
| hierarchy = { | |
| "viewer": 1, | |
| "user": 2, | |
| "operator": 3, | |
| "security_analyst": 3, | |
| "admin": 4, | |
| "super_admin": 5, | |
| } | |
| user_level = max(hierarchy.get(r, 0) for r in user_roles) if user_roles else hierarchy.get("viewer", 1) | |
| required_level = hierarchy.get(required_role, 0) | |
| return user_level >= required_level | |
| async def require_admin( | |
| credentials: HTTPAuthorizationCredentials = Depends(security), | |
| ) -> Dict: | |
| """Erfordert Admin-Rolle""" | |
| user = await verify_token(credentials) | |
| if not check_permissions(user, "admin"): | |
| raise HTTPException( | |
| status_code=status.HTTP_403_FORBIDDEN, | |
| detail="Admin privileges required", | |
| ) | |
| return user | |
| async def require_operator( | |
| credentials: HTTPAuthorizationCredentials = Depends(security), | |
| ) -> Dict: | |
| """Erfordert Security Analyst oder höhere Rolle""" | |
| user = await verify_token(credentials) | |
| if not check_permissions(user, "security_analyst"): | |
| raise HTTPException( | |
| status_code=status.HTTP_403_FORBIDDEN, | |
| detail="Security analyst privileges required", | |
| ) | |
| return user | |
| # ============================================================================= | |
| # Authentication Service | |
| # ============================================================================= | |
| class AuthService: | |
| """Authentication service for login/logout operations""" | |
| def __init__(self): | |
| self.jwt_handler = get_jwt_handler() | |
| self.password_hasher = get_password_hasher() | |
| def authenticate_user( | |
| self, | |
| db, | |
| username: str, | |
| password: str, | |
| ) -> Optional[Dict]: | |
| """ | |
| Authenticate user with username and password | |
| Returns: | |
| User dict if authentication successful, None otherwise | |
| """ | |
| from database.auth_models import User | |
| user = db.query(User).filter(User.username == username).first() | |
| if not user: | |
| return None | |
| if not user.is_active: | |
| return None | |
| if not self.password_hasher.verify(password, user.hashed_password): | |
| return None | |
| return { | |
| "id": user.id, | |
| "username": user.username, | |
| "email": user.email, | |
| "role": user.role.value if hasattr(user.role, "value") else user.role, | |
| "is_active": user.is_active, | |
| } | |
| def create_user( | |
| self, | |
| db, | |
| username: str, | |
| email: str, | |
| password: str, | |
| role: str = "user", | |
| ) -> Dict: | |
| """Create new user""" | |
| from database.auth_models import User, UserRole | |
| # Check if user exists | |
| existing = db.query(User).filter((User.username == username) | (User.email == email)).first() | |
| if existing: | |
| raise ValueError("Username or email already exists") | |
| # Validate password strength | |
| is_valid, error = self.password_hasher.validate_strength(password) | |
| if not is_valid: | |
| raise ValueError(f"Password too weak: {error}") | |
| # Hash password | |
| hashed_password = self.password_hasher.hash(password) | |
| # Create user | |
| try: | |
| user_role = UserRole(role) if isinstance(role, str) else role | |
| except ValueError: | |
| user_role = UserRole.USER | |
| user = User( | |
| username=username, | |
| email=email, | |
| hashed_password=hashed_password, | |
| role=user_role, | |
| is_active=True, | |
| is_verified=True, | |
| ) | |
| db.add(user) | |
| db.commit() | |
| db.refresh(user) | |
| return { | |
| "id": user.id, | |
| "username": user.username, | |
| "email": user.email, | |
| "role": user.role.value if hasattr(user.role, "value") else str(user.role), | |
| "is_active": user.is_active, | |
| "created_at": user.created_at.isoformat() if user.created_at else None, | |
| } | |
| def get_auth_service() -> AuthService: | |
| """Get auth service instance""" | |
| return AuthService() | |
| # ============================================================================= | |
| # Legacy Compatibility | |
| # ============================================================================= | |
| API_KEYS: dict = {} # Legacy compatibility for tests | |
| _api_key_counter = 0 | |
| def create_api_key(user_id: int, name: str) -> str: | |
| """Legacy API key creation for backward compatibility.""" | |
| global _api_key_counter | |
| _api_key_counter += 1 | |
| key = f"zen_{user_id}_{name}_{_api_key_counter}_{os.urandom(8).hex()}" | |
| API_KEYS[key] = {"user_id": user_id, "name": name, "created_at": datetime.now(timezone.utc).isoformat()} | |
| return key | |
| def revoke_api_key(api_key: str) -> bool: | |
| """Legacy API key revocation for backward compatibility.""" | |
| if api_key in API_KEYS: | |
| del API_KEYS[api_key] | |
| return True | |
| return False | |
| def verify_api_key(api_key: str): | |
| """Legacy API key verification for backward compatibility.""" | |
| return API_KEYS.get(api_key) | |
| # Backward-compatible module-level wrappers | |
| def authenticate_user(db, username: str, password: str): | |
| """Legacy wrapper for AuthService.authenticate_user""" | |
| return get_auth_service().authenticate_user(db, username, password) | |
| def create_user(db, username: str, email: str, password: str, role: str = "user"): | |
| """Legacy wrapper for AuthService.create_user""" | |
| return get_auth_service().create_user(db, username, email, password, role) | |
| # Export pwd_context for backward compatibility with tests | |
| from api.core.auth import pwd_context | |
Xet Storage Details
- Size:
- 14.8 kB
- Xet hash:
- aea2b2fb172540bba7458a7175239a7dc637e1a5d67bd449a39a9e2f5b284cde
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.