Skip to content

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.scss
index 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.scss
index 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.rb
index 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: true
class 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 = 4
ALLOWED_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 = 120
def new
if 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"
return
end
- 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 },
+ )
end
def create
@@ -82,6 +80,7 @@ class UserApiKeysController < ApplicationController
raise 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 limit
otp_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.new
end
end
+ 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 }
end
end
@@ -152,10 +405,15 @@ class UserApiKeysController < ApplicationController
return
end
- @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 }
+ end
end
def create_otp
@@ -167,9 +425,12 @@ class UserApiKeysController < ApplicationController
raise 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 } }
+ end
end
def revoke
@@ -190,6 +451,169 @@ class UserApiKeysController < ApplicationController
render json: success_json
end
+ 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_key
key = UserApiKey.find(params[:id])
raise Discourse::InvalidAccess unless current_user.admin || key.user_id == current_user.id
@@ -256,9 +680,11 @@ class UserApiKeysController < ApplicationController
end
def 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)
end
def meets_tl?
@@ -273,30 +699,173 @@ class UserApiKeysController < ApplicationController
otp = SecureRandom.hex
Discourse.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")
end
end
+
+ 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!
+ end
end
diff --git a/app/models/user_api_key.rb b/app/models/user_api_key.rb
index 67d39d52b03..6746381dd78 100644
--- a/app/models/user_api_key.rb
+++ b/app/models/user_api_key.rb
@@ -12,7 +12,8 @@ class UserApiKey < ActiveRecord::Base
belongs_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::Base
SiteSetting.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 :string
diff --git a/app/serializers/user_serializer.rb b/app/serializers/user_serializer.rb
index fb334f219fd..1087726c667 100644
--- a/app/serializers/user_serializer.rb
+++ b/app/serializers/user_serializer.rb
@@ -162,6 +162,7 @@ class UserSerializer < UserCardSerializer
scopes: 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,
}
end
diff --git a/app/services/user_api_key/device_auth.rb b/app/services/user_api_key/device_auth.rb
new file mode 100644
index 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
+end
diff --git a/app/services/user_api_key/device_auth/approval_token_store.rb b/app/services/user_api_key/device_auth/approval_token_store.rb
new file mode 100644
index 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
+end
diff --git a/app/services/user_api_key/device_auth/authorize.rb b/app/services/user_api_key/device_auth/authorize.rb
new file mode 100644
index 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
+end
diff --git a/app/services/user_api_key/device_auth/code_registry.rb b/app/services/user_api_key/device_auth/code_registry.rb
new file mode 100644
index 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
+end
diff --git a/app/services/user_api_key/device_auth/create_request.rb b/app/services/user_api_key/device_auth/create_request.rb
new file mode 100644
index 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
+end
diff --git a/app/services/user_api_key/device_auth/crypto.rb b/app/services/user_api_key/device_auth/crypto.rb
new file mode 100644
index 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
+end
diff --git a/app/services/user_api_key/device_auth/deny.rb b/app/services/user_api_key/device_auth/deny.rb
new file mode 100644
index 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
+end
diff --git a/app/services/user_api_key/device_auth/grant.rb b/app/services/user_api_key/device_auth/grant.rb
new file mode 100644
index 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
+end
diff --git a/app/services/user_api_key/device_auth/grant_store.rb b/app/services/user_api_key/device_auth/grant_store.rb
new file mode 100644
index 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
+end
diff --git a/app/services/user_api_key/device_auth/key_creator.rb b/app/services/user_api_key/device_auth/key_creator.rb
new file mode 100644
index 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
+end
diff --git a/app/services/user_api_key/device_auth/payload_builder.rb b/app/services/user_api_key/device_auth/payload_builder.rb
new file mode 100644
index 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
+end
diff --git a/app/services/user_api_key/device_auth/poll.rb b/app/services/user_api_key/device_auth/poll.rb
new file mode 100644
index 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
+end
diff --git a/app/services/user_api_key/device_auth/request_validator.rb b/app/services/user_api_key/device_auth/request_validator.rb
new file mode 100644
index 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!
+end
diff --git a/app/services/user_api_key/device_auth/user_activation.rb b/app/services/user_api_key/device_auth/user_activation.rb
new file mode 100644
index 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
+end
diff --git a/app/services/user_api_key/expiry.rb b/app/services/user_api_key/expiry.rb
new file mode 100644
index 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
+end
diff --git a/app/views/user_api_keys/new.html.erb b/app/views/user_api_keys/new.html.erb
deleted file mode 100644
index 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.erb
deleted file mode 100644
index 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.erb
deleted file mode 100644
index 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.yml
index 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.yml
index 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.rb
index b087ea1a7a6..25e15019bae 100644
--- a/config/routes.rb
+++ b/config/routes.rb
@@ -1880,6 +1880,12 @@ Discourse::Application.routes.draw do
get "/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.yml
index c5eb3948fc8..ae7a34339c7 100644
--- a/config/site_settings.yml
+++ b/config/site_settings.yml
@@ -4259,6 +4259,10 @@ user_api:
default: 0
max: 36500
hidden: true
+ max_user_api_key_expiry_days:
+ default: 365
+ max: 36500
+ hidden: true
unused_registered_user_api_key_clients_days:
default: 30
max: 36500
@@ -4267,6 +4271,9 @@ user_api:
default: ""
type: list
hidden: true
+ verbose_user_api_key_device_auth_logging:
+ default: false
+ hidden: true
tags:
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.rb
new file mode 100644
index 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
+end
diff --git a/db/structure.sql b/db/structure.sql
index 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.gjs
new file mode 100644
index 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.gjs
index 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);
+ }
+
@action
toggleScopes(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.js
new file mode 100644
index 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.js
new file mode 100644
index 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.js
new file mode 100644
index 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.js
new file mode 100644
index 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.js
new file mode 100644
index 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.js
index 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.js
new file mode 100644
index 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.js
new file mode 100644
index 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.js
new file mode 100644
index 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.js
new file mode 100644
index 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.gjs
new file mode 100644
index 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.gjs
new file mode 100644
index 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"
+ }}
+ {{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"
+ }}
+ </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"
+ }}
+ </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.gjs
new file mode 100644
index 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"
+ }}
+ </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.gjs
new file mode 100644
index 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.gjs
index 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 {
*/
@action
onInput(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-ignore
this.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.gjs
index 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.rake
new file mode 100644
index 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
+end
diff --git a/spec/lib/auth/default_current_user_provider_spec.rb b/spec/lib/auth/default_current_user_provider_spec.rb
index 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 do
expect { 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" do
before { 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.rb
index 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 do
expect(key.allow?(request_env("PUT", "/random"))).to eq(false)
end
end
+
+ 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
+ end
end
diff --git a/spec/requests/user_api_keys_controller_spec.rb b/spec/requests/user_api_keys_controller_spec.rb
index 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 do
end
def 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" do
it "supports a head request cleanly" do
head "/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" do
SiteSetting.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")
end
describe "as a normal user" do
@@ -55,12 +63,12 @@ RSpec.describe UserApiKeysController do
SiteSetting.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")
end
it "rejects invalid padding parameter" do
@@ -68,55 +76,83 @@ RSpec.describe UserApiKeysController do
expect(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" do
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")
end
it "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)
end
it "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)
end
it "does not show redirect warning when auth_redirect is discourse://auth_redirect" do
SiteSetting.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_nil
end
it "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")
end
it "shows redirect URI without trailing colon for custom scheme URLs" do
SiteSetting.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")
end
it "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,
+ )
end
it "allows auth_redirect when it matches allowed_user_api_auth_redirects" do
SiteSetting.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")
end
end
end
@@ -139,7 +175,7 @@ RSpec.describe UserApiKeysController do
sign_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)
end
it "does not create token unless TL requirement is met" do
@@ -169,7 +205,7 @@ RSpec.describe UserApiKeysController do
post "/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 do
scopes: "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 do
expect(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" do
SiteSetting.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 do
sign_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)
end
it "rejects wildcard auth_redirect matches outside the candidate host" do
@@ -282,7 +354,7 @@ RSpec.describe UserApiKeysController do
sign_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")
end
context "with a registered client" do
@@ -314,7 +386,7 @@ RSpec.describe UserApiKeysController do
it "does not require application_name or public_key params" do
post "/user-api-key.json", params: args.except(:application_name, :public_key)
- expect(response.status).to eq(302)
+ expect(response.status).to eq(200)
end
it "rejects scopes not allowed by client" do
@@ -324,6 +396,541 @@ RSpec.describe UserApiKeysController do
end
end
+ 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" do
it "allows revoking via API key header without id" do
key = Fabricate(:readonly_user_api_key)
@@ -372,15 +979,15 @@ RSpec.describe UserApiKeysController do
end
describe "#otp" do
- it "includes padding parameter in the form only when provided" do
+ it "includes padding parameter in the model only when provided" do
SiteSetting.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")
end
it "rejects invalid padding parameter" do
@@ -390,6 +997,15 @@ RSpec.describe UserApiKeysController do
expect(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" do
SiteSetting.allowed_user_api_auth_redirects = "https://*.example.com/callback"
@@ -419,9 +1035,13 @@ RSpec.describe UserApiKeysController do
expect(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)
end
diff --git a/spec/serializers/user_serializer_spec.rb b/spec/serializers/user_serializer_spec.rb
index 8f2b2fa0290..7c2d8853a58 100644
--- a/spec/serializers/user_serializer_spec.rb
+++ b/spec/serializers/user_serializer_spec.rb
@@ -477,6 +477,24 @@ RSpec.describe UserSerializer do
expect(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)
+ end
end
context "with user_passkeys" do
diff --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.rb
new file mode 100644
index 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
+end
diff --git a/spec/services/user_api_key/device_auth/authorize_spec.rb b/spec/services/user_api_key/device_auth/authorize_spec.rb
new file mode 100644
index 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
+end
diff --git a/spec/services/user_api_key/device_auth/code_registry_spec.rb b/spec/services/user_api_key/device_auth/code_registry_spec.rb
new file mode 100644
index 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
+end
diff --git a/spec/services/user_api_key/device_auth/create_request_spec.rb b/spec/services/user_api_key/device_auth/create_request_spec.rb
new file mode 100644
index 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
+end
diff --git a/spec/services/user_api_key/device_auth/crypto_spec.rb b/spec/services/user_api_key/device_auth/crypto_spec.rb
new file mode 100644
index 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
+end
diff --git a/spec/services/user_api_key/device_auth/deny_spec.rb b/spec/services/user_api_key/device_auth/deny_spec.rb
new file mode 100644
index 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
+end
diff --git a/spec/services/user_api_key/device_auth/grant_spec.rb b/spec/services/user_api_key/device_auth/grant_spec.rb
new file mode 100644
index 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
+end
diff --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.rb
new file mode 100644
index 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
+end
diff --git a/spec/services/user_api_key/device_auth/grant_store_spec.rb b/spec/services/user_api_key/device_auth/grant_store_spec.rb
new file mode 100644
index 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
+end
diff --git a/spec/services/user_api_key/device_auth/poll_spec.rb b/spec/services/user_api_key/device_auth/poll_spec.rb
new file mode 100644
index 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
+end
diff --git a/spec/services/user_api_key/device_auth/user_activation_spec.rb b/spec/services/user_api_key/device_auth/user_activation_spec.rb
new file mode 100644
index 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
+end
diff --git a/spec/services/user_api_key/device_auth_spec.rb b/spec/services/user_api_key/device_auth_spec.rb
new file mode 100644
index 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
+end
diff --git a/spec/support/user_api_key_device_auth_spec_helpers.rb b/spec/support/user_api_key_device_auth_spec_helpers.rb
new file mode 100644
index 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.rb
new file mode 100644
index 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
+end
diff --git a/spec/system/page_objects/pages/user_api_key_show.rb b/spec/system/page_objects/pages/user_api_key_show.rb
new file mode 100644
index 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
+end
diff --git a/spec/system/user_api_key_device_auth_spec.rb b/spec/system/user_api_key_device_auth_spec.rb
new file mode 100644
index 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
+end
diff --git a/spec/system/user_api_key_show_spec.rb b/spec/system/user_api_key_show_spec.rb
index 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" do
fab!(: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" do
sign_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_discourse
screenshot_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_discourse
cdp.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.payload
expect(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 whitespace
clipboard_content = cdp.read_clipboard
expect(clipboard_content).not_to match(/\s/)
-
- # Verify the copied content can be base64 decoded
expect { Base64.decode64(clipboard_content) }.not_to raise_error
end
+
+ 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
+ end
end