Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

feat(web): keep saved connection credentials on the server

zipge7973404660d
diff --git a/apps/desktop/src/StartupGate.vue b/apps/desktop/src/StartupGate.vue
index c5b4e9d75a..69036f8b9f 100644
--- a/apps/desktop/src/StartupGate.vue
+++ b/apps/desktop/src/StartupGate.vue
@@ -9,6 +9,7 @@ import { loadSavedLocale } from "@/i18n";
import { checkStartupAuthentication, type StartupAuthentication } from "@/lib/startup/startupAuthentication";
import { markStartupPhase } from "@/lib/startup/startupTiming";
import { retryStartupAfterPreloadFailure } from "@/lib/startup/startupPreloadRecovery";
+import { initializePasswordViewerCapability } from "@/lib/security/passwordViewer";
// App setup installs listeners and instantiates business stores, so even its import
// is deferred until authentication and the security migration have completed.
@@ -75,6 +76,9 @@ async function initialize() {
history.replaceState(null, "", webPath("/login"));
return;
}
+ await initializePasswordViewerCapability();
+ } else {
+ await initializePasswordViewerCapability();
}
markStartupPhase("auth-ready");
await migration.initialize();
diff --git a/apps/desktop/src/__tests__/StartupGate.spec.ts b/apps/desktop/src/__tests__/StartupGate.spec.ts
index 40f13312be..3ce5b62f53 100644
--- a/apps/desktop/src/__tests__/StartupGate.spec.ts
+++ b/apps/desktop/src/__tests__/StartupGate.spec.ts
@@ -11,6 +11,7 @@ const mocks = vi.hoisted(() => ({
migrationStart: vi.fn(),
migrationRetry: vi.fn(),
migrationCleanupBackups: vi.fn(),
+ loadWebCapabilities: vi.fn(),
}));
vi.mock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: mocks.desktop }));
vi.mock("@/lib/backend/api", () => mocks);
@@ -39,6 +40,7 @@ beforeEach(() => {
mocks.desktop.mockReturnValue(true);
mocks.migrationStatus.mockResolvedValue(readyStatus);
mocks.reloadLocale.mockResolvedValue(undefined);
+ mocks.loadWebCapabilities.mockResolvedValue({ passwordViewerEnabled: true });
businessReady = deferred<void>();
root = document.createElement("div");
document.body.append(root);
diff --git a/apps/desktop/src/components/sidebar/SidebarTreeRuntimeHost.vue b/apps/desktop/src/components/sidebar/SidebarTreeRuntimeHost.vue
index 047bf47426..91dc6fcacb 100644
--- a/apps/desktop/src/components/sidebar/SidebarTreeRuntimeHost.vue
+++ b/apps/desktop/src/components/sidebar/SidebarTreeRuntimeHost.vue
@@ -234,6 +234,7 @@ import type { BuildSingleColumnAlterSqlOptions } from "@/lib/table/tableStructur
import { formatSidebarTableCopyText, type FormatSidebarTableNamesOptions } from "@/lib/sidebar/sidebarTableNameCopy";
import { supportsScheduledDatabaseBackup } from "@/lib/backup/scheduledDatabaseBackup";
import { isTauriRuntime } from "@/lib/backend/tauriRuntime";
+import { passwordViewerEnabled } from "@/lib/security/passwordViewer";
import { copyToClipboard } from "@/lib/common/clipboard";
import { buildConnectionUrlCopy, CONNECTION_URL_COPY_WITH_PASSWORD_FORMATS, connectionUrlCopyFormats, type ConnectionUrlCopyFormat } from "@/lib/connection/connectionUrlBuilder";
import { rankSavedSqlHistory, type SavedSqlHistoryScope } from "@/lib/savedSql/savedSqlHistory";
@@ -2650,7 +2651,7 @@ function connectionUrlCopyMenuItem(databaseOverride?: string): ContextMenuItem |
const node = activeNode.value;
const config = node.connectionId ? connectionStore.getConfig(node.connectionId) : undefined;
if (!config) return null;
- const formats = connectionUrlCopyFormats(config);
+ const formats = connectionUrlCopyFormats(config).filter((format) => passwordViewerEnabled.value || !CONNECTION_URL_COPY_WITH_PASSWORD_FORMATS.has(format));
if (formats.length === 0) return null;
return {
sidebarActionId: "contextMenu.copyConnectionInfo",
diff --git a/apps/desktop/src/components/ui/PasswordInput.vue b/apps/desktop/src/components/ui/PasswordInput.vue
index 7d161fbc90..6ae0d695b9 100644
--- a/apps/desktop/src/components/ui/PasswordInput.vue
+++ b/apps/desktop/src/components/ui/PasswordInput.vue
@@ -3,6 +3,7 @@ import { computed, ref } from "vue";
import { useI18n } from "vue-i18n";
import { Eye, EyeOff } from "@lucide/vue";
import { Input } from "@/components/ui/input";
+import { isSavedCredential, passwordViewerEnabled } from "@/lib/security/passwordViewer";
defineOptions({ inheritAttrs: false });
@@ -24,16 +25,24 @@ const props = withDefaults(
},
);
+const savedCredential = computed(() => isSavedCredential(model.value));
+const inputValue = computed({
+ get: () => (savedCredential.value ? "" : model.value),
+ set: (value: string | undefined) => {
+ model.value = value;
+ },
+});
const visible = ref(false);
const { t } = useI18n();
+const showToggle = computed(() => props.showToggle && passwordViewerEnabled.value && !savedCredential.value);
const toggleLabel = computed(() => (visible.value ? props.hideLabel || t("common.hidePassword") : props.showLabel || t("common.showPassword")));
</script>
<template>
<div :class="props.class" class="relative">
- <Input v-model="model" data-password-input :type="visible ? 'text' : 'password'" :placeholder="placeholder" :disabled="disabled" :class="[props.inputClass, props.showToggle ? 'pr-8' : undefined]" v-bind="$attrs" />
+ <Input v-model="inputValue" data-password-input :type="visible && showToggle ? 'text' : 'password'" :placeholder="savedCredential ? '••••••••' : placeholder" :disabled="disabled" :class="[props.inputClass, showToggle ? 'pr-8' : undefined]" v-bind="$attrs" />
<button
- v-if="props.showToggle"
+ v-if="showToggle"
type="button"
:disabled="disabled"
:tabindex="toggleTabIndex"
diff --git a/apps/desktop/src/components/ui/PasswordTextarea.vue b/apps/desktop/src/components/ui/PasswordTextarea.vue
index 42385a8a6e..b373d952d6 100644
--- a/apps/desktop/src/components/ui/PasswordTextarea.vue
+++ b/apps/desktop/src/components/ui/PasswordTextarea.vue
@@ -2,9 +2,17 @@
import { computed, ref } from "vue";
import { useI18n } from "vue-i18n";
import { Eye, EyeOff } from "@lucide/vue";
+import { isSavedCredential, passwordViewerEnabled } from "@/lib/security/passwordViewer";
defineOptions({ inheritAttrs: false });
const model = defineModel<string>();
+const savedCredential = computed(() => isSavedCredential(model.value));
+const inputValue = computed({
+ get: () => (savedCredential.value ? "" : model.value),
+ set: (value: string) => {
+ model.value = value;
+ },
+});
const visible = ref(false);
const { t } = useI18n();
const toggleLabel = computed(() => t(visible.value ? "common.hidePassword" : "common.showPassword"));
@@ -13,15 +21,16 @@ const toggleLabel = computed(() => t(visible.value ? "common.hidePassword" : "co
<template>
<div class="relative">
<textarea
- v-model="model"
+ v-model="inputValue"
+ :placeholder="savedCredential ? '••••••••' : undefined"
v-bind="$attrs"
- :class="{ 'secret-masked': !visible }"
+ :class="{ 'secret-masked': !visible || !passwordViewerEnabled }"
class="min-h-20 w-full resize-y rounded-md border border-input bg-transparent py-2 pl-2.5 pr-9 text-sm outline-none transition-colors placeholder:text-muted-foreground focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50"
autocomplete="off"
autocapitalize="off"
:spellcheck="false"
/>
- <button type="button" class="absolute right-2 top-2.5 text-muted-foreground hover:text-foreground" :aria-label="toggleLabel" :title="toggleLabel" :aria-pressed="visible" @click="visible = !visible">
+ <button v-if="passwordViewerEnabled && !savedCredential" type="button" class="absolute right-2 top-2.5 text-muted-foreground hover:text-foreground" :aria-label="toggleLabel" :title="toggleLabel" :aria-pressed="visible" @click="visible = !visible">
<Eye v-if="!visible" class="size-3.5" />
<EyeOff v-else class="size-3.5" />
</button>
diff --git a/apps/desktop/src/lib/__tests__/connection/connectionPassword.spec.ts b/apps/desktop/src/lib/__tests__/connection/connectionPassword.spec.ts
index 42df5c7f56..4ab8a15d3f 100644
--- a/apps/desktop/src/lib/__tests__/connection/connectionPassword.spec.ts
+++ b/apps/desktop/src/lib/__tests__/connection/connectionPassword.spec.ts
@@ -44,4 +44,8 @@ describe("connection password prompting", () => {
expect(connectionNeedsPasswordPrompt(connection({ db_type: "mysql", port: 3306, url_params: "auth=noSasl" }))).toBe(true);
expect(connectionNeedsPasswordPrompt(connection({ db_type: "postgres", port: 5432, save_password: true }))).toBe(false);
});
+ it("prompts when saving is disabled even if the draft contains a saved reference", () => {
+ expect(connectionNeedsPasswordPrompt(connection({ db_type: "mysql", password: "__DBX_SAVED_CREDENTIAL__:ref" }))).toBe(true);
+ expect(connectionNeedsPasswordPrompt(connection({ db_type: "mysql", save_password: true, password: "__DBX_SAVED_CREDENTIAL__:ref" }))).toBe(false);
+ });
});
diff --git a/apps/desktop/src/lib/__tests__/ui/passwordInput.spec.ts b/apps/desktop/src/lib/__tests__/ui/passwordInput.spec.ts
index 568c9060e6..985500e240 100644
--- a/apps/desktop/src/lib/__tests__/ui/passwordInput.spec.ts
+++ b/apps/desktop/src/lib/__tests__/ui/passwordInput.spec.ts
@@ -4,16 +4,17 @@ import { createApp, nextTick, ref } from "vue";
import { createI18n } from "vue-i18n";
import { afterEach, describe, expect, it } from "vitest";
import PasswordInput from "@/components/ui/PasswordInput.vue";
+import { passwordViewerEnabled } from "@/lib/security/passwordViewer";
const mountedApps: Array<ReturnType<typeof createApp>> = [];
-async function mountPasswordInput(toggleTabIndex?: number) {
+async function mountPasswordInput(toggleTabIndex?: number, initialValue = "") {
const host = document.createElement("div");
document.body.appendChild(host);
const app = createApp({
components: { PasswordInput },
setup() {
- return { toggleTabIndex, value: ref("") };
+ return { toggleTabIndex, value: ref(initialValue) };
},
template: '<PasswordInput v-model="value" :toggle-tab-index="toggleTabIndex" />',
});
@@ -33,6 +34,7 @@ async function mountPasswordInput(toggleTabIndex?: number) {
afterEach(() => {
for (const app of mountedApps.splice(0)) app.unmount();
document.body.replaceChildren();
+ passwordViewerEnabled.value = true;
});
describe("PasswordInput", () => {
@@ -43,4 +45,22 @@ describe("PasswordInput", () => {
it("allows forms to remove the visibility toggle from the tab order", async () => {
expect((await mountPasswordInput(-1)).tabIndex).toBe(-1);
});
+
+ it("hides the visibility toggle when the backend disables password viewing", async () => {
+ passwordViewerEnabled.value = false;
+ expect(await mountPasswordInput()).toBeNull();
+ });
+ it("keeps saved references out of the input DOM and accepts replacement passwords", async () => {
+ passwordViewerEnabled.value = false;
+ await mountPasswordInput(undefined, "__DBX_SAVED_CREDENTIAL__:opaque-reference");
+ const input = document.querySelector("input") as HTMLInputElement;
+ expect(input.value).toBe("");
+ expect(input.placeholder).toBe("••••••••");
+ input.type = "text";
+ expect(input.value).toBe("");
+ input.value = "replacement-password";
+ input.dispatchEvent(new Event("input", { bubbles: true }));
+ await nextTick();
+ expect(input.value).toBe("replacement-password");
+ });
});
diff --git a/apps/desktop/src/lib/backend/api.ts b/apps/desktop/src/lib/backend/api.ts
index ce83242b46..1074ca0422 100644
--- a/apps/desktop/src/lib/backend/api.ts
+++ b/apps/desktop/src/lib/backend/api.ts
@@ -973,6 +973,7 @@ export const rotateMcpHttpServerToken = forward("rotateMcpHttpServerToken");
export const loadWebMcpHttpStatus = forward("loadWebMcpHttpStatus");
export const saveWebMcpHttpSettings = forward("saveWebMcpHttpSettings");
export const rotateWebMcpToken = forward("rotateWebMcpToken");
+export const loadWebCapabilities = forward("loadWebCapabilities");
export const checkForUpdates = forward("checkForUpdates");
export const fetchChangelog = forward("fetchChangelog");
export const getSystemProxyUrl = forward("getSystemProxyUrl");
@@ -1053,6 +1054,7 @@ export type {
McpHttpServerStatus,
WebMcpHttpStatus,
WebMcpHttpSettings,
+ WebCapabilities,
UpdateInfo,
DownloadedUpdate,
RedisBlob,
diff --git a/apps/desktop/src/lib/backend/http.ts b/apps/desktop/src/lib/backend/http.ts
index 6e93db1967..2e0145a070 100644
--- a/apps/desktop/src/lib/backend/http.ts
+++ b/apps/desktop/src/lib/backend/http.ts
@@ -2380,6 +2380,10 @@ export async function rotateWebMcpToken(): Promise<import("@/lib/backend/tauri")
return res.json();
}
+export async function loadWebCapabilities(): Promise<import("@/lib/backend/tauri").WebCapabilities> {
+ return get("/api/app-settings/web-capabilities");
+}
+
export async function loadMaxAgentTurns(): Promise<number> {
return get("/api/app-settings/max-agent-turns");
}
diff --git a/apps/desktop/src/lib/backend/tauri.ts b/apps/desktop/src/lib/backend/tauri.ts
index 9ebf899fbd..292e9eb764 100644
--- a/apps/desktop/src/lib/backend/tauri.ts
+++ b/apps/desktop/src/lib/backend/tauri.ts
@@ -916,6 +916,10 @@ export interface WebMcpHttpSettings {
allowedOrigins: string[];
}
+export interface WebCapabilities {
+ passwordViewerEnabled: boolean;
+}
+
export async function loadMcpHttpServerSettings(): Promise<McpHttpServerSettings> {
return invoke("load_mcp_http_server_settings");
}
@@ -944,6 +948,10 @@ export async function rotateWebMcpToken(): Promise<WebMcpHttpStatus> {
throw new Error("Web MCP settings are available only in DBX Web");
}
+export async function loadWebCapabilities(): Promise<WebCapabilities> {
+ return { passwordViewerEnabled: true };
+}
+
export async function loadMaxAgentTurns(): Promise<number> {
return invoke("load_max_agent_turns");
}
diff --git a/apps/desktop/src/lib/connection/connectionPassword.ts b/apps/desktop/src/lib/connection/connectionPassword.ts
index 9296c72826..8d6ab92637 100644
--- a/apps/desktop/src/lib/connection/connectionPassword.ts
+++ b/apps/desktop/src/lib/connection/connectionPassword.ts
@@ -1,4 +1,5 @@
import type { ConnectionConfig, PluginFormField, PluginFormFieldValue } from "@/types/database";
+import { isSavedCredential } from "@/lib/security/passwordViewer";
import { pluginFieldIsRequired } from "@/lib/plugins/pluginFieldConditions";
type PasswordAuthenticationConfig = Pick<ConnectionConfig, "db_type" | "driver_profile" | "url_params">;
@@ -29,7 +30,7 @@ export function connectionUsesPasswordlessAuthentication(config: PasswordAuthent
}
export function connectionNeedsPasswordPrompt(config: ConnectionConfig): boolean {
- return config.save_password === false && !config.password && !connectionUsesPasswordlessAuthentication(config);
+ return config.save_password === false && (!config.password || isSavedCredential(config.password)) && !connectionUsesPasswordlessAuthentication(config);
}
/**
diff --git a/apps/desktop/src/lib/security/passwordViewer.ts b/apps/desktop/src/lib/security/passwordViewer.ts
new file mode 100644
index 0000000000..88629011ab
--- /dev/null
+++ b/apps/desktop/src/lib/security/passwordViewer.ts
@@ -0,0 +1,28 @@
+import { ref } from "vue";
+import * as api from "@/lib/backend/api";
+
+/** Whether the current backend allows the UI to reveal stored connection secrets. */
+export const passwordViewerEnabled = ref(true);
+
+let initialization: Promise<boolean> | null = null;
+
+export function initializePasswordViewerCapability(): Promise<boolean> {
+ if (!initialization) {
+ initialization = api
+ .loadWebCapabilities()
+ .then((capabilities) => {
+ passwordViewerEnabled.value = capabilities.passwordViewerEnabled !== false;
+ return passwordViewerEnabled.value;
+ })
+ .catch(() => {
+ passwordViewerEnabled.value = false;
+ initialization = null;
+ return false;
+ });
+ }
+ return initialization;
+}
+
+export function isSavedCredential(value: unknown): value is string {
+ return typeof value === "string" && value.startsWith("__DBX_SAVED_CREDENTIAL__:");
+}
diff --git a/apps/desktop/src/stores/connectionStore.ts b/apps/desktop/src/stores/connectionStore.ts
index 1a355c4cd5..1a7078d0e1 100644
--- a/apps/desktop/src/stores/connectionStore.ts
+++ b/apps/desktop/src/stores/connectionStore.ts
@@ -182,6 +182,7 @@ import { normalizeRedisKeyTemplates } from "@/lib/redis/redisKeyTemplates";
import { appendAgentDriverUpdateHint, connectionUsesSsh, hasAgentDriverUpdate, hasInstalledAgentVersion, type AgentDriverInstallState } from "@/lib/connection/agentDriverInstallHint";
import { appendConnectionErrorHints, isMysqlMissingPasswordFailure, isSqliteMissingEncryptionPasswordFailure } from "@/lib/connection/connectionErrorHints";
import { connectionNeedsPasswordPrompt, pluginConnectionNeedsPasswordPrompt } from "@/lib/connection/connectionPassword";
+import { isSavedCredential } from "@/lib/security/passwordViewer";
import { createFrontendPluginRegistry } from "@/lib/plugins/frontendPlugin";
import { appendVisibleDatabaseSelection } from "@/lib/connection/connectionVisibleDatabases";
import { buildXuguTypeMemberNodes, isXuguTypeMemberContainer } from "@/lib/sidebar/xuguTypeMembers";
@@ -4601,7 +4602,7 @@ export const useConnectionStore = defineStore("connection", () => {
* after a successful connection when the user selects "remember password".
*/
async function ensureConnectionPassword(config: ConnectionConfig, force = false): Promise<{ config: ConnectionConfig; rememberPassword: boolean }> {
- if (!force && (config.save_password !== false || config.password)) return { config, rememberPassword: false };
+ if (!force && (config.save_password !== false || (config.password && !isSavedCredential(config.password)))) return { config, rememberPassword: false };
const { useConnectionPasswordPromptStore } = await import("@/stores/connectionPasswordPromptStore");
const result = await useConnectionPasswordPromptStore().requestPassword({
connectionId: config.id,
diff --git a/crates/dbx-core/src/persistence/storage.rs b/crates/dbx-core/src/persistence/storage.rs
index 777d07db24..0f10bc77e3 100644
--- a/crates/dbx-core/src/persistence/storage.rs
+++ b/crates/dbx-core/src/persistence/storage.rs
@@ -6509,7 +6509,8 @@ fn ensure_mcp_connection_change_allowed_in_tx(
Ok(())
}
-fn sanitized_connection_config(config: &ConnectionConfig) -> ConnectionConfig {
+/// Connection metadata with every field managed by the secret store removed.
+pub fn sanitized_connection_config(config: &ConnectionConfig) -> ConnectionConfig {
let mut sanitized = config.clone().canonicalized();
sanitized.password = String::new();
sanitized.url_params = None;
diff --git a/crates/dbx-web/src/credentials.rs b/crates/dbx-web/src/credentials.rs
new file mode 100644
index 0000000000..5a5360544c
--- /dev/null
+++ b/crates/dbx-web/src/credentials.rs
@@ -0,0 +1,592 @@
+//! Public connection configs contain references, never saved credential values.
+use std::collections::HashMap;
+
+use base64::{engine::general_purpose::URL_SAFE_NO_PAD, Engine};
+use dbx_core::models::connection::{ConnectionConfig, TransportLayerConfig};
+use serde_json::Value;
+
+use crate::{error::AppError, state::WebState};
+
+const REFERENCE_PREFIX: &str = "__DBX_SAVED_CREDENTIAL__:";
+const TUNNEL_PROFILE_PREFIX: &str = "__dbx_tunnel_profile__:";
+
+fn child_path(path: &str, key: &str) -> String {
+ format!("{path}/{}", key.replace('~', "~0").replace('/', "~1"))
+}
+
+fn reference(id: &str, path: &str) -> String {
+ format!("{REFERENCE_PREFIX}{}", URL_SAFE_NO_PAD.encode(serde_json::to_vec(&(id, path)).unwrap()))
+}
+
+fn sensitive_key(key: &str) -> bool {
+ let key = key.to_ascii_lowercase().replace(['_', '-'], "");
+ key.contains("password")
+ || key.contains("passphrase")
+ || key.contains("token")
+ || key.contains("secret")
+ || key.contains("apikey")
+ || key == "privatekey"
+}
+
+fn redact_value(value: &mut Value, sanitized: Option<&Value>, id: &str, path: &str) {
+ match value {
+ Value::Object(fields) => {
+ for (key, value) in fields {
+ redact_value(value, sanitized.and_then(|v| v.get(key)), id, &child_path(path, key));
+ }
+ }
+ Value::Array(values) => {
+ for (index, value) in values.iter_mut().enumerate() {
+ redact_value(value, sanitized.and_then(|v| v.get(index)), id, &child_path(path, &index.to_string()));
+ }
+ }
+ Value::String(text)
+ if !text.is_empty()
+ && (sensitive_key(path.rsplit('/').next().unwrap_or_default())
+ || sanitized != Some(&Value::String(text.clone()))) =>
+ {
+ *text = reference(id, path);
+ }
+ _ => {}
+ }
+}
+
+pub fn redact(config: &ConnectionConfig) -> ConnectionConfig {
+ let mut value = serde_json::to_value(config).expect("serialize connection");
+ let sanitized = serde_json::to_value(dbx_core::storage::sanitized_connection_config(config))
+ .expect("serialize sanitized connection");
+ redact_value(&mut value, Some(&sanitized), &config.id, "");
+ serde_json::from_value(value).expect("deserialize redacted connection")
+}
+
+pub fn contains_reference(value: &Value) -> bool {
+ match value {
+ Value::String(text) => text.starts_with(REFERENCE_PREFIX),
+ Value::Object(fields) => fields.values().any(contains_reference),
+ Value::Array(values) => values.iter().any(contains_reference),
+ _ => false,
+ }
+}
+
+fn restore_value(
+ value: &mut Value,
+ path: &str,
+ saved: &HashMap<String, ConnectionConfig>,
+ used: &mut Vec<String>,
+) -> Result<(), AppError> {
+ match value {
+ Value::Object(fields) => {
+ for (key, value) in fields {
+ restore_value(value, &child_path(path, key), saved, used)?;
+ }
+ }
+ Value::Array(values) => {
+ for (index, value) in values.iter_mut().enumerate() {
+ restore_value(value, &child_path(path, &index.to_string()), saved, used)?;
+ }
+ }
+ Value::String(text) if text.starts_with(REFERENCE_PREFIX) => {
+ let invalid =
+ || AppError::bad_request("Saved credential reference is no longer valid. Reload the connections.");
+ let bytes = URL_SAFE_NO_PAD.decode(&text[REFERENCE_PREFIX.len()..]).map_err(|_| invalid())?;
+ let (id, original_path): (String, String) = serde_json::from_slice(&bytes).map_err(|_| invalid())?;
+ let shared_tunnel = id.starts_with(TUNNEL_PROFILE_PREFIX)
+ && original_path.starts_with("/transport_layers/0/")
+ && path.starts_with("/transport_layers/")
+ && original_path.rsplit('/').next() == path.rsplit('/').next();
+ if original_path != path && !shared_tunnel {
+ return Err(invalid());
+ }
+ let config = saved.get(&id).ok_or_else(invalid)?;
+ if id.starts_with(TUNNEL_PROFILE_PREFIX)
+ && (!shared_tunnel
+ || !config.host.is_empty()
+ || !config.password.is_empty()
+ || config.transport_layers.len() != 1)
+ {
+ return Err(invalid());
+ }
+ let redacted = serde_json::to_value(redact(config)).map_err(|_| invalid())?;
+ // References cannot be moved into a note, host, or another credential field.
+ if redacted.pointer(&original_path) != Some(&Value::String(text.clone())) {
+ return Err(invalid());
+ }
+ *value = serde_json::to_value(config)
+ .map_err(|_| invalid())?
+ .pointer(&original_path)
+ .cloned()
+ .ok_or_else(invalid)?;
+ if !used.contains(&id) {
+ used.push(id);
+ }
+ }
+ _ => {}
+ }
+ Ok(())
+}
+
+fn credential_target(config: &ConnectionConfig) -> Value {
+ let mut value = serde_json::to_value(dbx_core::storage::sanitized_connection_config(config)).unwrap();
+ fn scrub(value: &mut Value) {
+ match value {
+ Value::Object(fields) => {
+ for (key, value) in fields {
+ if sensitive_key(key) && value.is_string() {
+ *value = Value::String(String::new());
+ } else {
+ scrub(value);
+ }
+ }
+ }
+ Value::Array(values) => values.iter_mut().for_each(scrub),
+ _ => {}
+ }
+ }
+ scrub(&mut value);
+ let fields = value.as_object_mut().unwrap();
+ for key in [
+ "id",
+ "name",
+ "note",
+ "driver_label",
+ "database",
+ "default_schema",
+ "visible_databases",
+ "visible_database_patterns",
+ "visible_schemas",
+ "show_system_schemas",
+ "color",
+ "docs_notes_path",
+ "connect_timeout_secs",
+ "query_timeout_secs",
+ "idle_timeout_secs",
+ "keepalive_interval_secs",
+ "redis_key_separator",
+ "redis_scan_page_size",
+ "redis_database_aliases",
+ "redis_key_templates",
+ "redis_key_grouping",
+ "one_time",
+ "save_password",
+ "read_only",
+ "is_production",
+ "production_databases",
+ "database_info",
+ ] {
+ fields.remove(key);
+ }
+ // URLs and scripts can redirect or disclose credentials, so changes to these
+ // fields require new credentials rather than silently reusing saved secrets.
+ for (key, value) in [
+ ("connection_string", &config.connection_string),
+ ("url_params", &config.url_params),
+ ("init_script", &config.init_script),
+ ] {
+ fields.insert(key.into(), serde_json::to_value(value.as_deref().filter(|value| !value.is_empty())).unwrap());
+ }
+ if let Some(external) = fields.get_mut("external_config").and_then(Value::as_object_mut) {
+ for key in ["managedNamespaces", "managed_namespaces"] {
+ external.remove(key);
+ }
+ }
+ value
+}
+
+pub fn restore(
+ config: ConnectionConfig,
+ saved: &HashMap<String, ConnectionConfig>,
+) -> Result<ConnectionConfig, AppError> {
+ let mut value = serde_json::to_value(&config).map_err(|e| AppError::from(e.to_string()))?;
+ if !contains_reference(&value) {
+ return Ok(config);
+ }
+ let mut used = Vec::new();
+ restore_value(&mut value, "", saved, &mut used)?;
+ let mut restored: ConnectionConfig = serde_json::from_value(value).map_err(|e| AppError::from(e.to_string()))?;
+ for id in used {
+ if id.starts_with(TUNNEL_PROFILE_PREFIX) {
+ let expected = &saved[&id].transport_layers[0];
+ let mut original_value = serde_json::to_value(&config).unwrap();
+ for (index, layer) in restored.transport_layers.iter().enumerate() {
+ let source = original_value["transport_layers"][index].take();
+ // Only compare layers that actually reference this saved profile.
+ if contains_tunnel_reference(&source, &id) && tunnel_target(layer) != tunnel_target(expected) {
+ return Err(AppError::forbidden(
+ "Saved tunnel credentials cannot be used with a different tunnel target.",
+ ));
+ }
+ }
+ } else if credential_target(&restored) != credential_target(&saved[&id]) {
+ return Err(AppError::forbidden("Saved credentials cannot be used with a different connection target. Enter replacement credentials to change the target."));
+ }
+ }
+ if !config.save_password {
+ // Unchecking Save password removes primary saved credentials. Transport
+ // and other independently persisted secrets keep their normal behavior.
+ restored.password = if config.password.starts_with(REFERENCE_PREFIX) { String::new() } else { config.password };
+ if restored.db_type == dbx_core::models::connection::DatabaseType::Nacos {
+ if let Some(external) = restored.external_config.as_mut().and_then(Value::as_object_mut) {
+ for key in ["auth", "rnacosConsoleAuth", "rnacos_console_auth"] {
+ if let Some(auth) = external.get_mut(key).and_then(Value::as_object_mut) {
+ let original = config
+ .external_config
+ .as_ref()
+ .and_then(|v| v.get(key))
+ .and_then(|v| v.get("password"))
+ .and_then(Value::as_str);
+ if original.is_some_and(|value| value.starts_with(REFERENCE_PREFIX)) {
+ auth.insert("password".into(), Value::String(String::new()));
+ }
+ }
+ }
+ }
+ }
+ }
+ Ok(restored)
+}
+
+fn contains_tunnel_reference(value: &Value, id: &str) -> bool {
+ match value {
+ Value::Object(fields) => fields.values().any(|value| contains_tunnel_reference(value, id)),
+ Value::Array(values) => values.iter().any(|value| contains_tunnel_reference(value, id)),
+ Value::String(text) if text.starts_with(REFERENCE_PREFIX) => URL_SAFE_NO_PAD
+ .decode(&text[REFERENCE_PREFIX.len()..])
+ .ok()
+ .and_then(|bytes| serde_json::from_slice::<(String, String)>(&bytes).ok())
+ .is_some_and(|(source_id, _)| source_id == id),
+ _ => false,
+ }
+}
+
+fn tunnel_target(layer: &TransportLayerConfig) -> Value {
+ let mut config = tunnel_connection(layer.clone());
+ for layer in &mut config.transport_layers {
+ match layer {
+ TransportLayerConfig::Ssh(layer) => {
+ layer.id.clear();
+ layer.profile_id.clear();
+ }
+ TransportLayerConfig::Proxy(layer) => {
+ layer.id.clear();
+ layer.profile_id.clear();
+ }
+ TransportLayerConfig::HttpTunnel(layer) => {
+ layer.id.clear();
+ layer.profile_id.clear();
+ }
+ }
+ }
+ credential_target(&config)
+}
+
+fn tunnel_connection(profile: TransportLayerConfig) -> ConnectionConfig {
+ serde_json::from_value(serde_json::json!({
+ "id": format!("{TUNNEL_PROFILE_PREFIX}{}", profile.id()), "name": "", "db_type": "mysql", "host": "", "port": 0,
+ "username": "", "password": "", "transport_layers": [profile]
+ }))
+ .expect("valid tunnel credential envelope")
+}
+
+pub fn redact_tunnel(profile: TransportLayerConfig) -> TransportLayerConfig {
+ redact(&tunnel_connection(profile)).transport_layers.remove(0)
+}
+
+impl WebState {
+ pub fn connection_response(&self, config: ConnectionConfig) -> ConnectionConfig {
+ if self.password_viewer_enabled {
+ config
+ } else {
+ redact(&config)
+ }
+ }
+
+ pub async fn resolve_connection_credentials(&self, config: ConnectionConfig) -> Result<ConnectionConfig, AppError> {
+ if !contains_reference(&serde_json::to_value(&config).unwrap()) {
+ return Ok(config);
+ }
+ let saved = self.saved_credential_configs().await?;
+ restore(config, &saved)
+ }
+
+ pub async fn saved_credential_configs(&self) -> Result<HashMap<String, ConnectionConfig>, AppError> {
+ let mut configs: HashMap<_, _> = self
+ .app
+ .storage
+ .load_connections()
+ .await
+ .map_err(AppError::from)?
+ .into_iter()
+ .map(|config| (config.id.clone(), config))
+ .collect();
+ configs.extend(
+ self.app
+ .storage
+ .load_tunnel_profiles()
+ .await
+ .map_err(AppError::from)?
+ .into_iter()
+ .map(tunnel_connection)
+ .map(|config| (config.id.clone(), config)),
+ );
+ Ok(configs)
+ }
+
+ pub async fn resolve_tunnel_credentials(
+ &self,
+ profile: TransportLayerConfig,
+ ) -> Result<TransportLayerConfig, AppError> {
+ if !contains_reference(&serde_json::to_value(&profile).unwrap()) {
+ return Ok(profile);
+ }
+ let saved = self
+ .app
+ .storage
+ .load_tunnel_profiles()
+ .await
+ .map_err(AppError::from)?
+ .into_iter()
+ .map(tunnel_connection)
+ .map(|config| (config.id.clone(), config))
+ .collect();
+ Ok(restore(tunnel_connection(profile), &saved)?.transport_layers.remove(0))
+ }
+
+ pub fn ensure_secret_export_allowed(&self, include_secrets: bool) -> Result<(), AppError> {
+ if include_secrets && !self.password_viewer_enabled {
+ return Err(AppError::forbidden("Credential export is disabled by DBX_DISABLE_PASSWORD_VIEWER"));
+ }
+ Ok(())
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::routes::connection::{self, ConnectRequest, SaveConnectionsRequest};
+ use axum::{extract::State, http::HeaderMap, Json};
+ use std::sync::Arc;
+
+ fn config() -> ConnectionConfig {
+ serde_json::from_value(serde_json::json!({
+ "id": "saved", "name": "Shared database", "db_type": "mysql", "driver_profile": "mysql",
+ "host": "db.internal", "port": 3306, "username": "app", "password": "database-secret",
+ "url_params": "trustStorePassword=trust-secret", "connection_secrets": {"custom": "plugin-secret"},
+ "transport_layers": [{"type": "ssh", "id": "ssh", "host": "gateway", "port": 22,
+ "user": "ssh-user", "password": "ssh-secret", "key_passphrase": "key-secret"}]
+ }))
+ .unwrap()
+ }
+
+ async fn web_state() -> (Arc<WebState>, tempfile::TempDir) {
+ let dir = tempfile::tempdir().unwrap();
+ let storage = dbx_core::persistence::test_storage::open(&dir.path().join("dbx.db")).await.unwrap();
+ let app = Arc::new(dbx_core::connection::AppState::new_with_plugin_dir(storage, dir.path().join("plugins")));
+ let mut state = WebState::for_tests(app, dir.path().to_path_buf());
+ state.password_viewer_enabled = false;
+ (Arc::new(state), dir)
+ }
+
+ #[test]
+ fn response_references_contain_no_secrets_and_restore_exact_credentials() {
+ let original = config();
+ let public = redact(&original);
+ let serialized = serde_json::to_string(&public).unwrap();
+ for secret in ["database-secret", "trust-secret", "ssh-secret", "key-secret", "plugin-secret"] {
+ assert!(!serialized.contains(secret));
+ }
+ let saved = HashMap::from([(original.id.clone(), original.clone())]);
+ assert_eq!(restore(public, &saved).unwrap(), original);
+ }
+
+ #[test]
+ fn target_changes_and_reference_substitution_are_rejected() {
+ let original = config();
+ let saved = HashMap::from([(original.id.clone(), original.clone())]);
+ for field in ["host", "username", "url_params", "init_script"] {
+ let mut value = serde_json::to_value(redact(&original)).unwrap();
+ value[field] = Value::String("attacker-controlled".into());
+ assert!(restore(serde_json::from_value(value).unwrap(), &saved).is_err(), "{field}");
+ }
+ let mut changed = redact(&original);
+ changed.note = changed.password.clone();
+ assert!(restore(changed, &saved).is_err());
+ let mut changed = redact(&original);
+ changed.password = reference(&original.id, "/host");
+ assert!(restore(changed, &saved).is_err());
+ assert!(restore(redact(&original), &HashMap::new()).is_err());
+ }
+
+ #[test]
+ fn draft_ids_metadata_and_password_replacement_remain_supported() {
+ let original = config();
+ let saved = HashMap::from([(original.id.clone(), original.clone())]);
+ let mut draft = redact(&original);
+ draft.id = "temporary-or-copy".into();
+ draft.name = "Renamed".into();
+ draft.database = Some("other".into());
+ assert_eq!(restore(draft.clone(), &saved).unwrap().password, original.password);
+ draft.password = "replacement".into();
+ assert_eq!(restore(draft, &saved).unwrap().password, "replacement");
+ let mut no_save = redact(&original);
+ no_save.save_password = false;
+ assert_eq!(restore(no_save, &saved).unwrap().password, "");
+ }
+
+ #[test]
+ fn empty_optional_form_fields_match_saved_null_values() {
+ let mut original = config();
+ original.url_params = None;
+ let saved = HashMap::from([(original.id.clone(), original.clone())]);
+ let mut form = redact(&original);
+ form.url_params = Some(String::new());
+ form.connection_string = Some(String::new());
+ form.init_script = Some(String::new());
+ assert_eq!(restore(form, &saved).unwrap().password, original.password);
+ }
+
+ #[test]
+ fn nested_auth_secrets_are_redacted() {
+ for (db_type, external) in [
+ (
+ "nacos",
+ serde_json::json!({"auth": {"kind": "usernamePassword", "username": "user", "password": "nested-secret"}}),
+ ),
+ ("mq", serde_json::json!({"auth": {"kind": "apiKey", "value": "nested-secret"}})),
+ ("mysql", serde_json::json!({"apiToken": "nested-secret"})),
+ ] {
+ let mut value = serde_json::to_value(config()).unwrap();
+ value["db_type"] = Value::String(db_type.into());
+ value["external_config"] = external;
+ let original: ConnectionConfig = serde_json::from_value(value).unwrap();
+ let public = redact(&original);
+ assert!(!serde_json::to_string(&public).unwrap().contains("nested-secret"));
+ let saved = HashMap::from([(original.id.clone(), original.clone())]);
+ assert_eq!(restore(public, &saved).unwrap(), original);
+ }
+ }
+
+ #[tokio::test]
+ async fn list_edit_replace_and_no_save_keep_correct_persisted_credentials() {
+ let (state, _dir) = web_state().await;
+ let original = config();
+ state.app.storage.save_connections(std::slice::from_ref(&original)).await.unwrap();
+ let Json(mut listed) = connection::load_connections(State(state.clone()), HeaderMap::new()).await.unwrap();
+ assert!(listed[0].password.starts_with(REFERENCE_PREFIX));
+ assert_eq!(state.app.configs.read().await[&original.id].password, original.password);
+ listed[0].name = "Renamed".into();
+ let _ = connection::save_connections(
+ State(state.clone()),
+ HeaderMap::new(),
+ Json(SaveConnectionsRequest { configs: listed.clone(), removed_ids: Vec::new() }),
+ )
+ .await
+ .unwrap();
+ assert_eq!(state.app.storage.load_connections().await.unwrap()[0].password, original.password);
+ listed[0].password = "replacement".into();
+ let _ = connection::save_connections(
+ State(state.clone()),
+ HeaderMap::new(),
+ Json(SaveConnectionsRequest { configs: listed.clone(), removed_ids: Vec::new() }),
+ )
+ .await
+ .unwrap();
+ assert_eq!(state.app.storage.load_connections().await.unwrap()[0].password, "replacement");
+ let Json(mut listed) = connection::load_connections(State(state.clone()), HeaderMap::new()).await.unwrap();
+ listed[0].save_password = false;
+ let _ = connection::save_connections(
+ State(state.clone()),
+ HeaderMap::new(),
+ Json(SaveConnectionsRequest { configs: listed, removed_ids: Vec::new() }),
+ )
+ .await
+ .unwrap();
+ assert_eq!(state.app.storage.get_secret(&original.id, "password").await.unwrap(), None);
+ assert!(state.ensure_secret_export_allowed(true).is_err());
+ assert!(state.ensure_secret_export_allowed(false).is_ok());
+ }
+
+ #[cfg(feature = "sqlite-sqlcipher")]
+ #[tokio::test]
+ async fn connect_and_test_use_server_held_password_including_temporary_drafts() {
+ let (state, dir) = web_state().await;
+ let path = dir.path().join("encrypted.sqlite").to_string_lossy().into_owned();
+ let handle =
+ dbx_core::db::sqlite::connect_path_create_if_missing_with_cipher_key(&path, "stored-key").await.unwrap();
+ handle
+ .with_connection(|db| db.execute_batch("CREATE TABLE proof (id INTEGER)").map_err(|e| e.to_string()))
+ .unwrap();
+ drop(handle);
+ let original: ConnectionConfig = serde_json::from_value(serde_json::json!({
+ "id": "encrypted", "name": "Encrypted SQLite", "db_type": "sqlite", "host": path, "port": 0,
+ "username": "", "password": "stored-key"
+ }))
+ .unwrap();
+ state.app.storage.save_connections(std::slice::from_ref(&original)).await.unwrap();
+ let browser = redact(&original);
+ let _ = connection::test_connection(
+ State(state.clone()),
+ Json(ConnectRequest { config: browser.clone(), client_attempt: None }),
+ )
+ .await
+ .unwrap();
+ let _ = connection::connect_db(
+ State(state.clone()),
+ HeaderMap::new(),
+ Json(ConnectRequest { config: browser.clone(), client_attempt: None }),
+ )
+ .await
+ .unwrap();
+ assert_eq!(state.app.configs.read().await[&original.id].password, "stored-key");
+ let mut draft = browser;
+ draft.id = "visible-db-preview".into();
+ draft.one_time = true;
+ let _ = connection::connect_db(
+ State(state.clone()),
+ HeaderMap::new(),
+ Json(ConnectRequest { config: draft, client_attempt: None }),
+ )
+ .await
+ .unwrap();
+ assert_eq!(state.app.configs.read().await["visible-db-preview"].password, "stored-key");
+ }
+
+ #[tokio::test]
+ async fn detached_shared_profile_refs_resolve_only_for_the_same_tunnel_endpoint() {
+ let (state, _dir) = web_state().await;
+ let profile = config().transport_layers.remove(0);
+ state.app.storage.save_tunnel_profiles(std::slice::from_ref(&profile)).await.unwrap();
+ let mut layer = redact_tunnel(profile.clone());
+ if let TransportLayerConfig::Ssh(layer) = &mut layer {
+ layer.id = "detached-copy".into();
+ }
+ let mut draft = config();
+ draft.password.clear();
+ draft.url_params = None;
+ draft.connection_secrets.clear();
+ draft.transport_layers = vec![layer];
+ let resolved = state.resolve_connection_credentials(draft.clone()).await.unwrap();
+ if let TransportLayerConfig::Ssh(layer) = &resolved.transport_layers[0] {
+ assert_eq!(layer.password, "ssh-secret");
+ }
+ if let TransportLayerConfig::Ssh(layer) = &mut draft.transport_layers[0] {
+ layer.host = "other-host".into();
+ }
+ assert!(state.resolve_connection_credentials(draft).await.is_err());
+ }
+
+ #[tokio::test]
+ async fn shared_tunnel_profiles_hide_and_preserve_passwords() {
+ let (state, _dir) = web_state().await;
+ let profile = config().transport_layers.remove(0);
+ state.app.storage.save_tunnel_profiles(std::slice::from_ref(&profile)).await.unwrap();
+ let Json(profiles) = crate::routes::tunnel_profiles::load_tunnel_profiles(State(state.clone())).await.unwrap();
+ assert!(!serde_json::to_string(&profiles).unwrap().contains("ssh-secret"));
+ let _ = crate::routes::tunnel_profiles::save_tunnel_profiles(
+ State(state.clone()),
+ Json(crate::routes::tunnel_profiles::SaveTunnelProfilesRequest { profiles }),
+ )
+ .await
+ .unwrap();
+ assert_eq!(state.app.storage.load_tunnel_profiles().await.unwrap()[0], profile);
+ }
+}
diff --git a/crates/dbx-web/src/main.rs b/crates/dbx-web/src/main.rs
index 0b3b419d02..882f2c6294 100644
--- a/crates/dbx-web/src/main.rs
+++ b/crates/dbx-web/src/main.rs
@@ -1,4 +1,5 @@
mod auth;
+mod credentials;
mod demo;
mod error;
mod routes;
@@ -144,6 +145,10 @@ fn web_compression_predicate() -> impl Predicate {
DefaultPredicate::new().and(NotForContentType::const_new(XLSX_CONTENT_TYPE))
}
+fn password_viewer_enabled_from_env(value: Option<&str>) -> bool {
+ !value.is_some_and(|value| matches!(value.trim().to_ascii_lowercase().as_str(), "1" | "true" | "yes" | "on"))
+}
+
fn web_body_limit_bytes() -> usize {
let value = std::env::var("DBX_MAX_UPLOAD_MB").ok();
web_body_limit_bytes_from_value(value.as_deref())
@@ -535,6 +540,8 @@ async fn serve() -> Result<(), String> {
let password_disabled = std::env::var("DBX_DISABLE_PASSWORD")
.map(|v| matches!(v.trim().to_lowercase().as_str(), "1" | "true" | "yes" | "on"))
.unwrap_or(false);
+ let password_viewer_enabled =
+ password_viewer_enabled_from_env(std::env::var("DBX_DISABLE_PASSWORD_VIEWER").ok().as_deref());
let password_hash = if password_disabled {
None
@@ -564,6 +571,7 @@ async fn serve() -> Result<(), String> {
public_base_path: public_base_path.clone(),
demo_mode,
password_disabled,
+ password_viewer_enabled,
password_hash: RwLock::new(password_hash),
sessions: RwLock::new(HashSet::new()),
sse_channels: RwLock::new(HashMap::new()),
@@ -1411,6 +1419,7 @@ async fn serve() -> Result<(), String> {
.route("/app-settings/mcp-http-status", get(routes::app_settings::load_web_mcp_http_status))
.route("/app-settings/mcp-http", put(routes::app_settings::save_web_mcp_http_settings))
.route("/app-settings/mcp-http/rotate-token", post(routes::app_settings::rotate_web_mcp_token))
+ .route("/app-settings/web-capabilities", get(routes::app_settings::load_web_capabilities))
.route(
"/app-settings/max-agent-turns",
get(routes::app_settings::load_max_agent_turns).put(routes::app_settings::save_max_agent_turns),
@@ -1535,6 +1544,9 @@ async fn serve() -> Result<(), String> {
} else if std::env::var("DBX_PASSWORD").is_ok() {
tracing::info!("Password protection is enabled");
}
+ if !password_viewer_enabled {
+ tracing::info!("Saved connection password viewing is disabled");
+ }
if demo_mode {
tracing::info!("Demo mode is enabled: connection/plugin/AI mutations are blocked");
}
@@ -1620,8 +1632,8 @@ async fn serve() -> Result<(), String> {
#[cfg(test)]
mod tests {
use super::{
- mount_static_assets, normalize_public_base_path, web_agent_dir_from_env, web_body_limit_bytes_from_value,
- web_compression_predicate, StaticSource, XLSX_CONTENT_TYPE,
+ mount_static_assets, normalize_public_base_path, password_viewer_enabled_from_env, web_agent_dir_from_env,
+ web_body_limit_bytes_from_value, web_compression_predicate, StaticSource, XLSX_CONTENT_TYPE,
};
use crate::routes::table_import;
use axum::body::Body;
@@ -1692,6 +1704,15 @@ mod tests {
assert_eq!(normalize_public_base_path(Some("/".to_string())), "/");
}
+ #[test]
+ fn password_viewer_enabled_defaults_to_true_and_accepts_truthy_disable_values() {
+ assert!(password_viewer_enabled_from_env(None));
+ assert!(password_viewer_enabled_from_env(Some("false")));
+ for value in ["1", "true", "yes", "on", " TRUE "] {
+ assert!(!password_viewer_enabled_from_env(Some(value)), "{value}");
+ }
+ }
+
#[test]
fn normalize_public_base_path_trims_and_preserves_segments() {
assert_eq!(normalize_public_base_path(Some("dbx".to_string())), "/dbx");
diff --git a/crates/dbx-web/src/routes/app_settings.rs b/crates/dbx-web/src/routes/app_settings.rs
index 6fd0ed9d62..0845a8eb40 100644
--- a/crates/dbx-web/src/routes/app_settings.rs
+++ b/crates/dbx-web/src/routes/app_settings.rs
@@ -69,6 +69,16 @@ pub async fn save_mcp_global_policy(
Ok(Json(()))
}
+#[derive(serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct WebCapabilities {
+ pub password_viewer_enabled: bool,
+}
+
+pub async fn load_web_capabilities(State(state): State<Arc<WebState>>) -> Json<WebCapabilities> {
+ Json(WebCapabilities { password_viewer_enabled: state.password_viewer_enabled })
+}
+
pub async fn load_web_mcp_http_status(State(state): State<Arc<WebState>>) -> impl IntoResponse {
let endpoint_path =
if state.public_base_path == "/" { "/mcp".to_string() } else { format!("{}/mcp", state.public_base_path) };
diff --git a/crates/dbx-web/src/routes/cloud_sync.rs b/crates/dbx-web/src/routes/cloud_sync.rs
index 766f69dc1d..50c0e987b4 100644
--- a/crates/dbx-web/src/routes/cloud_sync.rs
+++ b/crates/dbx-web/src/routes/cloud_sync.rs
@@ -221,6 +221,7 @@ pub async fn webdav_sync_upload(
State(state): State<Arc<WebState>>,
Json(mut req): Json<WebDavUploadRequest>,
) -> Result<Json<WebDavSyncSummary>, AppError> {
+ state.ensure_secret_export_allowed(req.include_secrets)?;
resolve_webdav_password(&state.app.storage, &mut req.config).await.map_err(AppError::from)?;
let explicit_passphrase = req.secrets_passphrase.as_deref().and_then(|value| {
let value = value.trim();
@@ -374,6 +375,7 @@ pub async fn snippet_sync_upload(
State(state): State<Arc<WebState>>,
Json(mut req): Json<SnippetUploadRequest>,
) -> Result<Json<SnippetSyncSummary>, AppError> {
+ state.ensure_secret_export_allowed(req.include_secrets)?;
resolve_snippet_token(&state.app.storage, &mut req.config).await.map_err(AppError::from)?;
let secrets_passphrase = if req.include_secrets {
Some(
diff --git a/crates/dbx-web/src/routes/connection.rs b/crates/dbx-web/src/routes/connection.rs
index c86cdaca86..72e2f955b3 100644
--- a/crates/dbx-web/src/routes/connection.rs
+++ b/crates/dbx-web/src/routes/connection.rs
@@ -389,7 +389,8 @@ pub async fn test_connection(
State(state): State<Arc<WebState>>,
Json(body): Json<ConnectRequest>,
) -> Result<Json<String>, AppError> {
- run_temporary_connection_test(&state.app, body.config, false)
+ let config = state.resolve_connection_credentials(body.config).await?;
+ run_temporary_connection_test(&state.app, config, false)
.await
.map(|result| Json(result.message))
.map_err(AppError::from)
@@ -399,14 +400,16 @@ pub async fn test_connection_with_info(
State(state): State<Arc<WebState>>,
Json(body): Json<ConnectRequest>,
) -> Result<Json<ConnectionTestResult>, AppError> {
- run_temporary_connection_test(&state.app, body.config, true).await.map(Json).map_err(AppError::from)
+ let config = state.resolve_connection_credentials(body.config).await?;
+ run_temporary_connection_test(&state.app, config, true).await.map(Json).map_err(AppError::from)
}
pub async fn test_ssh_tunnel(
State(state): State<Arc<WebState>>,
Json(body): Json<ConnectRequest>,
) -> Result<Json<String>, AppError> {
- state.app.test_connection_ssh_tunnel(&body.config.canonicalized()).await.map(Json).map_err(AppError::from)
+ let config = state.resolve_connection_credentials(body.config).await?;
+ state.app.test_connection_ssh_tunnel(&config.canonicalized()).await.map(Json).map_err(AppError::from)
}
pub async fn connect_db(
@@ -414,7 +417,7 @@ pub async fn connect_db(
headers: HeaderMap,
Json(body): Json<ConnectRequest>,
) -> Result<Json<String>, AppError> {
- let config = body.config;
+ let config = state.resolve_connection_credentials(body.config).await?;
// 演示模式:只允许连接已保存的连接,端点身份以存储为准,防止伪造 body
// 配置把服务器拨向任意主机(见 demo 模块)。
if state.demo_mode {
@@ -563,7 +566,7 @@ pub async fn connection_final_proxy_port(
headers: HeaderMap,
Json(body): Json<ConnectRequest>,
) -> Result<Json<u16>, AppError> {
- let runtime_config = body.config.canonicalized();
+ let runtime_config = state.resolve_connection_credentials(body.config).await?.canonicalized();
if !runtime_config.has_effective_transport_layers() {
return Err(AppError::from("Connection has no configured transport layers".to_string()));
}
@@ -769,7 +772,15 @@ pub async fn save_connections(
headers: HeaderMap,
Json(body): Json<SaveConnectionsRequest>,
) -> Result<Json<()>, AppError> {
- for config in &body.configs {
+ let mut configs = body.configs;
+ if configs.iter().any(|config| crate::credentials::contains_reference(&serde_json::to_value(config).unwrap())) {
+ let saved = state.saved_credential_configs().await?;
+ configs = configs
+ .into_iter()
+ .map(|config| crate::credentials::restore(config, &saved))
+ .collect::<Result<Vec<_>, AppError>>()?;
+ }
+ for config in &configs {
if config.db_type == dbx_core::models::connection::DatabaseType::Sqlite {
dbx_core::db::sqlite::validate_persistent_attachments(
&config.host,
@@ -782,9 +793,9 @@ pub async fn save_connections(
if !body.removed_ids.is_empty() {
state.app.storage.delete_connections(&body.removed_ids).await.map_err(AppError::from)?;
}
- state.app.storage.save_connections(&body.configs).await.map_err(AppError::from)?;
+ state.app.storage.save_connections(&configs).await.map_err(AppError::from)?;
let owner = session_token_from_headers(&headers).unwrap_or_default();
- let runtime_configs = body.configs.iter().cloned().map(prepare_runtime_config).collect::<Vec<_>>();
+ let runtime_configs = configs.iter().cloned().map(prepare_runtime_config).collect::<Vec<_>>();
// Saving is an upsert, so the request only describes the connections of this
// client. Sync the runtime cache against the whole persisted list instead of
// the request payload, otherwise a concurrent save from another client would
@@ -804,11 +815,12 @@ pub async fn mcp_add_connection(
State(state): State<Arc<WebState>>,
Json(body): Json<McpAddConnectionRequest>,
) -> Result<Json<ConnectionConfig>, AppError> {
- let saved = state.app.storage.add_connection_for_mcp(body.config).await.map_err(AppError::from)?;
+ let config = state.resolve_connection_credentials(body.config).await?;
+ let saved = state.app.storage.add_connection_for_mcp(config).await.map_err(AppError::from)?;
state.app.session_credentials.clear_connection(&saved.id);
state.app.remove_connection_pools_detached(&saved.id).await;
state.app.configs.write().await.insert(saved.id.clone(), saved.clone());
- Ok(Json(saved))
+ Ok(Json(state.connection_response(saved)))
}
pub async fn mcp_duplicate_connection(
@@ -824,7 +836,7 @@ pub async fn mcp_duplicate_connection(
state.app.session_credentials.clear_connection(&saved.id);
state.app.remove_connection_pools_detached(&saved.id).await;
state.app.configs.write().await.insert(saved.id.clone(), saved.clone());
- Ok(Json(saved))
+ Ok(Json(state.connection_response(saved)))
}
pub async fn mcp_remove_connection(
@@ -854,7 +866,7 @@ pub async fn load_connections(
remove_connection_pools_for_connection_ids(&state, &sync.connection_pool_ids_to_drop).await;
drop_nacos_adapters_for_connection_ids(&state, &sync.nacos_adapter_ids_to_drop).await;
drop_mq_adapters_for_connection_ids(&state, &sync.mq_adapter_ids_to_drop).await;
- Ok(Json(configs))
+ Ok(Json(configs.into_iter().map(|config| state.connection_response(config)).collect()))
}
struct ConnectionConfigSync {
diff --git a/crates/dbx-web/src/routes/mq.rs b/crates/dbx-web/src/routes/mq.rs
index ff6a900eb7..28cddd5832 100644
--- a/crates/dbx-web/src/routes/mq.rs
+++ b/crates/dbx-web/src/routes/mq.rs
@@ -1610,6 +1610,7 @@ mod tests {
notes_roots: Vec::new(),
public_base_path: "/".to_string(),
password_disabled: false,
+ password_viewer_enabled: true,
demo_mode: false,
password_hash: RwLock::new(None),
sessions: RwLock::new(HashSet::new()),
diff --git a/crates/dbx-web/src/routes/plugins.rs b/crates/dbx-web/src/routes/plugins.rs
index 3705956e92..3f8bb9e5e4 100644
--- a/crates/dbx-web/src/routes/plugins.rs
+++ b/crates/dbx-web/src/routes/plugins.rs
@@ -424,7 +424,8 @@ pub async fn invoke_plugin_connection_action(
State(state): State<Arc<WebState>>,
Json(body): Json<PluginConnectionActionRequest>,
) -> Result<Json<PluginConnectionActionResult>, AppError> {
- state.app.invoke_plugin_connection_action(body.config, &body.action_id).await.map(Json).map_err(AppError::from)
+ let config = state.resolve_connection_credentials(body.config).await?;
+ state.app.invoke_plugin_connection_action(config, &body.action_id).await.map(Json).map_err(AppError::from)
}
pub async fn notify_plugin(
diff --git a/crates/dbx-web/src/routes/tunnel_profiles.rs b/crates/dbx-web/src/routes/tunnel_profiles.rs
index 0515b4f6e8..0e824b8eac 100644
--- a/crates/dbx-web/src/routes/tunnel_profiles.rs
+++ b/crates/dbx-web/src/routes/tunnel_profiles.rs
@@ -17,19 +17,38 @@ pub struct SaveTunnelProfilesRequest {
pub async fn load_tunnel_profiles(
State(state): State<Arc<WebState>>,
) -> Result<Json<Vec<TransportLayerConfig>>, AppError> {
- state.app.storage.load_tunnel_profiles().await.map(Json).map_err(AppError::from)
+ let profiles = state.app.storage.load_tunnel_profiles().await.map_err(AppError::from)?;
+ Ok(Json(
+ profiles
+ .into_iter()
+ .map(
+ |profile| {
+ if state.password_viewer_enabled {
+ profile
+ } else {
+ crate::credentials::redact_tunnel(profile)
+ }
+ },
+ )
+ .collect(),
+ ))
}
pub async fn save_tunnel_profiles(
State(state): State<Arc<WebState>>,
Json(body): Json<SaveTunnelProfilesRequest>,
) -> Result<Json<()>, AppError> {
- state.app.storage.save_tunnel_profiles(&body.profiles).await.map(Json).map_err(AppError::from)
+ let mut profiles = Vec::with_capacity(body.profiles.len());
+ for profile in body.profiles {
+ profiles.push(state.resolve_tunnel_credentials(profile).await?);
+ }
+ state.app.storage.save_tunnel_profiles(&profiles).await.map(Json).map_err(AppError::from)
}
pub async fn test_tunnel_profile(
State(state): State<Arc<WebState>>,
Json(profile): Json<TransportLayerConfig>,
) -> Result<Json<String>, AppError> {
+ let profile = state.resolve_tunnel_credentials(profile).await?;
state.app.test_tunnel_profile(&profile).await.map(Json).map_err(AppError::from)
}
diff --git a/crates/dbx-web/src/state.rs b/crates/dbx-web/src/state.rs
index 38c5407baf..96e003d104 100644
--- a/crates/dbx-web/src/state.rs
+++ b/crates/dbx-web/src/state.rs
@@ -37,6 +37,8 @@ pub struct WebState {
pub notes_roots: Vec<PathBuf>,
pub public_base_path: String,
pub password_disabled: bool,
+ /// Whether the web UI may reveal saved connection passwords.
+ pub password_viewer_enabled: bool,
/// `DBX_DEMO_MODE`:公网演示部署的封锁开关(见 `demo` 模块)。
pub demo_mode: bool,
pub password_hash: RwLock<Option<String>>,
@@ -72,6 +74,7 @@ impl WebState {
notes_roots: Vec::new(),
public_base_path: "/".to_string(),
password_disabled: false,
+ password_viewer_enabled: true,
demo_mode: false,
password_hash: RwLock::new(None),
sessions: RwLock::new(HashSet::new()),
diff --git a/docs/content/docs/getting-started.cn.mdx b/docs/content/docs/getting-started.cn.mdx
index 60c7f41562..1638f303e5 100644
--- a/docs/content/docs/getting-started.cn.mdx
+++ b/docs/content/docs/getting-started.cn.mdx
@@ -102,10 +102,13 @@ description: 安装 DBX、创建第一个连接,并了解桌面版、Docker
| --- | --- | --- |
| `DBX_PASSWORD` | 未设置 | Web 登录密码,生产环境建议设置 |
| `DBX_DISABLE_PASSWORD` | `false` | 设为 `true` 或 `1` 可关闭登录保护 |
+ | `DBX_DISABLE_PASSWORD_VIEWER` | `false` | 设为 `true` 或 `1` 后,已保存连接凭据不返回浏览器,关闭密码查看、含密码复制及含凭据同步导出 |
| `DBX_DATA_DIR` | `/app/data` | 持久化数据目录 |
| `DBX_PORT` | `4224` | 容器内监听端口 |
| `DBX_PUBLIC_BASE_PATH` | `/` | 子路径部署,例如 `/dbx` |
+ 关闭密码查看后,已配置连接仍使用服务端保存的凭据。密码框显示固定占位符;不修改时保留原值,输入新值可替换原值。修改连接目标时不能复用隐藏的旧凭据,需要输入替换凭据。修改环境变量后请重启服务端并刷新浏览器。
+
启动后访问 `http://localhost:4224`。
`deploy/docker-compose.yml` 用于构建当前源码。若要部署已发布镜像,请使用 `deploy/docker-compose.release.yml`:
diff --git a/docs/content/docs/getting-started.mdx b/docs/content/docs/getting-started.mdx
index 2ff6698e27..2cd378d59e 100644
--- a/docs/content/docs/getting-started.mdx
+++ b/docs/content/docs/getting-started.mdx
@@ -102,10 +102,13 @@ This guide gets you through three things:
| --- | --- | --- |
| `DBX_PASSWORD` | Not set | Web login password; recommended for production |
| `DBX_DISABLE_PASSWORD` | `false` | Set to `true` or `1` to disable login protection |
+ | `DBX_DISABLE_PASSWORD_VIEWER` | `false` | Set to `true` or `1` to keep saved connection credentials on the server and disable password viewing, password-inclusive copying, and secret sync exports |
| `DBX_DATA_DIR` | `/app/data` | Persistent data directory |
| `DBX_PORT` | `4224` | Container listen port |
| `DBX_PUBLIC_BASE_PATH` | `/` | Deploy below a subpath, such as `/dbx` |
+ With password viewing disabled, existing connections continue to use credentials stored on the server. Password fields show a fixed placeholder; leaving them unchanged preserves the saved value, and entering a new value replaces it. Changing a connection target while reusing hidden credentials is rejected; enter replacement credentials instead. Restart the server and reload the browser after changing this variable.
+
Then open `http://localhost:4224`.
`deploy/docker-compose.yml` builds the current checkout. To deploy a published image, use `deploy/docker-compose.release.yml`: