first commit

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
kunkunxiaomaoandClaude committed 2026-11-16 20:45:22 +08:00
commit 9c5fef1a4d
412 files changed
+94582

No files matched your search

+301
View File
@@ -0,0 +1,301 @@
from __future__ import annotations
import tempfile
from pathlib import Path
from unittest import TestCase
from fastapi import APIRouter, FastAPI
from fastapi.testclient import TestClient
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from sakura_cloud.api.deps import AdminUser
from sakura_cloud.api.v1.router import api_router
from sakura_cloud.core.config import settings
from sakura_cloud.core.safety import is_allowed_external_url
from sakura_cloud.core.security import create_access_token
from sakura_cloud.db.base import Base
from sakura_cloud.db.session import get_db
from sakura_cloud.models import Artwork, CreatorFollow, FileBlob, Novel, User, UserFile
from sakura_cloud.models.user import UserRole
class SakuraCloudSecurityTest(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_storage_root = settings.storage_root
self.old_max_upload_size_mb = settings.max_upload_size_mb
settings.storage_root = str(self.root / "storage")
settings.max_upload_size_mb = 1
admin_router = APIRouter()
@admin_router.get("/admin/probe")
def admin_probe(_: AdminUser) -> dict[str, bool]:
return {"ok": True}
self.app = FastAPI()
self.app.include_router(api_router, prefix=settings.api_prefix)
self.app.include_router(admin_router, prefix=settings.api_prefix)
self.app.dependency_overrides[get_db] = self._override_db
self.client = TestClient(self.app)
self.user_a_id = "user-a"
self.user_b_id = "user-b"
self.admin_id = "admin"
self._seed_data()
self.auth_a = {"Authorization": f"Bearer {create_access_token(self.user_a_id)}"}
self.auth_b = {"Authorization": f"Bearer {create_access_token(self.user_b_id)}"}
self.auth_admin = {"Authorization": f"Bearer {create_access_token(self.admin_id)}"}
def tearDown(self) -> None:
self.client.close()
self.engine.dispose()
settings.storage_root = self.old_storage_root
settings.max_upload_size_mb = self.old_max_upload_size_mb
self.temp_dir.cleanup()
def _override_db(self):
db = self.SessionLocal()
try:
yield db
finally:
db.close()
def _seed_data(self) -> None:
storage_file = self.root / "b-file.txt"
storage_file.write_text("secret", encoding="utf-8")
with self.SessionLocal() as db:
user_a = User(
id=self.user_a_id,
username="alice",
email="alice@example.test",
password_hash="unused",
role=UserRole.USER,
)
user_b = User(
id=self.user_b_id,
username="bob",
email="bob@example.test",
password_hash="unused",
role=UserRole.USER,
)
admin = User(
id=self.admin_id,
username="admin",
email="admin@example.test",
password_hash="unused",
role=UserRole.ADMIN,
)
blob = FileBlob(
sha256="b" * 64,
storage_path=str(storage_file),
file_size=storage_file.stat().st_size,
mime_type="text/plain",
)
user_file = UserFile(id="file-b", user_id=self.user_b_id, file_sha256=blob.sha256, original_name="b-file.txt")
artwork = Artwork(
id="art-b",
user_id=self.user_b_id,
file_id=user_file.id,
source_platform="pixiv",
content_type="illust",
title="bob artwork",
file_path=str(storage_file),
file_size=storage_file.stat().st_size,
tags=[],
artwork_metadata={},
)
novel = Novel(
id="novel-b",
user_id=self.user_b_id,
file_id=user_file.id,
source_platform="pixiv",
title="bob novel",
file_path=str(storage_file),
file_size=storage_file.stat().st_size,
tags=[],
)
series_chapter = Novel(
id="novel-series-a",
user_id=self.user_a_id,
source_platform="biquge",
title="sakura series",
series_id="series-a",
series_title="Sakura Series",
chapter_title="Chapter One",
chapter_order=1,
file_path=str(storage_file),
file_size=storage_file.stat().st_size,
tags=[],
)
follow = CreatorFollow(
id="follow-b",
user_id=self.user_b_id,
platform="pixiv",
creator_id="creator-b",
creator_name="Bob Creator",
enabled=True,
metadata_json={},
)
db.add_all([user_a, user_b, admin, blob, user_file, artwork, novel, series_chapter, follow])
db.commit()
def test_protected_resource_groups_return_401_without_login(self) -> None:
cases = [
("GET", "/api/v1/gallery"),
("GET", "/api/v1/gallery/feed"),
("GET", "/api/v1/gallery/stat"),
("POST", "/api/v1/gallery"),
("GET", "/api/v1/novels"),
("GET", "/api/v1/novels/recent"),
("GET", "/api/v1/files/file-b/content"),
("POST", "/api/v1/upload/init"),
("GET", "/api/v1/upload/status/unknown"),
("GET", "/api/v1/follows"),
("POST", "/api/v1/follows"),
("POST", "/api/v1/follows/bulk-upsert"),
("GET", "/api/v1/follows/alerts"),
("GET", "/api/v1/push/devices"),
("POST", "/api/v1/push/register-token"),
("POST", "/api/v1/push/unregister-token"),
]
for method, path in cases:
with self.subTest(method=method, path=path):
response = self.client.request(method, path, json={})
self.assertEqual(response.status_code, 401)
def test_user_a_cannot_access_user_b_gallery_novel_file_or_follow_data(self) -> None:
gallery = self.client.get("/api/v1/gallery", headers=self.auth_a)
self.assertEqual(gallery.status_code, 200)
self.assertEqual(gallery.json()["data"]["items"], [])
self.assertEqual(self.client.get("/api/v1/gallery/art-b", headers=self.auth_a).status_code, 404)
novels = self.client.get("/api/v1/novels", headers=self.auth_a)
self.assertEqual(novels.status_code, 200)
self.assertNotIn("novel-b", {item["id"] for item in novels.json()["data"]["items"]})
self.assertEqual(self.client.get("/api/v1/novels/novel-b", headers=self.auth_a).status_code, 404)
self.assertEqual(self.client.get("/api/v1/novels/novel-b/content", headers=self.auth_a).status_code, 404)
self.assertEqual(self.client.get("/api/v1/files/file-b/content", headers=self.auth_a).status_code, 404)
self.assertEqual(self.client.get("/api/v1/files/file-b/thumbnail", headers=self.auth_a).status_code, 404)
follows = self.client.get("/api/v1/follows", headers=self.auth_a)
self.assertEqual(follows.status_code, 200)
self.assertEqual(follows.json()["data"], [])
self.assertEqual(self.client.delete("/api/v1/follows/follow-b", headers=self.auth_a).status_code, 404)
self.assertEqual(self.client.get("/api/v1/gallery/art-b", headers=self.auth_b).status_code, 200)
self.assertEqual(self.client.get("/api/v1/novels/novel-b", headers=self.auth_b).status_code, 200)
self.assertEqual(self.client.get("/api/v1/files/file-b/content", headers=self.auth_b).status_code, 200)
def test_follow_bulk_upsert_uses_current_user_and_deduplicates(self) -> None:
payload = {
"items": [
{
"platform": "pixiv",
"creator_id": "origin-1",
"creator_name": "Origin One",
"creator_handle": "origin_one",
"profile_url": "https://www.pixiv.net/users/origin-1",
"metadata": {"user_id": "user-b"},
},
{
"platform": "pixiv",
"creator_id": "origin-1",
"creator_name": "Origin One Duplicate",
},
{
"platform": "x",
"creator_id": "sakura",
"creator_handle": "sakura",
"profile_url": "https://x.com/sakura",
},
]
}
response = self.client.post("/api/v1/follows/bulk-upsert", headers=self.auth_a, json=payload)
self.assertEqual(response.status_code, 200)
data = response.json()["data"]
self.assertEqual(data["created"], 2)
self.assertEqual(data["updated"], 0)
self.assertEqual(data["skipped"], 1)
follows_a = self.client.get("/api/v1/follows", headers=self.auth_a).json()["data"]
follows_b = self.client.get("/api/v1/follows", headers=self.auth_b).json()["data"]
self.assertEqual({item["creator_id"] for item in follows_a}, {"origin-1", "sakura"})
self.assertEqual({item["creator_id"] for item in follows_b}, {"creator-b"})
def test_novel_series_summary_defers_chapter_loading(self) -> None:
summary = self.client.get("/api/v1/novels/series?include_chapters=false", headers=self.auth_a)
self.assertEqual(summary.status_code, 200)
item = summary.json()["data"][0]
self.assertEqual(item["series_id"], "series-a")
self.assertEqual(item["chapter_count"], 1)
self.assertEqual(item["chapters"], [])
detail = self.client.get("/api/v1/novels/series/series-a", headers=self.auth_a)
self.assertEqual(detail.status_code, 200)
self.assertEqual(len(detail.json()["data"]["chapters"]), 1)
self.assertEqual(self.client.get("/api/v1/novels/series/series-a", headers=self.auth_b).status_code, 404)
def test_batch_delete_novels_by_series_id(self) -> None:
response = self.client.post(
"/api/v1/novels/batch-delete",
headers=self.auth_a,
json={"ids": [], "series_ids": ["series-a"]},
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()["data"]["deleted"], 1)
self.assertEqual(self.client.get("/api/v1/novels/series/series-a", headers=self.auth_a).status_code, 404)
def test_upload_init_rejects_large_path_traversal_and_disallowed_mime(self) -> None:
base_payload = {
"sha256": "a" * 64,
"file_name": "safe.png",
"file_size": 10,
"mime_type": "image/png",
"resource_type": "image",
}
too_large = {**base_payload, "file_size": 2 * 1024 * 1024}
traversal = {**base_payload, "file_name": "../secret.png"}
windows_traversal = {**base_payload, "file_name": r"..\\secret.png"}
bad_mime = {**base_payload, "mime_type": "application/x-msdownload"}
self.assertEqual(self.client.post("/api/v1/upload/init", headers=self.auth_a, json=too_large).status_code, 413)
self.assertEqual(self.client.post("/api/v1/upload/init", headers=self.auth_a, json=traversal).status_code, 400)
self.assertEqual(self.client.post("/api/v1/upload/init", headers=self.auth_a, json=windows_traversal).status_code, 400)
self.assertEqual(self.client.post("/api/v1/upload/init", headers=self.auth_a, json=bad_mime).status_code, 415)
ok = self.client.post("/api/v1/upload/init", headers=self.auth_a, json=base_payload)
self.assertEqual(ok.status_code, 200)
self.assertFalse(ok.json()["data"]["exists"])
def test_external_url_collection_allows_only_whitelisted_public_domains(self) -> None:
self.assertTrue(is_allowed_external_url("https://www.pixiv.net/artworks/123"))
self.assertTrue(is_allowed_external_url("https://i.pximg.net/img-original/example.jpg"))
blocked = [
"http://127.0.0.1:8000/internal",
"http://localhost/admin",
"http://10.0.0.5/private",
"http://172.16.0.1/private",
"http://192.168.1.1/private",
"http://169.254.169.254/latest/meta-data",
"file:///etc/passwd",
"https://evil.example.test/image.jpg",
]
for url in blocked:
with self.subTest(url=url):
self.assertFalse(is_allowed_external_url(url))
def test_admin_dependency_requires_admin_role(self) -> None:
self.assertEqual(self.client.get("/api/v1/admin/probe").status_code, 401)
self.assertEqual(self.client.get("/api/v1/admin/probe", headers=self.auth_a).status_code, 403)
self.assertEqual(self.client.get("/api/v1/admin/probe", headers=self.auth_admin).status_code, 200)