Admin panel, login throttling, and Cloudflare edge hardening (#150)

* Document the remote shell for production user management

* add sitemap to footer links

* remove border under theme selection

* Add admin theme and user management (#144)

Add /admin/themes CRUD and /admin/users list/detail with role and plan editing, guarded by a shared Policy module. Include last-super-admin and self-role protections plus structured id-only admin logs.

Also add admin invitations, confirmation resends and password-reset emails, which work in development through the Swoosh mailbox before SES is configured.

* Rate-limit password logins and emit auth events (#142)

Add a two-bucket login throttle (5 failures per login, 10 per IP in a 15-minute window) and a shared client-address helper for controllers and LiveViews. Blocked attempts skip the database and bcrypt.

Log auth.login.failed and auth.login.throttled warnings with boot-scoped HMAC addresses only, and stop repeated confirmation emails on unconfirmed login attempts.

* Harden the production login edge for Cloudflare

Document the layered login defence: the app throttle is primary, Caddy must pass Cloudflare's CF-Connecting-IP to the app, and Cloudflare edge rate limiting covers request floods.

Update the reference Caddyfile to accept only Cloudflare ranges and reject direct-to-origin traffic, and document the exact Cloudflare dashboard rules.

* Document 10-second Cloudflare rate-limit window

Cloudflare may only offer a 10-second period. Keep the edge rule at 10 login POSTs per 10 seconds per IP and rely on the app's 15-minute login/address throttle for credential guessing.

* Document Cloudflare limits for LiveView registration

Registration submits over the shared LiveView socket, so a Cloudflare rule on POST /users/register will not count account creations. Note the app-level throttle/Turnstile options instead.

* Document current Cloudflare free-plan edge controls

Record the production setup: Cloudflare-only Caddy origins, Bot Fight Mode, and the 10-second login flood rule (10 POSTs per 10 seconds, 10-second block). Clarify that the application's 15-minute throttle remains the real credential lockout.

* Auto-refresh Cloudflare CIDRs for Caddy

Move the origin allowlist into a generated cloudflare-ranges.caddy imported by Caddy. Add an hourly systemd timer and script that fetch Cloudflare's v4/v6 lists, reject malformed responses, validate the candidate Caddyfile, and reload Caddy only when the ranges change. Restore the previous file on validation or reload failure.

* Document Cloudflare CIDR refresher setup and operations

Record the installed paths, permissions, timer checks, manual run, update procedure, and the direct-on-VPS setup fallback when the deploy directory is absent.
This commit is contained in:
2026-11-11 21:27:59 +01:00
committed by GitHub
parent 202b9b1f6a
commit 624ddab644
45 changed files with 3602 additions and 70 deletions
+100
View File
@@ -0,0 +1,100 @@
defmodule Chesstrainer.Accounts.Policy do
@moduledoc """
The single source of truth for administrator capabilities.
Roles are ordered by `Chesstrainer.Accounts.Role`. An administrator may only
manage users below their own rank; a `super_admin` may also manage admins and
other super admins, but never changes their own role.
The router uses `can?/2` to gate the admin area, and every mutating admin
LiveView calls back into this module or into the scoped `Accounts` functions
so hidden buttons are never the only protection.
"""
alias Chesstrainer.Accounts.{Role, Scope, User}
@capabilities %{
manage_endgames: [:admin, :super_admin],
manage_themes: [:admin, :super_admin],
manage_users: [:admin, :super_admin]
}
@doc "All admin capabilities."
@spec capabilities() :: [atom()]
def capabilities, do: Map.keys(@capabilities)
@doc """
Returns true when the scope may perform the given admin capability.
A nil scope or a member/moderator never satisfies an admin capability.
"""
@spec can?(Scope.t() | nil, atom()) :: boolean()
def can?(%Scope{user: %User{role: role}}, capability) when is_atom(capability) do
role in Map.get(@capabilities, capability, [])
end
def can?(_scope, _capability), do: false
@doc """
Returns true when the scope may edit the target user's role and plan.
An actor may only modify a user whose role rank is strictly lower, except a
`super_admin`, who may also modify admins and other super admins. Nobody may
modify themselves through the admin area.
"""
@spec can_manage_user?(Scope.t() | nil, User.t()) :: boolean()
def can_manage_user?(%Scope{user: %User{} = actor} = scope, %User{} = target) do
cond do
not can?(scope, :manage_users) -> false
actor.id == target.id -> false
actor.role == :super_admin -> true
Role.rank(actor.role) > Role.rank(target.role) -> true
true -> false
end
end
def can_manage_user?(_scope, _target), do: false
@doc """
Returns true when the scope may view the target user in the admin area.
Admins can see themselves and lower-ranked users read-only; super admins can
see everyone. This is deliberately wider than `can_manage_user?/2`, which
controls the editable form.
"""
@spec can_view_user?(Scope.t() | nil, User.t()) :: boolean()
def can_view_user?(%Scope{user: %User{} = actor} = scope, %User{} = target) do
can?(scope, :manage_users) and
(actor.id == target.id or actor.role == :super_admin or
Role.rank(actor.role) > Role.rank(target.role))
end
def can_view_user?(_scope, _target), do: false
@doc """
Returns true when the scope may assign the given role.
Admins can only assign member or moderator. Super admins can assign any role.
"""
@spec can_assign_role?(Scope.t() | nil, Role.value()) :: boolean()
def can_assign_role?(%Scope{user: %User{role: :super_admin}}, role) do
role in Role.values()
end
def can_assign_role?(%Scope{user: %User{role: actor_role}}, role) do
role in Role.values() and Role.rank(actor_role) > Role.rank(role)
end
def can_assign_role?(_scope, _role), do: false
@doc """
Returns the roles whose users the scope may see in the admin user list.
Admins only see members and moderators; super admins see every role.
"""
@spec visible_roles(Scope.t() | nil) :: [Role.value()]
def visible_roles(%Scope{user: %User{role: :super_admin}}), do: Role.values()
def visible_roles(%Scope{user: %User{role: :admin}}), do: [:member, :moderator]
def visible_roles(_scope), do: []
end