File size: 3,230 Bytes
a54fd97 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 | """
Token management for authentication
"""
import jwt
import base64
import hashlib
from datetime import datetime, timedelta
from typing import Optional, Tuple
from cryptography.fernet import Fernet
from .models import User, TokenPayload
class TokenManager:
"""Manages JWT tokens and API key encryption"""
def __init__(
self,
secret_key: str,
encryption_key: str,
algorithm: str = "HS256",
expiration_days: int = 30,
):
self.secret_key = secret_key
self.algorithm = algorithm
self.expiration_days = expiration_days
# Create Fernet cipher for API key encryption
# Derive a valid Fernet key from the encryption key
key = hashlib.sha256(encryption_key.encode()).digest()
self.fernet = Fernet(base64.urlsafe_b64encode(key))
def encrypt_api_key(self, api_key: str) -> str:
"""Encrypt an API key for storage"""
return self.fernet.encrypt(api_key.encode()).decode()
def decrypt_api_key(self, encrypted_key: str) -> str:
"""Decrypt a stored API key"""
return self.fernet.decrypt(encrypted_key.encode()).decode()
def generate_token(self, user: User) -> str:
"""Generate a JWT token for a user"""
expiration = datetime.utcnow() + timedelta(days=self.expiration_days)
payload = TokenPayload(
user_id=user.user_id,
table_name=user.table_name,
created_at=user.created_at.isoformat(),
exp=int(expiration.timestamp()),
)
return jwt.encode(
payload.to_dict(),
self.secret_key,
algorithm=self.algorithm,
)
def verify_token(self, token: str) -> Tuple[bool, Optional[TokenPayload], Optional[str]]:
"""
Verify a JWT token
Returns:
Tuple of (is_valid, payload, error_message)
"""
try:
decoded = jwt.decode(
token,
self.secret_key,
algorithms=[self.algorithm],
)
payload = TokenPayload.from_dict(decoded)
return True, payload, None
except jwt.ExpiredSignatureError:
return False, None, "Token has expired"
except jwt.InvalidTokenError as e:
return False, None, f"Invalid token: {str(e)}"
def refresh_token(self, token: str) -> Tuple[Optional[str], Optional[str]]:
"""
Refresh a valid token with new expiration
Returns:
Tuple of (new_token, error_message)
"""
is_valid, payload, error = self.verify_token(token)
if not is_valid:
return None, error
# Create new token with same user info but new expiration
expiration = datetime.utcnow() + timedelta(days=self.expiration_days)
new_payload = TokenPayload(
user_id=payload.user_id,
table_name=payload.table_name,
created_at=payload.created_at,
exp=int(expiration.timestamp()),
)
new_token = jwt.encode(
new_payload.to_dict(),
self.secret_key,
algorithm=self.algorithm,
)
return new_token, None
|