Skip to content

The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:

Track sensitive columns in query middleware (#83593)

Nathan Voxlanda6919714fd2e
diff --git a/.clj-kondo/config/modules/config.edn b/.clj-kondo/config/modules/config.edn
index 52249076383..0ded1266a8b 100644
--- a/.clj-kondo/config/modules/config.edn
+++ b/.clj-kondo/config/modules/config.edn
@@ -2291,6 +2291,7 @@
metabase.query-processor.reducible
metabase.query-processor.result-serialization
metabase.query-processor.schema
+ metabase.query-processor.sensitive-fields
metabase.query-processor.setup
metabase.query-processor.store
metabase.query-processor.streaming
diff --git a/enterprise/backend/test/metabase_enterprise/sandbox/query_processor/middleware/sandboxing_test.clj b/enterprise/backend/test/metabase_enterprise/sandbox/query_processor/middleware/sandboxing_test.clj
index 76e7f063a44..d0cb4d42517 100644
--- a/enterprise/backend/test/metabase_enterprise/sandbox/query_processor/middleware/sandboxing_test.clj
+++ b/enterprise/backend/test/metabase_enterprise/sandbox/query_processor/middleware/sandboxing_test.clj
@@ -350,6 +350,17 @@
(run-venues-count-query)))
(fails-without-token (run-venues-count-query))))))
+(deftest sandbox-on-sensitive-field-test
+ (testing "a sandbox can filter on a :sensitive column even though the sandboxed user can't reference it"
+ (tu/with-temp-vals-in-db :model/Field (mt/id :venues :price) {:visibility_type :sensitive}
+ (met/with-gtaps! {:gtaps {:venues (venues-price-mbql-gtap-def)}, :attributes {"price" 1}}
+ (is (= [[22]]
+ (run-venues-count-query)))
+ (is (thrown-with-msg?
+ clojure.lang.ExceptionInfo
+ #"not available for querying"
+ (qp/process-query (mt/mbql-query venues {:fields [$price]}))))))))
+
(deftest e2e-api-key-user-attributes-ignored-test
(testing (str "login_attributes stored on an API-key pseudo-user are not used for sandboxing (UXW-4240); the "
"query should fail with a missing-attribute error rather than using the stored attributes")
diff --git a/src/metabase/query_permissions/impl.clj b/src/metabase/query_permissions/impl.clj
index 0e62dc59164..dacfdcb0749 100644
--- a/src/metabase/query_permissions/impl.clj
+++ b/src/metabase/query_permissions/impl.clj
@@ -21,6 +21,7 @@
[metabase.query-processor.error-type :as qp.error-type]
[metabase.query-processor.interface :as qp.i]
[metabase.query-processor.preprocess :as qp.preprocess]
+ [metabase.query-processor.sensitive-fields :as qp.sensitive-fields]
;; legacy usage -- don't do things like this going forward
^{:clj-kondo/ignore [:deprecated-namespace :discouraged-namespace]} [metabase.query-processor.store :as qp.store]
[metabase.request.core :as request]
@@ -512,27 +513,36 @@
(mu/defn check-run-permissions-for-query
"Make sure the Current User has the appropriate permissions to run `query`. We don't want Users saving Cards with
- queries they wouldn't be allowed to run!"
- [query :- ::query]
- {:pre [(map? query)]}
- (let [query (dissoc query :query-permissions/perms)
- expanded (try
- (preprocess-query query)
- (catch Throwable _
- nil))
- query (or expanded query)
- expanded? (some? expanded)]
- (when-not (can-run-query? query expanded?)
- (let [required-perms (try
- (required-perms-for-query query :already-preprocessed? expanded? :throw-exceptions? true)
- (catch Throwable e
- e))]
- (throw (ex-info (tru "You cannot save this Question because you do not have permissions to run its query.")
- {:status-code 403
- :query query
- :required-perms (if (instance? Throwable required-perms)
- :error
- required-perms)
- :actual-perms @api/*current-user-permissions-set*}
- (when (instance? Throwable required-perms)
- required-perms)))))))
+ queries they wouldn't be allowed to run!
+
+ Also rejects queries that reference `:sensitive` columns, unless `allow-sensitive-fields?` is set because `query`
+ is saved content being restored rather than a new query."
+ ([query :- ::query]
+ (check-run-permissions-for-query query nil))
+ ([query :- ::query
+ {:keys [allow-sensitive-fields?]} :- [:maybe [:map {:closed true}
+ [:allow-sensitive-fields? {:optional true} :boolean]]]]
+ {:pre [(map? query)]}
+ (when-not allow-sensitive-fields?
+ (qp.sensitive-fields/check-query-can-be-saved! query))
+ (let [query (dissoc query :query-permissions/perms)
+ expanded (try
+ (preprocess-query query)
+ (catch Throwable _
+ nil))
+ query (or expanded query)
+ expanded? (some? expanded)]
+ (when-not (can-run-query? query expanded?)
+ (let [required-perms (try
+ (required-perms-for-query query :already-preprocessed? expanded? :throw-exceptions? true)
+ (catch Throwable e
+ e))]
+ (throw (ex-info (tru "You cannot save this Question because you do not have permissions to run its query.")
+ {:status-code 403
+ :query query
+ :required-perms (if (instance? Throwable required-perms)
+ :error
+ required-perms)
+ :actual-perms @api/*current-user-permissions-set*}
+ (when (instance? Throwable required-perms)
+ required-perms))))))))
diff --git a/src/metabase/query_processor.clj b/src/metabase/query_processor.clj
index b463e1db15a..789f727f721 100644
--- a/src/metabase/query_processor.clj
+++ b/src/metabase/query_processor.clj
@@ -17,6 +17,7 @@
[metabase.query-processor.middleware.catch-exceptions :as qp.catch-exceptions]
[metabase.query-processor.middleware.enterprise :as qp.middleware.enterprise]
[metabase.query-processor.middleware.process-userland-query :as qp.process-userland-query]
+ [metabase.query-processor.middleware.reject-sensitive-field-refs :as qp.reject-sensitive-field-refs]
[metabase.query-processor.postprocess :as qp.postprocess]
[metabase.query-processor.preprocess :as qp.preprocess]
[metabase.query-processor.reducible :as qp.reducible]
@@ -42,6 +43,7 @@
;;
;; ↓↓↓ POST-PROCESSING ↓↓↓ happens from TOP TO BOTTOM
[#'qp.middleware.enterprise/handle-audit-app-internal-queries-middleware
+ #'qp.reject-sensitive-field-refs/reject-sensitive-field-refs
#'qp.process-userland-query/process-userland-query-middleware
;; userland queries only: catch Exceptions and return a special error response
#'qp.catch-exceptions/catch-exceptions])
diff --git a/src/metabase/query_processor/middleware/reject_sensitive_field_refs.clj b/src/metabase/query_processor/middleware/reject_sensitive_field_refs.clj
new file mode 100644
index 00000000000..cd98b83f4a3
--- /dev/null
+++ b/src/metabase/query_processor/middleware/reject_sensitive_field_refs.clj
@@ -0,0 +1,25 @@
+(ns metabase.query-processor.middleware.reject-sensitive-field-refs
+ (:require
+ [metabase.api.common :as api]
+ [metabase.query-processor.middleware.normalize-query :as normalize]
+ [metabase.query-processor.middleware.permissions :as qp.perms]
+ [metabase.query-processor.sensitive-fields :as qp.sensitive-fields]))
+
+(defn- skip-check?
+ "Superusers can query anything, and queries with no user are run by Metabase itself. Saved cards and dashboard filter
+ values come from saved content."
+ []
+ (or api/*is-superuser?*
+ (nil? api/*current-user-id*)
+ qp.perms/*card-id*
+ qp.perms/*param-values-query*))
+
+(defn reject-sensitive-field-refs
+ "Around middleware. Throw if an ad-hoc query refers to a `:sensitive` column of a table. Runs before preprocessing
+ expands source cards, segments, and metrics, so only the parts of the query the user wrote are checked. (It can't be
+ a preprocessing middleware: those can't depend on [[qp.perms]].)"
+ [qp]
+ (fn [query rff]
+ (when-not (skip-check?)
+ (qp.sensitive-fields/check-query! (normalize/normalize-preprocessing-middleware query)))
+ (qp query rff)))
diff --git a/src/metabase/query_processor/sensitive_fields.clj b/src/metabase/query_processor/sensitive_fields.clj
new file mode 100644
index 00000000000..aba35daf593
--- /dev/null
+++ b/src/metabase/query_processor/sensitive_fields.clj
@@ -0,0 +1,74 @@
+(ns metabase.query-processor.sensitive-fields
+ "Columns an admin has marked \"Do not include\" (`visibility_type = :sensitive`) are left out of a table's returned
+ columns, so an explicit `:field` ref is the only way one can end up in a query. These checks reject such refs in
+ queries a non-admin writes themselves. Saved content (cards, segments, metrics, dashboard filters) is left alone:
+ whoever saved it decided what to share with the people who can see it."
+ (:require
+ [medley.core :as m]
+ [metabase.api.common :as api]
+ [metabase.lib.core :as lib]
+ [metabase.lib.field.resolution :as lib.field.resolution]
+ [metabase.lib.parameters :as lib.parameters]
+ [metabase.lib.util :as lib.util]
+ [metabase.lib.walk :as lib.walk]
+ [metabase.query-processor.error-type :as qp.error-type]
+ [metabase.query-processor.middleware.normalize-query :as normalize]
+ [metabase.query-processor.setup :as qp.setup]
+ [metabase.util.i18n :refer [tru]]))
+
+(defn- join-on-table? [query path join-alias]
+ (let [joins (lib.walk/apply-f-for-stage-at-path lib/joins query path)
+ join (m/find-first #(= (:alias %) join-alias) joins)]
+ (some? (:source-table (first (:stages join))))))
+
+(defn- read-from-table?
+ "Whether `col` comes straight from a table. Columns from native stages or saved cards were selected on purpose, and
+ MBQL stages never project a sensitive column for later stages to pick up."
+ [query path col]
+ (case (:lib/source col)
+ (:source/table-defaults :source/implicitly-joinable) true
+ :source/joins (join-on-table? query path (:lib/join-alias col))
+ false))
+
+(defn- check-field-ref [query path field-ref]
+ (let [col (lib.walk/apply-f-for-stage-at-path lib.field.resolution/resolve-field-ref query path field-ref)]
+ (when (and (= (:visibility-type col) :sensitive)
+ (read-from-table? query path col))
+ (throw (ex-info (tru "This query refers to a field that is not available for querying.")
+ {:type qp.error-type/invalid-query
+ :status-code 400
+ :field-id (:id col)
+ :field-name (:name col)
+ :table-id (:table-id col)
+ :log/keys #{:field-id :field-name :table-id}
+ ::sensitive-field true})))))
+
+(defn- check-parameters [query]
+ (doseq [{:keys [target]} (:parameters query)
+ :let [field-ref (lib.parameters/parameter-target-field-ref target)]
+ :when field-ref
+ :let [stage-number (lib.parameters/parameter-target-stage-number target)
+ stage-number (cond-> stage-number
+ (neg? stage-number) (+ (count (:stages query))))]]
+ (check-field-ref query [:stages stage-number] field-ref)))
+
+(defn check-query!
+ "Throw if `query`, a normalized MBQL 5 query, refers to a `:sensitive` column of a table."
+ [query]
+ (lib.walk/walk-clauses query (fn [query _path-type path clause]
+ (when (lib.util/field-clause? clause)
+ (check-field-ref query path clause))
+ nil))
+ (check-parameters query))
+
+(defn check-query-can-be-saved!
+ "Throw if the current user can't save `query` because it refers to a `:sensitive` column of a table."
+ [query]
+ (when-not api/*is-superuser?*
+ (try
+ (qp.setup/with-qp-setup [query query]
+ (check-query! (normalize/normalize-preprocessing-middleware query)))
+ ;; other problems with the query are left to the permissions check, which tolerates queries it can't preprocess
+ (catch clojure.lang.ExceptionInfo e
+ (when (::sensitive-field (ex-data e))
+ (throw e))))))
diff --git a/src/metabase/revisions/api.clj b/src/metabase/revisions/api.clj
index 99163ab0ab1..d8cab028523 100644
--- a/src/metabase/revisions/api.clj
+++ b/src/metabase/revisions/api.clj
@@ -125,7 +125,9 @@
(when (= model :model/Card)
;; TODO -- we should be using something like `api/read-check` for this, but unfortunately the impl for Cards
;; doesn't actually check important stuff like this.
- (query-perms/check-run-permissions-for-query (dissoc (get-in revision [:object :dataset_query]) :query-permissions/perms)))
+ ;; restoring saved content, so a reverted query may keep referencing columns marked "Do not include"
+ (query-perms/check-run-permissions-for-query (dissoc (get-in revision [:object :dataset_query]) :query-permissions/perms)
+ {:allow-sensitive-fields? true}))
(when (contains? #{:model/Transform :model/TransformTest} model)
(api/check-403 (mi/can-write? (merge instance (:object revision)))))
;; for Segments and Measures `table_id` is re-derived from `definition` on update, so when the restored definition
diff --git a/src/metabase/warehouse_schema/table.clj b/src/metabase/warehouse_schema/table.clj
index 7e3b16df833..58347b4736e 100644
--- a/src/metabase/warehouse_schema/table.clj
+++ b/src/metabase/warehouse_schema/table.clj
@@ -41,6 +41,11 @@
[table]
(mi/can-read? table))
+(defn- include-sensitive-fields-for?
+ "Sensitive fields are hidden from querying, so only list them for users who can edit the table's metadata."
+ [include-sensitive-fields? table]
+ (boolean (and include-sensitive-fields? (mi/can-write? table))))
+
(defn fetch-query-metadata*
"Returns the query metadata used to power the Query Builder for the given `table`. `include-sensitive-fields?`,
`include-hidden-fields?` and `include-editable-data-model?` can be either booleans or boolean strings."
@@ -49,9 +54,10 @@
(if include-editable-data-model?
(api/write-check table)
(api/check-403 (can-access-table-for-query-metadata? table)))
- (let [hydration-keys (cond-> [:db [:fields [:target :has_field_values] :has_field_values :dimensions :name_field]
- [:segments :definition_description] [:measures :definition_description] :metrics :collection]
- (premium-features/any-transforms-enabled?) (conj :transform))]
+ (let [include-sensitive-fields? (include-sensitive-fields-for? include-sensitive-fields? table)
+ hydration-keys (cond-> [:db [:fields [:target :has_field_values] :has_field_values :dimensions :name_field]
+ [:segments :definition_description] [:measures :definition_description] :metrics :collection]
+ (premium-features/any-transforms-enabled?) (conj :transform))]
(-> table
(update :collection nil-if-unreadable)
(#(apply t2/hydrate % hydration-keys))
@@ -67,7 +73,8 @@
(defn batch-fetch-query-metadatas*
"Returns the query metadata used to power the Query Builder for the `table`s specified by `ids`.
Options:
- - `include-sensitive-fields?` - if true, includes fields with visibility_type :sensitive (default false)"
+ - `include-sensitive-fields?` - if true, includes fields with visibility_type :sensitive for tables the current
+ user can write (default false)"
([ids]
(batch-fetch-query-metadatas* ids nil))
([ids {:keys [include-sensitive-fields?]}]
@@ -76,10 +83,11 @@
_ (perms/prime-table-perms-cache {:db-ids (into #{} (keep :db_id) tables)
:table-ids (into #{} (map :id) tables)})
tables (filter can-access-table-for-query-metadata? tables)
- tables (t2/hydrate tables [:fields [:target :has_field_values] :has_field_values :dimensions :name_field] :segments :measures :metrics)
- excluded-visibility-types (cond-> #{:hidden}
- (not include-sensitive-fields?) (conj :sensitive))]
- (for [table tables]
+ tables (t2/hydrate tables [:fields [:target :has_field_values] :has_field_values :dimensions :name_field] :segments :measures :metrics)]
+ (for [table tables
+ :let [excluded-visibility-types (cond-> #{:hidden}
+ (not (include-sensitive-fields-for? include-sensitive-fields? table))
+ (conj :sensitive))]]
(-> table
(m/dissoc-in [:db :details])
format-fields-for-response
diff --git a/test/metabase/queries_rest/api/card_test.clj b/test/metabase/queries_rest/api/card_test.clj
index 50523328cea..1e4033e7058 100644
--- a/test/metabase/queries_rest/api/card_test.clj
+++ b/test/metabase/queries_rest/api/card_test.clj
@@ -1602,6 +1602,62 @@
(is (= "You cannot save this Question because you do not have permissions to run its query."
body)))))))
+(deftest save-card-with-sensitive-field-test
+ (testing "non-admins can't save a query that references a :sensitive column (SEC-829)"
+ (let [sensitive-query (mt/mbql-query users {:fields [$id $password]})]
+ (mt/with-model-cleanup [:model/Card]
+ (testing "POST /api/card"
+ (let [body (mt/user-http-request :rasta :post 400 "card"
+ (card-with-name-and-query (mt/random-name) sensitive-query))]
+ (is (=? #".*not available for querying.*" body))
+ (testing "without naming the column"
+ (is (not (re-find #"(?i)password" (pr-str body))))))
+ (is (some? (mt/user-http-request :crowberto :post 200 "card"
+ (card-with-name-and-query (mt/random-name) sensitive-query))))))
+ (mt/with-temp [:model/Card card {:creator_id (mt/user->id :crowberto)
+ :dataset_query sensitive-query}]
+ (testing "PUT /api/card/:id without changing the query still works on a card an admin saved"
+ (is (=? {:name "Renamed"}
+ (mt/user-http-request :rasta :put 200 (format "card/%d" (:id card)) {:name "Renamed"}))))
+ (testing "PUT /api/card/:id changing the query to another one that references the column is rejected"
+ (is (=? #".*not available for querying.*"
+ (mt/user-http-request :rasta :put 400 (format "card/%d" (:id card))
+ {:dataset_query (mt/mbql-query users {:fields [$password]})})))))
+ (mt/with-temp [:model/Card card {:dataset_query (mt/mbql-query users)}]
+ (testing "PUT /api/card/:id adding the column to a query is rejected"
+ (is (=? #".*not available for querying.*"
+ (mt/user-http-request :rasta :put 400 (format "card/%d" (:id card))
+ {:dataset_query sensitive-query}))))))))
+
+(deftest sensitive-field-in-saved-content-test
+ (testing "content someone else saved that uses a :sensitive column keeps working for non-admins who can see it"
+ (mt/with-temp [:model/Card card {:creator_id (mt/user->id :crowberto)
+ :dataset_query (mt/mbql-query users
+ {:fields [$id $password]
+ :filter [:not-null $password]
+ :order-by [[:asc $id]]
+ :limit 1})}
+ :model/Segment segment {:table_id (mt/id :users)
+ :definition (mt/mbql-query users {:filter [:starts-with $password "4"]})}]
+ (testing "running the saved card"
+ (is (= [[1 "4be68cda-6fd5-4ba7-944e-2b475600bda5"]]
+ (mt/rows (mt/user-http-request :rasta :post 202 (format "card/%d/query" (:id card)))))))
+ (testing "an ad-hoc query built on top of the saved card"
+ (is (= [["4be68cda-6fd5-4ba7-944e-2b475600bda5"]]
+ (mt/rows (mt/user-http-request :rasta :post 202 "dataset"
+ {:database (mt/id)
+ :type :query
+ :query {:source-table (str "card__" (:id card))
+ :fields [[:field "PASSWORD" {:base-type :type/Text}]]}})))))
+ (testing "an ad-hoc query using a segment defined on the column"
+ (is (= [[1]]
+ (mt/rows (mt/user-http-request :rasta :post 202 "dataset"
+ (mt/mbql-query users
+ {:fields [$id]
+ :filter [:segment (:id segment)]
+ :order-by [[:asc $id]]
+ :limit 1})))))))))
+
(deftest create-card-parameter-permissions-generic-error-test
(testing "POST /api/card"
(testing "the 403 for a parameter field the user cannot query names neither the table nor its ids"
diff --git a/test/metabase/query_processor/api_test.clj b/test/metabase/query_processor/api_test.clj
index 262ea7a8560..334046121c1 100644
--- a/test/metabase/query_processor/api_test.clj
+++ b/test/metabase/query_processor/api_test.clj
@@ -1254,7 +1254,14 @@
:settings {:include_sensitive_fields true}))]
(is (some #(= (:id %) (mt/id :venues :price))
(->> result :tables (mapcat :fields)))
- "Sensitive field SHOULD be included when :settings :include-sensitive-fields is true"))))))
+ "Sensitive field SHOULD be included when :settings :include-sensitive-fields is true")))
+ (testing "sensitive fields are excluded for users who can't edit the table's metadata, even when requested"
+ (let [result (mt/user-http-request :rasta :post 200 "dataset/query_metadata"
+ (assoc (mt/mbql-query venues)
+ :settings {:include_sensitive_fields true}))]
+ (is (seq (->> result :tables (mapcat :fields))))
+ (is (not (some #(= (:id %) (mt/id :venues :price))
+ (->> result :tables (mapcat :fields))))))))))
(deftest native-form-requires-native-query-perms-test
(testing "POST /api/dataset only returns the compiled query in `:native_form` to users with native query perms"
diff --git a/test/metabase/query_processor/field_visibility_test.clj b/test/metabase/query_processor/field_visibility_test.clj
index 9f69b005cd8..ef45da70b19 100644
--- a/test/metabase/query_processor/field_visibility_test.clj
+++ b/test/metabase/query_processor/field_visibility_test.clj
@@ -63,6 +63,106 @@
(mt/run-mbql-query users
{:order-by [[:asc $id]]}))))))))
+(deftest ^:parallel sensitive-field-explicit-ref-test
+ (testing "an explicit :field ref to a :sensitive column is rejected, by ID and by name"
+ (mt/with-current-user (mt/user->id :rasta)
+ (doseq [[label field-ref] {"id ref" [:field (mt/id :users :password) nil]
+ "name ref" [:field "PASSWORD" {:base-type :type/Text}]}
+ [clause-label query] {":fields" (mt/mbql-query users {:fields [field-ref], :limit 1})
+ ":filter" (mt/mbql-query users {:fields [$id], :filter [:not-null field-ref], :limit 1})
+ ":breakout" (mt/mbql-query users {:breakout [field-ref], :aggregation [[:count]]})
+ ":order-by" (mt/mbql-query users {:fields [$id], :order-by [[:asc field-ref]], :limit 1})}]
+ (testing (str label " in " clause-label)
+ (is (thrown-with-msg?
+ clojure.lang.ExceptionInfo
+ #"not available for querying"
+ (qp/process-query query))))))
+ (testing "the error doesn't name the column, which an ID ref doesn't reveal"
+ (mt/with-current-user (mt/user->id :rasta)
+ (let [e (is (thrown? clojure.lang.ExceptionInfo
+ (qp/process-query
+ (mt/mbql-query users {:fields [[:field (mt/id :users :password) nil]], :limit 1}))))]
+ (is (not (re-find #"(?i)password" (ex-message e))))
+ (testing "but lists the column for the log, which the client doesn't get"
+ (is (=? {:field-id (mt/id :users :password)
+ :field-name "PASSWORD"
+ :table-id (mt/id :users)
+ :log/keys #{:field-id :field-name :table-id}}
+ (ex-data e)))))))
+ (testing "an implicitly joined :sensitive column is rejected"
+ (mt/with-current-user (mt/user->id :rasta)
+ (is (thrown-with-msg?
+ clojure.lang.ExceptionInfo
+ #"not available for querying"
+ (qp/process-query
+ (mt/mbql-query checkins {:fields [$user_id->users.password], :limit 1}))))))
+ (testing "an explicitly joined :sensitive column is rejected"
+ (mt/with-current-user (mt/user->id :rasta)
+ (is (thrown-with-msg?
+ clojure.lang.ExceptionInfo
+ #"not available for querying"
+ (qp/process-query
+ (mt/mbql-query checkins
+ {:joins [{:source-table $$users
+ :alias "u"
+ :condition [:= $user_id &u.users.id]
+ :fields [&u.users.password]}]
+ :limit 1}))))))
+ (testing "an explicitly joined :sensitive column referenced from the outer stage is rejected"
+ (mt/with-current-user (mt/user->id :rasta)
+ (doseq [[clause-label query]
+ {":fields" (mt/mbql-query checkins
+ {:joins [{:source-table $$users, :alias "u", :condition [:= $user_id &u.users.id], :fields :none}]
+ :fields [$id &u.users.password]
+ :limit 1})
+ ":filter" (mt/mbql-query checkins
+ {:joins [{:source-table $$users, :alias "u", :condition [:= $user_id &u.users.id], :fields :none}]
+ :fields [$id]
+ :filter [:starts-with &u.users.password "a"]
+ :limit 1})
+ ":order-by" (mt/mbql-query checkins
+ {:joins [{:source-table $$users, :alias "u", :condition [:= $user_id &u.users.id], :fields :none}]
+ :fields [$id]
+ :order-by [[:asc &u.users.password]]
+ :limit 1})}]
+ (testing clause-label
+ (is (thrown-with-msg?
+ clojure.lang.ExceptionInfo
+ #"not available for querying"
+ (qp/process-query query)))))))
+ (testing "an ad-hoc parameter targeting a :sensitive column is rejected"
+ (mt/with-current-user (mt/user->id :rasta)
+ (is (thrown-with-msg?
+ clojure.lang.ExceptionInfo
+ #"not available for querying"
+ (qp/process-query
+ (assoc (mt/mbql-query users {:fields [$id], :limit 1})
+ :parameters [{:type :string/starts-with
+ :value ["a"]
+ :target [:dimension [:field (mt/id :users :password) nil]]}]))))))
+ (testing "admins can still reference :sensitive columns"
+ (mt/with-current-user (mt/user->id :crowberto)
+ (is (= 1 (count (mt/rows (qp/process-query
+ (mt/mbql-query users {:fields [$password], :limit 1}))))))))))
+
+(deftest ^:parallel sensitive-field-mapped-native-model-test
+ (testing "a native model column mapped to a :sensitive field is still queryable, since the SQL selects it explicitly"
+ (let [mp0 (mt/metadata-provider)
+ mp1 (qp.test-util/metadata-provider-with-cards-with-metadata-for-queries
+ [(lib/native-query mp0 "SELECT ID, PASSWORD FROM USERS ORDER BY ID")])
+ mp (lib.tu/merged-mock-metadata-provider
+ mp1
+ {:cards [{:id 1
+ :type :model
+ :result-metadata (for [col (:result-metadata (lib.metadata/card mp1 1))]
+ (cond-> col
+ (= (:name col) "PASSWORD") (assoc :id (mt/id :users :password))))}]})]
+ (qp.store/with-metadata-provider mp
+ (mt/with-current-user (mt/user->id :rasta)
+ (is (= [[1 "4be68cda-6fd5-4ba7-944e-2b475600bda5"]]
+ (mt/rows (qp/process-query (-> (lib/query mp (lib.metadata/card mp 1))
+ (lib/limit 1)))))))))))
+
(deftest ^:parallel sensitive-field-hidden-in-model-query-test
(testing "a model whose stored result_metadata still lists a field made :sensitive after creation drops that column (#45919)"
(mt/test-drivers (mt/normal-drivers)
diff --git a/test/metabase/revisions/api_test.clj b/test/metabase/revisions/api_test.clj
index fa079d9bd63..2c0f0b1a476 100644
--- a/test/metabase/revisions/api_test.clj
+++ b/test/metabase/revisions/api_test.clj
@@ -304,6 +304,18 @@
(is (= "You don't have permissions to do that."
(mt/user-http-request :rasta :post "revision/revert" update-req))))))))
+(deftest revert-card-to-revision-with-sensitive-field-test
+ (testing "a non-admin can revert a card to a revision that references a :sensitive column (SEC-829)"
+ (mt/with-temp [:model/Card {card-id :id} {:creator_id (mt/user->id :crowberto)
+ :dataset_query (mt/mbql-query users {:fields [$id $password]})}]
+ (create-card-revision! card-id true :crowberto)
+ (t2/update! :model/Card :id card-id {:dataset_query (mt/mbql-query users {:fields [$id]})})
+ (create-card-revision! card-id false :crowberto)
+ (let [[_ {earlier-revision-id :id}] (revision/revisions :model/Card card-id)]
+ (mt/user-http-request :rasta :post 200 "revision/revert"
+ {:entity :card, :id card-id, :revision_id earlier-revision-id})
+ (is (= 2 (-> (t2/select-one :model/Card :id card-id) :dataset_query lib/fields count)))))))
+
(deftest dashboard-revision-description-test
(testing "revision description for dashboard are generated correctly"
(mt/with-temp
diff --git a/test/metabase/warehouse_schema_rest/api/table_test.clj b/test/metabase/warehouse_schema_rest/api/table_test.clj
index f6e13342d5f..2df05877702 100644
--- a/test/metabase/warehouse_schema_rest/api/table_test.clj
+++ b/test/metabase/warehouse_schema_rest/api/table_test.clj
@@ -260,7 +260,7 @@
(testing "GET api/table/:id/query_metadata?include_sensitive_fields"
(testing "Sensitive fields are included"
(is (= (merge
- (table-defaults)
+ (update (table-defaults) :db merge {:details nil, :write_data_details nil, :admin_details nil, :initial_sync_error nil})
(t2/hydrate (t2/select-one [:model/Table :created_at :updated_at :initial_sync_status :view_count]
:id (mt/id :users))
:collection)
@@ -337,9 +337,17 @@
:database_is_auto_increment false
:name_field nil)]
:id (mt/id :users)})
- (mt/user-http-request :rasta :get 200 (format "table/%d/query_metadata?include_sensitive_fields=true" (mt/id :users))))
+ (mt/user-http-request :crowberto :get 200 (format "table/%d/query_metadata?include_sensitive_fields=true" (mt/id :users))))
"Make sure that getting the User table *does* include info about the password field, but not actual values themselves")))))
+(deftest ^:parallel sensitive-fields-require-write-perms-test
+ (mt/with-premium-features #{}
+ (testing "GET api/table/:id/query_metadata?include_sensitive_fields ignores the flag for users who can't edit the table's metadata"
+ (is (= ["ID" "NAME" "LAST_LOGIN"]
+ (->> (mt/user-http-request :rasta :get 200 (format "table/%d/query_metadata?include_sensitive_fields=true" (mt/id :users)))
+ :fields
+ (map :name)))))))
+
(deftest ^:parallel sensitive-fields-not-included-test
(mt/with-premium-features #{}
(testing "GET api/table/:id/query_metadata"