226 lines
9.5 KiB
Python
226 lines
9.5 KiB
Python
from __future__ import annotations
|
|
|
|
import tempfile
|
|
from pathlib import Path
|
|
from unittest import TestCase
|
|
|
|
from fastapi.testclient import TestClient
|
|
from jose import jwt
|
|
from sqlalchemy import create_engine, select
|
|
from sqlalchemy.orm import sessionmaker
|
|
|
|
from sakura_cloud.core.config import settings
|
|
from sakura_cloud.core.security import create_access_token, create_refresh_token, hash_password
|
|
from sakura_cloud.db.base import Base
|
|
from sakura_cloud.db.session import get_db
|
|
from sakura_cloud.main import create_app
|
|
from sakura_cloud.models.admin import AdminAuditLog
|
|
from sakura_cloud.models.user import User, UserRole
|
|
from sakura_cloud.core.logging import logger
|
|
|
|
|
|
class AdminConsoleSecurityTest(TestCase):
|
|
def setUp(self) -> None:
|
|
self.temp_dir = tempfile.TemporaryDirectory()
|
|
self.root = Path(self.temp_dir.name)
|
|
self.db_path = self.root / "cloud.db"
|
|
self.engine = create_engine(f"sqlite:///{self.db_path}", connect_args={"check_same_thread": False})
|
|
self.SessionLocal = sessionmaker(bind=self.engine, autoflush=False, autocommit=False)
|
|
Base.metadata.create_all(self.engine)
|
|
|
|
self.old_cors = settings.cors_origins
|
|
self.old_log_dir = settings.log_dir
|
|
settings.cors_origins = ["http://admin.example.test"]
|
|
settings.log_dir = str(self.root / "logs")
|
|
Path(settings.log_dir).mkdir(parents=True, exist_ok=True)
|
|
|
|
self.app = create_app()
|
|
self.app.dependency_overrides[get_db] = self._override_db
|
|
self.client = TestClient(self.app)
|
|
|
|
self.user_id = "user"
|
|
self.admin_id = "admin"
|
|
self.super_id = "super"
|
|
with self.SessionLocal() as db:
|
|
db.add_all(
|
|
[
|
|
User(
|
|
id=self.user_id,
|
|
username="user",
|
|
email="user@example.test",
|
|
password_hash=hash_password("password123"),
|
|
role=UserRole.USER,
|
|
),
|
|
User(
|
|
id=self.admin_id,
|
|
username="admin",
|
|
email="admin@example.test",
|
|
password_hash=hash_password("password123"),
|
|
role=UserRole.ADMIN,
|
|
),
|
|
User(
|
|
id=self.super_id,
|
|
username="root",
|
|
email="root@example.test",
|
|
password_hash=hash_password("password123"),
|
|
role=UserRole.SUPER_ADMIN,
|
|
),
|
|
]
|
|
)
|
|
db.commit()
|
|
|
|
self.user_auth = {"Authorization": f"Bearer {create_access_token(self.user_id)}"}
|
|
self.admin_auth = {"Authorization": f"Bearer {create_access_token(self.admin_id)}"}
|
|
self.super_auth = {"Authorization": f"Bearer {create_access_token(self.super_id)}"}
|
|
|
|
def tearDown(self) -> None:
|
|
self.client.close()
|
|
self.engine.dispose()
|
|
logger.remove()
|
|
settings.cors_origins = self.old_cors
|
|
settings.log_dir = self.old_log_dir
|
|
try:
|
|
self.temp_dir.cleanup()
|
|
except PermissionError:
|
|
pass
|
|
|
|
def _override_db(self):
|
|
db = self.SessionLocal()
|
|
try:
|
|
yield db
|
|
finally:
|
|
db.close()
|
|
|
|
def test_admin_requires_login_and_role(self) -> None:
|
|
self.assertEqual(self.client.get("/api/v1/admin/dashboard").status_code, 401)
|
|
self.assertEqual(self.client.get("/api/v1/admin/dashboard", headers=self.user_auth).status_code, 403)
|
|
self.assertEqual(self.client.get("/api/v1/admin/dashboard", headers=self.admin_auth).status_code, 200)
|
|
|
|
def test_admin_cannot_disable_super_admin(self) -> None:
|
|
response = self.client.patch(
|
|
f"/api/v1/admin/users/{self.super_id}/status",
|
|
headers=self.admin_auth,
|
|
json={"is_active": False},
|
|
)
|
|
self.assertEqual(response.status_code, 403)
|
|
|
|
def test_invalid_query_params_return_422(self) -> None:
|
|
response = self.client.get("/api/v1/admin/users?sort=password_hash", headers=self.admin_auth)
|
|
self.assertEqual(response.status_code, 422)
|
|
|
|
def test_sensitive_fields_are_not_returned(self) -> None:
|
|
response = self.client.get("/api/v1/admin/users", headers=self.admin_auth)
|
|
self.assertEqual(response.status_code, 200)
|
|
text = response.text
|
|
self.assertNotIn("password_hash", text)
|
|
self.assertNotIn("password123", text)
|
|
self.assertIn("admin@example.test", text)
|
|
|
|
def test_audit_log_is_written_for_disable_user(self) -> None:
|
|
response = self.client.patch(
|
|
f"/api/v1/admin/users/{self.user_id}/status",
|
|
headers=self.admin_auth,
|
|
json={"is_active": False},
|
|
)
|
|
self.assertEqual(response.status_code, 200)
|
|
with self.SessionLocal() as db:
|
|
row = db.scalar(
|
|
select(AdminAuditLog).where(
|
|
AdminAuditLog.admin_user_id == self.admin_id,
|
|
AdminAuditLog.action == "disable_user",
|
|
AdminAuditLog.target_id == self.user_id,
|
|
)
|
|
)
|
|
self.assertIsNotNone(row)
|
|
self.assertEqual(row.detail_json["is_active"], False)
|
|
|
|
def test_admin_login_writes_audit_log(self) -> None:
|
|
response = self.client.post(
|
|
"/api/v1/admin/login",
|
|
json={"username_or_email": "admin", "password": "password123"},
|
|
)
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertIn("access_token", response.json()["data"])
|
|
with self.SessionLocal() as db:
|
|
row = db.scalar(select(AdminAuditLog).where(AdminAuditLog.action == "admin_login"))
|
|
self.assertIsNotNone(row)
|
|
|
|
def test_login_does_not_revoke_another_device_access_token(self) -> None:
|
|
response = self.client.post(
|
|
"/api/v1/auth/login",
|
|
json={"username_or_email": "user", "password": "password123"},
|
|
)
|
|
self.assertEqual(response.status_code, 200)
|
|
with self.SessionLocal() as db:
|
|
self.assertEqual(db.get(User, self.user_id).token_version, 0)
|
|
|
|
def test_refresh_does_not_revoke_other_device_tokens(self) -> None:
|
|
first_refresh_token = create_refresh_token(self.user_id)
|
|
second_refresh_token = create_refresh_token(self.user_id)
|
|
|
|
first_response = self.client.post(
|
|
"/api/v1/auth/refresh",
|
|
json={"refresh_token": first_refresh_token},
|
|
)
|
|
self.assertEqual(first_response.status_code, 200)
|
|
with self.SessionLocal() as db:
|
|
self.assertEqual(db.get(User, self.user_id).token_version, 0)
|
|
|
|
second_response = self.client.post(
|
|
"/api/v1/auth/refresh",
|
|
json={"refresh_token": second_refresh_token},
|
|
)
|
|
self.assertEqual(second_response.status_code, 200)
|
|
|
|
def test_security_headers_and_cors_are_present(self) -> None:
|
|
response = self.client.get(
|
|
"/api/v1/admin/dashboard",
|
|
headers={**self.admin_auth, "Origin": "http://admin.example.test"},
|
|
)
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertEqual(response.headers["X-Content-Type-Options"], "nosniff")
|
|
self.assertEqual(response.headers["X-Frame-Options"], "DENY")
|
|
self.assertIn("Referrer-Policy", response.headers)
|
|
self.assertIn("Content-Security-Policy", response.headers)
|
|
self.assertEqual(response.headers.get("Access-Control-Allow-Origin"), "http://admin.example.test")
|
|
self.assertEqual(response.headers["Referrer-Policy"], "no-referrer")
|
|
self.assertIn("Permissions-Policy", response.headers)
|
|
|
|
def test_disabled_user_access_and_refresh_are_rejected(self) -> None:
|
|
refresh_token = create_refresh_token(self.user_id)
|
|
with self.SessionLocal() as db:
|
|
user = db.get(User, self.user_id)
|
|
user.is_active = False
|
|
user.token_version += 1
|
|
db.commit()
|
|
|
|
response = self.client.get("/api/v1/me", headers=self.user_auth)
|
|
self.assertEqual(response.status_code, 401)
|
|
refresh_response = self.client.post("/api/v1/auth/refresh", json={"refresh_token": refresh_token})
|
|
self.assertEqual(refresh_response.status_code, 401)
|
|
|
|
def test_jwt_missing_exp_wrong_type_and_tampered_are_rejected(self) -> None:
|
|
no_exp = jwt.encode({"sub": self.user_id, "type": "access"}, settings.jwt_secret_key, algorithm=settings.jwt_algorithm)
|
|
wrong_type = jwt.encode({"sub": self.user_id, "type": "reset", "exp": 4102444800}, settings.jwt_secret_key, algorithm=settings.jwt_algorithm)
|
|
valid = create_access_token(self.user_id)
|
|
tampered = valid[:-1] + ("a" if valid[-1] != "a" else "b")
|
|
for token in (no_exp, wrong_type, tampered):
|
|
response = self.client.get("/api/v1/me", headers={"Authorization": f"Bearer {token}"})
|
|
self.assertEqual(response.status_code, 401)
|
|
|
|
def test_admin_role_changes_require_super_admin(self) -> None:
|
|
response = self.client.patch(
|
|
f"/api/v1/admin/users/{self.user_id}/role",
|
|
headers=self.admin_auth,
|
|
json={"role": "admin"},
|
|
)
|
|
self.assertEqual(response.status_code, 403)
|
|
|
|
response = self.client.patch(
|
|
f"/api/v1/admin/users/{self.user_id}/role",
|
|
headers=self.super_auth,
|
|
json={"role": "admin"},
|
|
)
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertEqual(response.json()["data"]["role"], "admin")
|