A platform for community discussion. Free, open, simple.
FEATURE: User API key device authorization flow (#40189)
Sam5458a5f15060
diff --git a/app/assets/stylesheets/common/base/authorize-api-key.scss b/app/assets/stylesheets/common/base/authorize-api-key.scssindex 7d204938d5c..541bb4a17ce 100644--- a/app/assets/stylesheets/common/base/authorize-api-key.scss+++ b/app/assets/stylesheets/common/base/authorize-api-key.scss@@ -1,51 +1,108 @@.authorize-api-key {- max-width: 480px;+ max-width: 42rem;margin: 0 auto;- padding: 0 1em;+ padding: 3rem 1rem;++ h1 {+ margin: 0 0 0.75rem;+ font-size: var(--font-up-5);+ line-height: var(--line-height-small);+ }++ .alert {+ border: 0;+ border-radius: var(--d-border-radius-large);+ margin: 1rem 0;+ padding: 1rem 1.25rem;++ p {+ margin: 0;+ }+ }&__user {display: flex;align-items: center;- gap: 0.35em;- font-size: var(--font-down-1);+ gap: 0.4rem;color: var(--primary-medium);- margin-bottom: 1.5em;+ margin-bottom: 1.5rem;}&__username {color: var(--primary);+ font-weight: 600;+ }++ &__summary {+ background: var(--primary-very-low);+ border: 1px solid var(--primary-low);+ border-radius: var(--d-border-radius-large);+ margin-bottom: 1.5rem;+ padding: 1.25rem;+ }++ &__permissions,+ &__summary-detail,+ &__summary-notice {+ padding: 0;}&__permissions {- background-color: var(--primary-very-low);- border-radius: 4px;- padding: 1em;- margin-bottom: 1em;+ margin-bottom: 1rem;}&__permissions-header {- margin: 0 0 0.5em;+ margin: 0 0 0.75rem;}&__scopes {margin: 0;- padding-left: 1.25em;+ padding-left: 1.25rem;+ }++ &__summary-detail,+ &__summary-notice {+ color: var(--primary-high);+ font-size: var(--font-down-1-rem);++ p {+ margin: 0;+ }+ }++ &__summary-notice {+ margin-bottom: 1rem;}&__redirect {- background-color: var(--highlight-bg);- border-radius: 4px;- padding: 1em;- margin-bottom: 1.5em;+ background: var(--highlight-bg);+ border-radius: var(--d-border-radius-large);+ padding: 1rem 1.25rem;+ margin-bottom: 1.5rem;}&__redirect-url {margin: 0;- word-break: break-all;+ word-break: break-word;}&__buttons {display: flex;- gap: 0.5em;+ align-items: center;+ gap: 0.5rem;+ margin-top: 1.25rem;+ }++ &__code-form {+ margin-top: 1.5rem;++ .d-otp-slot {+ font-size: var(--font-up-1);+ padding: 0.625em 0.8em;+ }+ }++ &__code-input {+ margin-top: 0.75rem;}}diff --git a/app/assets/stylesheets/common/components/d-otp.scss b/app/assets/stylesheets/common/components/d-otp.scssindex 61fe96867f9..a091e39ff52 100644--- a/app/assets/stylesheets/common/components/d-otp.scss+++ b/app/assets/stylesheets/common/components/d-otp.scss@@ -17,7 +17,8 @@}.d-otp-slot {- padding: 0.5em 0.65em;+ padding: var(--d-otp-slot-padding, 0.5em 0.65em);+ font-size: var(--d-otp-slot-font-size, inherit);line-height: normal;display: flex;align-items: center;@@ -50,6 +51,16 @@&.--placeholder {font-size: var(--font-up-0);}++ .form-kit__field.has-error & {+ border-color: var(--danger);+ }+}++.d-otp-separator {+ color: var(--primary-medium);+ font-size: var(--font-up-1);+ font-weight: 700;}.d-otp-input-wrapper {diff --git a/app/controllers/user_api_keys_controller.rb b/app/controllers/user_api_keys_controller.rbindex aa12b5e9ce1..1cda260b692 100644--- a/app/controllers/user_api_keys_controller.rb+++ b/app/controllers/user_api_keys_controller.rb@@ -1,75 +1,73 @@# frozen_string_literal: trueclass UserApiKeysController < ApplicationController- layout "no_ember"-- requires_login only: %i[create create_otp revoke undo_revoke]+ requires_login only: %i[+ create+ create_otp+ revoke+ undo_revoke+ authorize_device_request+ deny_device_request+ ]skip_before_action :redirect_to_login_if_required,:redirect_to_profile_if_required,- only: %i[new otp]+ only: %i[new otp activate create_device_request poll_device_request]skip_before_action :check_xhr, :preload_json+ skip_before_action :verify_authenticity_token, only: %i[create_device_request poll_device_request]+ before_action :set_device_auth_no_store,+ only: %i[+ new+ otp+ create+ create_otp+ create_device_request+ poll_device_request+ activate+ authorize_device_request+ deny_device_request+ ]AUTH_API_VERSION = 4ALLOWED_PADDING_MODES = %w[pkcs1 oaep].freeze+ DEVICE_REQUESTS_PER_MINUTE = 20+ DEVICE_POLLS_PER_MINUTE = 60+ DEVICE_ACTIVATION_ATTEMPTS_PER_MINUTE = 10+ DEVICE_ACTIVATION_ATTEMPTS_PER_HOUR = 30+ DEVICE_REQUEST_TOKEN_LOOKUPS_PER_MINUTE = 30+ DEVICE_REQUEST_TOKEN_LOOKUPS_PER_HOUR = 120def newif request.head?- head :ok, auth_api_version: AUTH_API_VERSION- return- end-- require_params- find_client- require_client_params- validate_params- validate_auth_redirect-- unless current_user- cookies[:destination_url] = request.fullpath-- if SiteSetting.enable_discourse_connect?- redirect_to path("/session/sso")- else- redirect_to path("/login")- end+ head :ok, auth_api_version: AUTH_API_VERSION, auth_api_device_code: "true"returnend- unless meets_tl?- @no_trust_level = true- return- end-- @application_name = params[:application_name] || @client&.application_name- @public_key = params[:public_key] || @client&.public_key- @nonce = params[:nonce]- @client_id = params[:client_id]- @auth_redirect = params[:auth_redirect]- @redirect_uri =- if @auth_redirect.present?- begin- if @auth_redirect == "discourse://auth_redirect"- nil- else- uri = URI.parse(@auth_redirect)- if uri.port.nil? || [80, 443].include?(uri.port)- uri.host- else- uri.host + ":" + uri.port.to_s- end- end- rescue StandardError- nil- end- else- nil- end- @push_url = params[:push_url]- @localized_scopes = params[:scopes].split(",").map { |s| I18n.t("user_api_key.scopes.#{s}") }- @scopes = params[:scopes]- @padding = params[:padding]- rescue Discourse::InvalidAccess- @generic_error = true+ json = user_api_key_authorization_model+ return if performed?++ render_user_api_key_authorization(json)+ rescue Discourse::InvalidAccess => exception+ trace_device_auth(+ "device_auth.authorization.rendered_generic",+ reason: exception.class.name,+ exception: exception,+ client_id: params[:client_id],+ )+ render_user_api_key_authorization(+ { state: UserApiKey::DeviceAuth::AUTHORIZATION_STATE_GENERIC_ERROR },+ )+ rescue Discourse::InvalidParameters => exception+ raise if exception.message == "padding"++ trace_device_auth(+ "device_auth.authorization.rendered_generic",+ reason: exception.class.name,+ exception: exception,+ client_id: params[:client_id],+ )+ render_user_api_key_authorization(+ { state: UserApiKey::DeviceAuth::AUTHORIZATION_STATE_GENERIC_ERROR },+ )enddef create@@ -82,6 +80,7 @@ class UserApiKeysController < ApplicationControllerraise Discourse::InvalidAccess unless meets_tl?scopes = params[:scopes].split(",")+ expires_at = requested_expires_at(parse_expires_in_seconds!)@client = UserApiKeyClient.new(client_id: params[:client_id]) if @client.blank?@client.application_name = params[:application_name] if params[:application_name].present?@@ -94,44 +93,298 @@ class UserApiKeysController < ApplicationController@client.keys.create!(user_id: current_user.id,push_url: params[:push_url],+ expires_at: expires_at,scopes: scopes.map { |name| UserApiKeyScope.new(name: name) },)# we keep the payload short so it encrypts easily with public key# it is often restricted to 128 chars- @payload = {- key: key.key,- nonce: params[:nonce],- push: key.has_push?,- api: AUTH_API_VERSION,- }.to_json-- validate_payload_size_for_oaep!(@payload, parsed_public_key)- @payload = Base64.encode64(rsa_encrypt(parsed_public_key, @payload))+ payload = { key: key.key, nonce: params[:nonce], push: key.has_push?, api: AUTH_API_VERSION }+ payload[:expires_at] = key.expires_at.iso8601 if key.expires_at+ @payload = payload.to_json++ UserApiKey::DeviceAuth::Crypto.validate_payload_size!(+ @payload,+ parsed_public_key,+ padding: params[:padding],+ )+ @payload =+ Base64.encode64(+ UserApiKey::DeviceAuth::Crypto.encrypt!(+ parsed_public_key,+ @payload,+ padding: params[:padding],+ ),+ )if scopes.include?("one_time_password")# encrypt one_time_password separately to bypass 128 chars encryption limitotp_payload = one_time_password(parsed_public_key, current_user.username)end- if params[:auth_redirect]- uri = URI.parse(params[:auth_redirect])- query_attributes = [uri.query, "payload=#{CGI.escape(@payload)}"]- if scopes.include?("one_time_password")- query_attributes << "oneTimePassword=#{CGI.escape(otp_payload)}"+ response_json =+ if params[:auth_redirect]+ uri = URI.parse(params[:auth_redirect])+ query_attributes = [uri.query, "payload=#{CGI.escape(@payload)}"]+ if scopes.include?("one_time_password")+ query_attributes << "oneTimePassword=#{CGI.escape(otp_payload)}"+ end+ uri.query = query_attributes.compact.join("&")++ { redirect_url: uri.to_s }+ else+ instructions =+ I18n.t("user_api_key.instructions", application_name: @client.application_name)+ { payload: @payload, instructions: instructions }end- uri.query = query_attributes.compact.join("&")- redirect_to(uri.to_s, allow_other_host: true)- else- respond_to do |format|- format.html { render :show }- format.json do- instructions =- I18n.t("user_api_key.instructions", application_name: @client.application_name)- render json: { payload: @payload, instructions: instructions }+ respond_to do |format|+ format.html do+ if response_json[:redirect_url]+ redirect_to(response_json[:redirect_url], allow_other_host: true)+ else+ store_preloaded("user_api_key_result", MultiJson.dump(response_json))+ raise ApplicationController::RenderEmpty.newendend+ format.json { render json: response_json }+ end+ end++ def create_device_request+ ensure_json_request!+ rate_limit_device_request_creation++ UserApiKey::DeviceAuth::CreateRequest.call(device_auth_service_params) do+ on_success do |device_request:|+ verification_uri = UrlHelper.absolute_without_cdn(path("/user-api-key/activate"))++ render json: {+ device_code: device_request[:device_code],+ user_code: device_request[:user_code],+ verification_uri: verification_uri,+ verification_uri_with_request:+ "#{verification_uri}?request=#{CGI.escape(device_request[:request_token])}",+ expires_in: UserApiKey::DeviceAuth::DEVICE_AUTH_TTL.to_i,+ interval: UserApiKey::DeviceAuth::DEVICE_AUTH_INTERVAL,+ }+ end+ on_failed_contract do |failure|+ trace_device_auth(+ "device_auth.create.failed",+ reason: "contract_invalid",+ contract_errors: failure.errors&.attribute_names&.join(","),+ )+ raise Discourse::InvalidParameters.new(:base)+ end+ on_exceptions(Discourse::InvalidParameters, Discourse::InvalidAccess) do |exception|+ trace_device_auth(+ "device_auth.create.failed",+ reason: exception.class.name,+ exception: exception,+ client_id: params[:client_id],+ )+ raise exception+ end+ end+ end++ def activate+ unless current_user+ request_token = params[:request].to_s+ destination =+ if UserApiKey::DeviceAuth::CodeRegistry.valid_request_token?(request_token)+ "#{path("/user-api-key/activate")}?request=#{CGI.escape(request_token)}"+ else+ path("/user-api-key/activate")+ end++ redirect_anonymous_to_login(destination)+ return+ end++ if request.get?+ if params[:code].present?+ redirect_to path("/user-api-key/activate")+ return+ end++ render_device_activation(device_activation_model)+ return+ end++ rate_limit_device_activation_attempt++ result = device_user_activation.find_manual_code(params[:code])++ if result.status == :invalid_code+ render_device_activation(+ { state: UserApiKey::DeviceAuth::DEVICE_ACTIVATION_STATE_ENTER_CODE, invalid_code: true },+ debug_reason: result.debug_reason,+ )+ return+ end++ if result.status == :expired_code+ render_device_activation(+ { state: UserApiKey::DeviceAuth::DEVICE_ACTIVATION_STATE_ENTER_CODE, expired_code: true },+ debug_reason: result.debug_reason,+ )+ return+ end++ @device_auth = result.grant++ unless meets_tl?+ render_device_activation(+ device_authorization_model(+ state: UserApiKey::DeviceAuth::DEVICE_ACTIVATION_STATE_AUTHORIZE,+ no_trust_level: true,+ ),+ debug_reason: "insufficient_trust_level",+ )+ return+ end++ approval_token = device_user_activation.create_approval_token!(result.grant)++ if approval_token.blank?+ render_device_activation(+ { state: UserApiKey::DeviceAuth::DEVICE_ACTIVATION_STATE_ENTER_CODE, expired_code: true },+ debug_reason: "approval_token_not_created",+ )+ return+ end++ render_device_activation(+ device_authorization_model(+ state: UserApiKey::DeviceAuth::DEVICE_ACTIVATION_STATE_AUTHORIZE,+ approval_token: approval_token,+ ),+ )+ end++ def authorize_device_request+ unless meets_tl?+ trace_device_auth("device_auth.authorize.failed", reason: "insufficient_trust_level")+ raise Discourse::InvalidAccess+ end++ device_code = device_code_for_authorize_request++ if device_code.blank?+ if @request_token.present? && @device_auth&.application_name.present?+ render_device_activation(+ device_authorization_model(+ state: UserApiKey::DeviceAuth::DEVICE_ACTIVATION_STATE_AUTHORIZE,+ request_token: @request_token,+ invalid_code: true,+ ),+ debug_reason: @device_auth_debug_reason || "invalid_request_token_code",+ )+ else+ render_device_activation(+ { state: UserApiKey::DeviceAuth::DEVICE_ACTIVATION_STATE_ENTER_CODE, expired_code: true },+ debug_reason: @device_auth_debug_reason || "device_code_unavailable",+ )+ end+ return+ end++ UserApiKey::DeviceAuth::Authorize.call(+ device_auth_service_params(device_code: device_code, user_id: current_user.id),+ ) do+ on_success do+ if params[:approval_token].present?+ device_user_activation.delete_approval_token(params[:approval_token])+ end+ render_device_activation(+ { state: UserApiKey::DeviceAuth::DEVICE_ACTIVATION_STATE_COMPLETE, denied: false },+ )+ end+ on_model_not_found(:user) do+ trace_device_auth(+ "device_auth.authorize.failed",+ reason: "user_not_found",+ device_code: device_code,+ )+ raise Discourse::InvalidAccess+ end+ on_failed_step(:authorize_grant) do |failure|+ render_device_activation(+ { state: UserApiKey::DeviceAuth::DEVICE_ACTIVATION_STATE_ENTER_CODE, expired_code: true },+ debug_reason: failure.error,+ )+ end+ on_exceptions(Discourse::InvalidParameters, Discourse::InvalidAccess) do |exception|+ trace_device_auth(+ "device_auth.authorize.failed",+ reason: exception.class.name,+ exception: exception,+ device_code: device_code,+ )+ raise exception+ end+ end+ end++ def deny_device_request+ if params[:request].present?+ render_device_activation(+ { state: UserApiKey::DeviceAuth::DEVICE_ACTIVATION_STATE_ENTER_CODE, expired_code: true },+ debug_reason: "deny_requires_approval_token",+ )+ return+ end++ approval_token = params.require(:approval_token)+ result =+ device_user_activation.resolve_deny_device_code(+ request_token: nil,+ approval_token: approval_token,+ )++ if result.status != :success+ render_device_activation(+ { state: UserApiKey::DeviceAuth::DEVICE_ACTIVATION_STATE_ENTER_CODE, expired_code: true },+ debug_reason: result.debug_reason,+ )+ return+ end++ UserApiKey::DeviceAuth::Deny.call(+ device_auth_service_params(device_code: result.device_code),+ ) do+ on_success do+ device_user_activation.delete_approval_token(approval_token)+ render_device_activation(+ { state: UserApiKey::DeviceAuth::DEVICE_ACTIVATION_STATE_COMPLETE, denied: true },+ )+ end+ on_failed_step(:deny_grant) do |failure|+ render_device_activation(+ { state: UserApiKey::DeviceAuth::DEVICE_ACTIVATION_STATE_ENTER_CODE, expired_code: true },+ debug_reason: failure.error,+ )+ end+ on_exceptions(Discourse::InvalidParameters, Discourse::InvalidAccess) do |exception|+ render_device_activation(+ { state: UserApiKey::DeviceAuth::DEVICE_ACTIVATION_STATE_ENTER_CODE, expired_code: true },+ debug_reason: exception.class.name,+ )+ end+ end+ end++ def poll_device_request+ ensure_json_request!+ rate_limit_device_poll++ device_code = params.require(:device_code)+ rate_limit_device_poll_for_code(device_code)++ UserApiKey::DeviceAuth::Poll.call(device_auth_service_params(device_code: device_code)) do+ on_success { |poll_response:| render json: poll_response }endend@@ -152,10 +405,15 @@ class UserApiKeysController < ApplicationControllerreturnend- @application_name = params[:application_name]- @public_key = params[:public_key]- @auth_redirect = params[:auth_redirect]- @padding = params[:padding]+ json = user_api_key_otp_model++ respond_to do |format|+ format.html do+ store_preloaded("user_api_key_otp", MultiJson.dump(json))+ raise ApplicationController::RenderEmpty.new+ end+ format.json { render json: json }+ endenddef create_otp@@ -167,9 +425,12 @@ class UserApiKeysController < ApplicationControllerraise Discourse::InvalidAccess unless meets_tl?otp_payload = one_time_password(parsed_public_key, current_user.username)-redirect_path = "#{params[:auth_redirect]}?oneTimePassword=#{CGI.escape(otp_payload)}"- redirect_to(redirect_path, allow_other_host: true)++ respond_to do |format|+ format.html { redirect_to(redirect_path, allow_other_host: true) }+ format.json { render json: { redirect_url: redirect_path } }+ endenddef revoke@@ -190,6 +451,169 @@ class UserApiKeysController < ApplicationControllerrender json: success_jsonend+ def render_user_api_key_authorization(json)+ respond_to do |format|+ format.html do+ store_preloaded("user_api_key_authorization", MultiJson.dump(json))+ raise ApplicationController::RenderEmpty.new+ end+ format.json { render json: json }+ end+ end++ def render_device_activation(json, debug_reason: nil)+ if debug_reason.present?+ trace_device_auth(+ "device_auth.activation.rendered_generic",+ reason: debug_reason,+ state: json[:state] || json["state"],+ expired_code: json[:expired_code] || json["expired_code"],+ invalid_code: json[:invalid_code] || json["invalid_code"],+ )+ end++ respond_to do |format|+ format.html do+ store_preloaded("user_api_key_device_activation", MultiJson.dump(json))+ raise ApplicationController::RenderEmpty.new+ end+ format.json { render json: json }+ end+ end++ def user_api_key_authorization_model+ require_params+ find_client+ require_client_params+ validate_params+ validate_auth_redirect+ expires_in_seconds = parse_expires_in_seconds!++ unless current_user+ redirect_anonymous_to_login+ return+ end++ application_name = params[:application_name] || @client&.application_name+ scopes = params[:scopes]+ expires_at = requested_expires_at(expires_in_seconds)++ if !meets_tl?+ return(+ {+ state: UserApiKey::DeviceAuth::AUTHORIZATION_STATE_NO_TRUST_LEVEL,+ application_name: application_name,+ current_user: current_user_json,+ }+ )+ end++ {+ state: UserApiKey::DeviceAuth::AUTHORIZATION_STATE_READY,+ application_name: application_name,+ public_key: params[:public_key] || @client&.public_key,+ nonce: params[:nonce],+ client_id: params[:client_id],+ auth_redirect: params[:auth_redirect],+ redirect_uri: redirect_uri_for(params[:auth_redirect]),+ push_url: params[:push_url],+ localized_scopes: localized_scopes(scopes),+ scopes: scopes,+ write_scope: scopes.split(",").include?("write"),+ padding: params[:padding],+ expires_in_seconds: expires_in_seconds,+ expires_at: expires_at&.iso8601,+ current_user: current_user_json,+ }+ end++ def user_api_key_otp_model+ {+ application_name: params[:application_name],+ public_key: params[:public_key],+ auth_redirect: params[:auth_redirect],+ padding: params[:padding],+ }+ end++ def device_activation_model+ if params[:request].blank?+ return { state: UserApiKey::DeviceAuth::DEVICE_ACTIVATION_STATE_ENTER_CODE }+ end++ rate_limit_device_request_token_lookup(params[:request])+ result = device_user_activation.preview_request_token(params[:request])++ if result.status != :success+ trace_device_auth(+ "device_auth.activation.preview.failed",+ reason: result.debug_reason,+ request_token: params[:request],+ )+ return(+ { state: UserApiKey::DeviceAuth::DEVICE_ACTIVATION_STATE_ENTER_CODE, expired_code: true }+ )+ end++ @device_auth = result.grant+ device_authorization_model(+ state: UserApiKey::DeviceAuth::DEVICE_ACTIVATION_STATE_AUTHORIZE,+ request_token: params[:request],+ no_trust_level: !meets_tl?,+ )+ end++ def device_authorization_model(+ state:,+ request_token: nil,+ approval_token: nil,+ no_trust_level: false,+ invalid_code: false+ )+ {+ state: state,+ request_token: request_token,+ approval_token: approval_token,+ no_trust_level: no_trust_level,+ invalid_code: invalid_code,+ device_auth: device_auth_json,+ current_user: current_user_json,+ }+ end++ def device_auth_json+ {+ application_name: @device_auth.application_name,+ localized_scopes: @device_auth.localized_scopes,+ write_scope: @device_auth.write_scope?,+ unregistered_client: @device_auth.unregistered_client?,+ expires_at: @device_auth.expires_at&.iso8601,+ }+ end++ def current_user_json+ return if current_user.blank?++ { username: current_user.username, avatar_template: current_user.avatar_template }+ end++ def redirect_uri_for(auth_redirect)+ return if auth_redirect.blank? || auth_redirect == "discourse://auth_redirect"++ uri = URI.parse(auth_redirect)+ if uri.port.nil? || [80, 443].include?(uri.port)+ uri.host+ else+ "#{uri.host}:#{uri.port}"+ end+ rescue StandardError+ nil+ end++ def localized_scopes(scopes)+ scopes.split(",").map { |scope| I18n.t("user_api_key.scopes.#{scope}") }+ end+def find_keykey = UserApiKey.find(params[:id])raise Discourse::InvalidAccess unless current_user.admin || key.user_id == current_user.id@@ -256,9 +680,11 @@ class UserApiKeysController < ApplicationControllerenddef parsed_public_key- @parsed_public_key ||= OpenSSL::PKey::RSA.new(public_key_str)- rescue OpenSSL::PKey::RSAError- raise Discourse::InvalidParameters.new(:public_key)+ @parsed_public_key ||= parse_public_key!(public_key_str)+ end++ def parse_public_key!(value)+ UserApiKey::DeviceAuth::Crypto.parse_public_key!(value)enddef meets_tl?@@ -273,30 +699,173 @@ class UserApiKeysController < ApplicationControllerotp = SecureRandom.hexDiscourse.redis.setex "otp_#{otp}", 10.minutes, username- Base64.encode64(rsa_encrypt(public_key, otp))+ Base64.encode64(+ UserApiKey::DeviceAuth::Crypto.encrypt!(public_key, otp, padding: params[:padding]),+ )end- def rsa_encrypt(public_key, data)- # OAEP padding is recommended for new applications and required for FIPS 140-3 compliance.- # PKCS1 padding is kept as default for backwards compatibility with existing clients.- padding_mode = params[:padding] == "oaep" ? "oaep" : "pkcs1"- public_key.encrypt(data, { "rsa_padding_mode" => padding_mode })+ def parse_expires_in_seconds!+ UserApiKey::Expiry.parse_seconds!(params[:expires_in_seconds])end- def validate_payload_size_for_oaep!(payload, public_key)- return unless params[:padding] == "oaep"+ def requested_expires_at(expires_in_seconds)+ UserApiKey::Expiry.requested_expires_at(expires_in_seconds)+ end- # RSA-OAEP max payload = key_size_bytes - 2*hash_size_bytes - 2- # OpenSSL uses SHA-1 (20 bytes) by default for OAEP- key_size_bytes = public_key.n.num_bytes- max_payload_size = key_size_bytes - 2 * 20 - 2+ def ensure_json_request!+ raise Discourse::InvalidAccess unless request.format.json? && request.content_mime_type&.json?+ end++ def set_device_auth_no_store+ response.headers["Cache-Control"] = "no-store"+ response.headers["Pragma"] = "no-cache"+ response.headers["Expires"] = "0"+ response.headers["Referrer-Policy"] = "same-origin"+ end- if payload.bytesize > max_payload_size- raise Discourse::InvalidParameters.new(- "Payload too large for OAEP encryption with this key size. " \- "Maximum: #{max_payload_size} bytes, got: #{payload.bytesize} bytes. " \- "Try using a shorter nonce or a larger RSA key (minimum 2048-bit recommended).",- )+ def redirect_anonymous_to_login(destination_url = request.fullpath)+ cookies[:destination_url] = destination_url++ if SiteSetting.enable_discourse_connect?+ redirect_to path("/session/sso")+ else+ redirect_to path("/login")endend++ def device_user_activation+ @device_user_activation ||=+ UserApiKey::DeviceAuth::UserActivation.new(+ session: session,+ user: current_user,+ request_id: request.request_id,+ )+ end++ def device_auth_service_params(**overrides)+ service_params.deep_merge(params: overrides, options: { request_id: request.request_id })+ end++ def trace_device_auth(event, **payload)+ UserApiKey::DeviceAuth.trace(+ event,+ **{ request_id: request.request_id, user_id: current_user&.id }.merge(payload),+ )+ end++ def device_code_for_authorize_request+ if params[:request].present?+ rate_limit_device_request_token_lookup(params[:request])+ preview = device_user_activation.preview_request_token(params[:request])+ if preview.status != :success+ @device_auth_debug_reason = preview.debug_reason+ return+ end++ @device_auth = preview.grant+ @request_token = params[:request]++ rate_limit_device_activation_attempt+ result =+ device_user_activation.resolve_authorize_device_code(+ request_token: params[:request],+ user_code: params[:code],+ approval_token: nil,+ )+ @device_auth = result.grant if result.grant.present?+ @device_auth_debug_reason = result.debug_reason++ return result.device_code if result.status == :success+ return+ end++ approval_token = params.require(:approval_token)+ result =+ device_user_activation.resolve_authorize_device_code(+ request_token: nil,+ user_code: nil,+ approval_token: approval_token,+ )+ @device_auth_debug_reason = result.debug_reason+ result.device_code if result.status == :success+ end++ def rate_limit_device_request_creation+ RateLimiter.new(+ nil,+ "user-api-key-device-requests-#{request.remote_ip}",+ DEVICE_REQUESTS_PER_MINUTE,+ 1.minute,+ ).performed!+ end++ def rate_limit_device_poll+ RateLimiter.new(+ nil,+ "user-api-key-device-poll-ip-#{request.remote_ip}",+ DEVICE_POLLS_PER_MINUTE,+ 1.minute,+ ).performed!+ end++ def rate_limit_device_poll_for_code(device_code)+ RateLimiter.new(+ nil,+ "user-api-key-device-poll-code-#{ApiKey.hash_key(device_code)}",+ DEVICE_POLLS_PER_MINUTE,+ 1.minute,+ ).performed!+ end++ def rate_limit_device_request_token_lookup(request_token)+ token_key =+ (+ if UserApiKey::DeviceAuth::CodeRegistry.valid_request_token?(request_token)+ ApiKey.hash_key(request_token)+ else+ "invalid"+ end+ )+ RateLimiter.new(+ nil,+ "user-api-key-device-request-token-ip-#{request.remote_ip}",+ DEVICE_REQUEST_TOKEN_LOOKUPS_PER_HOUR,+ 1.hour,+ ).performed!+ RateLimiter.new(+ nil,+ "user-api-key-device-request-token-user-#{current_user.id}",+ DEVICE_REQUEST_TOKEN_LOOKUPS_PER_MINUTE,+ 1.minute,+ ).performed!+ RateLimiter.new(+ nil,+ "user-api-key-device-request-token-#{token_key}",+ DEVICE_REQUEST_TOKEN_LOOKUPS_PER_MINUTE,+ 1.minute,+ ).performed!+ end++ def rate_limit_device_activation_attempt+ normalized_code =+ UserApiKey::DeviceAuth::CodeRegistry.normalize_user_code(params[:code]) || "invalid"+ RateLimiter.new(+ nil,+ "user-api-key-device-activate-ip-#{request.remote_ip}",+ DEVICE_ACTIVATION_ATTEMPTS_PER_HOUR,+ 1.hour,+ ).performed!+ RateLimiter.new(+ nil,+ "user-api-key-device-activate-user-#{current_user.id}",+ DEVICE_ACTIVATION_ATTEMPTS_PER_MINUTE,+ 1.minute,+ ).performed!+ RateLimiter.new(+ nil,+ "user-api-key-device-activate-code-#{ApiKey.hash_key(normalized_code)}",+ DEVICE_ACTIVATION_ATTEMPTS_PER_MINUTE,+ 1.minute,+ ).performed!+ endenddiff --git a/app/models/user_api_key.rb b/app/models/user_api_key.rbindex 67d39d52b03..6746381dd78 100644--- a/app/models/user_api_key.rb+++ b/app/models/user_api_key.rb@@ -12,7 +12,8 @@ class UserApiKey < ActiveRecord::Basebelongs_to :client, class_name: "UserApiKeyClient", foreign_key: "user_api_key_client_id"has_many :scopes, class_name: "UserApiKeyScope", dependent: :destroy- scope :active, -> { where(revoked_at: nil) }+ scope :active,+ -> { where(revoked_at: nil).where("expires_at IS NULL OR expires_at > ?", Time.zone.now) }scope :with_key, ->(key) { where(key_hash: ApiKey.hash_key(key)) }after_initialize :generate_key@@ -63,17 +64,21 @@ class UserApiKey < ActiveRecord::BaseSiteSetting.allowed_user_api_push_urls.include?(push_url)end+ def expired?+ expires_at.present? && expires_at <= Time.zone.now+ end+def self.push_clients_for(user)return [] if SiteSetting.allow_user_api_key_scopes.split("|").exclude?("push")return [] if SiteSetting.allowed_user_api_push_urls.blank?user.user_api_keys+ .active.joins(:scopes, :client).where("user_api_key_scopes.name IN ('push', 'notifications')").where("push_url IS NOT NULL AND push_url <> ''").where("position(push_url IN ?) > 0", SiteSetting.allowed_user_api_push_urls)- .where("revoked_at IS NULL").order("user_api_key_clients.client_id ASC").pluck("user_api_key_clients.client_id, user_api_keys.push_url")end@@ -98,6 +103,7 @@ end# Table name: user_api_keys## id :integer not null, primary key+# expires_at :datetime# key_hash :string not null# last_used_at :datetime not null# push_url :stringdiff --git a/app/serializers/user_serializer.rb b/app/serializers/user_serializer.rbindex fb334f219fd..1087726c667 100644--- a/app/serializers/user_serializer.rb+++ b/app/serializers/user_serializer.rb@@ -162,6 +162,7 @@ class UserSerializer < UserCardSerializerscopes: k.scopes.map { |s| I18n.t("user_api_key.scopes.#{s.name}") },created_at: k.created_at,last_used_at: k.last_used_at,+ expires_at: k.expires_at,}enddiff --git a/app/services/user_api_key/device_auth.rb b/app/services/user_api_key/device_auth.rbnew file mode 100644index 00000000000..c2a4052b8b4--- /dev/null+++ b/app/services/user_api_key/device_auth.rb@@ -0,0 +1,176 @@+# frozen_string_literal: true++require "digest"++class UserApiKey::DeviceAuth+ # Device auth flow:+ #+ # 1. A client POSTs to `/user-api-key/device.json`.+ # `CreateRequest` validates the request, stores a short-lived pending grant in Redis, and+ # returns a device code, a user-facing code, and an 8-character request token.+ # 2. The user visits `/user-api-key/activate` manually, or opens the request-token URL.+ # `UserActivation` loads the pending grant and validates user-facing codes/tokens.+ # 3. The user confirms the code. Manual-code approvals bind the pending grant to the+ # approving user and receive a browser-session approval token. Request-token approvals+ # bind the pending grant to the approving user after a matching code is submitted.+ # 4. `Authorize` creates the User API key, encrypts the response payload, stores it briefly,+ # and removes the user-code/request-token indexes.+ # 5. The client polls until `Poll` returns pending, denied, expired, or the encrypted payload.+ AUTH_API_VERSION = UserApiKeysController::AUTH_API_VERSION+ ALLOWED_PADDING_MODES = UserApiKeysController::ALLOWED_PADDING_MODES+ DEVICE_AUTH_TTL = 10.minutes+ DEVICE_AUTH_INTERVAL = 5+ DEVICE_AUTHORIZED_PAYLOAD_TTL = 1.minute+ DEVICE_KEY_PLACEHOLDER = "x" * 32+ DEVICE_CODE_REDIS_PREFIX = "user_api_key:device:"+ DEVICE_USER_CODE_REDIS_PREFIX = "user_api_key:device:code:"+ DEVICE_REQUEST_REDIS_PREFIX = "user_api_key:device:request:"+ DEVICE_AUTHORIZATION_LOCK_REDIS_PREFIX = "user_api_key:device:lock:"+ USER_CODE_ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789"+ DEVICE_CODE_REGEX = /\A\h{64}\z/+ DEVICE_REQUEST_TOKEN_REGEX = /\A[-_A-Za-z0-9]{8}\z/+ DISALLOWED_DEVICE_SCOPES = Set.new(%w[one_time_password])+ MAX_DEVICE_CLIENT_ID_LENGTH = 200+ MAX_DEVICE_APPLICATION_NAME_LENGTH = 200+ MAX_DEVICE_NONCE_LENGTH = 256+ MAX_DEVICE_PUBLIC_KEY_LENGTH = 4096+ MAX_DEVICE_PUSH_URL_LENGTH = 2000+ MAX_DEVICE_SCOPES_LENGTH = 500+ MAX_DEVICE_SCOPES_COUNT = 20+ MAX_DEVICE_GRANT_BYTES = 10_000+ MAX_CODE_REGISTRY_COLLISION_ATTEMPTS = 20+ MIN_DEVICE_RSA_BITS = 2048+ MAX_DEVICE_RSA_BITS = 8192+ DEVICE_AUTHORIZATION_LOCK_TTL = 30.seconds++ AUTHORIZATION_STATE_READY = "ready"+ AUTHORIZATION_STATE_NO_TRUST_LEVEL = "no_trust_level"+ AUTHORIZATION_STATE_GENERIC_ERROR = "generic_error"+ DEVICE_ACTIVATION_STATE_ENTER_CODE = "enter_code"+ DEVICE_ACTIVATION_STATE_AUTHORIZE = "authorize"+ DEVICE_ACTIVATION_STATE_COMPLETE = "complete"+ POLL_STATUS_AUTHORIZATION_PENDING = "authorization_pending"+ POLL_STATUS_AUTHORIZED = "authorized"+ POLL_STATUS_ACCESS_DENIED = "access_denied"+ POLL_STATUS_EXPIRED_TOKEN = "expired_token"++ # Response contracts consumed by the Ember UI and CLI poller. Keep this table in sync with+ # `frontend/discourse/app/lib/user-api-key-device-auth.js` when adding states/statuses.+ AUTHORIZATION_STATE_CONTRACT = {+ AUTHORIZATION_STATE_READY => {+ description: "Show the key authorization confirmation UI.",+ required_fields: %i[+ application_name+ client_id+ current_user+ localized_scopes+ nonce+ public_key+ scopes+ write_scope+ ],+ optional_fields: %i[+ auth_redirect+ expires_at+ expires_in_seconds+ padding+ push_url+ redirect_uri+ ],+ },+ AUTHORIZATION_STATE_NO_TRUST_LEVEL => {+ description: "Show a signed-in user that their account cannot create user API keys.",+ required_fields: %i[application_name current_user],+ },+ AUTHORIZATION_STATE_GENERIC_ERROR => {+ description: "Show a generic, user-safe authorization error.",+ required_fields: [],+ },+ }.freeze++ DEVICE_ACTIVATION_STATE_CONTRACT = {+ DEVICE_ACTIVATION_STATE_ENTER_CODE => {+ description:+ "Show manual code entry; optional invalid_code/expired_code flags explain UI copy.",+ required_fields: [],+ optional_fields: %i[invalid_code expired_code],+ },+ DEVICE_ACTIVATION_STATE_AUTHORIZE => {+ description: "Show the approval UI for a loaded pending grant.",+ required_fields: %i[current_user device_auth],+ optional_fields: %i[approval_token invalid_code no_trust_level request_token],+ },+ DEVICE_ACTIVATION_STATE_COMPLETE => {+ description: "Show the terminal browser result after authorize/deny.",+ required_fields: %i[denied],+ },+ }.freeze++ POLL_STATUS_CONTRACT = {+ POLL_STATUS_AUTHORIZATION_PENDING =>+ "The grant is still pending, or an authorized payload is briefly locked.",+ POLL_STATUS_AUTHORIZED => "The response includes the encrypted payload and consumes the grant.",+ POLL_STATUS_ACCESS_DENIED => "The user denied the grant.",+ POLL_STATUS_EXPIRED_TOKEN =>+ "The code is invalid, expired, missing, already consumed, or otherwise unavailable.",+ }.freeze++ TRACE_EVENT = :user_api_key_device_auth_trace+ TRACE_HASH_LENGTH = 12+ TRACE_HASH_KEYS = %i[approval_token device_code request_token user_code].freeze+ TRACE_FILTERED_KEYS = %i[key nonce payload public_key].freeze+ TRACE_MAX_VALUE_LENGTH = 256++ def self.clear!+ UserApiKey::DeviceAuth::GrantStore.clear!+ UserApiKey::DeviceAuth::CodeRegistry.clear!+ end++ def self.trace(event, **payload)+ event = event.to_s+ payload = normalize_trace_payload(payload)++ DiscourseEvent.trigger(TRACE_EVENT, event, payload, continue_on_error: true)++ return if !SiteSetting.verbose_user_api_key_device_auth_logging++ Rails.logger.info({ message: "user_api_key.device_auth", event: event }.merge(payload).to_json)+ rescue StandardError => exception+ Discourse.warn_exception(+ exception,+ message: "User API key device auth trace failed",+ env: {+ event: event,+ },+ )+ nil+ end++ def self.trace_id_for(value)+ return if value.nil? || value.to_s.empty?++ Digest::SHA256.hexdigest(value.to_s)[0, TRACE_HASH_LENGTH]+ end++ def self.normalize_trace_payload(payload)+ payload.each_with_object({}) do |(key, value), sanitized|+ key = key.to_sym+ next if value.nil? || (value.respond_to?(:empty?) && value.empty?)++ if TRACE_HASH_KEYS.include?(key)+ sanitized[:"#{key}_hash"] = trace_id_for(value)+ elsif TRACE_FILTERED_KEYS.include?(key)+ sanitized[:"#{key}_present"] = true+ elsif value.is_a?(Exception)+ sanitized[:exception_class] = value.class.name+ elsif value.respond_to?(:iso8601)+ sanitized[key] = value.iso8601+ elsif value.is_a?(String)+ sanitized[key] = value.first(TRACE_MAX_VALUE_LENGTH)+ else+ sanitized[key] = value+ end+ end+ end+ private_class_method :normalize_trace_payload+enddiff --git a/app/services/user_api_key/device_auth/approval_token_store.rb b/app/services/user_api_key/device_auth/approval_token_store.rbnew file mode 100644index 00000000000..fe1919ccc61--- /dev/null+++ b/app/services/user_api_key/device_auth/approval_token_store.rb@@ -0,0 +1,66 @@+# frozen_string_literal: true++class UserApiKey::DeviceAuth::ApprovalTokenStore+ SESSION_KEY = :user_api_key_device_approvals+ MAX_TOKENS = 10++ def initialize(session:, user:)+ @session = session+ @user = user+ end++ def create!(device_code)+ cleanup_expired!+ approvals.shift while approvals.length >= MAX_TOKENS++ token = SecureRandom.hex(32)+ approvals[token] = {+ "device_code" => device_code,+ "user_id" => user.id,+ "created_at" => Time.zone.now.iso8601,+ }+ persist!+ token+ end++ def device_code_for(token)+ approval = approvals[token]+ return if approval.blank?+ return if expired?(approval)+ return if approval["user_id"] != user.id++ device_code = approval["device_code"].to_s+ device_code if UserApiKey::DeviceAuth::DEVICE_CODE_REGEX.match?(device_code)+ rescue ArgumentError, TypeError+ nil+ end++ def delete!(token)+ approvals.delete(token)+ persist!+ end++ private++ attr_reader :session, :user++ def approvals+ @approvals ||= session[SESSION_KEY] ||= {}+ end++ def cleanup_expired!+ approvals.delete_if { |_, approval| expired?(approval) }+ persist!+ end++ def expired?(approval)+ created_at = Time.zone.parse(approval["created_at"])+ created_at.blank? || created_at <= UserApiKey::DeviceAuth::DEVICE_AUTH_TTL.ago+ rescue ArgumentError, TypeError+ true+ end++ def persist!+ session[SESSION_KEY] = approvals+ end+enddiff --git a/app/services/user_api_key/device_auth/authorize.rb b/app/services/user_api_key/device_auth/authorize.rbnew file mode 100644index 00000000000..c52a3cb412f--- /dev/null+++ b/app/services/user_api_key/device_auth/authorize.rb@@ -0,0 +1,109 @@+# frozen_string_literal: true++class UserApiKey::DeviceAuth::Authorize+ include Service::Base++ params do+ attribute :device_code, :string+ attribute :user_id, :integer++ validates :device_code, presence: true+ validates :user_id, presence: true+ end++ options { attribute :request_id, :string }++ model :user++ try Discourse::InvalidParameters, Discourse::InvalidAccess do+ step :authorize_grant+ end++ private++ def fetch_user(params:)+ User.find_by(id: params.user_id)+ end++ def authorize_grant(params:, user:, options:)+ UserApiKey::DeviceAuth::GrantStore.with_lock!(+ params.device_code,+ operation: "device_auth.authorize",+ request_id: options.request_id,+ ) do+ grant = UserApiKey::DeviceAuth::GrantStore.load(params.device_code)++ if grant.blank?+ fail_authorize_grant!(+ "grant_missing",+ params: params,+ user: user,+ request_id: options.request_id,+ )+ end++ if !grant.pending?+ fail_authorize_grant!(+ "grant_not_pending",+ params: params,+ user: user,+ grant: grant,+ request_id: options.request_id,+ )+ end++ if grant.bound_to_another_user?(user)+ fail_authorize_grant!(+ "bound_to_other_user",+ params: params,+ user: user,+ grant: grant,+ request_id: options.request_id,+ )+ end++ key = UserApiKey::DeviceAuth::KeyCreator.create!(grant, user)+ grant.authorize!(+ payload: UserApiKey::DeviceAuth::PayloadBuilder.encrypted_payload!(grant, key),+ )++ UserApiKey::DeviceAuth::GrantStore.save!(+ grant,+ ttl: UserApiKey::DeviceAuth::GrantStore.authorized_payload_ttl(params.device_code),+ )+ UserApiKey::DeviceAuth::CodeRegistry.delete_indexes_for(grant)+ context[:grant] = grant+ UserApiKey::DeviceAuth.trace(+ "device_auth.authorize.succeeded",+ request_id: options.request_id,+ client_id: grant.client_id,+ device_code: grant.device_code,+ user_id: user.id,+ )+ end+ rescue Discourse::InvalidParameters, Discourse::InvalidAccess => exception+ UserApiKey::DeviceAuth.trace(+ "device_auth.authorize.failed",+ request_id: options.request_id,+ reason: exception.class.name,+ exception: exception,+ device_code: params.device_code,+ user_id: user.id,+ )+ raise+ end++ def fail_authorize_grant!(reason, params:, user:, request_id:, grant: nil)+ UserApiKey::DeviceAuth.trace(+ "device_auth.authorize.failed",+ request_id: request_id,+ reason: reason,+ status: grant&.status,+ client_id: grant&.client_id,+ device_code: params.device_code,+ user_id: user.id,+ )+ context["result.step.authorize_grant"].fail(error: reason)+ context.fail!+ end+enddiff --git a/app/services/user_api_key/device_auth/code_registry.rb b/app/services/user_api_key/device_auth/code_registry.rbnew file mode 100644index 00000000000..d5d94762079--- /dev/null+++ b/app/services/user_api_key/device_auth/code_registry.rb@@ -0,0 +1,140 @@+# frozen_string_literal: true++class UserApiKey::DeviceAuth::CodeRegistry+ USER_CODE_ALPHABET = UserApiKey::DeviceAuth::USER_CODE_ALPHABET+ REQUEST_TOKEN_REGEX = UserApiKey::DeviceAuth::DEVICE_REQUEST_TOKEN_REGEX+ MAX_COLLISION_ATTEMPTS = UserApiKey::DeviceAuth::MAX_CODE_REGISTRY_COLLISION_ATTEMPTS++ CodeSet =+ if const_defined?(:CodeSet, false)+ const_get(:CodeSet)+ else+ Struct.new(:user_code, :request_token, keyword_init: true)+ end++ def self.valid_request_token?(request_token)+ REQUEST_TOKEN_REGEX.match?(request_token.to_s)+ end++ def self.normalize_user_code(value)+ code = value.to_s.upcase.gsub(/[^A-Z0-9]/, "")+ return if code.length != 8++ "#{code[0, 4]}-#{code[4, 4]}"+ end++ def self.reserve_for(device_code)+ request_token = nil+ user_code = nil++ begin+ request_token = reserve_request_token!(device_code)+ user_code = reserve_user_code!(device_code)++ CodeSet.new(user_code: user_code, request_token: request_token)+ rescue StandardError+ delete_request_token(request_token) if request_token.present?+ delete_user_code(user_code) if user_code.present?+ raise+ end+ end++ def self.load_by_user_code(user_code)+ device_code = Discourse.redis.get(user_code_key(user_code))+ return if device_code.blank?++ grant = UserApiKey::DeviceAuth::GrantStore.load(device_code)+ delete_user_code(user_code) if grant.blank?+ grant+ end++ def self.load_by_request_token(request_token)+ return if !valid_request_token?(request_token)++ device_code = Discourse.redis.get(request_token_key(request_token))+ return if device_code.blank?++ grant = UserApiKey::DeviceAuth::GrantStore.load(device_code)+ delete_request_token(request_token) if grant.blank?+ grant+ end++ def self.user_code_matches_grant?(user_code, grant)+ normalized_code = normalize_user_code(user_code)+ return false if normalized_code.blank?++ device_code = Discourse.redis.get(user_code_key(normalized_code))+ device_code.present? && device_code == grant.device_code+ end++ def self.delete_indexes_for(grant)+ delete_user_code(grant.user_code) if grant.user_code.present?+ delete_request_token(grant.request_token) if grant.request_token.present?+ end++ def self.delete_user_code(user_code)+ Discourse.redis.del(user_code_key(user_code))+ end++ def self.delete_request_token(request_token)+ Discourse.redis.del(request_token_key(request_token))+ end++ def self.user_code_key(user_code)+ "#{UserApiKey::DeviceAuth::DEVICE_USER_CODE_REDIS_PREFIX}#{user_code}"+ end++ def self.request_token_key(request_token)+ "#{UserApiKey::DeviceAuth::DEVICE_REQUEST_REDIS_PREFIX}#{request_token}"+ end++ def self.clear!+ [+ UserApiKey::DeviceAuth::DEVICE_USER_CODE_REDIS_PREFIX,+ UserApiKey::DeviceAuth::DEVICE_REQUEST_REDIS_PREFIX,+ ].each do |prefix|+ Discourse.redis.scan_each(match: "#{prefix}*") { |key| Discourse.redis.del(key) }+ end+ end++ def self.reserve_user_code!(device_code)+ MAX_COLLISION_ATTEMPTS.times do+ user_code = generate_user_code+ if Discourse.redis.set(+ user_code_key(user_code),+ device_code,+ nx: true,+ ex: UserApiKey::DeviceAuth::DEVICE_AUTH_TTL.to_i,+ )+ return user_code+ end+ end++ raise Discourse::InvalidAccess+ end++ def self.reserve_request_token!(device_code)+ MAX_COLLISION_ATTEMPTS.times do+ request_token = SecureRandom.urlsafe_base64(6)+ if Discourse.redis.set(+ request_token_key(request_token),+ device_code,+ nx: true,+ ex: UserApiKey::DeviceAuth::DEVICE_AUTH_TTL.to_i,+ )+ return request_token+ end+ end++ raise Discourse::InvalidAccess+ end++ def self.generate_user_code+ code =+ Array+ .new(8) { USER_CODE_ALPHABET[SecureRandom.random_number(USER_CODE_ALPHABET.length)] }+ .join+ "#{code[0, 4]}-#{code[4, 4]}"+ end+ private_class_method :reserve_user_code!, :reserve_request_token!, :generate_user_code+enddiff --git a/app/services/user_api_key/device_auth/create_request.rb b/app/services/user_api_key/device_auth/create_request.rbnew file mode 100644index 00000000000..907da00af05--- /dev/null+++ b/app/services/user_api_key/device_auth/create_request.rb@@ -0,0 +1,84 @@+# frozen_string_literal: true++class UserApiKey::DeviceAuth::CreateRequest+ include Service::Base++ params do+ attribute :nonce, :string+ attribute :scopes, :string+ attribute :client_id, :string+ attribute :application_name, :string+ attribute :public_key, :string+ attribute :push_url, :string+ attribute :padding, :string+ attribute :expires_in_seconds, :string++ validates :nonce, presence: true+ validates :scopes, presence: true+ validates :client_id, presence: true+ end++ options { attribute :request_id, :string }++ model :client, optional: true++ try Discourse::InvalidParameters, Discourse::InvalidAccess do+ step :validate_request+ step :build_grant+ step :validate_grant_size+ step :reserve_codes+ step :store_grant+ end++ private++ def fetch_client(params:)+ UserApiKeyClient.find_by(client_id: params.client_id)+ end++ def validate_request(params:, client:)+ UserApiKey::DeviceAuth::RequestValidator.validate!(params.attributes.symbolize_keys, client)+ end++ def build_grant(params:, client:)+ request_params = params.attributes.symbolize_keys+ scopes = request_params[:scopes].split(",")+ expires_in_seconds = UserApiKey::Expiry.parse_seconds!(request_params[:expires_in_seconds])+ device_code = SecureRandom.hex(32)++ context[:device_request] = { device_code: device_code }+ context[:grant] = UserApiKey::DeviceAuth::Grant.build(+ request_params,+ client,+ scopes,+ expires_in_seconds,+ device_code,+ )+ UserApiKey::DeviceAuth::PayloadBuilder.validate_size!(context[:grant])+ end++ def validate_grant_size(grant:)+ UserApiKey::DeviceAuth::KeyCreator.validate_grant_size!(grant)+ end++ def reserve_codes(device_request:, grant:)+ codes = UserApiKey::DeviceAuth::CodeRegistry.reserve_for(device_request[:device_code])++ grant.assign_codes!(user_code: codes.user_code, request_token: codes.request_token)+ device_request[:user_code] = codes.user_code+ device_request[:request_token] = codes.request_token+ end++ def store_grant(device_request:, grant:, options:)+ UserApiKey::DeviceAuth::KeyCreator.validate_grant_size!(grant)+ UserApiKey::DeviceAuth::GrantStore.save!(grant, ttl: UserApiKey::DeviceAuth::DEVICE_AUTH_TTL)+ UserApiKey::DeviceAuth.trace(+ "device_auth.create.succeeded",+ request_id: options.request_id,+ client_id: grant.client_id,+ device_code: grant.device_code,+ request_token: grant.request_token,+ user_code: grant.user_code,+ )+ end+enddiff --git a/app/services/user_api_key/device_auth/crypto.rb b/app/services/user_api_key/device_auth/crypto.rbnew file mode 100644index 00000000000..85034767767--- /dev/null+++ b/app/services/user_api_key/device_auth/crypto.rb@@ -0,0 +1,35 @@+# frozen_string_literal: true++class UserApiKey::DeviceAuth::Crypto+ def self.parse_public_key!(value)+ OpenSSL::PKey::RSA.new(value)+ rescue OpenSSL::PKey::RSAError, TypeError+ raise Discourse::InvalidParameters.new(:public_key)+ end++ def self.validate_payload_size!(payload, public_key, padding: nil)+ key_size_bytes = public_key.n.num_bytes+ max_payload_size =+ if padding == "oaep"+ key_size_bytes - 2 * 20 - 2+ else+ key_size_bytes - 11+ end++ if payload.bytesize > max_payload_size+ padding_name = padding == "oaep" ? "OAEP" : "PKCS#1"+ raise Discourse::InvalidParameters.new(+ "Payload too large for #{padding_name} encryption with this key size. " \+ "Maximum: #{max_payload_size} bytes, got: #{payload.bytesize} bytes. " \+ "Try using a shorter nonce or a larger RSA key (minimum 2048-bit recommended).",+ )+ end+ end++ def self.encrypt!(public_key, data, padding: nil)+ padding_mode = padding == "oaep" ? "oaep" : "pkcs1"+ public_key.encrypt(data, { "rsa_padding_mode" => padding_mode })+ rescue OpenSSL::PKey::PKeyError, OpenSSL::PKey::RSAError+ raise Discourse::InvalidParameters.new(:public_key)+ end+enddiff --git a/app/services/user_api_key/device_auth/deny.rb b/app/services/user_api_key/device_auth/deny.rbnew file mode 100644index 00000000000..faf917903c2--- /dev/null+++ b/app/services/user_api_key/device_auth/deny.rb@@ -0,0 +1,82 @@+# frozen_string_literal: true++class UserApiKey::DeviceAuth::Deny+ include Service::Base++ params do+ attribute :device_code, :string++ validates :device_code, presence: true+ end++ options { attribute :request_id, :string }++ try Discourse::InvalidParameters, Discourse::InvalidAccess do+ step :deny_grant+ end++ private++ def deny_grant(params:, options:)+ failure_reason = nil+ grant_status = nil+ client_id = nil++ UserApiKey::DeviceAuth::GrantStore.with_lock!(+ params.device_code,+ operation: "device_auth.deny",+ request_id: options.request_id,+ ) do+ grant = UserApiKey::DeviceAuth::GrantStore.load(params.device_code)+ grant_status = grant&.status+ client_id = grant&.client_id++ failure_reason =+ if grant.blank?+ "grant_missing"+ elsif grant.pending?+ grant.deny!+ UserApiKey::DeviceAuth::GrantStore.save!(+ grant,+ ttl: UserApiKey::DeviceAuth::GrantStore.ttl_for_update(params.device_code),+ )+ UserApiKey::DeviceAuth::CodeRegistry.delete_indexes_for(grant)+ grant_status = grant.status+ nil+ elsif grant.denied?+ nil+ else+ "grant_not_pending"+ end+ end++ if failure_reason.present?+ UserApiKey::DeviceAuth.trace(+ "device_auth.deny.failed",+ request_id: options.request_id,+ reason: failure_reason,+ status: grant_status,+ client_id: client_id,+ device_code: params.device_code,+ )+ fail!(failure_reason)+ end++ UserApiKey::DeviceAuth.trace(+ "device_auth.deny.succeeded",+ request_id: options.request_id,+ status: grant_status,+ client_id: client_id,+ device_code: params.device_code,+ )+ rescue Discourse::InvalidParameters, Discourse::InvalidAccess => exception+ UserApiKey::DeviceAuth.trace(+ "device_auth.deny.failed",+ request_id: options.request_id,+ reason: exception.class.name,+ exception: exception,+ device_code: params.device_code,+ )+ raise+ end+enddiff --git a/app/services/user_api_key/device_auth/grant.rb b/app/services/user_api_key/device_auth/grant.rbnew file mode 100644index 00000000000..1b49f050fc1--- /dev/null+++ b/app/services/user_api_key/device_auth/grant.rb@@ -0,0 +1,234 @@+# frozen_string_literal: true++class UserApiKey::DeviceAuth::Grant+ PENDING_STATUS = "pending"+ AUTHORIZED_STATUS = "authorized"+ DENIED_STATUS = "denied"+ STATUSES = [PENDING_STATUS, AUTHORIZED_STATUS, DENIED_STATUS].freeze++ def self.build(params, client, scopes, expires_in_seconds, device_code)+ created_at = Time.zone.now++ new(+ status: :pending,+ device_code: device_code,+ application_name:+ if client.present?+ client.application_name.presence || params[:application_name]+ else+ params[:application_name]+ end,+ client_id: params[:client_id],+ public_key: UserApiKey::DeviceAuth::RequestValidator.public_key_str(params, client),+ nonce: params[:nonce],+ scopes: scopes,+ push_url: params[:push_url].presence,+ padding: params[:padding].presence,+ expires_in_seconds: expires_in_seconds,+ expires_at:+ expires_in_seconds.present? ? (created_at + expires_in_seconds.seconds).iso8601(6) : nil,+ unregistered_client: client.blank? || client.public_key.blank?,+ created_at: created_at.iso8601(6),+ )+ end++ def self.from_json(json)+ data = JSON.parse(json)+ return if !data.is_a?(Hash)++ new(**data.symbolize_keys)+ rescue JSON::ParserError, ArgumentError, TypeError+ nil+ end++ attr_reader :status,+ :device_code,+ :user_code,+ :request_token,+ :application_name,+ :client_id,+ :public_key,+ :nonce,+ :push_url,+ :padding,+ :expires_in_seconds,+ :payload,+ :authorizing_user_id++ attr_writer :scopes++ def initialize(+ status:,+ device_code:,+ user_code: nil,+ request_token: nil,+ application_name: nil,+ client_id: nil,+ public_key: nil,+ nonce: nil,+ scopes: nil,+ push_url: nil,+ padding: nil,+ expires_in_seconds: nil,+ expires_at: nil,+ unregistered_client: false,+ created_at: nil,+ payload: nil,+ authorized_at: nil,+ denied_at: nil,+ authorizing_user_id: nil,+ authorizing_username: nil,+ authorizing_at: nil+ )+ @status = normalize_status(status)+ validate_status!+ @device_code = device_code+ @user_code = user_code+ @request_token = request_token+ @application_name = application_name+ @client_id = client_id+ @public_key = public_key+ @nonce = nonce+ @scopes = scopes+ @push_url = push_url+ @padding = padding+ @expires_in_seconds = expires_in_seconds+ @created_at = created_at+ @expires_at = expires_at || default_expires_at&.iso8601(6)+ @unregistered_client = unregistered_client+ @payload = payload+ @authorized_at = authorized_at+ @denied_at = denied_at+ @authorizing_user_id = authorizing_user_id+ @authorizing_username = authorizing_username+ @authorizing_at = authorizing_at+ end++ def ==(other)+ other.is_a?(self.class) && to_h == other.to_h+ end++ def pending?+ status == PENDING_STATUS+ end++ def authorized?+ status == AUTHORIZED_STATUS+ end++ def denied?+ status == DENIED_STATUS+ end++ def scopes+ Array(@scopes)+ end++ def localized_scopes+ scopes.map { |scope| I18n.t("user_api_key.scopes.#{scope}") }+ end++ def write_scope?+ scopes.include?("write")+ end++ def expires_at+ return if @expires_at.blank?++ Time.zone.parse(@expires_at.to_s)+ end++ def unregistered_client?+ !!@unregistered_client+ end++ def assign_codes!(user_code:, request_token:)+ @user_code = user_code+ @request_token = request_token+ end++ def authorize!(payload:)+ @status = AUTHORIZED_STATUS+ @payload = payload+ @authorized_at = Time.zone.now.iso8601+ end++ def deny!+ @status = DENIED_STATUS+ @denied_at = Time.zone.now.iso8601+ end++ def bound_to_another_user?(user)+ authorizing_user_id.present? && authorizing_user_id != user.id+ end++ def authorized_for_user?(user)+ authorizing_user_id == user.id+ end++ def bind_to_user!(user)+ return false if bound_to_another_user?(user)+ return true if authorized_for_user?(user)++ @authorizing_user_id = user.id+ @authorizing_username = user.username+ @authorizing_at = Time.zone.now.iso8601+ true+ end++ def to_h+ {+ "status" => status,+ "device_code" => device_code,+ "user_code" => user_code,+ "request_token" => request_token,+ "application_name" => application_name,+ "client_id" => client_id,+ "public_key" => public_key,+ "nonce" => nonce,+ "scopes" => scopes,+ "push_url" => push_url,+ "padding" => padding,+ "expires_in_seconds" => expires_in_seconds,+ "expires_at" => @expires_at,+ "unregistered_client" => unregistered_client?,+ "created_at" => @created_at,+ "payload" => payload,+ "authorized_at" => @authorized_at,+ "denied_at" => @denied_at,+ "authorizing_user_id" => authorizing_user_id,+ "authorizing_username" => @authorizing_username,+ "authorizing_at" => @authorizing_at,+ }.compact+ end++ def as_json(*)+ to_h+ end++ def to_json(*args)+ to_h.to_json(*args)+ end++ private++ def normalize_status(status)+ status.to_s+ end++ def default_expires_at+ return if expires_in_seconds.blank?++ if @created_at.present?+ Time.zone.parse(@created_at.to_s) + expires_in_seconds.to_i.seconds+ else+ UserApiKey::Expiry.requested_expires_at(expires_in_seconds)+ end+ end++ def validate_status!+ return if STATUSES.include?(status)++ raise ArgumentError, "invalid device auth grant status: #{status}"+ end+enddiff --git a/app/services/user_api_key/device_auth/grant_store.rb b/app/services/user_api_key/device_auth/grant_store.rbnew file mode 100644index 00000000000..dd369750436--- /dev/null+++ b/app/services/user_api_key/device_auth/grant_store.rb@@ -0,0 +1,125 @@+# frozen_string_literal: true++class UserApiKey::DeviceAuth::GrantStore+ REDIS_PREFIXES = [UserApiKey::DeviceAuth::DEVICE_AUTHORIZATION_LOCK_REDIS_PREFIX].freeze+ CONSUME_LOCKED = :locked+ UNLOCK_SCRIPT = DiscourseRedis::EvalHelper.new <<~LUA+ if redis.call("get", KEYS[1]) == ARGV[1] then+ return redis.call("del", KEYS[1])+ else+ return 0+ end+ LUA++ def self.grant_key(device_code)+ "#{UserApiKey::DeviceAuth::DEVICE_CODE_REDIS_PREFIX}#{device_code}"+ end++ def self.lock_key(device_code)+ "#{UserApiKey::DeviceAuth::DEVICE_AUTHORIZATION_LOCK_REDIS_PREFIX}#{device_code}"+ end++ def self.load(device_code)+ return if !UserApiKey::DeviceAuth::DEVICE_CODE_REGEX.match?(device_code.to_s)++ serialized = Discourse.redis.get(grant_key(device_code))+ return if serialized.blank?++ grant = UserApiKey::DeviceAuth::Grant.from_json(serialized)+ grant if grant&.device_code == device_code+ rescue JSON::ParserError, ArgumentError, TypeError+ nil+ end++ def self.save!(grant, ttl:)+ Discourse.redis.setex(grant_key(grant.device_code), ttl.to_i, grant.to_json)+ end++ def self.delete(device_code)+ Discourse.redis.del(grant_key(device_code))+ end++ def self.consume_authorized(device_code, request_id: nil)+ return if !UserApiKey::DeviceAuth::DEVICE_CODE_REGEX.match?(device_code.to_s)++ consumed_grant = nil++ with_lock!(+ device_code,+ operation: "device_auth.poll.consume_authorized",+ request_id: request_id,+ ) do+ grant = load(device_code)+ if grant&.authorized?+ delete(device_code)+ consumed_grant = grant+ end+ end++ consumed_grant+ rescue Discourse::InvalidAccess+ CONSUME_LOCKED+ end++ def self.ttl_for_update(device_code)+ ttl = Discourse.redis.ttl(grant_key(device_code)).to_i+ ttl.positive? ? ttl : UserApiKey::DeviceAuth::DEVICE_AUTH_TTL.to_i+ end++ def self.authorized_payload_ttl(device_code)+ [ttl_for_update(device_code), UserApiKey::DeviceAuth::DEVICE_AUTHORIZED_PAYLOAD_TTL.to_i].min+ end++ def self.with_lock!(device_code, operation: "device_auth.lock", request_id: nil)+ lock_key = self.lock_key(device_code)+ namespaced_lock_key = namespaced_key(lock_key)+ lock_token = SecureRandom.hex+ lock_acquired = false++ unless Discourse.redis.set(+ lock_key,+ lock_token,+ nx: true,+ ex: UserApiKey::DeviceAuth::DEVICE_AUTHORIZATION_LOCK_TTL.to_i,+ )+ UserApiKey::DeviceAuth.trace(+ "#{operation}.failed",+ request_id: request_id,+ reason: "lock_busy",+ device_code: device_code,+ )+ raise Discourse::InvalidAccess+ end++ lock_acquired = true++ yield+ ensure+ release_lock(namespaced_lock_key, lock_token) if lock_acquired+ end++ def self.namespaced_key(key)+ if Discourse.redis.respond_to?(:namespace_key)+ Discourse.redis.namespace_key(key)+ else+ key+ end+ end++ def self.release_lock(namespaced_lock_key, lock_token)+ UNLOCK_SCRIPT.eval(Discourse.redis, [namespaced_lock_key], [lock_token])+ end++ def self.clear!+ Discourse+ .redis+ .scan_each(match: "#{UserApiKey::DeviceAuth::DEVICE_CODE_REDIS_PREFIX}*") do |key|+ device_code = key.delete_prefix(UserApiKey::DeviceAuth::DEVICE_CODE_REDIS_PREFIX)+ Discourse.redis.del(key) if UserApiKey::DeviceAuth::DEVICE_CODE_REGEX.match?(device_code)+ end++ REDIS_PREFIXES.each do |prefix|+ Discourse.redis.scan_each(match: "#{prefix}*") { |key| Discourse.redis.del(key) }+ end+ end+enddiff --git a/app/services/user_api_key/device_auth/key_creator.rb b/app/services/user_api_key/device_auth/key_creator.rbnew file mode 100644index 00000000000..1c0d086f4eb--- /dev/null+++ b/app/services/user_api_key/device_auth/key_creator.rb@@ -0,0 +1,43 @@+# frozen_string_literal: true++class UserApiKey::DeviceAuth::KeyCreator+ def self.create!(grant, user)+ validate_grant!(grant)++ UserApiKey.transaction do+ client = UserApiKeyClient.find_by(client_id: grant.client_id)+ client = UserApiKeyClient.new(client_id: grant.client_id) if client.blank?+ client.application_name = grant.application_name if client.new_record?+ client.save! if client.new_record? || client.changed?++ client.keys.where(user_id: user.id).destroy_all+ client.keys.create!(+ user_id: user.id,+ push_url: grant.push_url,+ expires_at: grant.expires_at,+ scopes: grant.scopes.map { |name| UserApiKeyScope.new(name: name) },+ )+ end+ end++ def self.validate_grant!(grant)+ requested_scopes = Set.new(grant.scopes)+ raise Discourse::InvalidAccess unless UserApiKey.allowed_scopes.superset?(requested_scopes)+ UserApiKey::DeviceAuth::RequestValidator.validate_requested_scopes!(grant.scopes)++ client = UserApiKeyClient.find_by(client_id: grant.client_id)+ UserApiKey::DeviceAuth::RequestValidator.validate_client_scopes!(client, grant.scopes)++ public_key = UserApiKey::DeviceAuth::Crypto.parse_public_key!(grant.public_key)+ UserApiKey::DeviceAuth::RequestValidator.validate_public_key_constraints!(public_key)+ UserApiKey::DeviceAuth::RequestValidator.validate_padding!(grant.padding)+ UserApiKey::DeviceAuth::PayloadBuilder.validate_size!(grant)+ validate_grant_size!(grant)+ end++ def self.validate_grant_size!(grant)+ if grant.to_json.bytesize > UserApiKey::DeviceAuth::MAX_DEVICE_GRANT_BYTES+ raise Discourse::InvalidParameters.new(:base)+ end+ end+enddiff --git a/app/services/user_api_key/device_auth/payload_builder.rb b/app/services/user_api_key/device_auth/payload_builder.rbnew file mode 100644index 00000000000..9714c48f5e7--- /dev/null+++ b/app/services/user_api_key/device_auth/payload_builder.rb@@ -0,0 +1,36 @@+# frozen_string_literal: true++class UserApiKey::DeviceAuth::PayloadBuilder+ AUTH_API_VERSION = UserApiKey::DeviceAuth::AUTH_API_VERSION+ DEVICE_KEY_PLACEHOLDER = UserApiKey::DeviceAuth::DEVICE_KEY_PLACEHOLDER++ def self.validate_size!(grant)+ payload = payload_json(grant, key_value: DEVICE_KEY_PLACEHOLDER, push: false)+ UserApiKey::DeviceAuth::Crypto.validate_payload_size!(+ payload,+ UserApiKey::DeviceAuth::Crypto.parse_public_key!(grant.public_key),+ padding: grant.padding,+ )+ end++ def self.encrypted_payload!(grant, key)+ public_key = UserApiKey::DeviceAuth::Crypto.parse_public_key!(grant.public_key)+ payload =+ payload_json(grant, key_value: key.key, push: key.has_push?, expires_at: key.expires_at)++ UserApiKey::DeviceAuth::Crypto.validate_payload_size!(+ payload,+ public_key,+ padding: grant.padding,+ )+ Base64.encode64(+ UserApiKey::DeviceAuth::Crypto.encrypt!(public_key, payload, padding: grant.padding),+ )+ end++ def self.payload_json(grant, key_value:, push:, expires_at: grant.expires_at)+ payload = { key: key_value, nonce: grant.nonce, push: push, api: AUTH_API_VERSION }+ payload[:expires_at] = expires_at.iso8601 if expires_at.present?+ payload.to_json+ end+enddiff --git a/app/services/user_api_key/device_auth/poll.rb b/app/services/user_api_key/device_auth/poll.rbnew file mode 100644index 00000000000..f95f6aa4fc7--- /dev/null+++ b/app/services/user_api_key/device_auth/poll.rb@@ -0,0 +1,116 @@+# frozen_string_literal: true++class UserApiKey::DeviceAuth::Poll+ include Service::Base++ params do+ attribute :device_code, :string++ validates :device_code, presence: true+ end++ options { attribute :request_id, :string }++ model :poll_response, :poll_device_request++ private++ def poll_device_request(params:, options:)+ device_code = params.device_code+ request_id = options.request_id++ if !UserApiKey::DeviceAuth::DEVICE_CODE_REGEX.match?(device_code.to_s)+ return(+ poll_response(+ UserApiKey::DeviceAuth::POLL_STATUS_EXPIRED_TOKEN,+ reason: "invalid_device_code",+ device_code: device_code,+ request_id: request_id,+ )+ )+ end++ grant = UserApiKey::DeviceAuth::GrantStore.load(device_code)+ if grant.blank?+ return(+ poll_response(+ UserApiKey::DeviceAuth::POLL_STATUS_EXPIRED_TOKEN,+ reason: "grant_missing",+ device_code: device_code,+ request_id: request_id,+ )+ )+ end++ if grant.pending?+ poll_response(+ UserApiKey::DeviceAuth::POLL_STATUS_AUTHORIZATION_PENDING,+ reason: "grant_pending",+ grant: grant,+ device_code: device_code,+ request_id: request_id,+ )+ elsif grant.authorized?+ authorized_grant =+ UserApiKey::DeviceAuth::GrantStore.consume_authorized(device_code, request_id: request_id)+ if authorized_grant == UserApiKey::DeviceAuth::GrantStore::CONSUME_LOCKED+ poll_response(+ UserApiKey::DeviceAuth::POLL_STATUS_AUTHORIZATION_PENDING,+ reason: "authorized_grant_locked",+ grant: grant,+ device_code: device_code,+ request_id: request_id,+ )+ elsif authorized_grant.present?+ poll_response(+ UserApiKey::DeviceAuth::POLL_STATUS_AUTHORIZED,+ reason: "authorized_grant_consumed",+ grant: authorized_grant,+ device_code: device_code,+ request_id: request_id,+ payload: authorized_grant.payload,+ )+ else+ poll_response(+ UserApiKey::DeviceAuth::POLL_STATUS_EXPIRED_TOKEN,+ reason: "authorized_grant_missing_after_lock",+ grant: grant,+ device_code: device_code,+ request_id: request_id,+ )+ end+ elsif grant.denied?+ poll_response(+ UserApiKey::DeviceAuth::POLL_STATUS_ACCESS_DENIED,+ reason: "grant_denied",+ grant: grant,+ device_code: device_code,+ request_id: request_id,+ )+ else+ poll_response(+ UserApiKey::DeviceAuth::POLL_STATUS_EXPIRED_TOKEN,+ reason: "unknown_grant_status",+ grant: grant,+ device_code: device_code,+ request_id: request_id,+ )+ end+ end++ def poll_response(status, device_code:, request_id:, reason:, grant: nil, payload: nil)+ UserApiKey::DeviceAuth.trace(+ "device_auth.poll.checked",+ request_id: request_id,+ reason: reason,+ status: status,+ grant_status: grant&.status,+ client_id: grant&.client_id,+ device_code: device_code,+ )++ response = { status: status }+ response[:payload] = payload if payload.present?+ response+ end+enddiff --git a/app/services/user_api_key/device_auth/request_validator.rb b/app/services/user_api_key/device_auth/request_validator.rbnew file mode 100644index 00000000000..36e56416f67--- /dev/null+++ b/app/services/user_api_key/device_auth/request_validator.rb@@ -0,0 +1,89 @@+# frozen_string_literal: true++class UserApiKey::DeviceAuth::RequestValidator+ ALLOWED_PADDING_MODES = UserApiKey::DeviceAuth::ALLOWED_PADDING_MODES+ DISALLOWED_DEVICE_SCOPES = UserApiKey::DeviceAuth::DISALLOWED_DEVICE_SCOPES+ MAX_DEVICE_CLIENT_ID_LENGTH = UserApiKey::DeviceAuth::MAX_DEVICE_CLIENT_ID_LENGTH+ MAX_DEVICE_APPLICATION_NAME_LENGTH = UserApiKey::DeviceAuth::MAX_DEVICE_APPLICATION_NAME_LENGTH+ MAX_DEVICE_NONCE_LENGTH = UserApiKey::DeviceAuth::MAX_DEVICE_NONCE_LENGTH+ MAX_DEVICE_PUBLIC_KEY_LENGTH = UserApiKey::DeviceAuth::MAX_DEVICE_PUBLIC_KEY_LENGTH+ MAX_DEVICE_PUSH_URL_LENGTH = UserApiKey::DeviceAuth::MAX_DEVICE_PUSH_URL_LENGTH+ MAX_DEVICE_SCOPES_LENGTH = UserApiKey::DeviceAuth::MAX_DEVICE_SCOPES_LENGTH+ MAX_DEVICE_SCOPES_COUNT = UserApiKey::DeviceAuth::MAX_DEVICE_SCOPES_COUNT+ MIN_DEVICE_RSA_BITS = UserApiKey::DeviceAuth::MIN_DEVICE_RSA_BITS+ MAX_DEVICE_RSA_BITS = UserApiKey::DeviceAuth::MAX_DEVICE_RSA_BITS++ def self.validate!(params, client)+ validate_param_lengths!(params)++ if (client.blank? || client.application_name.blank?) && params[:application_name].blank?+ raise Discourse::InvalidParameters.new(:application_name)+ end++ scopes = params[:scopes].split(",")+ validate_requested_scopes!(scopes)+ validate_client_scopes!(client, scopes)+ validate_padding!(params[:padding])+ validate_public_key_constraints!(+ UserApiKey::DeviceAuth::Crypto.parse_public_key!(public_key_str(params, client)),+ )+ end++ def self.public_key_str(params, client)+ client&.public_key.presence || params[:public_key]+ end++ def self.validate_requested_scopes!(scopes)+ raise Discourse::InvalidParameters.new(:scopes) if scopes.blank? || scopes.any?(&:blank?)++ requested_scopes = Set.new(scopes)+ if DISALLOWED_DEVICE_SCOPES.intersect?(requested_scopes)+ raise Discourse::InvalidParameters.new(:scopes)+ end+ raise Discourse::InvalidAccess if !UserApiKey.allowed_scopes.superset?(requested_scopes)+ end++ def self.validate_client_scopes!(client, scopes)+ if client&.scopes.present? && !client.allowed_scopes.superset?(Set.new(scopes))+ raise Discourse::InvalidAccess+ end+ end++ def self.validate_padding!(padding)+ return if padding.blank? || ALLOWED_PADDING_MODES.include?(padding)++ raise Discourse::InvalidParameters.new(:padding)+ end++ def self.validate_public_key_constraints!(public_key)+ bits = public_key.n.num_bits+ if bits < MIN_DEVICE_RSA_BITS || bits > MAX_DEVICE_RSA_BITS+ raise Discourse::InvalidParameters.new(:public_key)+ end+ end++ def self.validate_param_lengths!(params)+ validate_param_length!(params, :client_id, MAX_DEVICE_CLIENT_ID_LENGTH)+ validate_param_length!(params, :application_name, MAX_DEVICE_APPLICATION_NAME_LENGTH)+ validate_param_length!(params, :nonce, MAX_DEVICE_NONCE_LENGTH)+ if params[:public_key].present?+ validate_param_length!(params, :public_key, MAX_DEVICE_PUBLIC_KEY_LENGTH)+ end+ if params[:push_url].present?+ validate_param_length!(params, :push_url, MAX_DEVICE_PUSH_URL_LENGTH)+ end++ scopes = params[:scopes].to_s+ if scopes.length > MAX_DEVICE_SCOPES_LENGTH ||+ scopes.split(",").length > MAX_DEVICE_SCOPES_COUNT+ raise Discourse::InvalidParameters.new(:scopes)+ end+ end++ def self.validate_param_length!(params, param_name, max_length)+ value = params[param_name]+ return if value.blank?+ raise Discourse::InvalidParameters.new(param_name) if value.to_s.bytesize > max_length+ end+ private_class_method :validate_param_length!+enddiff --git a/app/services/user_api_key/device_auth/user_activation.rb b/app/services/user_api_key/device_auth/user_activation.rbnew file mode 100644index 00000000000..3c09f9cb1da--- /dev/null+++ b/app/services/user_api_key/device_auth/user_activation.rb@@ -0,0 +1,313 @@+# frozen_string_literal: true++class UserApiKey::DeviceAuth::UserActivation+ class Result+ attr_reader :status, :grant, :device_code, :request_token, :debug_reason++ def initialize(status:, grant: nil, device_code: nil, request_token: nil, debug_reason: nil)+ @status = status+ @grant = grant+ @device_code = device_code+ @request_token = request_token+ @debug_reason = debug_reason+ end+ end++ def initialize(user:, session:, request_id: nil)+ @user = user+ @request_id = request_id+ @approval_tokens = UserApiKey::DeviceAuth::ApprovalTokenStore.new(session: session, user: user)+ end++ def preview_request_token(request_token)+ if !UserApiKey::DeviceAuth::CodeRegistry.valid_request_token?(request_token)+ return(+ trace_and_return_result(+ "device_auth.activation.preview.failed",+ expired_result("invalid_request_token", request_token: request_token),+ )+ )+ end++ grant = UserApiKey::DeviceAuth::CodeRegistry.load_by_request_token(request_token)+ if (reason = unavailable_reason_for(grant))+ return(+ trace_and_return_result(+ "device_auth.activation.preview.failed",+ expired_result(reason, grant: grant, request_token: request_token),+ )+ )+ end++ trace_and_return_result(+ "device_auth.activation.preview.succeeded",+ Result.new(status: :success, grant: grant, request_token: request_token),+ )+ end++ def find_manual_code(code)+ user_code = UserApiKey::DeviceAuth::CodeRegistry.normalize_user_code(code)+ if user_code.blank?+ return(+ trace_and_return_result(+ "device_auth.activation.manual_code.failed",+ Result.new(status: :invalid_code, debug_reason: "invalid_user_code_format"),+ user_code: code,+ )+ )+ end++ grant = UserApiKey::DeviceAuth::CodeRegistry.load_by_user_code(user_code)+ if grant.blank?+ return(+ trace_and_return_result(+ "device_auth.activation.manual_code.failed",+ Result.new(status: :invalid_code, debug_reason: "user_code_not_found"),+ user_code: user_code,+ )+ )+ end++ if (reason = unavailable_reason_for(grant))+ return(+ trace_and_return_result(+ "device_auth.activation.manual_code.failed",+ expired_result(reason, grant: grant),+ user_code: user_code,+ )+ )+ end++ trace_and_return_result(+ "device_auth.activation.manual_code.succeeded",+ Result.new(status: :success, grant: grant),+ user_code: user_code,+ )+ end++ def create_approval_token!(grant)+ device_code = grant.device_code+ approval_token = nil+ failure_reason = nil++ UserApiKey::DeviceAuth::GrantStore.with_lock!(+ device_code,+ operation: "device_auth.activation.approval_token",+ request_id: request_id,+ ) do+ stored_grant = UserApiKey::DeviceAuth::GrantStore.load(device_code)+ if (failure_reason = unavailable_reason_for(stored_grant))+ next+ end++ unless stored_grant.bind_to_user!(user)+ failure_reason = "bound_to_other_user"+ next+ end++ UserApiKey::DeviceAuth::GrantStore.save!(+ stored_grant,+ ttl: UserApiKey::DeviceAuth::GrantStore.ttl_for_update(device_code),+ )+ approval_token = @approval_tokens.create!(device_code)+ end++ if approval_token.present?+ UserApiKey::DeviceAuth.trace(+ "device_auth.activation.approval_token.succeeded",+ request_id: request_id,+ user_id: user&.id,+ device_code: device_code,+ approval_token: approval_token,+ )+ else+ UserApiKey::DeviceAuth.trace(+ "device_auth.activation.approval_token.failed",+ request_id: request_id,+ reason: failure_reason || "approval_token_not_created",+ user_id: user&.id,+ device_code: device_code,+ )+ end++ approval_token+ rescue Discourse::InvalidAccess+ UserApiKey::DeviceAuth.trace(+ "device_auth.activation.approval_token.failed",+ request_id: request_id,+ reason: "lock_busy",+ user_id: user&.id,+ device_code: device_code,+ )+ nil+ end++ def resolve_authorize_device_code(request_token:, user_code:, approval_token:)+ if request_token.present?+ resolve_request_authorize_device_code(request_token, user_code)+ else+ resolve_approval_token_device_code(approval_token)+ end+ end++ def resolve_deny_device_code(request_token:, approval_token:)+ if request_token.present?+ return(+ trace_and_return_result(+ "device_auth.activation.resolve_deny.failed",+ expired_result("deny_requires_approval_token", request_token: request_token),+ )+ )+ end++ resolve_approval_token_device_code(approval_token)+ end++ def delete_approval_token(token)+ @approval_tokens.delete!(token)+ UserApiKey::DeviceAuth.trace(+ "device_auth.activation.approval_token.deleted",+ request_id: request_id,+ user_id: user&.id,+ approval_token: token,+ )+ end++ private++ attr_reader :user, :request_id++ def resolve_request_authorize_device_code(request_token, user_code)+ grant = UserApiKey::DeviceAuth::CodeRegistry.load_by_request_token(request_token)+ if (reason = unavailable_reason_for(grant))+ return(+ trace_and_return_result(+ "device_auth.activation.resolve_request.failed",+ expired_result(reason, grant: grant, request_token: request_token),+ )+ )+ end++ result = nil++ UserApiKey::DeviceAuth::GrantStore.with_lock!(+ grant.device_code,+ operation: "device_auth.activation.resolve_request",+ request_id: request_id,+ ) do+ grant = UserApiKey::DeviceAuth::CodeRegistry.load_by_request_token(request_token)++ if (reason = unavailable_reason_for(grant))+ result = expired_result(reason, grant: grant, request_token: request_token)+ next+ end++ unless UserApiKey::DeviceAuth::CodeRegistry.user_code_matches_grant?(user_code, grant)+ result =+ Result.new(+ status: :invalid_code,+ grant: grant,+ request_token: request_token,+ debug_reason: "user_code_mismatch",+ )+ next+ end++ if !grant.bind_to_user!(user)+ result = expired_result("bound_to_other_user", grant: grant, request_token: request_token)+ next+ end++ UserApiKey::DeviceAuth::GrantStore.save!(+ grant,+ ttl: UserApiKey::DeviceAuth::GrantStore.ttl_for_update(grant.device_code),+ )++ result =+ Result.new(+ status: :success,+ grant: grant,+ device_code: grant.device_code,+ request_token: request_token,+ )+ end++ if result.present?+ trace_and_return_result(+ (+ if result.status == :success+ "device_auth.activation.resolve_request.succeeded"+ else+ "device_auth.activation.resolve_request.failed"+ end+ ),+ result,+ user_code: user_code,+ )+ else+ trace_and_return_result(+ "device_auth.activation.resolve_request.failed",+ expired_result("empty_lock_result", grant: grant, request_token: request_token),+ user_code: user_code,+ )+ end+ rescue Discourse::InvalidAccess+ trace_and_return_result(+ "device_auth.activation.resolve_request.failed",+ expired_result("lock_busy", grant: grant, request_token: request_token),+ user_code: user_code,+ )+ end++ def resolve_approval_token_device_code(approval_token)+ device_code = @approval_tokens.device_code_for(approval_token)+ if device_code.blank?+ return(+ trace_and_return_result(+ "device_auth.activation.resolve_approval_token.failed",+ expired_result("approval_token_invalid"),+ approval_token: approval_token,+ )+ )+ end++ trace_and_return_result(+ "device_auth.activation.resolve_approval_token.succeeded",+ Result.new(status: :success, device_code: device_code),+ approval_token: approval_token,+ )+ end++ def unavailable_reason_for(grant)+ return "grant_missing" if grant.blank?+ return "grant_not_pending" if !grant.pending?+ return "user_missing" if user.blank?++ "bound_to_other_user" if grant.bound_to_another_user?(user)+ end++ def expired_result(debug_reason, grant: nil, request_token: nil)+ Result.new(+ status: :expired_code,+ grant: grant,+ request_token: request_token,+ debug_reason: debug_reason,+ )+ end++ def trace_and_return_result(event, result, **payload)+ UserApiKey::DeviceAuth.trace(+ event,+ **{+ request_id: request_id,+ reason: result.debug_reason,+ status: result.status,+ user_id: user&.id,+ client_id: result.grant&.client_id,+ device_code: result.device_code || result.grant&.device_code,+ request_token: result.request_token,+ }.merge(payload),+ )+ result+ end+enddiff --git a/app/services/user_api_key/expiry.rb b/app/services/user_api_key/expiry.rbnew file mode 100644index 00000000000..206dcff67d0--- /dev/null+++ b/app/services/user_api_key/expiry.rb@@ -0,0 +1,29 @@+# frozen_string_literal: true++class UserApiKey::Expiry+ MAX_EXPIRES_IN_SECONDS_DIGITS = 10++ def self.parse_seconds!(value)+ return if value.blank?++ value = value.to_s+ if value.bytesize > MAX_EXPIRES_IN_SECONDS_DIGITS || !value.match?(/\A\d+\z/)+ raise Discourse::InvalidParameters.new(:expires_in_seconds)+ end++ seconds = Integer(value, 10)+ max_seconds = SiteSetting.max_user_api_key_expiry_days.to_i.days.to_i++ if seconds <= 0 || max_seconds <= 0 || seconds > max_seconds+ raise Discourse::InvalidParameters.new(:expires_in_seconds)+ end++ seconds+ rescue ArgumentError, TypeError+ raise Discourse::InvalidParameters.new(:expires_in_seconds)+ end++ def self.requested_expires_at(expires_in_seconds)+ expires_in_seconds.present? ? Time.zone.now + expires_in_seconds.to_i.seconds : nil+ end+enddiff --git a/app/views/user_api_keys/new.html.erb b/app/views/user_api_keys/new.html.erbdeleted file mode 100644index f901cd1c89b..00000000000--- a/app/views/user_api_keys/new.html.erb+++ /dev/null@@ -1,55 +0,0 @@-<div class='authorize-api-key'>- <h1><%= t("user_api_key.title", application_name: @application_name) %></h1>-<% if @no_trust_level %>- <p class="error-message"><%= t("user_api_key.no_trust_level") %></p>-<% elsif @generic_error %>- <p class="error-message"><%= t("user_api_key.generic_error") %></p>-<% else %>-- <div class="authorize-api-key__user">- <span class="authorize-api-key__user-label"><%= t("user_api_key.logged_in_as") %></span>- <img class="avatar" src="<%= current_user.avatar_template.gsub("{size}", "24") %>" width="24" height="24" alt="">- <span class="authorize-api-key__username"><%= current_user.username %></span>- </div>-- <div class="authorize-api-key__permissions">- <p class="authorize-api-key__permissions-header"><%= t("user_api_key.permissions_header", application_name: @application_name) %></p>- <ul class='authorize-api-key__scopes'>- <%- @localized_scopes.each do |scope| %>- <li><%= scope %></li>- <%- end %>- </ul>- </div>-- <% if @scopes&.split(",")&.include?("write") %>- <div class='authorize-api-key__write-warning alert alert-warning'>- <p><%= t("user_api_key.write_scope_warning") %></p>- </div>- <% end %>-- <% if @redirect_uri %>- <div class='authorize-api-key__redirect'>- <p class="authorize-api-key__redirect-url">- <%= t("user_api_key.redirect_warning") %>- <strong><%= @redirect_uri %></strong>- </p>- </div>- <% end %>-- <%= form_tag(user_api_key_path) do %>- <%= hidden_field_tag 'application_name', @application_name %>- <%= hidden_field_tag 'access', @access %>- <%= hidden_field_tag 'nonce', @nonce %>- <%= hidden_field_tag 'client_id', @client_id %>- <%= hidden_field_tag('auth_redirect', @auth_redirect) if @auth_redirect %>- <%= hidden_field_tag 'push_url', @push_url %>- <%= hidden_field_tag 'public_key', @public_key %>- <%= hidden_field_tag 'scopes', @scopes %>- <%= hidden_field_tag('padding', @padding) if @padding %>- <div class='authorize-api-key__buttons'>- <%= submit_tag t('user_api_key.authorize'), class: 'btn btn-primary' %>- <a href="/" class='btn btn-default'><%= t('user_api_key.deny') %></a>- </div>- <% end %>-<% end %>-</div>diff --git a/app/views/user_api_keys/otp.html.erb b/app/views/user_api_keys/otp.html.erbdeleted file mode 100644index d7a7032c2c3..00000000000--- a/app/views/user_api_keys/otp.html.erb+++ /dev/null@@ -1,10 +0,0 @@-<h1><%= t("user_api_key.otp_description", application_name: @application_name) %></h1>-<div class='authorize-api-key'>-<%= form_tag(user_api_key_otp_path) do %>- <%= hidden_field_tag 'application_name', @application_name %>- <%= hidden_field_tag 'public_key', @public_key%>- <%= hidden_field_tag('auth_redirect', @auth_redirect) %>- <%= hidden_field_tag('padding', @padding) if @padding %>- <%= submit_tag t('user_api_key.authorize'), class: 'btn btn-primary' %>-<% end %>-</div>diff --git a/app/views/user_api_keys/show.html.erb b/app/views/user_api_keys/show.html.erbdeleted file mode 100644index 74faa9be1a8..00000000000--- a/app/views/user_api_keys/show.html.erb+++ /dev/null@@ -1,23 +0,0 @@-<p><%= t("user_api_key.instructions", application_name: @client.application_name) %></p>-<div class="user-api-key-display">- <code id="user-api-key-payload"><%= @payload %></code>-</div>-<div>- <button class="btn btn-primary" id="copy-api-key-btn">- <%= t("user_api_key.copy_key") %>- </button>-</div>--<script nonce="<%= csp_nonce_placeholder %>">- document.getElementById('copy-api-key-btn').addEventListener('click', function() {- const btn = this;- const payload = document.getElementById('user-api-key-payload').textContent.replace(/\s/g, '');- navigator.clipboard.writeText(payload).then(() => {- const originalText = btn.textContent;- btn.textContent = '<%= t("user_api_key.copied") %>';- setTimeout(() => {- btn.textContent = originalText;- }, 2000);- });- });-</script>diff --git a/config/locales/client.en.yml b/config/locales/client.en.ymlindex 915f38eafa8..a1d2aba0a88 100644--- a/config/locales/client.en.yml+++ b/config/locales/client.en.yml@@ -1,5 +1,34 @@en:js:+ user_api_key:+ title: 'Authorize "%{application_name}"'+ authorize: "Authorize"+ deny: "Cancel"+ logged_in_as: "Logged in as"+ permissions_header: 'This will allow "%{application_name}" to:'+ redirect_warning: "Authorizing will redirect you to"+ expiry_notice: 'This key for "%{application_name}" will expire on %{expires_at}.'+ write_scope_warning: "Full write access requested — this application will be able to post, edit, and delete content. Proceed only if you fully trust it."+ copy_key: "Copy key"+ copied: "Copied!"+ otp_description: 'Would you like to allow "%{application_name}" to access this site?'+ no_trust_level: "Sorry, you do not have the required trust level to access the user API"+ generic_error: "Sorry, we are unable to issue user API keys, this feature may be disabled by the site admin"+ device:+ title: "Authorize an application"+ enter_code: "Enter the code displayed in your application."+ code: "Code"+ enter_full_code: "Enter the complete code to authorize this application."+ continue: "Continue"+ invalid_code: "Sorry, that code is invalid. Check the code and try again."+ expired_code: "Sorry, that code has expired or has already been used. Request a new code from the application and try again."+ authorize_title: 'Authorize "%{application_name}"'+ expiry_notice: "Expires: %{expires_at}"+ no_expiry_warning: "This key will not expire automatically. Only authorize this if you fully trust the application."+ unregistered_app_warning: "This application is not registered or verified by this site. Only continue if you fully trust the source of the code."+ complete: "Authorization complete"+ denied: "Authorization denied"+ return_to_cli: "You can now return to your terminal or application."blocks:ghost:# Section titles@@ -1841,6 +1870,9 @@ en:undo_revoke_access: "Undo Revoke Access"api_approved: "Approved:"api_last_used_at: "Last used at:"+ api_expires_at: "Expires:"+ api_expired_at: "Expired:"+ api_expires_never: "never"api_show_permissions:one: "Permissions granted (%{count})"other: "Permissions granted (%{count})"diff --git a/config/locales/server.en.yml b/config/locales/server.en.ymlindex f0253361e49..c669a4a0af0 100644--- a/config/locales/server.en.yml+++ b/config/locales/server.en.yml@@ -1283,6 +1283,7 @@ en:logged_in_as: "Logged in as"permissions_header: 'This will allow "%{application_name}" to:'redirect_warning: "Authorizing will redirect you to"+ expiry_notice: 'This key for "%{application_name}" will expire on %{expires_at}.'write_scope_warning: "Full write access requested — this application will be able to post, edit, and delete content. Proceed only if you fully trust it."instructions: 'We just generated a new user API key for you to use with "%{application_name}", please paste the following key into your application:'copy_key: "Copy Key"@@ -1304,6 +1305,22 @@ en:one_time_password: "Create a one-time login token"bookmarks_calendar: "Read bookmark reminders"user_status: "Read and update user status"+ device:+ title: "Authorize an application"+ enter_code: "Enter the code displayed in your application."+ enter_full_code: "Enter the complete code to authorize this application."+ code: "Code"+ code_character: "Code character %{position}"+ continue: "Continue"+ invalid_code: "Sorry, that code is invalid. Check the code and try again."+ expired_code: "Sorry, that code has expired or has already been used. Request a new code from the application and try again."+ authorize_title: 'Authorize "%{application_name}"'+ expiry_notice: 'This key for "%{application_name}" will expire on %{expires_at}.'+ no_expiry_warning: "This key will not expire automatically. Only authorize this if you fully trust the application."+ unregistered_app_warning: "This application is not registered or verified by this site. Only continue if you fully trust the source of the code."+ complete: "Authorization complete"+ denied: "Authorization denied"+ return_to_cli: "You can now return to your terminal or application."invalid_public_key: "Sorry, the public key is invalid."invalid_auth_redirect: "Sorry, this auth_redirect host is not allowed."invalid_token: "Missing, invalid or expired token."@@ -2765,6 +2782,8 @@ en:allowed_user_api_push_urls: "Allowed URLs for server push to user API"revoke_user_api_keys_unused_days: "Number of days since a user API key was last used before it is automatically revoked (0 for never)"revoke_user_api_keys_maxlife_days: "Number of days before a user API key is automatically revoked (0 for never)"+ max_user_api_key_expiry_days: "Maximum expiry, in days, that clients can request for user API keys"+ verbose_user_api_key_device_auth_logging: "Log detailed diagnostics for the user API key device authorization flow"tagging_enabled: "Enable tags on topics? See the <a href='https://meta.discourse.org/t/admin-guide-to-tags-in-discourse/121041'>Admin guide to tags on Meta</a> for more information."create_tag_allowed_groups: "Groups that are allowed to create tags. Admins and moderators can always create tags."diff --git a/config/routes.rb b/config/routes.rbindex b087ea1a7a6..25e15019bae 100644--- a/config/routes.rb+++ b/config/routes.rb@@ -1880,6 +1880,12 @@ Discourse::Application.routes.draw doget "/user-api-key/new" => "user_api_keys#new"post "/user-api-key" => "user_api_keys#create"+ post "/user-api-key/device" => "user_api_keys#create_device_request"+ post "/user-api-key/device/poll" => "user_api_keys#poll_device_request"+ get "/user-api-key/activate" => "user_api_keys#activate"+ post "/user-api-key/activate" => "user_api_keys#activate"+ post "/user-api-key/device/authorize" => "user_api_keys#authorize_device_request"+ post "/user-api-key/device/deny" => "user_api_keys#deny_device_request"post "/user-api-key/revoke" => "user_api_keys#revoke"post "/user-api-key/undo-revoke" => "user_api_keys#undo_revoke"get "/user-api-key/otp" => "user_api_keys#otp"diff --git a/config/site_settings.yml b/config/site_settings.ymlindex c5eb3948fc8..ae7a34339c7 100644--- a/config/site_settings.yml+++ b/config/site_settings.yml@@ -4259,6 +4259,10 @@ user_api:default: 0max: 36500hidden: true+ max_user_api_key_expiry_days:+ default: 365+ max: 36500+ hidden: trueunused_registered_user_api_key_clients_days:default: 30max: 36500@@ -4267,6 +4271,9 @@ user_api:default: ""type: listhidden: true+ verbose_user_api_key_device_auth_logging:+ default: false+ hidden: truetags:tagging_enabled:diff --git a/db/migrate/20260518072818_add_expires_at_to_user_api_keys.rb b/db/migrate/20260518072818_add_expires_at_to_user_api_keys.rbnew file mode 100644index 00000000000..7084ad828ae--- /dev/null+++ b/db/migrate/20260518072818_add_expires_at_to_user_api_keys.rb@@ -0,0 +1,7 @@+# frozen_string_literal: true++class AddExpiresAtToUserApiKeys < ActiveRecord::Migration[8.0]+ def change+ add_column :user_api_keys, :expires_at, :datetime+ end+enddiff --git a/db/structure.sql b/db/structure.sqlindex 62a6878b7b2..21bf0feacdf 100644--- a/db/structure.sql+++ b/db/structure.sql@@ -10381,7 +10381,8 @@ CREATE TABLE public.user_api_keys (revoked_at timestamp without time zone,last_used_at timestamp without time zone DEFAULT CURRENT_TIMESTAMP NOT NULL,key_hash character varying NOT NULL,- user_api_key_client_id bigint+ user_api_key_client_id bigint,+ expires_at timestamp(6) without time zone);@@ -21927,6 +21928,7 @@ INSERT INTO "schema_migrations" (version) VALUES('20260522043337'),('20260520090937'),('20260518104900'),+('20260518072818'),('20260518054805'),('20260514055648'),('20260514043815'),diff --git a/frontend/discourse/app/components/user-api-key-device-code-input.gjs b/frontend/discourse/app/components/user-api-key-device-code-input.gjsnew file mode 100644index 00000000000..2db4a66fe9f--- /dev/null+++ b/frontend/discourse/app/components/user-api-key-device-code-input.gjs@@ -0,0 +1,33 @@+import Component from "@glimmer/component";+import { action } from "@ember/object";+import DOtp from "discourse/ui-kit/d-otp";+import { i18n } from "discourse-i18n";++export default class UserApiKeyDeviceCodeInput extends Component {+ @action+ normalizeCode(value) {+ return value+ .toUpperCase()+ .replace(/[^A-Z0-9]/g, "")+ .slice(0, 8);+ }++ <template>+ <DOtp+ @slots={{8}}+ @groupSize={{4}}+ @inputMode="text"+ @autocomplete="off"+ @normalizeInput={{this.normalizeCode}}+ @onChange={{@onChange}}+ @onFill={{@onFill}}+ aria-label={{i18n "user_api_key.device.code"}}+ class="authorize-api-key__code-input"+ data-1p-ignore="true"+ data-lpignore="true"+ data-bwignore="true"+ data-form-type="other"+ ...attributes+ />+ </template>+}diff --git a/frontend/discourse/app/components/user-preferences/user-api-keys.gjs b/frontend/discourse/app/components/user-preferences/user-api-keys.gjsindex ee6dfae5b9e..206f79da07c 100644--- a/frontend/discourse/app/components/user-preferences/user-api-keys.gjs+++ b/frontend/discourse/app/components/user-preferences/user-api-keys.gjs@@ -4,6 +4,7 @@ import { fn } from "@ember/helper";import { on } from "@ember/modifier";import { action } from "@ember/object";import routeAction from "discourse/helpers/route-action";+import { longDate } from "discourse/lib/formatter";import DButton from "discourse/ui-kit/d-button";import dAgeWithTooltip from "discourse/ui-kit/helpers/d-age-with-tooltip";import dIcon from "discourse/ui-kit/helpers/d-icon";@@ -12,6 +13,17 @@ import { i18n } from "discourse-i18n";class UserApiKeyRow extends Component {@tracked showScopes = false;+ get isExpired() {+ return (+ this.args.apiKey.expires_at &&+ new Date(this.args.apiKey.expires_at) <= new Date()+ );+ }++ get expiresAtDate() {+ return longDate(this.args.apiKey.expires_at);+ }+@actiontoggleScopes(event) {event?.preventDefault();@@ -31,6 +43,19 @@ class UserApiKeyRow extends Component {<span>{{i18n "user.api_last_used_at"}}</span>{{dAgeWithTooltip @apiKey.last_used_at format="medium"}}</div>+ <div class="user-api-key__date-expires">+ {{#if @apiKey.expires_at}}+ {{#if this.isExpired}}+ <span>{{i18n "user.api_expired_at"}}</span>+ {{else}}+ <span>{{i18n "user.api_expires_at"}}</span>+ {{/if}}+ {{this.expiresAtDate}}+ {{else}}+ <span>{{i18n "user.api_expires_at"}}</span>+ {{i18n "user.api_expires_never"}}+ {{/if}}+ </div></div></div>diff --git a/frontend/discourse/app/controllers/user-api-key-activate.js b/frontend/discourse/app/controllers/user-api-key-activate.jsnew file mode 100644index 00000000000..3d9870e06b2--- /dev/null+++ b/frontend/discourse/app/controllers/user-api-key-activate.js@@ -0,0 +1,145 @@+import { tracked } from "@glimmer/tracking";+import Controller from "@ember/controller";+import { action } from "@ember/object";+import { ajax } from "discourse/lib/ajax";+import { extractError } from "discourse/lib/ajax-error";+import { longDate } from "discourse/lib/formatter";+import { USER_API_KEY_DEVICE_ACTIVATION_STATES } from "discourse/lib/user-api-key-device-auth";+import { i18n } from "discourse-i18n";++const CODE_FIELD = "code";++export default class UserApiKeyActivateController extends Controller {+ @tracked page;+ @tracked error = null;+ @tracked isLoading = false;+ queryParams = ["request"];+ request = null;+ codeFormApi = null;+ codeFormData = { [CODE_FIELD]: "" };+ approvalFormData = {};++ normalizeCode(value) {+ return value?.toUpperCase().replace(/[^A-Z0-9]/g, "") || "";+ }++ reset(model) {+ this.page = model;+ this.error = null;+ this.isLoading = false;+ this.codeFormApi = null;+ }++ get showEnterCode() {+ return (+ this.page?.state === USER_API_KEY_DEVICE_ACTIVATION_STATES.ENTER_CODE+ );+ }++ get showAuthorize() {+ return this.page?.state === USER_API_KEY_DEVICE_ACTIVATION_STATES.AUTHORIZE;+ }++ get showComplete() {+ return this.page?.state === USER_API_KEY_DEVICE_ACTIVATION_STATES.COMPLETE;+ }++ get deviceExpiresAt() {+ const expiresAt = this.page?.device_auth?.expires_at;+ return expiresAt ? longDate(expiresAt) : null;+ }++ get avatarUrl() {+ return this.page?.current_user?.avatar_template?.replace("{size}", "24");+ }++ @action+ registerCodeFormApi(api) {+ this.codeFormApi = api;+ }++ @action+ validateCode(name, value, { addError }) {+ if (this.normalizeCode(value).length !== 8) {+ addError(name, {+ title: i18n("user_api_key.device.code"),+ message: i18n("user_api_key.device.enter_full_code"),+ });+ }+ }++ addCodeError(message) {+ this.codeFormApi?.addError(CODE_FIELD, {+ title: i18n("user_api_key.device.code"),+ message,+ });+ }++ showInvalidCodeError() {+ this.addCodeError(i18n("user_api_key.device.invalid_code"));+ }++ @action+ async submitCode(data) {+ this.isLoading = true;+ this.error = null;++ try {+ this.page = await ajax("/user-api-key/activate.json", {+ type: "POST",+ data: { code: this.normalizeCode(data.code) },+ });++ if (this.page.invalid_code) {+ this.showInvalidCodeError();+ }+ } catch (errorResponse) {+ this.error = extractError(errorResponse);+ } finally {+ this.isLoading = false;+ }+ }++ @action+ async approve(data) {+ await this.submitAuthorization(+ "/user-api-key/device/authorize.json",+ data?.code+ );+ }++ @action+ async approveWithApprovalToken() {+ await this.submitAuthorization("/user-api-key/device/authorize.json");+ }++ @action+ async deny(event) {+ event?.preventDefault();+ await this.submitAuthorization("/user-api-key/device/deny.json");+ }++ async submitAuthorization(url, code) {+ this.isLoading = true;+ this.error = null;++ const data = this.page.request_token+ ? {+ request: this.page.request_token,+ code: this.normalizeCode(code),+ }+ : { approval_token: this.page.approval_token };++ try {+ this.page = await ajax(url, { type: "POST", data });++ if (this.page.invalid_code) {+ this.showInvalidCodeError();+ }+ } catch (errorResponse) {+ this.error = extractError(errorResponse);+ } finally {+ this.isLoading = false;+ }+ }+}diff --git a/frontend/discourse/app/controllers/user-api-key-new.js b/frontend/discourse/app/controllers/user-api-key-new.jsnew file mode 100644index 00000000000..13dd86a5bbd--- /dev/null+++ b/frontend/discourse/app/controllers/user-api-key-new.js@@ -0,0 +1,123 @@+import { tracked } from "@glimmer/tracking";+import Controller from "@ember/controller";+import { action } from "@ember/object";+import { ajax } from "discourse/lib/ajax";+import { extractError } from "discourse/lib/ajax-error";+import { longDate } from "discourse/lib/formatter";+import DiscourseURL from "discourse/lib/url";+import { USER_API_KEY_AUTHORIZATION_STATES } from "discourse/lib/user-api-key-device-auth";+import { clipboardCopy } from "discourse/lib/utilities";++export default class UserApiKeyNewController extends Controller {+ @tracked page;+ @tracked result;+ @tracked error;+ @tracked isLoading = false;+ @tracked copied = false;+ queryParams = [+ "nonce",+ "scopes",+ "client_id",+ "application_name",+ "public_key",+ "auth_redirect",+ "push_url",+ "padding",+ "expires_in_seconds",+ ];++ reset(model) {+ this.page = model;+ this.result = null;+ this.error = null;+ this.isLoading = false;+ this.copied = false;+ }++ get ready() {+ return this.page?.state === USER_API_KEY_AUTHORIZATION_STATES.READY;+ }++ get noTrustLevel() {+ return (+ this.page?.state === USER_API_KEY_AUTHORIZATION_STATES.NO_TRUST_LEVEL+ );+ }++ get genericError() {+ return this.page?.state === USER_API_KEY_AUTHORIZATION_STATES.GENERIC_ERROR;+ }++ get avatarUrl() {+ return this.page?.current_user?.avatar_template?.replace("{size}", "24");+ }++ get expiresAt() {+ return this.page?.expires_at ? longDate(this.page.expires_at) : null;+ }++ get copyButtonLabel() {+ return this.copied ? "user_api_key.copied" : "user_api_key.copy_key";+ }++ get payloadParameters() {+ const data = {+ application_name: this.page.application_name,+ nonce: this.page.nonce,+ client_id: this.page.client_id,+ push_url: this.page.push_url,+ public_key: this.page.public_key,+ scopes: this.page.scopes,+ };++ if (this.page.auth_redirect) {+ data.auth_redirect = this.page.auth_redirect;+ }+ if (this.page.padding) {+ data.padding = this.page.padding;+ }+ if (this.page.expires_in_seconds) {+ data.expires_in_seconds = this.page.expires_in_seconds;+ }++ return data;+ }++ @action+ async copy() {+ try {+ await clipboardCopy(this.result.payload?.replace(/\s/g, ""));+ this.copied = true;+ } catch {+ this.copied = false;+ }++ if (this.copied) {+ setTimeout(() => (this.copied = false), 2000);+ }+ }++ @action+ async authorize(event) {+ event?.preventDefault();+ this.isLoading = true;+ this.error = null;++ try {+ const response = await ajax("/user-api-key.json", {+ type: "POST",+ data: this.payloadParameters,+ });++ if (response.redirect_url) {+ DiscourseURL.routeTo(response.redirect_url);+ } else {+ this.result = response;+ }+ } catch (errorResponse) {+ this.error = extractError(errorResponse);+ } finally {+ this.isLoading = false;+ }+ }+}diff --git a/frontend/discourse/app/controllers/user-api-key-otp.js b/frontend/discourse/app/controllers/user-api-key-otp.jsnew file mode 100644index 00000000000..570b23aff28--- /dev/null+++ b/frontend/discourse/app/controllers/user-api-key-otp.js@@ -0,0 +1,45 @@+import { tracked } from "@glimmer/tracking";+import Controller from "@ember/controller";+import { action } from "@ember/object";+import { ajax } from "discourse/lib/ajax";+import { extractError } from "discourse/lib/ajax-error";+import DiscourseURL from "discourse/lib/url";++export default class UserApiKeyOtpController extends Controller {+ @tracked error;+ @tracked isLoading = false;+ queryParams = ["application_name", "public_key", "auth_redirect", "padding"];++ get payloadParameters() {+ const data = {+ application_name: this.model.application_name,+ public_key: this.model.public_key,+ auth_redirect: this.model.auth_redirect,+ };++ if (this.model.padding) {+ data.padding = this.model.padding;+ }++ return data;+ }++ @action+ async authorize(event) {+ event?.preventDefault();+ this.isLoading = true;+ this.error = null;++ try {+ const response = await ajax("/user-api-key/otp.json", {+ type: "POST",+ data: this.payloadParameters,+ });+ DiscourseURL.routeTo(response.redirect_url);+ } catch (errorResponse) {+ this.error = extractError(errorResponse);+ } finally {+ this.isLoading = false;+ }+ }+}diff --git a/frontend/discourse/app/controllers/user-api-key-result.js b/frontend/discourse/app/controllers/user-api-key-result.jsnew file mode 100644index 00000000000..3c68df9dc90--- /dev/null+++ b/frontend/discourse/app/controllers/user-api-key-result.js@@ -0,0 +1,29 @@+import { tracked } from "@glimmer/tracking";+import Controller from "@ember/controller";+import { action } from "@ember/object";+import { clipboardCopy } from "discourse/lib/utilities";+import { i18n } from "discourse-i18n";++export default class UserApiKeyResultController extends Controller {+ @tracked copied = false;++ get buttonLabel() {+ return this.copied+ ? i18n("user_api_key.copied")+ : i18n("user_api_key.copy_key");+ }++ @action+ async copy() {+ try {+ await clipboardCopy(this.model.payload?.replace(/\s/g, ""));+ this.copied = true;+ } catch {+ this.copied = false;+ }++ if (this.copied) {+ setTimeout(() => (this.copied = false), 2000);+ }+ }+}diff --git a/frontend/discourse/app/lib/user-api-key-device-auth.js b/frontend/discourse/app/lib/user-api-key-device-auth.jsnew file mode 100644index 00000000000..f7d3c88edb0--- /dev/null+++ b/frontend/discourse/app/lib/user-api-key-device-auth.js@@ -0,0 +1,20 @@+export const USER_API_KEY_AUTHORIZATION_STATES = {+ READY: "ready",+ NO_TRUST_LEVEL: "no_trust_level",+ GENERIC_ERROR: "generic_error",+};++// Keep these values in sync with `UserApiKey::DeviceAuth` state/status constants.+export const USER_API_KEY_DEVICE_ACTIVATION_STATES = {+ ENTER_CODE: "enter_code",+ AUTHORIZE: "authorize",+ COMPLETE: "complete",+};++// CLI poll statuses returned by `/user-api-key/device/poll.json`.+export const USER_API_KEY_DEVICE_POLL_STATUSES = {+ AUTHORIZATION_PENDING: "authorization_pending",+ AUTHORIZED: "authorized",+ ACCESS_DENIED: "access_denied",+ EXPIRED_TOKEN: "expired_token",+};diff --git a/frontend/discourse/app/routes/app-route-map.js b/frontend/discourse/app/routes/app-route-map.jsindex f99c3565ec1..b2b03bfb08f 100644--- a/frontend/discourse/app/routes/app-route-map.js+++ b/frontend/discourse/app/routes/app-route-map.js@@ -202,6 +202,10 @@ export default function () {this.route("login");this.route("email-login", { path: "/session/email-login/:token" });this.route("second-factor-auth", { path: "/session/2fa" });+ this.route("user-api-key-new", { path: "/user-api-key/new" });+ this.route("user-api-key-result", { path: "/user-api-key" });+ this.route("user-api-key-activate", { path: "/user-api-key/activate" });+ this.route("user-api-key-otp", { path: "/user-api-key/otp" });this.route("associate-account", { path: "/associate/:token" });this.route("login-preferences");this.route("forgot-password", { path: "/password-reset" });diff --git a/frontend/discourse/app/routes/user-api-key-activate.js b/frontend/discourse/app/routes/user-api-key-activate.jsnew file mode 100644index 00000000000..a3e3a657821--- /dev/null+++ b/frontend/discourse/app/routes/user-api-key-activate.js@@ -0,0 +1,22 @@+import { ajax } from "discourse/lib/ajax";+import PreloadStore from "discourse/lib/preload-store";+import DiscourseRoute from "discourse/routes/discourse";++export default class UserApiKeyActivateRoute extends DiscourseRoute {+ queryParams = {+ request: { refreshModel: true },+ };++ model() {+ if (PreloadStore.data.has("user_api_key_device_activation")) {+ return PreloadStore.getAndRemove("user_api_key_device_activation");+ }++ return ajax(`/user-api-key/activate.json${window.location.search}`);+ }++ setupController(controller, model) {+ super.setupController(controller, model);+ controller.reset(model);+ }+}diff --git a/frontend/discourse/app/routes/user-api-key-new.js b/frontend/discourse/app/routes/user-api-key-new.jsnew file mode 100644index 00000000000..0fa67c49cef--- /dev/null+++ b/frontend/discourse/app/routes/user-api-key-new.js@@ -0,0 +1,35 @@+import { ajax } from "discourse/lib/ajax";+import PreloadStore from "discourse/lib/preload-store";+import { USER_API_KEY_AUTHORIZATION_STATES } from "discourse/lib/user-api-key-device-auth";+import DiscourseRoute from "discourse/routes/discourse";++export default class UserApiKeyNewRoute extends DiscourseRoute {+ queryParams = {+ nonce: { refreshModel: true },+ scopes: { refreshModel: true },+ client_id: { refreshModel: true },+ application_name: { refreshModel: true },+ public_key: { refreshModel: true },+ auth_redirect: { refreshModel: true },+ push_url: { refreshModel: true },+ padding: { refreshModel: true },+ expires_in_seconds: { refreshModel: true },+ };++ model() {+ if (PreloadStore.data.has("user_api_key_authorization")) {+ return PreloadStore.getAndRemove("user_api_key_authorization");+ }++ return ajax(`/user-api-key/new.json${window.location.search}`).catch(+ () => ({+ state: USER_API_KEY_AUTHORIZATION_STATES.GENERIC_ERROR,+ })+ );+ }++ setupController(controller, model) {+ super.setupController(controller, model);+ controller.reset(model);+ }+}diff --git a/frontend/discourse/app/routes/user-api-key-otp.js b/frontend/discourse/app/routes/user-api-key-otp.jsnew file mode 100644index 00000000000..5396c52d3ce--- /dev/null+++ b/frontend/discourse/app/routes/user-api-key-otp.js@@ -0,0 +1,20 @@+import { ajax } from "discourse/lib/ajax";+import PreloadStore from "discourse/lib/preload-store";+import DiscourseRoute from "discourse/routes/discourse";++export default class UserApiKeyOtpRoute extends DiscourseRoute {+ queryParams = {+ application_name: { refreshModel: true },+ public_key: { refreshModel: true },+ auth_redirect: { refreshModel: true },+ padding: { refreshModel: true },+ };++ model() {+ if (PreloadStore.data.has("user_api_key_otp")) {+ return PreloadStore.getAndRemove("user_api_key_otp");+ }++ return ajax(`/user-api-key/otp.json${window.location.search}`);+ }+}diff --git a/frontend/discourse/app/routes/user-api-key-result.js b/frontend/discourse/app/routes/user-api-key-result.jsnew file mode 100644index 00000000000..1ea4c10c098--- /dev/null+++ b/frontend/discourse/app/routes/user-api-key-result.js@@ -0,0 +1,12 @@+import PreloadStore from "discourse/lib/preload-store";+import DiscourseRoute from "discourse/routes/discourse";++export default class UserApiKeyResultRoute extends DiscourseRoute {+ model() {+ if (PreloadStore.data.has("user_api_key_result")) {+ return PreloadStore.getAndRemove("user_api_key_result");+ }++ return {};+ }+}diff --git a/frontend/discourse/app/templates/user-api-key-activate.gjs b/frontend/discourse/app/templates/user-api-key-activate.gjsnew file mode 100644index 00000000000..a322e4664dd--- /dev/null+++ b/frontend/discourse/app/templates/user-api-key-activate.gjs@@ -0,0 +1,219 @@+import Form from "discourse/components/form";+import UserApiKeyDeviceCodeInput from "discourse/components/user-api-key-device-code-input";+import hideApplicationFooter from "discourse/helpers/hide-application-footer";+import hideApplicationSidebar from "discourse/helpers/hide-application-sidebar";+import DButton from "discourse/ui-kit/d-button";+import { i18n } from "discourse-i18n";++export default <template>+ {{hideApplicationSidebar}}+ {{hideApplicationFooter}}++ <div class="authorize-api-key">+ {{#if @controller.showComplete}}+ {{#if @controller.page.denied}}+ <h1>{{i18n "user_api_key.device.denied"}}</h1>+ {{else}}+ <h1>{{i18n "user_api_key.device.complete"}}</h1>+ {{/if}}++ <p>{{i18n "user_api_key.device.return_to_cli"}}</p>+ {{else if @controller.showAuthorize}}+ <h1>+ {{i18n+ "user_api_key.device.authorize_title"+ [email protected]_auth.application_name+ }}+ </h1>++ {{#if @controller.page.expired_code}}+ <p class="error-message">{{i18n "user_api_key.device.expired_code"}}</p>+ {{/if}}++ {{#if @controller.error}}+ <p class="error-message">{{@controller.error}}</p>+ {{/if}}++ {{#if @controller.page.no_trust_level}}+ <p class="error-message">{{i18n "user_api_key.no_trust_level"}}</p>+ {{else}}+ <div class="authorize-api-key__user">+ <span class="authorize-api-key__user-label">+ {{i18n "user_api_key.logged_in_as"}}+ </span>+ <img+ class="avatar"+ src={{@controller.avatarUrl}}+ width="24"+ height="24"+ alt=""+ />+ <span class="authorize-api-key__username">+ {{@controller.page.current_user.username}}+ </span>+ </div>++ <div class="authorize-api-key__summary">+ <div class="authorize-api-key__permissions">+ <p class="authorize-api-key__permissions-header">+ {{i18n+ "user_api_key.permissions_header"+ [email protected]_auth.application_name+ }}+ </p>+ <ul class="authorize-api-key__scopes">+ {{#each @controller.page.device_auth.localized_scopes as |scope|}}+ <li>{{scope}}</li>+ {{/each}}+ </ul>+ </div>++ {{#if @controller.page.device_auth.write_scope}}+ <div+ class="authorize-api-key__write-warning authorize-api-key__summary-notice"+ >+ <p>{{i18n "user_api_key.write_scope_warning"}}</p>+ </div>+ {{/if}}++ {{#if @controller.page.device_auth.unregistered_client}}+ <div+ class="authorize-api-key__unregistered-warning authorize-api-key__summary-notice"+ >+ <p>{{i18n "user_api_key.device.unregistered_app_warning"}}</p>+ </div>+ {{/if}}++ {{#if @controller.deviceExpiresAt}}+ <div+ class="authorize-api-key__expiry authorize-api-key__summary-detail"+ >+ <p>+ {{i18n+ "user_api_key.device.expiry_notice"+ [email protected]_auth.application_name+ }}+ </p>+ </div>+ {{else}}+ <div+ class="authorize-api-key__expiry-warning authorize-api-key__summary-notice"+ >+ <p>{{i18n "user_api_key.device.no_expiry_warning"}}</p>+ </div>+ {{/if}}+ </div>++ {{#unless @controller.page.expired_code}}+ {{#if @controller.page.request_token}}+ <Form+ @data={{@controller.codeFormData}}+ @onSubmit={{@controller.approve}}+ @onRegisterApi={{@controller.registerCodeFormApi}}+ class="authorize-api-key__code-form"+ as |form|+ >+ <form.Field+ @name="code"+ @title={{i18n "user_api_key.device.code"}}+ @description={{i18n "user_api_key.device.enter_code"}}+ @showOptional={{false}}+ @format="full"+ @type="custom"+ @validate={{@controller.validateCode}}+ as |field|+ >+ <field.Control>+ <UserApiKeyDeviceCodeInput+ id={{field.id}}+ @onChange={{field.set}}+ @onFill={{field.set}}+ aria-describedby={{field.describedBy}}+ aria-invalid={{if field.error "true" "false"}}+ />+ </field.Control>+ </form.Field>++ <form.Actions>+ <form.Submit+ @label="user_api_key.authorize"+ @disabled={{@controller.isLoading}}+ />+ </form.Actions>+ </Form>+ {{else}}+ <div class="authorize-api-key__buttons">+ <Form+ @data={{@controller.approvalFormData}}+ @onSubmit={{@controller.approveWithApprovalToken}}+ as |form|+ >+ <form.Actions>+ <form.Submit+ @label="user_api_key.authorize"+ @disabled={{@controller.isLoading}}+ />+ </form.Actions>+ </Form>+ <DButton+ @disabled={{@controller.isLoading}}+ @action={{@controller.deny}}+ @label="user_api_key.deny"+ class="btn-default"+ />+ </div>+ {{/if}}+ {{/unless}}+ {{/if}}+ {{else}}+ <h1>{{i18n "user_api_key.device.title"}}</h1>++ {{#if @controller.page.expired_code}}+ <p class="error-message">{{i18n "user_api_key.device.expired_code"}}</p>+ {{/if}}++ {{#if @controller.error}}+ <p class="error-message">{{@controller.error}}</p>+ {{/if}}++ {{#unless @controller.page.expired_code}}+ <Form+ @data={{@controller.codeFormData}}+ @onSubmit={{@controller.submitCode}}+ @onRegisterApi={{@controller.registerCodeFormApi}}+ class="authorize-api-key__code-form"+ as |form|+ >+ <form.Field+ @name="code"+ @title={{i18n "user_api_key.device.code"}}+ @description={{i18n "user_api_key.device.enter_code"}}+ @showOptional={{false}}+ @format="full"+ @type="custom"+ @validate={{@controller.validateCode}}+ as |field|+ >+ <field.Control>+ <UserApiKeyDeviceCodeInput+ id={{field.id}}+ @onChange={{field.set}}+ @onFill={{field.set}}+ aria-describedby={{field.describedBy}}+ aria-invalid={{if field.error "true" "false"}}+ />+ </field.Control>+ </form.Field>++ <form.Actions>+ <form.Submit+ @label="user_api_key.device.continue"+ @disabled={{@controller.isLoading}}+ />+ </form.Actions>+ </Form>+ {{/unless}}+ {{/if}}+ </div>+</template>diff --git a/frontend/discourse/app/templates/user-api-key-new.gjs b/frontend/discourse/app/templates/user-api-key-new.gjsnew file mode 100644index 00000000000..9648ca9b58d--- /dev/null+++ b/frontend/discourse/app/templates/user-api-key-new.gjs@@ -0,0 +1,124 @@+import { on } from "@ember/modifier";+import hideApplicationFooter from "discourse/helpers/hide-application-footer";+import hideApplicationSidebar from "discourse/helpers/hide-application-sidebar";+import DButton from "discourse/ui-kit/d-button";+import { i18n } from "discourse-i18n";++export default <template>+ {{hideApplicationSidebar}}+ {{hideApplicationFooter}}++ <div class="authorize-api-key">+ {{#if @controller.result}}+ <p>{{@controller.result.instructions}}</p>+ <div class="user-api-key-display">+ <code id="user-api-key-payload">{{@controller.result.payload}}</code>+ </div>+ <div>+ <DButton+ @action={{@controller.copy}}+ @translatedLabel={{i18n @controller.copyButtonLabel}}+ id="copy-api-key-btn"+ class="btn-primary"+ />+ </div>+ {{else}}+ <h1>+ {{#if @controller.page.application_name}}+ {{i18n+ "user_api_key.title"+ [email protected]_name+ }}+ {{else}}+ {{i18n "user_api_key.device.title"}}+ {{/if}}+ </h1>++ {{#if @controller.noTrustLevel}}+ <p class="error-message">{{i18n "user_api_key.no_trust_level"}}</p>+ {{else if @controller.genericError}}+ <p class="error-message">{{i18n "user_api_key.generic_error"}}</p>+ {{else}}+ {{#if @controller.error}}+ <p class="error-message">{{@controller.error}}</p>+ {{/if}}++ <div class="authorize-api-key__user">+ <span class="authorize-api-key__user-label">+ {{i18n "user_api_key.logged_in_as"}}+ </span>+ <img+ class="avatar"+ src={{@controller.avatarUrl}}+ width="24"+ height="24"+ alt=""+ />+ <span class="authorize-api-key__username">+ {{@controller.page.current_user.username}}+ </span>+ </div>++ <div class="authorize-api-key__summary">+ <div class="authorize-api-key__permissions">+ <p class="authorize-api-key__permissions-header">+ {{i18n+ "user_api_key.permissions_header"+ [email protected]_name+ }}+ </p>+ <ul class="authorize-api-key__scopes">+ {{#each @controller.page.localized_scopes as |scope|}}+ <li>{{scope}}</li>+ {{/each}}+ </ul>+ </div>++ {{#if @controller.page.write_scope}}+ <div+ class="authorize-api-key__write-warning authorize-api-key__summary-notice"+ >+ <p>{{i18n "user_api_key.write_scope_warning"}}</p>+ </div>+ {{/if}}++ {{#if @controller.expiresAt}}+ <div+ class="authorize-api-key__expiry authorize-api-key__summary-detail"+ >+ <p>+ {{i18n+ "user_api_key.expiry_notice"+ [email protected]_name+ }}+ </p>+ </div>+ {{/if}}+ </div>++ {{#if @controller.page.redirect_uri}}+ <div class="authorize-api-key__redirect">+ <p class="authorize-api-key__redirect-url">+ {{i18n "user_api_key.redirect_warning"}}+ <strong>{{@controller.page.redirect_uri}}</strong>+ </p>+ </div>+ {{/if}}++ <form {{on "submit" @controller.authorize}}>+ <div class="authorize-api-key__buttons">+ <DButton+ @isLoading={{@controller.isLoading}}+ @action={{@controller.authorize}}+ @label="user_api_key.authorize"+ type="submit"+ class="btn-primary"+ />+ <DButton @href="/" @label="user_api_key.deny" class="btn-default" />+ </div>+ </form>+ {{/if}}+ {{/if}}+ </div>+</template>diff --git a/frontend/discourse/app/templates/user-api-key-otp.gjs b/frontend/discourse/app/templates/user-api-key-otp.gjsnew file mode 100644index 00000000000..cf13510c754--- /dev/null+++ b/frontend/discourse/app/templates/user-api-key-otp.gjs@@ -0,0 +1,33 @@+import { on } from "@ember/modifier";+import hideApplicationFooter from "discourse/helpers/hide-application-footer";+import hideApplicationSidebar from "discourse/helpers/hide-application-sidebar";+import DButton from "discourse/ui-kit/d-button";+import { i18n } from "discourse-i18n";++export default <template>+ {{hideApplicationSidebar}}+ {{hideApplicationFooter}}++ <div class="authorize-api-key">+ <h1>+ {{i18n+ "user_api_key.otp_description"+ [email protected]_name+ }}+ </h1>++ {{#if @controller.error}}+ <p class="error-message">{{@controller.error}}</p>+ {{/if}}++ <form {{on "submit" @controller.authorize}}>+ <DButton+ @isLoading={{@controller.isLoading}}+ @action={{@controller.authorize}}+ @label="user_api_key.authorize"+ type="submit"+ class="btn-primary"+ />+ </form>+ </div>+</template>diff --git a/frontend/discourse/app/templates/user-api-key-result.gjs b/frontend/discourse/app/templates/user-api-key-result.gjsnew file mode 100644index 00000000000..92094f5c91b--- /dev/null+++ b/frontend/discourse/app/templates/user-api-key-result.gjs@@ -0,0 +1,23 @@+import hideApplicationFooter from "discourse/helpers/hide-application-footer";+import hideApplicationSidebar from "discourse/helpers/hide-application-sidebar";+import DButton from "discourse/ui-kit/d-button";++export default <template>+ {{hideApplicationSidebar}}+ {{hideApplicationFooter}}++ <div class="authorize-api-key">+ <p>{{@model.instructions}}</p>+ <div class="user-api-key-display">+ <code id="user-api-key-payload">{{@model.payload}}</code>+ </div>+ <div>+ <DButton+ @action={{@controller.copy}}+ @translatedLabel={{@controller.buttonLabel}}+ id="copy-api-key-btn"+ class="btn-primary"+ />+ </div>+ </div>+</template>diff --git a/frontend/discourse/app/ui-kit/d-otp/index.gjs b/frontend/discourse/app/ui-kit/d-otp/index.gjsindex aa1c41eb1af..59efbb86471 100644--- a/frontend/discourse/app/ui-kit/d-otp/index.gjs+++ b/frontend/discourse/app/ui-kit/d-otp/index.gjs@@ -21,9 +21,13 @@ const DEFAULT_SLOTS = 6;* @property {object} Args** @property {number} [Args.slots] - Number of OTP input slots to display (defaults to 6)- * @property {boolean} [Args.autoFocus] - Whether to autoFocus the input on mount (defaults to true)- * @property {function(string): void} [Args.onChange] - Callback invoked whenever the OTP value changes- * @property {function(string): void} [Args.onFill] - Callback invoked when all OTP slots are filled+ * @property {string} [Args.inputMode] - The inputmode attribute for the hidden input (defaults to "numeric")+ * @property {string} [Args.autocomplete] - The autocomplete attribute for the hidden input (defaults to "one-time-code")+ * @property {boolean} [Args.autoFocus] - Focus the input automatically unless disabled or on iOS+ * @property {function(string): string} [Args.normalizeInput] - Callback used to normalize typed or pasted input+ * @property {function(string): void} [Args.onChange] - Callback fired when the input value changes+ * @property {function(string): void} [Args.onFill] - Callback fired when all slots become filled+ * @property {number} [Args.groupSize] - Adds a visual separator after every groupSize slots**/@@ -48,6 +52,43 @@ export default class DOTP extends Component {return (this.args.autoFocus ?? true) && !this.capabilities.isIOS;}+ get inputMode() {+ return this.args.inputMode ?? "numeric";+ }++ get autocomplete() {+ return this.args.autocomplete ?? "one-time-code";+ }++ get groupSize() {+ return this.args.groupSize;+ }++ get maxLength() {+ if (!this.groupSize) {+ return this.slots;+ }++ return this.slots + Math.floor((this.slots - 1) / this.groupSize);+ }++ normalizeInput(value) {+ if (this.args.normalizeInput) {+ return this.args.normalizeInput(value);+ }++ return value.replace(/[^0-9]/g, "");+ }++ @action+ showSeparator(index) {+ return (+ this.groupSize &&+ index < this.otp.length - 1 &&+ (index + 1) % this.groupSize === 0+ );+ }+get isFilled() {return this.otp.every((char) => !isBlank(char));}@@ -78,19 +119,21 @@ export default class DOTP extends Component {*/@actiononInput(event) {- const chars = /** @type(HTMLInputElement) */ (event.target).value.split("");+ const chars = this.normalizeInput(+ /** @type(HTMLInputElement) */ (event.target).value+ )+ .split("")+ .slice(0, this.otp.length);const wasFilled = this.isFilled;- if (wasFilled && chars.length >= this.otp.length) {- return;- }-for (let i = 0; i < this.otp.length; i++) {this.otp[i] = chars[i] || "";}const joinedOtp = this.otp.join("");+ /** @type(HTMLInputElement) */ (event.target).value = joinedOtp;+this.args.onChange?.(joinedOtp);// Check if just became filled and call callback@@ -153,7 +196,7 @@ export default class DOTP extends Component {}const pastedData = clipboardData.getData("text");- input.value = pastedData.replace(/[^0-9]/g, "");+ input.value = this.normalizeInput(pastedData);// @ts-ignorethis.onInput({ target: input });}@@ -186,17 +229,23 @@ export default class DOTP extends Component {@char={{char}}@isFocused={{this.isFocusedSlot index}}/>+ {{#if (this.showSeparator index)}}+ <span class="d-otp-separator" aria-hidden="true">-</span>+ {{/if}}{{/each}}</div><div class="d-otp-input-wrapper"><input{{preventScrollOnFocus}}- inputmode="numeric"- autocomplete="one-time-code"+ inputmode={{this.inputMode}}+ autocomplete={{this.autocomplete}}+ spellcheck="false"+ autocorrect="off"+ autocapitalize="off"data-slot="input-otp"class="d-otp-input"- maxlength={{this.slots}}+ maxlength={{this.maxLength}}{{on "input" this.onInput}}{{on "select" this.onSelect}}{{on "keydown" this.onKeyDown}}diff --git a/frontend/discourse/tests/integration/ui-kit/d-otp-test.gjs b/frontend/discourse/tests/integration/ui-kit/d-otp-test.gjsindex a015fe309ee..7de76cbf455 100644--- a/frontend/discourse/tests/integration/ui-kit/d-otp-test.gjs+++ b/frontend/discourse/tests/integration/ui-kit/d-otp-test.gjs@@ -152,6 +152,67 @@ module("Integration | ui-kit | DOtp", function (hooks) {assert.dom(".d-otp-slot:nth-child(6)").hasText(" 6");});+ test("supports custom normalization and grouped slots", async function (assert) {+ this.normalizeInput = (value) =>+ value.toUpperCase().replace(/[^A-Z0-9]/g, "");++ await render(+ <template>+ <DOtp+ @slots={{8}}+ @groupSize={{4}}+ @inputMode="text"+ @autocomplete="off"+ @normalizeInput={{this.normalizeInput}}+ />+ </template>+ );++ const input = this.element.querySelector(".d-otp-input");+ const pasteEvent = new Event("paste", { bubbles: true });+ pasteEvent.clipboardData = {+ getData: () => "ab12-cd34",+ };+ input.dispatchEvent(pasteEvent);++ await settled();++ assert.dom(".d-otp-slot").exists({ count: 8 });+ assert.dom(".d-otp-separator").exists({ count: 1 });+ assert.dom(".d-otp-input").hasAttribute("inputmode", "text");+ assert.dom(".d-otp-input").hasAttribute("autocomplete", "off");+ assert.dom(".d-otp-input").hasAttribute("spellcheck", "false");+ assert.dom(".d-otp-input").hasAttribute("autocorrect", "off");+ assert.dom(".d-otp-input").hasAttribute("autocapitalize", "off");+ assert.dom(".d-otp-slot[data-index='0']").hasText(" A");+ assert.dom(".d-otp-slot[data-index='7']").hasText(" 4");+ });++ test("allows editing after all slots are filled", async function (assert) {+ this.set("value", null);+ this.onChangeCallback = (value) => {+ this.set("value", value);+ };++ await render(+ <template><DOtp @onChange={{this.onChangeCallback}} /></template>+ );++ const input = this.element.querySelector(".d-otp-input");+ input.value = "123456";+ input.dispatchEvent(new Event("input"));++ await settled();++ input.value = "12345";+ input.dispatchEvent(new Event("input"));++ await settled();++ assert.strictEqual(this.value, "12345");+ assert.dom(".d-otp-slot:nth-child(6)").hasText(" ");+ });+test("removes all content when all is selected and backspace is pressed", async function (assert) {await render(<template><DOtp /></template>);diff --git a/lib/tasks/user_api_key.rake b/lib/tasks/user_api_key.rakenew file mode 100644index 00000000000..ef25c52a599--- /dev/null+++ b/lib/tasks/user_api_key.rake@@ -0,0 +1,316 @@+# frozen_string_literal: true++require "base64"+require "cgi"+require "fileutils"+require "json"+require "net/http"+require "net/https"+require "openssl"+require "securerandom"+require "uri"++module UserApiKeyDeviceAuthRake+ class << self+ def run+ if ENV["HELP"].present?+ puts usage+ return+ end++ site =+ (ENV["SITE"].presence || Discourse.base_url.presence || "http://localhost:3000").chomp("/")+ scopes = ENV.fetch("SCOPES", "read")+ application_name = ENV.fetch("APPLICATION_NAME", "Discourse user API key device auth test")+ client_id = ENV.fetch("CLIENT_ID", "discourse-rake-device-auth")+ padding = ENV.fetch("PADDING", "oaep")+ poll_interval = ENV.fetch("POLL_INTERVAL", "5").to_i+ timeout = ENV.fetch("TIMEOUT", "600").to_i+ verify = ENV.fetch("VERIFY", "1") != "0"+ verbose = verbose?+ expires_in_seconds = requested_expiry_seconds++ private_key = OpenSSL::PKey::RSA.new(2048)+ nonce = SecureRandom.hex+ request_body = {+ application_name: application_name,+ client_id: client_id,+ scopes: scopes,+ public_key: private_key.public_key.to_pem,+ nonce: nonce,+ padding: padding,+ }+ request_body[:expires_in_seconds] = expires_in_seconds if expires_in_seconds++ _, device_response =+ json_request(:post, url_for(site, "/user-api-key/device.json"), body: request_body)+ interval = [poll_interval, device_response["interval"].to_i].max++ device_url =+ device_response["verification_uri_with_request"] || device_response["verification_uri"]++ device_code = device_response["device_code"]+ abort "Device authorization response did not include a device_code." if device_code.blank?+ fingerprint = device_code_fingerprint(device_code)++ puts "Open this URL in your browser: #{device_url}"+ puts "Enter this code when prompted: #{device_response["user_code"]}"+ log("Device code fingerprint: #{fingerprint} (matches verbose server logs)", verbose: verbose)+ puts "Waiting for authorization..."++ payload =+ poll_for_payload(+ site,+ device_code,+ interval,+ timeout,+ verbose: verbose,+ device_code_fingerprint: fingerprint,+ )+ decrypted_payload = decrypt_payload(payload, private_key, padding)++ if decrypted_payload["nonce"] != nonce+ abort "The encrypted payload nonce did not match the request nonce."+ end++ result = {+ site: site,+ user_api_key: decrypted_payload.fetch("key"),+ user_api_client_id: client_id,+ scopes: scopes.split(","),+ expires_at: decrypted_payload["expires_at"],+ }++ result[:verified] = verify_key(site, result[:user_api_key], client_id) if verify+ write_profile(ENV["OUTPUT"], site, result[:user_api_key], client_id) if ENV["OUTPUT"].present?++ puts JSON.pretty_generate(result)+ end++ def usage+ <<~TEXT+ Request a User API Key using the device authorization flow.++ Usage:+ bin/rake user_api_key:device_auth [SITE=http://localhost:3000] [SCOPES=read,write] [EXPIRES_IN=1d]++ Environment variables:+ SITE Discourse site URL. Defaults to Discourse.base_url.+ SCOPES Comma-separated scopes. Defaults to read.+ APPLICATION_NAME Name shown to the authorizing user.+ CLIENT_ID User API client id. Defaults to discourse-rake-device-auth.+ EXPIRES_IN Human duration, e.g. 1d, 12h, 30m, or integer seconds.+ EXPIRES_IN_SECONDS Exact expiry duration in seconds. Overrides EXPIRES_IN.+ PADDING RSA padding mode. Defaults to oaep.+ OUTPUT Optional path for a profile JSON file.+ POLL_INTERVAL Poll interval in seconds. Defaults to 5.+ TIMEOUT Poll timeout in seconds. Defaults to 600.+ VERIFY Set to 0 to skip /session/current.json verification.+ VERBOSE Set to 1 to print poll attempts, status changes, and correlation IDs.+ HELP Set to 1 to show this help.+ TEXT+ end++ def verbose?+ ENV["VERBOSE"] == "1"+ end++ def log(message, verbose: verbose?)+ puts message if verbose+ end++ def device_code_fingerprint(device_code)+ UserApiKey::DeviceAuth.trace_id_for(device_code)+ end++ def requested_expiry_seconds+ if ENV["EXPIRES_IN_SECONDS"].present?+ seconds = Integer(ENV["EXPIRES_IN_SECONDS"], 10)+ abort "EXPIRES_IN_SECONDS must be positive." if seconds <= 0+ return seconds+ end++ parse_duration(ENV["EXPIRES_IN"]) if ENV["EXPIRES_IN"].present?+ rescue ArgumentError+ abort "EXPIRES_IN_SECONDS must be an integer number of seconds."+ end++ def parse_duration(value)+ duration = value.to_s.strip.downcase+ if duration.match?(/\A\d+\z/)+ seconds = Integer(duration, 10)+ abort "EXPIRES_IN must be positive." if seconds <= 0+ return seconds+ end++ match = duration.match(/\A(\d+)([smhd])\z/)+ if match.blank?+ abort "EXPIRES_IN must be an integer number of seconds or a duration like 1d, 12h, or 30m."+ end++ amount = match[1].to_i+ multiplier = { "s" => 1, "m" => 60, "h" => 3600, "d" => 86_400 }.fetch(match[2])+ seconds = amount * multiplier+ abort "EXPIRES_IN must be positive." if seconds <= 0+ seconds+ end++ def url_for(site, path, query = nil)+ uri = URI("#{site.chomp("/")}/#{path.sub(%r{\A/}, "")}")+ uri.query = URI.encode_www_form(query) if query.present?+ uri+ end++ def json_request(method, uri, body: nil, headers: {})+ request =+ case method+ when :get+ Net::HTTP::Get.new(uri)+ when :post+ Net::HTTP::Post.new(uri)+ else+ raise ArgumentError, "Unsupported HTTP method: #{method}"+ end++ request["Accept"] = "application/json"+ headers.each { |name, value| request[name] = value }++ if body+ request.content_type = "application/json"+ request.body = JSON.generate(body)+ end++ response =+ Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|+ http.request(request)+ end++ parsed = response.body.present? ? JSON.parse(response.body) : {}+ unless response.is_a?(Net::HTTPSuccess)+ abort "Request to #{uri} failed with HTTP #{response.code}: #{response.body}"+ end++ [response, parsed]+ rescue JSON::ParserError+ abort "Request to #{uri} did not return JSON: #{response&.body}"+ rescue Errno::ECONNREFUSED, SocketError, OpenSSL::SSL::SSLError => e+ abort "Request to #{uri} failed: #{e.message}"+ end++ def poll_for_payload(site, device_code, interval, timeout, verbose:, device_code_fingerprint:)+ started_at = Time.now+ deadline = started_at + timeout+ attempt = 0+ previous_status = nil++ loop do+ if Time.now >= deadline+ abort "Timed out waiting for authorization#{correlation_suffix(device_code_fingerprint)}."+ end++ attempt += 1+ _, response =+ json_request(+ :post,+ url_for(site, "/user-api-key/device/poll.json"),+ body: {+ device_code: device_code,+ },+ )++ status = response["status"]+ log_poll_attempt(+ attempt: attempt,+ status: status,+ previous_status: previous_status,+ started_at: started_at,+ deadline: deadline,+ interval: interval,+ device_code_fingerprint: device_code_fingerprint,+ verbose: verbose,+ )+ previous_status = status++ case status+ when UserApiKey::DeviceAuth::POLL_STATUS_AUTHORIZATION_PENDING+ sleep interval+ when UserApiKey::DeviceAuth::POLL_STATUS_AUTHORIZED+ return response.fetch("payload")+ when UserApiKey::DeviceAuth::POLL_STATUS_ACCESS_DENIED+ abort "The authorization request was denied#{correlation_suffix(device_code_fingerprint)}."+ when UserApiKey::DeviceAuth::POLL_STATUS_EXPIRED_TOKEN+ abort "The device authorization request expired#{correlation_suffix(device_code_fingerprint)}."+ else+ abort "Unexpected device authorization status: #{status.inspect}#{correlation_suffix(device_code_fingerprint)}."+ end+ end+ end++ def log_poll_attempt(+ attempt:,+ status:,+ previous_status:,+ started_at:,+ deadline:,+ interval:,+ device_code_fingerprint:,+ verbose:+ )+ return if !verbose++ elapsed = (Time.now - started_at).round(1)+ remaining = [deadline - Time.now, 0].max.round(1)+ transition =+ previous_status.present? && previous_status != status ? " (was #{previous_status})" : ""+ puts "Poll ##{attempt}: status=#{status.inspect}#{transition}, elapsed=#{elapsed}s, remaining=#{remaining}s, next_interval=#{interval}s, device_code_hash=#{device_code_fingerprint}"+ end++ def correlation_suffix(device_code_fingerprint)+ " (device_code_hash=#{device_code_fingerprint})"+ end++ def decrypt_payload(payload, private_key, padding)+ encrypted = Base64.decode64(payload)+ decrypted =+ if padding == "oaep"+ private_key.private_decrypt(encrypted, OpenSSL::PKey::RSA::PKCS1_OAEP_PADDING)+ else+ private_key.private_decrypt(encrypted)+ end++ JSON.parse(decrypted)+ end++ def verify_key(site, key, client_id)+ _, response =+ json_request(+ :get,+ url_for(site, "/session/current.json"),+ headers: {+ "User-Api-Key" => key,+ "User-Api-Client-Id" => client_id,+ },+ )++ response["current_user"].present?+ end++ def write_profile(path, site, key, client_id)+ profile = { auth_pairs: [{ site: site, user_api_key: key, user_api_client_id: client_id }] }++ FileUtils.mkdir_p(File.dirname(path))+ File.open(path, File::WRONLY | File::CREAT | File::TRUNC, 0o600) do |file|+ file.write(JSON.pretty_generate(profile))+ end+ File.chmod(0o600, path)+ puts "Wrote profile to #{path}"+ end+ end+end++namespace :user_api_key do+ desc "Request a User API Key using the device authorization flow"+ task device_auth: :environment do+ UserApiKeyDeviceAuthRake.run+ end+enddiff --git a/spec/lib/auth/default_current_user_provider_spec.rb b/spec/lib/auth/default_current_user_provider_spec.rbindex 8d2a3247f4d..a489ab5e2d5 100644--- a/spec/lib/auth/default_current_user_provider_spec.rb+++ b/spec/lib/auth/default_current_user_provider_spec.rb@@ -655,6 +655,20 @@ RSpec.describe Auth::DefaultCurrentUserProvider doexpect { provider("/", params).current_user }.to raise_error(Discourse::InvalidAccess)end+ it "allows unexpired user API keys" do+ api_key.update!(expires_at: 1.minute.from_now)+ params = { "REQUEST_METHOD" => "GET", "HTTP_USER_API_KEY" => api_key.key }++ expect(provider("/", params).current_user.id).to eq(user.id)+ end++ it "does not allow expired user API keys" do+ api_key.update!(expires_at: 1.minute.ago)+ params = { "REQUEST_METHOD" => "GET", "HTTP_USER_API_KEY" => api_key.key }++ expect { provider("/", params).current_user }.to raise_error(Discourse::InvalidAccess)+ end+describe "when readonly mode is enabled due to postgres" dobefore { Discourse.enable_readonly_mode(Discourse::PG_READONLY_MODE_KEY) }diff --git a/spec/models/user_api_key_spec.rb b/spec/models/user_api_key_spec.rbindex efcf599412f..692b16c2e57 100644--- a/spec/models/user_api_key_spec.rb+++ b/spec/models/user_api_key_spec.rb@@ -48,4 +48,60 @@ RSpec.describe UserApiKey doexpect(key.allow?(request_env("PUT", "/random"))).to eq(false)endend++ describe ".active" do+ it "includes unexpired keys and excludes expired and revoked keys" do+ freeze_time++ active_key = Fabricate(:readonly_user_api_key, expires_at: 1.hour.from_now)+ key_without_expiry = Fabricate(:readonly_user_api_key, expires_at: nil)+ expired_key = Fabricate(:readonly_user_api_key, expires_at: 1.minute.ago)+ revoked_key = Fabricate(:readonly_user_api_key, revoked_at: Time.zone.now)++ expect(described_class.active).to include(active_key, key_without_expiry)+ expect(described_class.active).not_to include(expired_key, revoked_key)+ end+ end++ describe "#expired?" do+ it "returns true only for keys past their expiry" do+ freeze_time++ expect(described_class.new(expires_at: 1.second.ago)).to be_expired+ expect(described_class.new(expires_at: 1.second.from_now)).not_to be_expired+ expect(described_class.new(expires_at: nil)).not_to be_expired+ end+ end++ describe ".push_clients_for" do+ it "excludes expired keys" do+ freeze_time+ SiteSetting.allow_user_api_key_scopes = "push"+ SiteSetting.allowed_user_api_push_urls = "https://push.example.com"+ user = Fabricate(:user)+ active_client = Fabricate(:user_api_key_client, client_id: "active-client")+ expired_client = Fabricate(:user_api_key_client, client_id: "expired-client")++ Fabricate(+ :user_api_key,+ user: user,+ client: active_client,+ push_url: "https://push.example.com",+ expires_at: 1.hour.from_now,+ scopes: [Fabricate.build(:user_api_key_scope, name: "push")],+ )+ Fabricate(+ :user_api_key,+ user: user,+ client: expired_client,+ push_url: "https://push.example.com",+ expires_at: 1.hour.ago,+ scopes: [Fabricate.build(:user_api_key_scope, name: "push")],+ )++ expect(described_class.push_clients_for(user)).to eq(+ [%w[active-client https://push.example.com]],+ )+ end+ endenddiff --git a/spec/requests/user_api_keys_controller_spec.rb b/spec/requests/user_api_keys_controller_spec.rbindex b9b722a31c9..68eba03f16f 100644--- a/spec/requests/user_api_keys_controller_spec.rb+++ b/spec/requests/user_api_keys_controller_spec.rb@@ -28,23 +28,31 @@ RSpec.describe UserApiKeysController doenddef extract_payload_from_redirect(response, key: "payload")- uri = URI.parse(response.redirect_url)+ redirect_url = response.redirect_url || response.parsed_body["redirect_url"]+ uri = URI.parse(redirect_url)payload = uri.query.split("#{key}=")[1]Base64.decode64(CGI.unescape(payload))end+ def expect_required_fields(response_body, contract, state)+ required_fields = contract.fetch(state).fetch(:required_fields)+ expect(response_body.keys.map(&:to_sym)).to include(*required_fields)+ end+describe "#new" doit "supports a head request cleanly" dohead "/user-api-key/new"expect(response.status).to eq(200)expect(response.headers["Auth-Api-Version"]).to eq("4")+ expect(response.headers["Auth-Api-Device-Code"]).to eq("true")end- it "rejects a non-RSA public key with 400 even when not logged in" do+ it "renders an error for a non-RSA public key even when not logged in" doSiteSetting.allowed_user_api_auth_redirects = args[:auth_redirect]ec_key = OpenSSL::PKey::EC.generate("prime256v1")- get "/user-api-key/new", params: args.merge(public_key: ec_key.to_pem)- expect(response.status).to eq(400)+ get "/user-api-key/new.json", params: args.merge(public_key: ec_key.to_pem)+ expect(response.status).to eq(200)+ expect(response.parsed_body["state"]).to eq("generic_error")enddescribe "as a normal user" do@@ -55,12 +63,12 @@ RSpec.describe UserApiKeysController doSiteSetting.allowed_user_api_auth_redirects = args[:auth_redirect]end- it "includes padding parameter in the form only when provided" do- get "/user-api-key/new", params: args- expect(response.body).not_to include('name="padding"')+ it "includes padding parameter in the model only when provided" do+ get "/user-api-key/new.json", params: args+ expect(response.parsed_body["padding"]).to be_nil- get "/user-api-key/new", params: args.merge(padding: "oaep")- expect(response.body).to include('name="padding"', 'value="oaep"')+ get "/user-api-key/new.json", params: args.merge(padding: "oaep")+ expect(response.parsed_body["padding"]).to eq("oaep")endit "rejects invalid padding parameter" do@@ -68,55 +76,83 @@ RSpec.describe UserApiKeysController doexpect(response.status).to eq(400)end- it "rejects a non-RSA public key with 400" do+ it "renders an error for a non-RSA public key" doec_key = OpenSSL::PKey::EC.generate("prime256v1")- get "/user-api-key/new", params: args.merge(public_key: ec_key.to_pem)- expect(response.status).to eq(400)+ get "/user-api-key/new.json", params: args.merge(public_key: ec_key.to_pem)+ expect(response.status).to eq(200)+ expect(response.parsed_body["state"]).to eq("generic_error")endit "shows write scope warning when write scope is requested" do- get "/user-api-key/new", params: args.merge(scopes: "write")- expect(response.body).to include(I18n.t("user_api_key.write_scope_warning"))+ get "/user-api-key/new.json", params: args.merge(scopes: "write")+ expect(response.parsed_body["write_scope"]).to eq(true)endit "does not show write scope warning for read-only scopes" do- get "/user-api-key/new", params: args- expect(response.body).not_to include(I18n.t("user_api_key.write_scope_warning"))+ get "/user-api-key/new.json", params: args+ expect(response.parsed_body["write_scope"]).to eq(false)endit "does not show redirect warning when auth_redirect is discourse://auth_redirect" doSiteSetting.allowed_user_api_auth_redirects = "discourse://auth_redirect"- get "/user-api-key/new", params: args.merge(auth_redirect: "discourse://auth_redirect")- expect(response.body).not_to include(I18n.t("user_api_key.redirect_warning"))+ get "/user-api-key/new.json", params: args.merge(auth_redirect: "discourse://auth_redirect")+ expect(response.parsed_body["redirect_uri"]).to be_nilendit "shows redirect warning when auth_redirect is not discourse://auth_redirect" do- get "/user-api-key/new", params: args- expect(response.body).to include(I18n.t("user_api_key.redirect_warning"))+ get "/user-api-key/new.json", params: args+ expect(response.parsed_body["redirect_uri"]).to eq("over.the")endit "shows redirect URI without trailing colon for custom scheme URLs" doSiteSetting.allowed_user_api_auth_redirects = "myapp://callback"- get "/user-api-key/new", params: args.merge(auth_redirect: "myapp://callback")- expect(response.body).to include("<strong>callback</strong>")- expect(response.body).not_to include("<strong>callback:</strong>")+ get "/user-api-key/new.json", params: args.merge(auth_redirect: "myapp://callback")+ expect(response.parsed_body["redirect_uri"]).to eq("callback")endit "rejects auth_redirect to a disallowed domain" do- get "/user-api-key/new", params: args.merge(auth_redirect: "https://evil.com/steal")- expect(response.body).to include(I18n.t("user_api_key.generic_error"))- expect(response.body).not_to include("evil.com")+ get "/user-api-key/new.json", params: args.merge(auth_redirect: "https://evil.com/steal")+ expect(response.parsed_body["state"]).to eq("generic_error")+ expect(response.parsed_body["redirect_uri"]).to be_nil+ end++ it "matches the ready state contract" do+ get "/user-api-key/new.json", params: args++ expect(response.parsed_body["state"]).to eq(+ UserApiKey::DeviceAuth::AUTHORIZATION_STATE_READY,+ )+ expect_required_fields(+ response.parsed_body,+ UserApiKey::DeviceAuth::AUTHORIZATION_STATE_CONTRACT,+ UserApiKey::DeviceAuth::AUTHORIZATION_STATE_READY,+ )+ end++ it "matches the no trust level state contract" do+ SiteSetting.user_api_key_allowed_groups = Group::AUTO_GROUPS[:trust_level_4]++ get "/user-api-key/new.json", params: args++ expect(response.parsed_body["state"]).to eq(+ UserApiKey::DeviceAuth::AUTHORIZATION_STATE_NO_TRUST_LEVEL,+ )+ expect_required_fields(+ response.parsed_body,+ UserApiKey::DeviceAuth::AUTHORIZATION_STATE_CONTRACT,+ UserApiKey::DeviceAuth::AUTHORIZATION_STATE_NO_TRUST_LEVEL,+ )endit "allows auth_redirect when it matches allowed_user_api_auth_redirects" doSiteSetting.allowed_user_api_auth_redirects = "https://good.com/callback"- get "/user-api-key/new", params: args.merge(auth_redirect: "https://good.com/callback")+ get "/user-api-key/new.json", params: args.merge(auth_redirect: "https://good.com/callback")expect(response.status).to eq(200)- expect(response.body).to include("good.com")- expect(response.body).not_to include(I18n.t("user_api_key.generic_error"))+ expect(response.parsed_body["redirect_uri"]).to eq("good.com")+ expect(response.parsed_body["state"]).to eq("ready")endendend@@ -139,7 +175,7 @@ RSpec.describe UserApiKeysController dosign_in(Fabricate(:user, trust_level: TrustLevel[1], moderator: true))post "/user-api-key.json", params: args- expect(response.status).to eq(302)+ expect(response.status).to eq(200)endit "does not create token unless TL requirement is met" do@@ -169,7 +205,7 @@ RSpec.describe UserApiKeysController dopost "/user-api-key.json",params: args.merge(scopes: "push,read", push_url: "https://push.it/here")- expect(response.status).to eq(302)+ expect(response.status).to eq(200)parsed = JSON.parse(decrypt_payload(extract_payload_from_redirect(response)))expect(parsed["push"]).to eq(false)@@ -189,7 +225,7 @@ RSpec.describe UserApiKeysController doscopes: "push,notifications,message_bus,session_info,one_time_password",push_url: "https://push.it/here",)- expect(response.status).to eq(302)+ expect(response.status).to eq(200)parsed = JSON.parse(decrypt_payload(extract_payload_from_redirect(response)))expect(parsed["nonce"]).to eq(args[:nonce])@@ -216,6 +252,42 @@ RSpec.describe UserApiKeysController doexpect(UserApiKey.with_key(parsed["key"]).first.user_id).to eq(user.id)end+ it "creates keys with a requested expiry" do+ freeze_time+ SiteSetting.user_api_key_allowed_groups = Group::AUTO_GROUPS[:trust_level_0]+ user = Fabricate(:user, trust_level: TrustLevel[0])+ sign_in(user)++ post "/user-api-key.json",+ params: args.except(:auth_redirect).merge(expires_in_seconds: 1.day.to_i)+ expect(response.status).to eq(200)++ encrypted = Base64.decode64(response.parsed_body["payload"])+ parsed = JSON.parse(decrypt_payload(encrypted))+ key = UserApiKey.with_key(parsed["key"]).first+ expect(key.expires_at).to eq_time(1.day.from_now)+ expect(parsed["expires_at"]).to eq(key.expires_at.iso8601)+ end++ it "rejects requested expiry greater than the configured maximum" do+ SiteSetting.max_user_api_key_expiry_days = 1+ SiteSetting.user_api_key_allowed_groups = Group::AUTO_GROUPS[:trust_level_0]+ sign_in(Fabricate(:user, trust_level: TrustLevel[0]))++ post "/user-api-key.json",+ params: args.except(:auth_redirect).merge(expires_in_seconds: 2.days.to_i)+ expect(response.status).to eq(400)+ end++ it "rejects oversized requested expiry values" do+ SiteSetting.user_api_key_allowed_groups = Group::AUTO_GROUPS[:trust_level_0]+ sign_in(Fabricate(:user, trust_level: TrustLevel[0]))++ post "/user-api-key.json",+ params: args.except(:auth_redirect).merge(expires_in_seconds: "1" * 1_000)+ expect(response.status).to eq(400)+ end+it "renders show template with application_name when no auth_redirect provided" doSiteSetting.user_api_key_allowed_groups = Group::AUTO_GROUPS[:trust_level_0]user = Fabricate(:user, trust_level: TrustLevel[0])@@ -262,7 +334,7 @@ RSpec.describe UserApiKeysController dosign_in(Fabricate(:user, refresh_auto_groups: true))post "/user-api-key.json", params: args.merge(auth_redirect: args[:auth_redirect] + "/foo")- expect(response.status).to eq(302)+ expect(response.status).to eq(200)endit "rejects wildcard auth_redirect matches outside the candidate host" do@@ -282,7 +354,7 @@ RSpec.describe UserApiKeysController dosign_in(Fabricate(:user, trust_level: TrustLevel[0]))post "/user-api-key.json", params: args.merge(auth_redirect: args[:auth_redirect] + "/?p=1")- expect(response.redirect_url).to include("?p=1")+ expect(response.parsed_body["redirect_url"]).to include("?p=1")endcontext "with a registered client" do@@ -314,7 +386,7 @@ RSpec.describe UserApiKeysController doit "does not require application_name or public_key params" dopost "/user-api-key.json", params: args.except(:application_name, :public_key)- expect(response.status).to eq(302)+ expect(response.status).to eq(200)endit "rejects scopes not allowed by client" do@@ -324,6 +396,541 @@ RSpec.describe UserApiKeysController doendend+ describe "device authorization flow" do+ let(:device_args) { args.except(:auth_redirect).merge(padding: "oaep") }++ def create_pending_device_request(params = {})+ post "/user-api-key/device.json", params: device_args.merge(params), as: :json+ response.parsed_body+ end++ def approval_token_for(user_code, user)+ sign_in(user)+ post "/user-api-key/activate.json", params: { code: user_code }+ response.parsed_body["approval_token"]+ end++ def authorize_device_request(body, user: Fabricate(:user, refresh_auto_groups: true))+ approval_token = approval_token_for(body["user_code"], user)+ post "/user-api-key/device/authorize.json", params: { approval_token: approval_token }+ user+ end++ it "creates a pending request" do+ freeze_time++ body = create_pending_device_request(expires_in_seconds: 1.day.to_i)++ expect(response.status).to eq(200)+ expect(response.headers["Cache-Control"]).to eq("no-store")+ expect(response.headers["Pragma"]).to eq("no-cache")+ expect(response.headers["Expires"]).to eq("0")+ expect(body["device_code"]).to be_present+ expect(body["user_code"]).to match(/\A[A-Z2-9]{4}-[A-Z2-9]{4}\z/)+ expect(body["verification_uri"]).to end_with("/user-api-key/activate")+ expect(body["verification_uri_with_request"]).to include("/user-api-key/activate?request=")+ request_token =+ Rack::Utils.parse_query(URI.parse(body["verification_uri_with_request"]).query)["request"]+ expect(request_token).to match(/\A[-_A-Za-z0-9]{8}\z/)+ expect(body).not_to have_key("verification_uri_complete")+ expect(body["expires_in"]).to eq(10.minutes.to_i)+ expect(body["interval"]).to eq(5)++ grant = JSON.parse(Discourse.redis.get("user_api_key:device:#{body["device_code"]}"))+ expect(grant["status"]).to eq("pending")+ expect(grant["expires_in_seconds"]).to eq(1.day.to_i)+ end++ it "rejects device requests without a JSON content type" do+ post "/user-api-key/device.json", params: device_args++ expect(response.status).to eq(403)+ end++ it "rejects device polls without a JSON content type" do+ body = create_pending_device_request++ post "/user-api-key/device/poll.json", params: { device_code: body["device_code"] }++ expect(response.status).to eq(403)+ end++ it "rejects invalid scopes" do+ create_pending_device_request(scopes: "admin")+ expect(response.status).to eq(403)+ end++ it "rejects invalid public keys" do+ create_pending_device_request(public_key: "not a key")+ expect(response.status).to eq(400)+ end++ it "rejects invalid requested expiries" do+ SiteSetting.max_user_api_key_expiry_days = 1++ create_pending_device_request(expires_in_seconds: 2.days.to_i)+ expect(response.status).to eq(400)+ end++ it "rejects oversized payloads before creating a pending request" do+ request_keys_before = Discourse.redis.keys("user_api_key:device:request:*")+ user_code_keys_before = Discourse.redis.keys("user_api_key:device:code:*")++ create_pending_device_request(nonce: "x" * 150)++ expect(response.status).to eq(400)+ expect(response.parsed_body["errors"].first).to include("Payload too large for OAEP")+ expect(Discourse.redis.keys("user_api_key:device:request:*")).to match_array(+ request_keys_before,+ )+ expect(Discourse.redis.keys("user_api_key:device:code:*")).to match_array(+ user_code_keys_before,+ )+ end++ it "rejects oversized PKCS#1 payloads before creating a pending request" do+ create_pending_device_request(padding: nil, nonce: "x" * 180)++ expect(response.status).to eq(400)+ expect(response.parsed_body["errors"].first).to include("Payload too large for PKCS#1")+ end++ it "allows unregistered clients" do+ body = create_pending_device_request++ expect(response.status).to eq(200)+ grant = JSON.parse(Discourse.redis.get("user_api_key:device:#{body["device_code"]}"))+ expect(grant["unregistered_client"]).to eq(true)+ end++ it "uses registered client metadata and warns when public key is request-supplied" do+ Fabricate(+ :user_api_key_client,+ client_id: args[:client_id],+ application_name: "Stored Client Name",+ public_key: nil,+ )++ body = create_pending_device_request(application_name: "Spoofed Client Name")++ expect(response.status).to eq(200)+ grant = JSON.parse(Discourse.redis.get("user_api_key:device:#{body["device_code"]}"))+ expect(grant["application_name"]).to eq("Stored Client Name")+ expect(grant["unregistered_client"]).to eq(true)+ end++ it "rejects one-time password scope in the device flow" do+ create_pending_device_request(scopes: "one_time_password")++ expect(response.status).to eq(400)+ end++ it "redirects anonymous activation requests to login without preserving codes from URLs" do+ body = create_pending_device_request++ get "/user-api-key/activate", params: { code: body["user_code"] }++ expect(response).to redirect_to("/login")+ expect(response.cookies["destination_url"]).to eq("/user-api-key/activate")+ end++ it "preserves request tokens when redirecting anonymous activation requests to login" do+ body = create_pending_device_request+ request_token =+ Rack::Utils.parse_query(URI.parse(body["verification_uri_with_request"]).query)["request"]++ get "/user-api-key/activate", params: { request: request_token }++ expect(response).to redirect_to("/login")+ expect(response.cookies["destination_url"]).to eq(+ "/user-api-key/activate?request=#{CGI.escape(request_token)}",+ )+ end++ it "returns the code entry page model" do+ sign_in(Fabricate(:user, refresh_auto_groups: true))++ get "/user-api-key/activate.json"++ expect(response.status).to eq(200)+ expect(response.parsed_body["state"]).to eq("enter_code")+ end++ it "does not accept codes from query strings" do+ body = create_pending_device_request+ sign_in(Fabricate(:user, refresh_auto_groups: true))++ get "/user-api-key/activate", params: { code: body["user_code"] }++ expect(response).to redirect_to("/user-api-key/activate")+ end++ it "shows the authorization page for a request token before code entry" do+ freeze_time+ body = create_pending_device_request(scopes: "read,write", expires_in_seconds: 1.day.to_i)+ request_token =+ Rack::Utils.parse_query(URI.parse(body["verification_uri_with_request"]).query)["request"]+ user = Fabricate(:user, refresh_auto_groups: true)+ sign_in(user)++ get "/user-api-key/activate.json", params: { request: request_token }++ expect(response.status).to eq(200)+ expect(response.parsed_body["state"]).to eq(+ UserApiKey::DeviceAuth::DEVICE_ACTIVATION_STATE_AUTHORIZE,+ )+ expect_required_fields(+ response.parsed_body,+ UserApiKey::DeviceAuth::DEVICE_ACTIVATION_STATE_CONTRACT,+ UserApiKey::DeviceAuth::DEVICE_ACTIVATION_STATE_AUTHORIZE,+ )+ expect(response.parsed_body["request_token"]).to eq(request_token)+ expect(response.parsed_body["user_code"]).to be_blank+ expect(response.parsed_body["approval_token"]).to be_blank+ expect(response.parsed_body.dig("device_auth", "application_name")).to eq(+ args[:application_name],+ )+ expect(response.parsed_body.dig("device_auth", "localized_scopes")).to contain_exactly(+ I18n.t("user_api_key.scopes.read"),+ I18n.t("user_api_key.scopes.write"),+ )+ expect(response.parsed_body.dig("device_auth", "write_scope")).to eq(true)++ grant = JSON.parse(Discourse.redis.get("user_api_key:device:#{body["device_code"]}"))+ expect(grant["authorizing_user_id"]).to be_blank+ end++ it "does not allow another user to reuse a request token after authorization" do+ body = create_pending_device_request+ request_token =+ Rack::Utils.parse_query(URI.parse(body["verification_uri_with_request"]).query)["request"]+ first_user = Fabricate(:user, refresh_auto_groups: true)+ second_user = Fabricate(:user, refresh_auto_groups: true)++ sign_in(first_user)+ get "/user-api-key/activate", params: { request: request_token }+ expect(response.status).to eq(200)+ post "/user-api-key/device/authorize.json",+ params: {+ request: request_token,+ code: body["user_code"].delete("-"),+ }+ expect(response.parsed_body["state"]).to eq(+ UserApiKey::DeviceAuth::DEVICE_ACTIVATION_STATE_COMPLETE,+ )+ expect_required_fields(+ response.parsed_body,+ UserApiKey::DeviceAuth::DEVICE_ACTIVATION_STATE_CONTRACT,+ UserApiKey::DeviceAuth::DEVICE_ACTIVATION_STATE_COMPLETE,+ )++ sign_in(second_user)+ post "/user-api-key/device/authorize.json",+ params: {+ request: request_token,+ code: body["user_code"].delete("-"),+ }+ expect(response.parsed_body["state"]).not_to eq("complete")+ end++ it "shows the authorization page for a manually submitted valid code" do+ freeze_time+ body = create_pending_device_request(scopes: "read,write", expires_in_seconds: 1.day.to_i)+ user = Fabricate(:user, refresh_auto_groups: true)+ sign_in(user)++ post "/user-api-key/activate.json", params: { code: body["user_code"].delete("-") }++ expect(response.status).to eq(200)+ expect(response.parsed_body["state"]).to eq("authorize")+ expect(response.parsed_body["approval_token"]).to be_present+ expect(response.parsed_body.dig("device_auth", "application_name")).to eq(+ args[:application_name],+ )+ expect(response.parsed_body.dig("device_auth", "localized_scopes")).to contain_exactly(+ I18n.t("user_api_key.scopes.read"),+ I18n.t("user_api_key.scopes.write"),+ )+ expect(response.parsed_body.dig("device_auth", "write_scope")).to eq(true)+ expect(response.parsed_body.dig("device_auth", "unregistered_client")).to eq(true)+ expect(response.parsed_body.dig("device_auth", "expires_at")).to eq(1.day.from_now.iso8601)+ expect(Discourse.redis.get("user_api_key:device:code:#{body["user_code"]}")).to eq(+ body["device_code"],+ )++ grant = UserApiKey::DeviceAuth::GrantStore.load(body["device_code"])+ expect(grant.authorizing_user_id).to eq(user.id)+ end++ it "does not allow another user to claim a manual code after the first user reaches confirmation" do+ body = create_pending_device_request+ request_token =+ Rack::Utils.parse_query(URI.parse(body["verification_uri_with_request"]).query)["request"]+ first_user = Fabricate(:user, refresh_auto_groups: true)+ second_user = Fabricate(:user, refresh_auto_groups: true)++ sign_in(first_user)+ post "/user-api-key/activate.json", params: { code: body["user_code"] }+ expect(response.parsed_body["approval_token"]).to be_present++ sign_in(second_user)+ post "/user-api-key/activate.json", params: { code: body["user_code"] }++ expect(response.parsed_body["expired_code"]).to eq(true)+ expect(response.parsed_body["approval_token"]).to be_blank++ post "/user-api-key/device/authorize.json",+ params: {+ request: request_token,+ code: body["user_code"],+ }+ expect(response.parsed_body["state"]).to eq("enter_code")+ expect(response.parsed_body["expired_code"]).to eq(true)+ end++ it "warns when no expiry is requested" do+ body = create_pending_device_request+ sign_in(Fabricate(:user, refresh_auto_groups: true))++ post "/user-api-key/activate.json", params: { code: body["user_code"] }++ expect(response.status).to eq(200)+ expect(response.parsed_body.dig("device_auth", "expires_at")).to be_nil+ end++ it "does not consume a manual user code for users who cannot authorize keys" do+ body = create_pending_device_request+ SiteSetting.user_api_key_allowed_groups = Group::AUTO_GROUPS[:trust_level_4]+ sign_in(Fabricate(:user, trust_level: TrustLevel[0]))++ post "/user-api-key/activate.json", params: { code: body["user_code"] }++ expect(response.status).to eq(200)+ expect(response.parsed_body["no_trust_level"]).to eq(true)+ expect(Discourse.redis.get("user_api_key:device:code:#{body["user_code"]}")).to eq(+ body["device_code"],+ )+ SiteSetting.user_api_key_allowed_groups = Group::AUTO_GROUPS[:trust_level_0]+ end++ it "does not allow an approval token to be reused by another user" do+ body = create_pending_device_request+ first_user = Fabricate(:user, refresh_auto_groups: true)+ second_user = Fabricate(:user, refresh_auto_groups: true)+ approval_token = approval_token_for(body["user_code"], first_user)+ sign_in(second_user)++ post "/user-api-key/device/authorize.json", params: { approval_token: approval_token }++ expect(response.parsed_body["expired_code"]).to eq(true)+ post "/user-api-key/device/poll.json", params: { device_code: body["device_code"] }, as: :json+ expect(response.parsed_body["status"]).to eq("authorization_pending")+ end++ it "shows a safe error for invalid codes" do+ sign_in(Fabricate(:user, refresh_auto_groups: true))++ post "/user-api-key/activate.json", params: { code: "BAD-CODE" }++ expect(response.status).to eq(200)+ expect(response.parsed_body["invalid_code"]).to eq(true)+ expect(response.parsed_body["device_auth"]).to be_blank+ end++ it "returns authorization_pending while waiting for authorization" do+ body = create_pending_device_request++ post "/user-api-key/device/poll.json", params: { device_code: body["device_code"] }, as: :json++ expect(response.status).to eq(200)+ expect(response.parsed_body["status"]).to eq("authorization_pending")+ end++ it "authorizes a pending request with a request token and typed code" do+ freeze_time+ body = create_pending_device_request(scopes: "read,write", expires_in_seconds: 1.day.to_i)+ request_token =+ Rack::Utils.parse_query(URI.parse(body["verification_uri_with_request"]).query)["request"]+ user = Fabricate(:user, refresh_auto_groups: true)+ sign_in(user)+ get "/user-api-key/activate", params: { request: request_token }++ post "/user-api-key/device/authorize.json",+ params: {+ request: request_token,+ code: body["user_code"].delete("-"),+ }++ expect(response.status).to eq(200)+ expect(response.parsed_body["state"]).to eq("complete")++ post "/user-api-key/device/poll.json", params: { device_code: body["device_code"] }, as: :json++ expect(response.parsed_body["status"]).to eq("authorized")+ encrypted = Base64.decode64(response.parsed_body["payload"])+ parsed = JSON.parse(decrypt_payload(encrypted, padding: "oaep"))+ key = UserApiKey.with_key(parsed["key"]).first++ expect(parsed["nonce"]).to eq(args[:nonce])+ expect(parsed["api"]).to eq(4)+ expect(parsed["expires_at"]).to eq(1.day.from_now.iso8601)+ expect(key.user_id).to eq(user.id)+ expect(key.expires_at).to eq_time(1.day.from_now)+ expect(key.scopes.map(&:name).sort).to eq(%w[read write])+ end++ it "keeps request context and does not authorize when request token code is wrong" do+ body = create_pending_device_request+ request_token =+ Rack::Utils.parse_query(URI.parse(body["verification_uri_with_request"]).query)["request"]+ sign_in(Fabricate(:user, refresh_auto_groups: true))+ get "/user-api-key/activate", params: { request: request_token }++ post "/user-api-key/device/authorize.json",+ params: {+ request: request_token,+ code: "BADCODE1",+ }++ expect(response.status).to eq(200)+ expect(response.parsed_body["invalid_code"]).to eq(true)+ expect(response.parsed_body.dig("device_auth", "application_name")).to eq(+ args[:application_name],+ )+ expect(response.parsed_body["request_token"]).to eq(request_token)+ expect(response.parsed_body["user_code"]).to be_blank++ post "/user-api-key/device/poll.json", params: { device_code: body["device_code"] }, as: :json+ expect(response.parsed_body["status"]).to eq("authorization_pending")+ end++ it "authorizes a pending request and returns an encrypted payload when polled" do+ freeze_time+ body = create_pending_device_request(scopes: "read,write", expires_in_seconds: 1.day.to_i)+ user = authorize_device_request(body)++ expect(response.status).to eq(200)+ expect(response.parsed_body["state"]).to eq("complete")++ post "/user-api-key/device/poll.json", params: { device_code: body["device_code"] }, as: :json++ expect(response.parsed_body["status"]).to eq("authorized")+ encrypted = Base64.decode64(response.parsed_body["payload"])+ parsed = JSON.parse(decrypt_payload(encrypted, padding: "oaep"))+ key = UserApiKey.with_key(parsed["key"]).first++ expect(parsed["nonce"]).to eq(args[:nonce])+ expect(parsed["api"]).to eq(4)+ expect(parsed["expires_at"]).to eq(1.day.from_now.iso8601)+ expect(key.user_id).to eq(user.id)+ expect(key.expires_at).to eq_time(1.day.from_now)+ expect(key.scopes.map(&:name).sort).to eq(%w[read write])++ post "/user-api-key/device/poll.json", params: { device_code: body["device_code"] }, as: :json+ expect(response.parsed_body["status"]).to eq("expired_token")+ end++ it "returns access_denied when a pending request is denied" do+ body = create_pending_device_request+ user = Fabricate(:user, refresh_auto_groups: true)+ approval_token = approval_token_for(body["user_code"], user)++ post "/user-api-key/device/deny.json", params: { approval_token: approval_token }+ expect(response.parsed_body["denied"]).to eq(true)++ post "/user-api-key/device/poll.json", params: { device_code: body["device_code"] }, as: :json+ expect(response.parsed_body["status"]).to eq("access_denied")+ end++ it "does not report denied for an invalid approval token" do+ sign_in(Fabricate(:user, refresh_auto_groups: true))++ post "/user-api-key/device/deny.json", params: { approval_token: SecureRandom.hex(32) }++ expect(response.parsed_body["expired_code"]).to eq(true)+ expect(response.parsed_body["denied"]).not_to eq(true)+ end++ it "does not allow request-token denial without an approval token" do+ body = create_pending_device_request+ request_token =+ Rack::Utils.parse_query(URI.parse(body["verification_uri_with_request"]).query)["request"]+ sign_in(Fabricate(:user, refresh_auto_groups: true))+ get "/user-api-key/activate", params: { request: request_token }++ post "/user-api-key/device/deny.json", params: { request: request_token }+ expect(response.parsed_body["expired_code"]).to eq(true)++ post "/user-api-key/device/poll.json", params: { device_code: body["device_code"] }, as: :json+ expect(response.parsed_body["status"]).to eq("authorization_pending")+ end++ it "returns expired_token for expired or missing requests" do+ post "/user-api-key/device/poll.json",+ params: {+ device_code: SecureRandom.hex(32),+ },+ as: :json++ expect(response.status).to eq(200)+ expect(response.parsed_body["status"]).to eq("expired_token")+ end++ it "enforces registered client scope restrictions" do+ Fabricate(+ :user_api_key_client,+ client_id: args[:client_id],+ application_name: args[:application_name],+ public_key: public_key,+ scopes: "read",+ )++ create_pending_device_request(scopes: "write")++ expect(response.status).to eq(403)+ end++ context "with rate limiting enabled" do+ before { RateLimiter.enable }+ after { RateLimiter.disable }++ it "rate limits device request creation" do+ UserApiKeysController::DEVICE_REQUESTS_PER_MINUTE.times do |i|+ create_pending_device_request(client_id: "device-client-#{i}")+ expect(response.status).to eq(200)+ end++ create_pending_device_request(client_id: "device-client-limited")+ expect(response.status).to eq(429)+ end++ it "rate limits invalid code entry" do+ user = Fabricate(:user, refresh_auto_groups: true)+ sign_in(user)++ UserApiKeysController::DEVICE_ACTIVATION_ATTEMPTS_PER_MINUTE.times do |i|+ post "/user-api-key/activate", params: { code: "BADCODE#{i}" }+ expect(response.status).to eq(200)+ end++ post "/user-api-key/activate", params: { code: "LIMITED1" }+ expect(response.status).to eq(429)+ end++ it "rate limits request token lookup" do+ sign_in(Fabricate(:user, refresh_auto_groups: true))++ UserApiKeysController::DEVICE_REQUEST_TOKEN_LOOKUPS_PER_MINUTE.times do |i|+ get "/user-api-key/activate", params: { request: "A00000#{format("%02d", i)}" }+ expect(response.status).to eq(200)+ end++ get "/user-api-key/activate", params: { request: "LIMITED1" }+ expect(response.status).to eq(429)+ end+ end+ end+describe "#revoke" doit "allows revoking via API key header without id" dokey = Fabricate(:readonly_user_api_key)@@ -372,15 +979,15 @@ RSpec.describe UserApiKeysController doenddescribe "#otp" do- it "includes padding parameter in the form only when provided" do+ it "includes padding parameter in the model only when provided" doSiteSetting.allowed_user_api_auth_redirects = otp_args[:auth_redirect]sign_in(Fabricate(:user, refresh_auto_groups: true))- get "/user-api-key/otp", params: otp_args- expect(response.body).not_to include('name="padding"')+ get "/user-api-key/otp.json", params: otp_args+ expect(response.parsed_body["padding"]).to be_nil- get "/user-api-key/otp", params: otp_args.merge(padding: "oaep")- expect(response.body).to include('name="padding"', 'value="oaep"')+ get "/user-api-key/otp.json", params: otp_args.merge(padding: "oaep")+ expect(response.parsed_body["padding"]).to eq("oaep")endit "rejects invalid padding parameter" do@@ -390,6 +997,15 @@ RSpec.describe UserApiKeysController doexpect(response.status).to eq(400)end+ it "rejects auth_redirect outside the allowlist" do+ SiteSetting.allowed_user_api_auth_redirects = "https://good.example.com/callback"++ get "/user-api-key/otp",+ params: otp_args.merge(auth_redirect: "https://evil.example.com/callback")++ expect(response.status).to eq(403)+ end+it "does not show the form when auth_redirect differs from a registered client's redirect" doSiteSetting.allowed_user_api_auth_redirects = "https://*.example.com/callback"@@ -419,9 +1035,13 @@ RSpec.describe UserApiKeysController doexpect(response.status).to eq(403)end- it "refuses to redirect to disallowed place" do+ it "rejects auth_redirect outside the allowlist" do+ SiteSetting.allowed_user_api_auth_redirects = "https://good.example.com/callback"sign_in(Fabricate(:user))- post "/user-api-key/otp", params: otp_args++ post "/user-api-key/otp",+ params: otp_args.merge(auth_redirect: "https://evil.example.com/callback")+expect(response.status).to eq(403)enddiff --git a/spec/serializers/user_serializer_spec.rb b/spec/serializers/user_serializer_spec.rbindex 8f2b2fa0290..7c2d8853a58 100644--- a/spec/serializers/user_serializer_spec.rb+++ b/spec/serializers/user_serializer_spec.rb@@ -477,6 +477,24 @@ RSpec.describe UserSerializer doexpect(json[:user_api_keys][1][:id]).to eq(user_api_key_4.id)expect(json[:user_api_keys][2][:id]).to eq(user_api_key_2.id)end++ it "includes expires_at" do+ freeze_time+ key = Fabricate(:readonly_user_api_key, user: user, expires_at: 1.day.from_now)++ json = UserSerializer.new(user, scope: Guardian.new(user), root: false).as_json++ serialized_key = json[:user_api_keys].find { |api_key| api_key[:id] == key.id }+ expect(serialized_key[:expires_at]).to eq_time(1.day.from_now)+ end++ it "includes expired keys that have not been revoked" do+ expired_key = Fabricate(:readonly_user_api_key, user: user, expires_at: 1.day.ago)++ json = UserSerializer.new(user, scope: Guardian.new(user), root: false).as_json++ expect(json[:user_api_keys].map { |key| key[:id] }).to include(expired_key.id)+ endendcontext "with user_passkeys" dodiff --git a/spec/services/user_api_key/device_auth/approval_token_store_spec.rb b/spec/services/user_api_key/device_auth/approval_token_store_spec.rbnew file mode 100644index 00000000000..36a7e1cf987--- /dev/null+++ b/spec/services/user_api_key/device_auth/approval_token_store_spec.rb@@ -0,0 +1,94 @@+# frozen_string_literal: true++RSpec.describe UserApiKey::DeviceAuth::ApprovalTokenStore do+ subject(:store) { described_class.new(session: session, user: user) }++ fab!(:user)+ fab!(:other_user, :user)++ let(:session) { {} }+ let(:device_code) { SecureRandom.hex(32) }++ describe "#create!" do+ it "stores an approval token bound to the device code and user" do+ token = store.create!(device_code)++ expect(token).to be_present+ expect(store.device_code_for(token)).to eq(device_code)+ expect(session[described_class::SESSION_KEY][token]).to include(+ "device_code" => device_code,+ "user_id" => user.id,+ )+ end++ it "removes expired tokens before storing a new one" do+ session[described_class::SESSION_KEY] = {+ "expired" => {+ "device_code" => SecureRandom.hex(32),+ "user_id" => user.id,+ "created_at" => (UserApiKey::DeviceAuth::DEVICE_AUTH_TTL + 1.minute).ago.iso8601,+ },+ }++ store.create!(device_code)++ expect(session[described_class::SESSION_KEY]).not_to have_key("expired")+ end++ it "keeps at most the latest tokens" do+ tokens = Array.new(described_class::MAX_TOKENS + 1) { store.create!(SecureRandom.hex(32)) }++ expect(session[described_class::SESSION_KEY].length).to eq(described_class::MAX_TOKENS)+ expect(session[described_class::SESSION_KEY]).not_to have_key(tokens.first)+ expect(session[described_class::SESSION_KEY]).to have_key(tokens.last)+ end+ end++ describe "#device_code_for" do+ it "returns nil when the token is unknown" do+ expect(store.device_code_for("missing")).to be_nil+ end++ it "returns nil when the token belongs to another user" do+ token = store.create!(device_code)++ expect(+ described_class.new(session: session, user: other_user).device_code_for(token),+ ).to be_nil+ end++ it "returns nil when the token is expired" do+ token = store.create!(device_code)+ session[described_class::SESSION_KEY][token]["created_at"] = (+ UserApiKey::DeviceAuth::DEVICE_AUTH_TTL + 1.minute+ ).ago.iso8601++ expect(store.device_code_for(token)).to be_nil+ end++ it "returns nil when the timestamp is malformed" do+ token = store.create!(device_code)+ session[described_class::SESSION_KEY][token]["created_at"] = "not-a-date"++ expect(store.device_code_for(token)).to be_nil+ end++ it "returns nil when the device code is malformed" do+ token = store.create!(device_code)+ session[described_class::SESSION_KEY][token]["device_code"] = "invalid"++ expect(store.device_code_for(token)).to be_nil+ end+ end++ describe "#delete!" do+ it "removes the token" do+ token = store.create!(device_code)++ store.delete!(token)++ expect(store.device_code_for(token)).to be_nil+ expect(session[described_class::SESSION_KEY]).not_to have_key(token)+ end+ end+enddiff --git a/spec/services/user_api_key/device_auth/authorize_spec.rb b/spec/services/user_api_key/device_auth/authorize_spec.rbnew file mode 100644index 00000000000..64f793a07d9--- /dev/null+++ b/spec/services/user_api_key/device_auth/authorize_spec.rb@@ -0,0 +1,99 @@+# frozen_string_literal: true++RSpec.describe UserApiKey::DeviceAuth::Authorize do+ fab!(:user)++ let(:key) { OpenSSL::PKey::RSA.new(2048) }+ let(:device_request) do+ create_user_api_key_device_auth_request!(+ params: {+ nonce: "nonce",+ scopes: "read",+ client_id: "device-client",+ application_name: "Device Client",+ public_key: key.public_key.to_pem,+ },+ )+ end+ let(:params) { { device_code: device_request[:device_code], user_id: user.id } }++ after { clear_user_api_key_device_auth_redis! }++ describe described_class::Contract, type: :model do+ it { is_expected.to validate_presence_of(:device_code) }+ it { is_expected.to validate_presence_of(:user_id) }+ end++ describe ".call" do+ subject(:result) { described_class.call(params: params) }++ it { is_expected.to run_successfully }++ it "authorizes the grant and creates a user API key" do+ expect { result }.to change { UserApiKey.where(user: user).count }.by(1)++ grant = UserApiKey::DeviceAuth::GrantStore.load(device_request[:device_code])++ expect(grant).to be_authorized+ expect(grant.payload).to be_present+ end++ context "when the user does not exist" do+ let(:params) { { device_code: device_request[:device_code], user_id: 0 } }++ it { is_expected.to fail_to_find_a_model(:user) }+ end++ context "when the grant does not exist" do+ let(:params) { { device_code: SecureRandom.hex(32), user_id: user.id } }++ it { is_expected.to fail_a_step(:authorize_grant) }+ end++ context "when the grant is bound to another user" do+ let!(:other_user) { Fabricate(:user) }++ before do+ grant = UserApiKey::DeviceAuth::GrantStore.load(device_request[:device_code])+ grant.bind_to_user!(other_user)+ UserApiKey::DeviceAuth::GrantStore.save!(+ grant,+ ttl: UserApiKey::DeviceAuth::GrantStore.ttl_for_update(grant.device_code),+ )+ end++ it { is_expected.to fail_a_step(:authorize_grant) }++ it "does not create a key for the current user" do+ expect { result }.not_to change { UserApiKey.where(user: user).count }+ end+ end++ context "when the grant is already authorized" do+ before { UserApiKey::DeviceAuth::Authorize.call(params: params) }++ it { is_expected.to fail_a_step(:authorize_grant) }++ it "does not create another key for the current user" do+ expect { result }.not_to change { UserApiKey.where(user: user).count }+ end+ end++ context "when the grant is denied" do+ before do+ grant = UserApiKey::DeviceAuth::GrantStore.load(device_request[:device_code])+ grant.deny!+ UserApiKey::DeviceAuth::GrantStore.save!(+ grant,+ ttl: UserApiKey::DeviceAuth::GrantStore.ttl_for_update(grant.device_code),+ )+ end++ it { is_expected.to fail_a_step(:authorize_grant) }++ it "does not create a key for the current user" do+ expect { result }.not_to change { UserApiKey.where(user: user).count }+ end+ end+ end+enddiff --git a/spec/services/user_api_key/device_auth/code_registry_spec.rb b/spec/services/user_api_key/device_auth/code_registry_spec.rbnew file mode 100644index 00000000000..8b544384339--- /dev/null+++ b/spec/services/user_api_key/device_auth/code_registry_spec.rb@@ -0,0 +1,85 @@+# frozen_string_literal: true++RSpec.describe UserApiKey::DeviceAuth::CodeRegistry do+ let(:device_code) { SecureRandom.hex(32) }+ let(:grant) do+ UserApiKey::DeviceAuth::Grant.new(+ status: :pending,+ device_code: device_code,+ user_code: "ABCD-2345",+ request_token: "abcdefgh",+ )+ end++ after { clear_user_api_key_device_auth_redis! }++ describe ".load_by_user_code" do+ it "loads through the user-code index" do+ UserApiKey::DeviceAuth::GrantStore.save!(grant, ttl: 1.minute)+ Discourse.redis.setex(described_class.user_code_key("ABCD-2345"), 1.minute, device_code)++ expect(described_class.load_by_user_code("ABCD-2345")).to eq(grant)+ end++ it "deletes stale user-code indexes" do+ Discourse.redis.setex(described_class.user_code_key("ABCD-2345"), 1.minute, device_code)++ expect(described_class.load_by_user_code("ABCD-2345")).to be_nil+ expect(Discourse.redis.get(described_class.user_code_key("ABCD-2345"))).to be_nil+ end+ end++ describe ".load_by_request_token" do+ it "loads through the request-token index" do+ UserApiKey::DeviceAuth::GrantStore.save!(grant, ttl: 1.minute)+ Discourse.redis.setex(described_class.request_token_key("abcdefgh"), 1.minute, device_code)++ expect(described_class.load_by_request_token("abcdefgh")).to eq(grant)+ end++ it "deletes stale request-token indexes" do+ Discourse.redis.setex(described_class.request_token_key("abcdefgh"), 1.minute, device_code)++ expect(described_class.load_by_request_token("abcdefgh")).to be_nil+ expect(Discourse.redis.get(described_class.request_token_key("abcdefgh"))).to be_nil+ end++ it "rejects invalid request-token formats" do+ expect(described_class.load_by_request_token("not valid")).to be_nil+ end+ end++ describe ".user_code_matches_grant?" do+ it "checks the normalized user-code index against the grant" do+ Discourse.redis.setex(described_class.user_code_key("ABCD-2345"), 1.minute, device_code)++ expect(described_class.user_code_matches_grant?("abcd2345", grant)).to eq(true)+ expect(described_class.user_code_matches_grant?("WXYZ6789", grant)).to eq(false)+ end+ end++ describe ".delete_indexes_for" do+ it "removes user-code and request-token indexes" do+ Discourse.redis.setex(described_class.user_code_key("ABCD-2345"), 1.minute, device_code)+ Discourse.redis.setex(described_class.request_token_key("abcdefgh"), 1.minute, device_code)++ described_class.delete_indexes_for(grant)++ expect(Discourse.redis.get(described_class.user_code_key("ABCD-2345"))).to be_nil+ expect(Discourse.redis.get(described_class.request_token_key("abcdefgh"))).to be_nil+ end+ end++ describe ".reserve_for" do+ it "reserves a user code and request token for the device" do+ codes = described_class.reserve_for(device_code)++ expect(codes.user_code).to match(/\A[A-Z2-9]{4}-[A-Z2-9]{4}\z/)+ expect(codes.request_token).to match(UserApiKey::DeviceAuth::DEVICE_REQUEST_TOKEN_REGEX)+ expect(Discourse.redis.get(described_class.user_code_key(codes.user_code))).to eq(device_code)+ expect(Discourse.redis.get(described_class.request_token_key(codes.request_token))).to eq(+ device_code,+ )+ end+ end+enddiff --git a/spec/services/user_api_key/device_auth/create_request_spec.rb b/spec/services/user_api_key/device_auth/create_request_spec.rbnew file mode 100644index 00000000000..14b8c03b2de--- /dev/null+++ b/spec/services/user_api_key/device_auth/create_request_spec.rb@@ -0,0 +1,104 @@+# frozen_string_literal: true++RSpec.describe UserApiKey::DeviceAuth::CreateRequest do+ let(:key) { OpenSSL::PKey::RSA.new(2048) }+ let(:public_key) { key.public_key.to_pem }+ let(:params) do+ {+ nonce: "nonce",+ scopes: "read",+ client_id: "device-client",+ application_name: "Device Client",+ public_key: public_key,+ }+ end++ after { clear_user_api_key_device_auth_redis! }++ describe described_class::Contract, type: :model do+ it { is_expected.to validate_presence_of(:nonce) }+ it { is_expected.to validate_presence_of(:scopes) }+ it { is_expected.to validate_presence_of(:client_id) }+ end++ describe ".call" do+ subject(:result) { described_class.call(params: params) }++ it { is_expected.to run_successfully }++ it "stores a pending device grant" do+ device_request = result[:device_request]++ expect(device_request[:device_code]).to match(UserApiKey::DeviceAuth::DEVICE_CODE_REGEX)+ expect(device_request[:request_token]).to match(+ UserApiKey::DeviceAuth::DEVICE_REQUEST_TOKEN_REGEX,+ )++ grant = UserApiKey::DeviceAuth::GrantStore.load(device_request[:device_code])++ expect(grant).to be_pending+ expect(grant.application_name).to eq("Device Client")+ expect(grant).to be_unregistered_client+ end++ context "with missing required parameters" do+ let(:params) { { scopes: "read", client_id: "device-client" } }++ it { is_expected.to fail_a_contract }+ end++ context "when application metadata is missing" do+ let(:params) { super().except(:application_name) }++ it { is_expected.to fail_with_exception(Discourse::InvalidParameters) }+ end++ context "when the requested expiry is invalid" do+ let(:params) { super().merge(expires_in_seconds: 10.years.to_i) }++ it { is_expected.to fail_with_exception(Discourse::InvalidParameters) }++ it "records the validation exception" do+ expect(result["result.try.default"].exception).to be_a(Discourse::InvalidParameters)+ end+ end++ context "when the requested expiry is not numeric" do+ let(:params) { super().merge(expires_in_seconds: "abc") }++ it { is_expected.to fail_with_exception(Discourse::InvalidParameters) }+ end++ context "when the requested expiry is too long" do+ let(:params) { super().merge(expires_in_seconds: "1" * 1_000) }++ it { is_expected.to fail_with_exception(Discourse::InvalidParameters) }+ end++ context "with a registered client" do+ let!(:client) do+ UserApiKeyClient.create!(+ client_id: "device-client",+ application_name: "Stored Client Name",+ public_key: public_key,+ )+ end++ let(:params) do+ super().merge(+ application_name: "Spoofed Client Name",+ public_key: OpenSSL::PKey::RSA.new(2048).public_key.to_pem,+ )+ end++ it "uses trusted metadata from the registered client" do+ device_request = result[:device_request]+ grant = UserApiKey::DeviceAuth::GrantStore.load(device_request[:device_code])++ expect(grant.application_name).to eq("Stored Client Name")+ expect(grant.public_key).to eq(public_key)+ expect(grant).not_to be_unregistered_client+ end+ end+ end+enddiff --git a/spec/services/user_api_key/device_auth/crypto_spec.rb b/spec/services/user_api_key/device_auth/crypto_spec.rbnew file mode 100644index 00000000000..0bac5d3a05b--- /dev/null+++ b/spec/services/user_api_key/device_auth/crypto_spec.rb@@ -0,0 +1,48 @@+# frozen_string_literal: true++RSpec.describe UserApiKey::DeviceAuth::Crypto do+ let(:key) { OpenSSL::PKey::RSA.new(2048) }+ let(:public_key_pem) { key.public_key.to_pem }++ describe ".parse_public_key!" do+ it "parses RSA public keys" do+ expect(described_class.parse_public_key!(public_key_pem)).to be_a(OpenSSL::PKey::RSA)+ end++ it "raises an invalid parameter error for invalid keys" do+ expect { described_class.parse_public_key!("not a key") }.to raise_error(+ Discourse::InvalidParameters,+ )+ end+ end++ describe ".validate_payload_size!" do+ it "allows payloads that fit the key and padding" do+ expect { described_class.validate_payload_size!("short", key.public_key) }.not_to raise_error+ end++ it "raises when payloads are too large" do+ expect { described_class.validate_payload_size!("x" * 300, key.public_key) }.to raise_error(+ Discourse::InvalidParameters,+ )+ end+ end++ describe ".encrypt!" do+ it "encrypts using the requested padding" do+ encrypted = described_class.encrypt!(key.public_key, "secret", padding: "oaep")++ expect(encrypted).to be_present+ expect(encrypted).not_to eq("secret")+ end++ it "raises an invalid parameter error when encryption fails" do+ public_key = key.public_key+ allow(public_key).to receive(:encrypt).and_raise(OpenSSL::PKey::PKeyError)++ expect { described_class.encrypt!(public_key, "secret") }.to raise_error(+ Discourse::InvalidParameters,+ )+ end+ end+enddiff --git a/spec/services/user_api_key/device_auth/deny_spec.rb b/spec/services/user_api_key/device_auth/deny_spec.rbnew file mode 100644index 00000000000..2274be8854a--- /dev/null+++ b/spec/services/user_api_key/device_auth/deny_spec.rb@@ -0,0 +1,79 @@+# frozen_string_literal: true++RSpec.describe UserApiKey::DeviceAuth::Deny do+ let(:key) { OpenSSL::PKey::RSA.new(2048) }+ let(:device_request) do+ create_user_api_key_device_auth_request!(+ params: {+ nonce: "nonce",+ scopes: "read",+ client_id: "device-client",+ application_name: "Device Client",+ public_key: key.public_key.to_pem,+ },+ )+ end+ let(:params) { { device_code: device_request[:device_code] } }++ after { clear_user_api_key_device_auth_redis! }++ describe described_class::Contract, type: :model do+ it { is_expected.to validate_presence_of(:device_code) }+ end++ describe ".call" do+ subject(:result) { described_class.call(params: params) }++ it { is_expected.to run_successfully }++ it "marks the grant as denied" do+ result++ grant = UserApiKey::DeviceAuth::GrantStore.load(device_request[:device_code])++ expect(grant).to be_denied+ end++ context "when the grant does not exist" do+ let(:params) { { device_code: SecureRandom.hex(32) } }++ it { is_expected.to fail_a_step(:deny_grant) }+ end++ context "when the grant is already denied" do+ before do+ grant = UserApiKey::DeviceAuth::GrantStore.load(device_request[:device_code])+ grant.deny!+ UserApiKey::DeviceAuth::GrantStore.save!(+ grant,+ ttl: UserApiKey::DeviceAuth::GrantStore.ttl_for_update(grant.device_code),+ )+ end++ it { is_expected.to run_successfully }++ it "keeps the grant denied" do+ result++ grant = UserApiKey::DeviceAuth::GrantStore.load(device_request[:device_code])++ expect(grant).to be_denied+ end+ end++ context "when the grant is authorized" do+ fab!(:user)++ before do+ UserApiKey::DeviceAuth::Authorize.call(+ params: {+ device_code: device_request[:device_code],+ user_id: user.id,+ },+ )+ end++ it { is_expected.to fail_a_step(:deny_grant) }+ end+ end+enddiff --git a/spec/services/user_api_key/device_auth/grant_spec.rb b/spec/services/user_api_key/device_auth/grant_spec.rbnew file mode 100644index 00000000000..89207137072--- /dev/null+++ b/spec/services/user_api_key/device_auth/grant_spec.rb@@ -0,0 +1,179 @@+# frozen_string_literal: true++RSpec.describe UserApiKey::DeviceAuth::Grant do+ fab!(:user)++ let(:device_code) { SecureRandom.hex(32) }+ let(:grant) do+ described_class.new(+ status: :pending,+ device_code: device_code,+ scopes: %w[read write],+ unregistered_client: true,+ )+ end++ it "serializes through JSON" do+ parsed = described_class.from_json(grant.to_json)++ expect(parsed).to eq(grant)+ expect(parsed.device_code).to eq(device_code)+ end++ it "transitions grant states" do+ freeze_time++ expect(grant).to be_pending++ grant.assign_codes!(user_code: "ABCD-2345", request_token: "abcdefgh")+ expect(grant.user_code).to eq("ABCD-2345")+ expect(grant.request_token).to eq("abcdefgh")++ grant.authorize!(payload: "encrypted-payload")+ expect(grant).to be_authorized+ expect(grant.payload).to eq("encrypted-payload")+ expect(grant.to_h["authorized_at"]).to eq(Time.zone.now.iso8601)++ denied_grant = described_class.new(status: :pending, device_code: device_code)+ denied_grant.deny!+ expect(denied_grant).to be_denied+ expect(denied_grant.to_h["denied_at"]).to eq(Time.zone.now.iso8601)+ end++ it "binds grants to users" do+ freeze_time+ other_user = Fabricate(:user)++ expect(grant.bind_to_user!(user)).to eq(true)+ expect(grant).to be_authorized_for_user(user)+ expect(grant).to be_bound_to_another_user(other_user)+ expect(grant.to_h["authorizing_username"]).to eq(user.username)+ expect(grant.to_h["authorizing_at"]).to eq(Time.zone.now.iso8601)+ expect(grant.bind_to_user!(other_user)).to eq(false)+ end++ it "builds a grant from request details" do+ freeze_time+ client =+ Fabricate(:user_api_key_client, application_name: "Stored App", public_key: "stored-key")+ params = {+ client_id: client.client_id,+ application_name: "Submitted App",+ public_key: "submitted-key",+ nonce: "nonce",+ push_url: "",+ padding: "oaep",+ }++ grant = described_class.build(params, client, %w[read write], 1.day.to_i, device_code)++ expect(grant).to be_pending+ expect(grant.device_code).to eq(device_code)+ expect(grant.application_name).to eq("Stored App")+ expect(grant.client_id).to eq(client.client_id)+ expect(grant.public_key).to eq(client.public_key)+ expect(grant.nonce).to eq("nonce")+ expect(grant.scopes).to eq(%w[read write])+ expect(grant.push_url).to be_nil+ expect(grant.padding).to eq("oaep")+ expect(grant.expires_in_seconds).to eq(1.day.to_i)+ expect(grant.expires_at).to eq_time(1.day.from_now)+ expect(grant).not_to be_unregistered_client+ expect(grant.to_h["created_at"]).to eq(Time.zone.now.iso8601(6))+ end++ it "builds a grant for an unregistered client" do+ freeze_time+ params = {+ client_id: "unregistered-client",+ application_name: "Submitted App",+ public_key: "submitted-key",+ nonce: "nonce",+ push_url: "https://example.com/push",+ padding: "oaep",+ }++ grant = described_class.build(params, nil, %w[read], nil, device_code)++ expect(grant.application_name).to eq("Submitted App")+ expect(grant.client_id).to eq("unregistered-client")+ expect(grant.public_key).to eq("submitted-key")+ expect(grant.push_url).to eq("https://example.com/push")+ expect(grant).to be_unregistered_client+ expect(grant.to_h["created_at"]).to eq(Time.zone.now.iso8601(6))+ end++ it "falls back to request details when registered client fields are missing" do+ client = UserApiKeyClient.new(client_id: SecureRandom.hex)+ params = {+ client_id: client.client_id,+ application_name: "Submitted App",+ public_key: "submitted-key",+ nonce: "nonce",+ }++ grant = described_class.build(params, client, %w[read], nil, device_code)++ expect(grant.application_name).to eq("Submitted App")+ expect(grant.public_key).to eq("submitted-key")+ expect(grant).to be_unregistered_client+ end++ it "exposes fields used by the authorization view" do+ grant = nil+ freeze_time do+ grant =+ described_class.new(+ status: :pending,+ device_code: device_code,+ user_code: "ABCD-2345",+ application_name: "Device Client",+ client_id: "device-client",+ scopes: %w[read write],+ push_url: "https://example.com/push",+ padding: "oaep",+ expires_in_seconds: 1.day.to_i,+ unregistered_client: true,+ )++ expect(grant.user_code).to eq("ABCD-2345")+ expect(grant.application_name).to eq("Device Client")+ expect(grant.client_id).to eq("device-client")+ expect(grant.localized_scopes).to eq(+ [I18n.t("user_api_key.scopes.read"), I18n.t("user_api_key.scopes.write")],+ )+ expect(grant).to be_write_scope+ expect(grant.push_url).to eq("https://example.com/push")+ expect(grant.padding).to eq("oaep")+ expect(grant.expires_in_seconds).to eq(1.day.to_i)+ expect(grant).to be_unregistered_client+ expect(grant.expires_at).to eq_time(1.day.from_now)+ end++ grant_without_expiry = described_class.new(status: :pending, device_code: device_code)+ expect(grant_without_expiry.expires_at).to be_nil++ grant.scopes = nil+ expect(grant.scopes).to eq([])+ expect(grant).not_to be_write_scope+ end++ it "uses created_at when loading an older serialized grant without expires_at" do+ freeze_time+ grant =+ described_class.new(+ status: :pending,+ device_code: device_code,+ expires_in_seconds: 1.day.to_i,+ created_at: 1.hour.ago.iso8601(6),+ )++ expect(grant.expires_at).to eq_time(23.hours.from_now)+ end++ it "rejects invalid statuses" do+ expect { described_class.new(status: :invalid, device_code: device_code) }.to raise_error(+ ArgumentError,+ )+ end+enddiff --git a/spec/services/user_api_key/device_auth/grant_store_multisite_spec.rb b/spec/services/user_api_key/device_auth/grant_store_multisite_spec.rbnew file mode 100644index 00000000000..870e1f02a47--- /dev/null+++ b/spec/services/user_api_key/device_auth/grant_store_multisite_spec.rb@@ -0,0 +1,36 @@+# frozen_string_literal: true++RSpec.describe UserApiKey::DeviceAuth::GrantStore, type: :multisite do+ let(:device_code) { SecureRandom.hex(32) }++ after { clear_user_api_key_device_auth_redis! }++ it "keeps grants with the same device code isolated by site" do+ default_grant = UserApiKey::DeviceAuth::Grant.new(status: :pending, device_code: device_code)+ second_grant = UserApiKey::DeviceAuth::Grant.new(status: :denied, device_code: device_code)++ described_class.save!(default_grant, ttl: 1.minute)++ test_multisite_connection("second") do+ described_class.save!(second_grant, ttl: 1.minute)+ expect(described_class.load(device_code)).to eq(second_grant)+ described_class.clear!+ expect(described_class.load(device_code)).to be_nil+ end++ expect(described_class.load(device_code)).to eq(default_grant)+ end++ it "releases the original site's lock even if the current connection changes" do+ original_db = RailsMultisite::ConnectionManagement.current_db++ described_class.with_lock!(device_code) do+ RailsMultisite::ConnectionManagement.establish_connection(db: "second")+ end++ RailsMultisite::ConnectionManagement.establish_connection(db: original_db)+ expect(Discourse.redis.get(described_class.lock_key(device_code))).to be_nil+ ensure+ RailsMultisite::ConnectionManagement.establish_connection(db: original_db) if original_db+ end+enddiff --git a/spec/services/user_api_key/device_auth/grant_store_spec.rb b/spec/services/user_api_key/device_auth/grant_store_spec.rbnew file mode 100644index 00000000000..7f2c8cd7cb3--- /dev/null+++ b/spec/services/user_api_key/device_auth/grant_store_spec.rb@@ -0,0 +1,188 @@+# frozen_string_literal: true++RSpec.describe UserApiKey::DeviceAuth::GrantStore do+ let(:device_code) { SecureRandom.hex(32) }+ let(:grant) { UserApiKey::DeviceAuth::Grant.new(status: :pending, device_code: device_code) }++ after { clear_user_api_key_device_auth_redis! }++ describe ".save! and .load" do+ it "stores and loads grants" do+ described_class.save!(grant, ttl: 1.minute)++ expect(described_class.load(device_code)).to eq(grant)+ end++ it "ignores malformed device codes" do+ expect(described_class.load("invalid")).to be_nil+ end++ it "loads serialized grant JSON with string keys" do+ Discourse.redis.setex(+ described_class.grant_key(device_code),+ 1.minute,+ {+ "status" => "pending",+ "device_code" => device_code,+ "user_code" => "ABCD-2345",+ "request_token" => "abcdefgh",+ "authorizing_user_id" => 12,+ "authorizing_username" => "authorizer",+ "authorizing_at" => Time.zone.now.iso8601,+ }.to_json,+ )++ loaded_grant = described_class.load(device_code)++ expect(loaded_grant).to be_pending+ expect(loaded_grant.device_code).to eq(device_code)+ expect(loaded_grant.user_code).to eq("ABCD-2345")+ expect(loaded_grant.request_token).to eq("abcdefgh")+ expect(loaded_grant.authorizing_user_id).to eq(12)+ end++ it "loads authorized and denied serialized grants" do+ authorized_device_code = SecureRandom.hex(32)+ denied_device_code = SecureRandom.hex(32)+ Discourse.redis.setex(+ described_class.grant_key(authorized_device_code),+ 1.minute,+ {+ "status" => "authorized",+ "device_code" => authorized_device_code,+ "payload" => "encrypted-payload",+ "authorized_at" => Time.zone.now.iso8601,+ }.to_json,+ )+ Discourse.redis.setex(+ described_class.grant_key(denied_device_code),+ 1.minute,+ {+ "status" => "denied",+ "device_code" => denied_device_code,+ "denied_at" => Time.zone.now.iso8601,+ }.to_json,+ )++ expect(described_class.load(authorized_device_code)).to be_authorized+ expect(described_class.load(authorized_device_code).payload).to eq("encrypted-payload")+ expect(described_class.load(denied_device_code)).to be_denied+ end++ it "rejects invalid serialized grants" do+ described_class.save!(grant, ttl: 1.minute)+ Discourse.redis.setex(described_class.grant_key(device_code), 1.minute, [].to_json)++ expect(described_class.load(device_code)).to be_nil+ end++ it "rejects serialized grants with unknown fields" do+ Discourse.redis.setex(+ described_class.grant_key(device_code),+ 1.minute,+ { status: "pending", device_code: device_code, unexpected: "value" }.to_json,+ )++ expect(described_class.load(device_code)).to be_nil+ end++ it "rejects grants with mismatched device codes" do+ Discourse.redis.setex(+ described_class.grant_key(device_code),+ 1.minute,+ { status: "pending", device_code: SecureRandom.hex(32) }.to_json,+ )++ expect(described_class.load(device_code)).to be_nil+ end+ end++ describe ".consume_authorized" do+ it "atomically removes and returns an authorized grant" do+ authorized_grant =+ UserApiKey::DeviceAuth::Grant.new(+ status: :authorized,+ device_code: device_code,+ payload: "encrypted-payload",+ )+ described_class.save!(authorized_grant, ttl: 1.minute)++ expect(described_class.consume_authorized(device_code)).to eq(authorized_grant)+ expect(described_class.consume_authorized(device_code)).to be_nil+ expect(described_class.load(device_code)).to be_nil+ end++ it "returns a locked sentinel when the lock is held" do+ authorized_grant =+ UserApiKey::DeviceAuth::Grant.new(+ status: :authorized,+ device_code: device_code,+ payload: "encrypted-payload",+ )+ described_class.save!(authorized_grant, ttl: 1.minute)+ Discourse.redis.setex(+ described_class.lock_key(device_code),+ UserApiKey::DeviceAuth::DEVICE_AUTHORIZATION_LOCK_TTL.to_i,+ SecureRandom.hex,+ )++ expect(described_class.consume_authorized(device_code)).to eq(described_class::CONSUME_LOCKED)+ expect(described_class.load(device_code)).to eq(authorized_grant)+ end++ it "does not consume pending grants" do+ described_class.save!(grant, ttl: 1.minute)++ expect(described_class.consume_authorized(device_code)).to be_nil+ expect(described_class.load(device_code)).to eq(grant)+ end+ end++ describe ".with_lock!" do+ it "runs while holding the grant lock" do+ expect { |block| described_class.with_lock!(device_code, &block) }.to yield_control+ end++ it "releases the owned lock after running" do+ described_class.with_lock!(device_code) do+ expect(Discourse.redis.get(described_class.lock_key(device_code))).to be_present+ end++ expect(Discourse.redis.get(described_class.lock_key(device_code))).to be_nil+ end++ it "raises when the lock is already held" do+ Discourse.redis.setex(+ described_class.lock_key(device_code),+ UserApiKey::DeviceAuth::DEVICE_AUTHORIZATION_LOCK_TTL.to_i,+ SecureRandom.hex,+ )++ expect { described_class.with_lock!(device_code) }.to raise_error(Discourse::InvalidAccess)+ end++ it "does not release a lock claimed by another token" do+ replacement_token = SecureRandom.hex++ described_class.with_lock!(device_code) do+ Discourse.redis.set(described_class.lock_key(device_code), replacement_token)+ end++ expect(Discourse.redis.get(described_class.lock_key(device_code))).to eq(replacement_token)+ end+ end++ describe ".clear!" do+ it "removes only device auth keys" do+ described_class.save!(grant, ttl: 1.minute)+ Discourse.redis.setex("unrelated", 1.minute, "value")++ described_class.clear!++ expect(described_class.load(device_code)).to be_nil+ expect(Discourse.redis.get("unrelated")).to eq("value")+ ensure+ Discourse.redis.del("unrelated")+ end+ end+enddiff --git a/spec/services/user_api_key/device_auth/poll_spec.rb b/spec/services/user_api_key/device_auth/poll_spec.rbnew file mode 100644index 00000000000..5f83b10dcdc--- /dev/null+++ b/spec/services/user_api_key/device_auth/poll_spec.rb@@ -0,0 +1,91 @@+# frozen_string_literal: true++RSpec.describe UserApiKey::DeviceAuth::Poll do+ fab!(:user)++ let(:key) { OpenSSL::PKey::RSA.new(2048) }+ let(:device_request) do+ create_user_api_key_device_auth_request!(+ params: {+ nonce: "nonce",+ scopes: "read",+ client_id: "device-client",+ application_name: "Device Client",+ public_key: key.public_key.to_pem,+ },+ )+ end+ let(:params) { { device_code: device_request[:device_code] } }++ after { clear_user_api_key_device_auth_redis! }++ describe described_class::Contract, type: :model do+ it { is_expected.to validate_presence_of(:device_code) }+ end++ describe ".call" do+ subject(:result) { described_class.call(params: params) }++ it { is_expected.to run_successfully }++ it "returns authorization_pending for a pending grant" do+ expect(result[:poll_response]).to eq(status: "authorization_pending")+ end++ context "with an authorized grant" do+ before do+ UserApiKey::DeviceAuth::Authorize.call(+ params: {+ device_code: device_request[:device_code],+ user_id: user.id,+ },+ )+ end++ it "returns the payload only once" do+ expect(result[:poll_response]).to include(status: "authorized", payload: be_present)+ expect(described_class.call(params: params)[:poll_response]).to eq(status: "expired_token")+ end++ it "returns a retryable response while the authorized grant is locked" do+ grant = UserApiKey::DeviceAuth::GrantStore.load(device_request[:device_code])+ UserApiKey::DeviceAuth::GrantStore.save!(+ grant,+ ttl: UserApiKey::DeviceAuth::GrantStore.ttl_for_update(device_request[:device_code]),+ )+ Discourse.redis.setex(+ UserApiKey::DeviceAuth::GrantStore.lock_key(device_request[:device_code]),+ UserApiKey::DeviceAuth::DEVICE_AUTHORIZATION_LOCK_TTL.to_i,+ SecureRandom.hex,+ )++ expect(result[:poll_response]).to eq(status: "authorization_pending")+ Discourse.redis.del(+ UserApiKey::DeviceAuth::GrantStore.lock_key(device_request[:device_code]),+ )+ expect(described_class.call(params: params)[:poll_response]).to include(+ status: "authorized",+ payload: be_present,+ )+ end+ end++ context "with a denied grant" do+ before { UserApiKey::DeviceAuth::Deny.call(params: params) }++ it "returns access_denied" do+ expect(result[:poll_response]).to eq(status: "access_denied")+ end+ end++ context "with an invalid device code" do+ let(:params) { { device_code: "invalid" } }++ it { is_expected.to run_successfully }++ it "returns expired_token" do+ expect(result[:poll_response]).to eq(status: "expired_token")+ end+ end+ end+enddiff --git a/spec/services/user_api_key/device_auth/user_activation_spec.rb b/spec/services/user_api_key/device_auth/user_activation_spec.rbnew file mode 100644index 00000000000..8c0c220ce32--- /dev/null+++ b/spec/services/user_api_key/device_auth/user_activation_spec.rb@@ -0,0 +1,33 @@+# frozen_string_literal: true++RSpec.describe UserApiKey::DeviceAuth::UserActivation do+ let(:key) { OpenSSL::PKey::RSA.new(2048) }+ let(:session) { {} }+ let(:device_request) do+ create_user_api_key_device_auth_request!(+ params: {+ nonce: "nonce",+ scopes: "read",+ client_id: "device-client",+ application_name: "Device Client",+ public_key: key.public_key.to_pem,+ },+ )+ end++ after { clear_user_api_key_device_auth_redis! }++ describe "#preview_request_token" do+ it "does not preview grants without a user" do+ result =+ described_class.new(+ user: nil,+ session: session,+ request_id: "request-id",+ ).preview_request_token(device_request[:request_token])++ expect(result.status).to eq(:expired_code)+ expect(result.debug_reason).to eq("user_missing")+ end+ end+enddiff --git a/spec/services/user_api_key/device_auth_spec.rb b/spec/services/user_api_key/device_auth_spec.rbnew file mode 100644index 00000000000..7a9e0e555fe--- /dev/null+++ b/spec/services/user_api_key/device_auth_spec.rb@@ -0,0 +1,44 @@+# frozen_string_literal: true++RSpec.describe UserApiKey::DeviceAuth do+ describe ".trace" do+ it "does not raise when an event subscriber raises" do+ listener = ->(*) { raise "boom" }+ DiscourseEvent.on(described_class::TRACE_EVENT, &listener)++ expect {+ described_class.trace("device_auth.test", device_code: SecureRandom.hex(32))+ }.not_to raise_error+ ensure+ DiscourseEvent.off(described_class::TRACE_EVENT, &listener)+ end++ it "reports when verbose logging fails" do+ SiteSetting.verbose_user_api_key_device_auth_logging = true+ allow(Rails.logger).to receive(:info).and_raise("boom")+ allow(Discourse).to receive(:warn_exception)++ expect {+ described_class.trace("device_auth.test", device_code: SecureRandom.hex(32))+ }.not_to raise_error+ expect(Discourse).to have_received(:warn_exception).with(+ an_instance_of(RuntimeError),+ message: "User API key device auth trace failed",+ env: {+ event: "device_auth.test",+ },+ )+ end++ it "truncates string payload values" do+ SiteSetting.verbose_user_api_key_device_auth_logging = true+ logged_message = nil+ allow(Rails.logger).to receive(:info) { |message| logged_message = message }++ described_class.trace("device_auth.test", client_id: "x" * 300)++ logged_payload = JSON.parse(logged_message)+ expect(logged_payload["client_id"]).to eq("x" * described_class::TRACE_MAX_VALUE_LENGTH)+ end+ end+enddiff --git a/spec/support/user_api_key_device_auth_spec_helpers.rb b/spec/support/user_api_key_device_auth_spec_helpers.rbnew file mode 100644index 00000000000..5e5606cc935--- /dev/null+++ b/spec/support/user_api_key_device_auth_spec_helpers.rb@@ -0,0 +1,13 @@+# frozen_string_literal: true++module UserApiKeyDeviceAuthSpecHelpers+ def clear_user_api_key_device_auth_redis!+ UserApiKey::DeviceAuth.clear!+ end++ def create_user_api_key_device_auth_request!(params:, client: nil)+ UserApiKey::DeviceAuth::CreateRequest.call(params: params)[:device_request]+ end+end++RSpec.configure { |config| config.include UserApiKeyDeviceAuthSpecHelpers }diff --git a/spec/system/page_objects/pages/user_api_key_device_auth.rb b/spec/system/page_objects/pages/user_api_key_device_auth.rbnew file mode 100644index 00000000000..75222283d2a--- /dev/null+++ b/spec/system/page_objects/pages/user_api_key_device_auth.rb@@ -0,0 +1,81 @@+# frozen_string_literal: true++module PageObjects+ module Pages+ class UserApiKeyDeviceAuth < PageObjects::Pages::Base+ def visit_activate(request_token: nil)+ path = "/user-api-key/activate"+ path = "#{path}?#{URI.encode_www_form(request: request_token)}" if request_token.present?++ page.visit(path)+ self+ end++ def has_authorization_details?(application_name:, scopes:, username:)+ has_css?(".authorize-api-key h1", text: application_name) &&+ has_css?(".authorize-api-key__username", text: username) &&+ scopes.all? { |scope| has_css?(".authorize-api-key__scopes li", text: scope) }+ end++ def has_write_warning?+ has_css?(+ ".authorize-api-key__write-warning",+ text: I18n.t("user_api_key.write_scope_warning"),+ )+ end++ def has_unregistered_app_warning?+ has_css?(+ ".authorize-api-key__unregistered-warning",+ text: I18n.t("user_api_key.device.unregistered_app_warning"),+ )+ end++ def has_expiry_notice?(application_name:)+ has_css?(".authorize-api-key__expiry", text: "Expires:")+ end++ def enter_code(code)+ input = find("input.authorize-api-key__code-input")+ input.fill_in(with: code.delete("-"))+ page.execute_script(+ "arguments[0].value = arguments[1]; arguments[0].dispatchEvent(new Event('input', { bubbles: true })); arguments[0].dispatchEvent(new Event('change', { bubbles: true }));",+ input.native,+ code.delete("-"),+ )++ self+ end++ def click_continue+ click_button(I18n.t("user_api_key.device.continue"))+ self+ end++ def click_authorize+ if has_css?(+ ".authorize-api-key__buttons .btn-primary",+ text: I18n.t("user_api_key.authorize"),+ wait: 0,+ )+ find(+ ".authorize-api-key__buttons .btn-primary",+ text: I18n.t("user_api_key.authorize"),+ ).click+ else+ click_button(I18n.t("user_api_key.authorize"))+ end+ self+ end++ def has_invalid_code_message?+ has_css?(".form-kit__errors", text: I18n.t("user_api_key.device.invalid_code"))+ end++ def has_completion_message?+ has_css?(".authorize-api-key h1", text: I18n.t("user_api_key.device.complete"), wait: 10) &&+ has_css?(".authorize-api-key p", text: I18n.t("user_api_key.device.return_to_cli"))+ end+ end+ end+enddiff --git a/spec/system/page_objects/pages/user_api_key_show.rb b/spec/system/page_objects/pages/user_api_key_show.rbnew file mode 100644index 00000000000..bb4153d92f0--- /dev/null+++ b/spec/system/page_objects/pages/user_api_key_show.rb@@ -0,0 +1,79 @@+# frozen_string_literal: true++module PageObjects+ module Pages+ class UserApiKeyShow < PageObjects::Pages::Base+ def visit_authorization(public_key:)+ page.visit(+ "/user-api-key/new?#{+ URI.encode_www_form(+ scopes: "read",+ client_id: "x" * 32,+ application_name: "Test Application",+ public_key: public_key,+ nonce: SecureRandom.hex,+ )+ }",+ )++ self+ end++ def visit_otp(public_key:)+ page.visit(+ "/user-api-key/otp?#{+ URI.encode_www_form(+ application_name: "Test Application",+ public_key: public_key,+ auth_redirect: "discourse://auth_redirect",+ )+ }",+ )++ self+ end++ def click_authorize+ click_button(I18n.t("user_api_key.authorize"))+ self+ end++ def click_copy_key+ find("#copy-api-key-btn").click+ self+ end++ def payload+ find("#user-api-key-payload").text+ end++ def has_authorization_form?+ has_css?(".authorize-api-key h1", text: "Test Application") &&+ has_button?(I18n.t("user_api_key.authorize"))+ end++ def has_payload?+ has_css?("#user-api-key-payload") && has_css?("#copy-api-key-btn")+ end++ def has_copied_button?+ has_button?(I18n.t("user_api_key.copied"))+ end++ def has_otp_form?+ has_css?(+ ".authorize-api-key h1",+ text: I18n.t("user_api_key.otp_description", application_name: "Test Application"),+ ) && has_button?(I18n.t("user_api_key.authorize"))+ end++ def has_no_sidebar?+ has_no_css?("#d-sidebar")+ end++ def has_no_powered_by_discourse?+ has_no_css?(".powered-by-discourse")+ end+ end+ end+enddiff --git a/spec/system/user_api_key_device_auth_spec.rb b/spec/system/user_api_key_device_auth_spec.rbnew file mode 100644index 00000000000..dc478b2392d--- /dev/null+++ b/spec/system/user_api_key_device_auth_spec.rb@@ -0,0 +1,74 @@+# frozen_string_literal: true++RSpec.describe "User API key device auth" do+ fab!(:user) { Fabricate(:user, refresh_auto_groups: true) }++ let(:device_auth_page) { PageObjects::Pages::UserApiKeyDeviceAuth.new }+ let(:private_key) { OpenSSL::PKey::RSA.new(2048) }+ let(:application_name) { "Test CLI" }+ let(:expires_in_seconds) { 1.day.to_i }+ let(:request_params) do+ {+ scopes: "read,write",+ client_id: "x" * 32,+ application_name: application_name,+ public_key: private_key.public_key.to_pem,+ nonce: SecureRandom.hex,+ padding: "oaep",+ expires_in_seconds: expires_in_seconds,+ }+ end++ before { SiteSetting.user_api_key_allowed_groups = Group::AUTO_GROUPS[:trust_level_0] }++ after { clear_user_api_key_device_auth_redis! }++ it "allows a user to authorize a device request", time: Time.zone.parse("2026-05-20 12:00:00") do+ device_request = create_user_api_key_device_auth_request!(params: request_params)+ sign_in(user)++ device_auth_page.visit_activate(request_token: device_request[:request_token])++ expect(device_auth_page).to have_authorization_details(+ application_name: application_name,+ scopes: [I18n.t("user_api_key.scopes.read"), I18n.t("user_api_key.scopes.write")],+ username: user.username,+ )+ expect(device_auth_page).to have_write_warning+ expect(device_auth_page).to have_unregistered_app_warning+ expect(device_auth_page).to have_expiry_notice(application_name: application_name)++ device_auth_page.enter_code(device_request[:user_code]).click_authorize++ expect(device_auth_page).to have_completion_message+ end++ it "allows a user to authorize a device request by manually entering the code",+ time: Time.zone.parse("2026-05-20 12:00:00") do+ device_request = create_user_api_key_device_auth_request!(params: request_params)+ sign_in(user)++ device_auth_page.visit_activate.enter_code(device_request[:user_code]).click_continue++ expect(device_auth_page).to have_authorization_details(+ application_name: application_name,+ scopes: [I18n.t("user_api_key.scopes.read"), I18n.t("user_api_key.scopes.write")],+ username: user.username,+ )++ device_auth_page.click_authorize++ expect(device_auth_page).to have_completion_message+ end++ it "rejects an incorrect code for a request token" do+ device_request = create_user_api_key_device_auth_request!(params: request_params)+ sign_in(user)++ device_auth_page.visit_activate(request_token: device_request[:request_token])+ device_auth_page.enter_code("BADCODE1").click_authorize++ expect(device_auth_page).to have_invalid_code_message+ expect(UserApiKey.exists?(user_id: user.id)).to eq(false)+ end+enddiff --git a/spec/system/user_api_key_show_spec.rb b/spec/system/user_api_key_show_spec.rbindex 798e3532a83..b1053624ac0 100644--- a/spec/system/user_api_key_show_spec.rb+++ b/spec/system/user_api_key_show_spec.rb@@ -2,44 +2,56 @@RSpec.describe "User API Key Show Page" dofab!(:user) { Fabricate(:user, refresh_auto_groups: true) }+let(:cdp) { PageObjects::CDP.new }+ let(:user_api_key_page) { PageObjects::Pages::UserApiKeyShow.new }let(:public_key) { OpenSSL::PKey::RSA.new(2048).public_key.to_pem }- before { SiteSetting.user_api_key_allowed_groups = Group::AUTO_GROUPS[:trust_level_0] }+ before do+ SiteSetting.user_api_key_allowed_groups = Group::AUTO_GROUPS[:trust_level_0]+ SiteSetting.navigation_menu = "sidebar"+ SiteSetting.enable_powered_by_discourse = true+ end- it "displays the copy button and copies the payload without whitespace" do+ it "lets a user authorize and copy the generated key" dosign_in(user)- # Visit the authorization page (no auth_redirect means show page after submit)- visit "/user-api-key/new?#{URI.encode_www_form(scopes: "read", client_id: "x" * 32, application_name: "Test Application", public_key: public_key, nonce: SecureRandom.hex)}"+ user_api_key_page.visit_authorization(public_key: public_key)++ expect(user_api_key_page).to have_authorization_form+ expect(user_api_key_page).to have_no_sidebar+ expect(user_api_key_page).to have_no_powered_by_discoursescreenshot_marker(label: "user-api-key-auth")- # Submit the authorization form- click_button I18n.t("user_api_key.authorize")+ user_api_key_page.click_authorize- # Now we should be on the show page- expect(page).to have_css("#user-api-key-payload")- expect(page).to have_css("#copy-api-key-btn")+ expect(user_api_key_page).to have_payload+ expect(user_api_key_page).to have_no_sidebar+ expect(user_api_key_page).to have_no_powered_by_discoursecdp.allow_clipboard- displayed_payload = find("#user-api-key-payload").text-- # The displayed payload should have whitespace (rendered from newlines in Base64.encode64)+ displayed_payload = user_api_key_page.payloadexpect(displayed_payload).to match(/\s/)- find("#copy-api-key-btn").click+ user_api_key_page.click_copy_key- # Verify button text changes to "Copied"- expect(page).to have_button(I18n.t("user_api_key.copied"))+ expect(user_api_key_page).to have_copied_button- # Verify clipboard contains payload without whitespaceclipboard_content = cdp.read_clipboardexpect(clipboard_content).not_to match(/\s/)-- # Verify the copied content can be base64 decodedexpect { Base64.decode64(clipboard_content) }.not_to raise_errorend++ it "keeps one-time password authorization focused" do+ sign_in(user)++ user_api_key_page.visit_otp(public_key: public_key)++ expect(user_api_key_page).to have_otp_form+ expect(user_api_key_page).to have_no_sidebar+ expect(user_api_key_page).to have_no_powered_by_discourse+ endend