mirror of
https://github.com/lintsinghua/DeepAudit.git
synced 2026-11-22 05:07:12 +08:00
309 lines
8.2 KiB
Python
309 lines
8.2 KiB
Python
"""Authentication API Endpoints
|
|
Handles user registration, login, token refresh, and password reset.
|
|
"""
|
|
from fastapi import APIRouter, Depends, HTTPException, status
|
|
from fastapi.security import OAuth2PasswordRequestForm
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
from sqlalchemy import select
|
|
from datetime import timedelta
|
|
|
|
from db.session import get_db
|
|
from models.user import User, UserRole
|
|
from schemas.auth import (
|
|
UserRegister,
|
|
UserResponse,
|
|
Token,
|
|
TokenRefresh,
|
|
PasswordResetRequest,
|
|
PasswordReset
|
|
)
|
|
from core.security import (
|
|
get_password_hash,
|
|
verify_password,
|
|
create_access_token,
|
|
create_refresh_token,
|
|
verify_token
|
|
)
|
|
from app.config import settings
|
|
from api.dependencies import get_current_user
|
|
|
|
router = APIRouter()
|
|
|
|
|
|
@router.post(
|
|
"/register",
|
|
response_model=UserResponse,
|
|
status_code=status.HTTP_201_CREATED,
|
|
summary="Register new user",
|
|
description="Create a new user account"
|
|
)
|
|
async def register(
|
|
user_data: UserRegister,
|
|
db: AsyncSession = Depends(get_db)
|
|
):
|
|
"""
|
|
Register a new user.
|
|
|
|
- **email**: Valid email address
|
|
- **username**: Unique username
|
|
- **password**: Strong password (min 8 chars, uppercase, lowercase, number, special char)
|
|
- **full_name**: User's full name (optional)
|
|
"""
|
|
# Check if email already exists
|
|
result = await db.execute(
|
|
select(User).where(User.email == user_data.email)
|
|
)
|
|
if result.scalar_one_or_none():
|
|
raise HTTPException(
|
|
status_code=status.HTTP_400_BAD_REQUEST,
|
|
detail="Email already registered"
|
|
)
|
|
|
|
# Check if username already exists
|
|
result = await db.execute(
|
|
select(User).where(User.username == user_data.username)
|
|
)
|
|
if result.scalar_one_or_none():
|
|
raise HTTPException(
|
|
status_code=status.HTTP_400_BAD_REQUEST,
|
|
detail="Username already taken"
|
|
)
|
|
|
|
# Create new user
|
|
user = User(
|
|
email=user_data.email,
|
|
username=user_data.username,
|
|
full_name=user_data.full_name,
|
|
password_hash=get_password_hash(user_data.password),
|
|
role=UserRole.USER,
|
|
is_active=True
|
|
)
|
|
|
|
db.add(user)
|
|
await db.commit()
|
|
await db.refresh(user)
|
|
|
|
return user
|
|
|
|
|
|
@router.post(
|
|
"/login",
|
|
response_model=Token,
|
|
summary="Login",
|
|
description="Authenticate user and return access token"
|
|
)
|
|
async def login(
|
|
form_data: OAuth2PasswordRequestForm = Depends(),
|
|
db: AsyncSession = Depends(get_db)
|
|
):
|
|
"""
|
|
Login with username/email and password.
|
|
|
|
Returns access token and refresh token.
|
|
"""
|
|
# Find user by username or email
|
|
result = await db.execute(
|
|
select(User).where(
|
|
(User.username == form_data.username) |
|
|
(User.email == form_data.username)
|
|
)
|
|
)
|
|
user = result.scalar_one_or_none()
|
|
|
|
# Verify user exists and password is correct
|
|
if not user or not verify_password(form_data.password, user.password_hash):
|
|
raise HTTPException(
|
|
status_code=status.HTTP_401_UNAUTHORIZED,
|
|
detail="Incorrect username or password",
|
|
headers={"WWW-Authenticate": "Bearer"},
|
|
)
|
|
|
|
# Check if user is active
|
|
if not user.is_active:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_403_FORBIDDEN,
|
|
detail="User account is disabled"
|
|
)
|
|
|
|
# Create tokens
|
|
access_token = create_access_token({"sub": str(user.id)})
|
|
refresh_token = create_refresh_token({"sub": str(user.id)})
|
|
|
|
return {
|
|
"access_token": access_token,
|
|
"refresh_token": refresh_token,
|
|
"token_type": "bearer"
|
|
}
|
|
|
|
|
|
@router.post(
|
|
"/refresh",
|
|
response_model=Token,
|
|
summary="Refresh token",
|
|
description="Get new access token using refresh token"
|
|
)
|
|
async def refresh_token(
|
|
token_data: TokenRefresh,
|
|
db: AsyncSession = Depends(get_db)
|
|
):
|
|
"""
|
|
Refresh access token using refresh token.
|
|
"""
|
|
# Verify refresh token
|
|
payload = verify_token(token_data.refresh_token)
|
|
if not payload:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_401_UNAUTHORIZED,
|
|
detail="Invalid refresh token"
|
|
)
|
|
|
|
user_id = payload.get("sub")
|
|
if not user_id:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_401_UNAUTHORIZED,
|
|
detail="Invalid token payload"
|
|
)
|
|
|
|
# Verify user still exists and is active
|
|
result = await db.execute(
|
|
select(User).where(User.id == user_id)
|
|
)
|
|
user = result.scalar_one_or_none()
|
|
|
|
if not user or not user.is_active:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_401_UNAUTHORIZED,
|
|
detail="User not found or inactive"
|
|
)
|
|
|
|
# Create new tokens
|
|
access_token = create_access_token({"sub": str(user.id)})
|
|
new_refresh_token = create_refresh_token({"sub": str(user.id)})
|
|
|
|
return {
|
|
"access_token": access_token,
|
|
"refresh_token": new_refresh_token,
|
|
"token_type": "bearer"
|
|
}
|
|
|
|
|
|
@router.post(
|
|
"/logout",
|
|
status_code=status.HTTP_204_NO_CONTENT,
|
|
summary="Logout",
|
|
description="Logout user (client should discard tokens)"
|
|
)
|
|
async def logout():
|
|
"""
|
|
Logout user.
|
|
|
|
Note: Since we're using stateless JWT tokens, the client
|
|
should simply discard the tokens. For enhanced security,
|
|
implement token blacklisting with Redis.
|
|
"""
|
|
# TODO: Implement token blacklisting with Redis
|
|
# For now, client-side token removal is sufficient
|
|
return None
|
|
|
|
|
|
@router.post(
|
|
"/password-reset/request",
|
|
status_code=status.HTTP_200_OK,
|
|
summary="Request password reset",
|
|
description="Send password reset email"
|
|
)
|
|
async def request_password_reset(
|
|
request_data: PasswordResetRequest,
|
|
db: AsyncSession = Depends(get_db)
|
|
):
|
|
"""
|
|
Request password reset email.
|
|
|
|
Always returns success to prevent email enumeration.
|
|
"""
|
|
# Find user by email
|
|
result = await db.execute(
|
|
select(User).where(User.email == request_data.email)
|
|
)
|
|
user = result.scalar_one_or_none()
|
|
|
|
if user and user.is_active:
|
|
# Generate reset token
|
|
reset_token = create_access_token(
|
|
{"sub": str(user.id), "type": "password_reset"},
|
|
expires_delta=timedelta(hours=1)
|
|
)
|
|
|
|
# TODO: Send email with reset link
|
|
# For now, just log it (in production, use email service)
|
|
from loguru import logger
|
|
logger.info(f"Password reset token for {user.email}: {reset_token}")
|
|
|
|
# In production, send email:
|
|
# await send_password_reset_email(user.email, reset_token)
|
|
|
|
# Always return success to prevent email enumeration
|
|
return {
|
|
"message": "If the email exists, a password reset link has been sent"
|
|
}
|
|
|
|
|
|
@router.post(
|
|
"/password-reset/confirm",
|
|
status_code=status.HTTP_200_OK,
|
|
summary="Reset password",
|
|
description="Reset password with token"
|
|
)
|
|
async def reset_password(
|
|
reset_data: PasswordReset,
|
|
db: AsyncSession = Depends(get_db)
|
|
):
|
|
"""
|
|
Reset password using reset token.
|
|
"""
|
|
# Verify reset token
|
|
payload = verify_token(reset_data.token)
|
|
if not payload or payload.get("type") != "password_reset":
|
|
raise HTTPException(
|
|
status_code=status.HTTP_400_BAD_REQUEST,
|
|
detail="Invalid or expired reset token"
|
|
)
|
|
|
|
user_id = payload.get("sub")
|
|
|
|
# Get user
|
|
result = await db.execute(
|
|
select(User).where(User.id == user_id)
|
|
)
|
|
user = result.scalar_one_or_none()
|
|
|
|
if not user:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_404_NOT_FOUND,
|
|
detail="User not found"
|
|
)
|
|
|
|
# Update password
|
|
user.password_hash = get_password_hash(reset_data.new_password)
|
|
await db.commit()
|
|
|
|
return {"message": "Password reset successful"}
|
|
|
|
|
|
@router.get(
|
|
"/me",
|
|
response_model=UserResponse,
|
|
summary="Get current user",
|
|
description="Get current authenticated user information"
|
|
)
|
|
async def get_current_user_info(
|
|
current_user: User = Depends(get_current_user)
|
|
):
|
|
"""
|
|
Get current user information.
|
|
|
|
Requires authentication via Bearer token.
|
|
Returns the authenticated user's profile information.
|
|
"""
|
|
return current_user
|