The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:
TypeScript analyticsbibusiness-intelligencebusinessintelligenceclojuredashboarddatadata-analysisdata-visualizationdatabasemetabasemysqlpostgrespostgresqlreportingslacksql-editorvisualization
Track sensitive columns in query middleware (#83593)
Nathan Voxlanda6919714fd2e
diff --git a/.clj-kondo/config/modules/config.edn b/.clj-kondo/config/modules/config.ednindex 52249076383..0ded1266a8b 100644--- a/.clj-kondo/config/modules/config.edn+++ b/.clj-kondo/config/modules/config.edn@@ -2291,6 +2291,7 @@metabase.query-processor.reduciblemetabase.query-processor.result-serializationmetabase.query-processor.schema+ metabase.query-processor.sensitive-fieldsmetabase.query-processor.setupmetabase.query-processor.storemetabase.query-processor.streamingdiff --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.cljindex 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.cljindex 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.cljindex 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.cljnew file mode 100644index 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.cljnew file mode 100644index 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.cljindex 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 definitiondiff --git a/src/metabase/warehouse_schema/table.clj b/src/metabase/warehouse_schema/table.cljindex 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-responsediff --git a/test/metabase/queries_rest/api/card_test.clj b/test/metabase/queries_rest/api/card_test.cljindex 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.cljindex 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.cljindex 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.cljindex 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-tempdiff --git a/test/metabase/warehouse_schema_rest/api/table_test.clj b/test/metabase/warehouse_schema_rest/api/table_test.cljindex 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"