Buckets:

download
raw
14.8 kB
"""
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.