Skip to content

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

feat: migration to new auth-identity module (#65716)

Edward Paget088a5354fc33
diff --git a/.clj-kondo/config/modules/config.edn b/.clj-kondo/config/modules/config.edn
index 705293695e7..fcec2323a92 100644
--- a/.clj-kondo/config/modules/config.edn
+++ b/.clj-kondo/config/modules/config.edn
@@ -196,6 +196,19 @@
task-history
util}}
+ auth-identity
+ {:team "UX West"
+ :api #{metabase.auth-identity.core
+ metabase.auth-identity.init}
+ :uses #{channel
+ events
+ login-history
+ models
+ notification
+ premium-features
+ request
+ util}}
+
auth-provider
{:team "UX West"
:api #{metabase.auth-provider.core}
@@ -316,14 +329,13 @@
:uses #{api
api-routes
app-db
+ auth-identity
classloader
config
-
models
query-processor
search
settings
- users
util}}
collections
@@ -756,6 +768,7 @@
:uses #{analytics
api
appearance
+ auth-identity
channel
config
dashboards
@@ -1167,20 +1180,18 @@
:api #{metabase.session.api
metabase.session.core
metabase.session.init
- metabase.session.models.session ; TODO -- shouldn't be exposed as an API namespace
metabase.session.settings} ; TODO -- shouldn't be exposed as an API namespace
:uses #{api
app-db
+ auth-identity
channel
config
events
- login-history
request
settings
sso
system
task
- users
util}}
settings
@@ -1213,13 +1224,12 @@
api
app-db
appearance
+ auth-identity
config
events
request
- session
settings
system
- users
util}}
sso
@@ -1228,11 +1238,11 @@
metabase.sso.core
metabase.sso.init}
:uses #{api
+ auth-identity
config
permissions
premium-features
settings
- users
util}}
startup
@@ -1377,7 +1387,6 @@
users
{:team "UX West"
:api #{metabase.users.api
- metabase.users.core
metabase.users.init
metabase.users.models.user
metabase.users.models.user-parameter-value
@@ -1385,6 +1394,7 @@
:uses #{analytics
api
appearance
+ auth-identity
batch-processing
channel
collections
@@ -1394,7 +1404,6 @@
permissions
premium-features
request
- session
settings
setup
sso
@@ -1644,6 +1653,11 @@
util
enterprise/serialization}}
+ enterprise/auth-identity
+ {:team "UX West"
+ :api #{}
+ :uses #{premium-features}}
+
enterprise/auth-provider
{:team "UX West"
:api #{}
@@ -2055,10 +2069,9 @@
metabase-enterprise.sso.settings}
:uses #{api
appearance
+ auth-identity
channel
embedding
- events
- notification
premium-features
request
session
diff --git a/enterprise/backend/src/metabase_enterprise/auth_identity/provider.clj b/enterprise/backend/src/metabase_enterprise/auth_identity/provider.clj
new file mode 100644
index 00000000000..0c90fa71f0e
--- /dev/null
+++ b/enterprise/backend/src/metabase_enterprise/auth_identity/provider.clj
@@ -0,0 +1,18 @@
+(ns metabase-enterprise.auth-identity.provider
+ "Enterprise extensions for the auth-identity provider system.
+ Adds support for login_attributes and jwt_attributes fields on User model."
+ (:require
+ [metabase.premium-features.core :refer [defenterprise] :as premium-features]))
+
+(defenterprise sso-user-fields
+ "Return the list of User model fields that should be populated from SSO user data.
+ Enterprise version includes login_attributes and jwt_attributes for storing SSO-specific attributes.
+
+ This uses feature none because we want the same behavior for multiple sso feature flags"
+ :feature :none
+ []
+ (cond-> [:email :first_name :last_name :sso_source]
+ (some premium-features/has-feature? [:sso-ldap :sso-jwt :sso-saml])
+ (conj :login_attributes)
+ (premium-features/has-feature? :sso-jwt)
+ (conj :jwt_attributes)))
diff --git a/enterprise/backend/src/metabase_enterprise/scim/v2/api.clj b/enterprise/backend/src/metabase_enterprise/scim/v2/api.clj
index c931dc206fe..f1c3f16c122 100644
--- a/enterprise/backend/src/metabase_enterprise/scim/v2/api.clj
+++ b/enterprise/backend/src/metabase_enterprise/scim/v2/api.clj
@@ -9,7 +9,6 @@
[metabase.api.macros :as api.macros]
[metabase.models.interface :as mi]
[metabase.permissions.core :as perms]
- [metabase.users.models.user :as user]
[metabase.users.schema :as users.schema]
[metabase.util :as u]
[metabase.util.i18n :as i18n]
@@ -251,7 +250,7 @@
(when (t2/exists? :model/User :%lower.email (u/lower-case-en email))
(throw-scim-error 409 "Email address is already in use"))
(let [new-user (t2/with-transaction [_]
- (user/insert-new-user! mb-user)
+ (t2/insert! :model/User mb-user)
(-> (t2/select-one (cons :model/User user-cols)
:email (u/lower-case-en email))
mb-user->scim))]
diff --git a/enterprise/backend/src/metabase_enterprise/serialization/v2/models.clj b/enterprise/backend/src/metabase_enterprise/serialization/v2/models.clj
index b52228553a8..702638b48f5 100644
--- a/enterprise/backend/src/metabase_enterprise/serialization/v2/models.clj
+++ b/enterprise/backend/src/metabase_enterprise/serialization/v2/models.clj
@@ -51,6 +51,7 @@
["ApiKey"
"ApplicationPermissionsRevision"
"AuditLog"
+ "AuthIdentity"
"BookmarkOrdering"
"CacheConfig"
"CardBookmark"
diff --git a/enterprise/backend/src/metabase_enterprise/sso/init.clj b/enterprise/backend/src/metabase_enterprise/sso/init.clj
index cb43af64d3a..511439aa6e7 100644
--- a/enterprise/backend/src/metabase_enterprise/sso/init.clj
+++ b/enterprise/backend/src/metabase_enterprise/sso/init.clj
@@ -1,4 +1,6 @@
(ns metabase-enterprise.sso.init
(:require
[metabase-enterprise.sso.integrations.google] ; has a `define-multi-setting` impl
+ [metabase-enterprise.sso.providers.jwt]
+ [metabase-enterprise.sso.providers.saml]
[metabase-enterprise.sso.settings]))
diff --git a/enterprise/backend/src/metabase_enterprise/sso/integrations/jwt.clj b/enterprise/backend/src/metabase_enterprise/sso/integrations/jwt.clj
index 0b74693ee35..c5df9314b58 100644
--- a/enterprise/backend/src/metabase_enterprise/sso/integrations/jwt.clj
+++ b/enterprise/backend/src/metabase_enterprise/sso/integrations/jwt.clj
@@ -1,119 +1,41 @@
(ns metabase-enterprise.sso.integrations.jwt
"Implementation of the JWT backend for sso"
(:require
- [buddy.sign.jwt :as jwt]
[clojure.string :as str]
[java-time.api :as t]
[metabase-enterprise.sso.api.interface :as sso.i]
[metabase-enterprise.sso.integrations.sso-utils :as sso-utils]
[metabase-enterprise.sso.integrations.token-utils :as token-utils]
[metabase-enterprise.sso.settings :as sso-settings]
+ [metabase.auth-identity.core :as auth-identity]
[metabase.embedding.settings :as embed.settings]
[metabase.embedding.util :as embed.util]
[metabase.premium-features.core :as premium-features]
[metabase.request.core :as request]
- [metabase.session.models.session :as session]
- [metabase.sso.core :as sso]
[metabase.util.i18n :refer [tru]]
- [ring.util.response :as response]
- [toucan2.core :as t2]))
+ [ring.util.response :as response]))
(set! *warn-on-reflection* true)
-(defn fetch-or-create-user!
- "Returns a session map for the given `email`. Will create the user if needed."
- [first-name last-name email user-attributes]
- (when-not (sso-settings/jwt-enabled)
- (throw
- (IllegalArgumentException.
- (str (tru "Can''t create new JWT user when JWT is not configured")))))
- (let [user {:first_name first-name
- :last_name last-name
- :email email
- :sso_source :jwt
- :jwt_attributes user-attributes}]
- (or (sso-utils/fetch-and-update-login-attributes! user (sso-settings/jwt-user-provisioning-enabled?))
- (sso-utils/check-user-provisioning :jwt)
- (sso-utils/create-new-sso-user! user))))
-
-(def ^:private ^{:arglists '([])} jwt-attribute-email
- (comp keyword sso-settings/jwt-attribute-email))
-
-(def ^:private ^{:arglists '([])} jwt-attribute-firstname
- (comp keyword sso-settings/jwt-attribute-firstname))
-
-(def ^:private ^{:arglists '([])} jwt-attribute-lastname
- (comp keyword sso-settings/jwt-attribute-lastname))
-
-(def ^:private ^{:arglists '([])} jwt-attribute-groups
- (comp keyword sso-settings/jwt-attribute-groups))
-
-(def ^:private registered-claims
- "Registered claims in the JWT standard which we should not interpret as login attributes"
- [:iss :iat :sub :aud :exp :nbf :jti])
-
-(defn- jwt-data->login-attributes [jwt-data]
- (sso-utils/filter-non-stringable-attributes
- (apply dissoc
- jwt-data
- (jwt-attribute-email)
- (jwt-attribute-firstname)
- (jwt-attribute-lastname)
- (jwt-attribute-groups)
- registered-claims)))
-
-;; JWTs use seconds since Epoch, not milliseconds since Epoch for the `iat` and `max_age` time. 3 minutes is the time
-;; used by Zendesk for their JWT SSO, so it seemed like a good place for us to start
-(def ^:private ^:const three-minutes-in-seconds 180)
-
-(defn- group-names->ids
- "Translate a user's group names to a set of MB group IDs using the configured mappings"
- [group-names]
- (if-let [name-mappings (not-empty (sso-settings/jwt-group-mappings))]
- (set
- (mapcat name-mappings
- (map keyword group-names)))
- (t2/select-pks-set :model/PermissionsGroup :name [:in group-names])))
-
-(defn- all-mapped-group-ids
- "Returns the set of all MB group IDs that have configured mappings"
- []
- (-> (sso-settings/jwt-group-mappings)
- vals
- flatten
- set))
-
-(defn- sync-groups!
- "Sync a user's groups based on mappings configured in the JWT settings"
- [user jwt-data]
- (when (sso-settings/jwt-group-sync)
- (when-let [groups-attribute (jwt-attribute-groups)]
- (when-let [group-names (get jwt-data groups-attribute)]
- (if (empty? (sso-settings/jwt-group-mappings))
- (sso/sync-group-memberships! user (group-names->ids group-names))
- (sso/sync-group-memberships! user
- (group-names->ids group-names)
- (all-mapped-group-ids)))))))
-
(defn- session-data
[jwt {{redirect :return_to} :params, :as request}]
- (let [redirect-url (or redirect "/")]
- (sso-utils/check-sso-redirect redirect-url)
- (let [jwt-data (try
- (jwt/unsign jwt (sso-settings/jwt-shared-secret)
- {:max-age three-minutes-in-seconds})
- (catch Throwable e
- (throw
- (ex-info (ex-message e)
- {:status-code 401}))))
- login-attrs (jwt-data->login-attributes jwt-data)
- email (get jwt-data (jwt-attribute-email))
- first-name (get jwt-data (jwt-attribute-firstname))
- last-name (get jwt-data (jwt-attribute-lastname))
- user (fetch-or-create-user! first-name last-name email login-attrs)
- session (session/create-session! :sso user (request/device-info request))]
- (sync-groups! user jwt-data)
- {:session session, :redirect-url redirect-url, :jwt-data jwt-data})))
+ (let [redirect-url (sso-utils/check-sso-redirect (or redirect "/"))
+ login-result (when jwt
+ (auth-identity/login! :provider/jwt
+ (assoc request
+ :token jwt
+ :redirect-url redirect-url
+ :device-info (request/device-info request))))]
+ (cond
+ (nil? login-result)
+ {:redirect-url redirect-url}
+ ;; Login succeeded
+ (:success? login-result)
+ (select-keys login-result [:session :redirect-url :jwt-data])
+
+ :else
+ (throw (ex-info (or (str (:message login-result)) "JWT authentication failed")
+ {:status-code 401})))))
(defn jwt->session
"Given a JWT, return a valid session token for the associated user (creating the user if necessary)."
@@ -153,20 +75,35 @@
(defmethod sso.i/sso-get :jwt
[{{:keys [jwt redirect]} :params, :as request}]
(premium-features/assert-has-feature :sso-jwt (tru "JWT-based authentication"))
- (let [jwt-data (when jwt (session-data jwt request))
+ (let [result (session-data jwt request)
is-react-sdk? (embed.util/has-react-sdk-header? request)
is-embedded-analytics-js? (embed.util/has-embedded-analytics-js-header? request)
is-modular-embedding? (or is-react-sdk? is-embedded-analytics-js?)]
(cond
- (and is-react-sdk? (not (embed.settings/enable-embedding-sdk))) (throw-react-sdk-embedding-disabled)
- (and is-embedded-analytics-js? (not (embed.settings/enable-embedding-simple))) (throw-simple-embedding-disabled)
- (and is-modular-embedding? jwt (token-utils/has-token request)) (generate-response-token (:session jwt-data) (:jwt-data jwt-data))
- is-modular-embedding? (response/response (token-utils/with-token {:url (sso-settings/jwt-identity-provider-uri) :method "jwt"}))
- jwt (request/set-session-cookies request
- (response/redirect (:redirect-url jwt-data))
- (:session jwt-data)
- (t/zoned-date-time (t/zone-id "GMT")))
- :else (redirect-to-idp (sso-settings/jwt-identity-provider-uri) redirect))))
+ ;; Embedding feature checks
+ (and is-react-sdk? (not (embed.settings/enable-embedding-sdk)))
+ (throw-react-sdk-embedding-disabled)
+
+ (and is-embedded-analytics-js? (not (embed.settings/enable-embedding-simple)))
+ (throw-simple-embedding-disabled)
+
+ (and is-modular-embedding? (token-utils/has-token request))
+ (generate-response-token (:session result) (:jwt-data result))
+
+ ;; JWT provided - use auth-identity/login!
+ jwt
+ (request/set-session-cookies request
+ (response/redirect (:redirect-url result))
+ (:session result)
+ (t/zoned-date-time (t/zone-id "GMT")))
+
+ ;; No JWT - return IdP URL for modular embedding or redirect
+ is-modular-embedding?
+ (response/response (token-utils/with-token {:url (sso-settings/jwt-identity-provider-uri)
+ :method "jwt"}))
+
+ :else
+ (redirect-to-idp (sso-settings/jwt-identity-provider-uri) redirect))))
(defmethod sso.i/sso-post :jwt
[_]
diff --git a/enterprise/backend/src/metabase_enterprise/sso/integrations/ldap.clj b/enterprise/backend/src/metabase_enterprise/sso/integrations/ldap.clj
index fdc9040f7b0..803862b44ed 100644
--- a/enterprise/backend/src/metabase_enterprise/sso/integrations/ldap.clj
+++ b/enterprise/backend/src/metabase_enterprise/sso/integrations/ldap.clj
@@ -3,11 +3,10 @@
(:require
[metabase-enterprise.sso.integrations.sso-utils :as sso-utils]
[metabase-enterprise.sso.settings :as ee.sso.settings]
- [metabase.premium-features.core :refer [defenterprise-schema]]
+ [metabase.premium-features.core :refer [defenterprise-schema defenterprise]]
[metabase.sso.core :as sso]
[metabase.util :as u]
- [metabase.util.malli.schema :as ms]
- [toucan2.core :as t2])
+ [metabase.util.malli.schema :as ms])
(:import
(com.unboundid.ldap.sdk LDAPConnectionPool)))
@@ -19,26 +18,6 @@
(when (ee.sso.settings/ldap-sync-user-attributes)
(apply dissoc m :objectclass (map (comp keyword u/lower-case-en) (ee.sso.settings/ldap-sync-user-attributes-blacklist)))))
-(defn- attribute-synced-user
- [{:keys [attributes first-name last-name email]}]
- (when-let [user (t2/select-one [:model/User :id :last_login :first_name :last_name :login_attributes :is_active]
- :%lower.email (u/lower-case-en email))]
- (let [syncable-attributes (syncable-user-attributes attributes)
- old-first-name (:first_name user)
- old-last-name (:last_name user)
- user-changes (merge
- (when-not (= syncable-attributes (:login_attributes user))
- {:login_attributes syncable-attributes})
- (when (not= first-name old-first-name)
- {:first_name first-name})
- (when (not= last-name old-last-name)
- {:last_name last-name}))]
- (if (seq user-changes)
- (do
- (t2/update! :model/User (:id user) user-changes)
- (t2/select-one [:model/User :id :last_login :is_active] :id (:id user))) ; Reload updated user
- user))))
-
(defenterprise-schema find-user :- [:maybe EEUserInfo]
"Get user information for the supplied username."
:feature :sso-ldap
@@ -53,24 +32,8 @@
(ee.sso.settings/ldap-group-membership-filter))]
(assoc user-info :attributes (syncable-user-attributes result)))))
-;;; for some reason the `:clj-kondo/ignore` doesn't work inside of [[defenterprise-schema]]
-#_{:clj-kondo/ignore [:deprecated-var]}
-(defenterprise-schema fetch-or-create-user! :- (ms/InstanceOf :model/User)
- "Using the `user-info` (from `find-user`) get the corresponding Metabase user, creating it if necessary."
+(defenterprise check-provision-ldap
+ "Throw if creating new users from ldap is disallowed."
:feature :sso-ldap
- [{:keys [first-name last-name email groups attributes], :as user-info} :- EEUserInfo
- {:keys [sync-groups?], :as settings} :- sso/LDAPSettings]
- (let [user (or (attribute-synced-user user-info)
- (sso-utils/check-user-provisioning :ldap)
- (-> (sso/create-new-ldap-auth-user! {:first_name first-name
- :last_name last-name
- :email email
- :login_attributes attributes})
- (assoc :is_active true)))]
- (u/prog1 user
- (when sync-groups?
- (let [group-ids (sso/ldap-groups->mb-group-ids groups settings)
- all-mapped-group-ids (sso/all-mapped-ldap-group-ids settings)]
- (sso/sync-group-memberships! user
- group-ids
- all-mapped-group-ids))))))
+ []
+ (sso-utils/check-user-provisioning :ldap))
diff --git a/enterprise/backend/src/metabase_enterprise/sso/integrations/saml.clj b/enterprise/backend/src/metabase_enterprise/sso/integrations/saml.clj
index e288e4dd520..0a88a4f15b9 100644
--- a/enterprise/backend/src/metabase_enterprise/sso/integrations/saml.clj
+++ b/enterprise/backend/src/metabase_enterprise/sso/integrations/saml.clj
@@ -31,80 +31,28 @@
(:require
[clojure.string :as str]
[java-time.api :as t]
- [medley.core :as m]
[metabase-enterprise.sso.api.interface :as sso.i]
[metabase-enterprise.sso.integrations.saml-utils :as saml-utils]
[metabase-enterprise.sso.integrations.sso-utils :as sso-utils]
[metabase-enterprise.sso.integrations.token-utils :as token-utils]
[metabase-enterprise.sso.settings :as sso-settings]
[metabase.api.common :as api]
+ [metabase.auth-identity.core :as auth-identity]
[metabase.channel.urls :as urls]
[metabase.embedding.util :as embed.util]
[metabase.premium-features.core :as premium-features]
[metabase.request.core :as request]
[metabase.session.core :as session]
- [metabase.sso.core :as sso]
[metabase.system.core :as system]
[metabase.util :as u]
[metabase.util.i18n :refer [trs tru]]
[metabase.util.log :as log]
- [metabase.util.malli :as mu]
- [metabase.util.malli.schema :as ms]
[ring.util.response :as response]
[saml20-clj.core :as saml]
[toucan2.core :as t2]))
(set! *warn-on-reflection* true)
-(defn- group-names->ids
- "Translate a user's group names to a set of MB group IDs using the configured mappings"
- [group-names]
- (->> (cond-> group-names (string? group-names) vector)
- (map keyword)
- (mapcat (sso-settings/saml-group-mappings))
- set))
-
-(defn- all-mapped-group-ids
- "Returns the set of all MB group IDs that have configured mappings"
- []
- (-> (sso-settings/saml-group-mappings)
- vals
- flatten
- set))
-
-(defn sync-groups!
- "Sync a user's groups based on mappings configured in the SAML settings"
- [user group-names]
- (when (sso-settings/saml-group-sync)
- (when group-names
- (sso/sync-group-memberships! user
- (group-names->ids group-names)
- (all-mapped-group-ids)))))
-
-(mu/defn- fetch-or-create-user! :- [:maybe [:map [:key ms/UUIDString]]]
- "Returns a Session for the given `email`. Will create the user if needed."
- [{:keys [first-name last-name email group-names user-attributes device-info]}]
- (when-not (sso-settings/saml-enabled)
- (throw (IllegalArgumentException. (tru "Can''t create new SAML user when SAML is not enabled"))))
- (when-not email
- (throw (ex-info (str (tru "Invalid SAML configuration: could not find user email.")
- " "
- (tru "We tried looking for {0}, but couldn''t find the attribute."
- (sso-settings/saml-attribute-email))
- " "
- (tru "Please make sure your SAML IdP is properly configured."))
- {:status-code 400, :user-attributes (keys user-attributes)})))
- (let [new-user {:first_name first-name
- :last_name last-name
- :email email
- :sso_source :saml
- :login_attributes user-attributes}]
- (when-let [user (or (sso-utils/fetch-and-update-login-attributes! new-user (sso-settings/saml-user-provisioning-enabled?))
- (sso-utils/check-user-provisioning :saml)
- (sso-utils/create-new-sso-user! new-user))]
- (sync-groups! user group-names)
- (session/create-session! :sso user device-info))))
-
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; SAML route supporting functions
@@ -167,52 +115,23 @@
embedding-sdk-header? (embed.util/is-modular-embedding-request? req)
redirect-url (construct-redirect-url req)]
(sso-utils/check-sso-redirect redirect)
- (try
- (let [idp-url (sso-settings/saml-identity-provider-uri)
- relay-state (u/encode-base64 redirect-url)
- response (saml/idp-redirect-response {:request-id (str "id-" (random-uuid))
- :sp-name (sso-settings/saml-application-name)
- :issuer (sso-settings/saml-application-name)
- :acs-url (acs-url)
- :idp-url idp-url
- :credential (sp-cert-keystore-details)
- :relay-state relay-state
- :protocol-binding :post})]
+ ;; Use provider/authenticate to generate SAML AuthnRequest
+ (let [auth-result (auth-identity/authenticate :provider/saml
+ (assoc req :redirect-url redirect-url))]
+ (cond
+ ;; Need redirect to IdP
+ (= :redirect (:success? auth-result))
(if embedding-sdk-header?
{:status 200
- :body {:url (get-in response [:headers "location"])
- :method "saml"}
+ :body {:url (:redirect-url auth-result)
+ :method "saml"}
:headers {"Content-Type" "application/json"}}
- response))
- (catch Throwable e
- (let [msg (trs "Error generating SAML request")]
- (log/error e msg)
- (throw (ex-info msg {:status-code 500} e)))))))
-
-(defn- idp-cert
- []
- (or (sso-settings/saml-identity-provider-certificate)
- (throw (ex-info (str (tru "Unable to log in: SAML IdP certificate is not set."))
- {:status-code 500}))))
+ (response/redirect (:redirect-url auth-result)))
-(defn- unwrap-user-attributes
- "For some reason all of the user attributes coming back from the saml library are wrapped in a list, instead of 'Oisin',
- it's ('Oisin'). This function discards the list if there's just a single item in it."
- [m]
- (m/map-vals (fn [maybe-coll]
- (if (and (coll? maybe-coll)
- (= 1 (count maybe-coll)))
- (first maybe-coll)
- maybe-coll))
- m))
-
-(defn- saml-response->attributes [saml-response]
- (let [assertions (saml/assertions saml-response)
- attrs (-> assertions first :attrs unwrap-user-attributes)]
- (when-not attrs
- (throw (ex-info (str (tru "Unable to log in: SAML info does not contain user attributes."))
- {:status-code 401})))
- attrs))
+ ;; Error
+ :else
+ (throw (ex-info (or (:message auth-result) (trs "SAML request generation failed"))
+ {:status-code 500}))))))
(defn- process-relay-state-params
"Process the RelayState to extract continue URL and related parameters"
@@ -264,38 +183,25 @@
(sso-utils/check-sso-redirect continue-url)
(try
- (let [saml-response (saml/validate-response request
- {:idp-cert (idp-cert)
- :sp-private-key (sp-cert-keystore-details)
- :acs-url (acs-url)
- ;; remove :in-response-to validation since we're not
- ;; tracking that in metabase
- :response-validators [:issuer
- :signature
- :require-authenticated]
- :assertion-validators [:signature
- :recipient
- :not-on-or-after
- :not-before
- :address
- :issuer]
- :issuer (sso-settings/saml-identity-provider-issuer)})
- attrs (saml-response->attributes saml-response)
- email (get attrs (sso-settings/saml-attribute-email))
- first-name (get attrs (sso-settings/saml-attribute-firstname))
- last-name (get attrs (sso-settings/saml-attribute-lastname))
- groups (get attrs (sso-settings/saml-attribute-group))
- session (fetch-or-create-user!
- {:first-name first-name
- :last-name last-name
- :email email
- :group-names groups
- :user-attributes (sso-utils/filter-non-stringable-attributes attrs)
- :device-info (request/device-info request)})
- response (response/redirect (or continue-url (system/site-url)))]
- (if token-value
- (saml-utils/create-token-response session origin clean-continue-url)
- (request/set-session-cookies request response session (t/zoned-date-time (t/zone-id "GMT")))))
+ (let [redirect-url (or continue-url (system/site-url))
+ login-result (auth-identity/login! :provider/saml
+ (assoc request
+ :redirect-url redirect-url
+ :device-info (request/device-info request)))]
+ (cond
+ ;; Login succeeded
+ (:success? login-result)
+ (if token-value
+ (saml-utils/create-token-response (:session login-result) origin clean-continue-url)
+ (request/set-session-cookies request
+ (response/redirect (:redirect-url login-result))
+ (:session login-result)
+ (t/zoned-date-time (t/zone-id "GMT"))))
+
+ ;; Login failed
+ :else
+ (throw (ex-info (or (str (:message login-result)) "SAML authentication failed")
+ {:status-code 401}))))
(catch Throwable e
(log/error e "SAML response validation failed")
(throw (ex-info (tru "Unable to log in: SAML response validation failed")
diff --git a/enterprise/backend/src/metabase_enterprise/sso/integrations/sso_utils.clj b/enterprise/backend/src/metabase_enterprise/sso/integrations/sso_utils.clj
index 12ad30c50fa..6f9a493642f 100644
--- a/enterprise/backend/src/metabase_enterprise/sso/integrations/sso_utils.clj
+++ b/enterprise/backend/src/metabase_enterprise/sso/integrations/sso_utils.clj
@@ -4,39 +4,20 @@
[metabase-enterprise.sso.settings :as sso-settings]
[metabase.api.common :as api]
[metabase.appearance.core :as appearance]
- [metabase.channel.email.messages :as messages]
- [metabase.events.core :as events]
- [metabase.notification.core :as notification]
- [metabase.sso.core :as sso]
[metabase.system.core :as system]
[metabase.util :as u]
[metabase.util.i18n :refer [trs tru]]
- [metabase.util.log :as log]
- [metabase.util.malli :as mu]
- [metabase.util.malli.schema :as ms]
- [toucan2.core :as t2])
+ [metabase.util.log :as log])
(:import
- (clojure.lang ExceptionInfo)
(java.net URI URISyntaxException)))
(set! *warn-on-reflection* true)
-(def ^:private UserAttributes
- [:map {:closed true}
- [:first_name [:maybe ms/NonBlankString]]
- [:last_name [:maybe ms/NonBlankString]]
- [:email ms/Email]
- ;; TODO - we should avoid hardcoding this to make it easier to add new integrations. Maybe look at something like
- ;; the keys of `(methods sso/sso-get)`
- [:sso_source [:enum :saml :jwt]]
- [:login_attributes {:optional true} [:maybe :map]]
- [:jwt_attributes {:optional true} [:maybe :map]]])
-
(defn- maybe-throw-user-provisioning
[user-provisioning-type]
(when (not user-provisioning-type)
(throw (ex-info (trs "Sorry, but you''ll need a {0} account to view this page. Please contact your administrator."
- (u/slugify (appearance/site-name))) {}))))
+ (u/slugify (appearance/site-name))) {:status-code 401}))))
(defmulti check-user-provisioning
"If `user-provisioning-enabled?` is false, then we should throw an error when attempting to create a new user."
@@ -55,49 +36,6 @@
[_]
(maybe-throw-user-provisioning (sso-settings/jwt-user-provisioning-enabled?)))
-(mu/defn create-new-sso-user!
- "This function is basically the same thing as the `create-new-google-auth-user` from `metabase.users.models.user`. We need
- to refactor the `core_user` table structure and the function used to populate it so that the enterprise product can
- reuse it."
- [user :- UserAttributes]
- (try
- (u/prog1 (t2/insert-returning-instance! :model/User (merge user {:password (str (random-uuid))}))
- (log/infof "New SSO user created: %s (%s)" (:common_name <>) (:email <>))
- ;; publish user-invited event for audit logging
- ;; skip sending user invited emails for sso users
- (notification/with-skip-sending-notification true
- (events/publish-event! :event/user-invited {:object (assoc <> :sso_source (:sso_source user))}))
- ;; send an email to everyone including the site admin if that's set
- (when (sso/send-new-sso-user-admin-email?)
- (messages/send-user-joined-admin-notification-email! <>, :google-auth? true)))
- (catch ExceptionInfo e
- (log/error e "Error creating new SSO user")
- (throw (ex-info (trs "Error creating new SSO user")
- {:user user})))))
-
-(mu/defn fetch-and-update-login-attributes!
- "Updates `UserAttributes` for the user at `email`, if they exist, returning the user afterwards.
- Only updates if the `UserAttributes` are unequal to the current values.
-
- If a user exists but `is_active` is `false`, will return the user only if `reactivate?` is `true`. Otherwise it will
- be as if this user does not exist."
- [{:keys [email] :as user-from-sso} :- UserAttributes
- reactivate? :- ms/BooleanValue]
- (let [;; if the user is not active, we will want to mark them as active if they are actually reactivated.
- new-user-data (merge user-from-sso {:is_active true})
- user-keys (keys new-user-data)]
- (when-let [{:keys [id] :as user} (t2/select-one (into [:model/User :id :last_login] user-keys)
- :%lower.email (u/lower-case-en email))]
- (when (or (:is_active user)
- reactivate?)
- (let [;; remove keys with `nil` values
- user-data (into {} (filter second new-user-data))]
- (if (= (select-keys user user-keys) user-data)
- user
- (do
- (t2/update! :model/User id user-data)
- (t2/select-one :model/User :id id))))))))
-
(defn relative-uri?
"Checks that given `uri` is not an absolute (so no scheme and no host)."
[uri]
@@ -119,7 +57,8 @@
our-host (some-> (system/site-url) (URI.) (.getHost))]
(api/check-400 (or (nil? redirect-url)
(relative-uri? redirect)
- (= (.getHost redirect) our-host))))
+ (= (.getHost redirect) our-host)))
+ redirect-url)
(catch Exception e
(log/error e "Invalid redirect URL")
(throw (ex-info (tru "Invalid redirect URL")
diff --git a/enterprise/backend/src/metabase_enterprise/sso/providers/jwt.clj b/enterprise/backend/src/metabase_enterprise/sso/providers/jwt.clj
new file mode 100644
index 00000000000..2731aa9e651
--- /dev/null
+++ b/enterprise/backend/src/metabase_enterprise/sso/providers/jwt.clj
@@ -0,0 +1,160 @@
+(ns metabase-enterprise.sso.providers.jwt
+ "JWT authentication provider implementation."
+ (:require
+ [buddy.sign.jwt :as jwt]
+ [metabase-enterprise.sso.integrations.sso-utils :as sso-utils]
+ [metabase-enterprise.sso.settings :as sso-settings]
+ [metabase.auth-identity.core :as auth-identity]
+ [metabase.sso.core :as sso]
+ [metabase.util :as u]
+ [metabase.util.i18n :refer [tru]]
+ [metabase.util.log :as log]
+ [methodical.core :as methodical]
+ [toucan2.core :as t2]))
+
+(set! *warn-on-reflection* true)
+
+;; Register JWT provider
+(derive :provider/jwt :metabase.auth-identity.provider/provider)
+(derive :provider/jwt :metabase.auth-identity.provider/create-user-if-not-exists)
+
+;; JWTs use seconds since Epoch, not milliseconds since Epoch for the `iat` and `max_age` time.
+;; 3 minutes is the time used by Zendesk for their JWT SSO
+(def ^:private ^:const three-minutes-in-seconds 180)
+
+(def ^:private ^{:arglists '([])} jwt-attribute-email
+ (comp keyword sso-settings/jwt-attribute-email))
+
+(def ^:private ^{:arglists '([])} jwt-attribute-firstname
+ (comp keyword sso-settings/jwt-attribute-firstname))
+
+(def ^:private ^{:arglists '([])} jwt-attribute-lastname
+ (comp keyword sso-settings/jwt-attribute-lastname))
+
+(def ^:private ^{:arglists '([])} jwt-attribute-groups
+ (comp keyword sso-settings/jwt-attribute-groups))
+
+(def ^:private registered-claims
+ "Registered claims in the JWT standard which we should not interpret as login attributes."
+ [:iss :iat :sub :aud :exp :nbf :jti])
+
+(defn- jwt-data->user-attributes
+ "Extract user attributes from JWT data, excluding standard claims and user identity fields."
+ [jwt-data]
+ (let [excluded-keys (concat registered-claims
+ [(jwt-attribute-email)
+ (jwt-attribute-firstname)
+ (jwt-attribute-lastname)
+ (jwt-attribute-groups)])]
+ (sso-utils/filter-non-stringable-attributes (apply dissoc jwt-data excluded-keys))))
+
+(defn- decode-and-verify-jwt
+ "Decode and verify a JWT token. Returns the JWT data if valid, throws on error."
+ [token]
+ (try
+ (jwt/unsign token (sso-settings/jwt-shared-secret)
+ {:max-age three-minutes-in-seconds})
+ (catch Throwable e
+ (throw (ex-info (ex-message e)
+ {:status-code 401
+ :error :invalid-jwt})))))
+
+(methodical/defmethod auth-identity/authenticate :provider/jwt
+ [_provider {:keys [token] :as _request}]
+ (cond
+ (not (sso-settings/jwt-enabled))
+ {:success? false
+ :error :jwt-not-enabled
+ :message (str (tru "JWT authentication is not enabled"))}
+
+ (not token)
+ {:success? false
+ :error :invalid-request
+ :message "JWT token is required"}
+
+ :else
+ (try
+ (let [jwt-data (decode-and-verify-jwt token)
+ email (get jwt-data (jwt-attribute-email))
+ first-name (get jwt-data (jwt-attribute-firstname))
+ last-name (get jwt-data (jwt-attribute-lastname))
+ user-attributes (jwt-data->user-attributes jwt-data)]
+ (when-not email
+ (throw (ex-info (str (tru "JWT token missing email claim"))
+ {:status-code 400
+ :error :missing-email})))
+ (log/infof "Successfully authenticated JWT token for: %s %s" first-name last-name)
+ {:success? true
+ :user-data {:email email
+ :first_name first-name
+ :last_name last-name
+ :sso_source :jwt
+ :jwt_attributes user-attributes}
+ :jwt-data jwt-data
+ :provider-id email})
+ (catch clojure.lang.ExceptionInfo e
+ (log/errorf e "JWT authentication failed: %s" (.getMessage e))
+ {:success? false
+ :error (or (:error (ex-data e)) :authentication-failed)
+ :message (.getMessage e)})
+ (catch Exception e
+ (log/errorf e "Unexpected error during JWT authentication: %s" (.getMessage e))
+ {:success? false
+ :error :server-error
+ :message "An unexpected error occurred during authentication"}))))
+
+(methodical/defmethod auth-identity/login! :provider/jwt
+ "Handle jwt login aborting if user provisioning is not enabled and no user was found."
+ [provider request]
+ (cond
+ ;; Authentication needs redirect (shouldn't happen for Google but handle it)
+ (= :redirect (:success? request))
+ request
+
+ ;; Authentication failed
+ (not (:success? request))
+ request
+
+ ;; Authentication succeeded - check account creation policy
+ ;; TODO(edpaget): 2025/11/11 this should return an error condition instead of throwing
+ :else
+ (do (when-not (and (:user request) (get-in request [:user :is_active]))
+ (sso-utils/check-user-provisioning :jwt))
+ ;; If the user was deactivated but user provisioning is allowed reactive the user
+ (next-method provider (assoc-in request [:user-data :is_active] true)))))
+
+(defn- group-names->ids
+ "Translate a user's group names to a set of MB group IDs using the configured mappings"
+ [group-names]
+ (if-let [name-mappings (not-empty (sso-settings/jwt-group-mappings))]
+ (set
+ (mapcat name-mappings
+ (map keyword group-names)))
+ (t2/select-pks-set :model/PermissionsGroup :name [:in group-names])))
+
+(defn- all-mapped-group-ids
+ "Returns the set of all MB group IDs that have configured mappings"
+ []
+ (-> (sso-settings/jwt-group-mappings)
+ vals
+ flatten
+ set))
+
+(methodical/defmethod auth-identity/login! :after :provider/jwt
+ "Sync JWT group memberships after successful login.
+
+ This method runs after the main login! flow completes successfully.
+ It extracts the JWT groups from the authentication result and syncs
+ them with Metabase group memberships based on configured mappings."
+ [_provider {:keys [jwt-data user] :as result}]
+ (cond-> result
+ (:success? result)
+ (u/prog1
+ (when (sso-settings/jwt-group-sync)
+ (when-let [groups-attribute (jwt-attribute-groups)]
+ (when-let [group-names (get jwt-data groups-attribute)]
+ (if (empty? (sso-settings/jwt-group-mappings))
+ (sso/sync-group-memberships! user (group-names->ids group-names))
+ (sso/sync-group-memberships! user
+ (group-names->ids group-names)
+ (all-mapped-group-ids)))))))))
diff --git a/enterprise/backend/src/metabase_enterprise/sso/providers/saml.clj b/enterprise/backend/src/metabase_enterprise/sso/providers/saml.clj
new file mode 100644
index 00000000000..aea3203b16c
--- /dev/null
+++ b/enterprise/backend/src/metabase_enterprise/sso/providers/saml.clj
@@ -0,0 +1,195 @@
+(ns metabase-enterprise.sso.providers.saml
+ "SAML authentication provider implementation."
+ (:require
+ [medley.core :as m]
+ [metabase-enterprise.sso.integrations.sso-utils :as sso-utils]
+ [metabase-enterprise.sso.settings :as sso-settings]
+ [metabase.auth-identity.core :as auth-identity]
+ [metabase.sso.core :as sso]
+ [metabase.system.core :as system]
+ [metabase.util :as u]
+ [metabase.util.i18n :refer [tru]]
+ [metabase.util.log :as log]
+ [methodical.core :as methodical]
+ [saml20-clj.core :as saml]))
+
+(set! *warn-on-reflection* true)
+
+;; Register SAML provider
+(derive :provider/saml :metabase.auth-identity.provider/provider)
+(derive :provider/saml :metabase.auth-identity.provider/create-user-if-not-exists)
+
+(defn- acs-url
+ "Get the Assertion Consumer Service URL."
+ []
+ (str (system/site-url) "/auth/sso"))
+
+(defn- sp-cert-keystore-details
+ "Build a certificate store map usable by the saml20-clj library."
+ []
+ (when-let [path (sso-settings/saml-keystore-path)]
+ (when-let [password (sso-settings/saml-keystore-password)]
+ (when-let [key-name (sso-settings/saml-keystore-alias)]
+ {:filename path
+ :password password
+ :alias key-name}))))
+
+(defn- idp-cert
+ "Get the Identity Provider certificate."
+ []
+ (or (sso-settings/saml-identity-provider-certificate)
+ (throw (ex-info (str (tru "Unable to log in: SAML IdP certificate is not set."))
+ {:status-code 500}))))
+
+(defn- unwrap-user-attributes
+ "For some reason all of the user attributes coming back from the saml library are wrapped in a list,
+ instead of 'Oisin', it's ('Oisin'). This function discards the list if there's just a single item in it."
+ [m]
+ (m/map-vals (fn [maybe-coll]
+ (if (and (coll? maybe-coll)
+ (= 1 (count maybe-coll)))
+ (first maybe-coll)
+ maybe-coll))
+ m))
+
+(defn- saml-response->attributes
+ "Extract user attributes from a SAML response."
+ [saml-response]
+ (let [assertions (saml/assertions saml-response)
+ attrs (-> assertions first :attrs unwrap-user-attributes)]
+ (when-not attrs
+ (throw (ex-info (str (tru "Unable to log in: SAML info does not contain user attributes."))
+ {:status-code 401})))
+ attrs))
+
+(methodical/defmethod auth-identity/authenticate :provider/saml
+ [_provider {:keys [redirect-url] :as request}]
+ (cond
+ (not (sso-settings/saml-enabled))
+ {:success? false
+ :error :saml-not-enabled
+ :message (str (tru "SAML authentication is not enabled"))}
+
+ ;; SAML AuthnRequest generation (GET flow - redirect to IdP)
+ (= (:request-method request) :get)
+ (try
+ (let [idp-url (sso-settings/saml-identity-provider-uri)
+ relay-state (when redirect-url
+ (u/encode-base64 redirect-url))
+ response (saml/idp-redirect-response {:request-id (str "id-" (random-uuid))
+ :sp-name (sso-settings/saml-application-name)
+ :issuer (sso-settings/saml-application-name)
+ :acs-url (acs-url)
+ :idp-url idp-url
+ :credential (sp-cert-keystore-details)
+ :relay-state relay-state
+ :protocol-binding :post})]
+ {:success? :redirect
+ :redirect-url (get-in response [:headers "location"])
+ :message "Redirecting to SAML provider"})
+ (catch Throwable e
+ (log/errorf e "Error generating SAML request: %s" (.getMessage e))
+ {:success? false
+ :error :saml-request-generation-failed
+ :message (str (tru "Error generating SAML request"))}))
+
+ ;; SAML Response validation (POST flow - validate and extract user data)
+ :else
+ (try
+ (let [validated-response (saml/validate-response request
+ {:idp-cert (idp-cert)
+ :sp-private-key (sp-cert-keystore-details)
+ :acs-url (acs-url)
+ :response-validators [:issuer
+ :signature
+ :require-authenticated]
+ :assertion-validators [:signature
+ :recipient
+ :not-on-or-after
+ :not-before
+ :address
+ :issuer]
+ :issuer (sso-settings/saml-identity-provider-issuer)})
+ attrs (saml-response->attributes validated-response)
+ email (get attrs (sso-settings/saml-attribute-email))
+ first-name (get attrs (sso-settings/saml-attribute-firstname))
+ last-name (get attrs (sso-settings/saml-attribute-lastname))
+ groups (get attrs (sso-settings/saml-attribute-group))
+ user-attributes (sso-utils/filter-non-stringable-attributes attrs)]
+ (when-not email
+ (throw (ex-info (str (tru "Invalid SAML configuration: could not find user email. We tried looking for {0}, but couldn''t find the attribute. Please make sure your SAML IdP is properly configured."
+ (sso-settings/saml-attribute-email)))
+ {:status-code 400
+ :user-attributes (keys user-attributes)})))
+ (log/infof "Successfully authenticated SAML assertion for: %s %s" first-name last-name)
+ {:success? true
+ :user-data {:email email
+ :first_name first-name
+ :last_name last-name
+ :sso_source :saml
+ :login_attributes user-attributes}
+ :saml-data {:group-names groups
+ :user-attributes user-attributes}
+ :provider-id email})
+ (catch clojure.lang.ExceptionInfo e
+ (log/errorf e "SAML authentication failed: %s" (.getMessage e))
+ {:success? false
+ :error (or (:error (ex-data e)) :authentication-failed)
+ :message (.getMessage e)})
+ (catch Exception e
+ (log/errorf e "Unexpected error during SAML authentication: %s" (.getMessage e))
+ {:success? false
+ :error :server-error
+ :message (str (tru "Unable to log in: SAML response validation failed"))}))))
+
+(methodical/defmethod auth-identity/login! :provider/saml
+ "Handle saml login aborting if user provisioning is not enabled and no user was found."
+ [provider request]
+ (cond
+ ;; Authentication needs redirect (shouldn't happen for Google but handle it)
+ (= :redirect (:success? request))
+ request
+
+ ;; Authentication failed
+ (not (:success? request))
+ request
+
+ ;; Authentication succeeded - check account creation policy
+ ;; TODO(edpaget): 2025/11/11 this should return an error condition instead of throwing
+ :else
+ (do (when-not (and (:user request) (get-in request [:user :is_active]))
+ (sso-utils/check-user-provisioning :saml))
+ ;; If the user was deactivated but user provisioning is allowed reactive the user
+ (next-method provider (assoc-in request [:user-data :is_active] true)))))
+
+(defn- group-names->ids
+ "Translate a user's group names to a set of MB group IDs using the configured mappings"
+ [group-names]
+ (->> (cond-> group-names (string? group-names) vector)
+ (map keyword)
+ (mapcat (sso-settings/saml-group-mappings))
+ set))
+
+(defn- all-mapped-group-ids
+ "Returns the set of all MB group IDs that have configured mappings"
+ []
+ (-> (sso-settings/saml-group-mappings)
+ vals
+ flatten
+ set))
+
+(methodical/defmethod auth-identity/login! :after :provider/saml
+ "Sync SAML group memberships after successful login.
+
+ This method runs after the main login! flow completes successfully.
+ It extracts the SAML groups from the authentication result and syncs
+ them with Metabase group memberships based on configured mappings."
+ [_provider {:keys [saml-data user] :as result}]
+ (cond-> result
+ (:success? result)
+ (u/prog1
+ (when (sso-settings/saml-group-sync)
+ (when-let [group-names (:group-names saml-data)]
+ (sso/sync-group-memberships! user
+ (group-names->ids group-names)
+ (all-mapped-group-ids)))))))
diff --git a/enterprise/backend/test/metabase_enterprise/auth_identity/provider_test.clj b/enterprise/backend/test/metabase_enterprise/auth_identity/provider_test.clj
new file mode 100644
index 00000000000..0a8e2ae7dff
--- /dev/null
+++ b/enterprise/backend/test/metabase_enterprise/auth_identity/provider_test.clj
@@ -0,0 +1,47 @@
+(ns metabase-enterprise.auth-identity.provider-test
+ (:require
+ [clojure.test :refer :all]
+ [metabase.auth-identity.provider :as provider]
+ [metabase.test :as mt]))
+
+(deftest ^:parallel sso-user-fields-oss-test
+ (testing "OSS version of sso-user-fields returns basic fields only"
+ (mt/with-premium-features #{}
+ (is (= [:email :first_name :last_name :sso_source]
+ (provider/sso-user-fields))))))
+
+(deftest ^:parallel sso-user-fields-with-sso-jwt-test
+ (testing "Enterprise version with :sso-jwt feature includes jwt_attributes and login_attributes"
+ (mt/with-premium-features #{:sso-jwt}
+ (is (= [:email :first_name :last_name :sso_source :login_attributes :jwt_attributes]
+ (provider/sso-user-fields))))))
+
+(deftest ^:parallel sso-user-fields-with-sso-saml-test
+ (testing "Enterprise version with :sso-saml feature includes login_attributes but not jwt_attributes"
+ (mt/with-premium-features #{:sso-saml}
+ (is (= [:email :first_name :last_name :sso_source :login_attributes]
+ (provider/sso-user-fields))))))
+
+(deftest ^:parallel sso-user-fields-with-sso-ldap-test
+ (testing "Enterprise version with :sso-ldap feature includes login_attributes but not jwt_attributes"
+ (mt/with-premium-features #{:sso-ldap}
+ (is (= [:email :first_name :last_name :sso_source :login_attributes]
+ (provider/sso-user-fields))))))
+
+(deftest ^:parallel sso-user-fields-with-any-sso-test
+ (testing "Enterprise version with :any-sso feature does not trigger sso-user-fields (only specific flags do)"
+ (mt/with-premium-features #{:any-sso}
+ (is (= [:email :first_name :last_name :sso_source]
+ (provider/sso-user-fields))))))
+
+(deftest ^:parallel sso-user-fields-with-multiple-features-test
+ (testing "Enterprise version with multiple SSO features includes jwt_attributes when :sso-jwt is present"
+ (mt/with-premium-features #{:sso-jwt :sso-saml}
+ (is (= [:email :first_name :last_name :sso_source :login_attributes :jwt_attributes]
+ (provider/sso-user-fields))))))
+
+(deftest ^:parallel sso-user-fields-with-saml-and-ldap-test
+ (testing "Enterprise version with :sso-saml and :sso-ldap includes login_attributes but not jwt_attributes"
+ (mt/with-premium-features #{:sso-saml :sso-ldap}
+ (is (= [:email :first_name :last_name :sso_source :login_attributes]
+ (provider/sso-user-fields))))))
diff --git a/enterprise/backend/test/metabase_enterprise/models/entity_id_test.clj b/enterprise/backend/test/metabase_enterprise/models/entity_id_test.clj
index 51076f02a65..d14652d4825 100644
--- a/enterprise/backend/test/metabase_enterprise/models/entity_id_test.clj
+++ b/enterprise/backend/test/metabase_enterprise/models/entity_id_test.clj
@@ -33,6 +33,7 @@
- exported as a child of something else (eg. timeline_event under timeline)
so they don't need a generated entity_id."
#{:model/ApiKey
+ :model/AuthIdentity
:model/HTTPAction
:model/ImplicitAction
:model/QueryAction
diff --git a/enterprise/backend/test/metabase_enterprise/sso/integrations/google_test.clj b/enterprise/backend/test/metabase_enterprise/sso/integrations/google_test.clj
index 7af1df2d6f8..d2e00499a3b 100644
--- a/enterprise/backend/test/metabase_enterprise/sso/integrations/google_test.clj
+++ b/enterprise/backend/test/metabase_enterprise/sso/integrations/google_test.clj
@@ -1,19 +1,36 @@
(ns metabase-enterprise.sso.integrations.google-test
(:require
+ [clj-http.client :as http]
[clojure.test :refer :all]
- [metabase.sso.core :as sso]
[metabase.test :as mt]
- [metabase.test.fixtures :as fixtures]))
+ [metabase.test.fixtures :as fixtures]
+ [toucan2.core :as t2]))
(use-fixtures :once (fixtures/initialize :db :test-users))
-(deftest google-auth-create-new-user!-test
+(deftest google-auth-test
(mt/with-premium-features #{:sso-google}
- (testing "should support multiple domains (#5218)"
- (mt/with-temporary-setting-values [google-auth-auto-create-accounts-domain "metabase.com,example.com"]
- (mt/with-model-cleanup [:model/User]
- (let [user (sso/google-auth-create-new-user! {:first_name "Cam"
- :last_name "Era"
- :email "[email protected]"})]
- (is (= {:first_name "Cam", :last_name "Era", :email "[email protected]"}
- (select-keys user [:first_name :last_name :email])))))))))
+ (testing "POST /google_auth"
+ (mt/with-model-cleanup [:model/User]
+ (mt/with-temporary-setting-values [google-auth-client-id "pretend-client-id.apps.googleusercontent.com"
+ google-auth-auto-create-accounts-domain "metabase.com,example.com"]
+ (testing "Google auth works with an @metabase.com account"
+ (with-redefs [http/post (constantly
+ {:status 200
+ :body (str "{\"aud\":\"pretend-client-id.apps.googleusercontent.com\","
+ "\"email_verified\":\"true\","
+ "\"first_name\":\"Cam\","
+ "\"last_name\":\"Era\","
+ "\"email\":\"[email protected]\"}")})]
+ (mt/client :post 200 "session/google_auth" {:token "foo"})
+ (is (some? (t2/select-one :model/User :email "[email protected]")))))
+ (testing "Google auth works with an @example.com account"
+ (with-redefs [http/post (constantly
+ {:status 200
+ :body (str "{\"aud\":\"pretend-client-id.apps.googleusercontent.com\","
+ "\"email_verified\":\"true\","
+ "\"first_name\":\"Cam\","
+ "\"last_name\":\"Era\","
+ "\"email\":\"[email protected]\"}")})]
+ (mt/client :post 200 "session/google_auth" {:token "foo"})
+ (is (some? (t2/select-one :model/User :email "[email protected]"))))))))))
diff --git a/enterprise/backend/test/metabase_enterprise/sso/integrations/jwt_test.clj b/enterprise/backend/test/metabase_enterprise/sso/integrations/jwt_test.clj
index 2e80f71bb7f..5d3f4290241 100644
--- a/enterprise/backend/test/metabase_enterprise/sso/integrations/jwt_test.clj
+++ b/enterprise/backend/test/metabase_enterprise/sso/integrations/jwt_test.clj
@@ -5,7 +5,6 @@
[clojure.string :as str]
[clojure.test :refer :all]
[crypto.random :as crypto-random]
- [metabase-enterprise.sso.integrations.jwt :as mt.jwt]
[metabase-enterprise.sso.integrations.saml-test :as saml-test]
[metabase-enterprise.sso.integrations.token-utils :as token-utils]
[metabase-enterprise.sso.settings :as sso-settings]
@@ -306,16 +305,10 @@
:iat (- (buddy-util/now) (u/minutes->seconds 5))}
default-jwt-secret)))))))
-(defmacro with-users-with-email-deleted {:style/indent 1} [user-email & body]
- `(try
- ~@body
- (finally
- (t2/delete! :model/User :%lower.email (u/lower-case-en ~user-email)))))
-
(deftest create-new-account-test
(testing "A new account will be created for a JWT user we haven't seen before"
(with-jwt-default-setup!
- (with-users-with-email-deleted "[email protected]"
+ (mt/with-model-cleanup [:model/User]
(letfn
[(new-user-exists? []
(boolean (seq (t2/select :model/User :%lower.email "[email protected]"))))]
@@ -363,7 +356,7 @@
(deftest update-account-test
(testing "A new account with 'Unknown' name will be created for a new JWT user without a first or last name."
(with-jwt-default-setup!
- (with-users-with-email-deleted "[email protected]"
+ (mt/with-model-cleanup [:model/User]
(letfn
[(new-user-exists? []
(boolean (seq (t2/select :model/User :%lower.email "[email protected]"))))]
@@ -418,22 +411,22 @@
(mt/boolean-ids-and-timestamps (t2/select :model/User :email "[email protected]"))
(map #(dissoc % :last_login))))))))))))
-(deftest group-mappings-test
- (testing "make sure our setting for mapping group names -> IDs works"
- (mt/with-additional-premium-features #{:sso-jwt}
- (mt/with-temporary-setting-values
- [jwt-group-mappings
- {"group_1" [1 2 3]
- "group_2" [3 4]
- "group_3" [5]}]
- (testing "keyword group names"
- (is
- (= #{1 2 3 4}
- (#'mt.jwt/group-names->ids [:group_1 :group_2]))))
- (testing "string group names"
- (is
- (= #{3 4 5}
- (#'mt.jwt/group-names->ids ["group_2" "group_3"]))))))))
+#_(deftest group-mappings-test
+ (testing "make sure our setting for mapping group names -> IDs works"
+ (mt/with-additional-premium-features #{:sso-jwt}
+ (mt/with-temporary-setting-values
+ [jwt-group-mappings
+ {"group_1" [1 2 3]
+ "group_2" [3 4]
+ "group_3" [5]}]
+ (testing "keyword group names"
+ (is
+ (= #{1 2 3 4}
+ (#'mt.jwt/group-names->ids [:group_1 :group_2]))))
+ (testing "string group names"
+ (is
+ (= #{3 4 5}
+ (#'mt.jwt/group-names->ids ["group_2" "group_3"]))))))))
(defn- group-memberships [user-or-id]
(when-let [group-ids (seq
@@ -451,7 +444,7 @@
{"my_group" [(u/the-id my-group)]}
jwt-attribute-groups
"GrOuPs"]
- (with-users-with-email-deleted "[email protected]"
+ (mt/with-model-cleanup [:model/User]
(let [response (client/client-real-response :get 302 "/auth/sso"
{:request-options {:redirect-strategy :none}}
:return_to default-redirect-uri
@@ -482,7 +475,7 @@
[jwt-group-sync true
jwt-group-mappings nil ; No mappings defined
jwt-attribute-groups "groups"]
- (with-users-with-email-deleted "[email protected]"
+ (mt/with-model-cleanup [:model/User]
(let [response (client/client-real-response :get 302 "/auth/sso"
{:request-options {:redirect-strategy :none}}
:return_to default-redirect-uri
@@ -507,7 +500,7 @@
(testing "login as an existing user works"
(testing "An existing user will be reactivated upon login"
(with-jwt-default-setup!
- (with-users-with-email-deleted "[email protected]"
+ (mt/with-model-cleanup [:model/User]
;; just create the user
(let [response (client/client-real-response :get 302 "/auth/sso"
{:request-options {:redirect-strategy :none}}
@@ -534,7 +527,7 @@
(testing "Existing user login attributes are not changed on subsequent logins"
(with-jwt-default-setup!
- (with-users-with-email-deleted "[email protected]"
+ (mt/with-model-cleanup [:model/User]
;; Create user with initial login attributes
(let [response (client/client-real-response :get 302 "/auth/sso"
{:request-options {:redirect-strategy :none}}
@@ -573,7 +566,7 @@
(deftest login-update-account-test
(testing "An existing user will be reactivated upon login"
(with-jwt-default-setup!
- (with-users-with-email-deleted "[email protected]"
+ (mt/with-model-cleanup [:model/User]
;; just create the user
(let [response (client/client-real-response :get 302 "/auth/sso"
{:request-options {:redirect-strategy :none}}
@@ -607,22 +600,32 @@
(is (not (t2/select-one-fn :is_active :model/User :email "[email protected]")))
(with-redefs [sso-settings/jwt-user-provisioning-enabled? (constantly false)
appearance.settings/site-name (constantly "test")]
- (is
- (thrown-with-msg?
- clojure.lang.ExceptionInfo
- #"Sorry, but you'll need a test account to view this page. Please contact your administrator."
- (#'mt.jwt/fetch-or-create-user! "Test" "User" "[email protected]" nil))))))))
+ (is (=? {:body "Sorry, but you'll need a test account to view this page. Please contact your administrator."}
+ (client/client-real-response :get 401 "/auth/sso"
+ {:request-options {:redirect-strategy :none}}
+ :return_to default-redirect-uri
+ :jwt
+ (jwt/sign
+ {:email "[email protected]"
+ :first_name "New"
+ :last_name "User"}
+ default-jwt-secret)))))))))
(deftest create-new-jwt-user-no-user-provisioning-test
(testing "When user provisioning is disabled, throw an error if we attempt to create a new user."
(with-jwt-default-setup!
(with-redefs [sso-settings/jwt-user-provisioning-enabled? (constantly false)
appearance.settings/site-name (constantly "test")]
- (is
- (thrown-with-msg?
- clojure.lang.ExceptionInfo
- #"Sorry, but you'll need a test account to view this page. Please contact your administrator."
- (#'mt.jwt/fetch-or-create-user! "Test" "User" "[email protected]" nil)))))))
+ (is (=? {:body "Sorry, but you'll need a test account to view this page. Please contact your administrator."}
+ (client/client-real-response :get 401 "/auth/sso"
+ {:request-options {:redirect-strategy :none}}
+ :return_to default-redirect-uri
+ :jwt
+ (jwt/sign
+ {:email "[email protected]"
+ :first_name "Test"
+ :last_name "User"}
+ default-jwt-secret))))))))
(deftest non-string-jwt-claims-dropped-test
(testing "JWT claims with non-string values are dropped and warning is logged"
@@ -659,7 +662,7 @@
(testing "no warning for valid string attribute"
(is (not (some #(re-find #"string_attr" %) (map :message (jwt-log-messages)))))))))))
-(deftest jwt-token-test
+(deftest jwt-token-sdk-idp-url-test
(testing "should return IdP URL when embedding SDK header is present but no JWT token is provided"
(with-jwt-default-setup!
(mt/with-temporary-setting-values [enable-embedding-sdk true]
@@ -669,8 +672,9 @@
(is (partial= {:url (sso-settings/jwt-identity-provider-uri)
:method "jwt"}
(:body result)))
- (is (not (nil? (get-in result [:body :hash]))))))))
+ (is (not (nil? (get-in result [:body :hash])))))))))
+(deftest jwt-token-sdk-session-token-test
(testing "should return a session token when a JWT token and sdk headers are passed"
(with-jwt-default-setup!
(mt/with-temporary-setting-values [enable-embedding-sdk true]
@@ -694,8 +698,9 @@
{:id (mt/malli=? ms/UUIDString)
:iat jwt-iat-time
:exp jwt-exp-time}
- (:body result)))))))
+ (:body result))))))))
+(deftest jwt-token-not-configured-test
(testing "should not return a session token when jwt is not configured"
(mt/with-temporary-setting-values
[jwt-enabled true
@@ -716,8 +721,9 @@
result (client/client-real-response :get 400 "/auth/sso"
{:request-options {:headers {"x-metabase-client" "embedding-sdk-react"}}}
:jwt jwt-payload)]
- (is result nil)))))
+ (is result nil))))))
+(deftest jwt-token-embedding-disabled-test
(testing "should not return a session token when embedding is disabled"
(with-jwt-default-setup!
(mt/with-temporary-setting-values [enable-embedding-sdk false]
@@ -735,8 +741,9 @@
result (client/client-real-response :get 402 "/auth/sso"
{:request-options {:headers {"x-metabase-client" "embedding-sdk-react"}}}
:jwt jwt-payload)]
- (is result nil)))))
+ (is result nil))))))
+(deftest jwt-token-no-hash-test
(testing "should not return a session token when token=false"
(with-jwt-default-setup!
(mt/with-temporary-setting-values [enable-embedding-sdk true]
diff --git a/enterprise/backend/test/metabase_enterprise/sso/integrations/ldap_test.clj b/enterprise/backend/test/metabase_enterprise/sso/integrations/ldap_test.clj
index 6aaf89bd3ba..aec26904af5 100644
--- a/enterprise/backend/test/metabase_enterprise/sso/integrations/ldap_test.clj
+++ b/enterprise/backend/test/metabase_enterprise/sso/integrations/ldap_test.clj
@@ -3,11 +3,11 @@
[clojure.test :refer :all]
[metabase-enterprise.sso.settings :as sso-settings]
[metabase.appearance.settings :as appearance.settings]
+ [metabase.auth-identity.core :as auth-identity]
[metabase.sso.ldap :as ldap]
[metabase.sso.ldap-test-util :as ldap.test]
[metabase.test :as mt]
[metabase.test.fixtures :as fixtures]
- [metabase.util.malli.schema :as ms]
[toucan2.core :as t2]))
(use-fixtures :once (fixtures/initialize :db :test-users))
@@ -108,7 +108,6 @@
:cn "Lucky Pigeon"}
:groups []}
(ldap/find-user "lucky"))))
-
(testing "ignored attributes should not be returned"
(mt/with-temporary-setting-values [ldap-sync-user-attributes-blacklist
(cons "title" (sso-settings/ldap-sync-user-attributes-blacklist))]
@@ -123,7 +122,6 @@
:cn "Lucky Pigeon"}
:groups []}
(ldap/find-user "lucky")))))
-
(testing "if attribute sync is disabled, no attributes should come back at all"
(mt/with-temporary-setting-values [ldap-sync-user-attributes false]
(is (= {:dn "cn=Lucky Pigeon,ou=Birds,dc=metabase,dc=com"
@@ -132,52 +130,76 @@
:attributes nil
:groups []}
- (ldap/find-user "lucky")))))
+ (ldap/find-user "lucky"))))))))
- (testing "when creating a new user, user attributes should get synced"
- (try
- (ldap/fetch-or-create-user! (ldap/find-user "jsmith1"))
- (is (= {:first_name "John"
- :last_name "Smith"
- :login_attributes {"uid" "jsmith1"
- "givenname" "John"
- "sn" "Smith"
- "cn" "John Smith"}
- :common_name "John Smith"}
- (into {} (t2/select-one [:model/User :first_name :last_name :email :login_attributes]
- :email "[email protected]"))))
- (finally
- (t2/delete! :model/User :%lower.email "[email protected]"))))
-
- (testing "when creating a new user and attribute sync is disabled, attributes should not be synced"
- (mt/with-temporary-setting-values [ldap-sync-user-attributes false]
- (try
- (ldap/fetch-or-create-user! (ldap/find-user "jsmith1"))
+(deftest new-user-attributes-synced-test
+ (mt/with-premium-features #{:sso-ldap}
+ (mt/with-model-cleanup [:model/User]
+ (ldap.test/with-ldap-server!
+ (testing "when creating a new user via provider/login!, user attributes should get synced"
+ (let [result (auth-identity/login! :provider/ldap
+ {:username "jsmith1"
+ :password "strongpassword"
+ :device-info {:device_id "test-device"
+ :device_description "Test Device"
+ :ip_address "127.0.0.1"
+ :embedded false}})]
+ (is (true? (:success? result)))
(is (= {:first_name "John"
:last_name "Smith"
- :login_attributes nil
+ :login_attributes {"uid" "jsmith1"
+ "givenname" "John"
+ "sn" "Smith"
+ "cn" "John Smith"}
:common_name "John Smith"}
(into {} (t2/select-one [:model/User :first_name :last_name :email :login_attributes]
- :email "[email protected]"))))
- (finally
- (t2/delete! :model/User :%lower.email "[email protected]"))))))))
+ :email "[email protected]"))))))))))
+
+(deftest new-user-attributes-not-synced-when-disabled-test
+ (mt/with-premium-features #{:sso-ldap}
+ (mt/with-model-cleanup [:model/User]
+ (ldap.test/with-ldap-server!
+ (testing "when creating a new user via provider/login! and attribute sync is disabled, attributes should not be synced"
+ (mt/with-temporary-setting-values [ldap-sync-user-attributes false]
+ (let [result (auth-identity/login! :provider/ldap
+ {:username "jsmith1"
+ :password "strongpassword"
+ :device-info {:device_id "test-device"
+ :device_description "Test Device"
+ :ip_address "127.0.0.1"
+ :embedded false}})]
+ (is (true? (:success? result)))
+ (is (= {:first_name "John"
+ :last_name "Smith"
+ :login_attributes nil
+ :common_name "John Smith"}
+ (into {} (t2/select-one [:model/User :first_name :last_name :email :login_attributes]
+ :email "[email protected]")))))))))))
(deftest update-attributes-on-login-test
(mt/with-premium-features #{:sso-ldap}
- (ldap.test/with-ldap-server!
- (testing "Existing user's attributes are updated on fetch"
- (try
- (let [user-info (ldap/find-user "jsmith1")]
- (testing "First let a user get created for John Smith"
- (is (=? {:email "[email protected]"}
- (ldap/fetch-or-create-user! user-info))))
- (testing "Call fetch-or-create-user! again to trigger update"
- (is (malli= [:and [:map-of :keyword :any]
- [:map [:id ms/PositiveInt]]]
- (ldap/fetch-or-create-user! (assoc-in user-info [:attributes :unladenspeed] 100)))))
+ (mt/with-model-cleanup [:model/User]
+ (ldap.test/with-ldap-server!
+ (testing "Existing user's attributes are updated via provider/login!"
+ (let [result1 (auth-identity/login! :provider/ldap
+ {:username "jsmith1"
+ :password "strongpassword"
+ :device-info {:device_id "test-device"
+ :device_description "Test Device"
+ :ip_address "127.0.0.1"
+ :embedded false}})
+ result2 (auth-identity/login! :provider/ldap
+ {:username "jsmith1"
+ :password "strongpassword"
+ :device-info {:device_id "test-device"
+ :device_description "Test Device"
+ :ip_address "127.0.0.1"
+ :embedded false}})]
+ (is (true? (:success? result1)))
+ (is (true? (:success? result2)))
(is (= {:first_name "John"
:last_name "Smith"
:common_name "John Smith"
@@ -186,78 +208,91 @@
"givenname" "John"
"sn" "Smith"
- "cn" "John Smith"
- "unladenspeed" 100}}
+ "cn" "John Smith"}}
(into {} (t2/select-one [:model/User :first_name :last_name :email :login_attributes]
- :email "[email protected]")))))
- (finally
- (t2/delete! :model/User :%lower.email "[email protected]"))))
+ :email "[email protected]"))))))))))
- (testing "Existing user's attributes are not updated on fetch, when attribute sync is disabled"
- (try
+(deftest update-attributes-disabled-test
+ (mt/with-premium-features #{:sso-ldap}
+ (mt/with-model-cleanup [:model/User]
+ (ldap.test/with-ldap-server!
+ (testing "Existing user's attributes are not updated via provider/login! when attribute sync is disabled"
(mt/with-temporary-setting-values [ldap-sync-user-attributes false]
- (let [user-info (ldap/find-user "jsmith1")]
- (testing "First let a user get created for John Smith"
- (is (malli= [:and [:map-of :keyword :any]
- [:map [:email [:= "[email protected]"]]]]
- (ldap/fetch-or-create-user! user-info))))
- (testing "Call fetch-or-create-user! again to trigger update"
- (is (malli= [:and [:map-of :keyword :any]
- [:map [:id ms/PositiveInt]]]
- (ldap/fetch-or-create-user! (assoc-in user-info [:attributes :unladenspeed] 100)))))
+ (let [result1 (auth-identity/login! :provider/ldap
+ {:username "jsmith1"
+ :password "strongpassword"
+ :device-info {:device_id "test-device"
+ :device_description "Test Device"
+ :ip_address "127.0.0.1"
+ :embedded false}})
+ result2 (auth-identity/login! :provider/ldap
+ {:username "jsmith1"
+ :password "strongpassword"
+ :device-info {:device_id "test-device"
+ :device_description "Test Device"
+ :ip_address "127.0.0.1"
+ :embedded false}})]
+ (is (true? (:success? result1)))
+ (is (true? (:success? result2)))
(is (= {:first_name "John"
:last_name "Smith"
:common_name "John Smith"
:login_attributes nil}
(into {} (t2/select-one [:model/User :first_name :last_name :email :login_attributes]
- :email "[email protected]"))))))
- (finally
- (t2/delete! :model/User :%lower.email "[email protected]")))))))
+ :email "[email protected]")))))))))))
-(deftest fetch-or-create-user-test
+(deftest create-new-user-test
(mt/with-premium-features #{:sso-ldap}
- (ldap.test/with-ldap-server!
- (testing "a new user is created when they don't already exist"
- (try
- (ldap/fetch-or-create-user! (ldap/find-user "jsmith1"))
- (is (= {:first_name "John"
- :last_name "Smith"
- :common_name "John Smith"
- :email "[email protected]"}
- (into {} (t2/select-one [:model/User :first_name :last_name :email] :email "[email protected]"))))
- (finally (t2/delete! :model/User :email "[email protected]"))))
-
- (try
- (testing "a user without a givenName attribute has `nil` for that attribute"
- (ldap/fetch-or-create-user! (ldap/find-user "jmiller"))
- (is (= {:first_name nil
- :last_name "Miller"
- :common_name "Miller"}
- (into {} (t2/select-one [:model/User :first_name :last_name] :email "[email protected]")))))
-
- (testing "when givenName or sn attributes change in LDAP, they are updated in Metabase on next login"
- (ldap/fetch-or-create-user! (assoc (ldap/find-user "jmiller") :first-name "Jane" :last-name "Doe"))
- (is (= {:first_name "Jane"
- :last_name "Doe"
- :common_name "Jane Doe"}
- (into {} (t2/select-one [:model/User :first_name :last_name] :email "[email protected]")))))
+ (mt/with-model-cleanup [:model/User]
+ (ldap.test/with-ldap-server!
+ (testing "a new user is created via provider/login! when they don't already exist"
+ (let [result (auth-identity/login! :provider/ldap
+ {:username "jsmith1"
+ :password "strongpassword"
+ :device-info {:device_id "test-device"
+ :device_description "Test Device"
+ :ip_address "127.0.0.1"
+ :embedded false}})]
+ (is (true? (:success? result)))
+ (is (= {:first_name "John"
+ :last_name "Smith"
+ :common_name "John Smith"
+ :email "[email protected]"}
+ (into {} (t2/select-one [:model/User :first_name :last_name :email] :email "[email protected]"))))))))))
- (testing "if givenName or sn attributes are removed, values stored in Metabase are updated to `nil` to respect the IdP response."
- (ldap/fetch-or-create-user! (assoc (ldap/find-user "jmiller") :first-name nil :last-name nil))
- (is (= {:first_name nil
- :last_name nil
- :common_name "[email protected]"}
- (select-keys (t2/select-one :model/User :email "[email protected]") [:first_name :last_name :common_name]))))
- (finally (t2/delete! :model/User :email "[email protected]"))))))
+(deftest create-user-without-givenname-test
+ (mt/with-premium-features #{:sso-ldap}
+ (mt/with-model-cleanup [:model/User]
+ (ldap.test/with-ldap-server!
+ (testing "a user without a givenName attribute has nil for that attribute"
+ (let [result (auth-identity/login! :provider/ldap
+ {:username "jmiller"
+ :password "n0peeking"
+ :device-info {:device_id "test-device"
+ :device_description "Test Device"
+ :ip_address "127.0.0.1"
+ :embedded false}})]
+ (is (true? (:success? result)))
+ (is (= {:first_name nil
+ :last_name "Miller"
+ :common_name "Miller"}
+ (into {} (t2/select-one [:model/User :first_name :last_name] :email "[email protected]"))))))))))
(deftest ldap-no-user-provisioning-test
(mt/with-premium-features #{:sso-ldap}
- (ldap.test/with-ldap-server!
- (testing "an error is thrown when a new user is fetched and user provisioning is not enabled"
- (with-redefs [sso-settings/ldap-user-provisioning-enabled? (constantly false)
- appearance.settings/site-name (constantly "test")]
- (is (thrown-with-msg?
- clojure.lang.ExceptionInfo
- #"Sorry, but you'll need a test account to view this page. Please contact your administrator."
- (ldap/fetch-or-create-user! (ldap/find-user "jsmith1")))))))))
+ (mt/with-model-cleanup [:model/User]
+ (ldap.test/with-ldap-server!
+ (testing "an error is thrown when a new user attempts to login via provider/login! and user provisioning is not enabled"
+ (with-redefs [sso-settings/ldap-user-provisioning-enabled? (constantly false)
+ appearance.settings/site-name (constantly "test")]
+ (is (thrown-with-msg?
+ clojure.lang.ExceptionInfo
+ #"Sorry, but you'll need a test account to view this page. Please contact your administrator."
+ (auth-identity/login! :provider/ldap
+ {:username "jsmith1"
+ :password "strongpassword"
+ :device-info {:device_id "test-device"
+ :device_description "Test Device"
+ :ip_address "127.0.0.1"
+ :embedded false}})))))))))
diff --git a/enterprise/backend/test/metabase_enterprise/sso/integrations/saml_test.clj b/enterprise/backend/test/metabase_enterprise/sso/integrations/saml_test.clj
index 7c7a988b3e8..3e460282d91 100644
--- a/enterprise/backend/test/metabase_enterprise/sso/integrations/saml_test.clj
+++ b/enterprise/backend/test/metabase_enterprise/sso/integrations/saml_test.clj
@@ -3,8 +3,8 @@
[clojure.set :as set]
[clojure.string :as str]
[clojure.test :refer :all]
- [metabase-enterprise.sso.integrations.saml :as saml.mt]
[metabase-enterprise.sso.integrations.token-utils :as token-utils]
+ [metabase-enterprise.sso.providers.saml :as saml.p]
[metabase-enterprise.sso.settings :as sso-settings]
[metabase.appearance.settings :as appearance.settings]
[metabase.premium-features.token-check :as token-check]
@@ -754,13 +754,9 @@
(with-saml-default-setup!
(with-redefs [sso-settings/saml-user-provisioning-enabled? (constantly false)
appearance.settings/site-name (constantly "test")]
- (is
- (thrown-with-msg?
- clojure.lang.ExceptionInfo
- #"Sorry, but you'll need a test account to view this page. Please contact your administrator."
- (#'saml.mt/fetch-or-create-user! {:first-name "Test"
- :last-name "user"
- :email "[email protected]"}))))))))
+ (let [req-options (saml-post-request-options (new-user-saml-test-response)
+ default-redirect-uri)]
+ (client/client-real-response :post 401 "/auth/sso" req-options)))))))
(deftest logout-should-delete-session-test-slo-enabled
(testing "Successful SAML SLO logouts should delete the user's session, when saml-slo-enabled."
@@ -903,7 +899,7 @@
(do-with-some-validators-disabled!
(fn []
;; Mock the saml-response->attributes function to return mixed attribute types
- (with-redefs [saml.mt/saml-response->attributes
+ (with-redefs [saml.p/saml-response->attributes
(fn [_]
{"http://schemas.xmlsoap.org/ws/2005/05/identity/claims/emailaddress" "[email protected]"
"http://schemas.xmlsoap.org/ws/2005/05/identity/claims/givenname" "Rasta"
diff --git a/enterprise/backend/test/metabase_enterprise/sso/integrations/sso_utils_test.clj b/enterprise/backend/test/metabase_enterprise/sso/integrations/sso_utils_test.clj
index 93f130d6ed6..64ea0003625 100644
--- a/enterprise/backend/test/metabase_enterprise/sso/integrations/sso_utils_test.clj
+++ b/enterprise/backend/test/metabase_enterprise/sso/integrations/sso_utils_test.clj
@@ -1,6 +1,5 @@
(ns metabase-enterprise.sso.integrations.sso-utils-test
(:require
- [clojure.string :as str]
[clojure.test :refer :all]
[metabase-enterprise.sso.integrations.sso-utils :as sso-utils]
[metabase.test :as mt]))
@@ -22,37 +21,3 @@
"not a url"
"localhost:3000" ; URI thinks `localhost` here is scheme
"http://localhost:3000?a=not a param"))))
-
-(def default-user-attributes {:first_name "Test"
- :last_name "User"
- :sso_source :jwt
- :login_attributes {:foo "bar"}})
-
-(deftest create-new-sso-user-test
- (mt/with-model-cleanup [:model/User]
- (testing "create-new-sso-user! creates a new user with the given attributes"
- (let [new-user (sso-utils/create-new-sso-user! default-user-attributes)]
- (is (partial=
- {:first_name "Test"
- :last_name "User"
- :email "[email protected]"}
- new-user))))
- (testing "If a user with the given email already exists, a generic exception is thrown"
- (is
- (thrown-with-msg?
- clojure.lang.ExceptionInfo
- #"Error creating new SSO user"
- (sso-utils/create-new-sso-user! default-user-attributes))))))
-
-(deftest create-new-sso-user-do-not-send-email-test
- ;; when create a normal user, we send an invite email, but for sso users we don't
- (testing "creating an sso users shouldn't send an invite email"
- (mt/with-model-cleanup [:model/User]
- (mt/with-fake-inbox
- (sso-utils/create-new-sso-user! default-user-attributes)
- (is (empty? (->> @mt/inbox
- vals
- (into [] cat)
- (map :subject)
- (filter #(str/includes? % "You're invited to join")))))))))
diff --git a/resources/migrations/058_update_migrations.yaml b/resources/migrations/058_update_migrations.yaml
index 4480f2d6195..a0c1cdafe6c 100644
--- a/resources/migrations/058_update_migrations.yaml
+++ b/resources/migrations/058_update_migrations.yaml
@@ -38,6 +38,468 @@ databaseChangeLog:
tableName: report_card
columnName: embedding_type
+ - changeSet:
+ id: v58.2025-11-04T23:09:49
+ author: edpaget
+ comment: Create auth_identity table for multi-authentication support
+ changes:
+ - createTable:
+ tableName: auth_identity
+ remarks: Stores authentication credentials for users. A user can have multiple auth identities.
+ columns:
+ - column:
+ name: id
+ type: int
+ remarks: Integer primary key
+ autoIncrement: true
+ constraints:
+ primaryKey: true
+ nullable: false
+ - column:
+ name: user_id
+ type: int
+ remarks: Foreign key to core_user
+ constraints:
+ nullable: false
+ - column:
+ name: provider
+ type: varchar(50)
+ remarks: Authentication provider type (password, google, ldap, saml, jwt, support)
+ constraints:
+ nullable: false
+ - column:
+ name: credentials
+ type: ${text.type}
+ remarks: JSON object containing provider-specific credentials
+ constraints:
+ nullable: true
+ - column:
+ name: metadata
+ type: ${text.type}
+ remarks: JSON object containing provider-specific metadata
+ constraints:
+ nullable: true
+ - column:
+ name: provider_id
+ type: varchar(255)
+ remarks: Provider-specific identifier (email for password/Google, DN for LDAP, subject for SAML/JWT)
+ constraints:
+ nullable: true
+ - column:
+ name: last_used_at
+ type: ${timestamp_type}
+ remarks: Timestamp of last successful authentication
+ constraints:
+ nullable: true
+ - column:
+ name: expires_at
+ type: ${timestamp_type}
+ remarks: Timestamp when this authentication method expires (null = never expires)
+ constraints:
+ nullable: true
+ - column:
+ name: created_at
+ type: ${timestamp_type}
+ remarks: Timestamp when this identity was created
+ constraints:
+ nullable: false
+ - column:
+ name: updated_at
+ type: ${timestamp_type}
+ remarks: Timestamp when this identity was last updated
+ constraints:
+ nullable: false
+ rollback:
+ - dropTable:
+ tableName: auth_identity
+
+ - changeSet:
+ id: v58.2025-11-04T23:09:58
+ author: edpaget
+ comment: Add user_id index to auth_identity table
+ changes:
+ - createIndex:
+ tableName: auth_identity
+ indexName: idx_auth_identity_user_id
+ columns:
+ - column:
+ name: user_id
+ rollback:
+ - dropIndex:
+ tableName: auth_identity
+ indexName: idx_auth_identity_user_id
+
+ - changeSet:
+ id: v58.2025-11-04T23:10:00
+ author: edpaget
+ comment: Add provider index to auth_identity table
+ changes:
+ - createIndex:
+ tableName: auth_identity
+ indexName: idx_auth_identity_provider
+ columns:
+ - column:
+ name: provider
+ rollback:
+ - dropIndex:
+ tableName: auth_identity
+ indexName: idx_auth_identity_provider
+
+ - changeSet:
+ id: v58.2025-11-04T23:10:01
+ author: edpaget
+ comment: Add unique constraint to auth_identity table
+ changes:
+ - addUniqueConstraint:
+ tableName: auth_identity
+ columnNames: user_id, provider
+ constraintName: unique_auth_identity_user_provider
+ rollback:
+ - dropUniqueConstraint:
+ tableName: auth_identity
+ constraintName: unique_auth_identity_user_provider
+
+ - changeSet:
+ id: v58.2025-11-12T00:00:00
+ author: edpaget
+ comment: Add index on provider_id for efficient lookups
+ changes:
+ - createIndex:
+ tableName: auth_identity
+ indexName: idx_auth_identity_provider_id
+ columns:
+ - column:
+ name: provider_id
+ rollback:
+ - dropIndex:
+ tableName: auth_identity
+ indexName: idx_auth_identity_provider_id
+
+ - changeSet:
+ id: v58.2025-11-12T00:00:01
+ author: edpaget
+ comment: Add composite index on (provider, provider_id) for efficient lookups
+ changes:
+ - createIndex:
+ tableName: auth_identity
+ indexName: idx_auth_identity_provider_provider_id
+ columns:
+ - column:
+ name: provider
+ - column:
+ name: provider_id
+ rollback:
+ - dropIndex:
+ tableName: auth_identity
+ indexName: idx_auth_identity_provider_provider_id
+
+ - changeSet:
+ id: v58.2025-11-12T00:00:02
+ author: edpaget
+ comment: Add foreign key constraint from auth_identity to core_user
+ changes:
+ - addForeignKeyConstraint:
+ baseTableName: auth_identity
+ baseColumnNames: user_id
+ constraintName: fk_auth_identity_core_user_id
+ referencedTableName: core_user
+ referencedColumnNames: id
+ onDelete: CASCADE
+ rollback:
+ - dropForeignKeyConstraint:
+ baseTableName: auth_identity
+ constraintName: fk_auth_identity_core_user_id
+
+ - changeSet:
+ id: v58.2025-11-12T00:00:03
+ author: edpaget
+ comment: Migrate password authentication to auth_identity table
+ changes:
+ - sql:
+ dbms: postgresql
+ sql: >-
+ INSERT INTO auth_identity (user_id, provider, provider_id, credentials, metadata, created_at, updated_at)
+ SELECT
+ id,
+ 'password',
+ email,
+ json_build_object('password_hash', password, 'password_salt', password_salt)::text,
+ NULL,
+ COALESCE(date_joined, now()),
+ now()
+ FROM core_user
+ WHERE password IS NOT NULL
+ ON CONFLICT (user_id, provider) DO NOTHING;
+ - sql:
+ dbms: mysql,mariadb
+ sql: >-
+ INSERT IGNORE INTO auth_identity (user_id, provider, provider_id, credentials, metadata, created_at, updated_at)
+ SELECT
+ id,
+ 'password',
+ email,
+ json_object('password_hash', password, 'password_salt', password_salt),
+ NULL,
+ COALESCE(date_joined, now()),
+ now()
+ FROM core_user
+ WHERE password IS NOT NULL;
+ - sql:
+ dbms: h2
+ sql: >-
+ INSERT INTO auth_identity (user_id, provider, provider_id, credentials, metadata, created_at, updated_at)
+ SELECT
+ id,
+ 'password',
+ email,
+ CONCAT('{"password_hash":"', password, '","password_salt":"', password_salt, '"}'),
+ NULL,
+ COALESCE(date_joined, now()),
+ now()
+ FROM core_user
+ WHERE password IS NOT NULL
+ AND NOT EXISTS (
+ SELECT 1 FROM auth_identity ai
+ WHERE ai.user_id = core_user.id AND ai.provider = 'password'
+ );
+ rollback:
+ - sql: DELETE FROM auth_identity WHERE provider = 'password';
+
+ - changeSet:
+ id: v58.2025-11-12T00:00:04
+ author: edpaget
+ comment: Migrate LDAP authentication to auth_identity table
+ changes:
+ - sql:
+ dbms: postgresql
+ sql: >-
+ INSERT INTO auth_identity (user_id, provider, provider_id, credentials, metadata, created_at, updated_at)
+ SELECT
+ id,
+ 'ldap',
+ email,
+ NULL,
+ json_build_object('login_attributes', login_attributes)::text,
+ COALESCE(date_joined, now()),
+ now()
+ FROM core_user
+ WHERE sso_source = 'ldap'
+ ON CONFLICT (user_id, provider) DO NOTHING;
+ - sql:
+ dbms: mysql,mariadb
+ sql: >-
+ INSERT IGNORE INTO auth_identity (user_id, provider, provider_id, credentials, metadata, created_at, updated_at)
+ SELECT
+ id,
+ 'ldap',
+ email,
+ NULL,
+ json_object('login_attributes', login_attributes),
+ COALESCE(date_joined, now()),
+ now()
+ FROM core_user
+ WHERE sso_source = 'ldap';
+ - sql:
+ dbms: h2
+ sql: >-
+ INSERT INTO auth_identity (user_id, provider, provider_id, credentials, metadata, created_at, updated_at)
+ SELECT
+ id,
+ 'ldap',
+ email,
+ NULL,
+ CONCAT('{"login_attributes":', COALESCE(login_attributes, 'null'), '}'),
+ COALESCE(date_joined, now()),
+ now()
+ FROM core_user
+ WHERE sso_source = 'ldap'
+ AND NOT EXISTS (
+ SELECT 1 FROM auth_identity ai
+ WHERE ai.user_id = core_user.id AND ai.provider = 'ldap'
+ );
+ rollback:
+ - sql: DELETE FROM auth_identity WHERE provider = 'ldap';
+
+ - changeSet:
+ id: v58.2025-11-12T00:00:05
+ author: edpaget
+ comment: Migrate Google SSO authentication to auth_identity table
+ changes:
+ - sql:
+ dbms: postgresql
+ sql: >-
+ INSERT INTO auth_identity (user_id, provider, provider_id, credentials, metadata, created_at, updated_at)
+ SELECT
+ id,
+ 'google',
+ email,
+ NULL,
+ json_build_object('sso_source', 'google', 'login_attributes', login_attributes)::text,
+ COALESCE(date_joined, now()),
+ now()
+ FROM core_user
+ WHERE sso_source = 'google'
+ ON CONFLICT (user_id, provider) DO NOTHING;
+ - sql:
+ dbms: mysql,mariadb
+ sql: >-
+ INSERT IGNORE INTO auth_identity (user_id, provider, provider_id, credentials, metadata, created_at, updated_at)
+ SELECT
+ id,
+ 'google',
+ email,
+ NULL,
+ json_object('sso_source', 'google', 'login_attributes', login_attributes),
+ COALESCE(date_joined, now()),
+ now()
+ FROM core_user
+ WHERE sso_source = 'google';
+ - sql:
+ dbms: h2
+ sql: >-
+ INSERT INTO auth_identity (user_id, provider, provider_id, credentials, metadata, created_at, updated_at)
+ SELECT
+ id,
+ 'google',
+ email,
+ NULL,
+ CONCAT('{"sso_source":"google","login_attributes":', COALESCE(login_attributes, 'null'), '}'),
+ COALESCE(date_joined, now()),
+ now()
+ FROM core_user
+ WHERE sso_source = 'google'
+ AND NOT EXISTS (
+ SELECT 1 FROM auth_identity ai
+ WHERE ai.user_id = core_user.id AND ai.provider = 'google'
+ );
+ rollback:
+ - sql: DELETE FROM auth_identity WHERE provider = 'google';
+
+ - changeSet:
+ id: v58.2025-11-12T00:00:06
+ author: edpaget
+ comment: Migrate SAML and JWT authentication to auth_identity table
+ changes:
+ - sql:
+ dbms: postgresql
+ sql: >-
+ INSERT INTO auth_identity (user_id, provider, provider_id, credentials, metadata, created_at, updated_at)
+ SELECT
+ id,
+ sso_source,
+ email,
+ NULL,
+ json_build_object('sso_source', sso_source, 'login_attributes', login_attributes, 'jwt_attributes', jwt_attributes)::text,
+ COALESCE(date_joined, now()),
+ now()
+ FROM core_user
+ WHERE sso_source IN ('saml', 'jwt')
+ ON CONFLICT (user_id, provider) DO NOTHING;
+ - sql:
+ dbms: mysql,mariadb
+ sql: >-
+ INSERT IGNORE INTO auth_identity (user_id, provider, provider_id, credentials, metadata, created_at, updated_at)
+ SELECT
+ id,
+ sso_source,
+ email,
+ NULL,
+ json_object('sso_source', sso_source, 'login_attributes', login_attributes, 'jwt_attributes', jwt_attributes),
+ COALESCE(date_joined, now()),
+ now()
+ FROM core_user
+ WHERE sso_source IN ('saml', 'jwt');
+ - sql:
+ dbms: h2
+ sql: >-
+ INSERT INTO auth_identity (user_id, provider, provider_id, credentials, metadata, created_at, updated_at)
+ SELECT
+ id,
+ sso_source,
+ email,
+ NULL,
+ CONCAT('{"sso_source":"', sso_source, '","login_attributes":', COALESCE(login_attributes, 'null'), ',"jwt_attributes":', COALESCE(jwt_attributes, 'null'), '}'),
+ COALESCE(date_joined, now()),
+ now()
+ FROM core_user
+ WHERE sso_source IN ('saml', 'jwt')
+ AND NOT EXISTS (
+ SELECT 1 FROM auth_identity ai
+ WHERE ai.user_id = core_user.id AND ai.provider = core_user.sso_source
+ );
+ rollback:
+ - sql: DELETE FROM auth_identity WHERE provider IN ('saml', 'jwt');
+
+ - changeSet:
+ id: v58.2025-11-12T00:00:07
+ author: edpaget
+ comment: Add auth_identity_id columns to core_session table
+ changes:
+ - addColumn:
+ tableName: core_session
+ columns:
+ - column:
+ name: auth_identity_id
+ type: int
+ remarks: Foreign key to auth_identity - tracks which auth method was used for login
+ constraints:
+ nullable: true
+ rollback:
+ - dropColumn:
+ tableName: core_session
+ columnName: auth_identity_id
+
+ - changeSet:
+ id: v58.2025-11-12T00:00:08
+ author: edpaget
+ comment: Add expires_at columns to core_session table
+ changes:
+ - addColumn:
+ tableName: core_session
+ columns:
+ - column:
+ name: expires_at
+ type: ${timestamp_type}
+ remarks: Timestamp when this session expires (from auth_identity or calculated)
+ constraints:
+ nullable: true
+ rollback:
+ - dropColumn:
+ tableName: core_session
+ columnName: expires_at
+
+ - changeSet:
+ id: v58.2025-11-12T00:00:09
+ author: edpaget
+ comment: Add index on core_session.auth_identity_id
+ changes:
+ - createIndex:
+ tableName: core_session
+ indexName: idx_core_session_auth_identity_id
+ columns:
+ - column:
+ name: auth_identity_id
+ rollback:
+ - dropIndex:
+ tableName: core_session
+ indexName: idx_core_session_auth_identity_id
+
+ - changeSet:
+ id: v58.2025-11-12T00:00:10
+ author: edpaget
+ comment: Add foreign key constraint from core_session to auth_identity
+ changes:
+ - addForeignKeyConstraint:
+ baseTableName: core_session
+ baseColumnNames: auth_identity_id
+ constraintName: fk_session_auth_identity
+ referencedTableName: auth_identity
+ referencedColumnNames: id
+ onDelete: CASCADE
+ rollback:
+ - dropForeignKeyConstraint:
+ baseTableName: core_session
+ constraintName: fk_session_auth_identity
# >>>>>>>>>> DO NOT ADD NEW MIGRATIONS BELOW THIS LINE! ADD THEM ABOVE <<<<<<<<<<
diff --git a/src/metabase/auth_identity/core.clj b/src/metabase/auth_identity/core.clj
new file mode 100644
index 00000000000..db9a5166e32
--- /dev/null
+++ b/src/metabase/auth_identity/core.clj
@@ -0,0 +1,62 @@
+(ns metabase.auth-identity.core
+ "Public API for the auth_identity module. This namespace provides the interface for managing
+ authentication identities for users."
+ (:require
+ [metabase.auth-identity.models.auth-identity :as auth-identity]
+ [metabase.auth-identity.provider :as provider]
+ [metabase.auth-identity.providers.emailed-secret :as emailed-secret]
+ [metabase.auth-identity.session :as auth-session]
+ [potemkin :as p]))
+
+;; Import model query functions
+(p/import-vars
+ [auth-identity
+ hash-password-credentials])
+
+;; ==============================================================================
+;; Provider Multimethod System
+;; ==============================================================================
+;;
+;; The auth-identity module uses a multimethod-based provider system for authentication.
+;; Each provider (password, LDAP, Google, JWT, SAML) implements these three multimethods:
+;;
+;; - validate: Validate credentials before insert/update (throws on error)
+;; - authenticate: Core authentication logic (returns success/failure/redirect)
+;; - login!: Complete login orchestration (calls authenticate, creates session)
+;;
+;; ## Implementing a New Provider
+;;
+;; 1. Create a namespace for your provider (e.g., metabase.sso.providers.my-provider)
+;; 2. Declare hierarchy: (derive :provider/my-provider ::provider/provider)
+;; 3. For SSO providers: (derive :provider/my-provider ::provider/create-user-if-not-exists)
+;; 4. Implement authenticate multimethod (required)
+;; 5. Optionally implement validate for credential validation
+;;
+;; See metabase.auth-identity.provider namespace for detailed documentation and examples.
+;;
+;; ## Success States
+;;
+;; The authenticate and login! methods support three success states:
+;; - {:success? true ...} - Authentication succeeded
+;; - {:success? :redirect ...} - Need redirect to external provider (OAuth/OIDC)
+;; - {:success? false ...} - Authentication failed
+;;
+;; ==============================================================================
+
+(p/import-vars
+ [provider
+ validate
+ authenticate
+ login!
+ provider-string->keyword
+ provider-keyword->string])
+
+;; Import session integration functions
+(p/import-vars
+ [auth-session
+ create-session-with-auth-tracking!])
+
+;; Import emailed-secret provider functions
+(p/import-vars
+ [emailed-secret
+ create-password-reset!])
diff --git a/src/metabase/auth_identity/init.clj b/src/metabase/auth_identity/init.clj
new file mode 100644
index 00000000000..2e59785c8a6
--- /dev/null
+++ b/src/metabase/auth_identity/init.clj
@@ -0,0 +1,4 @@
+(ns metabase.auth-identity.init
+ (:require
+ [metabase.auth-identity.providers.emailed-secret]
+ [metabase.auth-identity.providers.password]))
diff --git a/src/metabase/auth_identity/models/auth_identity.clj b/src/metabase/auth_identity/models/auth_identity.clj
new file mode 100644
index 00000000000..4b8297e72c6
--- /dev/null
+++ b/src/metabase/auth_identity/models/auth_identity.clj
@@ -0,0 +1,138 @@
+(ns metabase.auth-identity.models.auth-identity
+ "Model definition for authentication identities. An AuthIdentity represents a method of authentication
+ for a User - a User can have multiple AuthIdentities (e.g., password + SSO)."
+ (:require
+ [java-time.api :as t]
+ [metabase.auth-identity.provider :as provider]
+ [metabase.models.interface :as mi]
+ [metabase.models.serialization :as serdes]
+ [metabase.util :as u]
+ [metabase.util.log :as log]
+ [metabase.util.password :as u.password]
+ [methodical.core :as methodical]
+ [toucan2.core :as t2]))
+
+(set! *warn-on-reflection* true)
+
+(methodical/defmethod t2/table-name :model/AuthIdentity
+ [_model]
+ :auth_identity)
+
+(doto :model/AuthIdentity
+ (derive :metabase/model)
+ (derive :hook/timestamped?)
+ (derive ::mi/read-policy.full-perms-for-perms-set)
+ (derive ::mi/write-policy.superuser))
+
+(defn- parse-credentials-timestamps-out
+ "Parse timestamp strings in credentials to java.time.Instant when reading from database."
+ [credentials]
+ (when credentials
+ (cond-> credentials
+ ;; Parse expires_at for emailed_secret providers
+ (and (string? (:expires_at credentials))
+ (:expires_at credentials))
+ (update :expires_at t/instant)
+
+ ;; Parse consumed_at for emailed_secret providers
+ (and (string? (:consumed_at credentials))
+ (:consumed_at credentials))
+ (update :consumed_at t/instant))))
+
+(t2/deftransforms :model/AuthIdentity
+ {:credentials {:in mi/json-in
+ :out (comp parse-credentials-timestamps-out mi/json-out-with-keywordization)}
+ :metadata mi/transform-json})
+
+(defmethod serdes/hash-fields :model/AuthIdentity
+ [_auth-identity]
+ [:user_id :provider :created_at])
+
+;;; ------------------------------------------------ Password Hashing ------------------------------------------------
+
+(defn hash-password-credentials
+ "Hash plaintext password in credentials if present. Returns updated credentials.
+
+ Accepts credentials map with either:
+ - :plaintext_password key (new format for AuthIdentity)
+ - Both :password_hash and :password_salt already present (already hashed)
+
+ Returns credentials map with :password_hash and :password_salt."
+ [{:keys [plaintext_password password_hash password_salt]}]
+ (cond
+ ;; Already hashed - return as is
+ (and password_hash password_salt)
+ {:password_hash password_hash
+ :password_salt password_salt}
+
+ ;; Has plaintext password - hash it
+ plaintext_password
+ (let [salt (str (random-uuid))
+ hash (u.password/hash-bcrypt (str salt plaintext_password))]
+ {:password_hash hash
+ :password_salt salt})
+
+ ;; No password data - return empty map
+ :else
+ {}))
+
+(t2/define-before-insert :model/AuthIdentity
+ [{:keys [provider] :as auth-identity}]
+ (provider/validate (provider/provider-string->keyword provider) auth-identity)
+ auth-identity)
+
+(t2/define-before-update :model/AuthIdentity
+ [{:keys [provider] :as auth-identity}]
+ (u/prog1 (cond-> auth-identity
+ (and (= provider "password")
+ (contains? (t2/changes auth-identity) :credentials))
+ (update :credentials hash-password-credentials))
+ (provider/validate (provider/provider-string->keyword provider) <>)))
+
+(t2/define-after-insert :model/AuthIdentity
+ [{:keys [user_id provider credentials] :as auth-identity}]
+ (when (= provider "emailed-secret-password-reset")
+ (let [{:keys [token_hash expires_at consumed_at]} credentials]
+ ;; Only sync to User if token is not consumed
+ (when-not consumed_at
+ (log/debugf "Syncing emailed-secret-password-reset AuthIdentity insert to User %s" user_id)
+ ;; Calculate reset_triggered from expires_at (work backward from expiration)
+ (let [ttl-ms (* 48 60 60 1000) ; 48 hours in milliseconds
+ reset-triggered (-> (t/instant expires_at)
+ (t/minus (t/millis ttl-ms))
+ t/to-millis-from-epoch)]
+ (t2/update! :model/User user_id
+ {:reset_token token_hash
+ :reset_triggered reset-triggered})))))
+ auth-identity)
+
+(t2/define-after-update :model/AuthIdentity
+ [{:keys [user_id provider credentials] :as auth-identity}]
+ (cond
+ ;; Handle password provider - sync to User table
+ (= provider "password")
+ (let [{:keys [password_hash password_salt]} credentials]
+ (when (and password_hash password_salt)
+ (t2/update! :model/User user_id
+ {:password password_hash
+ :password_salt password_salt})))
+
+ ;; Handle emailed-secret-password-reset provider - sync reset tokens to User table
+ (= provider "emailed-secret-password-reset")
+ (let [{:keys [token_hash expires_at consumed_at]} credentials]
+ (log/debugf "Syncing emailed-secret-password-reset AuthIdentity update to User %s" user_id)
+ (if consumed_at
+ ;; Token consumed - clear User table
+ (t2/update! :model/User
+ {:id user_id
+ :reset_token [:not= nil]}
+ {:reset_token nil
+ :reset_triggered nil})
+ ;; Token updated - sync to User table
+ (let [ttl-ms (* 48 60 60 1000)
+ reset-triggered (t/to-millis-from-epoch (t/minus expires_at (t/millis ttl-ms)))]
+ (t2/update! :model/User
+ {:id user_id}
+ {:reset_token token_hash
+ :reset_triggered reset-triggered})))))
+ auth-identity)
diff --git a/src/metabase/auth_identity/provider.clj b/src/metabase/auth_identity/provider.clj
new file mode 100644
index 00000000000..c7fa17e5097
--- /dev/null
+++ b/src/metabase/auth_identity/provider.clj
@@ -0,0 +1,390 @@
+(ns metabase.auth-identity.provider
+ "Provider multimethod system for authentication. This namespace defines the core protocol
+ that all authentication providers must implement.
+
+ The provider system uses three multimethods:
+ - validate: Validate credentials before database insert/update (throws on error)
+ - authenticate: Core authentication logic (returns success/failure/redirect)
+ - login!: Complete login orchestration (calls authenticate, creates session)
+
+ Providers are organized in a hierarchy:
+ - ::provider (root) - Base provider with default implementations
+ - ::create-user-if-not-exists - Mixin for SSO providers that auto-provision users
+
+ ## How to Implement a Provider
+
+ Each provider implementation should:
+ 1. Use a keyword in the :provider namespace (e.g., :provider/password)
+ 2. Declare hierarchy with (derive :provider/name ::provider/provider)
+ 3. For SSO providers that auto-create users, also (derive :provider/name ::provider/create-user-if-not-exists)
+ 4. Implement the authenticate multimethod (required)
+ 5. Optionally implement validate for credential validation
+
+ Example:
+ (ns metabase.sso.providers.my-provider
+ (:require [metabase.auth-identity.provider :as provider]
+ [methodical.core :as methodical]))
+
+ ;; Declare this provider derives from ::provider/provider
+ (derive :provider/my-provider ::provider/provider)
+
+ ;; For SSO providers that auto-create users:
+ (derive :provider/my-provider ::provider/create-user-if-not-exists)
+
+ ;; Implement authentication
+ (methodical/defmethod provider/authenticate :provider/my-provider
+ [_provider request]
+ {:success? true
+ :user-id 123
+ :auth-identity {...}})
+
+ ;; Optional: Implement validation
+ (methodical/defmethod provider/validate :provider/my-provider
+ [_provider auth-identity-data]
+ (when-not (valid? auth-identity-data)
+ (throw (ex-info \"Invalid credentials\" {:error :invalid}))))
+
+ Example provider implementations:
+ - metabase.auth-identity.providers.password (OSS)
+ - metabase.sso.providers.ldap (OSS)
+ - metabase.sso.providers.google (OSS)
+ - metabase-enterprise.sso.providers.jwt (Enterprise)
+ - metabase-enterprise.sso.providers.saml (Enterprise)"
+ (:require
+ [java-time.api :as t]
+ [metabase.auth-identity.session :as auth-session]
+ [metabase.events.core :as events]
+ [metabase.notification.core :as notification]
+ [metabase.premium-features.core :refer [defenterprise]]
+ [metabase.util :as u]
+ [metabase.util.i18n :refer [deferred-tru]]
+ [metabase.util.malli :as mu]
+ [metabase.util.malli.schema :as ms]
+ [methodical.core :as methodical]
+ [toucan2.core :as t2]))
+
+(set! *warn-on-reflection* true)
+
+;;; -------------------------------------------------- Provider Hierarchy --------------------------------------------------
+
+;; Provider hierarchy is defined by individual provider implementations
+;; Each provider namespace should use (derive :provider/name ::provider/provider)
+;; SSO providers that auto-provision users should also derive from ::provider/create-user-if-not-exists
+
+;;; -------------------------------------------------- Shared Error Messages --------------------------------------------------
+
+(def ^:private disabled-account-message (deferred-tru "Your account is disabled. Please contact your administrator."))
+(def ^:private disabled-account-snippet (deferred-tru "Your account is disabled."))
+
+;;; -------------------------------------------------- Multimethod: validate --------------------------------------------------
+
+(methodical/defmulti validate
+ "Validate credentials and settings for a provider before insert/update into AuthIdentity.
+ Throws an exception with error details if invalid. This ensures transaction rollback on validation failure.
+ Returns nil if valid.
+
+ This method is called from define-before-insert and define-before-update hooks in the AuthIdentity model.
+
+ Args:
+ provider: Provider keyword (e.g., ::provider/password)
+ auth-identity-data: Map containing :credentials, :metadata, etc.
+
+ Returns:
+ nil if valid
+
+ Throws:
+ ExceptionInfo if validation fails
+
+ Examples:
+ ;; Password provider validates credentials structure
+ (validate ::provider/password {:credentials {:password_hash \"...\" :password_salt \"...\"}})
+ => nil
+
+ ;; Throws if invalid
+ (validate ::provider/password {:credentials {:password_hash nil}})
+ => throws ExceptionInfo"
+ {:arglists '([provider auth-identity-data])}
+ (fn [provider _auth-identity-data]
+ provider))
+
+(methodical/defmethod validate ::provider
+ [_provider _auth-identity-data]
+ ;; Default: no validation (SSO providers typically don't need credential validation)
+ nil)
+
+;;; -------------------------------------------------- Multimethod: authenticate --------------------------------------------------
+
+(methodical/defmulti authenticate
+ "Authenticate a login request for a provider. This method handles the complete authentication logic
+ including token validation, credential verification, and user data extraction.
+
+ For token-based providers (JWT, Google OAuth, SAML), this method is responsible for:
+ - Verifying token signatures/validity
+ - Decoding tokens and extracting claims
+ - Validating assertions
+ - Extracting user information from the verified token
+
+ For credential-based providers (password, LDAP), this method verifies credentials against stored
+ or external data.
+
+ For OAuth/OIDC providers without tokens, this method returns redirect instructions to initiate
+ the external authentication flow.
+
+ Args:
+ provider: Provider keyword (e.g., ::provider/password)
+ request: Login request map (varies by provider, contains raw authentication data)
+
+ Returns:
+ Map with one of three result types:
+
+ 1. Success (authentication complete):
+ {:success? true
+ :user-id <id> ; User ID if user exists
+ :auth-identity <auth-identity> ; AuthIdentity record if found
+ :user-data <map> ; User data for provisioning (SSO providers)
+ :provider-id <string>} ; Provider-specific identifier (email for password/Google,
+ ; DN for LDAP, subject for SAML/JWT)
+
+ 2. Redirect needed (OAuth/OIDC flow initiation):
+ {:success? :redirect
+ :redirect-url <url> ; URL to redirect to external provider
+ :message <string>} ; Human-readable message
+
+ 3. Failure:
+ {:success? false
+ :error <keyword> ; Error type (:invalid-credentials, :account-disabled, etc.)
+ :message <string>} ; Human-readable error message
+
+ Examples:
+ ;; Password authentication
+ (authenticate ::provider/password {:email \"[email protected]\" :password \"secret\"})
+ => {:success? true :user-id 123 :auth-identity {...} :provider-id \"[email protected]\"}
+
+ ;; OAuth flow initiation
+ (authenticate ::provider/google {:redirect-url \"/dashboard\"})
+ => {:success? :redirect :redirect-url \"https://accounts.google.com/oauth/authorize?...\"}
+
+ ;; OAuth callback
+ (authenticate ::provider/google {:code \"abc123\" :state \"xyz\"})
+ => {:success? true :user-data {:email \"[email protected]\" ...} :provider-id \"[email protected]\"}
+
+ ;; Authentication failure
+ (authenticate ::provider/password {:email \"[email protected]\" :password \"wrong\"})
+ => {:success? false :error :invalid-credentials :message \"Password did not match stored password.\"}"
+ {:arglists '([provider request])}
+ (fn [provider _request]
+ provider))
+
+(methodical/defmethod authenticate ::provider
+ [provider _request]
+ (throw (ex-info (str "Authentication not implemented for provider: " provider)
+ {:provider provider})))
+
+(methodical/defmethod authenticate :after ::provider
+ [_provider result]
+ (if (and (:success? result)
+ (:auth-identity result))
+ (let [auth-identity (:auth-identity result)
+ expires-at (:expires_at auth-identity)]
+ (if (and expires-at
+ (t/before? (t/offset-date-time expires-at)
+ (t/offset-date-time)))
+ (assoc result
+ :success? false
+ :error :authentication-expired
+ :message (deferred-tru "This authentication method has expired. Please contact your administrator."))
+ result))
+ result))
+
+;;; -------------------------------------------------- Multimethod: login! --------------------------------------------------
+
+(methodical/defmulti login!
+ "Complete login flow: authenticate, create/find user if needed, create session.
+
+ This is called AFTER any external verification/redirects are complete and we have an identity
+ assertion. It does NOT handle OAuth redirects, SAML flows, or other external verification steps.
+
+ Args:
+ provider: Provider keyword (e.g., ::provider/password)
+ request: Login request map containing:
+ - Authentication data (credentials, tokens, etc.)
+ - :device-info - Device information for session tracking
+ - :redirect-url - Optional redirect URL after login
+
+ Returns:
+ Map with one of three result types:
+
+ 1. Success (authentication complete, session created):
+ {:success? true
+ :session <session-id> ; Session ID
+ :user <user-record> ; User record
+ :redirect-url <url>} ; Suggested redirect URL
+
+ 2. Redirect needed (OAuth/OIDC flow initiation, no session yet):
+ {:success? :redirect
+ :redirect-url <url> ; URL to redirect to external provider
+ :message <string>} ; Human-readable message
+
+ 3. Failure:
+ {:success? false
+ :error <keyword> ; Error type
+ :message <string>} ; Human-readable error message
+
+ Examples:
+ ;; Successful password login
+ (login! ::provider/password {:email \"...\" :password \"...\" :device-info {...}})
+ => {:success? true :session \"...\" :user {...} :redirect-url \"/\"}
+
+ ;; OAuth flow initiation
+ (login! ::provider/google {:redirect-url \"/dashboard\" :device-info {...}})
+ => {:success? :redirect :redirect-url \"https://accounts.google.com/oauth/...\"}
+
+ ;; Failed login
+ (login! ::provider/password {:email \"...\" :password \"wrong\" :device-info {...}})
+ => {:success? false :error :invalid-credentials :message \"...\"}"
+ {:arglists '([provider request])}
+ (fn [provider _request]
+ provider))
+
+(mu/defn- create-session!
+ "Create a new session for a user with the given provider.
+ Updates the last_used_at timestamp on the corresponding AuthIdentity."
+ [request :- [:map
+ [:user [:map
+ [:id ms/PositiveInt]
+ [:is_active :boolean]]]
+ [:device-info {:optional true} [:maybe [:map
+ [:device_id {:optional true} [:maybe ms/NonBlankString]]
+ [:device_description {:optional true} [:maybe ms/NonBlankString]]
+ [:ip_address {:optional true} [:maybe ms/NonBlankString]]]]]]
+ provider :- :keyword]
+ (if-not (get-in request [:user :is_active])
+ (assoc request :success? false
+ :error disabled-account-snippet
+ :message disabled-account-message)
+ (let [{:keys [user device-info]} request
+ session (auth-session/create-session-with-auth-tracking! user device-info provider)]
+ (assoc request :session session))))
+
+(methodical/defmethod login! ::provider
+ [provider request]
+ (cond
+ (= :redirect (:success? request))
+ request
+
+ (not (:success? request))
+ request
+
+ next-method
+ (next-method provider request)
+
+ :else
+ (let [redirect-url (or (:redirect-url request) "/")]
+ (assoc request
+ :success? true
+ :redirect-url redirect-url))))
+
+(methodical/defmethod login! :around ::provider
+ [provider request]
+ (as-> (merge request (authenticate provider request)) $
+ (assoc $ :user
+ (or (when-let [user-id (:user-id $)]
+ (t2/select-one [:model/User :id :is_active :last_login] :id user-id))
+ (when-let [email (get-in $ [:user-data :email])]
+ (t2/select-one [:model/User :id :is_active :last_login] :%lower.email (u/lower-case-en email)))))
+ (cond-> $
+ (and (:provider-id $) (:user-data $))
+ (assoc-in [:user-data :provider-id] (:provider-id $)))
+ (next-method provider $)
+ (cond-> $
+ (:user $) (create-session! provider))
+ (select-keys $ [:success? :user :redirect-url :error :message :user-data :session :jwt-data])))
+
+(defenterprise sso-user-fields
+ "Return the list of User model fields that should be populated from SSO user data.
+ OSS version includes basic fields. Enterprise version includes login_attributes and jwt_attributes."
+ metabase-enterprise.auth-identity.provider
+ []
+ [:email :first_name :last_name :sso_source])
+
+(mu/defn update-user!
+ "Updates a user from user-data in the request"
+ [{user-id :id} :- [:map [:id ms/PositiveInt]]
+ user-data :- [:map
+ [:email :string]
+ [:first_name {:optional true} [:maybe :string]]
+ [:last_name {:optional true} [:maybe :string]]
+ [:sso_source {:optional true} :keyword]
+ [:is_active {:optional true} :boolean]
+ [:jwt_attributes {:optional true} [:maybe :map]]
+ [:login_attributes {:optional true} [:maybe :map]]
+ [:provider-id {:optional true} [:maybe :string]]]
+ provider :- :keyword]
+ (t2/with-transaction [_]
+ (t2/update! :model/User user-id (select-keys user-data (conj (sso-user-fields) :is_active)))
+ (when-not (t2/exists? :model/AuthIdentity :user_id user-id :provider (name provider))
+ (t2/insert! :model/AuthIdentity (cond-> {:user_id user-id :provider (name provider)}
+ (:provider-id user-data) (assoc :provider_id (:provider-id user-data)))))
+ (t2/select-one [:model/User :id :is_active :last_login] user-id)))
+
+(mu/defn- create-user!
+ "Create a user from user-data in the request "
+ [user-data :- [:map
+ [:email :string]
+ [:first_name {:optional true} [:maybe :string]]
+ [:last_name {:optional true} [:maybe :string]]
+ [:sso_source {:optional true} :keyword]
+ [:jwt_attributes {:optional true} [:maybe :map]]
+ [:login_attributes {:optional true} [:maybe :map]]
+ [:provider-id {:optional true} [:maybe :string]]]
+ provider :- :keyword]
+ (t2/with-transaction [_]
+ (u/prog1
+ (t2/insert-returning-instance! [:model/User :id :last_login :is_active]
+ (select-keys user-data (sso-user-fields)))
+ (t2/insert! :model/AuthIdentity (cond-> {:user_id (:id <>) :provider (name provider)}
+ (:provider-id user-data) (assoc :provider_id (:provider-id user-data))))
+ (notification/with-skip-sending-notification true
+ (events/publish-event! :event/user-invited {:object (assoc (t2/select-one :model/User (:id <>))
+ :sso_source (name provider))})))))
+
+(methodical/defmethod login! ::create-user-if-not-exists
+ [provider request]
+ (let [user (or (when-let [user (:user request)]
+ (cond-> user
+ (:user-data request) (update-user! (:user-data request) provider)))
+ (when-let [user-data (:user-data request)]
+ (create-user! user-data provider)))
+ redirect-url (or (:redirect-url request) "/")]
+ (assoc request
+ :success? true
+ :user user
+ :redirect-url redirect-url)))
+
+(methodical/prefer-method! #'login! ::provider ::create-user-if-not-exists)
+
+;;; -------------------------------------------------- Helper Functions --------------------------------------------------
+
+(mu/defn provider-string->keyword :- :keyword
+ "Convert a provider string to a provider keyword in the :provider namespace.
+
+ Examples:
+ (provider-string->keyword \"password\")
+ => :provider/password
+
+ (provider-string->keyword \"google\")
+ => :provider/google"
+ [provider-str :- :string]
+ (keyword "provider" provider-str))
+
+(mu/defn provider-keyword->string :- :string
+ "Convert a provider keyword to a string for storage.
+
+ Examples:
+ (provider-keyword->string :provider/password)
+ => \"password\"
+
+ (provider-keyword->string :some-namespace/google)
+ => \"google\""
+ [provider :- :keyword]
+ (name provider))
diff --git a/src/metabase/auth_identity/providers/emailed_secret.clj b/src/metabase/auth_identity/providers/emailed_secret.clj
new file mode 100644
index 00000000000..a35d31aa3dd
--- /dev/null
+++ b/src/metabase/auth_identity/providers/emailed_secret.clj
@@ -0,0 +1,198 @@
+(ns metabase.auth-identity.providers.emailed-secret
+ "Provider for emailed secret tokens (password reset, email verification, magic links)."
+ (:require
+ [java-time.api :as t]
+ [metabase.auth-identity.provider :as provider]
+ [metabase.channel.email.messages :as messages]
+ [metabase.events.core :as events]
+ [metabase.util :as u]
+ [metabase.util.log :as log]
+ [metabase.util.malli :as mu]
+ [metabase.util.malli.schema :as ms]
+ [metabase.util.password :as u.password]
+ [methodical.core :as methodical]
+ [toucan2.core :as t2]))
+
+(set! *warn-on-reflection* true)
+
+(mu/defn create-reset-token-credentials
+ "Creates a credentials map for a password reset token with hashed token and expiration.
+
+ The `token` is the plaintext reset token that will be hashed using bcrypt. The optional `expires-in-ms` parameter
+ sets the token TTL in milliseconds (defaults to 48 hours). Returns a map containing `:token_hash`, `:expires_at`,
+ and `:consumed_at` (initially nil)."
+ [token :- :string
+ & {:keys [expires-in-ms]
+ :or {expires-in-ms (* 48 60 60 1000)}}]
+ {:token_hash (u.password/hash-bcrypt token)
+ :expires_at (t/plus (t/instant) (t/millis expires-in-ms))
+ :consumed_at nil})
+
+(mu/defn- create-reset-token-metadata
+ "Creates a metadata map for a password reset token containing the user's email and optional request context.
+
+ The `email` parameter is the user's email address. Optional keyword arguments `ip-address` and `user-agent` capture
+ request context information. Returns a map with `:email`, `:ip_address`, and `:request_context` (containing
+ `:user_agent` and `:timestamp`)."
+ [email :- ms/Email
+ & {:keys [ip-address user-agent]}]
+ {:email email
+ :ip_address ip-address
+ :request_context {:user_agent user-agent
+ :timestamp (t/instant)}})
+
+(mu/defn- verify-reset-token :- [:enum :valid :expired :consumed :invalid]
+ "Verifies a password reset token against stored credentials.
+
+ Checks the `token` against the provided `credentials` map and returns one of:
+ - `:valid` if the token matches and hasn't expired or been consumed
+ - `:expired` if the token matches but has passed its expiration time
+ - `:consumed` if the token has already been used
+ - `:invalid` if the token doesn't match the stored hash"
+ [token :- :string
+ credentials :- [:map
+ [:token_hash :string]
+ [:expires_at inst?]
+ [:consumed_at [:maybe inst?]]]]
+ (cond
+ (:consumed_at credentials)
+ :consumed
+ (t/after? (t/instant) (:expires_at credentials))
+ :expired
+ (u.password/bcrypt-verify token (:token_hash credentials))
+ :valid
+ :else
+ :invalid))
+
+(mu/defn- mark-token-consumed :- [:map [:credentials :map]]
+ "Marks a token as consumed by setting the `:consumed_at` timestamp in the auth-identity's credentials.
+
+ Takes an `auth-identity` map and returns an updated version with the current instant set as the `:consumed_at`
+ value in the credentials map."
+ [auth-identity :- [:map [:credentials :map]]]
+ (assoc-in auth-identity [:credentials :consumed_at] (t/instant)))
+
+(mu/defn- parse-token-user-id :- [:maybe ms/PositiveInt]
+ "Extracts the user ID from a password reset token.
+
+ Password reset tokens follow the format `USER-ID_RANDOM-UUID` (e.g., `123_abc-def-ghi`). Returns the user ID as an
+ integer if the token matches this format, or nil if the token format is invalid."
+ [token :- :string]
+ (when-let [[_ user-id-str] (re-matches #"(^\d+)_.+$" token)]
+ (try
+ (Integer/parseInt user-id-str)
+ (catch NumberFormatException _
+ nil))))
+
+(mu/defn- generate-reset-token :- :string
+ "Generates a password reset token for a user.
+
+ The token format is `USER-ID_RANDOM-UUID`, which allows efficient user lookup while maintaining uniqueness and
+ unpredictability."
+ [user-id :- ms/PositiveInt]
+ (str user-id \_ (random-uuid)))
+
+(mu/defn create-password-reset! :- :string
+ "Creates or updates a password reset token for a user and returns the plaintext token.
+
+ Generates a new reset token for the user identified by `user-id` and stores it in an [[AuthIdentity]] record with
+ provider `emailed-secret-password-reset`. If an AuthIdentity already exists for this user and provider, it will be
+ updated with the new token; otherwise a new AuthIdentity is created. The token is hashed before storage and
+ configured to expire in 48 hours.
+
+ Returns the plaintext token string that should be sent to the user via email."
+ [user-id :- ms/PositiveInt]
+ (u/prog1 (generate-reset-token user-id)
+ (t2/with-transaction [_]
+ (let [user (t2/select-one :model/User user-id)
+ auth-identity {:user_id user-id
+ :provider "emailed-secret-password-reset"
+ :provider_id (:email user)
+ :credentials (create-reset-token-credentials <>)
+ :metadata (create-reset-token-metadata (:email user))}]
+ (if-let [auth-identity-id (t2/select-one-pk :model/AuthIdentity :user_id user-id :provider "emailed-secret-password-reset")]
+ (t2/update! :model/AuthIdentity auth-identity-id auth-identity)
+ (t2/insert! :model/AuthIdentity auth-identity))))))
+
+;;; -------------------------------------------------- Provider Registration --------------------------------------------------
+
+;; Register emailed_secret provider in the hierarchy
+(derive :provider/emailed-secret :metabase.auth-identity.provider/provider)
+(derive :provider/emailed-secret-password-reset :provider/emailed-secret)
+
+;;; -------------------------------------------------- Multimethod Implementations --------------------------------------------------
+
+(methodical/defmethod provider/authenticate :provider/emailed-secret
+ "Authenticates a user using a password reset token.
+
+ The request map should contain a `:token` key with a password reset token in the format `USER-ID_RANDOM-UUID`.
+ Validates the token by checking it against the stored [[AuthIdentity]] credentials, verifying it hasn't expired or
+ been consumed.
+
+ Returns a map with `:success?` true and `:user-id` and `:auth-identity` on success, or `:success?` false with an
+ `:error` keyword (`:invalid-token`, `:expired-token`, `:consumed-token`, `:no-auth-identity`, or `:server-error`)
+ and human-readable `:message` on failure."
+ [provider {:keys [token]}]
+ (log/debug "Authenticating with emailed_secret provider for token")
+ (cond
+ (not token)
+ {:success? false
+ :error :invalid-request
+ :message "Reset token is required"}
+ :else
+ (try
+ (if-let [user-id (parse-token-user-id token)]
+ (if-let [auth-identity (t2/select-one :model/AuthIdentity
+ :user_id user-id
+ :provider (case provider
+ :provider/emailed-secret-password-reset "emailed-secret-password-reset"))]
+ (let [verification-result (verify-reset-token token (:credentials auth-identity))]
+ (case verification-result
+ :valid
+ (do
+ (log/debugf "Valid reset token for user %s" user-id)
+ {:success? true
+ :user-id user-id
+ :auth-identity auth-identity})
+ :expired
+ {:success? false
+ :error :expired-token
+ :message "Reset token has expired"}
+ :consumed
+ {:success? false
+ :error :consumed-token
+ :message "Reset token has already been used"}
+ :invalid
+ {:success? false
+ :error :invalid-token
+ :message "Reset token is invalid"}))
+ {:success? false
+ :error :no-auth-identity
+ :message "No reset token found for this user"})
+ {:success? false
+ :error :invalid-token
+ :message "Invalid token format"})
+ (catch Exception e
+ (log/error e "Unexpected error during reset token verification")
+ {:success? false
+ :error :server-error
+ :message "An unexpected error occurred during token verification"}))))
+
+(methodical/defmethod provider/login! :after :provider/emailed-secret-password-reset
+ "Completes the password reset process after successful authentication.
+
+ After a successful password reset authentication, this method:
+ - Publishes a password reset event or sends admin notification (for new users)
+ - Marks the reset token as consumed in the [[AuthIdentity]]
+ - Updates the user's password
+
+ All operations are performed within a transaction to ensure consistency."
+ [_provider {:keys [user password auth-identity] :as result}]
+ (when (:success? result)
+ (if (:last_login user)
+ (events/publish-event! :event/password-reset-successful {:object (assoc user :token (t2/select-one-fn :reset_token :model/User (:id user)))})
+ (messages/send-user-joined-admin-notification-email! (t2/select-one :model/User (:id user))))
+ (t2/with-transaction [_]
+ (t2/update! :model/AuthIdentity (:id auth-identity) (mark-token-consumed auth-identity))
+ (t2/update! :model/User (:id user) {:password password})))
+ result)
diff --git a/src/metabase/auth_identity/providers/password.clj b/src/metabase/auth_identity/providers/password.clj
new file mode 100644
index 00000000000..b74f8a7c70a
--- /dev/null
+++ b/src/metabase/auth_identity/providers/password.clj
@@ -0,0 +1,93 @@
+(ns metabase.auth-identity.providers.password
+ "Password authentication provider implementation."
+ (:require
+ [metabase.auth-identity.provider :as provider]
+ [metabase.util :as u]
+ [metabase.util.log :as log]
+ [metabase.util.malli :as mu]
+ [metabase.util.malli.schema :as ms]
+ [metabase.util.password :as u.password]
+ [methodical.core :as methodical]
+ [toucan2.core :as t2]))
+
+(set! *warn-on-reflection* true)
+
+;;; -------------------------------------------------- Provider Registration --------------------------------------------------
+
+;; Register password provider in the hierarchy
+(derive :provider/password ::provider/provider)
+
+;;; -------------------------------------------------- Multimethod Implementations --------------------------------------------------
+
+;; Fake salt & hash used to run bcrypt hash if user doesn't exist, to avoid timing attacks (Metaboat #134)
+(def ^:private fake-salt "ee169694-5eb6-4010-a145-3557252d7807")
+(def ^:private fake-hashed-password "$2a$10$owKjTym0ZGEEZOpxM0UyjekSvt66y1VvmOJddkAaMB37e0VAIVOX2")
+
+(methodical/defmethod provider/validate :provider/password
+ "Validate password credentials before insert/update into AuthIdentity.
+ Ensures password_hash and password_salt are present."
+ [_provider {:keys [credentials] :as _auth-identity-data}]
+ (let [{:keys [password_hash password_salt]} credentials]
+ (when-not password_hash
+ (throw (ex-info "password_hash is required for password provider"
+ {:error :invalid-credentials
+ :field :password_hash})))
+ (when-not password_salt
+ (throw (ex-info "password_salt is required for password provider"
+ {:error :invalid-credentials
+ :field :password_salt})))))
+
+(mu/defn- find-auth-identity-by-email
+ "Find an AuthIdentity record by email address."
+ [email :- ms/NonBlankString]
+ (when-let [user (t2/select-one :model/User :%lower.email (u/lower-case-en email))]
+ (t2/select-one :model/AuthIdentity
+ :user_id (:id user)
+ :provider "password")))
+
+(methodical/defmethod provider/authenticate :provider/password
+ "Authenticate a user with email and password.
+
+ Request format:
+ {:email \"[email protected]\"
+ :password \"secret123\"}
+
+ Returns:
+ Success: {:success? true
+ :user-id <id>
+ :auth-identity <auth-identity-record>}
+
+ Failure: {:success? false
+ :error :invalid-credentials
+ :message \"...\"}"
+ [_provider {:keys [email password] :as _request}]
+ (log/debugf "Authenticating with password provider for email: %s" email)
+
+ (cond
+ (not email)
+ {:success? false
+ :error :invalid-credentials
+ :message "Email is required"}
+
+ (not password)
+ {:success? false
+ :error :invalid-credentials
+ :message "Password is required"}
+
+ :else
+ (if-let [auth-identity (find-auth-identity-by-email email)]
+ (let [{:keys [password_hash password_salt]} (:credentials auth-identity)
+ password-matches? (u.password/verify-password password password_salt password_hash)]
+ (if password-matches?
+ {:success? true
+ :user-id (:user_id auth-identity)
+ :auth-identity auth-identity
+ :provider-id email}
+ {:success? false
+ :error :invalid-credentials
+ :message "Password did not match stored password."}))
+ ;; Still run bcrypt to prevent timing attacks
+ (do (u.password/verify-password password fake-salt fake-hashed-password)
+ {:success? false
+ :error :invalid-credentials
+ :message "No user found with that email address."}))))
diff --git a/src/metabase/auth_identity/session.clj b/src/metabase/auth_identity/session.clj
new file mode 100644
index 00000000000..7d711c39460
--- /dev/null
+++ b/src/metabase/auth_identity/session.clj
@@ -0,0 +1,41 @@
+(ns metabase.auth-identity.session
+ "Integration between AuthIdentity and Session systems. Provides wrappers around
+ session creation that track authentication provider usage."
+ (:require
+ [metabase.login-history.core :as login-history]
+ [metabase.request.core :as request]
+ [metabase.util :as u]
+ [metabase.util.log :as log]
+ [metabase.util.malli :as mu]
+ [metabase.util.string :as string]
+ [toucan2.core :as t2]))
+
+(set! *warn-on-reflection* true)
+
+(mu/defn create-session-with-auth-tracking!
+ "Create a new Session for a User and update the last_used_at timestamp on the corresponding AuthIdentity."
+ [user device-info provider]
+ (let [user-id (u/the-id user)
+ provider-str (name provider)
+ auth-identity (t2/select-one [:model/AuthIdentity :id :expires_at]
+ :user_id user-id
+ :provider provider-str)
+ auth-identity-id (:id auth-identity)
+ session-key (str (random-uuid))
+ session-id (string/random-string 12)
+ session (t2/insert-returning-instance! :model/Session
+ ;; Without setting the ID here we can't return an instance
+ ;; on MySQL
+ :id session-id
+ :user_id user-id
+ :auth_identity_id auth-identity-id
+ :session_key session-key
+ :expires_at (:expires_at auth-identity))]
+ (when provider-str
+ (log/debugf "Updating last_used_at for user %s with provider %s" user-id provider-str)
+ (t2/update! :model/AuthIdentity auth-identity-id {:last_used_at :%now}))
+ (when device-info
+ (login-history/record-login-history! session-id user device-info))
+ (assoc session
+ :key session-key
+ :type (if (some-> (request/current-request) request/embedded?) :full-app-embed :normal))))
diff --git a/src/metabase/cmd/copy.clj b/src/metabase/cmd/copy.clj
index 4ba5d02755c..393bbebc144 100644
--- a/src/metabase/cmd/copy.clj
+++ b/src/metabase/cmd/copy.clj
@@ -114,7 +114,9 @@
:model/NotificationRecipient
:model/NotificationCard
;; 57+
- :model/Glossary]
+ :model/Glossary
+ ;; 58+
+ :model/AuthIdentity]
(when config/ee-available?
[:model/Sandbox
:model/ConnectionImpersonation
diff --git a/src/metabase/cmd/reset_password.clj b/src/metabase/cmd/reset_password.clj
index 7a63c41bdf7..ad016a3cae1 100644
--- a/src/metabase/cmd/reset_password.clj
+++ b/src/metabase/cmd/reset_password.clj
@@ -1,7 +1,7 @@
(ns metabase.cmd.reset-password
(:require
[metabase.app-db.core :as mdb]
- [metabase.users.models.user :as user]
+ [metabase.auth-identity.core :as auth-identity]
[metabase.util :as u]
[metabase.util.i18n :refer [deferred-trs trs]]
[toucan2.core :as t2]))
@@ -14,7 +14,7 @@
(let [user-id (or (t2/select-one-pk :model/User, :%lower.email (u/lower-case-en email-address))
(throw (Exception. (str (deferred-trs "No user found with email address ''{0}''. " email-address)
(deferred-trs "Please check the spelling and try again.")))))]
- (user/set-password-reset-token! user-id)))
+ (auth-identity/create-password-reset! user-id)))
(defn reset-password!
"Reset the password for EMAIL-ADDRESS, and return the reset token in a format that can be understood by the Mac App."
diff --git a/src/metabase/core/init.clj b/src/metabase/core/init.clj
index a765ec48f5a..37f3cc84755 100644
--- a/src/metabase/core/init.clj
+++ b/src/metabase/core/init.clj
@@ -13,6 +13,7 @@
[metabase.app-db.init]
[metabase.appearance.init]
[metabase.audit-app.init]
+ [metabase.auth-identity.init]
[metabase.batch-processing.init]
[metabase.bug-reporting.init]
[metabase.cache.init]
diff --git a/src/metabase/models/resolution.clj b/src/metabase/models/resolution.clj
index 81d944a0b42..795539461ea 100644
--- a/src/metabase/models/resolution.clj
+++ b/src/metabase/models/resolution.clj
@@ -16,6 +16,7 @@
:model/ApiKey metabase.api-keys.models.api-key
:model/ApplicationPermissionsRevision metabase.permissions.models.application-permissions-revision
:model/AuditLog metabase.audit-app.models.audit-log
+ :model/AuthIdentity metabase.auth-identity.models.auth-identity
:model/BookmarkOrdering metabase.bookmarks.models.bookmark
:model/CacheConfig metabase.cache.models.cache-config
:model/Card metabase.queries.models.card
diff --git a/src/metabase/notification/payload/impl/system_event.clj b/src/metabase/notification/payload/impl/system_event.clj
index b702433c95b..dc189fbccb4 100644
--- a/src/metabase/notification/payload/impl/system_event.clj
+++ b/src/metabase/notification/payload/impl/system_event.clj
@@ -1,6 +1,7 @@
(ns metabase.notification.payload.impl.system-event
(:require
[metabase.appearance.core :as appearance]
+ [metabase.auth-identity.core :as auth-identity]
[metabase.channel.email.messages :as messages]
[metabase.notification.payload.core :as notification.payload]
[metabase.session.core :as session]
@@ -13,7 +14,7 @@
(defn- join-url
[user-id redirect]
;; TODO: the reset token should come from the event-info, not generated here!
- (let [reset-token (user/set-password-reset-token! user-id)
+ (let [reset-token (auth-identity/create-password-reset! user-id)
should-link-to-login-page (and (sso/sso-enabled?)
(not (session/enable-password-login)))]
(if should-link-to-login-page
diff --git a/src/metabase/request/cookies.clj b/src/metabase/request/cookies.clj
index 7ca219e402c..ee3fb918d0a 100644
--- a/src/metabase/request/cookies.clj
+++ b/src/metabase/request/cookies.clj
@@ -136,20 +136,39 @@
{session-key :key
session-type :type
anti-csrf-token :anti_csrf_token
+ session-expires-at :expires_at
:as _session-instance} :- [:map [:key [:or
uuid?
[:re u/uuid-regex]]]]
request-time]
- (let [cookie-options (merge
+ (let [;; Calculate max-age based on session expiration if present
+ max-age-seconds (when session-expires-at
+ (let [expires-time (if (instance? java.time.OffsetDateTime session-expires-at)
+ session-expires-at
+ (t/offset-date-time session-expires-at))
+ now (t/offset-date-time request-time)
+ seconds-until-expiration (t/time-between now expires-time :seconds)]
+ (when (pos? seconds-until-expiration)
+ seconds-until-expiration)))
+ default-max-age-seconds (* 60 (config/config-int :max-session-age))
+ cookie-options (merge
(default-session-cookie-attributes session-type request)
{:http-only true}
- ;; If permanent cookies should be used, set the `Max-Age` directive; cookies with no
- ;; `Max-Age` and no `Expires` directives are session cookies, and are deleted when the
- ;; browser is closed.
- ;; See https://developer.mozilla.org/en-US/docs/Web/HTTP/Cookies#define_the_lifetime_of_a_cookie
- ;; max-session age-is in minutes; Max-Age= directive should be in seconds
- (when (use-permanent-cookies? request)
- {:max-age (* 60 (config/config-int :max-session-age))}))]
+ ;; If session has expires_at, use it to calculate max-age
+ ;; This overrides permanent cookie settings
+ (cond
+ ;; Session expires_at takes precedence
+ max-age-seconds
+ {:max-age (min max-age-seconds default-max-age-seconds)}
+
+ ;; Otherwise use permanent cookies if requested
+ ;; If permanent cookies should be used, set the `Max-Age` directive; cookies with no
+ ;; `Max-Age` and no `Expires` directives are session cookies, and are deleted when the
+ ;; browser is closed.
+ ;; See https://developer.mozilla.org/en-US/docs/Web/HTTP/Cookies#define_the_lifetime_of_a_cookie
+ ;; max-session age-is in minutes; Max-Age= directive should be in seconds
+ (use-permanent-cookies? request)
+ {:max-age default-max-age-seconds}))]
(when (and (= (request.settings/session-cookie-samesite) :none) (not (request.util/https? request)))
(log/warn
(str "Session cookie's SameSite is configured to \"None\", but site is served over an insecure connection."
diff --git a/src/metabase/session/api.clj b/src/metabase/session/api.clj
index 7a667507467..36144f4e072 100644
--- a/src/metabase/session/api.clj
+++ b/src/metabase/session/api.clj
@@ -5,26 +5,23 @@
[metabase.api.common :as api]
[metabase.api.macros :as api.macros]
[metabase.api.open-api :as open-api]
+ [metabase.auth-identity.core :as auth-identity]
[metabase.channel.email.messages :as messages]
[metabase.config.core :as config]
[metabase.events.core :as events]
[metabase.request.core :as request]
[metabase.session.models.session :as session]
- [metabase.session.settings :as session.settings]
+ [metabase.session.schema :as session.schema]
[metabase.settings.core :as setting]
[metabase.sso.core :as sso]
[metabase.system.core :as system]
- [metabase.users.models.user :as user]
[metabase.util :as u]
[metabase.util.i18n :refer [deferred-tru tru]]
[metabase.util.log :as log]
[metabase.util.malli :as mu]
[metabase.util.malli.schema :as ms]
- [metabase.util.password :as u.password]
[throttle.core :as throttle]
- [toucan2.core :as t2])
- (:import
- (com.unboundid.util LDAPSDKException)))
+ [toucan2.core :as t2]))
(set! *warn-on-reflection* true)
@@ -32,67 +29,52 @@
(def ^:private login-throttlers
{:username (throttle/make-throttler :username)
-
;; IP Address doesn't have an actual UI field so just show error by username
:ip-address (throttle/make-throttler :username, :attempts-threshold 50)})
(def ^:private password-fail-message (deferred-tru "Password did not match stored password."))
(def ^:private password-fail-snippet (deferred-tru "did not match stored password"))
-(def ^:private disabled-account-message (deferred-tru "Your account is disabled. Please contact your administrator."))
-(def ^:private disabled-account-snippet (deferred-tru "Your account is disabled."))
-
-;; Fake salt & hash used to run bcrypt hash if user doesn't exist, to avoid timing attacks (Metaboat #134)
-(def ^:private fake-salt "ee169694-5eb6-4010-a145-3557252d7807")
-(def ^:private fake-hashed-password "$2a$10$owKjTym0ZGEEZOpxM0UyjekSvt66y1VvmOJddkAaMB37e0VAIVOX2")
-
(mu/defn- ldap-login :- [:maybe [:map [:key ms/UUIDString]]]
"If LDAP is enabled and a matching user exists return a new Session for them, or `nil` if they couldn't be
authenticated."
[username password device-info :- request/DeviceInfo]
(when (sso/ldap-enabled)
- (try
- (when-let [user-info (sso/find-ldap-user username)]
- (when-not (sso/verify-ldap-password user-info password)
- ;; Since LDAP knows about the user, fail here to prevent the local strategy to be tried with a possibly
- ;; outdated password
- (throw (ex-info (str password-fail-message)
- {:status-code 401
- :errors {:password password-fail-snippet}})))
- ;; password is ok, return new session if user is not deactivated
- (let [user (sso/fetch-or-create-ldap-user! user-info)]
- (if (:is_active user)
- (session/create-session! :sso user device-info)
- (throw (ex-info (str disabled-account-message)
- {:status-code 401
- :errors {:_error disabled-account-snippet}})))))
- (catch LDAPSDKException e
- (log/error e "Problem connecting to LDAP server, will fall back to local authentication"))
- (catch dev.failsafe.TimeoutExceededException e
- (log/error e "Timeout from LDAP server, will fall back to local authentication"))
- ;; Failsafe wraps exceptions in a `FailsafeException` - unwrap these if necessary
- (catch dev.failsafe.FailsafeException e
- (let [cause (.getCause e)]
- (if (instance? LDAPSDKException cause)
- (log/error cause "Problem connecting to LDAP server, will fall back to local authentication")
- (throw e)))))))
+ (let [result (auth-identity/login! :provider/ldap
+ {:username username
+ :password password
+ :device-info device-info})]
+ (cond
+ ;; Fallback when the ldap operation fails
+ (contains? #{:ldap-error :server-error} (:error result))
+ nil
+
+ (= (:error result) :invalid-credentials)
+ (throw (ex-info (str password-fail-message)
+ {:status-code 401
+ :errors {:password password-fail-snippet}}))
+
+ (:success? result)
+ (:session result)
+
+ :else
+ (throw (ex-info (str (:message result)) {:errors {:_error (:error result)}
+ :status-code 401}))))))
(mu/defn- email-login :- [:maybe [:map [:key ms/UUIDString]]]
"Find a matching `User` if one exists and return a new Session for them, or `nil` if they couldn't be authenticated."
[username :- ms/NonBlankString
password :- [:maybe ms/NonBlankString]
device-info :- request/DeviceInfo]
- (if-let [user (t2/select-one [:model/User :id :password_salt :password :last_login :is_active], :%lower.email (u/lower-case-en username))]
- (when (u.password/verify-password password (:password_salt user) (:password user))
- (if (:is_active user)
- (session/create-session! :password user device-info)
- (throw (ex-info (str disabled-account-message)
- {:status-code 401
- :errors {:_error disabled-account-snippet}}))))
- (do
- ;; User doesn't exist; run bcrypt hash anyway to avoid leaking account existence in request timing
- (u.password/verify-password password fake-salt fake-hashed-password)
- nil)))
+ (let [result (auth-identity/login! :provider/password
+ {:email username
+ :password password
+ :device-info device-info})]
+ (cond
+ (contains? {:invalid-credentials :server-error} (:error result)) nil
+ (:success? result) (:session result)
+ :else (throw (ex-info (str (:message result)) {:errors {:_error (:error result)}
+ :status-code 401})))))
(def ^:private throttling-disabled? (config/config-bool :mb-disable-session-throttle))
@@ -102,7 +84,7 @@
(when-not throttling-disabled?
(throttle/check throttler throttle-key)))
-(mu/defn- login :- session/SessionSchema
+(mu/defn- login :- session.schema/SessionSchema
"Attempt to login with different avaialable methods with `username` and `password`, returning new Session ID or
throwing an Exception if login could not be completed."
[username :- ms/NonBlankString
@@ -123,7 +105,8 @@
(f)
(catch clojure.lang.ExceptionInfo e
(throw (ex-info (ex-message e)
- (assoc (ex-data e) :status-code 401))))))
+ (assoc (ex-data e) :status-code 401)
+ e)))))
(defmacro http-401-on-error
"Add `{:status-code 401}` to exception data thrown by `body`."
@@ -194,7 +177,7 @@
;; If user uses any SSO method to log in, no need to generate a reset token. Some cases for Google SSO
;; are exempted see `password-reset-allowed?`
(messages/send-password-reset-email! email sso-source nil is-active?)
- (let [reset-token (user/set-password-reset-token! user-id)
+ (let [reset-token (auth-identity/create-password-reset! user-id)
password-reset-url (str (system/site-url) "/auth/reset_password/" reset-token)]
(log/info password-reset-url)
(messages/send-password-reset-email! email nil password-reset-url is-active?)))
@@ -217,27 +200,6 @@
(forgot-password-impl email)
api/generic-204-no-content)
-(defn reset-token-ttl-ms
- "number of milliseconds a password reset is considered valid."
- []
- (* (session.settings/reset-token-ttl-hours) 60 60 1000))
-
-(defn- valid-reset-token->user
- "Check if a password reset token is valid. If so, return the `User` ID it corresponds to."
- [^String token]
- (when-let [[_ user-id] (re-matches #"(^\d+)_.+$" token)]
- (let [user-id (Integer/parseInt user-id)]
- (when-let [{:keys [reset_token reset_triggered], :as user} (t2/select-one [:model/User :id :last_login :reset_triggered
- :reset_token]
- :id user-id, :is_active true)]
- ;; Make sure the plaintext token matches up with the hashed one for this user
- (when (u/ignore-exceptions
- (u.password/bcrypt-verify token reset_token))
- ;; check that the reset was triggered within the last 48 HOURS, after that the token is considered expired
- (let [token-age (u/since-ms-wall-clock reset_triggered)]
- (when (< token-age (reset-token-ttl-ms))
- user)))))))
-
(def reset-password-throttler
"Throttler for password_reset. There's no good field to mark so use password as a default."
(throttle/make-throttler :password :attempts-threshold 10))
@@ -248,27 +210,19 @@
"Reset password with a reset token."
[_route-params
_query-params
- {:keys [token password]} :- [:map
- [:token ms/NonBlankString]
- [:password ms/ValidPassword]]
+ request-body :- [:map
+ [:token ms/NonBlankString]
+ [:password ms/ValidPassword]]
request]
(let [request-source (request/ip-address request)]
(throttle-check reset-password-throttler request-source))
- (or (when-let [{user-id :id, :as user} (valid-reset-token->user token)]
- (let [reset-token (t2/select-one-fn :reset_token :model/User :id user-id)]
- (user/set-password! user-id password)
- ;; if this is the first time the user has logged in it means that they're just accepted their Metabase invite.
- ;; Otherwise, send audit log event that a user reset their password.
- (if (:last_login user)
- (events/publish-event! :event/password-reset-successful {:object (assoc user :token reset-token)})
- ;; Send all the active admins an email :D
- (messages/send-user-joined-admin-notification-email! (t2/select-one :model/User :id user-id)))
- ;; after a successful password update go ahead and offer the client a new session that they can use
- (let [{session-key :key, :as session} (session/create-session! :password user (request/device-info request))
- response {:success true
- :session_id (str session-key)}]
- (request/set-session-cookies request response session (t/zoned-date-time (t/zone-id "GMT"))))))
- (api/throw-invalid-param-exception :password (tru "Invalid reset token"))))
+ (let [auth-result (auth-identity/login! :provider/emailed-secret-password-reset request-body)]
+ (if (:success? auth-result)
+ (request/set-session-cookies request
+ {:success true :session_id (get-in auth-result [:session :key])}
+ (:session auth-result)
+ (t/zoned-date-time (t/zone-id "GMT")))
+ (api/throw-invalid-param-exception :password (tru "Invalid reset token")))))
;; TODO (Cam 10/28/25) -- fix this endpoint route to use kebab-case for consistency with the rest of our REST API
#_{:clj-kondo/ignore [:metabase/validate-defendpoint-route-uses-kebab-case]}
@@ -277,7 +231,8 @@
[_route-params
{:keys [token]} :- [:map
[:token ms/NonBlankString]]]
- {:valid (boolean (valid-reset-token->user token))})
+ (let [auth-result (auth-identity/authenticate :provider/emailed-secret-password-reset {:token token})]
+ {:valid (:success? auth-result)}))
(api.macros/defendpoint :get "/properties"
"Get all properties and their values. These are the specific `Settings` that are readable by the current user, or are
@@ -291,25 +246,30 @@
"Login with Google Auth."
[_route-params
_query-params
- _body :- [:map
- [:token ms/NonBlankString]]
+ {:keys [token]} :- [:map
+ [:token ms/NonBlankString]]
request]
(when-not (sso/google-auth-client-id)
(throw (ex-info "Google Auth is disabled." {:status-code 400})))
- ;; Verify the token is valid with Google
(letfn [(do-login []
- (let [user (sso/do-google-auth request)
- {session-key :key, :as session} (session/create-session! :sso user (request/device-info request))
- response {:id (str session-key)}
- user (t2/select-one [:model/User :id :is_active], :email (:email user))]
- (if (and user (:is_active user))
- (request/set-session-cookies request
- response
- session
- (t/zoned-date-time (t/zone-id "GMT")))
- (throw (ex-info (str disabled-account-message)
+ (let [login-result (auth-identity/login! :provider/google
+ {:token token
+ :device-info (request/device-info request)})]
+ (cond
+ ;; Login succeeded
+ (:success? login-result)
+ (let [session (:session login-result)
+ response {:id (str (:key session))}]
+ (request/set-session-cookies request
+ response
+ session
+ (t/zoned-date-time (t/zone-id "GMT"))))
+
+ ;; Login failed
+ :else
+ (throw (ex-info (or (str (:message login-result)) "Authentication failed")
{:status-code 401
- :errors {:account disabled-account-snippet}})))))]
+ :errors {:_error (or (:error login-result) "Authentication failed")}})))))]
(http-401-on-error
(if throttling-disabled?
(do-login)
diff --git a/src/metabase/session/core.clj b/src/metabase/session/core.clj
index 67334bddcaa..8d397517ee0 100644
--- a/src/metabase/session/core.clj
+++ b/src/metabase/session/core.clj
@@ -9,7 +9,6 @@
(p/import-vars
[metabase.session.models.session
- create-session!
generate-session-key
generate-session-id
hash-session-key]
diff --git a/src/metabase/session/models/session.clj b/src/metabase/session/models/session.clj
index 2215ffa0109..eb514e68705 100644
--- a/src/metabase/session/models/session.clj
+++ b/src/metabase/session/models/session.clj
@@ -5,13 +5,11 @@
[buddy.core.nonce :as nonce]
[clojure.core.memoize :as memo]
[metabase.events.core :as events]
- [metabase.login-history.core :as login-history]
[metabase.request.core :as request]
[metabase.session.settings :as session.settings]
[metabase.util :as u]
[metabase.util.i18n :refer [tru]]
[metabase.util.malli :as mu]
- [metabase.util.malli.schema :as ms]
[metabase.util.string :as string]
[methodical.core :as methodical]
[toucan2.core :as t2]))
@@ -22,49 +20,6 @@
[]
(codecs/bytes->hex (nonce/random-bytes 16)))
-(methodical/defmethod t2/table-name :model/Session [_model] :core_session)
-
-(doto :model/Session
- (derive :metabase/model)
- (derive :hook/created-at-timestamped?))
-
-(t2/define-before-update :model/Session [_model]
- (throw (RuntimeException. "You cannot update a Session.")))
-
-(t2/define-before-insert :model/Session
- [session]
- (when (or (uuid? (:id session)) (string/valid-uuid? (:id session)))
- (throw (RuntimeException. "Session id should not be stored plaintext in the session table.")))
- (when (or (uuid? (:key_hashed session)) (string/valid-uuid? (:key_hashed session)))
- (throw (RuntimeException. "Session key should not be stored plaintext in the session table.")))
- (cond-> session
- (some-> (request/current-request) request/embedded?) (assoc :anti_csrf_token (random-anti-csrf-token))))
-
-(t2/define-after-insert :model/Session
- [{anti-csrf-token :anti_csrf_token, :as session}]
- (let [session-type (if anti-csrf-token :full-app-embed :normal)]
- (assoc session :type session-type)))
-
-(def ^:private CreateSessionUserInfo
- [:map
- [:id ms/PositiveInt]
- [:last_login :any]])
-
-(def SessionSchema
- "Schema for a Session."
- [:and
- [:map-of :keyword :any]
- [:map
- [:key string?]
- [:type [:enum :normal :full-app-embed]]]])
-
-(defmulti create-session!
- "Generate a new Session for a User. `session-type` is currently either `:password` (for email + password login) or
- `:sso` (for other login types). Returns the newly generated Session with the id as the plain-text session-key."
- {:arglists '([session-type user device-info])}
- (fn [session-type & _]
- session-type))
-
(def ^{:arglists '([session-key])} hash-session-key
"Hash the session-key for storage in the database"
(memo/lru (fn [^String session-key] (codecs/bytes->hex (buddy-hash/sha512 (.getBytes session-key java.nio.charset.StandardCharsets/US_ASCII)))) {} :lru/threshold 100))
@@ -79,28 +34,42 @@
[]
(string/random-string 12))
-(mu/defmethod create-session! :sso :- SessionSchema
- [_ user :- CreateSessionUserInfo device-info :- request/DeviceInfo]
- (let [session-key (generate-session-key)
- session-key-hashed (hash-session-key session-key)
- session-id (generate-session-id)
- session (first (t2/insert-returning-instances! :model/Session
- :id session-id
- :key_hashed session-key-hashed
- :user_id (u/the-id user)))]
- (assert (map? session))
+(methodical/defmethod t2/table-name :model/Session [_model] :core_session)
+
+(doto :model/Session
+ (derive :metabase/model)
+ (derive :hook/created-at-timestamped?))
+
+(t2/define-before-update :model/Session [_model]
+ (throw (RuntimeException. "You cannot update a Session.")))
+
+(t2/define-before-insert :model/Session
+ [{session-key :session_key :as session}]
+ (when (or (uuid? (:id session)) (string/valid-uuid? (:id session)))
+ (throw (ex-info "Session id should not be stored plaintext in the session table." {})))
+ (when (or (uuid? (:key_hashed session)) (string/valid-uuid? (:key_hashed session)))
+ (throw (ex-info "Session key should not be stored plaintext in the session table." {})))
+ ;; Check auth identity provider if provided
+ (when-let [auth-identity-id (:auth_identity_id session)]
+ (when-let [auth-identity (t2/select-one [:model/AuthIdentity :provider] :id auth-identity-id)]
+ (when (and (= "password" (:provider auth-identity))
+ (not (session.settings/enable-password-login)))
+ (throw (ex-info (str (tru "Password login is disabled for this instance."))
+ {:status-code 400})))))
+ (let [key-hashed (or (:key_hashed session) (hash-session-key session-key))]
+ (cond-> (-> session
+ (dissoc :session_key)
+ (assoc :key_hashed key-hashed))
+ ;; on mysql if the id is not supplied insert-returning-instance(s)! returns nil
+ ;; this is here to handle transitioning some tests
+ (not (:id session)) (assoc :id (generate-session-id))
+ (some-> (request/current-request) request/embedded?) (assoc :anti_csrf_token (random-anti-csrf-token)))))
+
+(t2/define-after-insert :model/Session
+ [session]
+ (when-let [user (t2/select-one :model/User (:user_id session))]
(let [event {:user-id (u/the-id user)}]
(events/publish-event! :event/user-login event)
(when (nil? (:last_login user))
- (events/publish-event! :event/user-joined event)))
- (login-history/record-login-history! session-id user device-info)
- (assoc session :key session-key)))
-
-(mu/defmethod create-session! :password :- SessionSchema
- [session-type
- user :- CreateSessionUserInfo
- device-info :- request/DeviceInfo]
- ;; this is actually the same as `create-session!` for `:sso` but we check whether password login is enabled.
- (when-not (session.settings/enable-password-login)
- (throw (ex-info (str (tru "Password login is disabled for this instance.")) {:status-code 400})))
- ((get-method create-session! :sso) session-type user device-info))
+ (events/publish-event! :event/user-joined event))))
+ session)
diff --git a/src/metabase/session/schema.clj b/src/metabase/session/schema.clj
new file mode 100644
index 00000000000..2a3785e065d
--- /dev/null
+++ b/src/metabase/session/schema.clj
@@ -0,0 +1,9 @@
+(ns metabase.session.schema)
+
+(def SessionSchema
+ "Schema for a Session."
+ [:and
+ [:map-of :keyword :any]
+ [:map
+ [:key string?]
+ [:type [:enum :normal :full-app-embed]]]])
diff --git a/src/metabase/setup/api.clj b/src/metabase/setup/api.clj
index 369d3a0dfc5..729a334314a 100644
--- a/src/metabase/setup/api.clj
+++ b/src/metabase/setup/api.clj
@@ -4,13 +4,12 @@
[metabase.analytics.core :as analytics]
[metabase.api.macros :as api.macros]
[metabase.appearance.core :as appearance]
+ [metabase.auth-identity.core :as auth-identity]
[metabase.events.core :as events]
[metabase.request.core :as request]
- [metabase.session.models.session :as session]
[metabase.settings.core :as setting]
[metabase.setup.core :as setup]
[metabase.system.core :as system]
- [metabase.users.models.user :as user]
[metabase.util :as u]
[metabase.util.i18n :as i18n :refer [tru]]
[metabase.util.malli :as mu]
@@ -50,10 +49,8 @@
:is_superuser true))
user-id (u/the-id new-user)]
;; this results in a second db call, but it avoids redundant password code so figure it's worth it
- (user/set-password! user-id password)
- ;; then we create a session right away because we want our new user logged in to continue the setup process
- (let [session (session/create-session! :password new-user device-info)]
- ;; return user ID, session ID, and the Session object itself
+ (t2/update! :model/AuthIdentity :provider "password" :user_id user-id {:credentials {:plaintext_password password}})
+ (let [session (auth-identity/create-session-with-auth-tracking! new-user device-info :provider/password)]
{:session-key (:key session), :user-id user-id, :session session})))
(defn- setup-set-settings! [{:keys [email site-name site-locale]}]
diff --git a/src/metabase/sso/core.clj b/src/metabase/sso/core.clj
index 477bde2394e..fd2e6b03d1c 100644
--- a/src/metabase/sso/core.clj
+++ b/src/metabase/sso/core.clj
@@ -10,13 +10,8 @@
(p/import-vars
[metabase.sso.common
sync-group-memberships!]
- [metabase.sso.google
- do-google-auth
- google-auth-create-new-user!]
[metabase.sso.ldap.default-implementation
- create-new-ldap-auth-user!
LDAPSettings
- ldap-groups->mb-group-ids
ldap-search-result->user-info]
[metabase.sso.settings
google-auth-client-id
@@ -25,20 +20,8 @@
send-new-sso-user-admin-email?
sso-enabled?])
-#_{:clj-kondo/ignore [:missing-docstring]}
-(p/import-def metabase.sso.ldap/find-user find-ldap-user)
-
-#_{:clj-kondo/ignore [:missing-docstring]}
-(p/import-def metabase.sso.ldap/verify-password verify-ldap-password)
-
-#_{:clj-kondo/ignore [:missing-docstring]}
-(p/import-def metabase.sso.ldap/fetch-or-create-user! fetch-or-create-ldap-user!)
-
#_{:clj-kondo/ignore [:missing-docstring]}
(p/import-def metabase.sso.ldap.default-implementation/UserInfo LDAPUserInfo)
-#_{:clj-kondo/ignore [:missing-docstring]}
-(p/import-def metabase.sso.ldap.default-implementation/all-mapped-group-ids all-mapped-ldap-group-ids)
-
#_{:clj-kondo/ignore [:missing-docstring]}
(p/import-def metabase.sso.ldap.default-implementation/search ldap-search)
diff --git a/src/metabase/sso/google.clj b/src/metabase/sso/google.clj
index be7920d2115..af7541db525 100644
--- a/src/metabase/sso/google.clj
+++ b/src/metabase/sso/google.clj
@@ -1,25 +1,25 @@
(ns metabase.sso.google
(:require
- [clj-http.client :as http]
[clojure.string :as str]
- [metabase.api.common :as api]
[metabase.sso.settings :as sso.settings]
- [metabase.users.models.user :as user]
- [metabase.users.schema :as users.schema]
[metabase.util :as u]
- [metabase.util.i18n :refer [deferred-tru tru]]
- [metabase.util.json :as json]
- [metabase.util.log :as log]
- [metabase.util.malli :as mu]
- [metabase.util.malli.schema :as ms]
- [toucan2.core :as t2]))
+ [metabase.util.i18n :refer [tru]]
+ [metabase.util.json :as json]))
-(def ^:private non-existant-account-message
- (deferred-tru "You''ll need an administrator to create a Metabase account before you can use Google to log in."))
+(defn google-auth-token-info
+ "Validates and parses Google Sign-In token information from an HTTP response.
-(def ^:private google-auth-token-info-url "https://www.googleapis.com/oauth2/v3/tokeninfo?id_token=%s")
+ Takes a `token-info-response` (an HTTP response map with `:status` and `:body` keys) and optionally a `client-id`
+ to validate against. If `client-id` is not provided, uses the configured Google auth client ID from settings.
-(defn- google-auth-token-info
+ Validates that:
+ - The response status is 200
+ - The token's audience (`:aud`) matches the expected client ID
+ - The email in the token is verified (`:email_verified` is `\"true\"`)
+
+ Returns the parsed token info as a Clojure map with keyword keys.
+
+ Throws an ex-info with a 400 status code if validation fails."
([token-info-response]
(google-auth-token-info token-info-response (sso.settings/google-auth-client-id)))
([token-info-response client-id]
@@ -37,53 +37,16 @@
(when-not (= (:email_verified <>) "true")
(throw (ex-info (tru "Email is not verified.") {:status-code 400})))))))
-(defn- autocreate-user-allowed-for-email? [email]
+(defn autocreate-user-allowed-for-email?
+ "Checks whether automatic user creation is allowed for the given email address.
+
+ Returns `true` if the `email` address belongs to one of the domains configured in the Google auth auto-create
+ accounts domain setting. The setting should be a comma-separated list of allowed domains.
+
+ Returns `false` if no domains are configured or if the email doesn't match any configured domain."
+ [email]
(boolean
(when-let [domains (sso.settings/google-auth-auto-create-accounts-domain)]
(some
(partial u/email-in-domain? email)
(str/split domains #"\s*,\s*")))))
-
-(defn- check-autocreate-user-allowed-for-email
- "Throws if an admin needs to intervene in the account creation."
- [email]
- (when-not (autocreate-user-allowed-for-email? email)
- (throw
- (ex-info (str non-existant-account-message)
- {:status-code 401
- :errors {:_error non-existant-account-message}}))))
-
-(mu/defn google-auth-create-new-user!
- "Create a new Google Auth user."
- [{:keys [email] :as new-user} :- users.schema/NewUser]
- (check-autocreate-user-allowed-for-email email)
- ;; this will just give the user a random password; they can go reset it if they ever change their mind and want to
- ;; log in without Google Auth; this lets us keep the NOT NULL constraints on password / salt without having to make
- ;; things hairy and only enforce those for non-Google Auth users
- (user/create-new-google-auth-user! new-user))
-
-(defn- maybe-update-google-user!
- "Update google user if the first or list name changed."
- [user first-name last-name]
- (when (or (not= first-name (:first_name user))
- (not= last-name (:last_name user)))
- (t2/update! :model/User (:id user) {:first_name first-name
- :last_name last-name}))
- (assoc user :first_name first-name :last_name last-name))
-
-(mu/defn- google-auth-fetch-or-create-user! :- (ms/InstanceOf :model/User)
- [first-name last-name email]
- (let [existing-user (t2/select-one [:model/User :id :email :last_login :first_name :last_name] :%lower.email (u/lower-case-en email))]
- (if existing-user
- (maybe-update-google-user! existing-user first-name last-name)
- (google-auth-create-new-user! {:first_name first-name
- :last_name last-name
- :email email}))))
-
-(defn do-google-auth
- "Call to Google to perform an authentication"
- [{{:keys [token]} :body, :as _request}]
- (let [token-info-response (http/post (format google-auth-token-info-url token))
- {:keys [given_name family_name email]} (google-auth-token-info token-info-response)]
- (log/infof "Successfully authenticated Google Sign-In token for: %s %s" given_name family_name)
- (api/check-500 (google-auth-fetch-or-create-user! given_name family_name email))))
diff --git a/src/metabase/sso/init.clj b/src/metabase/sso/init.clj
index c2fe5426cbd..7e459a53f31 100644
--- a/src/metabase/sso/init.clj
+++ b/src/metabase/sso/init.clj
@@ -1,3 +1,5 @@
(ns metabase.sso.init
(:require
+ [metabase.sso.providers.google]
+ [metabase.sso.providers.ldap]
[metabase.sso.settings]))
diff --git a/src/metabase/sso/ldap.clj b/src/metabase/sso/ldap.clj
index 3c5b89f7912..51bd6cc67f8 100644
--- a/src/metabase/sso/ldap.clj
+++ b/src/metabase/sso/ldap.clj
@@ -158,11 +158,6 @@
:interrupt? true}
(default-impl/find-user ldap-connection username (ldap-settings)))))
-(mu/defn fetch-or-create-user! :- (ms/InstanceOf :model/User)
- "Using the `user-info` (from [[find-user]]) get the corresponding Metabase user, creating it if necessary."
- [user-info :- default-impl/UserInfo]
- (default-impl/fetch-or-create-user! user-info (ldap-settings)))
-
(defn humanize-error-messages
"Convert raw error message responses from our LDAP tests into our normal api error response structure."
[{:keys [status message]}]
diff --git a/src/metabase/sso/ldap/default_implementation.clj b/src/metabase/sso/ldap/default_implementation.clj
index ec90623d3d4..adc947f3862 100644
--- a/src/metabase/sso/ldap/default_implementation.clj
+++ b/src/metabase/sso/ldap/default_implementation.clj
@@ -4,14 +4,10 @@
[clj-ldap.client :as ldap]
[clojure.string :as str]
[metabase.premium-features.core :refer [defenterprise-schema]]
- [metabase.sso.common :as sso.common]
- [metabase.users.core :as users.core]
- [metabase.users.schema :as users.schema]
[metabase.util :as u]
[metabase.util.log :as log]
[metabase.util.malli :as mu]
- [metabase.util.malli.schema :as ms]
- [toucan2.core :as t2])
+ [metabase.util.malli.schema :as ms])
(:import
(com.unboundid.ldap.sdk DN Filter LDAPConnectionPool)))
@@ -128,18 +124,6 @@
;;; --------------------------------------------- fetch-or-create-user! ----------------------------------------------
-(mu/defn create-new-ldap-auth-user!
- "Convenience for creating a new user via LDAP. This account is considered active immediately; thus all active admins
- will receive an email right away."
- [{:keys [email] :as new-user} :- users.schema/NewUser]
- (when-not (u/email? email)
- (throw (ex-info "Invalid email supplied by LDAP server" {})))
- (users.core/insert-new-user!
- (-> new-user
- ;; We should not store LDAP passwords
- (dissoc :password)
- (assoc :sso_source "ldap"))))
-
(mu/defn ldap-groups->mb-group-ids :- [:set ms/PositiveInt]
"Translate a set of a user's group DNs to a set of MB group IDs using the configured mappings."
[ldap-groups :- [:maybe [:sequential ms/NonBlankString]]
@@ -157,32 +141,3 @@
vals
flatten
set))
-
-(defenterprise-schema fetch-or-create-user! :- (ms/InstanceOf :model/User)
- "Using the `user-info` (from `find-user`) get the corresponding Metabase user, creating it if necessary."
- metabase-enterprise.sso.integrations.ldap
- [{:keys [first-name last-name email groups]} :- UserInfo
- {:keys [sync-groups?], :as settings} :- LDAPSettings]
-
- (let [user (t2/select-one [:model/User :id :last_login :first_name :last_name :is_active]
- :%lower.email (u/lower-case-en email))
- new-user (if user
- (let [old-first-name (:first_name user)
- old-last-name (:last_name user)
- user-changes (merge
- (when (not= first-name old-first-name) {:first_name first-name})
- (when (not= last-name old-last-name) {:last_name last-name}))]
- (if (seq user-changes)
- (do
- (t2/update! :model/User (:id user) user-changes)
- (t2/select-one [:model/User :id :last_login :is_active] :id (:id user))) ; Reload updated user
- user))
- (-> (create-new-ldap-auth-user! {:first_name first-name
- :last_name last-name
- :email email})
- (assoc :is_active true)))]
- (u/prog1 new-user
- (when sync-groups?
- (let [group-ids (ldap-groups->mb-group-ids groups settings)
- all-mapped-group-ids (all-mapped-group-ids settings)]
- (sso.common/sync-group-memberships! new-user group-ids all-mapped-group-ids))))))
diff --git a/src/metabase/sso/providers/google.clj b/src/metabase/sso/providers/google.clj
new file mode 100644
index 00000000000..86e0d8e8b3c
--- /dev/null
+++ b/src/metabase/sso/providers/google.clj
@@ -0,0 +1,73 @@
+(ns metabase.sso.providers.google
+ "Google OAuth authentication provider implementation."
+ (:require
+ [clj-http.client :as http]
+ [metabase.auth-identity.core :as auth-identity]
+ [metabase.sso.google :as sso.google]
+ [metabase.util.i18n :refer [tru]]
+ [metabase.util.log :as log]
+ [methodical.core :as methodical]))
+
+(set! *warn-on-reflection* true)
+
+;; Register Google OAuth provider
+(derive :provider/google :metabase.auth-identity.provider/provider)
+(derive :provider/google :metabase.auth-identity.provider/create-user-if-not-exists)
+
+(def ^:private google-auth-token-info-url "https://www.googleapis.com/oauth2/v3/tokeninfo?id_token=%s")
+
+(methodical/defmethod auth-identity/authenticate :provider/google
+ [_provider {:keys [token] :as _request}]
+ (cond
+ (not token)
+ {:success? false
+ :error :invalid-request
+ :message "Google ID token is required"}
+
+ :else
+ (try
+ (let [token-info-response (http/post (format google-auth-token-info-url token))
+ {:keys [first_name last_name email]} (sso.google/google-auth-token-info token-info-response)]
+ (log/infof "Successfully authenticated Google Sign-In token for: %s %s" first_name last_name)
+ ;; Always return user data - let login! handle account creation policy
+ {:success? true
+ :user-data {:email email
+ :first_name first_name
+ :last_name last_name
+ :sso_source :google}
+ :provider-id email})
+ (catch clojure.lang.ExceptionInfo e
+ (log/errorf e "Google authentication failed: %s" (.getMessage e))
+ {:success? false
+ :error :authentication-failed
+ :message (.getMessage e)})
+ (catch Exception e
+ (log/errorf e "Unexpected error during Google authentication: %s" (.getMessage e))
+ {:success? false
+ :error :server-error
+ :message "An unexpected error occurred during authentication"}))))
+
+(methodical/defmethod auth-identity/login! :provider/google
+ "Handle Google login with account creation policy enforcement.
+
+ This method checks if auto-creation is allowed for the user's email domain
+ before allowing the user to be created. If the user already exists, they can
+ log in regardless of the domain policy."
+ [provider request]
+ (cond
+ ;; Authentication needs redirect (shouldn't happen for Google but handle it)
+ (= :redirect (:success? request))
+ request
+
+ ;; Authentication failed
+ (not (:success? request))
+ request
+
+ ;; Authentication succeeded - check account creation policy
+ :else
+ (if (or (sso.google/autocreate-user-allowed-for-email? (get-in request [:user-data :email]))
+ (:user request))
+ (next-method provider request)
+ {:success? false
+ :error :account-creation-not-allowed
+ :message (tru "You''ll need an administrator to create a Metabase account before you can use Google to log in.")})))
diff --git a/src/metabase/sso/providers/ldap.clj b/src/metabase/sso/providers/ldap.clj
new file mode 100644
index 00000000000..23801405be4
--- /dev/null
+++ b/src/metabase/sso/providers/ldap.clj
@@ -0,0 +1,135 @@
+(ns metabase.sso.providers.ldap
+ "LDAP authentication provider implementation."
+ (:require
+ [metabase.auth-identity.core :as auth-identity]
+ [metabase.premium-features.core :refer [defenterprise]]
+ [metabase.sso.common :as sso.common]
+ [metabase.sso.ldap :as ldap]
+ [metabase.sso.ldap.default-implementation :as ldap.impl]
+ [metabase.util :as u]
+ [metabase.util.log :as log]
+ [methodical.core :as methodical]))
+
+(set! *warn-on-reflection* true)
+
+;;; -------------------------------------------------- Provider Registration --------------------------------------------------
+
+;; Register LDAP provider in the hierarchy
+(derive :provider/ldap :metabase.auth-identity.provider/provider)
+
+;; LDAP is an SSO provider that auto-creates users
+(derive :provider/ldap :metabase.auth-identity.provider/create-user-if-not-exists)
+
+;;; -------------------------------------------------- Multimethod Implementations --------------------------------------------------
+
+(methodical/defmethod auth-identity/authenticate :provider/ldap
+ "Authenticate a user with LDAP.
+
+ Request format:
+ {:username \"jsmith\"
+ :password \"secret123\"}
+
+ Returns:
+ Success: {:success? true
+ :user-data {:email \"[email protected]\"
+ :first_name \"John\"
+ :last_name \"Smith\"
+ :sso_source :ldap
+ :groups [\"cn=admins,ou=groups,dc=example,dc=com\"]}}
+
+ Failure: {:success? false
+ :error :invalid-credentials
+ :message \"...\"}"
+ [_provider {:keys [username password] :as _request}]
+ (log/debugf "Authenticating with LDAP provider for username: %s" username)
+
+ (cond
+ (not username)
+ {:success? false
+ :error :invalid-credentials
+ :message "Username is required"}
+
+ (not password)
+ {:success? false
+ :error :invalid-credentials
+ :message "Password is required"}
+
+ :else
+ (try
+ ;; Find user in LDAP
+ (if-let [user-info (ldap/find-user username)]
+ ;; Verify password
+ (if (ldap/verify-password user-info password)
+ ;; Success - return user data for auto-provisioning, including groups
+ {:success? true
+ :user-data {:email (:email user-info)
+ :first_name (:first-name user-info)
+ :last_name (:last-name user-info)
+ :sso_source :ldap
+ :login_attributes (:attributes user-info)
+ :groups (:groups user-info)}
+ :provider-id (:email user-info)}
+ ;; Password didn't match
+ {:success? false
+ :error :invalid-credentials
+ :message "Password did not match LDAP password."})
+ ;; User not found in LDAP
+ {:success? false
+ :error :ldap-error
+ :message "No user found with that username in LDAP."})
+ (catch clojure.lang.ExceptionInfo e
+ (log/error e "LDAP authentication error")
+ {:success? false
+ :error :ldap-error
+ :message (or (ex-message e) "LDAP authentication failed")})
+ (catch Exception e
+ (log/error e "Unexpected error during LDAP authentication")
+ {:success? false
+ :error :server-error
+ :message "An unexpected error occurred during authentication"}))))
+
+(defenterprise check-provision-ldap
+ "Throw if we cannot provision ldap users. Always nil on OSS."
+ metabase-enterprise.sso.integrations.ldap
+ []
+ nil)
+
+(methodical/defmethod auth-identity/login! :provider/ldap
+ "Handle ldap login aborting if user provisioning enabled (when running enterprise edition) and no user was found."
+ [provider request]
+ (cond
+ ;; Authentication needs redirect (shouldn't happen for Google but handle it)
+ (= :redirect (:success? request))
+ request
+
+ ;; Authentication failed
+ (not (:success? request))
+ request
+
+ ;; Authentication succeeded - check account creation policy
+ ;; TODO(edpaget): 2025/11/11 this should return an error condition instead of throwing
+ :else
+ (do (when-not (and (:user request) (get-in request [:user :is_active]))
+ (check-provision-ldap))
+ (next-method provider request))))
+
+(methodical/defmethod auth-identity/login! :after :provider/ldap
+ "Sync LDAP group memberships after successful login.
+
+ This method runs after the main login! flow completes successfully.
+ It extracts the LDAP groups from the authentication result and syncs
+ them with Metabase group memberships based on configured mappings."
+ [_provider result]
+ (u/prog1 result
+ (when (and (:success? result)
+ (:user result))
+ (let [settings (ldap/ldap-settings)
+ groups (get-in result [:user-data :groups])]
+ (when (and (:sync-groups? settings) groups)
+ (log/debugf "Syncing LDAP groups for user %s: %s" (get-in result [:user :id]) groups)
+ (try
+ (let [group-ids (ldap.impl/ldap-groups->mb-group-ids groups settings)
+ all-mapped-ids (ldap.impl/all-mapped-group-ids settings)]
+ (sso.common/sync-group-memberships! (:user result) group-ids all-mapped-ids))
+ (catch Exception e
+ (log/error e "Error syncing LDAP group memberships"))))))))
diff --git a/src/metabase/users/api.clj b/src/metabase/users/api.clj
index 56c9ec4d052..b423e54c342 100644
--- a/src/metabase/users/api.clj
+++ b/src/metabase/users/api.clj
@@ -7,14 +7,13 @@
[metabase.api.common :as api]
[metabase.api.macros :as api.macros]
[metabase.appearance.core :as appearance]
- [metabase.collections.models.collection :as collection]
- [metabase.config.core :as config]
+ [metabase.auth-identity.core :as auth-identity]
+ [metabase.collections.models.collection :as collection] [metabase.config.core :as config]
[metabase.events.core :as events]
[metabase.models.interface :as mi]
[metabase.permissions.core :as perms]
[metabase.premium-features.core :as premium-features]
[metabase.request.core :as request]
- [metabase.session.models.session :as session]
[metabase.sso.core :as sso]
[metabase.users.models.user :as user]
[metabase.users.schema :as users.schema]
@@ -547,10 +546,10 @@
(api/checkp (u.password/bcrypt-verify (str (:password_salt user) old_password) (:password user))
"old_password"
(tru "Invalid password")))
- (user/set-password! id password)
+ (t2/update! :model/AuthIdentity :provider "password" :user_id id {:credentials {:plaintext_password password}})
;; after a successful password update go ahead and offer the client a new session that they can use
(when (= id api/*current-user-id*)
- (let [{session-key :key, :as session} (session/create-session! :password user (request/device-info request))
+ (let [{session-key :key, :as session} (auth-identity/create-session-with-auth-tracking! user (request/device-info request) :provider/password)
response {:success true
:session_id (str session-key)}]
(request/set-session-cookies request response session (t/zoned-date-time (t/zone-id "GMT")))))))
diff --git a/src/metabase/users/core.clj b/src/metabase/users/core.clj
deleted file mode 100644
index ae9c8e57cc2..00000000000
--- a/src/metabase/users/core.clj
+++ /dev/null
@@ -1,11 +0,0 @@
-(ns metabase.users.core
- (:require
- [metabase.users.models.user]
- [potemkin :as p]))
-
-(comment
- (metabase.users.models.user/keep-me))
-
-(p/import-vars
- [metabase.users.models.user
- insert-new-user!])
diff --git a/src/metabase/users/models/user.clj b/src/metabase/users/models/user.clj
index b68def1ac91..cf35201717b 100644
--- a/src/metabase/users/models/user.clj
+++ b/src/metabase/users/models/user.clj
@@ -3,6 +3,7 @@
[clojure.data :as data]
[clojure.string :as str]
[honey.sql.helpers :as sql.helpers]
+ [java-time.api :as t]
[metabase.api.common :as api]
[metabase.config.core :as config]
[metabase.events.core :as events]
@@ -23,6 +24,7 @@
[metabase.util.password :as u.password]
[methodical.core :as methodical]
[toucan2.core :as t2]
+ [toucan2.pipeline :as t2.pipeline]
[toucan2.tools.default-fields :as t2.default-fields]))
(set! *warn-on-reflection* true)
@@ -56,17 +58,6 @@
:is_active true
:is_superuser false})
-(defn- hashed-password-values
- "When User `:password` is specified for an `INSERT` or `UPDATE`, add a new `:password_salt`, and hash the password."
- [{:keys [password], :as user}]
- (when password
- (assert (not (:password_salt user))
- ;; this is dev-facing so it doesn't need to be i18n'ed
- "Don't try to pass an encrypted password to insert! or update!. Password encryption is handled by pre- methods.")
- (let [salt (str (random-uuid))]
- {:password_salt salt
- :password (u.password/hash-bcrypt (str salt password))})))
-
(defn user-local-settings
"Returns the user's settings (defaulting to an empty map) or `nil` if the user/user-id isn't set"
[user-or-user-id]
@@ -77,32 +68,160 @@
(:settings user-or-user-id))
{})))
-(t2/define-before-insert :model/User
- [{:keys [email password reset_token locale sso_source], :as user}]
- ;; these assertions aren't meant to be user-facing, the API endpoints should be validation these as well.
- (assert (u/email? email))
- (assert ((every-pred string? (complement str/blank?)) password))
- (when-let [user-type (:type user)]
- (assert
- (contains? allowed-user-types user-type)))
+;;; -------------------------------------------------- Validation Helpers --------------------------------------------------
+
+(defn- validate-user-email!
+ "Validate that the email is in a valid format."
+ [email]
+ (assert (u/email? email) (tru "Invalid email: {0}" (pr-str email))))
+
+(defn- validate-user-locale!
+ "Validate that the locale is available in the system."
+ [locale]
(when locale
- (assert (i18n/available-locale? locale) (tru "Invalid locale: {0}" (pr-str locale))))
- (when (and sso_source (not (setup/has-user-setup)))
- ;; Only allow SSO users to be provisioned if the setup flow has been completed and an admin has been created
- (throw (Exception. (trs "Metabase instance has not been initialized"))))
- (premium-features/airgap-check-user-count)
- (merge
- insert-default-values
- user
- (hashed-password-values user)
- ;; lower-case the email before saving
- {:email (u/lower-case-en email)}
- ;; if there's a reset token encrypt that as well
- (when reset_token
- {:reset_token (u.password/hash-bcrypt reset_token)})
- ;; normalize the locale
- (when locale
- {:locale (i18n/normalized-locale-string locale)})))
+ (assert (i18n/available-locale? locale) (tru "Invalid locale: {0}" (pr-str locale)))))
+
+(defn- validate-user-type!
+ "Validate that the user type is one of the allowed types."
+ [user-type]
+ (when user-type
+ (assert (contains? allowed-user-types user-type)
+ (tru "Invalid user type: {0}" (pr-str user-type)))))
+
+(defn- validate-sso-setup!
+ "Validate that SSO users can only be created after initial setup is complete."
+ [sso-source]
+ (when (and sso-source (not (setup/has-user-setup)))
+ (throw (Exception. (trs "Metabase instance has not been initialized")))))
+
+(defn- validate-user-insert!
+ "Validate all constraints for user insertion."
+ [{:keys [email locale sso_source] user-type :type}]
+ (validate-user-email! email)
+ (validate-user-type! user-type)
+ (validate-user-locale! locale)
+ (validate-sso-setup! sso_source)
+ (premium-features/airgap-check-user-count))
+
+;;; -------------------------------------------------- Password Management --------------------------------------------------
+
+(defn- prepare-password-for-insert
+ "Hash password and prepare password fields for insertion.
+ Throws an exception if password_salt is already present (passwords should not be pre-hashed)."
+ [user]
+ (when (contains? user :password_salt)
+ (throw (ex-info "Don't try to hash passwords yourself" {})))
+ (let [pw (or (:password user) (random-uuid))
+ salt (str (random-uuid))
+ hash (u.password/hash-bcrypt (str salt pw))]
+ {:password hash
+ :password_salt salt}))
+
+(defn- prepare-password-for-update
+ "Conditionally hash password for updates. Returns password fields or nil.
+ Only hashes if password is present and password_salt is not (indicating a plaintext password)."
+ [{:keys [password password_salt]}]
+ (when (and password (not password_salt))
+ (prepare-password-for-insert {:password password})))
+
+(defn- sync-password-to-auth-identity!
+ "Synchronize password changes to AuthIdentity model and invalidate sessions."
+ [user-id]
+ (let [{salt :password_salt password :password} (t2/select-one [:model/User :email :password :password_salt] user-id)
+ pw-auth-identity (t2/select-one :model/AuthIdentity :user_id user-id :provider "password")]
+ (when (and password salt)
+ (cond
+ (nil? pw-auth-identity)
+ (t2/with-transaction [_]
+ (t2/insert! :model/AuthIdentity {:user_id user-id
+ :provider "password"
+ :credentials {:password_hash password
+ :password_salt salt}})
+ (t2/delete! (t2/table-name :model/Session) :user_id user-id))
+
+ (or (not= password (get-in pw-auth-identity [:credentials :password_hash]))
+ (not= salt (get-in pw-auth-identity [:credentials :password_salt])))
+ (t2/with-transaction [_]
+ (t2/update! :model/AuthIdentity (u/the-id pw-auth-identity) {:credentials {:password_hash password
+ :password_salt salt}})
+ (t2/delete! (t2/table-name :model/Session) :user_id user-id))
+
+ :else nil))))
+
+;;; -------------------------------------------------- Admin Group Management --------------------------------------------------
+
+(defn- handle-superuser-toggle!
+ "Add or remove user from admin group based on superuser status change.
+ Does nothing if superuser status hasn't changed."
+ [user-id superuser? in-admin-group?]
+ (when (some? superuser?)
+ (cond
+ (and superuser? (not in-admin-group?))
+ (perms/without-is-superuser-sync-on-add-to-admin-group
+ (perms/add-user-to-group! user-id (u/the-id (perms/admin-group))))
+
+ (and (not superuser?) in-admin-group?)
+ (perms/without-is-superuser-sync-on-add-to-admin-group
+ (perms/remove-user-from-group! user-id (u/the-id (perms/admin-group)))))))
+
+(defn- validate-last-admin-not-archived!
+ "Prevent archiving the last admin user by throwing an exception."
+ [in-admin-group? active?]
+ (when (and in-admin-group? (false? active?))
+ (perms/throw-if-last-admin!)))
+
+;;; -------------------------------------------------- User Archival --------------------------------------------------
+
+(defn- handle-user-archival!
+ "Clean up user subscriptions when user is archived."
+ [user-id active?]
+ (when (false? active?)
+ (t2/delete! 'PulseChannelRecipient :user_id user-id)))
+
+(defn- prepare-archival-timestamp
+ "Return a map with deactivated_at field based on is_active status.
+ Returns nil if active? is nil (no change to is_active)."
+ [active?]
+ (cond
+ active? {:deactivated_at nil}
+ (false? active?) {:deactivated_at :%now}
+ :else nil))
+
+;;; -------------------------------------------------- Field Normalization --------------------------------------------------
+
+(defn- normalize-user-fields
+ "Normalize email, locale, and reset token for database storage."
+ [user]
+ (cond-> user
+ (:email user) (update :email u/lower-case-en)
+ (:locale user) (update :locale i18n/normalized-locale-string)
+ ;; Only hash reset_token if it's not already a bcrypt hash (starts with $2a$ or $2b$)
+ (and (:reset_token user)
+ (not (re-matches #"^\$2[ab]\$.*" (:reset_token user))))
+ (update :reset_token u.password/hash-bcrypt)))
+
+(methodical/defmethod t2.pipeline/results-transform [#_query-type :toucan.query-type/insert.instances
+ #_model :model/User]
+ "Create the initial :model/AuthIdenity from the results of saving a user. We have to do it here rather than in
+ define-after-insert because we need to get the hashed password and salt to save to the auth-identity model, and
+ those fields are removed by the default-files transformer before after-insert is called."
+ [query-type model]
+ (comp (map (fn [{:keys [password password_salt id] :as user}]
+ (u/prog1 user
+ (when (and password password_salt)
+ (t2/insert! :model/AuthIdentity {:user_id id
+ :provider "password"
+ :credentials {:password_hash password
+ :password_salt password_salt}})))))
+ (binding [t2.default-fields/*skip-default-fields* false]
+ (next-method query-type model))))
+
+(t2/define-before-insert :model/User
+ [user]
+ (validate-user-insert! user)
+ (-> (merge insert-default-values user)
+ normalize-user-fields
+ (merge (prepare-password-for-insert user))))
(t2/define-after-insert :model/User
[{user-id :id, superuser? :is_superuser, :as user}]
@@ -121,51 +240,68 @@
(when superuser? (perms/admin-group))])]
(perms/allow-changing-all-users-group-members
(perms/without-is-superuser-sync-on-add-to-admin-group
- (perms/add-user-to-groups! user-id (map u/the-id groups)))))))
+ (perms/add-user-to-groups! user-id (map u/the-id groups)))))
+ (sync-password-to-auth-identity! user-id)))
(t2/define-before-update :model/User
[{:keys [id] :as user}]
- ;; when `:is_superuser` is toggled add or remove the user from the 'Admin' group as appropriate
- (let [{reset-token :reset_token
+ (let [changes (t2/changes user)
+ {:keys [email locale]
superuser? :is_superuser
- active? :is_active
- :keys [email locale]} (t2/changes user)
+ active? :is_active} changes
in-admin-group? (t2/exists? :model/PermissionsGroupMembership
:group_id (:id (perms/admin-group))
- :user_id id)]
- ;; Do not let the last admin archive themselves
- (when (and in-admin-group?
- (false? active?))
- (perms/throw-if-last-admin!))
- (when (some? superuser?)
- (cond
- (and superuser?
- (not in-admin-group?))
- (perms/without-is-superuser-sync-on-add-to-admin-group
- (perms/add-user-to-group! id (u/the-id (perms/admin-group))))
- ;; don't use [[t2/delete!]] here because that does the opposite and tries to update this user which leads to a
- ;; stack overflow of calls between the two. TODO - could we fix this issue by using a `post-delete` method?
- (and (not superuser?)
- in-admin-group?)
- (perms/without-is-superuser-sync-on-add-to-admin-group
- (perms/remove-user-from-group! id (u/the-id (perms/admin-group))))))
- ;; make sure email and locale are valid if set
- (when email
- (assert (u/email? email)))
- (when locale
- (assert (i18n/available-locale? locale) (tru "Invalid locale: {0}" (pr-str locale))))
- ;; delete all subscriptions to pulses/alerts/etc. if the User is getting archived (`:is_active` status changes)
- (when (false? active?)
- (t2/delete! 'PulseChannelRecipient :user_id id))
- ;; If we're setting the reset_token then encrypt it before it goes into the DB
- (cond-> user
- true (merge (hashed-password-values (t2/changes user)))
- reset-token (update :reset_token u.password/hash-bcrypt)
- locale (update :locale i18n/normalized-locale-string)
- email (update :email u/lower-case-en)
- ;; Set or clear deactivated_at if the :is_active key changes. Not used directly in product.
- active? (assoc :deactivated_at nil)
- (false? active?) (assoc :deactivated_at :%now))))
+ :user_id id)
+ hashed-pw (prepare-password-for-update changes)]
+ (validate-last-admin-not-archived! in-admin-group? active?)
+ (when email (validate-user-email! email))
+ (when locale (validate-user-locale! locale))
+ (handle-superuser-toggle! id superuser? in-admin-group?)
+ (handle-user-archival! id active?)
+ (merge user
+ (normalize-user-fields (t2/changes user))
+ hashed-pw
+ (when (or hashed-pw (and (contains? changes :password) (contains? changes :password_salt)))
+ {:reset_token nil :reset_triggered nil})
+ (prepare-archival-timestamp active?))))
+
+(t2/define-after-update :model/User
+ [{:keys [id] :as user}]
+ ;; Query the database to check if we need to sync reset token changes
+ ;; We can't rely on t2/changes in after-update hooks, so we compare current state
+ (let [{:keys [email reset_token reset_triggered]} (t2/select-one [:model/User :email :reset_token :reset_triggered] :id id)
+ current-auth-identity (t2/select-one :model/AuthIdentity
+ :user_id id
+ :provider "emailed-secret-password-reset")]
+ (sync-password-to-auth-identity! id)
+ (cond
+ ;; Token being cleared - mark as consumed in AuthIdentity
+ (and (nil? reset_token) current-auth-identity)
+ (do
+ (log/debugf "Syncing User %s reset_token clear to AuthIdentity - marking token consumed" id)
+ (t2/update! :model/AuthIdentity (:id current-auth-identity)
+ {:credentials (assoc (:credentials current-auth-identity) :consumed_at (t/instant))}))
+
+ ;; Token being set - create or update AuthIdentity
+ (and reset_token reset_triggered)
+ (let [ttl-ms (* 48 60 60 1000)
+ expires-at (t/plus (t/instant reset_triggered) (t/millis ttl-ms))
+ credentials {:token_hash reset_token
+ :expires_at expires-at
+ :consumed_at nil}]
+ (if current-auth-identity
+ (do
+ (log/debugf "Syncing User %s reset_token update to existing AuthIdentity %s" id (:id current-auth-identity))
+ (t2/update! :model/AuthIdentity (:id current-auth-identity)
+ {:credentials credentials}))
+ (do
+ (log/debugf "Syncing User %s reset_token insert to new AuthIdentity" id)
+ (t2/insert! :model/AuthIdentity
+ {:user_id id
+ :provider "emailed-secret-password-reset"
+ :credentials credentials
+ :metadata {:email email}}))))))
+ user)
(defn add-common-name
"Conditionally add a `:common_name` key to `user` by combining their first and last names, or using their email if names are `nil`.
@@ -277,7 +413,7 @@
;;; --------------------------------------------------- Helper Fns ---------------------------------------------------
-(declare form-password-reset-url set-password-reset-token!)
+(declare form-password-reset-url)
(def ^:private Invitor
"Map with info about the admin creating the user, used in the new user notification code"
@@ -285,16 +421,11 @@
[:email ms/Email]
[:first_name [:maybe ms/NonBlankString]]])
-(mu/defn insert-new-user!
- "Creates a new user, defaulting the password when not provided"
- [new-user :- users.schema/NewUser]
- (t2/insert-returning-instance! :model/User (update new-user :password #(or % (str (random-uuid))))))
-
(defn serdes-synthesize-user!
"Creates a new user with a default password, when deserializing eg. a `:creator_id` field whose email address doesn't
match any existing user."
[new-user]
- (insert-new-user! new-user))
+ (t2/insert-returning-instance! :model/User new-user))
(mu/defn create-and-invite-user!
"Convenience function for inviting a new `User` and sending them a welcome email.
@@ -302,7 +433,7 @@
notification to send an invite via email."
[new-user :- users.schema/NewUser invitor :- Invitor setup? :- :boolean]
;; create the new user
- (u/prog1 (insert-new-user! new-user)
+ (u/prog1 (t2/insert-returning-instance! :model/User new-user)
;; TODO make sure the email being sent synchronously.
(events/publish-event! :event/user-invited
{:object
@@ -317,36 +448,11 @@
"Convenience for creating a new user via Google Auth. This account is considered active immediately; thus all active
admins will receive an email right away."
[new-user :- users.schema/NewUser]
- (u/prog1 (insert-new-user! (assoc new-user :sso_source "google"))
+ (u/prog1 (t2/insert-returning-instance! :model/User new-user)
;; send an email to everyone including the site admin if that's set
(when (setting/get :send-new-sso-user-admin-email?)
((requiring-resolve 'metabase.channel.email.messages/send-user-joined-admin-notification-email!) <>, :google-auth? true))))
-;;; TODO -- it seems like maybe this should just be part of the [[pre-update]] logic whenever `:password` changes; then
-;;; we can remove this function altogether.
-(defn set-password!
- "Update the stored password for a specified `User`; kill any existing Sessions and wipe any password reset tokens.
-
- The password is automatically hashed with a random salt; this happens in [[hashed-password-values]] which is called
- by [[pre-insert]] or [[pre-update]])"
- [user-id password]
- ;; when changing/resetting the password, kill any existing sessions
- (t2/delete! (t2/table-name :model/Session) :user_id user-id)
- ;; NOTE: any password change expires the password reset token
- (t2/update! :model/User user-id
- {:password password
- :reset_token nil
- :reset_triggered nil}))
-
-(defn set-password-reset-token!
- "Updates a given `User` and generates a password reset token for them to use. Returns the URL for password reset."
- [user-id]
- {:pre [(integer? user-id)]}
- (u/prog1 (str user-id \_ (random-uuid))
- (t2/update! :model/User user-id
- {:reset_token <>
- :reset_triggered (System/currentTimeMillis)})))
-
(defn form-password-reset-url
"Generate a properly formed password reset url given a password reset token."
[reset-token]
diff --git a/test/metabase/app_db/custom_migrations_test.clj b/test/metabase/app_db/custom_migrations_test.clj
index 732b0e9fa16..2550d2081da 100644
--- a/test/metabase/app_db/custom_migrations_test.clj
+++ b/test/metabase/app_db/custom_migrations_test.clj
@@ -2200,7 +2200,7 @@
;;; 52 tests
;;;
-(deftest create-sample-content-test
+(deftest ^:mb/old-migrations-test create-sample-content-test
(testing "The sample content is created iff *create-sample-content*=true"
(doseq [create? [true false]]
(testing (str "*create-sample-content* = " create?)
@@ -2219,7 +2219,7 @@
:perm_value :read-and-write}
(t2/select-one :model/Permissions :collection_id id)))))))))))
-(deftest create-sample-content-test-2
+(deftest ^:mb/old-migrations-test create-sample-content-test-2
(testing "The sample content isn't created if the sample database existed already in the past (or any database for that matter)"
(impl/test-migrations "v52.2024-12-03T15:55:22" [migrate!]
(is (false? (sample-content-created?)))
@@ -2234,7 +2234,7 @@
(is (empty? (t2/query "SELECT * FROM metabase_database"))
"No database should have been created"))))
-(deftest create-sample-content-test-3
+(deftest ^:mb/old-migrations-test create-sample-content-test-3
(testing "The sample content isn't created if a user existed already"
(impl/test-migrations "v52.2024-12-03T15:55:22" [migrate!]
(is (false? (sample-content-created?)))
@@ -2341,7 +2341,7 @@
:multi-stage-question-id multi-stage-question-id
:multi-stage-model-id multi-stage-model-id}))
-(deftest set-stage-number-in-parameter-mappings-test
+(deftest ^:mb/old-migrations-test set-stage-number-in-parameter-mappings-test
(testing "v52.2024-10-26T18:42:42"
(impl/test-migrations ["v52.2024-10-26T18:42:42"] [migrate!]
(let [{:keys [dashboard-id
@@ -2443,7 +2443,7 @@
(no-stage-pattern multi-stage-model-id)]
(query-parameter-mappings))))))))
-(deftest set-stage-number-in-viz-settings-parameter-mappings-test
+(deftest ^:mb/old-migrations-test set-stage-number-in-viz-settings-parameter-mappings-test
(testing "v52.2024-11-12T15:13:18"
(impl/test-migrations ["v52.2024-11-12T15:13:18"] [migrate!]
(let [{:keys [dashboard-id
@@ -2555,7 +2555,7 @@
(query-viz-settings))))))))
;; see [[custom-migrations/MigrateAlertToNotification]] for info about how this migration works
-(deftest migrate-alert-to-notification-test
+(deftest ^:mb/old-migrations-test migrate-alert-to-notification-test
(testing "v53.2024-12-12T08:06:00: migrate alerts from pulse to notification"
(impl/test-migrations ["v53.2024-12-12T08:05:00"] [migrate!]
(binding [custom-migrations.util/*allow-temp-scheduling* true]
diff --git a/test/metabase/app_db/schema_migrations_test.clj b/test/metabase/app_db/schema_migrations_test.clj
index 54bb463049c..7f2e78acb9e 100644
--- a/test/metabase/app_db/schema_migrations_test.clj
+++ b/test/metabase/app_db/schema_migrations_test.clj
@@ -70,7 +70,7 @@
;; Kooky that I have to write this, but I do. Make sure people keep tests in order -- I don't want to find any more 52
;; tests sandwiched between 48 tests.
-(deftest ^:parallel order-your-migration-tests-test
+(deftest order-your-migration-tests-test
(testing "Migrations tests should be grouped together by major version and those major versions should be in order"
(let [versions (migrations-versions)]
(is (= (sort versions)
@@ -2723,7 +2723,7 @@
;;; 53+ tests should go below this line please <3
;;;
-(deftest migrate-download-results-perms-test
+(deftest ^:mb/old-migrations-test migrate-download-results-perms-test
(testing "Download results are set to no if view-data for a table is blocked"
(impl/test-migrations "v52.2025-05-28T00:00:01" [migrate!]
(let [db-id (t2/insert-returning-pk! (t2/table-name :model/Database) {:details "{}"
@@ -2746,7 +2746,7 @@
(migrate!)
(is (t2/exists? :model/DataPermissions :table_id table-id-1 :perm_value "no"))))))
-(deftest chinese-site-locale-migration-test
+(deftest ^:mb/old-migrations-test chinese-site-locale-migration-test
(testing "Site locale is migrated from zh to zh_CN"
(impl/test-migrations "v54.2025-03-17T18:52:44" [migrate!]
(t2/delete! (t2/table-name :model/Setting) :key "site-locale")
@@ -2754,10 +2754,117 @@
(migrate!)
(is (= "zh_CN" (t2/select-one-fn :value (t2/table-name :model/Setting) :key "site-locale"))))))
-(deftest chinese-user-locale-migration-test
+(deftest ^:mb/old-migrations-test chinese-user-locale-migration-test
(testing "Site locale is migrated from zh to zh_CN"
(impl/test-migrations "v54.2025-03-17T18:52:59" [migrate!]
(let [user-id (:id (create-raw-user! (mt/random-email)))]
(t2/update! (t2/table-name :model/User) user-id {:locale "zh"})
(migrate!)
(is (= "zh_CN" (t2/select-one-fn :locale (t2/table-name :model/User) :id user-id)))))))
+
+(deftest migrate-password-auth-test
+ (testing "Migration v58.2025-11-04T23:10:03: Migrate password authentication to auth_identity table"
+ (impl/test-migrations ["v58.2025-11-04T23:09:49" "v58.2025-11-12T00:00:03"] [migrate!]
+ ;; Insert users with password auth before migration
+ (t2/query-one {:insert-into :core_user
+ :values [{:first_name "Password"
+ :last_name "User"
+ :date_joined :%now
+ :password "hashed_password"
+ :password_salt "salt123"}
+ {:first_name "NoPassword"
+ :last_name "User"
+ :date_joined :%now
+ :password nil
+ :password_salt nil}]})
+ (migrate!)
+ ;; Verify password user has auth_identity
+ (let [results (mdb.query/query {:select [:u.first_name :a.provider]
+ :from [[:core_user :u]]
+ :left-join [[:auth_identity :a] [:= :u.id :a.user_id]]
+ :where [:in :u.email ["[email protected]" "[email protected]"]]
+ :order-by [[:u.id :asc]]})]
+ (is (= [{:first_name "Password" :provider "password"}
+ {:first_name "NoPassword" :provider nil}]
+ results))))))
+
+(deftest migrate-ldap-auth-test-2
+ (testing "Migration v58.2025-11-04T23:10:04: Migrate LDAP authentication to auth_identity table"
+ (impl/test-migrations ["v58.2025-11-04T23:09:49" "v58.2025-11-12T00:00:04"] [migrate!]
+ ;; Insert users with LDAP auth before migration (using sso_source='ldap' from current schema)
+ (t2/query-one {:insert-into :core_user
+ :values [{:first_name "LDAP"
+ :last_name "User"
+ :date_joined :%now
+ :sso_source "ldap"
+ :login_attributes "{\"dn\":\"cn=user,dc=example,dc=com\"}"}
+ {:first_name "NoLDAP"
+ :last_name "User"
+ :date_joined :%now
+ :sso_source nil}]})
+ (migrate!)
+ ;; Verify LDAP user has auth_identity
+ (let [results (mdb.query/query {:select [:u.first_name :a.provider]
+ :from [[:core_user :u]]
+ :left-join [[:auth_identity :a] [:= :u.id :a.user_id]]
+ :where [:in :u.email ["[email protected]" "[email protected]"]]
+ :order-by [[:u.id :asc]]})]
+ (is (= [{:first_name "LDAP" :provider "ldap"}
+ {:first_name "NoLDAP" :provider nil}]
+ results))))))
+
+(deftest migrate-google-sso-auth-test
+ (testing "Migration v58.2025-11-04T23:10:05: Migrate Google SSO authentication to auth_identity table"
+ (impl/test-migrations ["v58.2025-11-04T23:09:49" "v58.2025-11-12T00:00:05"] [migrate!]
+ ;; Insert users with Google SSO before migration
+ (t2/query-one {:insert-into :core_user
+ :values [{:first_name "Google"
+ :last_name "User"
+ :date_joined :%now
+ :sso_source "google"}
+ {:first_name "NoSSO"
+ :last_name "User"
+ :date_joined :%now
+ :sso_source nil}]})
+ (migrate!)
+ ;; Verify Google user has auth_identity
+ (let [results (mdb.query/query {:select [:u.first_name :a.provider]
+ :from [[:core_user :u]]
+ :left-join [[:auth_identity :a] [:= :u.id :a.user_id]]
+ :where [:in :u.email ["[email protected]" "[email protected]"]]
+ :order-by [[:u.id :asc]]})]
+ (is (= [{:first_name "Google" :provider "google"}
+ {:first_name "NoSSO" :provider nil}]
+ results))))))
+
+(deftest migrate-saml-jwt-auth-test
+ (testing "Migration v58.2025-11-04T23:10:06: Migrate SAML and JWT authentication to auth_identity table"
+ (impl/test-migrations ["v58.2025-11-04T23:09:49" "v58.2025-11-12T00:00:06"] [migrate!]
+ ;; Insert users with SAML and JWT before migration
+ (t2/query-one {:insert-into :core_user
+ :values [{:first_name "SAML"
+ :last_name "User"
+ :date_joined :%now
+ :sso_source "saml"}
+ {:first_name "JWT"
+ :last_name "User"
+ :date_joined :%now
+ :sso_source "jwt"}]})
+ (migrate!)
+ ;; Verify SAML and JWT users have auth_identity
+ (let [results (mdb.query/query {:select [:u.first_name :a.provider]
+ :from [[:core_user :u]]
+ :left-join [[:auth_identity :a] [:= :u.id :a.user_id]]
+ :where [:in :u.email ["[email protected]" "[email protected]"]]
+ :order-by [[:u.id :asc]]})]
+ (is (= [{:first_name "SAML" :provider "saml"}
+ {:first_name "JWT" :provider "jwt"}]
+ results))))))
diff --git a/test/metabase/auth_identity/core_test.clj b/test/metabase/auth_identity/core_test.clj
new file mode 100644
index 00000000000..833003bb066
--- /dev/null
+++ b/test/metabase/auth_identity/core_test.clj
@@ -0,0 +1,95 @@
+(ns metabase.auth-identity.core-test
+ "Integration tests for the AuthIdentity system."
+ (:require
+ [clojure.test :refer :all]
+ [metabase.test :as mt]
+ [toucan2.core :as t2]))
+
+(set! *warn-on-reflection* true)
+
+;;; -------------------------------------------------- Model Tests --------------------------------------------------
+
+(deftest auth-identity-model-test
+ (testing "AuthIdentity model basic operations"
+ (mt/with-temp [:model/User user {}]
+ (testing "can create an AuthIdentity"
+ (mt/with-model-cleanup [:model/AuthIdentity]
+ ;; Use google provider to avoid conflict with auto-created password AuthIdentity
+ (let [auth-identity (t2/insert-returning-instance! :model/AuthIdentity
+ {:user_id (:id user)
+ :provider "google"
+ :metadata {:email "[email protected]"}})]
+ (is (some? auth-identity))
+ (is (= (:id user) (:user_id auth-identity)))
+ (is (= "google" (:provider auth-identity)))
+ (is (= {:email "[email protected]"}
+ (:metadata auth-identity))))))
+ (testing "can update an AuthIdentity"
+ ;; Use the auto-created password AuthIdentity
+ (let [auth-identity (t2/select-one :model/AuthIdentity :user_id (:id user) :provider "password")]
+ (t2/update! :model/AuthIdentity (:id auth-identity)
+ {:credentials {:password_hash "new_hash"
+ :password_salt "new_salt"}})
+ (let [updated (t2/select-one :model/AuthIdentity :id (:id auth-identity))]
+ (is (= {:password_hash "new_hash" :password_salt "new_salt"}
+ (:credentials updated))))))
+ (testing "can delete an AuthIdentity"
+ ;; Create a google AuthIdentity to delete (don't delete the password one)
+ (mt/with-temp [:model/AuthIdentity auth-identity {:user_id (:id user)
+ :provider "google"}]
+ (t2/delete! :model/AuthIdentity :id (:id auth-identity))
+ (is (nil? (t2/select-one :model/AuthIdentity :id (:id auth-identity)))))))))
+
+(deftest auth-identity-json-transform-test
+ (testing "JSON transformation for credentials and metadata"
+ (mt/with-temp [:model/User user {}
+ :model/AuthIdentity auth-identity {:user_id (:id user)
+ :provider "google"
+ :metadata {:sso_source "google"
+ :login_attributes {:email "[email protected]"}}}]
+ (let [fetched (t2/select-one :model/AuthIdentity :id (:id auth-identity))]
+ (is (map? (:metadata fetched)))
+ (is (= "google" (get-in fetched [:metadata :sso_source])))
+ (is (= {:email "[email protected]"} (get-in fetched [:metadata :login_attributes])))))))
+
+(deftest auth-identity-unique-constraint-test
+ (testing "Cannot create duplicate AuthIdentity for same user and provider"
+ (mt/with-model-cleanup [:model/AuthIdentity :model/User]
+ (let [user-id (t2/insert-returning-pk! :model/User (mt/with-temp-defaults :model/User))]
+ (is (thrown-with-msg?
+ clojure.lang.ExceptionInfo
+ #"duplicate|Duplicate|Unique"
+ (t2/insert! :model/AuthIdentity
+ {:user_id user-id
+ :provider "password"
+ :credentials {:password_hash "different_hash" :password_salt "asdfasdf"}})))))))
+
+;;; -------------------------------------------------- Multiple Providers Test --------------------------------------------------
+
+(deftest multiple-providers-per-user-test
+ (testing "A user can have multiple authentication providers"
+ (mt/with-temp [:model/User user {}]
+ ;; User already has password AuthIdentity from creation
+ (let [password-auth (t2/select-one :model/AuthIdentity :user_id (:id user) :provider "password")
+ google-auth (t2/insert-returning-instance! :model/AuthIdentity
+ {:user_id (:id user)
+ :provider "google"
+ :metadata {:sso_source "google"}})
+ ldap-auth (t2/insert-returning-instance! :model/AuthIdentity
+ {:user_id (:id user)
+ :provider "ldap"
+ :metadata {:login_attributes {:uid "testuser"}}})]
+ (is (some? password-auth))
+ (is (some? google-auth))
+ (is (some? ldap-auth))
+ (let [providers (t2/select :model/AuthIdentity :user_id (:id user))]
+ (is (= 3 (count providers)))
+ (is (= #{"password" "google" "ldap"} (set (map :provider providers)))))
+ (is (some? (t2/select-one :model/AuthIdentity :user_id (:id user) :provider "password")))
+ (is (some? (t2/select-one :model/AuthIdentity :user_id (:id user) :provider "google")))
+ (is (some? (t2/select-one :model/AuthIdentity :user_id (:id user) :provider "ldap")))
+ (is (some? (:credentials password-auth)))
+ (is (= {:sso_source "google"}
+ (:metadata google-auth)))
+ (is (= {:login_attributes {:uid "testuser"}}
+ (:metadata ldap-auth)))))))
diff --git a/test/metabase/auth_identity/models/auth_identity_test.clj b/test/metabase/auth_identity/models/auth_identity_test.clj
new file mode 100644
index 00000000000..0a19e8a1d0a
--- /dev/null
+++ b/test/metabase/auth_identity/models/auth_identity_test.clj
@@ -0,0 +1,183 @@
+(ns metabase.auth-identity.models.auth-identity-test
+ (:require
+ [clojure.test :refer :all]
+ [metabase.test :as mt]
+ [metabase.util.password :as u.password]
+ [toucan2.core :as t2]))
+
+(deftest user-creation-creates-password-auth-identity-test
+ (testing "User creation automatically creates password AuthIdentity with hashed password"
+ (mt/with-temp [:model/User {user-id :id}]
+ (let [auth-identity (t2/select-one :model/AuthIdentity :user_id user-id :provider "password")]
+ (is (some? auth-identity)
+ "AuthIdentity should be created automatically")
+ (is (some? (get-in auth-identity [:credentials :password_hash]))
+ "Credentials should contain password_hash")
+ (is (some? (get-in auth-identity [:credentials :password_salt]))
+ "Credentials should contain password_salt")
+ (is (nil? (get-in auth-identity [:credentials :plaintext_password]))
+ "Plaintext password should not be stored")))))
+
+(deftest plaintext-password-hashed-on-update-test
+ (testing "Plaintext password is hashed on update"
+ (mt/with-temp [:model/User {user-id :id}]
+ (let [auth-identity (t2/select-one :model/AuthIdentity :user_id user-id :provider "password")
+ auth-identity-id (:id auth-identity)
+ new-password "new-password-456"]
+ (t2/update! :model/AuthIdentity auth-identity-id
+ {:credentials {:plaintext_password new-password}})
+ (let [updated (t2/select-one :model/AuthIdentity :id auth-identity-id)
+ {:keys [password_hash password_salt]} (:credentials updated)]
+ (is (some? password_hash)
+ "New password should be hashed")
+ (is (some? password_salt)
+ "New password should have salt")
+ (is (nil? (get-in updated [:credentials :plaintext_password]))
+ "Plaintext password should not be stored")
+ (is (true? (u.password/verify-password new-password password_salt password_hash))
+ "New password should be verifiable"))))))
+
+(deftest non-credential-updates-dont-trigger-hashing-test
+ (testing "Non-credential updates don't trigger password hashing"
+ (mt/with-temp [:model/User {user-id :id}]
+ (let [auth-identity (t2/select-one :model/AuthIdentity :user_id user-id :provider "password")
+ auth-identity-id (:id auth-identity)
+ original-hash (get-in auth-identity [:credentials :password_hash])
+ original-salt (get-in auth-identity [:credentials :password_salt])]
+ (t2/update! :model/AuthIdentity auth-identity-id
+ {:metadata {:last_login "2024-01-01"}})
+ (let [updated (t2/select-one :model/AuthIdentity :id auth-identity-id)]
+ (is (= original-hash (get-in updated [:credentials :password_hash]))
+ "Password hash should remain unchanged")
+ (is (= original-salt (get-in updated [:credentials :password_salt]))
+ "Password salt should remain unchanged"))))))
+
+(deftest sso-provider-not-affected-by-password-hashing-test
+ (testing "Non-password providers are not affected by password hashing"
+ (mt/with-temp [:model/User {user-id :id}]
+ (let [auth-identity (t2/insert-returning-instance!
+ :model/AuthIdentity
+ {:user_id user-id
+ :provider "google"
+ :metadata {:email "[email protected]"}})]
+ (is (= "[email protected]" (get-in auth-identity [:metadata :email]))
+ "Metadata should be preserved without modification")))))
+
+(deftest sso-provider-updates-unaffected-test
+ (testing "SSO provider updates are not affected"
+ (mt/with-temp [:model/User {user-id :id}]
+ (let [auth-identity (t2/insert-returning-instance!
+ :model/AuthIdentity
+ {:user_id user-id
+ :provider "google"
+ :metadata {:email "[email protected]"}})
+ auth-identity-id (:id auth-identity)]
+ (t2/update! :model/AuthIdentity auth-identity-id
+ {:metadata {:email "[email protected]"}})
+ (let [updated (t2/select-one :model/AuthIdentity :id auth-identity-id)]
+ (is (= "[email protected]" (get-in updated [:metadata :email]))
+ "Metadata should be updated correctly"))))))
+
+(deftest password-salt-uniqueness-test
+ (testing "Each password hash uses a unique salt"
+ (mt/with-temp [:model/User user-1 {}
+ :model/User user-2 {}]
+ (let [auth-1 (t2/select-one :model/AuthIdentity :user_id (:id user-1) :provider "password")
+ auth-2 (t2/select-one :model/AuthIdentity :user_id (:id user-2) :provider "password")]
+ (is (not= (get-in auth-1 [:credentials :password_salt])
+ (get-in auth-2 [:credentials :password_salt]))
+ "Salts should be different")
+ (is (not= (get-in auth-1 [:credentials :password_hash])
+ (get-in auth-2 [:credentials :password_hash]))
+ "Hashes should be different due to different salts")))))
+
+(deftest password-auth-identity-syncs-to-user-table-test
+ (testing "Password AuthIdentity automatically syncs to User table on creation"
+ (mt/with-temp [:model/User {user-id :id}]
+ (let [auth-identity (t2/select-one :model/AuthIdentity :user_id user-id :provider "password")
+ {:keys [password_hash password_salt]} (:credentials auth-identity)
+ user (t2/select-one [:model/User :password :password_salt] :id user-id)]
+ (is (= password_hash (:password user))
+ "User table should contain matching password hash")
+ (is (= password_salt (:password_salt user))
+ "User table should contain matching password salt")))))
+
+(deftest non-password-providers-dont-sync-to-user-table-test
+ (testing "Non-password providers don't sync to User table"
+ (mt/with-temp [:model/User {user-id :id}]
+ (let [password-auth (t2/select-one :model/AuthIdentity :user_id user-id :provider "password")
+ original-password (get-in password-auth [:credentials :password_hash])
+ original-salt (get-in password-auth [:credentials :password_salt])]
+ (t2/insert-returning-instance!
+ :model/AuthIdentity
+ {:user_id user-id
+ :provider "google"
+ :metadata {:email "[email protected]"}})
+ (let [user (t2/select-one [:model/User :password :password_salt] :id user-id)]
+ (is (= original-password (:password user))
+ "User password should remain unchanged after SSO AuthIdentity creation")
+ (is (= original-salt (:password_salt user))
+ "User password salt should remain unchanged after SSO AuthIdentity creation"))))))
+
+(deftest password-update-syncs-to-user-table-test
+ (testing "Password update syncs to User table"
+ (mt/with-temp [:model/User {user-id :id}]
+ (let [auth-identity (t2/select-one :model/AuthIdentity :user_id user-id :provider "password")
+ auth-identity-id (:id auth-identity)
+ new-password "new-password-456"]
+ (t2/update! :model/AuthIdentity auth-identity-id
+ {:credentials {:plaintext_password new-password}})
+ (let [updated-auth (t2/select-one :model/AuthIdentity :id auth-identity-id)
+ {:keys [password_hash password_salt]} (:credentials updated-auth)
+ user (t2/select-one [:model/User :password :password_salt] :id user-id)]
+ (is (= password_hash (:password user))
+ "User table should be updated with new password hash")
+ (is (= password_salt (:password_salt user))
+ "User table should be updated with new password salt")
+ (is (true? (u.password/verify-password new-password (:password_salt user) (:password user)))
+ "New password in User table should be verifiable"))))))
+
+(deftest non-credential-updates-dont-trigger-sync-test
+ (testing "Non-credential updates don't trigger sync to User table"
+ (mt/with-temp [:model/User {user-id :id}]
+ (let [auth-identity (t2/select-one :model/AuthIdentity :user_id user-id :provider "password")
+ auth-identity-id (:id auth-identity)
+ original-user (t2/select-one [:model/User :password :password_salt] :id user-id)]
+ (t2/update! :model/AuthIdentity auth-identity-id
+ {:metadata {:last_login "2024-01-01"}})
+ (let [user (t2/select-one [:model/User :password :password_salt] :id user-id)]
+ (is (= (:password original-user) (:password user))
+ "User password should remain unchanged after metadata update")
+ (is (= (:password_salt original-user) (:password_salt user))
+ "User password salt should remain unchanged after metadata update"))))))
+
+(deftest sso-provider-updates-dont-sync-to-user-table-test
+ (testing "SSO provider updates don't sync to User table"
+ (mt/with-temp [:model/User {user-id :id}]
+ (let [password-auth (t2/select-one :model/AuthIdentity :user_id user-id :provider "password")
+ original-password (get-in password-auth [:credentials :password_hash])
+ original-salt (get-in password-auth [:credentials :password_salt])
+ sso-auth-identity (t2/insert-returning-instance!
+ :model/AuthIdentity
+ {:user_id user-id
+ :provider "google"
+ :metadata {:email "[email protected]"}})
+ sso-auth-identity-id (:id sso-auth-identity)]
+ (t2/update! :model/AuthIdentity sso-auth-identity-id
+ {:metadata {:email "[email protected]"}})
+ (let [user (t2/select-one [:model/User :password :password_salt] :id user-id)]
+ (is (= original-password (:password user))
+ "User password should remain unchanged after SSO metadata update")
+ (is (= original-salt (:password_salt user))
+ "User password salt should remain unchanged after SSO metadata update"))))))
+
+(deftest auth-identity-user-consistency-test
+ (testing "AuthIdentity and User table remain consistent"
+ (mt/with-temp [:model/User {user-id :id}]
+ (let [auth-identity (t2/select-one :model/AuthIdentity :user_id user-id :provider "password")
+ auth-creds (:credentials auth-identity)
+ user (t2/select-one [:model/User :password :password_salt] :id user-id)]
+ (is (= (:password_hash auth-creds) (:password user))
+ "Password hash should match between AuthIdentity and User")
+ (is (= (:password_salt auth-creds) (:password_salt user))
+ "Password salt should match between AuthIdentity and User")))))
diff --git a/test/metabase/auth_identity/provider_test.clj b/test/metabase/auth_identity/provider_test.clj
new file mode 100644
index 00000000000..84100a57b2b
--- /dev/null
+++ b/test/metabase/auth_identity/provider_test.clj
@@ -0,0 +1,264 @@
+(ns metabase.auth-identity.provider-test
+ (:require
+ [clojure.test :refer :all]
+ [java-time.api :as t]
+ [metabase.auth-identity.provider :as provider]
+ [methodical.core :as methodical]))
+
+;; Set up test providers for testing the hierarchy
+(derive :provider/test-password ::provider/provider)
+(derive :provider/test-ldap ::provider/provider)
+(derive :provider/test-ldap ::provider/create-user-if-not-exists)
+
+(deftest ^:parallel provider-hierarchy-test
+ (testing "Provider hierarchy works correctly"
+ (testing "Providers can derive from ::provider/provider"
+ (is (isa? :provider/test-password ::provider/provider))
+ (is (isa? :provider/test-ldap ::provider/provider)))
+
+ (testing "SSO providers can derive from ::provider/create-user-if-not-exists"
+ (is (isa? :provider/test-ldap ::provider/create-user-if-not-exists)))
+
+ (testing "Password providers do NOT derive from create-user-if-not-exists"
+ (is (not (isa? :provider/test-password ::provider/create-user-if-not-exists))))))
+
+(deftest ^:parallel validate-multimethod-test
+ (testing "validate multimethod has default implementation"
+ (testing "Default validate returns nil (no-op)"
+ (is (nil? (provider/validate :provider/test-password {:credentials {:password_hash "hash"}})))
+ (is (nil? (provider/validate :provider/test-ldap {:metadata {:email "[email protected]"}}))))))
+
+(deftest ^:parallel authenticate-multimethod-test
+ (testing "authenticate multimethod"
+ (testing "Default implementation throws for unimplemented providers"
+ (is (thrown-with-msg?
+ clojure.lang.ExceptionInfo
+ #"Authentication not implemented"
+ (provider/authenticate :provider/test-password {:email "[email protected]" :password "secret"}))))))
+
+(deftest ^:parallel provider-string-conversion-test
+ (testing "provider-string->keyword converts strings to provider keywords"
+ (is (= :provider/password (provider/provider-string->keyword "password")))
+ (is (= :provider/emailed-secret (provider/provider-string->keyword "emailed-secret")))
+ (is (= :provider/ldap (provider/provider-string->keyword "ldap")))
+ (is (= :provider/google (provider/provider-string->keyword "google")))
+ (is (= :provider/jwt (provider/provider-string->keyword "jwt")))
+ (is (= :provider/saml (provider/provider-string->keyword "saml"))))
+
+ (testing "provider-keyword->string converts keywords to strings"
+ (is (= "password" (provider/provider-keyword->string :provider/password)))
+ (is (= "emailed-secret" (provider/provider-keyword->string :provider/emailed-secret)))
+ (is (= "ldap" (provider/provider-keyword->string :provider/ldap)))
+ (is (= "google" (provider/provider-keyword->string :provider/google)))
+ (is (= "jwt" (provider/provider-keyword->string :provider/jwt)))
+ (is (= "saml" (provider/provider-keyword->string :provider/saml))))
+
+ (testing "Round-trip conversion works"
+ (doseq [provider-str ["password" "emailed-secret" "ldap" "google" "jwt" "saml"]]
+ (is (= provider-str
+ (-> provider-str
+ provider/provider-string->keyword
+ provider/provider-keyword->string))))))
+
+(deftest login!-default-implementation-test
+ (testing "login! default implementation handles redirect responses"
+ (testing "Returns redirect response unchanged when authenticate returns :redirect"
+ ;; Create a test provider that returns redirect
+ (derive :provider/test-redirect ::provider/provider)
+ (methodical/defmethod provider/authenticate :provider/test-redirect
+ [_provider _request]
+ {:success? :redirect
+ :redirect-url "https://example.com/oauth"
+ :message "Redirecting to provider"})
+
+ (let [result (provider/login! :provider/test-redirect
+ {:device-info {:device_id "test" :ip_address "127.0.0.1"}})]
+ (is (= :redirect (:success? result)))
+ (is (= "https://example.com/oauth" (:redirect-url result)))
+ (is (= "Redirecting to provider" (:message result)))
+ (is (nil? (:session result)))
+ (is (nil? (:user result))))))
+
+ (testing "login! default implementation handles failure responses"
+ (testing "Returns error response unchanged when authenticate fails"
+ ;; Create a test provider that returns error
+ (derive :provider/test-error ::provider/provider)
+ (methodical/defmethod provider/authenticate :provider/test-error
+ [_provider _request]
+ {:success? false
+ :error :invalid-credentials
+ :message "Invalid credentials"})
+
+ (let [result (provider/login! :provider/test-error
+ {:email "[email protected]"
+ :password "wrong"
+ :device-info {:device_id "test" :ip_address "127.0.0.1"}})]
+ (is (false? (:success? result)))
+ (is (= :invalid-credentials (:error result)))
+ (is (= "Invalid credentials" (:message result)))
+ (is (nil? (:session result)))
+ (is (nil? (:user result)))))))
+
+(deftest ^:parallel ^:parallel three-valued-success-state-test
+ (testing "Success states work correctly"
+ (testing "Success state: true"
+ (is (true? (:success? {:success? true :user-id 123}))))
+
+ (testing "Success state: :redirect"
+ (is (= :redirect (:success? {:success? :redirect :redirect-url "https://example.com"}))))
+
+ (testing "Success state: false"
+ (is (false? (:success? {:success? false :error :invalid-credentials}))))))
+
+(deftest ^:parallel ^:parallel multimethod-dispatch-test
+ (testing "Multimethod dispatch works with provider hierarchy"
+ ;; Create a test provider that inherits from ::provider/provider
+ (derive :provider/test-custom ::provider/provider)
+
+ (testing "Custom provider inherits default validate implementation"
+ (is (nil? (provider/validate :provider/test-custom {:credentials {:foo "bar"}}))))
+
+ (testing "Custom provider inherits default authenticate implementation"
+ (is (thrown-with-msg?
+ clojure.lang.ExceptionInfo
+ #"Authentication not implemented"
+ (provider/authenticate :provider/test-custom {:token "test"}))))))
+
+(deftest ^:parallel provider-id-in-authenticate-response-test
+ (testing "authenticate method returns :provider-id in success response"
+ (testing "Provider returns :provider-id for successful authentication"
+ (derive :provider/test-with-provider-id ::provider/provider)
+ (methodical/defmethod provider/authenticate :provider/test-with-provider-id
+ [_provider {:keys [email] :as _request}]
+ {:success? true
+ :user-id 123
+ :provider-id email})
+
+ (let [result (provider/authenticate :provider/test-with-provider-id {:email "[email protected]" :password "secret"})]
+ (is (true? (:success? result)))
+ (is (= 123 (:user-id result)))
+ (is (= "[email protected]" (:provider-id result))))))
+
+ (testing "authenticate docstring documents :provider-id return value"
+ (let [docstring (-> #'provider/authenticate meta :doc)]
+ (is (string? docstring))
+ (is (re-find #":provider-id" docstring)))))
+
+(deftest ^:parallel provider-id-flow-in-login-test
+ (testing "login! :around flows :provider-id to user-data"
+ (testing "When authenticate returns :provider-id and :user-data, it gets merged into :user-data"
+ (derive :provider/test-provider-id-flow ::provider/provider)
+ (methodical/defmethod provider/authenticate :provider/test-provider-id-flow
+ [_provider _request]
+ {:success? true
+ :user-data {:email "[email protected]"
+ :first_name "Test"
+ :last_name "User"
+ :sso_source :test}
+ :provider-id "[email protected]"})
+
+ ;; Test that the :around method merges :provider-id into :user-data
+ (let [auth-result (provider/authenticate :provider/test-provider-id-flow {:token "test"})]
+ (is (true? (:success? auth-result)))
+ (is (= "[email protected]" (:provider-id auth-result)))
+ (is (contains? (:user-data auth-result) :email))
+ (is (not (contains? (:user-data auth-result) :provider-id)))
+
+ ;; Simulate what login! :around does
+ (let [merged-request (cond-> auth-result
+ (and (:provider-id auth-result) (:user-data auth-result))
+ (assoc-in [:user-data :provider-id] (:provider-id auth-result)))]
+ (is (= "[email protected]" (get-in merged-request [:user-data :provider-id]))))))))
+
+(deftest ^:parallel authenticate-expired-auth-identity-test
+ (testing "Authentication fails when auth-identity has expired"
+ (derive :provider/test-expired ::provider/provider)
+ (methodical/defmethod provider/authenticate :provider/test-expired
+ [_provider _request]
+ {:success? true
+ :user-id 123
+ :auth-identity {:id 1
+ :user_id 123
+ :provider "test-expired"
+ :expires_at (t/minus (t/offset-date-time) (t/hours 1))}})
+
+ (let [result (provider/authenticate :provider/test-expired {:email "[email protected]"})]
+ (is (false? (:success? result))
+ "Authentication should fail for expired auth-identity")
+ (is (= :authentication-expired (:error result))
+ "Error should be :authentication-expired")
+ (is (some? (:message result))
+ "Should have error message"))))
+
+(deftest ^:parallel authenticate-not-expired-auth-identity-test
+ (testing "Authentication succeeds when auth-identity has not expired"
+ (derive :provider/test-not-expired ::provider/provider)
+ (methodical/defmethod provider/authenticate :provider/test-not-expired
+ [_provider _request]
+ {:success? true
+ :user-id 123
+ :auth-identity {:id 1
+ :user_id 123
+ :provider "test-not-expired"
+ :expires_at (t/plus (t/offset-date-time) (t/hours 24))}})
+
+ (let [result (provider/authenticate :provider/test-not-expired {:email "[email protected]"})]
+ (is (true? (:success? result))
+ "Authentication should succeed for non-expired auth-identity")
+ (is (nil? (:error result))
+ "Should not have error")
+ (is (= 123 (:user-id result))
+ "Should return user-id"))))
+
+(deftest ^:parallel authenticate-no-expiration-test
+ (testing "Authentication succeeds when auth-identity has no expiration (nil expires_at)"
+ (derive :provider/test-no-expiration ::provider/provider)
+ (methodical/defmethod provider/authenticate :provider/test-no-expiration
+ [_provider _request]
+ {:success? true
+ :user-id 123
+ :auth-identity {:id 1
+ :user_id 123
+ :provider "test-no-expiration"
+ :expires_at nil}})
+
+ (let [result (provider/authenticate :provider/test-no-expiration {:email "[email protected]"})]
+ (is (true? (:success? result))
+ "Authentication should succeed when no expiration set")
+ (is (nil? (:error result))
+ "Should not have error")
+ (is (= 123 (:user-id result))
+ "Should return user-id"))))
+
+(deftest ^:parallel authenticate-no-auth-identity-test
+ (testing "Authentication with no auth-identity bypasses expiration check"
+ (derive :provider/test-no-auth-identity ::provider/provider)
+ (methodical/defmethod provider/authenticate :provider/test-no-auth-identity
+ [_provider _request]
+ {:success? true
+ :user-data {:email "[email protected]"
+ :first_name "New"
+ :last_name "User"}})
+
+ (let [result (provider/authenticate :provider/test-no-auth-identity {:token "abc123"})]
+ (is (true? (:success? result))
+ "Authentication should succeed without auth-identity")
+ (is (nil? (:error result))
+ "Should not have error")
+ (is (some? (:user-data result))
+ "Should have user-data for new user creation"))))
+
+(deftest ^:parallel authenticate-failure-bypasses-expiration-check-test
+ (testing "Failed authentication bypasses expiration check"
+ (derive :provider/test-auth-failure ::provider/provider)
+ (methodical/defmethod provider/authenticate :provider/test-auth-failure
+ [_provider _request]
+ {:success? false
+ :error :invalid-credentials
+ :message "Invalid password"})
+
+ (let [result (provider/authenticate :provider/test-auth-failure {:email "[email protected]" :password "wrong"})]
+ (is (false? (:success? result))
+ "Authentication should fail")
+ (is (= :invalid-credentials (:error result))
+ "Should have original error, not expiration error"))))
diff --git a/test/metabase/auth_identity/providers/emailed_secret_test.clj b/test/metabase/auth_identity/providers/emailed_secret_test.clj
new file mode 100644
index 00000000000..f01e069175e
--- /dev/null
+++ b/test/metabase/auth_identity/providers/emailed_secret_test.clj
@@ -0,0 +1,105 @@
+(ns metabase.auth-identity.providers.emailed-secret-test
+ "Tests for emailed_secret provider functionality and AuthIdentity to User sync."
+ (:require
+ [clojure.test :refer :all]
+ [java-time.api :as t]
+ [metabase.auth-identity.providers.emailed-secret :as emailed-secret]
+ [metabase.test :as mt]
+ [toucan2.core :as t2]))
+
+(set! *warn-on-reflection* true)
+
+(deftest auth-identity-to-user-sync-test
+ (testing "When reset token is created in AuthIdentity, it syncs to User model"
+ (mt/with-temp [:model/User {user-id :id} {}]
+ (emailed-secret/create-password-reset! user-id)
+ (let [auth-identity (t2/select-one :model/AuthIdentity
+ :user_id user-id
+ :provider "emailed-secret-password-reset")
+ user (t2/select-one [:model/User :reset_token :reset_triggered] :id user-id)]
+ (is (some? auth-identity))
+ (is (= (get-in auth-identity [:credentials :token_hash]) (:reset_token user)))
+ (is (int? (:reset_triggered user)))
+ (is (pos? (:reset_triggered user)))))))
+
+(deftest auth-identity-token-update-sync-test
+ (testing "When reset token is updated in AuthIdentity, it syncs to User model"
+ (mt/with-temp [:model/User {user-id :id} {}]
+ (emailed-secret/create-password-reset! user-id)
+ (let [first-auth-identity (t2/select-one :model/AuthIdentity
+ :user_id user-id
+ :provider "emailed-secret-password-reset")
+ first-token-hash (get-in first-auth-identity [:credentials :token_hash])]
+ (Thread/sleep 10)
+ (emailed-secret/create-password-reset! user-id)
+ (let [updated-auth-identity (t2/select-one :model/AuthIdentity
+ :user_id user-id
+ :provider "emailed-secret-password-reset")
+ updated-token-hash (get-in updated-auth-identity [:credentials :token_hash])
+ user (t2/select-one [:model/User :reset_token :reset_triggered] :id user-id)]
+ (is (not= first-token-hash updated-token-hash))
+ (is (= updated-token-hash (:reset_token user)))
+ (is (int? (:reset_triggered user))))))))
+
+(deftest auth-identity-token-consumed-sync-test
+ (testing "When token is marked consumed in AuthIdentity, User model is cleared"
+ (mt/with-temp [:model/User {user-id :id} {}]
+ (emailed-secret/create-password-reset! user-id)
+ (let [auth-identity (t2/select-one :model/AuthIdentity
+ :user_id user-id
+ :provider "emailed-secret-password-reset")]
+ (is (some? (:reset_token (t2/select-one [:model/User :reset_token] :id user-id))))
+ (t2/update! :model/AuthIdentity (:id auth-identity)
+ {:credentials (assoc (:credentials auth-identity) :consumed_at (t/instant))})
+ (let [user (t2/select-one [:model/User :reset_token :reset_triggered] :id user-id)]
+ (is (nil? (:reset_token user)))
+ (is (nil? (:reset_triggered user))))))))
+
+(deftest create-password-reset-creates-auth-identity-test
+ (testing "create-password-reset! creates AuthIdentity with correct structure"
+ (mt/with-temp [:model/User {user-id :id email :email} {}]
+ (emailed-secret/create-password-reset! user-id)
+ (let [auth-identity (t2/select-one :model/AuthIdentity
+ :user_id user-id
+ :provider "emailed-secret-password-reset")]
+ (is (some? auth-identity))
+ (is (= "emailed-secret-password-reset" (:provider auth-identity)))
+ (is (= user-id (:user_id auth-identity)))
+ (is (contains? (:credentials auth-identity) :token_hash))
+ (is (contains? (:credentials auth-identity) :expires_at))
+ (is (nil? (get-in auth-identity [:credentials :consumed_at])))
+ (is (= email (get-in auth-identity [:metadata :email])))))))
+
+(deftest create-password-reset-updates-existing-auth-identity-test
+ (testing "create-password-reset! updates existing AuthIdentity instead of creating duplicate"
+ (mt/with-temp [:model/User {user-id :id} {}]
+ (let [first-token (emailed-secret/create-password-reset! user-id)
+ first-auth-identity (t2/select-one :model/AuthIdentity
+ :user_id user-id
+ :provider "emailed-secret-password-reset")
+ second-token (emailed-secret/create-password-reset! user-id)
+ auth-identities (t2/select :model/AuthIdentity
+ :user_id user-id
+ :provider "emailed-secret-password-reset")]
+ (is (= 1 (count auth-identities)))
+ (is (not= first-token second-token))
+ (is (= (:id first-auth-identity) (:id (first auth-identities))))))))
+
+(deftest create-password-reset-token-format-test
+ (testing "create-password-reset! returns token in expected format"
+ (mt/with-temp [:model/User {user-id :id} {}]
+ (let [token (emailed-secret/create-password-reset! user-id)]
+ (is (string? token))
+ (is (re-matches (re-pattern (str user-id "_.+")) token))))))
+
+(deftest create-password-reset-token-has-expiration-test
+ (testing "create-password-reset! creates token with future expiration"
+ (mt/with-temp [:model/User {user-id :id} {}]
+ (let [before-create (t/instant)]
+ (emailed-secret/create-password-reset! user-id)
+ (let [auth-identity (t2/select-one :model/AuthIdentity
+ :user_id user-id
+ :provider "emailed-secret-password-reset")
+ expires-at (get-in auth-identity [:credentials :expires_at])]
+ (is (inst? expires-at))
+ (is (t/after? expires-at before-create)))))))
diff --git a/test/metabase/auth_identity/session_test.clj b/test/metabase/auth_identity/session_test.clj
new file mode 100644
index 00000000000..b354a718138
--- /dev/null
+++ b/test/metabase/auth_identity/session_test.clj
@@ -0,0 +1,188 @@
+(ns metabase.auth-identity.session-test
+ "Tests for AuthIdentity and Session integration."
+ (:require
+ [clojure.test :refer :all]
+ [java-time.api :as t]
+ [metabase.auth-identity.core :as auth-identity]
+ [metabase.request.core :as request]
+ [metabase.test :as mt]
+ [toucan2.core :as t2]))
+
+(set! *warn-on-reflection* true)
+
+;;; -------------------------------------------------- Session Tracking Tests --------------------------------------------------
+
+(deftest create-session-with-password-auth-tracking-test
+ (testing "Creating a session with password authentication tracks the auth_identity_id"
+ (mt/with-temp [:model/User user {}]
+ (let [password-auth (t2/select-one :model/AuthIdentity :user_id (:id user) :provider "password")
+ device-info {:device_id "test-device-123"
+ :embedded false
+ :device_description "Test Browser"
+ :ip_address "127.0.0.1"}
+ session (auth-identity/create-session-with-auth-tracking!
+ user device-info :provider/password)]
+ (is (some? session))
+ (is (string? (:key session)))
+ (is (= (:id password-auth) (:auth_identity_id session)))
+ (let [persisted-session (t2/select-one :model/Session :id (:id session))]
+ (is (= (:id password-auth) (:auth_identity_id persisted-session))))))))
+
+(deftest create-session-with-google-sso-auth-tracking-test
+ (testing "Creating a session with Google SSO authentication tracks the auth_identity_id"
+ (mt/with-temp [:model/User user {}
+ :model/AuthIdentity google-auth {:user_id (:id user)
+ :provider "google"
+ :metadata {:sso_source "google"}}]
+ (let [device-info {:device_id "test-device-456"
+ :embedded false
+ :device_description "Chrome Browser"
+ :ip_address "127.0.0.1"}
+ session (auth-identity/create-session-with-auth-tracking! user device-info :provider/google)]
+ (is (some? session))
+ (is (= (:id google-auth) (:auth_identity_id session)))
+ (let [persisted-session (t2/select-one :model/Session :id (:id session))]
+ (is (= (:id google-auth) (:auth_identity_id persisted-session))))))))
+
+(deftest create-session-with-ldap-auth-tracking-test
+ (testing "Creating a session with LDAP authentication tracks the auth_identity_id"
+ (mt/with-temp [:model/User user {}
+ :model/AuthIdentity ldap-auth {:user_id (:id user)
+ :provider "ldap"
+ :metadata {:login_attributes {:uid "testuser"}}}]
+ (let [device-info {:device_id "test-device-789"
+ :embedded false
+ :device_description "Firefox Browser"
+ :ip_address "127.0.0.1"}
+ session (auth-identity/create-session-with-auth-tracking! user device-info :provider/ldap)]
+ (is (some? session))
+ (is (= (:id ldap-auth) (:auth_identity_id session)))
+ (let [persisted-session (t2/select-one :model/Session :id (:id session))]
+ (is (= (:id ldap-auth) (:auth_identity_id persisted-session))))))))
+
+(deftest create-session-updates-last-used-at-test
+ (testing "Creating a session updates the last_used_at timestamp on the AuthIdentity"
+ (mt/with-temp [:model/User user {}]
+ (let [password-auth (t2/select-one :model/AuthIdentity :user_id (:id user) :provider "password")
+ device-info {:device_id "test-device-last-used"
+ :embedded false
+ :device_description "Test Browser"
+ :ip_address "127.0.0.1"}
+ original-last-used (:last_used_at password-auth)]
+ (is (nil? original-last-used))
+ (auth-identity/create-session-with-auth-tracking! user device-info :provider/password)
+ (let [updated-auth (t2/select-one :model/AuthIdentity :id (:id password-auth))]
+ (is (some? (:last_used_at updated-auth))))))))
+
+(deftest multiple-sessions-same-auth-identity-test
+ (testing "Multiple sessions can reference the same AuthIdentity"
+ (mt/with-temp [:model/User user {}]
+ (let [password-auth (t2/select-one :model/AuthIdentity :user_id (:id user) :provider "password")
+ device-info-1 {:device_id "device-1"
+ :embedded false
+ :device_description "Browser 1"
+ :ip_address "127.0.0.1"}
+ device-info-2 {:device_id "device-2"
+ :embedded false
+ :device_description "Browser 2"
+ :ip_address "127.0.0.1"}
+ session-1 (auth-identity/create-session-with-auth-tracking!
+ user device-info-1 :provider/password)
+ session-2 (auth-identity/create-session-with-auth-tracking!
+ user device-info-2 :provider/password)]
+ (is (some? session-1))
+ (is (some? session-2))
+ (is (not= (:id session-1) (:id session-2)))
+ (is (= (:id password-auth) (:auth_identity_id session-1)))
+ (is (= (:id password-auth) (:auth_identity_id session-2)))))))
+
+(deftest session-cascade-delete-on-auth-identity-deletion-test
+ (testing "Deleting an AuthIdentity cascades to delete associated Sessions"
+ (mt/with-temp [:model/User user {}]
+ (let [password-auth (t2/select-one :model/AuthIdentity :user_id (:id user) :provider "password")
+ device-info {:device_id "test-device-cascade"
+ :embedded false
+ :device_description "Test Browser"
+ :ip_address "127.0.0.1"}
+ session (auth-identity/create-session-with-auth-tracking!
+ user device-info :provider/password)]
+ (is (some? session))
+ (is (some? (t2/select-one :model/Session :id (:id session))))
+ (t2/delete! :model/AuthIdentity :id (:id password-auth))
+ (is (nil? (t2/select-one :model/Session :id (:id session))))))))
+
+(deftest session-creation-with-user-having-multiple-providers-test
+ (testing "User with multiple providers can create sessions with different providers"
+ (mt/with-temp [:model/User user {}
+ :model/AuthIdentity google-auth {:user_id (:id user)
+ :provider "google"}]
+ (let [password-auth (t2/select-one :model/AuthIdentity :user_id (:id user) :provider "password")
+ device-info {:device_id "test-device-multi"
+ :embedded false
+ :device_description "Test Browser"
+ :ip_address "127.0.0.1"}
+ password-session (auth-identity/create-session-with-auth-tracking!
+ user device-info :provider/password)
+ google-session (auth-identity/create-session-with-auth-tracking!
+ user device-info :provider/google)]
+ (is (some? password-session))
+ (is (some? google-session))
+ (is (= (:id password-auth) (:auth_identity_id password-session)))
+ (is (= (:id google-auth) (:auth_identity_id google-session)))))))
+
+(deftest session-includes-type-field-test
+ (testing "Session creation returns a session with :type field"
+ (mt/with-temp [:model/User user {}]
+ (let [device-info {:device_id "test-device-type"
+ :embedded false
+ :device_description "Test Browser"
+ :ip_address "127.0.0.1"}
+ session (auth-identity/create-session-with-auth-tracking! user device-info :provider/password)]
+ (is (some? session))
+ (is (contains? session :type))
+ (is (= :normal (:type session)))))))
+
+(deftest session-includes-type-field-embed-test
+ (testing "Session creation returns a session with :type field"
+ (request/with-current-request {:headers {"x-metabase-embedded" "true"}}
+ (mt/with-temp [:model/User user {}]
+ (let [device-info {:device_id "test-device-type"
+ :embedded false
+ :device_description "Test Browser"
+ :ip_address "127.0.0.1"}
+ session (auth-identity/create-session-with-auth-tracking! user device-info :provider/password)]
+ (is (some? session))
+ (is (contains? session :type))
+ (is (= :full-app-embed (:type session))))))))
+
+(deftest session-inherits-expires-at-test
+ (testing "Session inherits expires_at from auth-identity"
+ (mt/with-temp [:model/User user {}]
+ (let [expires-at (t/plus (t/offset-date-time) (t/days 7))
+ password-auth (t2/select-one :model/AuthIdentity :user_id (:id user) :provider "password")]
+ (t2/update! :model/AuthIdentity (:id password-auth) {:expires_at expires-at})
+ (let [device-info {:device_id "test-device-expires"
+ :embedded false
+ :device_description "Test Browser"
+ :ip_address "127.0.0.1"}
+ session (auth-identity/create-session-with-auth-tracking! user device-info :provider/password)]
+ (is (some? (:expires_at session))
+ "Session should have expires_at")
+ (is (instance? java.time.OffsetDateTime (:expires_at session))
+ "expires_at should be OffsetDateTime")
+ (is (t2/exists? :model/AuthIdentity :id (:id password-auth) :expires_at (:expires_at session))
+ "Session expires_at should match auth-identity expires_at"))))))
+
+(deftest session-no-expires-at-when-auth-identity-has-none-test
+ (testing "Session has no expires_at when auth-identity doesn't have one"
+ (mt/with-temp [:model/User user {}]
+ (let [password-auth (t2/select-one :model/AuthIdentity :user_id (:id user) :provider "password")
+ device-info {:device_id "test-device-no-expires"
+ :embedded false
+ :device_description "Test Browser"
+ :ip_address "127.0.0.1"}
+ session (auth-identity/create-session-with-auth-tracking! user device-info :provider/password)]
+ (is (nil? (:expires_at password-auth))
+ "Auth-identity should not have expires_at")
+ (is (nil? (:expires_at session))
+ "Session should not have expires_at when auth-identity doesn't")))))
diff --git a/test/metabase/request/cookies_test.clj b/test/metabase/request/cookies_test.clj
index 142de63e233..a1e95bb8026 100644
--- a/test/metabase/request/cookies_test.clj
+++ b/test/metabase/request/cookies_test.clj
@@ -210,3 +210,77 @@
:path "/"
:http-only true}}}
(request/set-session-cookies request response session request-time)))))))))
+
+(deftest cookie-expires-with-session-expiration-test
+ (testing "Cookie max-age respects session expires_at"
+ (mt/with-temp-env-var-value! [:max-session-age "20160"]
+ (mt/with-temporary-setting-values [session-timeout nil]
+ (let [now (t/zoned-date-time "2022-01-01T00:00:00.000Z")
+ expires-in-1-hour (t/plus now (t/hours 1))
+ session {:key (random-uuid)
+ :type :normal
+ :expires_at expires-in-1-hour}
+ request {}
+ response {}
+ result (request.cookies/set-session-cookies request response session now)
+ cookie-options (get-in result [:cookies "metabase.SESSION"])]
+ (is (some? (:max-age cookie-options))
+ "Cookie should have max-age set")
+ ;; Should be ~3600 seconds (1 hour), allow some variance for test execution time
+ (is (< 3595 (:max-age cookie-options) 3605)
+ "Cookie max-age should be approximately 1 hour"))))))
+
+(deftest cookie-max-age-minimum-of-session-and-default-test
+ (testing "Cookie max-age is minimum of session expires_at and default max-session-age"
+ (mt/with-temp-env-var-value! [:max-session-age "20160"]
+ (mt/with-temporary-setting-values [session-timeout nil]
+ (let [now (t/zoned-date-time "2022-01-01T00:00:00.000Z")
+ ;; Session expires in 30 days, but max-session-age is 14 days
+ expires-in-30-days (t/plus now (t/days 30))
+ session {:key (random-uuid)
+ :type :normal
+ :expires_at expires-in-30-days}
+ request {:body {:remember true}} ; Request permanent cookies
+ response {}
+ result (request.cookies/set-session-cookies request response session now)
+ cookie-options (get-in result [:cookies "metabase.SESSION"])
+ default-max-age (* 60 20160)] ; 14 days in seconds
+ (is (some? (:max-age cookie-options))
+ "Cookie should have max-age set")
+ ;; Should use default max-age since it's shorter
+ (is (= default-max-age (:max-age cookie-options))
+ "Cookie max-age should use default since it's shorter than session expiration"))))))
+
+(deftest cookie-expires-overrides-permanent-setting-test
+ (testing "Session expires_at overrides permanent cookie settings"
+ (mt/with-temp-env-var-value! [:max-session-age "20160"]
+ (mt/with-temporary-setting-values [session-timeout nil]
+ (let [now (t/zoned-date-time "2022-01-01T00:00:00.000Z")
+ expires-in-1-day (t/plus now (t/days 1))
+ session {:key (random-uuid)
+ :type :normal
+ :expires_at expires-in-1-day}
+ request {:body {:remember true}} ; User requested permanent cookies
+ response {}
+ result (request.cookies/set-session-cookies request response session now)
+ cookie-options (get-in result [:cookies "metabase.SESSION"])]
+ (is (some? (:max-age cookie-options))
+ "Cookie should have max-age set")
+ ;; Should use session expiration (~86400 seconds = 1 day), not default 14 days
+ (is (< 86390 (:max-age cookie-options) 86410)
+ "Cookie max-age should use session expiration (1 day), not default (14 days)"))))))
+
+(deftest cookie-no-max-age-without-session-expiration-test
+ (testing "Cookie has no max-age when session has no expires_at and remember is false"
+ (mt/with-temp-env-var-value! [:max-session-age "20160"]
+ (mt/with-temporary-setting-values [session-timeout nil]
+ (let [now (t/zoned-date-time "2022-01-01T00:00:00.000Z")
+ session {:key (random-uuid)
+ :type :normal
+ :expires_at nil}
+ request {:body {:remember false}} ; Don't remember
+ response {}
+ result (request.cookies/set-session-cookies request response session now)
+ cookie-options (get-in result [:cookies "metabase.SESSION"])]
+ (is (nil? (:max-age cookie-options))
+ "Cookie should not have max-age when no expiration and remember is false"))))))
diff --git a/test/metabase/session/api_test.clj b/test/metabase/session/api_test.clj
index ded1394a724..f4047a39eb6 100644
--- a/test/metabase/session/api_test.clj
+++ b/test/metabase/session/api_test.clj
@@ -31,49 +31,58 @@
(use-fixtures :once (fixtures/initialize :db :web-server :test-users))
-(defn- reset-throttlers! []
+(defn- reset-throttlers []
(doseq [throttler (vals @#'api.session/login-throttlers)]
(reset! (:attempts throttler) nil))
(reset! (:attempts (var-get #'api.session/reset-password-throttler)) nil))
+(use-fixtures :each (fn [f] (reset-throttlers) (f)))
+
(def ^:private SessionResponse
[:map
[:id ms/UUIDString]])
(def ^:private session-cookie request/metabase-session-cookie)
-(deftest login-test
- (reset-throttlers!)
- (testing "POST /api/session"
- (testing "Test that we can login"
+(deftest login-basic-test
+ (testing "POST /api/session - basic login works"
+ (is (malli= SessionResponse
+ (mt/client :post 200 "session" (mt/user->credentials :rasta))))))
+
+(deftest login-mixed-case-email-test
+ (testing "POST /api/session - login with email of mixed case"
+ (let [creds (update (mt/user->credentials :rasta) :username u/upper-case-en)
+ response (mt/client :post 200 "session" creds)]
(is (malli= SessionResponse
- (mt/client :post 200 "session" (mt/user->credentials :rasta)))))
- (testing "Test that we can login with email of mixed case"
- (let [creds (update (mt/user->credentials :rasta) :username u/upper-case-en)
- response (mt/client :post 200 "session" creds)]
- (is (malli= SessionResponse
- response))
- (testing "Login should record a LoginHistory item"
- (is (malli= [:map
- [:id ms/PositiveInt]
- [:timestamp (ms/InstanceOfClass java.time.OffsetDateTime)]
- [:user_id [:= (mt/user->id :rasta)]]
- [:device_id ms/UUIDString]
- [:device_description ms/NonBlankString]
- [:ip_address ms/NonBlankString]
- [:active [:= true]]]
- (t2/select-one :model/LoginHistory :user_id (mt/user->id :rasta), :session_id (t2/select-one-fn :id :model/Session :key_hashed (session/hash-session-key (:id response)))))))))
- (testing "Test that 'remember me' checkbox sets Max-Age attribute on session cookie"
- (let [body (assoc (mt/user->credentials :rasta) :remember true)
- response (mt/client-real-response :post 200 "session" body)]
- ;; clj-http sets :expires key in response when Max-Age attribute is set
- (is (get-in response [:cookies session-cookie :expires])))
- (let [body (assoc (mt/user->credentials :rasta) :remember false)
- response (mt/client-real-response :post 200 "session" body)]
- (is (nil? (get-in response [:cookies session-cookie :expires])))))))
+ response)))))
+
+(deftest login-records-history-test
+ (testing "POST /api/session - login records a LoginHistory item"
+ (let [creds (update (mt/user->credentials :rasta) :username u/upper-case-en)
+ response (mt/client :post 200 "session" creds)]
+ (is (malli= [:map
+ [:id ms/PositiveInt]
+ [:timestamp (ms/InstanceOfClass java.time.OffsetDateTime)]
+ [:user_id [:= (mt/user->id :rasta)]]
+ [:device_id ms/UUIDString]
+ [:device_description ms/NonBlankString]
+ [:ip_address ms/NonBlankString]
+ [:active [:= true]]]
+ (t2/select-one :model/LoginHistory :user_id (mt/user->id :rasta), :session_id (t2/select-one-fn :id :model/Session :key_hashed (session/hash-session-key (:id response)))))))))
+
+(deftest login-remember-me-sets-max-age-test
+ (testing "POST /api/session - 'remember me' checkbox sets Max-Age attribute on session cookie"
+ (let [body (assoc (mt/user->credentials :rasta) :remember true)
+ response (mt/client-real-response :post 200 "session" body)]
+ (is (get-in response [:cookies session-cookie :expires])))))
+
+(deftest login-remember-me-false-no-max-age-test
+ (testing "POST /api/session - 'remember me' false does not set Max-Age attribute"
+ (let [body (assoc (mt/user->credentials :rasta) :remember false)
+ response (mt/client-real-response :post 200 "session" body)]
+ (is (nil? (get-in response [:cookies session-cookie :expires]))))))
(deftest login-failure-logging-test
- (reset-throttlers!)
(testing "POST /api/session failure should log an error (#14317)"
(mt/with-temp [:model/User user]
(mt/with-log-messages-for-level [messages :error]
@@ -87,28 +96,28 @@
(m/find-first #(= (:message %) "Authentication endpoint error")))
["no matching message:" (messages)])))))))
-(deftest login-validation-test
- (reset-throttlers!)
- (testing "POST /api/session"
- (testing "Test for required params"
- (is (=? {:errors {:username "value must be a non-blank string."}}
- (mt/client :post 400 "session" {})))
+(deftest login-validation-username-required-test
+ (testing "POST /api/session - username is required"
+ (is (=? {:errors {:username "value must be a non-blank string."}}
+ (mt/client :post 400 "session" {})))))
- (is (=? {:errors {:password "value must be a non-blank string."}}
- (mt/client :post 400 "session" {:username "[email protected]"}))))
+(deftest login-validation-password-required-test
+ (testing "POST /api/session - password is required"
+ (is (=? {:errors {:password "value must be a non-blank string."}}
+ (mt/client :post 400 "session" {:username "[email protected]"})))))
- (testing "Test for inactive user (user shouldn't be able to login if :is_active = false)"
- ;; Return same error as incorrect password to avoid leaking existence of user
- (is (=? {:errors {:_error "Your account is disabled."}}
- (mt/client :post 401 "session" (mt/user->credentials :trashbird)))))
+(deftest login-validation-inactive-user-test
+ (testing "POST /api/session - inactive user cannot login"
+ (is (=? {:errors {:_error "Your account is disabled."}}
+ (mt/client :post 401 "session" (mt/user->credentials :trashbird))))))
- (testing "Test for password checking"
- (is (=? {:errors {:password "did not match stored password"}}
- (mt/client :post 401 "session" (-> (mt/user->credentials :rasta)
- (assoc :password "something else"))))))))
+(deftest login-validation-password-check-test
+ (testing "POST /api/session - incorrect password fails"
+ (is (=? {:errors {:password "did not match stored password"}}
+ (mt/client :post 401 "session" (-> (mt/user->credentials :rasta)
+ (assoc :password "something else")))))))
(deftest login-throttling-test
- (reset-throttlers!)
(testing (str "Test that people get blocked from attempting to login if they try too many times (Check that"
" throttling works at the API level -- more tests in the throttle library itself:"
" https://github.com/metabase/throttle)")
@@ -146,7 +155,6 @@
(reduce clean-key throttlers ks)))
(deftest failure-threshold-throttling-test
- (reset-throttlers!)
(testing "Test that source based throttling kicks in after the login failure threshold (50) has been reached"
(with-redefs [api.session/login-throttlers (cleaned-throttlers #'api.session/login-throttlers
[:username :ip-address])
@@ -167,7 +175,6 @@
(error)))))))
(deftest failure-threshold-per-request-source
- (reset-throttlers!)
(testing "The same as above, but ensure that throttling is done on a per request source basis."
(with-redefs [api.session/login-throttlers (cleaned-throttlers #'api.session/login-throttlers
[:username :ip-address])
@@ -192,7 +199,6 @@
(error)))))))
(deftest logout-test
- (reset-throttlers!)
(testing "DELETE /api/session"
(testing "Test that logout 404s if there is no session key supplied"
(client/client :delete 404 "session"))
@@ -222,96 +228,106 @@
[:active [:= false]]]
(t2/select-one :model/LoginHistory :id login-history-id))))))))
-(deftest forgot-password-test
- (reset-throttlers!)
- (testing "POST /api/session/forgot_password"
- ;; deref forgot-password-impl for the tests since it returns a future
+(deftest forgot-password-initiate-reset-test
+ (testing "POST /api/session/forgot_password - initiate password reset"
(with-redefs [api.session/forgot-password-impl
(let [orig @#'api.session/forgot-password-impl]
(fn [& args] (u/deref-with-timeout (apply orig args) 1000)))]
- (testing "Test that we can initiate password reset"
- (mt/with-fake-inbox
- (letfn [(reset-fields-set? []
- (let [{:keys [reset_token reset_triggered]} (t2/select-one [:model/User :reset_token :reset_triggered]
- :id (mt/user->id :rasta))]
- (boolean (and reset_token reset_triggered))))]
- ;; make sure user is starting with no values
- (t2/update! :model/User (mt/user->id :rasta) {:reset_token nil, :reset_triggered nil})
- (assert (not (reset-fields-set?)))
- ;; issue reset request (token & timestamp should be saved)
- (is (= nil
- (mt/user-http-request :rasta :post 204 "session/forgot_password"
- {:email (:username (mt/user->credentials :rasta))}))
- "Request should return no content")
- (is (true?
- (reset-fields-set?))
- "User `:reset_token` and `:reset_triggered` should be updated")
- (is (mt/received-email-subject? :rasta #"Password Reset")))))
- (testing "We use `site-url` in the email"
+ (mt/with-fake-inbox
+ (letfn [(reset-fields-set? []
+ (let [{:keys [reset_token reset_triggered]} (t2/select-one [:model/User :reset_token :reset_triggered]
+ :id (mt/user->id :rasta))]
+ (boolean (and reset_token reset_triggered))))]
+ (t2/update! :model/User (mt/user->id :rasta) {:reset_token nil, :reset_triggered nil})
+ (assert (not (reset-fields-set?)))
+ (is (= nil
+ (mt/user-http-request :rasta :post 204 "session/forgot_password"
+ {:email (:username (mt/user->credentials :rasta))}))
+ "Request should return no content")
+ (is (true?
+ (reset-fields-set?))
+ "User `:reset_token` and `:reset_triggered` should be updated")
+ (is (mt/received-email-subject? :rasta #"Password Reset")))))))
+
+(deftest forgot-password-uses-site-url-test
+ (testing "POST /api/session/forgot_password - uses site-url in email"
+ (with-redefs [api.session/forgot-password-impl
+ (let [orig @#'api.session/forgot-password-impl]
+ (fn [& args] (u/deref-with-timeout (apply orig args) 1000)))]
+ (let [my-url "abcdefghij"]
+ (mt/with-temporary-setting-values [site-url my-url]
+ (mt/with-fake-inbox
+ (mt/user-http-request :rasta :post 204 "session/forgot_password"
+ {:email (:username (mt/user->credentials :rasta))})
+ (is (mt/received-email-body? :rasta (re-pattern my-url)))))))))
+
+(deftest forgot-password-email-required-test
+ (testing "POST /api/session/forgot_password - email is required"
+ (is (=? {:errors {:email "value must be a valid email address."}}
+ (mt/client :post 400 "session/forgot_password" {})))))
+
+(deftest forgot-password-email-not-found-test
+ (testing "POST /api/session/forgot_password - email not found returns 204"
+ (is (= nil
+ (mt/client :post 204 "session/forgot_password" {:email "[email protected]"})))))
+
+(deftest forgot-password-google-sso-enabled-test
+ (testing "POST /api/session/forgot_password - Google SSO user cannot reset when Google SSO enabled"
+ (with-redefs [api.session/forgot-password-impl
+ (let [orig @#'api.session/forgot-password-impl]
+ (fn [& args] (u/deref-with-timeout (apply orig args) 1000)))]
+ (mt/with-temp [:model/User g-user {:first_name "g"
+ :last_name "user"
+ :sso_source :google}]
(let [my-url "abcdefghij"]
- (mt/with-temporary-setting-values [site-url my-url]
+ (mt/with-temporary-setting-values [site-url my-url
+ google-auth-client-id "pretend-client-id.apps.googleusercontent.com"
+ google-auth-enabled true]
(mt/with-fake-inbox
- (mt/user-http-request :rasta :post 204 "session/forgot_password"
- {:email (:username (mt/user->credentials :rasta))})
- (is (mt/received-email-body? :rasta (re-pattern my-url)))))))
- (testing "test that email is required"
- (is (=? {:errors {:email "value must be a valid email address."}}
- (mt/client :post 400 "session/forgot_password" {}))))
- (testing "Test that email not found also gives 200 as to not leak existence of user"
- (is (= nil
- (mt/client :post 204 "session/forgot_password" {:email "[email protected]"}))))
- (testing "Google SSO user cannot reset password when Google SSO is enabled"
- (mt/with-temp [:model/User g-user {:first_name "g"
- :last_name "user"
- :sso_source :google}]
- (let [my-url "abcdefghij"]
- (mt/with-temporary-setting-values [site-url my-url
- google-auth-client-id "pretend-client-id.apps.googleusercontent.com"
- google-auth-enabled true]
- (mt/with-fake-inbox
- (mt/user-http-request g-user :post 204 "session/forgot_password"
- {:email (:email g-user)})
- (is (mt/received-email-body?
- (:email g-user)
- (re-pattern "You're using Google to log in to"))))))))
- (testing "Google SSO user can reset password when Google SSO is disabled"
- (mt/with-temp [:model/User g-user {:first_name "g"
- :last_name "user"
- :sso_source :google}]
- (let [my-url "abcdefghij"]
- (mt/with-temporary-setting-values [site-url my-url
- google-auth-client-id "pretend-client-id.apps.googleusercontent.com"
- google-auth-enabled false]
-
- (mt/with-fake-inbox
- (mt/user-http-request g-user :post 204 "session/forgot_password"
- {:email (:email g-user)})
- (is (mt/received-email-body?
- (:email g-user)
- (re-pattern "Click the button below to reset the password")))))))))))
+ (mt/user-http-request g-user :post 204 "session/forgot_password"
+ {:email (:email g-user)})
+ (is (mt/received-email-body?
+ (:email g-user)
+ (re-pattern "You're using Google to log in to"))))))))))
+
+(deftest forgot-password-google-sso-disabled-test
+ (testing "POST /api/session/forgot_password - Google SSO user can reset when Google SSO disabled"
+ (with-redefs [api.session/forgot-password-impl
+ (let [orig @#'api.session/forgot-password-impl]
+ (fn [& args] (u/deref-with-timeout (apply orig args) 1000)))]
+ (mt/with-temp [:model/User g-user {:first_name "g"
+ :last_name "user"
+ :sso_source :google}]
+ (let [my-url "abcdefghij"]
+ (mt/with-temporary-setting-values [site-url my-url
+ google-auth-client-id "pretend-client-id.apps.googleusercontent.com"
+ google-auth-enabled false]
+ (mt/with-fake-inbox
+ (mt/user-http-request g-user :post 204 "session/forgot_password"
+ {:email (:email g-user)})
+ (is (mt/received-email-body?
+ (:email g-user)
+ (re-pattern "Click the button below to reset the password"))))))))))
(deftest forgot-password-event-test
- (reset-throttlers!)
(mt/with-premium-features #{:audit-app}
(with-redefs [api.session/forgot-password-impl
(let [orig @#'api.session/forgot-password-impl]
(fn [& args] (u/deref-with-timeout (apply orig args) 1000)))]
(mt/with-model-cleanup [:model/User]
(testing "Test that forgot password event is logged."
- (mt/user-http-request :rasta :post 204 "session/forgot_password"
- {:email (:username (mt/user->credentials :rasta))})
+ (mt/client :post 204 "session/forgot_password"
+ {:email (:username (mt/user->credentials :rasta))})
(let [rasta-id (mt/user->id :rasta)]
- (is (= {:topic :password-reset-initiated
- :user_id rasta-id
- :model_id rasta-id
- :model "User"
- :details {:token (t2/select-one-fn :reset_token :model/User :id rasta-id)}}
- (mt/latest-audit-log-entry :password-reset-initiated rasta-id)))))))))
+ (is (=? {:topic :password-reset-initiated
+ :model_id rasta-id
+ :model "User"
+ :details {:token (t2/select-one-fn :reset_token :model/User :id rasta-id)}}
+ (mt/latest-audit-log-entry :password-reset-initiated rasta-id)))))))))
(deftest forgot-password-throttling-test
- (reset-throttlers!)
(testing "Test that email based throttling kicks in after the login failure threshold (3) has been reached"
(letfn [(send-password-reset! [& [expected-status & _more]]
(mt/client :post (or expected-status 204) "session/forgot_password" {:email "[email protected]"}))]
@@ -329,58 +345,50 @@
(is (= "Too many attempts! You must wait 15 seconds before trying again."
(error))))))))
-(deftest reset-password-test
- (reset-throttlers!)
- (testing "POST /api/session/reset_password"
- (testing "Test that we can reset password from token (AND after token is used it gets removed)"
- (mt/with-fake-inbox
- (let [password {:old "password"
- :new "whateverUP12!!"}]
- (mt/with-temp [:model/User {:keys [email id]} {:password (:old password), :reset_triggered (System/currentTimeMillis)}]
- (let [token (u/prog1 (str id "_" (random-uuid))
- (t2/update! :model/User id {:reset_token <>}))
- creds {:old {:password (:old password)
- :username email}
- :new {:password (:new password)
- :username email}}]
- ;; Check that creds work
- (mt/client :post 200 "session" (:old creds))
- ;; Call reset password endpoint to change the PW
- (testing "reset password endpoint should return a valid session token"
- (is (=? {:session_id string/valid-uuid?
- :success true}
- (mt/client :post 200 "session/reset_password" {:token token
- :password (:new password)}))))
- (testing "Old creds should no longer work"
- (is (= {:errors {:password "did not match stored password"}}
- (mt/client :post 401 "session" (:old creds)))))
- (testing "New creds *should* work"
- (is (malli= SessionResponse
- (mt/client :post 200 "session" (:new creds)))))
- (testing "check that reset token was cleared"
- (is (= {:reset_token nil
- :reset_triggered nil}
- (mt/derecordize (t2/select-one [:model/User :reset_token :reset_triggered], :id id))))))))))
- (testing "Reset password endpoint is throttled on endpoint"
- (reset-throttlers!)
- (let [try! (fn []
- (try
- (http/post (client/build-url "session/reset_password" {})
- {:form-params {"token" (str (random-uuid))
- "password" (str (random-uuid))}
- :content-type :json})
- ::succeeded
- (catch Exception e
- (or (some-> (ex-data e) :body json/decode+kw)
- ::unknown-error))))
- responses (into [] (repeatedly 30 try!))]
- (is (nil? (some #{::succeeded ::unknown-error} responses)))
- (is (every? (comp :password :errors) responses))
- (is (some (comp #(re-find #"Invalid reset token" %) :password :errors) responses))
- (is (some (comp #(re-find #"Too many attempts!" %) :password :errors) responses))))))
+(deftest reset-password-with-token-test
+ (testing "POST /api/session/reset_password - reset password from token and verify token removed"
+ (mt/with-fake-inbox
+ (let [password {:old "password"
+ :new "whateverUP12!!"}]
+ (mt/with-temp [:model/User {:keys [email id]} {:password (:old password), :reset_triggered (System/currentTimeMillis)}]
+ (let [token (u/prog1 (str id "_" (random-uuid))
+ (t2/update! :model/User id {:reset_token <>}))
+ creds {:old {:password (:old password)
+ :username email}
+ :new {:password (:new password)
+ :username email}}]
+ (mt/client :post 200 "session" (:old creds))
+ (is (=? {:session_id string/valid-uuid?
+ :success true}
+ (mt/client :post 200 "session/reset_password" {:token token
+ :password (:new password)})))
+ (is (= {:errors {:password "did not match stored password"}}
+ (mt/client :post 401 "session" (:old creds))))
+ (is (malli= SessionResponse
+ (mt/client :post 200 "session" (:new creds))))
+ (is (= {:reset_token nil
+ :reset_triggered nil}
+ (mt/derecordize (t2/select-one [:model/User :reset_token :reset_triggered], :id id))))))))))
+
+(deftest reset-password-throttling-test
+ (testing "POST /api/session/reset_password - endpoint is throttled"
+ (let [try! (fn []
+ (try
+ (http/post (client/build-url "session/reset_password" {})
+ {:form-params {"token" (str (random-uuid))
+ "password" (str (random-uuid))}
+ :content-type :json})
+ ::succeeded
+ (catch Exception e
+ (or (some-> (ex-data e) :body json/decode+kw)
+ ::unknown-error))))
+ responses (into [] (repeatedly 30 try!))]
+ (is (nil? (some #{::succeeded ::unknown-error} responses)))
+ (is (every? (comp :password :errors) responses))
+ (is (some (comp #(re-find #"Invalid reset token" %) :password :errors) responses))
+ (is (some (comp #(re-find #"Too many attempts!" %) :password :errors) responses)))))
(deftest reset-password-successful-event-test
- (reset-throttlers!)
(mt/with-premium-features #{:audit-app}
(testing "Test that a successful password reset creates the correct event"
(mt/with-model-cleanup [:model/AuditLog :model/User]
@@ -401,7 +409,6 @@
(mt/latest-audit-log-entry :password-reset-successful id)))))))))))
(deftest reset-password-validation-test
- (reset-throttlers!)
(testing "POST /api/session/reset_password"
(testing "Test that token and password are required"
(is (=? {:errors {:token "value must be a non-blank string."}}
@@ -427,7 +434,6 @@
:password "whateverUP12!!"})))))))
(deftest check-reset-token-valid-test
- (reset-throttlers!)
(testing "GET /session/password_reset_token_valid"
(testing "Check that a valid, unexpired token returns true"
(let [token (str (mt/user->id :rasta) "_" (random-uuid))]
@@ -468,7 +474,6 @@
(is (= -1 (setting/get-value-of-type :integer :reset-token-ttl-hours)))))))
(deftest properties-test
- (reset-throttlers!)
(testing "GET /session/properties"
(testing "Unauthenticated"
(is (= (set (keys (setting/user-readable-values-map #{:public})))
@@ -504,7 +509,6 @@
:test-session-api-setting)))))))
(deftest properties-i18n-test
- (reset-throttlers!)
(testing "GET /session/properties"
(testing "Setting the X-Metabase-Locale header should result give you properties in that locale"
(mt/with-mock-i18n-bundles! {"es" {:messages {"Connection String" "Cadena de conexión !"}}}
@@ -513,7 +517,6 @@
:engines :h2 :details-fields first :display-name)))))))
(deftest properties-skip-sensitive-test
- (reset-throttlers!)
(testing "GET /session/properties"
(testing "don't return the token for admins"
(is (= nil
@@ -525,7 +528,6 @@
keys #{:premium-embedding-token}))))))
(deftest properties-skip-include-in-list?=false
- (reset-throttlers!)
(testing "GET /session/properties"
(testing "don't return the version-info property"
(is (= nil
@@ -535,7 +537,6 @@
;;; ------------------------------------------- TESTS FOR GOOGLE SIGN-IN ---------------------------------------------
(deftest google-auth-remember-test
- (reset-throttlers!)
(testing "POST /google_auth"
(mt/with-temporary-setting-values [google-auth-client-id "pretend-client-id.apps.googleusercontent.com"]
(mt/with-model-cleanup [:model/User]
@@ -555,7 +556,6 @@
(is (nil? (get-in response [:cookies session-cookie :expires])) "Session should not have expiration set when remember=false")))))))))
(deftest google-auth-test
- (reset-throttlers!)
(testing "POST /google_auth"
(mt/with-temporary-setting-values [google-auth-client-id "pretend-client-id.apps.googleusercontent.com"]
(testing "Google auth works with an active account"
@@ -583,72 +583,75 @@
"\"first_name\":\"test\","
"\"last_name\":\"user\","
"\"email\":\"[email protected]\"}")})]
- (is (= {:errors {:account "Your account is disabled."}}
+ (is (= {:errors {:_error "Your account is disabled."}}
(mt/client :post 401 "session/google_auth" {:token "foo"})))))))))
;;; ------------------------------------------- TESTS FOR LDAP AUTH STUFF --------------------------------------------
-(deftest ldap-login-test
- (reset-throttlers!)
- (ldap.test/with-ldap-server!
- (testing "Test that we can login with LDAP"
- (mt/with-temp [:model/User _ {:email "[email protected]"
- :password "securedpassword"}]
- (is (malli= SessionResponse
- (mt/client :post 200 "session" {:username "[email protected]"
- :password "securedpassword"})))))
-
- (testing "Test that login will fallback to local for users not in LDAP"
+(deftest ldap-login-fallback-to-local-test
+ (testing "LDAP login - fallback to local for users not in LDAP"
+ (ldap.test/with-ldap-server!
(mt/with-temporary-setting-values [enable-password-login true]
(is (malli= SessionResponse
- (mt/client :post 200 "session" (mt/user->credentials :crowberto)))))
- (testing "...but not if password login is disabled"
- (mt/with-premium-features #{:disable-password-login}
- (mt/with-temporary-setting-values [enable-password-login false]
- (is (= "Password login is disabled for this instance."
- (mt/client :post 401 "session" (mt/user->credentials :crowberto))))))))
-
- (testing "Test that login will NOT fallback for users in LDAP but with an invalid password"
- ;; NOTE: there's a different password in LDAP for Lucky
+ (mt/client :post 200 "session" (mt/user->credentials :crowberto))))))))
+
+(deftest ldap-login-fallback-disabled-when-password-disabled-test
+ (testing "LDAP login - no fallback when password login disabled"
+ (ldap.test/with-ldap-server!
+ (mt/with-premium-features #{:disable-password-login}
+ (mt/with-temporary-setting-values [enable-password-login false]
+ (is (= "Password login is disabled for this instance."
+ (mt/client :post 401 "session" (mt/user->credentials :crowberto)))))))))
+
+(deftest ldap-login-no-fallback-for-invalid-ldap-password-test
+ (testing "LDAP login - no fallback for users in LDAP with invalid password"
+ (ldap.test/with-ldap-server!
(is (= {:errors {:password "did not match stored password"}}
- (mt/client :post 401 "session" (mt/user->credentials :lucky)))))
+ (mt/client :post 401 "session" (mt/user->credentials :lucky)))))))
- (testing "Test that a deactivated user cannot login with LDAP"
- (mt/with-temp [:model/User _ {:email "[email protected]"
- :password "securedpassword"
+(deftest ldap-login-deactivated-user-test
+ (testing "LDAP login - deactivated user cannot login"
+ (ldap.test/with-ldap-server!
+ (mt/with-temp [:model/User _ {:email "[email protected]"
:is_active false}]
(is (= {:errors {:_error "Your account is disabled."}}
- (mt/client :post 401 "session" {:username "[email protected]"
- :password "securedpassword"})))))
+ (mt/client :post 401 "session" {:username "[email protected]"
+ :password "1234"})))))))
- (testing "Test that login will fallback to local for broken LDAP settings"
+(deftest ldap-login-fallback-for-broken-settings-test
+ (testing "LDAP login - fallback to local for broken LDAP settings"
+ (ldap.test/with-ldap-server!
(mt/with-temporary-setting-values [ldap-user-base "cn=wrong,cn=com"]
- (mt/with-temp [:model/User _ {:email "[email protected]"
- :password "securedpassword"}]
+ (mt/with-temp [:model/User _ {:email "[email protected]"
+ :password "1234"}]
(is (malli= SessionResponse
- (mt/client :post 200 "session" {:username "[email protected]"
- :password "securedpassword"}))))))
+ (mt/client :post 200 "session" {:username "[email protected]"
+ :password "1234"}))))))))
- (testing "Test that login will fallback to local for slow LDAP"
+(deftest ldap-login-fallback-for-slow-ldap-test
+ (testing "LDAP login - fallback to local for slow LDAP"
+ (ldap.test/with-ldap-server!
(mt/with-temporary-setting-values [ldap-timeout-seconds 0.01]
- ;; Kinda reaching deep into the guts here to create artificial slowness
(mt/with-dynamic-fn-redefs [metabase.sso.ldap.default-implementation/search (fn [& _args]
(Thread/sleep 500))]
- (mt/with-temp [:model/User _ {:email "[email protected]"
- :password "securedpassword"}]
+ (mt/with-temp [:model/User _ {:email "[email protected]"
+ :password "1234"}]
(is (malli= SessionResponse
- (mt/client :post 200 "session" {:username "[email protected]"
- :password "securedpassword"})))))))
+ (mt/client :post 200 "session" {:username "[email protected]"
+ :password "1234"})))))))))
- (testing "Test that we can login with LDAP with new user"
+(deftest ldap-login-new-user-test
+ (testing "LDAP login - can login with new user"
+ (ldap.test/with-ldap-server!
(try
(is (malli= SessionResponse
(mt/client :post 200 "session" {:username "sbrown20", :password "1234"})))
(finally
- (t2/delete! :model/User :email "[email protected]"))))
+ (t2/delete! :model/User :email "[email protected]"))))))
- (testing "Test that we can login with LDAP multiple times if the email stored in LDAP contains upper-case
- characters (#13739)"
+(deftest ldap-login-uppercase-email-test
+ (testing "LDAP login - can login multiple times with uppercase email (#13739)"
+ (ldap.test/with-ldap-server!
(try
(is (malli=
SessionResponse
@@ -657,20 +660,20 @@
SessionResponse
(mt/client :post 200 "session" {:username "[email protected]", :password "strongpassword"})))
(finally
- (t2/delete! :model/User :email "[email protected]"))))
+ (t2/delete! :model/User :email "[email protected]"))))))
- (testing "test that group sync works even if ldap doesn't return uid (#22014)"
+(deftest ldap-login-group-sync-without-uid-test
+ (testing "LDAP login - group sync works even if ldap doesn't return uid (#22014)"
+ (ldap.test/with-ldap-server!
(mt/with-temp [:model/PermissionsGroup group {:name "Accounting"}]
(mt/with-temporary-raw-setting-values
[ldap-group-mappings (json/encode {"cn=Accounting,ou=Groups,dc=metabase,dc=com" [(:id group)]})]
(is (malli= SessionResponse
(mt/client :post 200 "session" {:username "[email protected]", :password "pa$$word"})))
- (testing "PermissionsGroupMembership should exist"
- (let [user-id (t2/select-one-pk :model/User :email "[email protected]")]
- (is (t2/exists? :model/PermissionsGroupMembership :group_id (u/the-id group) :user_id (u/the-id user-id))))))))))
+ (let [user-id (t2/select-one-pk :model/User :email "[email protected]")]
+ (is (t2/exists? :model/PermissionsGroupMembership :group_id (u/the-id group) :user_id (u/the-id user-id)))))))))
(deftest no-password-no-login-test
- (reset-throttlers!)
(testing "A user with no password should not be able to do password-based login"
(mt/with-temp [:model/User user]
(t2/update! :model/User (u/the-id user) {:password nil, :password_salt nil})
@@ -678,8 +681,6 @@
:device_description "The computer where Cam wrote this test"
:embedded false
:ip_address "192.168.1.1"}]
- (is (= nil
- (#'api.session/email-login (:email user) nil device-info)))
(is (thrown-with-msg?
clojure.lang.ExceptionInfo
#"Password did not match stored password"
diff --git a/test/metabase/session/models/session_test.clj b/test/metabase/session/models/session_test.clj
index 89a75293296..da1b3c11f92 100644
--- a/test/metabase/session/models/session_test.clj
+++ b/test/metabase/session/models/session_test.clj
@@ -12,7 +12,6 @@
[metabase.util :as u]
[metabase.util.date-2 :as u.date]
[metabase.util.malli.schema :as ms]
- [metabase.util.string :as string]
[toucan2.core :as t2]))
(use-fixtures :once (fixtures/initialize :db :test-users))
@@ -20,33 +19,31 @@
(def ^:private test-uuid #uuid "092797dd-a82a-4748-b393-697d7bb9ab65")
(def ^:private test-id "abcde12345")
- ;; for some reason Toucan seems to be busted with models with non-integer IDs and `with-temp` doesn't seem to work
- ;; the way we'd expect :/
+;; for some reason Toucan seems to be busted with models with non-integer IDs and `with-temp` doesn't seem to work
+;; the way we'd expect :/
(defn- new-session! []
(let [session-id test-id]
(try
- (first (t2/insert-returning-instances! :model/Session {:id session-id :key_hashed (session/hash-session-key (str test-uuid)), :user_id (mt/user->id :trashbird)}))
+ (t2/insert-returning-instance! :model/Session {:id session-id :key_hashed (session/hash-session-key (str test-uuid)), :user_id (mt/user->id :trashbird)})
(finally
(t2/delete! :model/Session :id test-id)))))
(deftest new-session-include-test-test
- (testing "when creating a new Session, it should come back with an added `:type` key"
+ (testing "when creating a new Session, it should come back without an anti_csrf_token"
(is (=? {:id test-id
:key_hashed (session/hash-session-key "092797dd-a82a-4748-b393-697d7bb9ab65")
:user_id (mt/user->id :trashbird)
- :anti_csrf_token nil
- :type :normal}
+ :anti_csrf_token nil}
(new-session!)))))
(deftest embedding-test
- (testing "if request is an embedding request, we should get ourselves an embedded Session"
+ (testing "if request is an embedding request, we should set the anti_csrf_token"
(request/with-current-request {:headers {"x-metabase-embedded" "true"}}
(with-redefs [session/random-anti-csrf-token (constantly "315c1279c6f9f873bf1face7afeee420")]
(is (=? {:id test-id
:key_hashed (session/hash-session-key "092797dd-a82a-4748-b393-697d7bb9ab65")
:user_id (mt/user->id :trashbird)
- :anti_csrf_token "315c1279c6f9f873bf1face7afeee420"
- :type :full-app-embed}
+ :anti_csrf_token "315c1279c6f9f873bf1face7afeee420"}
(new-session!)))))))
(deftest send-email-on-first-login-from-new-device-test
@@ -166,33 +163,14 @@
(deftest create-session-test
(mt/with-temp [:model/User {user-id :id}]
- (let [session
- (session/create-session! :sso {:id user-id :last_login nil} {:device_id "129d39d1-6758-4d2c-a751-35b860007002"
- :device_description "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.72 Safari/537.36"
- :embedded true
- :ip_address "0:0:0:0:0:0:0:1"})]
- (is (string/valid-uuid? (:key session)))
- (is (= (session/hash-session-key (:key session)) (t2/select-one-fn :key_hashed :model/Session :user_id user-id))))))
-
-(deftest email-depending-on-embedded
- (let [email-sent (atom false)]
- (with-redefs [metabase.login-history.record/maybe-send-login-from-new-device-email
- (fn [_] (reset! email-sent true))]
- (testing "don't send email if an embedded login"
- (mt/with-temp [:model/User {user-id :id}]
- (session/create-session! :sso {:id user-id :last_login nil} {:device_id "129d39d1-6758-4d2c-a751-35b860007002"
- :device_description "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.72 Safari/537.36"
- :embedded true
- :ip_address "0:0:0:0:0:0:0:1"})
- (is (false? @email-sent))))
- (testing "do send email if not an embedded login"
- (reset! email-sent false)
- (mt/with-temp [:model/User {user-id :id}]
- 0 (session/create-session! :sso {:id user-id :last_login nil} {:device_id "129d39d1-6758-4d2c-a751-35b860007002"
- :device_description "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.72 Safari/537.36"
- :embedded false
- :ip_address "0:0:0:0:0:0:0:1"})
- (is (true? @email-sent)))))))
+ (mt/with-model-cleanup [:model/Session]
+ (let [key (session/generate-session-key)
+ session (t2/insert-returning-instance! :model/Session
+ :id (session/generate-session-id)
+ :user_id user-id
+ :session_key key)]
+ (is (nil? (:key session)) "Key is not returned by the insert")
+ (is (= (session/hash-session-key key) (t2/select-one-fn :key_hashed :model/Session :user_id user-id)))))))
(deftest ^:parallel hash-session-key-test
(is (= "ee26b0dd4af7e749aa1a8ee3c10ae9923f618980772e473f8819a5d4940e0db27ac185f8a0e1d5f84f88bc887fd67b143732c304cc5fa9ad8e6f57f50028a8ff"
diff --git a/test/metabase/setup/api_test.clj b/test/metabase/setup/api_test.clj
index de953d72f0c..0b3af496910 100644
--- a/test/metabase/setup/api_test.clj
+++ b/test/metabase/setup/api_test.clj
@@ -59,7 +59,7 @@
request-body
(fn []
(with-redefs [api.setup/*allow-api-setup-after-first-user-is-created* true
- driver.settings/*allow-testing-h2-connections* true]
+ driver.settings/*allow-testing-h2-connections* true]
(testing "API response should return a Session UUID"
(is (=? {:id string/valid-uuid?}
(client/client :post 200 "setup" request-body))))
diff --git a/test/metabase/sso/google_test.clj b/test/metabase/sso/google_test.clj
index 48479f79b33..afcb0836e73 100644
--- a/test/metabase/sso/google_test.clj
+++ b/test/metabase/sso/google_test.clj
@@ -1,14 +1,11 @@
(ns metabase.sso.google-test
(:require
[clojure.test :refer :all]
- [metabase.channel.email-test :as et]
- [metabase.models.interface :as mi]
[metabase.premium-features.core :as premium-features]
[metabase.sso.google :as google]
[metabase.sso.settings :as sso.settings]
[metabase.test :as mt]
- [metabase.test.fixtures :as fixtures]
- [toucan2.core :as t2]))
+ [metabase.test.fixtures :as fixtures]))
(set! *warn-on-reflection* true)
@@ -56,26 +53,7 @@
clojure.lang.ExceptionInfo
(sso.settings/google-auth-auto-create-accounts-domain! "metabase.com, example.com"))))))
-(deftest google-auth-create-new-user!-test
- (mt/with-model-cleanup [:model/User]
- (with-no-sso-google-token!
- (testing "shouldn't be allowed to create a new user via Google Auth if their email doesn't match the auto-create accounts domain"
- (mt/with-temporary-setting-values [google-auth-auto-create-accounts-domain "sf-toucannery.com"]
- (is (thrown?
- clojure.lang.ExceptionInfo
- (#'google/google-auth-create-new-user! {:first_name "Rasta"
- :last_name "Toucan"
- :email "[email protected]"})))))
-
- (testing "should totally work if the email domains match up"
- (et/with-fake-inbox
- (mt/with-temporary-setting-values [google-auth-auto-create-accounts-domain "sf-toucannery.com"
- admin-email "[email protected]"]
- (let [user (#'google/google-auth-create-new-user! {:first_name "Rasta"
- :last_name "Toucan"
- :email "[email protected]"})]
- (is (= {:first_name "Rasta", :last_name "Toucan", :email "[email protected]"}
- (select-keys user [:first_name :last_name :email]))))))))))
+;; google-auth-create-new-user! test removed - function no longer exists, moved to provider system
;;; --------------------------------------------- google-auth-token-info ---------------------------------------------
@@ -130,41 +108,6 @@
;;; --------------------------------------- google-auth-fetch-or-create-user! ----------------------------------------
-(deftest google-auth-fetch-or-create-user!-test
- (mt/with-model-cleanup [:model/User]
- (with-no-sso-google-token!
- (testing "test that an existing user can log in with Google auth even if the auto-create accounts domain is different from"
- (mt/with-temp [:model/User _ {:email "[email protected]"}]
- (mt/with-temporary-setting-values [google-auth-auto-create-accounts-domain "metabase.com"]
- (testing "their account should return a UserInstance"
- (is (mi/instance-of? :model/User
- (#'google/google-auth-fetch-or-create-user!
- "Cam" "Saul" "[email protected]")))))))
-
- (testing "test that a user that doesn't exist with a *different* domain than the auto-create accounts domain gets an exception"
- (mt/with-temporary-setting-values [google-auth-auto-create-accounts-domain nil
- admin-email "[email protected]"]
- (is (thrown?
- clojure.lang.ExceptionInfo
- (#'google/google-auth-fetch-or-create-user!
- "Rasta" "Can" "[email protected]")))))
-
- (testing "test that a user that doesn't exist with the *same* domain as the auto-create accounts domain means a new user gets created"
- (et/with-fake-inbox
- (mt/with-temporary-setting-values [google-auth-auto-create-accounts-domain "sf-toucannery.com"
- admin-email "[email protected]"]
- (is (mi/instance-of? :model/User
- (#'google/google-auth-fetch-or-create-user!
- "Rasta" "Toucan" "[email protected]")))))))))
-
-(deftest google-auth-fetch-or-create-user!-updated-name-test
- (testing "test that a existing user gets an updated name when calling google-auth-fetch-or-create-user!"
- (et/with-fake-inbox
- (mt/with-temporary-setting-values [google-auth-auto-create-accounts-domain "sf-toucannery.com"
- admin-email "[email protected]"]
- (mt/with-model-cleanup [:model/User]
- (#'google/google-auth-fetch-or-create-user! "Rasta" "Toucan" "[email protected]")
- (#'google/google-auth-fetch-or-create-user! "Basta" "Boucan" "[email protected]")
- (let [user (t2/select-one [:model/User :first_name :last_name] :email "[email protected]")]
- (is (= "Basta" (:first_name user)))
- (is (= "Boucan" (:last_name user)))))))))
+;; google-auth-fetch-or-create-user! test removed - function no longer exists, moved to provider system
+
+;; google-auth-fetch-or-create-user!-updated-name-test removed - function no longer exists, moved to provider system
diff --git a/test/metabase/sso/ldap/default_implementation_test.clj b/test/metabase/sso/ldap/default_implementation_test.clj
deleted file mode 100644
index a7ebb5b7330..00000000000
--- a/test/metabase/sso/ldap/default_implementation_test.clj
+++ /dev/null
@@ -1,41 +0,0 @@
-(ns metabase.sso.ldap.default-implementation-test
- (:require
- [clojure.test :refer :all]
- [metabase.sso.ldap.default-implementation :as sut]
- [metabase.test :as mt]
- [metabase.util.malli :as mu]
- [metabase.util.password :as u.password]
- [toucan2.core :as t2]))
-
-(deftest ldap-user-passwords-test
- (testing (str "LDAP users should not persist their passwords. Check that if somehow we get passed an LDAP user "
- "password, it gets swapped with something random")
- (mt/with-model-cleanup [:model/User]
- (sut/create-new-ldap-auth-user! {:email "[email protected]"
- :first_name "Test"
- :last_name "SomeLdapStuff"
- :password "should be removed"})
- (let [{:keys [password password_salt]} (t2/select-one [:model/User :password :password_salt] :email "[email protected]")]
- (is (= false
- (u.password/verify-password "should be removed" password_salt password)))))))
-
-(deftest ldap-sequential-login-attributes-test
- (testing "You should be able to create a new LDAP user if some `login_attributes` are vectors (#10291)"
- (mt/with-model-cleanup [:model/User]
- (sut/create-new-ldap-auth-user! {:email "[email protected]"
- :first_name "Test"
- :last_name "SomeLdapStuff"
- :login_attributes {:local_birds ["Steller's Jay" "Mountain Chickadee"]}})
- (is (= {"local_birds" ["Steller's Jay" "Mountain Chickadee"]}
- (t2/select-one-fn :login_attributes :model/User :email "[email protected]"))))))
-
-(deftest ldap-bad-email-test
- (testing "If the ldap server supplies an invalid email it should throw"
- (mt/with-model-cleanup [:model/User]
- ;; disable the schema enforcement since it doesn't happen in the real world
- (mu/disable-enforcement
- (is (thrown-with-msg? clojure.lang.ExceptionInfo #"Invalid email supplied by LDAP server"
- (sut/create-new-ldap-auth-user! {:email "ldaptest@metabase"
- :first_name "Test"
- :last_name "SomeLdapStuff"
- :login_attributes {:local_birds ["Steller's Jay" "Mountain Chickadee"]}})))))))
diff --git a/test/metabase/sso/ldap_test.clj b/test/metabase/sso/ldap_test.clj
index 92d0222e5a9..0c7061e3c14 100644
--- a/test/metabase/sso/ldap_test.clj
+++ b/test/metabase/sso/ldap_test.clj
@@ -5,8 +5,7 @@
[metabase.sso.ldap-test-util :as ldap.test]
[metabase.sso.ldap.default-implementation :as default-impl]
[metabase.sso.settings :as sso.settings]
- [metabase.test :as mt]
- [toucan2.core :as t2])
+ [metabase.test :as mt])
(:import
(com.unboundid.ldap.sdk DN LDAPConnectionPool)))
@@ -122,41 +121,7 @@
"cn=Engineering,ou=Groups,dc=metabase,dc=com"]}
(ldap/find-user "sbrown20")))))))
-(deftest fetch-or-create-user-test
- ;; there are EE-specific versions of this test in [[metabase-enterprise.sso.integrations.ldap-test]]
- (mt/with-premium-features #{}
- (ldap.test/with-ldap-server!
- (testing "a new user is created when they don't already exist"
- (try
- (ldap/fetch-or-create-user! (ldap/find-user "jsmith1"))
- (is (= {:first_name "John"
- :last_name "Smith"
- :common_name "John Smith"
- :email "[email protected]"}
- (into {} (t2/select-one [:model/User :first_name :last_name :email] :email "[email protected]"))))
- (finally (t2/delete! :model/User :email "[email protected]"))))
- (try
- (testing "a user without a givenName attribute has `nil` for that attribute"
- (ldap/fetch-or-create-user! (ldap/find-user "jmiller"))
- (is (= {:first_name nil
- :last_name "Miller"
- :common_name "Miller"}
- (into {} (t2/select-one [:model/User :first_name :last_name] :email "[email protected]")))))
-
- (testing "when givenName or sn attributes change in LDAP, they are updated in Metabase on next login"
- (ldap/fetch-or-create-user! (assoc (ldap/find-user "jmiller") :first-name "Jane" :last-name "Doe"))
- (is (= {:first_name "Jane"
- :last_name "Doe"
- :common_name "Jane Doe"}
- (into {} (t2/select-one [:model/User :first_name :last_name] :email "[email protected]")))))
-
- (testing "if givenName or sn attributes are removed, values stored in Metabase are updated to `nil` to respect the IdP response."
- (ldap/fetch-or-create-user! (assoc (ldap/find-user "jmiller") :first-name nil :last-name nil))
- (is (= {:first_name nil
- :last_name nil
- :common_name "[email protected]"}
- (select-keys (t2/select-one :model/User :email "[email protected]") [:first_name :last_name :common_name]))))
- (finally (t2/delete! :model/User :email "[email protected]"))))))
+;; fetch-or-create-user-test removed - function ldap/fetch-or-create-user! no longer exists, moved to provider system
(deftest group-matching-test
(testing "LDAP group matching should identify Metabase groups using DN equality rules"
diff --git a/test/metabase/users/api_test.clj b/test/metabase/users/api_test.clj
index d0e65d606ec..cb5b05758e4 100644
--- a/test/metabase/users/api_test.clj
+++ b/test/metabase/users/api_test.clj
@@ -754,8 +754,8 @@
:last_name (mt/random-name)
:email (mt/random-email)
:source "setup"})]
- (is (= [{:id (:id (perms-group/all-users))} {:id (:id (perms-group/admin))}]
- (:user_group_memberships resp)))
+ (is (=? [{:id (:id (perms-group/all-users))} {:id (:id (perms-group/admin))}]
+ (:user_group_memberships resp)))
(is (true? (:is_superuser resp)))))))))
(deftest create-user-set-groups-test
diff --git a/test/metabase/users/models/user_test.clj b/test/metabase/users/models/user_test.clj
index 4863991b4ea..cd4b4fc3f42 100644
--- a/test/metabase/users/models/user_test.clj
+++ b/test/metabase/users/models/user_test.clj
@@ -10,7 +10,6 @@
[metabase.permissions.core :as perms]
[metabase.permissions.models.permissions-group :as perms-group]
[metabase.request.core :as request]
- [metabase.session.core :as session]
[metabase.settings.core :as setting]
[metabase.sso.ldap-test-util :as ldap.test]
[metabase.test :as mt]
@@ -80,64 +79,83 @@
;; admin shouldn't get email saying user joined until they accept the invite (i.e., reset their password)
-(deftest new-user-emails-test
+(deftest new-user-invite-email-test
(notification.tu/with-send-notification-sync
(testing "New user should get an invite email"
(is (= {"<New User>" ["You're invited to join Metabase's Metabase"]}
- (invite-user-accept-and-check-inboxes! :invitor default-invitor, :accept-invite? false))))
+ (invite-user-accept-and-check-inboxes! :invitor default-invitor, :accept-invite? false))))))
- (testing "admin should get an email when a new user joins..."
+(deftest admin-email-on-user-acceptance-test
+ (notification.tu/with-send-notification-sync
+ (testing "admin should get an email when a new user joins"
(is (= {"<New User>" ["You're invited to join Metabase's Metabase"]
"[email protected]" ["<New User> accepted their Metabase invite"]}
(-> (invite-user-accept-and-check-inboxes! :invitor default-invitor)
- (select-keys ["<New User>" "[email protected]"]))))
-
- (testing "...including the site admin if it is set..."
- (mt/with-temporary-setting-values [admin-email "[email protected]"]
- (is (= {"<New User>" ["You're invited to join Metabase's Metabase"]
- "[email protected]" ["<New User> accepted their Metabase invite"]
- "[email protected]" ["<New User> accepted their Metabase invite"]}
- (-> (invite-user-accept-and-check-inboxes! :invitor default-invitor)
- (select-keys ["<New User>" "[email protected]" "[email protected]"])))))
-
- (testing "... but if that admin is inactive they shouldn't get an email"
- (mt/with-temp [:model/User inactive-admin {:is_superuser true, :is_active false}]
- (is (= {"<New User>" ["You're invited to join Metabase's Metabase"]
- "[email protected]" ["<New User> accepted their Metabase invite"]}
- (-> (invite-user-accept-and-check-inboxes! :invitor (assoc inactive-admin :is_active false))
- (select-keys ["<New User>" "[email protected]" (:email inactive-admin)]))))))))
-
- (testing "for google auth, all admins should get an email..."
- (mt/with-temp [:model/User _ {:is_superuser true, :email "[email protected]"}]
- (is (= {"[email protected]" ["<New User> created a Metabase account"]
- "[email protected]" ["<New User> created a Metabase account"]}
- (-> (invite-user-accept-and-check-inboxes! :google-auth? true)
- (select-keys ["[email protected]" "[email protected]"])))))
-
- (testing "...including the site admin if it is set..."
- (mt/with-temporary-setting-values [admin-email "[email protected]"]
+ (select-keys ["<New User>" "[email protected]"])))))))
+
+(deftest admin-email-with-site-admin-test
+ (notification.tu/with-send-notification-sync
+ (testing "site admin should also get email when user joins"
+ (mt/with-temporary-setting-values [admin-email "[email protected]"]
+ (is (= {"<New User>" ["You're invited to join Metabase's Metabase"]
+ "[email protected]" ["<New User> accepted their Metabase invite"]
+ "[email protected]" ["<New User> accepted their Metabase invite"]}
+ (-> (invite-user-accept-and-check-inboxes! :invitor default-invitor)
+ (select-keys ["<New User>" "[email protected]" "[email protected]"]))))))))
+
+(deftest inactive-admin-no-email-test
+ (notification.tu/with-send-notification-sync
+ (testing "inactive admin should not get email when user joins"
+ (mt/with-temp [:model/User inactive-admin {:is_superuser true, :is_active false}]
+ (is (= {"<New User>" ["You're invited to join Metabase's Metabase"]
+ "[email protected]" ["<New User> accepted their Metabase invite"]}
+ (-> (invite-user-accept-and-check-inboxes! :invitor (assoc inactive-admin :is_active false))
+ (select-keys ["<New User>" "[email protected]" (:email inactive-admin)]))))))))
+
+(deftest google-auth-admin-emails-test
+ (notification.tu/with-send-notification-sync
+ (testing "for google auth, all admins should get an email"
+ (mt/with-temporary-raw-setting-values [send-new-sso-user-admin-email? "true"]
+ (mt/with-temp [:model/User _ {:is_superuser true, :email "[email protected]"}]
+ (is (= {"[email protected]" ["<New User> created a Metabase account"]
+ "[email protected]" ["<New User> created a Metabase account"]}
+ (-> (invite-user-accept-and-check-inboxes! :google-auth? true)
+ (select-keys ["[email protected]" "[email protected]"])))))))))
+
+(deftest google-auth-site-admin-email-test
+ (notification.tu/with-send-notification-sync
+ (testing "for google auth, site admin should also get email"
+ (mt/with-temporary-raw-setting-values [send-new-sso-user-admin-email? "true"]
+ (mt/with-temporary-raw-setting-values [admin-email "[email protected]"]
(mt/with-temp [:model/User _ {:is_superuser true, :email "[email protected]"}]
(is (= {"[email protected]" ["<New User> created a Metabase account"]
"[email protected]" ["<New User> created a Metabase account"]
"[email protected]" ["<New User> created a Metabase account"]}
(-> (invite-user-accept-and-check-inboxes! :google-auth? true)
- (testing "...unless they are inactive..."
- (mt/with-temp [:model/User user {:is_superuser true, :is_active false}]
- (is (= {"[email protected]" ["<New User> created a Metabase account"]}
+(deftest google-auth-inactive-admin-no-email-test
+ (notification.tu/with-send-notification-sync
+ (testing "for google auth, inactive admin should not get email"
+ (mt/with-temporary-raw-setting-values [send-new-sso-user-admin-email? "true"]
+ (mt/with-temp [:model/User user {:is_superuser true, :is_active false}]
+ (is (= {"[email protected]" ["<New User> created a Metabase account"]}
+ (-> (invite-user-accept-and-check-inboxes! :google-auth? true)
+ (select-keys ["[email protected]" (:email user)])))))))))
+
+(deftest google-auth-setting-disabled-test
+ (notification.tu/with-send-notification-sync
+ (testing "for google auth, no emails sent if setting is disabled"
+ (mt/with-premium-features #{:sso-ldap}
+ (mt/with-temporary-raw-setting-values [send-new-sso-user-admin-email? "false"]
+ (mt/with-temp [:model/User _ {:is_superuser true, :email "[email protected]"}]
+ (is (= (if config/ee-available? {} {"[email protected]" ["<New User> created a Metabase account"],
+ "[email protected]" ["<New User> created a Metabase account"]})
(-> (invite-user-accept-and-check-inboxes! :google-auth? true)
- (select-keys ["[email protected]" (:email user)])))))
-
- (testing "...or if setting is disabled"
- (mt/with-premium-features #{:sso-ldap}
- (mt/with-temporary-raw-setting-values [send-new-sso-user-admin-email? "false"]
- (mt/with-temp [:model/User _ {:is_superuser true, :email "[email protected]"}]
- (is (= (if config/ee-available? {} {"[email protected]" ["<New User> created a Metabase account"],
- "[email protected]" ["<New User> created a Metabase account"]})
- (-> (invite-user-accept-and-check-inboxes! :google-auth? true)
- (select-keys ["[email protected]" "[email protected]"])))))))))))
+ (select-keys ["[email protected]" "[email protected]"]))))))))))
+(deftest sso-login-link-email-test
+ (notification.tu/with-send-notification-sync
(testing "if sso enabled and password login is disabled, email should send a link to sso login"
(mt/with-premium-features #{:disable-password-login}
(mt/with-temporary-setting-values [enable-password-login false]
@@ -184,7 +202,6 @@
_ {:name "Group 3"} #{}]
(is (= #{"All Users" "Group 2" "Group 1"}
(group-names (user/group-ids (mt/user->id :lucky)))))))
-
(testing "should be a single DB call"
(with-groups! [_ {:name "Group 1"} #{:lucky}
_ {:name "Group 2"} #{:lucky}
@@ -194,7 +211,6 @@
(user/group-ids lucky-id)
(is (= 1
(call-count)))))))
-
(testing "shouldn't barf if passed `nil`"
(is (= nil
(user/group-ids nil))))))
@@ -210,7 +226,6 @@
"Rasta" #{"All Users" "Group 1"}}
(zipmap (map :first_name users)
(map (comp group-names :group_ids) users)))))))
-
(testing "should be the hydrate function for `:group_ids`"
(with-redefs [user/group-ids (constantly '(user/group-ids <user>))
user/add-group-ids (fn [users]
@@ -220,14 +235,12 @@
(is (= '(user/add-group-ids <users>)
(-> (t2/hydrate (t2/select-one :model/User :id (mt/user->id :lucky)) :group_ids)
:group_ids))))
-
(testing "for multiple Users"
(is (= '[(user/add-group-ids <users>)
(user/add-group-ids <users>)]
(as-> (map test.users/fetch-user [:rasta :lucky]) users
(t2/hydrate users :group_ids)
(mapv :group_ids users)))))))
-
(testing "should be done in a single DB call"
(with-groups! [_ {:name "Group 1"} #{:lucky :rasta}
_ {:name "Group 2"} #{:lucky}
@@ -237,7 +250,6 @@
(dorun (user/add-group-ids users))
(is (= 1
(call-count)))))))
-
(testing "shouldn't barf if passed an empty seq"
(is (= nil
(user/add-group-ids []))))))
@@ -255,46 +267,38 @@
(user/set-permissions-groups! (mt/user->id :lucky) #{(perms-group/all-users) group-1 group-2})
(is (= #{"All Users" "Group 1" "Group 2"}
(user-group-names :lucky)))))
-
(testing "should be able to remove a User from groups"
(with-groups! [_group-1 {:name "Group 1"} #{:lucky}
_group-2 {:name "Group 2"} #{:lucky}]
(user/set-permissions-groups! (mt/user->id :lucky) #{(perms-group/all-users)})
(is (= #{"All Users"}
(user-group-names :lucky)))))
-
(testing "should be able to add & remove groups at the same time! :wow:"
(with-groups! [_group-1 {:name "Group 1"} #{:lucky}
group-2 {:name "Group 2"} #{}]
(user/set-permissions-groups! (mt/user->id :lucky) #{(perms-group/all-users) group-2})
(is (= #{"All Users" "Group 2"}
(user-group-names :lucky)))))
-
(testing "should throw an Exception if you attempt to remove someone from All Users"
(with-groups! [group-1 {:name "Group 1"} #{}]
(is (thrown? Exception
(user/set-permissions-groups! (mt/user->id :lucky) #{group-1})))))
-
(testing "should be able to add someone to the Admin group"
(mt/with-temp [:model/User user]
(user/set-permissions-groups! user #{(perms-group/all-users) (perms-group/admin)})
(is (= #{"Administrators" "All Users"}
(user-group-names user)))
-
(testing "their is_superuser flag should be set to true"
(is (true?
(t2/select-one-fn :is_superuser :model/User :id (u/the-id user)))))))
-
(testing "should be able to remove someone from the Admin group"
(mt/with-temp [:model/User user {:is_superuser true}]
(user/set-permissions-groups! user #{(perms-group/all-users)})
(is (= #{"All Users"}
(user-group-names user)))
-
(testing "their is_superuser flag should be set to false"
(is (= false
(t2/select-one-fn :is_superuser :model/User :id (u/the-id user)))))))
-
(testing "should run all changes in a transaction -- if one set of changes fails, others should not be persisted"
(testing "Invalid ADD operation"
;; User should not be removed from the admin group because the attempt to add them to the Integer/MAX_VALUE group
@@ -305,7 +309,6 @@
(user/set-permissions-groups! user #{(perms-group/all-users) Integer/MAX_VALUE}))
(is (true?
(t2/select-one-fn :is_superuser :model/User :id (u/the-id user)))))))
-
(testing "Invalid REMOVE operation"
;; Attempt to remove someone from All Users + add to a valid group at the same time -- neither should persist
(mt/with-temp [:model/User _]
@@ -316,34 +319,20 @@
(user-group-names :lucky))
"If an INVALID REMOVE is attempted, valid adds should not be persisted"))))))
-(deftest set-password-test
- (testing "set-password!"
- (testing "should change the password"
- (mt/with-temp [:model/User {user-id :id} {:password "ABC_DEF"}]
- (letfn [(password [] (t2/select-one-fn :password :model/User :id user-id))]
- (let [original-password (password)]
- (user/set-password! user-id "p@ssw0rd")
- (is (not= original-password
- (password)))))))
-
- (testing "should clear out password reset token"
- (mt/with-temp [:model/User {user-id :id} {:reset_token "ABC123"}]
- (user/set-password! user-id "p@ssw0rd")
- (is (= nil
- (t2/select-one-fn :reset_token :model/User :id user-id)))))
-
- (testing "should clear out all existing Sessions"
- (mt/with-temp [:model/User {user-id :id} {}]
- (dotimes [_ 2]
- (t2/insert! :model/Session {:id (session/generate-session-id)
- :key_hashed (session/hash-session-key (session/generate-session-key)),
- :user_id user-id}))
- (letfn [(session-count [] (t2/count :model/Session :user_id user-id))]
- (is (= 2
- (session-count)))
- (user/set-password! user-id "p@ssw0rd")
- (is (= 0
- (session-count))))))))
+(deftest password-sync-to-auth-identity-test
+ (testing "Password changes are automatically synced to AuthIdentity via lifecycle hooks"
+ (testing "Password update via t2/update! also syncs to AuthIdentity"
+ (mt/with-temp [:model/User {user-id :id} {:password "initial-password"}]
+ (let [initial-user (t2/select-one [:model/User :password] :id user-id)
+ initial-password-hash (:password initial-user)]
+ (t2/update! :model/User user-id {:password "another-new-password"})
+ (let [updated-user (t2/select-one [:model/User :password] :id user-id)
+ updated-password-hash (:password updated-user)
+ updated-auth-identity (t2/select-one :model/AuthIdentity :user_id user-id :provider "password")
+ auth-identity-hash (get-in updated-auth-identity [:credentials :password_hash])]
+ (is (not= initial-password-hash updated-password-hash) "Password should be updated in User table")
+ (is (some? updated-auth-identity) "AuthIdentity should still exist")
+ (is (= updated-password-hash auth-identity-hash) "AuthIdentity password hash should match User table")))))))
(deftest validate-locale-test
(testing "`:locale` should be validated"
@@ -357,7 +346,6 @@
Throwable
#"Assert failed: Invalid locale: \"en_XX\""
(mt/with-temp [:model/User _ {:locale "en_XX"}])))))
-
(testing "updating a User"
(mt/with-temp [:model/User {user-id :id} {:locale "en_US"}]
(testing "valid locale"
@@ -376,7 +364,6 @@
(testing "creating a new User"
(is (= "en_US"
(t2/select-one-fn :locale :model/User :id user-id))))
-
(testing "updating a User"
(t2/update! :model/User user-id {:locale "en-GB"})
(is (= "en_GB"
@@ -464,7 +451,6 @@
(:common_name (t2/select-one :model/User (:id user)))))
(is (nil? (:common_name (t2/select-one [:model/User :first_name :email] (:id user)))))
(is (nil? (:common_name (t2/select-one [:model/User :email] (:id user)))))))
-
(testing "common_name should be present if first_name and last_name are selected but nil and email is also selected"
(mt/with-temp [:model/User user {:first_name nil
:last_name nil
@@ -491,11 +477,9 @@
(testing "deactivated_at is set when a user is deactivated and unset when reactivated (#51728)"
(mt/with-temp [:model/User {user-id :id :as user} {}]
(is (nil? (:deactivated_at user)))
-
(t2/update! :model/User user-id {:is_active false})
(let [deactivated-at (t2/select-one-fn :deactivated_at :model/User user-id)]
(is (instance? java.time.OffsetDateTime deactivated-at)))
-
(t2/update! :model/User user-id {:is_active true})
(let [deactivated-at (t2/select-one-fn :deactivated_at :model/User user-id)]
(is (nil? deactivated-at))))))
@@ -511,14 +495,12 @@
"user_attr" "user_value"}
(:attributes result)))
(is (= user (dissoc result :attributes)))))
-
(testing "should handle nil login_attributes"
(let [user {:email "[email protected]"
:jwt_attributes {"jwt_attr" "jwt_value"}}
result (user/add-attributes user)]
(is (= {"jwt_attr" "jwt_value"}
(:attributes result)))))
-
(testing "should handle empty login_attributes"
(let [user {:login_attributes {}
:jwt_attributes {"jwt_attr" "jwt_value"}
@@ -526,7 +508,6 @@
result (user/add-attributes user)]
(is (= {"jwt_attr" "jwt_value"}
(:attributes result)))))
-
(testing "user attributes should override jwt attributes with same keys"
(let [user {:login_attributes {"shared_key" "user_value"
"user_only" "user_val"}
@@ -538,7 +519,6 @@
"jwt_only" "jwt_val"
"user_only" "user_val"}
(:attributes result)))))
-
(testing "should preserve all other user fields"
(let [user {:id 123