From 9c37c308adc063f000a951fd407fe911413a7b63 Mon Sep 17 00:00:00 2001 From: Stephen von Takach Date: Mon, 2 Nov 2026 18:07:41 +1100 Subject: [PATCH 1/2] fix(security): cap JWT permissions by the user's current admin/support Port of PlaceOS/rest-api 8779928. authorize! already loads the user row for bearer JWTs, but sys_admin and support were read only from the token claims, so revoking them had no effect until the token expired. The decoded JWT is now capped to the user's current permissions, so every is_admin?/is_support? check sees the effective value. A token is never raised above its claims. API keys keep their stored permissions, which may exceed the owner's. Requests from deleted (hard or soft) users now return 401 on both the JWT and API key paths, rather than proceeding or returning 404 from the RecordNotFound raised by User.find. Mock::Token.office/google claim Admin but named a non-admin user, so the mocks now mark that user sys_admin to keep spec behaviour unchanged. Co-Authored-By: Claude Opus 5.5 --- spec/controllers/live_permissions_spec.cr | 131 ++++++++++++++++++++++ spec/spec_helper.cr | 16 ++- src/controllers/utilities/current-user.cr | 40 ++++++- 3 files changed, 183 insertions(+), 4 deletions(-) create mode 100644 spec/controllers/live_permissions_spec.cr diff --git a/spec/controllers/live_permissions_spec.cr b/spec/controllers/live_permissions_spec.cr new file mode 100644 index 00000000..c40c89d8 --- /dev/null +++ b/spec/controllers/live_permissions_spec.cr @@ -0,0 +1,131 @@ +require "../spec_helper" +require "./helpers/survey_helper" + +# sys_admin / support are capped by the user's current model, so revoking them applies +# before the JWT expires. API keys deliberately keep their own stored permissions. +describe "live user permissions" do + client = AC::SpecHelper.client + domain = "toby.staff-api.dev" + admin_path = Tenants.base_route # is_admin? + + new_user = ->(sys_admin : Bool, support : Bool) do + # ensures the spec authority exists + Mock::Token.office + authority = PlaceOS::Model::Authority.find_by_domain(domain).not_nil! + PlaceOS::Model::Generator.user(authority, support: support, admin: sys_admin).save! + end + + bearer_headers = ->(user : PlaceOS::Model::User) do + permissions = UserJWT::Permissions::User + permissions |= UserJWT::Permissions::Admin if user.sys_admin + permissions |= UserJWT::Permissions::Support if user.support + token = UserJWT.new( + iss: "staff-api", + iat: Time.local, + exp: Time.local + 1.week, + domain: domain, + id: user.id.as(String), + scope: [UserJWT::Scope::PUBLIC], + user: UserJWT::Metadata.new( + name: user.name.as(String), + email: user.email.to_s, + permissions: permissions, + ), + ) + HTTP::Headers{ + "Host" => domain, + "Authorization" => "Bearer #{token.encode}", + } + end + + api_key_headers = ->(user : PlaceOS::Model::User, permissions : UserJWT::Permissions) do + key = PlaceOS::Model::ApiKey.new(name: "live-permissions-#{user.id}") + key.user = user + key.permissions = permissions + key.x_api_key + key.save! + HTTP::Headers{ + "Host" => domain, + "X-API-Key" => key.x_api_key.not_nil!, + } + end + + # survey questions may only be created by support (or admin) + create_question = ->(headers : HTTP::Headers) do + question = SurveyHelper.question_responders.first.to_json + client.post(Surveys::Questions.base_route, headers: headers, body: question).status_code + end + + it "revokes admin and support from a JWT once the user is demoted" do + user = new_user.call(true, true) + headers = bearer_headers.call(user) + client.get(admin_path, headers: headers).status_code.should eq 200 + create_question.call(headers).should eq 201 + + user.sys_admin = false + user.support = false + user.save! + + client.get(admin_path, headers: headers).status_code.should eq 403 + create_question.call(headers).should eq 403 + end + + it "downgrades an admin JWT to support when only admin is revoked" do + user = new_user.call(true, true) + headers = bearer_headers.call(user) + + user.sys_admin = false + user.save! + + client.get(admin_path, headers: headers).status_code.should eq 403 + create_question.call(headers).should eq 201 + end + + it "does not elevate a JWT when the user is promoted" do + user = new_user.call(false, false) + headers = bearer_headers.call(user) + + user.sys_admin = true + user.support = true + user.save! + + client.get(admin_path, headers: headers).status_code.should eq 403 + create_question.call(headers).should eq 403 + end + + it "lets an API key grant more than its owner holds" do + user = new_user.call(false, false) + headers = api_key_headers.call(user, UserJWT::Permissions::AdminSupport) + + client.get(admin_path, headers: headers).status_code.should eq 200 + create_question.call(headers).should eq 201 + end + + it "rejects a JWT for a deleted user with 401" do + user = new_user.call(true, true) + headers = bearer_headers.call(user) + user.destroy + + client.get(admin_path, headers: headers).status_code.should eq 401 + end + + it "rejects a JWT for a soft deleted user with 401" do + user = new_user.call(true, true) + headers = bearer_headers.call(user) + user.deleted = true + user.save! + + client.get(admin_path, headers: headers).status_code.should eq 401 + end + + it "rejects an API key for a soft deleted user with 401" do + user = new_user.call(false, false) + headers = api_key_headers.call(user, UserJWT::Permissions::AdminSupport) + client.get(admin_path, headers: headers).status_code.should eq 200 + + user.deleted = true + user.save! + + client.get(admin_path, headers: headers).status_code.should eq 401 + end +end diff --git a/spec/spec_helper.cr b/spec/spec_helper.cr index 6115261c..ae2b6608 100644 --- a/spec/spec_helper.cr +++ b/spec/spec_helper.cr @@ -80,7 +80,7 @@ module Mock # office_mock_token def office(sys_admin = false, support = false, groups = ["manage", "admin"]) - user = generate_auth_user(sys_admin, support, groups) + user = admin_user(sys_admin, support, groups) UserJWT.new( iss: "staff-api", iat: Time.local, @@ -135,7 +135,7 @@ module Mock # google_mock_token def google(sys_admin = false, support = false, groups = ["manage", "admin"]) - user = generate_auth_user(sys_admin, support, groups) + user = admin_user(sys_admin, support, groups) UserJWT.new( iss: "staff-api", iat: Time.local, @@ -152,6 +152,18 @@ module Mock ).encode end + # `office` and `google` tokens claim Admin, and authorize! caps a token to the user's + # current permissions, so the user they name must be a sys_admin too. The flags only + # pick which user (email) the token is for. + def admin_user(sys_admin, support, groups) + user = generate_auth_user(sys_admin, support, groups) + unless user.sys_admin + user.sys_admin = true + user.save! + end + user + end + def generate_auth_user(sys_admin, support, groups = [] of String) CREATION_LOCK.synchronize do org_zone diff --git a/src/controllers/utilities/current-user.cr b/src/controllers/utilities/current-user.cr index 603ab373..1f72d9ef 100644 --- a/src/controllers/utilities/current-user.cr +++ b/src/controllers/utilities/current-user.cr @@ -25,10 +25,12 @@ module Utils::CurrentUser begin api_key = ::PlaceOS::Model::ApiKey.find_key!(token) raise Error::Unauthorized.new "API key has expired" if api_key.expired? + user = active_user!(api_key.user_id.as(String)) + # API keys keep their stored permissions, which may exceed the owner's user_token = api_key.build_jwt Log.context.set(api_key_id: api_key.id, api_key_name: api_key.name) @api_key = api_key - @current_user = ::PlaceOS::Model::User.find(user_token.id) + @current_user = user return @user_token = user_token rescue e : Error::Unauthorized raise e @@ -44,12 +46,14 @@ module Utils::CurrentUser begin user_token = UserJWT.decode(token) - if !user_token.guest_scope? && (user_model = ::PlaceOS::Model::User.find(user_token.id)) + unless user_token.guest_scope? + user_model = active_user!(user_token.id) logged_out_at = user_model.logged_out_at if logged_out_at && (logged_out_at >= user_token.iat) raise JWT::Error.new("logged out") end @current_user = user_model + user_token = cap_permissions(user_token, user_model) end @user_token = user_token @@ -64,6 +68,38 @@ module Utils::CurrentUser raise e end + # Tokens outlive the user record, so a deleted user's credentials must be refused + private def active_user!(id : String) : ::PlaceOS::Model::User + user = ::PlaceOS::Model::User.find?(id) + raise Error::Unauthorized.new("user not found") if user.nil? || user.deleted + user + end + + # A JWT can't grant more than the user currently holds, so revoking sys_admin or + # support applies before the token expires. Promotions still need a new token. + private def cap_permissions(token : UserJWT, user : ::PlaceOS::Model::User) : UserJWT + held = UserJWT::Permissions::User + held |= UserJWT::Permissions::Admin if user.sys_admin + held |= UserJWT::Permissions::Support if user.support + meta = token.user + return token if meta.permissions <= held + + UserJWT.new( + iss: token.iss, + iat: token.iat, + exp: token.exp, + domain: token.domain, + id: token.id, + scope: token.scope, + user: UserJWT::Metadata.new( + name: meta.name, + email: meta.email, + permissions: held, + roles: meta.roles, + ), + ) + end + # Getter for user_token def user_token : UserJWT # FIXME: Remove when action-controller respects the ordering of route callbacks From 0ad4a649a9ec3f6472dcd2cb9186764850f3f5f7 Mon Sep 17 00:00:00 2001 From: Stephen von Takach Date: Mon, 2 Nov 2026 18:14:12 +1100 Subject: [PATCH 2/2] fix(auth): take JWT sys_admin/support from the user record The user record now decides permissions for bearer JWTs, rather than only capping the token's claims, so a promotion also applies to existing sessions without the user signing in again. API keys keep their own stored permissions. Co-Authored-By: Claude Opus 5.5 --- spec/controllers/live_permissions_spec.cr | 13 ++++++++----- spec/spec_helper.cr | 6 +++--- src/controllers/utilities/current-user.cr | 10 +++++----- 3 files changed, 16 insertions(+), 13 deletions(-) diff --git a/spec/controllers/live_permissions_spec.cr b/spec/controllers/live_permissions_spec.cr index c40c89d8..597727b5 100644 --- a/spec/controllers/live_permissions_spec.cr +++ b/spec/controllers/live_permissions_spec.cr @@ -1,8 +1,8 @@ require "../spec_helper" require "./helpers/survey_helper" -# sys_admin / support are capped by the user's current model, so revoking them applies -# before the JWT expires. API keys deliberately keep their own stored permissions. +# sys_admin / support come from the user's current model, not the JWT claims, so changes +# apply to existing sessions. API keys deliberately keep their own stored permissions. describe "live user permissions" do client = AC::SpecHelper.client domain = "toby.staff-api.dev" @@ -81,16 +81,19 @@ describe "live user permissions" do create_question.call(headers).should eq 201 end - it "does not elevate a JWT when the user is promoted" do + it "elevates a JWT when the user is promoted" do user = new_user.call(false, false) headers = bearer_headers.call(user) + client.get(admin_path, headers: headers).status_code.should eq 403 + create_question.call(headers).should eq 403 + user.sys_admin = true user.support = true user.save! - client.get(admin_path, headers: headers).status_code.should eq 403 - create_question.call(headers).should eq 403 + client.get(admin_path, headers: headers).status_code.should eq 200 + create_question.call(headers).should eq 201 end it "lets an API key grant more than its owner holds" do diff --git a/spec/spec_helper.cr b/spec/spec_helper.cr index ae2b6608..4fba515f 100644 --- a/spec/spec_helper.cr +++ b/spec/spec_helper.cr @@ -152,9 +152,9 @@ module Mock ).encode end - # `office` and `google` tokens claim Admin, and authorize! caps a token to the user's - # current permissions, so the user they name must be a sys_admin too. The flags only - # pick which user (email) the token is for. + # `office` and `google` tokens claim Admin, but authorize! takes permissions from the + # user record, so the user they name must be a sys_admin. The flags only pick which + # user (email) the token is for. def admin_user(sys_admin, support, groups) user = generate_auth_user(sys_admin, support, groups) unless user.sys_admin diff --git a/src/controllers/utilities/current-user.cr b/src/controllers/utilities/current-user.cr index 1f72d9ef..c6d6f994 100644 --- a/src/controllers/utilities/current-user.cr +++ b/src/controllers/utilities/current-user.cr @@ -53,7 +53,7 @@ module Utils::CurrentUser raise JWT::Error.new("logged out") end @current_user = user_model - user_token = cap_permissions(user_token, user_model) + user_token = apply_user_permissions(user_token, user_model) end @user_token = user_token @@ -75,14 +75,14 @@ module Utils::CurrentUser user end - # A JWT can't grant more than the user currently holds, so revoking sys_admin or - # support applies before the token expires. Promotions still need a new token. - private def cap_permissions(token : UserJWT, user : ::PlaceOS::Model::User) : UserJWT + # The user record, not the JWT claims, decides sys_admin / support, so permission + # changes apply to existing sessions without the user signing in again. + private def apply_user_permissions(token : UserJWT, user : ::PlaceOS::Model::User) : UserJWT held = UserJWT::Permissions::User held |= UserJWT::Permissions::Admin if user.sys_admin held |= UserJWT::Permissions::Support if user.support meta = token.user - return token if meta.permissions <= held + return token if meta.permissions == held UserJWT.new( iss: token.iss,