security: 修复管理员鉴权与配置导出泄露等严重漏洞

针对部署在 Hugging Face Spaces 上的 ds2api 进行安全审计并修复 5 个严重问题：

FIXED-1 (CRITICAL): effectiveAdminKey 不再硬编码返回 "admin"，
未配置凭据时返回空字符串禁用密码登录，避免任何知道源码的攻击者
直接登录未配置管理员密钥的部署。

FIXED-2 (CRITICAL): jwtSecret 在未配置时不再回退到 "admin"，
新增 fallbackJWTSecret() 使用 crypto/rand 生成进程级 32 字节
随机 secret，防止攻击者用历史默认值伪造 JWT 绕过 RequireAdmin。

FIXED-3 (HIGH): /admin/config/export 的 config 字段改用
Config.RedactSecrets() 清除所有 token/password/vercel token/
admin password_hash，避免 admin JWT 泄露链导致凭据全部泄露。
json/base64 字段保留密码（迁移必需）但清除 live token，
并新增 secrets_in_json 警告标志。

FIXED-4 (MEDIUM): 删除可疑的 _fix.py 和 _fix2.py，其中
_fix2.py 使用 chr() 字符编码混淆访问 "Dockerfile"，符合
安全审计中的可疑模式。

FIXED-5 (MEDIUM): devcapture 改为默认禁用，必须显式设置
DS2API_DEV_PACKET_CAPTURE=1 才启用。原逻辑在非 Vercel 环境
默认启用，会捕获每次请求的完整 prompt/response（最大 5MB）
并通过 /admin/dev/captures 暴露，存在内存与隐私风险。

新增 12 个回归测试覆盖所有修复点，包括默认密钥拒绝、JWT 伪造
拒绝、配置导出脱敏、迁移用途保留等攻击场景。详细审计报告与
待修复问题见 security_best_practices_report.md。

_fix.py

@@ -1,8 +0,0 @@
-import pathlib
-p = pathlib.Path("Dockerfile")
-t = p.read_text()
-old = 'CMD["/usr/local/bin/ds2api"]'
-new = 'COPY entrypoint.sh /usr/local/bin/entrypoint.sh\nRUN chmod +x /usr/local/bin/entrypoint.sh\nCMD["/usr/local/bin/entrypoint.sh"]'
-t = t.replace(old, new)
-p.write_text(t)
-print("Done")

_fix2.py

@@ -1,7 +0,0 @@
-import pathlib
-p=pathlib.Path(chr(68)+chr(111)+chr(99)+chr(107)+chr(101)+chr(114)+chr(102)+chr(105)+chr(108)+chr(101))
-t=p.read_text()
-old=CMD [/usr/local/bin/ds2api]
-new=CMD [/usr/local/bin/entrypoint.sh]
-print(repr(old))
-print(repr(new))

internal/auth/admin.go

@@ -2,9 +2,11 @@ package auth
 
 import (
 	"crypto/hmac"
+	"crypto/rand"
 	"crypto/sha256"
 	"crypto/subtle"
 	"encoding/base64"
+	"encoding/binary"
 	"encoding/hex"
 	"encoding/json"
 	"errors"
@@ -17,7 +19,17 @@ import (
 	"time"
 )
 
-var warnOnce sync.Once
+var (
+	warnOnce sync.Once
+
+	// fallbackSecretOnce lazily generates a process-local random secret used
+	// only when no explicit JWT secret AND no admin credentials are configured.
+	// Because admin login is also disabled in that state (see
+	// effectiveAdminKey), no real token can be minted with this secret; it
+	// exists solely so token signing never falls back to a hardcoded value.
+	fallbackSecretOnce sync.Once
+	fallbackSecret     []byte
+)
 
 type AdminConfigReader interface {
 	AdminPasswordHash() string
@@ -39,9 +51,33 @@ func effectiveAdminKey(store AdminConfigReader) string {
 		return v
 	}
 	warnOnce.Do(func() {
-		slog.Warn("⚠️  DS2API_ADMIN_KEY is not set! Using insecure default \"admin\". Set a strong key in production!")
+		slog.Warn("DS2API_ADMIN_KEY is not set and no admin password hash is configured. " +
+			"Admin login is DISABLED until you set DS2API_ADMIN_KEY or configure a password via the admin panel. " +
+			"Set a strong DS2API_ADMIN_KEY in your deployment secrets.")
 	})
-	return "admin"
+	// Security: do NOT fall back to an insecure hardcoded default like "admin".
+	// Returning empty disables admin password login until the operator
+	// configures credentials, which is the safe-by-default behavior.
+	return ""
+}
+
+// fallbackJWTSecret returns a process-local random secret used only when no
+// explicit JWT secret and no admin credentials are configured. Because admin
+// login is also disabled in that state (see effectiveAdminKey), no real token
+// can be minted with this secret; it exists solely so token signing uses a
+// non-predictable key rather than the historical hardcoded "admin" value.
+func fallbackJWTSecret() []byte {
+	fallbackSecretOnce.Do(func() {
+		buf := make([]byte, 32)
+		if _, err := rand.Read(buf); err != nil {
+			// Extremely unlikely; derive from time + pid as a last resort so
+			// we never return an empty secret.
+			binary.BigEndian.PutUint64(buf[0:8], uint64(time.Now().UnixNano()))
+			binary.BigEndian.PutUint64(buf[8:16], uint64(os.Getpid()))
+		}
+		fallbackSecret = buf
+	})
+	return fallbackSecret
 }
 
 func jwtSecret(store AdminConfigReader) string {
@@ -53,7 +89,12 @@ func jwtSecret(store AdminConfigReader) string {
 			return hash
 		}
 	}
-	return effectiveAdminKey(store)
+	if key := effectiveAdminKey(store); key != "" {
+		return key
+	}
+	// Security: never fall back to a hardcoded value. Use a process-local
+	// random secret so tokens cannot be forged even if minting were possible.
+	return string(fallbackJWTSecret())
 }
 
 func jwtExpireHours(store AdminConfigReader) int {

internal/auth/admin_security_test.go

@@ -0,0 +1,212 @@
+package auth
+
+import (
+	"crypto/hmac"
+	"crypto/sha256"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"strings"
+	"testing"
+
+	"ds2api/internal/config"
+)
+
+// stubStore implements AdminConfigReader for testing without pulling in the
+// full config store. We intentionally use a struct (not a mock) so the test
+// exercises the real auth code paths.
+type stubStore struct {
+	passwordHash string
+	expireHours  int
+	validAfter   int64
+}
+
+func (s stubStore) AdminPasswordHash() string     { return s.passwordHash }
+func (s stubStore) AdminJWTExpireHours() int      { return s.expireHours }
+func (s stubStore) AdminJWTValidAfterUnix() int64 { return s.validAfter }
+
+func TestEffectiveAdminKeyNeverReturnsHardcodedDefault(t *testing.T) {
+	// Security: ensure the historical "admin" default is gone. If this test
+	// ever fails, it means a regression reintroduced a publicly-known default
+	// credential that would let anyone log in to deployments without
+	// DS2API_ADMIN_KEY set.
+	t.Setenv("DS2API_ADMIN_KEY", "")
+	t.Setenv("DS2API_CONFIG_JSON", "")
+
+	stub := stubStore{}
+	if got := effectiveAdminKey(stub); got != "" {
+		t.Fatalf("effectiveAdminKey with no env and no password hash must be empty, got %q", got)
+	}
+	if got := AdminKey(); got != "" {
+		t.Fatalf("AdminKey() with no env must be empty, got %q", got)
+	}
+}
+
+func TestVerifyAdminCredentialRejectsEmptyAndDefaultAdmin(t *testing.T) {
+	// Security: with no admin key configured and no password hash, login
+	// MUST be impossible — even if an attacker tries "admin" or empty string.
+	t.Setenv("DS2API_ADMIN_KEY", "")
+	t.Setenv("DS2API_CONFIG_JSON", "")
+
+	stub := stubStore{}
+	for _, candidate := range []string{"", "admin", "password", "123456", "default"} {
+		if VerifyAdminCredential(candidate, stub) {
+			t.Fatalf("VerifyAdminCredential must reject %q when no credentials configured", candidate)
+		}
+	}
+}
+
+func TestVerifyAdminCredentialRejectsKnownDefaultAdminWithEnvSet(t *testing.T) {
+	// Security: when DS2API_ADMIN_KEY is set to a strong value, the literal
+	// "admin" must NOT authenticate.
+	t.Setenv("DS2API_ADMIN_KEY", "a-strong-and-random-key-12345")
+	t.Setenv("DS2API_CONFIG_JSON", "")
+
+	stub := stubStore{}
+	if VerifyAdminCredential("admin", stub) {
+		t.Fatal("VerifyAdminCredential must reject literal \"admin\" when env key is set to something else")
+	}
+	if !VerifyAdminCredential("a-strong-and-random-key-12345", stub) {
+		t.Fatal("VerifyAdminCredential must accept the configured env key")
+	}
+}
+
+func TestJWTSecretNotHardcodedAdminWhenUnconfigured(t *testing.T) {
+	// Security: when no DS2API_JWT_SECRET, no password hash, and no
+	// DS2API_ADMIN_KEY are configured, the JWT signing secret must NOT be
+	// the historical hardcoded "admin". A process-local random secret is
+	// used instead so attackers cannot forge tokens.
+	t.Setenv("DS2API_ADMIN_KEY", "")
+	t.Setenv("DS2API_JWT_SECRET", "")
+	t.Setenv("DS2API_CONFIG_JSON", "")
+
+	secret := jwtSecret(nil)
+	if secret == "admin" {
+		t.Fatal("jwtSecret must not fall back to hardcoded \"admin\"")
+	}
+	if secret == "" {
+		t.Fatal("jwtSecret must be non-empty so token signing is non-trivial")
+	}
+	// The fallback secret must be process-stable (same value across calls).
+	if secret != jwtSecret(nil) {
+		t.Fatal("jwtSecret fallback must be process-stable so minted tokens verify")
+	}
+}
+
+func TestJWTForgedWithAdminSecretFailsVerification(t *testing.T) {
+	// Security: an attacker who knows the historical default "admin" cannot
+	// forge a token that verifies when no credentials are configured, because
+	// the actual signing secret is a process-local random value.
+	t.Setenv("DS2API_ADMIN_KEY", "")
+	t.Setenv("DS2API_JWT_SECRET", "")
+
+	// Forge a token signed with the historical "admin" secret.
+	header := map[string]any{"alg": "HS256", "typ": "JWT"}
+	payload := map[string]any{
+		"iat":  0,
+		"exp":  9999999999,
+		"role": "admin",
+	}
+	h, _ := json.Marshal(header)
+	p, _ := json.Marshal(payload)
+	msg := rawB64Encode(h) + "." + rawB64Encode(p)
+
+	mac := hmac.New(sha256.New, []byte("admin"))
+	_, _ = mac.Write([]byte(msg))
+	forgedSig := mac.Sum(nil)
+	forged := msg + "." + rawB64Encode(forgedSig)
+
+	if _, err := VerifyJWT(forged); err == nil {
+		t.Fatal("forged token signed with hardcoded \"admin\" secret must NOT verify")
+	}
+}
+
+func TestAdminLoginDisabledWithoutCredentials(t *testing.T) {
+	// Security: end-to-end check that VerifyAdminRequestWithStore rejects
+	// Bearer tokens when no credentials are configured, regardless of what
+	// string the attacker supplies.
+	t.Setenv("DS2API_ADMIN_KEY", "")
+	t.Setenv("DS2API_CONFIG_JSON", "")
+
+	stub := stubStore{}
+	for _, token := range []string{"admin", "", "Bearer admin", "anything"} {
+		req := httptest.NewRequest(http.MethodGet, "/admin/config", nil)
+		req.Header.Set("Authorization", "Bearer "+token)
+		if err := VerifyAdminRequestWithStore(req, stub); err == nil {
+			t.Fatalf("VerifyAdminRequestWithStore must reject token %q when no credentials configured", token)
+		}
+	}
+}
+
+func TestAdminLoginWithConfiguredPasswordHash(t *testing.T) {
+	// Regression: ensure password-hash based login still works after the
+	// default-removal change.
+	t.Setenv("DS2API_ADMIN_KEY", "")
+	t.Setenv("DS2API_JWT_SECRET", "")
+
+	stub := stubStore{passwordHash: HashAdminPassword("super-secret-pw")}
+	if !VerifyAdminCredential("super-secret-pw", stub) {
+		t.Fatal("VerifyAdminCredential must accept the configured password")
+	}
+	if VerifyAdminCredential("wrong-password", stub) {
+		t.Fatal("VerifyAdminCredential must reject wrong password")
+	}
+	// JWT secret must derive from the password hash, not the empty admin key.
+	secret := jwtSecret(stub)
+	if secret != strings.TrimSpace(stub.passwordHash) {
+		t.Fatalf("jwtSecret must be the password hash when no env secret set, got %q", secret)
+	}
+}
+
+func TestAdminLoginWithEnvKey(t *testing.T) {
+	// Regression: ensure env-key based login still works after the change.
+	t.Setenv("DS2API_ADMIN_KEY", "env-key-12345")
+	t.Setenv("DS2API_JWT_SECRET", "")
+
+	stub := stubStore{}
+	if !VerifyAdminCredential("env-key-12345", stub) {
+		t.Fatal("VerifyAdminCredential must accept the configured env key")
+	}
+	if VerifyAdminCredential("env-key-99999", stub) {
+		t.Fatal("VerifyAdminCredential must reject wrong env key")
+	}
+}
+
+func TestAdminLoginWithJWTSecretEnv(t *testing.T) {
+	// Regression: ensure an explicit JWT secret takes precedence and works
+	// for both signing and verifying.
+	t.Setenv("DS2API_ADMIN_KEY", "env-key-12345")
+	t.Setenv("DS2API_JWT_SECRET", "explicit-jwt-secret")
+
+	stub := stubStore{}
+	if jwtSecret(stub) != "explicit-jwt-secret" {
+		t.Fatalf("jwtSecret must use explicit env value, got %q", jwtSecret(stub))
+	}
+
+	token, err := CreateJWTWithStore(1, stub)
+	if err != nil {
+		t.Fatalf("CreateJWTWithStore failed: %v", err)
+	}
+	if _, err := VerifyJWTWithStore(token, stub); err != nil {
+		t.Fatalf("VerifyJWTWithStore failed: %v", err)
+	}
+}
+
+// usingRealStoreHelper wraps a minimal config.Store so we exercise the same
+// store code paths used in production. We avoid pulling in the full server.
+func TestUsingRealStoreNoCredentials(t *testing.T) {
+	if os.Getenv("DS2API_RUN_REAL_STORE_TEST") == "" {
+		t.Skip("skipping real-store test; set DS2API_RUN_REAL_STORE_TEST=1 to run")
+	}
+	t.Setenv("DS2API_ADMIN_KEY", "")
+	t.Setenv("DS2API_JWT_SECRET", "")
+	t.Setenv("DS2API_CONFIG_JSON", "{}")
+	store := config.LoadStore()
+	if !UsingDefaultAdminKey(store) {
+		t.Fatal("UsingDefaultAdminKey must be true when nothing is configured")
+	}
+	if VerifyAdminCredential("admin", store) {
+		t.Fatal("VerifyAdminCredential must reject \"admin\" with no credentials configured")
+	}
+}

internal/config/config.go

@@ -86,6 +86,29 @@ func (c *Config) ClearAccountTokens() {
 	}
 }
 
+// RedactSecrets returns a copy of the config with all sensitive credentials
+// removed (tokens, passwords, vercel token, admin password hash). Used for
+// display-only snapshots that must not leak secrets even to authenticated
+// admins (e.g. the `config` field of /admin/config/export). Migration-grade
+// exports that need passwords to re-import on another deployment should use
+// ExportJSONAndBase64 instead, which keeps passwords but clears live tokens.
+func (c *Config) RedactSecrets() Config {
+	if c == nil {
+		return Config{}
+	}
+	out := c.Clone()
+	out.ClearAccountTokens()
+	for i := range out.Accounts {
+		out.Accounts[i].Password = ""
+	}
+	for i := range out.Proxies {
+		out.Proxies[i].Password = ""
+	}
+	out.Vercel.Token = ""
+	out.Admin.PasswordHash = ""
+	return out
+}
+
 func (c *Config) NormalizeCredentials() {
 	if c == nil {
 		return

internal/devcapture/store.go

@@ -73,7 +73,12 @@ func Global() *Store {
 }
 
 func NewFromEnv() *Store {
-	enabled := !isVercelRuntime()
+	// Security: dev packet capture stores full request/response bodies (up to
+	// 5MB each) in memory and exposes them via /admin/dev/captures. Default
+	// to disabled everywhere (including HF Spaces and local dev) to avoid
+	// silently capturing user prompts and DeepSeek responses. Operators who
+	// need this for debugging must opt in with DS2API_DEV_PACKET_CAPTURE=1.
+	enabled := false
 	if raw, ok := os.LookupEnv("DS2API_DEV_PACKET_CAPTURE"); ok {
 		enabled = parseBool(raw)
 	}
@@ -96,10 +101,6 @@ func NewFromEnv() *Store {
 	}
 }
 
-func isVercelRuntime() bool {
-	return strings.TrimSpace(os.Getenv("VERCEL")) != "" || strings.TrimSpace(os.Getenv("NOW_REGION")) != ""
-}
-
 func (s *Store) Enabled() bool {
 	if s == nil {
 		return false

internal/httpapi/admin/configmgmt/handler_config_read.go

@@ -70,10 +70,18 @@ func (h *Handler) configExport(w http.ResponseWriter, _ *http.Request) {
 		writeJSON(w, http.StatusInternalServerError, map[string]any{"detail": err.Error()})
 		return
 	}
+	// Security: the `config` field is a display-only snapshot and must never
+	// leak live tokens, plaintext passwords, the Vercel API token, or the
+	// admin password hash. Authenticated admins who need a migration-grade
+	// export with passwords (e.g. to seed a new deployment) should use the
+	// `json`/`base64` fields, which keep passwords but still strip live tokens.
+	redacted := snap.RedactSecrets()
 	writeJSON(w, http.StatusOK, map[string]any{
-		"success": true,
-		"config":  snap,
-		"json":    jsonStr,
-		"base64":  b64,
+		"success":              true,
+		"config":               redacted,
+		"json":                 jsonStr,
+		"base64":               b64,
+		"secrets_in_json":      true,
+		"secrets_in_json_note": "json/base64 contain account and proxy passwords required for migration; treat as a secret and do not share or log.",
 	})
 }

internal/httpapi/admin/configmgmt/handler_config_read_security_test.go

@@ -0,0 +1,196 @@
+package configmgmt
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"github.com/go-chi/chi/v5"
+)
+
+// TestConfigExportRedactsSecretsFromConfigField is a security regression test
+// for the HIGH-severity finding: the `config` field of /admin/config/export
+// previously returned a raw Snapshot() including live account tokens,
+// plaintext passwords, the Vercel API token, and the admin password hash.
+// It must now return a redacted snapshot.
+func TestConfigExportRedactsSecretsFromConfigField(t *testing.T) {
+	raw := `{
+		"api_keys":[{"key":"sk-test-123","name":"primary"}],
+		"accounts":[
+			{"email":"alice@example.com","password":"alice-secret-pw","token":"live-deepseek-token-abc"},
+			{"email":"bob@example.com","password":"bob-secret-pw","token":"live-deepseek-token-def"}
+		],
+		"proxies":[
+			{"id":"proxy_1","name":"main","type":"socks5","host":"p.example.com","port":1080,"username":"u1","password":"proxy-secret-pw"}
+		],
+		"vercel":{"token":"vercel-api-token-secret","project_id":"prj_123","team_id":"team_456"},
+		"admin":{"password_hash":"sha256:abcdef0123456789","jwt_expire_hours":12}
+	}`
+	h := newAdminTestHandler(t, raw)
+
+	r := chi.NewRouter()
+	r.Get("/admin/config/export", h.configExport)
+
+	req := httptest.NewRequest(http.MethodGet, "/admin/config/export", nil)
+	rec := httptest.NewRecorder()
+	r.ServeHTTP(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("export status=%d body=%s", rec.Code, rec.Body.String())
+	}
+
+	var resp struct {
+		Success           bool             `json:"success"`
+		Config            *json.RawMessage `json:"config"`
+		JSON              string           `json:"json"`
+		Base64            string           `json:"base64"`
+		SecretsInJSON     bool             `json:"secrets_in_json"`
+		SecretsInJSONNote string           `json:"secrets_in_json_note"`
+	}
+	if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil {
+		t.Fatalf("unmarshal export response failed: %v body=%s", err, rec.Body.String())
+	}
+
+	if resp.Config == nil {
+		t.Fatal("config field must be present in export response")
+	}
+	configField := string(*resp.Config)
+
+	// CRITICAL: the config field must NOT leak live tokens or plaintext passwords.
+	forbiddenInConfig := []string{
+		"live-deepseek-token-abc",
+		"live-deepseek-token-def",
+		"alice-secret-pw",
+		"bob-secret-pw",
+		"proxy-secret-pw",
+		"vercel-api-token-secret",
+		"sha256:abcdef0123456789",
+	}
+	for _, secret := range forbiddenInConfig {
+		if strings.Contains(configField, secret) {
+			t.Fatalf("config field leaked secret %q in: %s", secret, configField)
+		}
+	}
+
+	if !resp.SecretsInJSON {
+		t.Fatal("secrets_in_json flag must be true so admins know json/base64 contain credentials")
+	}
+	if !strings.Contains(strings.ToLower(resp.SecretsInJSONNote), "secret") {
+		t.Fatalf("secrets_in_json_note should warn about credentials, got %q", resp.SecretsInJSONNote)
+	}
+}
+
+// TestConfigExportJSONStillContainsPasswordsForMigration verifies that the
+// json/base64 fields still contain passwords so the admin can migrate
+// deployments. Live tokens, however, must remain stripped.
+func TestConfigExportJSONStillContainsPasswordsForMigration(t *testing.T) {
+	raw := `{
+		"accounts":[
+			{"email":"alice@example.com","password":"alice-secret-pw","token":"live-deepseek-token-abc"}
+		],
+		"proxies":[
+			{"id":"proxy_1","name":"main","type":"socks5","host":"p.example.com","port":1080,"password":"proxy-secret-pw"}
+		]
+	}`
+	h := newAdminTestHandler(t, raw)
+
+	r := chi.NewRouter()
+	r.Get("/admin/config/export", h.configExport)
+
+	req := httptest.NewRequest(http.MethodGet, "/admin/config/export", nil)
+	rec := httptest.NewRecorder()
+	r.ServeHTTP(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("export status=%d body=%s", rec.Code, rec.Body.String())
+	}
+
+	var resp struct {
+		JSON   string `json:"json"`
+		Base64 string `json:"base64"`
+	}
+	if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil {
+		t.Fatalf("unmarshal export response failed: %v", err)
+	}
+
+	// Passwords are needed for migration (a fresh deployment needs the
+	// password to log into DeepSeek and obtain a fresh token).
+	if !strings.Contains(resp.JSON, "alice-secret-pw") {
+		t.Fatal("json field must keep account passwords for migration use case")
+	}
+	if !strings.Contains(resp.JSON, "proxy-secret-pw") {
+		t.Fatal("json field must keep proxy passwords for migration use case")
+	}
+
+	// Live tokens must NEVER be in any export field — they can be replayed
+	// to authenticate as the user while still valid.
+	if strings.Contains(resp.JSON, "live-deepseek-token-abc") {
+		t.Fatal("json field must NOT contain live account tokens")
+	}
+
+	// Base64 must decode to the same JSON content.
+	decoded, err := base64.StdEncoding.DecodeString(resp.Base64)
+	if err != nil {
+		t.Fatalf("base64 decode failed: %v", err)
+	}
+	if !strings.Contains(string(decoded), "alice-secret-pw") {
+		t.Fatal("base64 field must decode to JSON containing migration passwords")
+	}
+	if strings.Contains(string(decoded), "live-deepseek-token-abc") {
+		t.Fatal("base64 field must NOT contain live account tokens")
+	}
+}
+
+// TestRedactSecretsIsComplete is a unit-level regression test for
+// Config.RedactSecrets covering every secret-bearing field.
+func TestRedactSecretsIsComplete(t *testing.T) {
+	raw := `{
+		"accounts":[
+			{"email":"a@x.com","password":"pw-a","token":"tok-a"},
+			{"email":"b@x.com","password":"pw-b","token":"tok-b"}
+		],
+		"proxies":[
+			{"id":"p1","host":"h","port":1,"password":"proxy-pw"}
+		],
+		"vercel":{"token":"vercel-tok","project_id":"prj"},
+		"admin":{"password_hash":"sha256:hashed","jwt_expire_hours":24}
+	}`
+	h := newAdminTestHandler(t, raw)
+	snap := h.Store.Snapshot()
+	redacted := snap.RedactSecrets()
+
+	for i, acc := range redacted.Accounts {
+		if acc.Token != "" {
+			t.Fatalf("account %d token not redacted: %q", i, acc.Token)
+		}
+		if acc.Password != "" {
+			t.Fatalf("account %d password not redacted: %q", i, acc.Password)
+		}
+	}
+	for i, p := range redacted.Proxies {
+		if p.Password != "" {
+			t.Fatalf("proxy %d password not redacted: %q", i, p.Password)
+		}
+	}
+	if redacted.Vercel.Token != "" {
+		t.Fatalf("vercel token not redacted: %q", redacted.Vercel.Token)
+	}
+	if redacted.Admin.PasswordHash != "" {
+		t.Fatalf("admin password hash not redacted: %q", redacted.Admin.PasswordHash)
+	}
+
+	// Non-secret fields must remain intact so the redacted view is still useful.
+	if len(redacted.Accounts) != 2 {
+		t.Fatalf("redacted accounts count mismatch: %d", len(redacted.Accounts))
+	}
+	if redacted.Accounts[0].Email != "a@x.com" {
+		t.Fatalf("redacted account email lost: %q", redacted.Accounts[0].Email)
+	}
+	if redacted.Vercel.ProjectID != "prj" {
+		t.Fatalf("redacted vercel project id lost: %q", redacted.Vercel.ProjectID)
+	}
+	if redacted.Admin.JWTExpireHours != 24 {
+		t.Fatalf("redacted admin jwt_expire_hours lost: %d", redacted.Admin.JWTExpireHours)
+	}
+}

internal/httpapi/admin/rawsamples/handler_raw_samples_test.go

@@ -15,6 +15,18 @@ import (
 	"ds2api/internal/devcapture"
 )
 
+// TestMain enables dev packet capture for the rawsamples test binary so the
+// devcapture.Global() singleton initializes as enabled. The rawsamples
+// capture handler only records captures when devcapture is enabled; in
+// production this must be opted in via DS2API_DEV_PACKET_CAPTURE=1, but for
+// these tests we always need it on.
+func TestMain(m *testing.M) {
+	if err := os.Setenv("DS2API_DEV_PACKET_CAPTURE", "1"); err != nil {
+		panic("failed to set DS2API_DEV_PACKET_CAPTURE: " + err.Error())
+	}
+	os.Exit(m.Run())
+}
+
 type stubOpenAIChatCaller struct{}
 
 func (stubOpenAIChatCaller) ChatCompletions(w http.ResponseWriter, _ *http.Request) {

internal/httpapi/admin/token_runtime_http_test.go

@@ -17,6 +17,12 @@ import (
 
 func newHTTPAdminHarness(t *testing.T, rawConfig string, ds adminshared.DeepSeekCaller) http.Handler {
 	t.Helper()
+	// Security regression fix: admin login is disabled when no credentials
+	// are configured. Tests in this file exercise admin endpoints, so set a
+	// test-only admin key to authenticate. This also ensures the JWT secret
+	// is deterministic rather than a process-local random fallback.
+	t.Setenv("DS2API_ADMIN_KEY", "test-admin-key-12345")
+	t.Setenv("DS2API_JWT_SECRET", "test-jwt-secret")
 	t.Setenv("DS2API_CONFIG_JSON", rawConfig)
 	store := config.LoadStore()
 	h := &Handler{
@@ -31,7 +37,7 @@ func newHTTPAdminHarness(t *testing.T, rawConfig string, ds adminshared.DeepSeek
 
 func adminReq(method, path string, body []byte) *http.Request {
 	req := httptest.NewRequest(method, path, bytes.NewReader(body))
-	req.Header.Set("Authorization", "Bearer admin")
+	req.Header.Set("Authorization", "Bearer test-admin-key-12345")
 	req.Header.Set("Content-Type", "application/json")
 	return req
 }

security_best_practices_report.md

@@ -0,0 +1,289 @@
+# ds2api 安全审计报告
+
+## 概述
+
+本次安全审计针对部署在 Hugging Face Spaces 上的 ds2api（DeepSeek 反向代理）项目。背景是该用户的其他 HF Spaces 遭到猛烈的扫描攻击（探测 `/.git/config`、`/.env`、`/wp-config.php.bak`、`/proc/self/environ`、`/phpinfo.php` 等敏感路径），因此对当前项目进行全面审查以排除潜在隐患。
+
+审计覆盖范围：
+- Go 后端（chi router）+ React/Vite 前端 webui + Cloudflare Worker（cron 自愈）+ Node.js chat-stream（Vercel runtime）
+- JWT (HS256) 管理员鉴权 + 可选 sha256 密码哈希
+- DeepSeek PoW + 多账号池 + SOCKS5 代理池
+- devcapture（请求/响应体内存捕获）+ rawsample（持久化到 `tests/raw_stream_samples/`）
+- 协议适配器边界（OpenAI/Claude/Gemini/Ollama）
+
+**严重问题已在本次提交中直接修复并通过测试验证**（详见"已修复问题"章节）。本报告其余章节列出尚未修复的中低风险问题，建议按优先级排期处理。
+
+---
+
+## 已修复问题（本次提交）
+
+### FIXED-1: 默认管理员密钥为 "admin"（CRITICAL）
+
+**位置**: `internal/auth/admin.go:32-45`（修复前）
+
+**问题**: `effectiveAdminKey` 在 `DS2API_ADMIN_KEY` 未设置且未配置 password_hash 时，硬编码返回 `"admin"`。这意味着任何未配置管理员密钥的部署（包括全新 HF Space、本地开发实例）都能用 `admin` 作为 admin_key 登录后台。扫描攻击日志显示攻击者正在批量探测 `/admin`、`/admin/config` 等路径。
+
+**影响**: 任何知道项目源码的攻击者可以直接登录未配置管理员密钥的部署，获取所有 DeepSeek 账号、代理、API key 等敏感配置。
+
+**修复**: `effectiveAdminKey` 在未配置任何凭据时返回空字符串，禁用密码登录。`VerifyAdminCredential` 已有空检查会拒绝空 key。同时把警告日志从"使用不安全默认 admin"改为"管理员登录已禁用，请配置 DS2API_ADMIN_KEY 或在管理面板设置密码"。
+
+### FIXED-2: JWT secret 回退到 "admin"（CRITICAL）
+
+**位置**: `internal/auth/admin.go:47-57`（修复前）
+
+**问题**: `jwtSecret` 在没有 `DS2API_JWT_SECRET`、没有 password_hash 时回退到 `effectiveAdminKey(store)`，也就是上面的 `"admin"`。这意味着即使攻击者无法登录（因为 `VerifyAdminCredential` 会拒绝），他也可以用公开已知的 `"admin"` 作为 HS256 密钥**伪造任意 JWT**，绕过 `RequireAdmin` 中间件直接访问所有 admin 端点。
+
+**影响**: 与 FIXED-1 等价 —— 任何未配置 JWT secret 的部署，攻击者可伪造 JWT 直接访问所有 `/admin/*` 端点，包括导出全部账号密码的 `/admin/config/export`。
+
+**修复**: 新增 `fallbackJWTSecret()`，使用 `crypto/rand` 生成 32 字节进程级随机 secret（一次性生成、`sync.Once` 缓存），确保 JWT 签名密钥不可预测。即使攻击者知道历史默认值 `"admin"`，也无法伪造能通过验证的 token。
+
+### FIXED-3: `/admin/config/export` 泄露明文密码和 live token（HIGH）
+
+**位置**: `internal/httpapi/admin/configmgmt/handler_config_read.go:66-78`（修复前）
+
+**问题**: `configExport` 返回的 `config` 字段是 `h.Store.Snapshot()` 的原始对象，包含：
+- `accounts[].password`（DeepSeek 账号明文密码）
+- `accounts[].token`（**实时**有效的 DeepSeek 会话 token，可被重放）
+- `proxies[].password`（SOCKS5 代理密码）
+- `vercel.token`（Vercel API token，第三方凭据）
+- `admin.password_hash`（管理员密码哈希，可用于伪造 JWT）
+
+虽然该端点要求 Bearer token 鉴权，但一旦 admin JWT 泄露（XSS、浏览器扩展、日志捕获、共享开发机器），所有密码和 live token 立刻泄露。前端实际只用 `json`/`base64` 字段（用于迁移），`config` 字段是冗余的展示性快照。
+
+**影响**: 通过 admin token 泄露链，攻击者可一次性获取所有 DeepSeek 账号凭据，可被用于登录 DeepSeek 网站或重放 API 调用。
+
+**修复**:
+1. 新增 `Config.RedactSecrets()` 方法，返回清除所有 token/password/vercel token/admin password_hash 的快照副本。
+2. `configExport` 的 `config` 字段改用 `snap.RedactSecrets()`，前端展示用，永不包含敏感数据。
+3. `json`/`base64` 字段保留密码（迁移用途必需 —— 新部署需要密码才能登录 DeepSeek 获取新 token），但 `accounts[].token` 仍由 `ExportJSONAndBase64` 的 `ClearAccountTokens()` 清除。
+4. 新增 `secrets_in_json: true` 标志和 `secrets_in_json_note` 警告，提醒管理员 json/base64 包含凭据，应作为机密处理。
+
+### FIXED-4: 删除可疑的 `_fix.py` 和 `_fix2.py`（MEDIUM）
+
+**位置**: `/workspace/_fix.py`、`/workspace/_fix2.py`
+
+**问题**:
+- `_fix.py` 是一次性脚本，用于修改 Dockerfile 的 CMD（已被 `entrypoint.sh` 取代）。
+- `_fix2.py` 使用 `chr()` 字符编码混淆访问 `"Dockerfile"`（`chr(68)+chr(111)+chr(99)+chr(107)+chr(101)+chr(114)+chr(102)+chr(105)+chr(108)+chr(101)`），这种混淆在安全审计中属于可疑模式 —— 攻击者常用此技巧逃避 `grep "Dockerfile"` 类的静态扫描。虽然内容看起来是良性的（patch Dockerfile），但既然已经废弃，不应留在仓库里。审计期间也发现 `_fix2.py` 还有语法错误（`old=CMD [/usr/local/bin/ds2api]` 缺引号），说明它从未实际运行过。
+
+**影响**: 低，但会误导后续审计、增加攻击面认知噪音。
+
+**修复**: 直接删除两个文件。
+
+### FIXED-5: devcapture 默认在非 Vercel 启用，捕获完整 prompt/response（MEDIUM）
+
+**位置**: `internal/devcapture/store.go:75-97`（修复前）
+
+**问题**: `NewFromEnv` 的逻辑是 `enabled := !isVercelRuntime()`，即在 HF Spaces、本地开发、Docker 部署等所有非 Vercel 环境下**默认启用** devcapture。该模块会捕获每次请求的完整 body 和响应 body（最大 5MB），存于内存并通过 `/admin/dev/captures` 端点暴露。对于 DeepSeek 代理来说，请求 body 包含用户的完整 prompt（可能含敏感对话内容），响应 body 包含完整 LLM 回复。
+
+**影响**:
+- 内存占用：高并发下 20 条 × 5MB = 100MB，可能触发 OOM。
+- 隐私泄露：管理员 JWT 泄露后，攻击者可读取最近 20 条用户的完整 prompt/response。
+- 默认开启：大多数部署者不知道此功能存在。
+
+**修复**: 改为默认禁用，必须显式设置 `DS2API_DEV_PACKET_CAPTURE=1` 才启用。同时移除不再使用的 `isVercelRuntime()` 辅助函数。
+
+---
+
+## 待修复问题（按优先级排序）
+
+### TODO-1: `/admin/login` 无速率限制（MEDIUM）
+
+**位置**: `internal/httpapi/admin/auth/handler_auth.go` 的 `login` handler
+
+**问题**: 登录端点直接调用 `VerifyAdminCredential`，没有任何速率限制、IP 封禁或失败计数。攻击者可对 admin key 进行暴力枚举。
+
+**影响**:
+- 当 admin key 较弱（如 `admin123`、`password`）时，可被字典攻击破解。
+- 即使 admin key 强，暴力请求也会消耗服务器资源。
+
+**建议修复**:
+1. 在 `login` handler 中维护进程级失败计数器（IP → 失败次数 + 最后失败时间）。
+2. 同一 IP 连续失败 5 次后，5 分钟内拒绝所有登录请求（返回 429）。
+3. 失败计数器在成功登录或时间窗口过后重置。
+4. 可选：使用 `golang.org/x/time/rate` 实现 token bucket。
+
+**注意**: HF Spaces 通常有多副本，进程级限流可被绕过（每个副本独立计数）。若需更强保护，可结合 Cloudflare Worker 或外部 WAF。
+
+### TODO-2: rawsample 持久化完整 prompt/response 到磁盘（MEDIUM）
+
+**位置**: `internal/httpapi/admin/rawsamples/handler_raw_samples.go` + `internal/rawsample/rawsample.go`
+
+**问题**: 当 `DS2API_RAW_SAMPLE_CAPTURE=1` 时，系统会把请求/响应的完整原始字节流持久化到 `tests/raw_stream_samples/` 目录。每个 sample 包含：
+- 完整的用户 prompt
+- DeepSeek 的完整响应
+- 账号 identifier
+- 时间戳
+
+这些文件以 `.json` 形式落盘，没有加密，且在 git 提交时可能被意外加入。在生产 HF Space 上启用时，`/data/` 持久化卷会一直保留这些 sample。
+
+**影响**:
+- 隐私：用户 prompt 持久化到磁盘。
+- 合规：可能违反 GDPR/CCPA 等数据最小化原则。
+- 攻击面：管理员 JWT 泄露后，攻击者可下载历史 sample。
+
+**建议修复**:
+1. 默认禁用（已是默认行为，确认即可）。
+2. 在 admin UI 上明确警告"启用后会持久化用户 prompt 到磁盘"。
+3. 增加自动过期机制（如 24 小时后自动删除）。
+4. 在 `.gitignore` 中确认 `tests/raw_stream_samples/` 已被忽略（已确认）。
+
+### TODO-3: 版本检查 handler 指向不存在的 GitHub 仓库（LOW）
+
+**位置**: `internal/httpapi/admin/version/handler_version.go`
+
+**问题**: 版本检查 handler 调用 GitHub API 比对版本，但硬编码的仓库是 `CJackHwang/ds2api`，而实际部署的 remote 是 `luckfun233/ds2api`（或 `a3216/ds2api`）。这导致：
+1. 版本检查永远返回"有更新可用"或"无法获取"。
+2. 误导管理员升级到无关项目的版本。
+3. 信任了一个第三方仓库的 release tag，存在供应链风险。
+
+**影响**: 低，但会误导管理员。
+
+**建议修复**:
+1. 把仓库 ID 改为实际部署的 `a3216/ds2api`（或通过环境变量配置）。
+2. 或者移除版本检查功能，让管理员自行关注 release。
+
+### TODO-4: CORS reflect origin（LOW）
+
+**位置**: `internal/server/router.go` 的 CORS 中间件
+
+**问题**: CORS 策略反射请求的 `Origin` header，允许任意网站发起跨域请求。虽然所有 admin 端点都要求 Bearer token（不会被 cookie 自动携带），但：
+1. 如果未来添加了基于 cookie 的鉴权，反射 origin 会变成漏洞。
+2. 反射 origin 让攻击者网站可以发起 authenticated CORS 请求（如果前端把 token 存在内存里被 XSS 偷走）。
+
+**影响**: 低，因为当前 admin 鉴权用 Bearer token 而非 cookie。
+
+**建议修复**:
+1. 把 CORS 限制为已知的前端域名（如 `https://a3216-ds2api.hf.space`）。
+2. 或者只允许同源请求（不设 `Access-Control-Allow-Origin`）。
+3. 如果保留 reflect origin，确保 `Access-Control-Allow-Credentials: false`（当前未设 credential，符合预期）。
+
+### TODO-5: account token 在内存中以明文存在（LOW）
+
+**位置**: `internal/config/store.go` 的 `cfg.Accounts[].Token`
+
+**问题**: DeepSeek 账号的 session token 在内存中以明文存储。如果服务器进程内存被 dump（如通过 `/proc/<pid>/mem`、core dump、swap 文件），token 会泄露。
+
+**影响**: 低，需要本地权限提升才能利用。
+
+**建议修复**: 不建议立即修复 —— Go 进程内存加密会显著增加复杂度且无法抵御 root 攻击者。建议：
+1. 确保 HF Space 容器以非 root 用户运行（已确认 `ds2api` 用户）。
+2. 定期刷新 token（已有 `TokenRefreshIntervalHours` 配置）。
+3. 监控异常 token 使用。
+
+### TODO-6: webui 静态文件路径穿越（已防护，建议加固）
+
+**位置**: `internal/webui/handler.go` 的 `serveFromDisk`
+
+**当前状态**: 已正确实现路径穿越防护 —— 使用 `filepath.Clean` + `isPathInsideRoot` 检查。
+
+**建议加固**:
+1. 在 `isPathInsideRoot` 失败时返回 404 而非 403（避免泄露路径存在性）。
+2. 对所有静态文件请求添加 `X-Content-Type-Options: nosniff` header。
+3. 对 `.json`、`.map` 等开发文件在生产环境返回 404。
+
+### TODO-7: chat_history 持久化用户对话（LOW）
+
+**位置**: `internal/chathistory/store.go`
+
+**问题**: chat_history 默认开启，把每个会话的完整消息持久化到 `/data/chat_history.json`。这是设计意图（用于上下文续接），但：
+1. 文件未加密。
+2. 没有 TTL 自动清理。
+3. HF Space 重启时 `/data/` 保留，历史数据可能长期堆积。
+
+**影响**: 隐私 —— 用户对话长期持久化。
+
+**建议修复**:
+1. 添加 `DS2API_CHAT_HISTORY_TTL_HOURS` 环境变量，自动清理超期记录。
+2. 在 admin UI 提供"一键清空 chat history"按钮。
+3. 文档中明确告知部署者 chat_history 会持久化用户对话。
+
+### TODO-8: env writeback 把环境变量写回 config.json（LOW）
+
+**位置**: `internal/config/store_env_writeback.go`
+
+**问题**: 当 `DS2API_ENV_WRITEBACK=1` 时，系统会把 `DS2API_CONFIG_JSON` 环境变量的内容写回 `/data/config.json`。这意味着：
+1. 如果环境变量包含明文密码（常见于 HF Space Secrets），密码会被复制到 `/data/config.json`。
+2. `/data/config.json` 的权限是 644（world-readable），同机其他用户可读。
+
+**影响**: 低 —— HF Space 容器隔离，无其他用户。但本地开发或自托管场景下有风险。
+
+**建议修复**:
+1. 把 `/data/config.json` 权限改为 600（仅 owner 可读）。
+2. 在 `entrypoint.sh` 中 `chmod 600 /data/config.json`。
+3. 文档中说明 env writeback 会把密码写入磁盘。
+
+### TODO-9: 没有请求体大小限制（LOW）
+
+**位置**: `internal/server/router.go`
+
+**问题**: chi router 没有全局的 `http.MaxBytesReader`。攻击者可发送超大请求体消耗内存。
+
+**影响**: 低 —— DeepSeek API 本身有请求大小限制，且 chi 默认有超时。
+
+**建议修复**:
+1. 在 router 中间件添加 `http.MaxBytesReader(w, r.Body, 10*1024*1024)`（10MB）。
+2. 对 `/admin/config/import` 等需要大 body 的端点单独放宽限制。
+
+### TODO-10: 没有 HSTS / Secure cookie（按 skill 建议不报）
+
+按 `security-best-practices` skill 指引，HSTS 在不完全理解长期影响时不建议启用，且 HF Space 已自带 HTTPS 终结，故不作为问题报告。
+
+---
+
+## 渗透测试验证
+
+针对已修复的 CRITICAL/HIGH 问题，本次审计通过单元测试模拟了以下攻击场景：
+
+1. **默认密钥登录**：`TestVerifyAdminCredentialRejectsEmptyAndDefaultAdmin` —— 验证未配置凭据时，`"admin"`、空字符串、`"password"`、`"123456"` 等常见弱密码全部被拒绝。
+
+2. **JWT 伪造**：`TestJWTForgedWithAdminSecretFailsVerification` —— 模拟攻击者用历史默认 `"admin"` 作为 HS256 密钥伪造 JWT，验证 `VerifyJWT` 拒绝该 token。
+
+3. **配置导出泄露**：`TestConfigExportRedactsSecretsFromConfigField` —— 验证 `config` 字段不包含 live token、明文密码、vercel token、admin password hash。
+
+4. **迁移用途保留**：`TestConfigExportJSONStillContainsPasswordsForMigration` —— 验证 `json`/`base64` 字段仍保留密码（迁移必需），但绝不包含 live token。
+
+5. **密码哈希登录回归**：`TestAdminLoginWithConfiguredPasswordHash` —— 验证配置 password_hash 后，密码登录和 JWT 签名都正常工作。
+
+6. **环境变量密钥登录回归**：`TestAdminLoginWithEnvKey` —— 验证配置 `DS2API_ADMIN_KEY` 后，env key 登录正常。
+
+7. **显�� JWT secret 优先**：`TestAdminLoginWithJWTSecretEnv` —— 验证 `DS2API_JWT_SECRET` 优先级最高。
+
+所有测试通过。建议在 CI 中持续运行这些回归测试，防止未来重构时 reintroduce 这些漏洞。
+
+---
+
+## 部署者操作建议
+
+本次修复后，部署者应：
+
+1. **必须**：在 HF Space Secrets 中设置 `DS2API_ADMIN_KEY` 为强随机字符串（至少 32 字符）。否则管理员登录将完全禁用。
+2. **强烈建议**：设置 `DS2API_JWT_SECRET` 为另一个独立的强随机字符串（不要复用 `DS2API_ADMIN_KEY`）。
+3. **建议**：通过 admin UI 的"修改密码"功能设置管理员密码（会写入 `admin.password_hash`），这样即使 `DS2API_ADMIN_KEY` 泄露，密码登录通道仍可用。
+4. **可选**：如需调试，设置 `DS2API_DEV_PACKET_CAPTURE=1` 临时启用 devcapture，调试完毕后务必设回 `0` 或删除该环境变量。
+5. **审计**：检查 `/data/config.json` 是否包含不再需要的账号密码，定期清理。
+6. **监控**：定期查看 HF Space 日志，关注异常 admin 端点访问。
+
+---
+
+## 审计方法说明
+
+本次审计采用以下方法：
+
+1. **静态代码审查**：阅读 30+ 个关键文件，包括鉴权、配置、API 路由、前端、CF Worker、Dockerfile。
+2. **数据流追踪**：从 HTTP 请求入口追踪到配置持久化，识别敏感数据（密码、token、prompt）的存储和暴露路径。
+3. **攻击者视角**：假设攻击者拥有源码（项目开源），从扫描攻击日志中提取常见攻击模式，验证项目是否易受这些攻击。
+4. **依赖审查**：检查 `go.mod` 和 `package.json`，未发现已知漏洞依赖。
+5. **配置审查**：检查 Dockerfile、entrypoint.sh、CF Worker 配置，确认容器以非 root 运行、端口隔离、配置文件权限合理。
+
+未覆盖的范围（建议后续审计）：
+- DeepSeek PoW 实现的密码学正确性（`pow/deepseek_pow.go`）
+- utls 指纹模拟的隐私影响（`internal/deepseek/client/proxy.go`）
+- shumei 设备 ID 生成算法（`internal/shumei/`）
+- Vercel Edge Function 的资源限制行为
+- 前端 XSS 防护（React 默认转义，但需检查 `dangerouslySetInnerHTML` 使用）
+
+---
+
+*报告生成时间：2026-07-21*
+*审计者：security-best-practices skill*