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
+10
View File
@@ -39,6 +39,16 @@ config :chesstrainer,
ecto_repos: [Chesstrainer.Repo],
generators: [timestamp_type: :utc_datetime]
# Password-login throttle. Failures are counted in fixed windows for each
# client address and each normalised login. The address bucket is deliberately
# wider so one account stays protected from distributed guessing while one
# address cannot spray many accounts.
config :chesstrainer, ChesstrainerWeb.LoginThrottle,
window_ms: :timer.minutes(15),
max_per_login: 5,
max_per_ip: 10,
confirmation_cooldown_ms: :timer.minutes(15)
# Glicko rating system.
#
# `system_constant` is the volatility constraint passed through to the Glicko
+27 -4
View File
@@ -3,13 +3,36 @@
# This file is not installed automatically. On the shared VPS, add this block
# to the existing Caddy config by hand, then validate and reload Caddy.
#
# The app listens on loopback only; Caddy is the public entry point.
# Cloudflare sits in front of Caddy. Two things matter here:
#
# 1. Only accept requests from Cloudflare's published edge ranges.
# 2. Replace X-Forwarded-For with Cloudflare's single-value CF-Connecting-IP
# header, so the app's TRUST_FORWARDED_FOR=true path sees the visitor, not a
# Cloudflare edge address.
#
# The ranges live in cloudflare-ranges.caddy next to this file. A systemd
# timer refreshes them from https://www.cloudflare.com/ips-v4 and /ips-v6;
# see deploy/update-cloudflare-ranges.sh and deploy/README.md.
innersquare.app {
encode zstd gzip
reverse_proxy 127.0.0.1:4100
encode zstd gzip
@cloudflare {
import cloudflare-ranges.caddy
}
handle @cloudflare {
reverse_proxy 127.0.0.1:4100 {
header_up X-Forwarded-For {http.request.header.CF-Connecting-IP}
}
}
# Direct-to-origin requests cannot spoof Cloudflare's client-IP header.
handle {
respond "Access Denied" 403
}
}
www.innersquare.app {
redir https://innersquare.app{uri} permanent
redir https://innersquare.app{uri} permanent
}
+171 -8
View File
@@ -4,9 +4,10 @@ Phoenix release on the shared Ubuntu VPS, behind Caddy, with Postgres in Docker.
```text
Internet
└─ Caddy :443
└─ Phoenix release 127.0.0.1:4100
└─ Postgres 127.0.0.1:5432
└─ Cloudflare (TLS, WAF, edge rate limiting)
└─ Caddy :443 (cloudflare ranges only)
└─ Phoenix release 127.0.0.1:4100
└─ Postgres 127.0.0.1:5432
```
## Pinned versions
@@ -442,13 +443,30 @@ is in place.
## Caddy
On the current VPS the Caddyfile is a single file with no imports. Add the block
from `deploy/Caddyfile` by hand:
Add the site block from `deploy/Caddyfile` by hand. It imports
`cloudflare-ranges.caddy`, which is generated by
`deploy/update-cloudflare-ranges.sh` and refreshed by a systemd timer.
Caddy must only accept Cloudflare traffic and must replace `X-Forwarded-For`
with Cloudflare's `CF-Connecting-IP` value:
```caddy
innersquare.app {
encode zstd gzip
reverse_proxy 127.0.0.1:4100
@cloudflare {
import cloudflare-ranges.caddy
}
handle @cloudflare {
reverse_proxy 127.0.0.1:4100 {
header_up X-Forwarded-For {http.request.header.CF-Connecting-IP}
}
}
handle {
respond "Access Denied" 403
}
}
www.innersquare.app {
@@ -456,7 +474,72 @@ www.innersquare.app {
}
```
If a new VPS uses imports, put the block in its own site file instead.
Install the range file and the hourly refresh timer:
```sh
sudo install -m 0755 /opt/chesstrainer/src/deploy/update-cloudflare-ranges.sh \
/usr/local/sbin/chesstrainer-update-cloudflare-ranges
sudo install -m 0644 /opt/chesstrainer/src/deploy/cloudflare-ranges.caddy \
/etc/caddy/cloudflare-ranges.caddy
sudo install -m 0644 /opt/chesstrainer/src/deploy/chesstrainer-cloudflare-ranges.service \
/etc/systemd/system/chesstrainer-cloudflare-ranges.service
sudo install -m 0644 /opt/chesstrainer/src/deploy/chesstrainer-cloudflare-ranges.timer \
/etc/systemd/system/chesstrainer-cloudflare-ranges.timer
```
The installed pieces are:
| Path | Mode | Purpose |
|---|---|---|
| `/usr/local/sbin/chesstrainer-update-cloudflare-ranges` | `0755` | fetch/validate/reload script |
| `/etc/caddy/cloudflare-ranges.caddy` | `0644` | generated `remote_ip` list |
| `/etc/systemd/system/chesstrainer-cloudflare-ranges.service` | `0644` | oneshot service |
| `/etc/systemd/system/chesstrainer-cloudflare-ranges.timer` | `0644` | hourly timer |
If `/opt/chesstrainer/src/deploy` is not present on the VPS, create the same
four files directly with `sudo tee` from the canonical contents in `deploy/`.
The timer only depends on the installed copies; it does not read the repo.
Run it once manually and enable the timer:
```sh
sudo systemctl daemon-reload
sudo systemctl enable --now chesstrainer-cloudflare-ranges.timer
sudo systemctl start chesstrainer-cloudflare-ranges.service
sudo journalctl -u chesstrainer-cloudflare-ranges.service -n 50 --no-pager
```
The script fetches <https://www.cloudflare.com/ips-v4> and
<https://www.cloudflare.com/ips-v6>, validates the result, and reloads Caddy
only when the ranges actually changed. If the download, Caddy validation or
reload fails, it keeps or restores the previous file.
Check the timer and last run:
```sh
systemctl list-timers chesstrainer-cloudflare-ranges.timer
systemctl status chesstrainer-cloudflare-ranges.service
journalctl -u chesstrainer-cloudflare-ranges.service --since "24 hours ago"
```
Do not edit `/etc/caddy/cloudflare-ranges.caddy` by hand; the next timer run
overwrites it.
To update the refresher itself, replace the installed script or unit files from
the deploy directory, then:
```sh
sudo systemctl daemon-reload
sudo systemctl restart chesstrainer-cloudflare-ranges.timer
sudo systemctl start chesstrainer-cloudflare-ranges.service
```
Without this, `TRUST_FORWARDED_FOR=true` records a Cloudflare edge address
instead of the visitor, and the login throttle and guest puzzle limit bucket
whole Cloudflare POPs together.
If a new VPS uses imports, put the site block in its own file instead; keep the
`import cloudflare-ranges.caddy` path next to the Caddyfile.
Do **not** switch Caddy until a release is running and verified on
`127.0.0.1:4100`. Before that, keep the static coming-soon site live.
@@ -468,8 +551,16 @@ sudo caddy validate --config /etc/caddy/Caddyfile
sudo systemctl reload caddy
```
A direct request to the origin with a forged `CF-Connecting-IP` header should
receive `403 Access Denied`.
Do not let a deploy overwrite the shared Caddyfile.
See `docs/security.md` for the application throttle, real-IP setup and the
Cloudflare edge controls. Production currently has Bot Fight Mode enabled and
the free-plan login flood rule: 10 POSTs per 10 seconds per IP, blocked for 10
seconds.
## Building a release
Build on a machine matching Ubuntu 24.04 / glibc 2.39, or let CI do it.
@@ -694,6 +785,75 @@ Set `Storage=persistent` and a `SystemMaxUse=` value in
rate-limits bursts; if a crash storm drops lines, raise `RateLimitBurst` or
`RateLimitIntervalSec` there.
## Interactive shell and user management
Attach an IEx shell to the **running** release. This does not restart the
service and does not require direct database access:
```sh
sudo /opt/chesstrainer/current/bin/chesstrainer remote
```
You should get a prompt like `iex(chesstrainer@<host>)1>`. Exit with **Ctrl-C
twice**. Never call `System.halt/0`, `:init.stop/0`, or
`Application.stop(:chesstrainer)` from this shell — those stop production.
Use it for account and role management. Go through the application contexts
(not SQL) so changesets, bcrypt hashing, timestamps, and token bookkeeping stay
consistent:
```elixir
# Look up by email or username
u = Chesstrainer.Accounts.get_user_by_login("owen")
# Promote or demote
{:ok, u} = Chesstrainer.Accounts.update_user_role(u, :super_admin)
# Confirm an account without sending email
{:ok, u} = Chesstrainer.Repo.update(Chesstrainer.Accounts.User.confirm_changeset(u))
# Create an account, generating its password server-side
pw = :crypto.strong_rand_bytes(18) |> Base.url_encode64(padding: false)
{:ok, u} =
Chesstrainer.Accounts.register_user(%{
email: "you@example.com",
username: "owen",
password: pw
})
{:ok, u} = Chesstrainer.Repo.update(Chesstrainer.Accounts.User.confirm_changeset(u))
pw
```
Notes:
- `register_user/1` hashes the password with bcrypt; `password` is virtual and
is never written to the database.
- Do not type passwords into the shell if you can avoid it — IEx may keep a
history file — and never paste a password from shell history. Generate one as
above and change it later at `/users/profile/settings`.
- `mix accounts.promote` still works when a compiled source checkout is present
on the host, but the release shell is the supported production path.
- There is no guard against demoting the last `super_admin` outside the future
admin UI, so check the result before demoting.
If `remote` fails while booting its client VM (for example
`Kernel pid terminated (logger)` with `code_server`/`persistent_term` in the
trace), the deployed release is stale, mixed, or missing IEx: rebuild and
redeploy it. To attach in the meantime, use the release's own ERTS:
```sh
sudo bash -c '
COOKIE=$(cat /opt/chesstrainer/current/releases/COOKIE)
exec /opt/chesstrainer/current/erts-*/bin/erl \
-sname debug -setcookie "$COOKIE" -remsh chesstrainer
'
```
That shell speaks Erlang syntax, so quote Elixir module atoms, e.g.
`'Elixir.Chesstrainer.Accounts':register_user(...)`.
## Backups
`docker exec` connects over the container's Unix socket, which the Postgres
@@ -753,6 +913,9 @@ the VPS regularly. A backup that is only on the VPS is not a backup.
until a release exists.
6. Release built on a matching Ubuntu runner and activated.
7. `/health` and `/` verified on `127.0.0.1:4100`.
8. Caddy block added, validated, reloaded.
8. Caddy block, `cloudflare-ranges.caddy`, and the CIDR refresh timer added;
validated and reloaded.
9. Public `/`, `/privacy`, `/terms-conditions`, and `/health` verified.
10. Read-only role created, tunnel verified, backups scheduled and tested.
11. Remote shell attaches and exits cleanly:
`sudo /opt/chesstrainer/current/bin/chesstrainer remote` (Ctrl-C twice).
@@ -0,0 +1,11 @@
[Unit]
Description=Refresh Cloudflare CIDRs for Caddy
Documentation=https://github.com/TheRealOwenRees/chess-endgame-trainer/blob/main/docs/security.md
After=network-online.target
Wants=network-online.target
[Service]
Type=oneshot
ExecStart=/usr/local/sbin/chesstrainer-update-cloudflare-ranges
TimeoutStartSec=2min
Nice=10
@@ -0,0 +1,11 @@
[Unit]
Description=Hourly refresh of Cloudflare CIDRs for Caddy
[Timer]
OnCalendar=hourly
RandomizedDelaySec=10m
Persistent=true
Unit=chesstrainer-cloudflare-ranges.service
[Install]
WantedBy=timers.target
+3
View File
@@ -0,0 +1,3 @@
# Generated by deploy/update-cloudflare-ranges.sh.
# Source: https://www.cloudflare.com/ips-v4 and /ips-v6
remote_ip 173.245.48.0/20 103.21.244.0/22 103.22.200.0/22 103.31.4.0/22 141.101.64.0/18 108.162.192.0/18 190.93.240.0/20 188.114.96.0/20 197.234.240.0/22 198.41.128.0/17 162.158.0.0/15 104.16.0.0/13 104.24.0.0/14 172.64.0.0/13 131.0.72.0/22 2400:cb00::/32 2606:4700::/32 2803:f800::/32 2405:b500::/32 2405:8100::/32 2a06:98c0::/29 2c0f:f248::/32
+115
View File
@@ -0,0 +1,115 @@
#!/usr/bin/env bash
#
# Refresh Caddy's Cloudflare origin allowlist from Cloudflare's published
# ranges. Called by chesstrainer-cloudflare-ranges.timer.
#
# The generated file is imported by /etc/caddy/Caddyfile:
#
# @cloudflare {
# import cloudflare-ranges.caddy
# }
#
# The script validates the candidate Caddyfile before reloading Caddy. If the
# download or validation fails, the previous ranges stay in place.
set -euo pipefail
CADDYFILE="${CADDYFILE:-/etc/caddy/Caddyfile}"
RANGES_FILE="${RANGES_FILE:-/etc/caddy/cloudflare-ranges.caddy}"
CADDY_BIN="${CADDY_BIN:-caddy}"
RELOAD_CMD="${RELOAD_CMD:-systemctl reload caddy}"
LOCK_FILE="${LOCK_FILE:-/run/lock/chesstrainer-cloudflare-ranges.lock}"
tmpdir="$(mktemp -d)"
trap 'rm -rf "$tmpdir"' EXIT
exec 9>"$LOCK_FILE"
if ! flock -n 9; then
echo "another Cloudflare range update is already running" >&2
exit 0
fi
fetch() {
local url="$1"
local output="$2"
curl --fail --silent --show-error --location \
--proto '=https' \
--retry 3 --retry-delay 2 --connect-timeout 10 \
"$url" --output "$output"
}
validate_download() {
local file="$1"
[[ -s "$file" ]] || return 1
# One CIDR per line. Caddy performs the real validation; this prevents
# obviously malformed or injected content from being written.
if grep -Evq '^[0-9A-Fa-f:.]+/[0-9]{1,3}$' "$file"; then
return 1
fi
}
fetch "https://www.cloudflare.com/ips-v4" "$tmpdir/ips-v4"
fetch "https://www.cloudflare.com/ips-v6" "$tmpdir/ips-v6"
validate_download "$tmpdir/ips-v4"
validate_download "$tmpdir/ips-v6"
ranges="$(awk 'NF { printf "%s ", $0 }' "$tmpdir/ips-v4" "$tmpdir/ips-v6" | sed -e 's/[[:space:]]*$//')"
if [[ -z "$ranges" ]]; then
echo "Cloudflare returned an empty CIDR list" >&2
exit 1
fi
candidate="$tmpdir/cloudflare-ranges.caddy"
{
echo "# Generated by deploy/update-cloudflare-ranges.sh."
echo "# Source: https://www.cloudflare.com/ips-v4 and /ips-v6"
echo "remote_ip $ranges"
} >"$candidate"
if cmp -s "$candidate" "$RANGES_FILE"; then
echo "Cloudflare ranges are unchanged"
exit 0
fi
install -d -m 0755 "$(dirname "$RANGES_FILE")"
backup="$tmpdir/previous-ranges.caddy"
if [[ -e "$RANGES_FILE" ]]; then
cp -a "$RANGES_FILE" "$backup"
fi
install -m 0644 "$candidate" "$RANGES_FILE"
if ! "$CADDY_BIN" validate --config "$CADDYFILE" --adapter caddyfile; then
echo "Caddy rejected the new Cloudflare ranges; restoring the previous file" >&2
if [[ -e "$backup" ]]; then
install -m 0644 "$backup" "$RANGES_FILE"
else
rm -f "$RANGES_FILE"
fi
exit 1
fi
read -r -a reload_command <<<"$RELOAD_CMD"
if ! "${reload_command[@]}"; then
echo "Caddy reload failed; restoring the previous ranges" >&2
if [[ -e "$backup" ]]; then
install -m 0644 "$backup" "$RANGES_FILE"
else
rm -f "$RANGES_FILE"
fi
exit 1
fi
echo "Cloudflare ranges updated and Caddy reloaded"
+15
View File
@@ -115,6 +115,21 @@ Prefer identifiers such as `user_id` or `table` over emails, and never log
params or request bodies. The formatter is a safety net, not a licence to log
PII.
## Authentication events
`ChesstrainerWeb.UserSessionController` emits warning lines consumed by
host-level tooling such as fail2ban:
| Message | Metadata | Meaning |
|---|---|---|
| `auth.login.failed` | `reason` (`invalid_credentials` / `unconfirmed`), `ip` | A password login failed. |
| `auth.login.throttled` | `reason` (`ip` / `login`), `ip` | The address or login bucket blocked the attempt before bcrypt. |
`ip` is a boot-scoped HMAC of the client address, not the address itself. The
raw login identifier and password are never included. The login throttle is
configured in `config/config.exs` and defaults to five failures per login and
ten per address in a fifteen-minute window.
## Querying logs
`journalctl` prints the raw line only with `-o cat`; the default output wraps it
+187
View File
@@ -0,0 +1,187 @@
# Login and edge security
The login surface is protected in layers. The application throttle is the
primary control; Cloudflare is the edge backstop for volume. There is no
origin-level fail2ban for HTTP logins, because it would require storing raw IP
addresses and would ban Cloudflare edge addresses on this deployment.
## Current production configuration
- Caddy accepts only Cloudflare's published ranges and forwards
`CF-Connecting-IP` as `X-Forwarded-For`. The ranges are refreshed hourly by
`chesstrainer-cloudflare-ranges.timer`.
- `TRUST_FORWARDED_FOR=true`, so the app throttles by the real visitor address.
- Cloudflare Bot Fight Mode is enabled.
- The free-plan login flood rule allows 10 login POSTs per 10 seconds per IP and
blocks for 10 seconds.
The short Cloudflare block is rate smoothing, not a credential lockout. The
application's 5-per-login and 10-per-address failures in a 15-minute window are
the real control.
## 1. Application login throttle
`ChesstrainerWeb.LoginThrottle` counts failures in two buckets:
| Bucket | Limit | Window |
|---|---|---|
| Normalised login (email or username) | 5 failures | 15 minutes |
| Client address | 10 failures | 15 minutes |
Blocked attempts are rejected before the database lookup and bcrypt, so they do
not consume password-hashing CPU. A successful login clears the login bucket
only, keeping the address bucket in place so one address cannot spray many
accounts.
The bucket keys are boot-scoped HMACs. Raw addresses and raw login identifiers
are never stored in ETS or written to the application logs. The login form
returns the same generic error for unknown accounts, bad passwords and
unconfirmed accounts.
Configured in `config/config.exs`:
```elixir
config :chesstrainer, ChesstrainerWeb.LoginThrottle,
window_ms: :timer.minutes(15),
max_per_login: 5,
max_per_ip: 10,
confirmation_cooldown_ms: :timer.minutes(15)
```
`auth.login.failed` and `auth.login.throttled` are documented in
`docs/logging.md`.
## 2. Real client IPs behind Cloudflare and Caddy
The production chain is:
```text
Internet
└─ Cloudflare
└─ Caddy :443
└─ Phoenix 127.0.0.1:4100
```
Caddy ignores incoming `X-Forwarded-*` values by default and replaces them with
the immediate peer address. Behind Cloudflare that peer is a Cloudflare edge
node, so without configuration the app would throttle whole Cloudflare POPs
rather than individual visitors.
`deploy/Caddyfile` fixes this by:
1. accepting only Cloudflare's published ranges, and
2. setting `X-Forwarded-For` from Cloudflare's single-value `CF-Connecting-IP`
header.
That keeps `TRUST_FORWARDED_FOR=true` safe: direct clients cannot reach the app
through Caddy, so they cannot forge the header.
`deploy/Caddyfile` imports `cloudflare-ranges.caddy`. The file is generated by
`deploy/update-cloudflare-ranges.sh`; do not edit it by hand.
The script is run hourly by `chesstrainer-cloudflare-ranges.timer`. It:
- downloads <https://www.cloudflare.com/ips-v4> and
<https://www.cloudflare.com/ips-v6>,
- rejects empty or malformed responses,
- validates the candidate Caddyfile,
- reloads Caddy only when the ranges changed.
If the download, validation or Caddy reload fails, the previous ranges stay in
place.
Install and run it:
```sh
sudo install -m 0755 /opt/chesstrainer/src/deploy/update-cloudflare-ranges.sh \
/usr/local/sbin/chesstrainer-update-cloudflare-ranges
sudo install -m 0644 /opt/chesstrainer/src/deploy/cloudflare-ranges.caddy \
/etc/caddy/cloudflare-ranges.caddy
sudo install -m 0644 /opt/chesstrainer/src/deploy/chesstrainer-cloudflare-ranges.service \
/etc/systemd/system/chesstrainer-cloudflare-ranges.service
sudo install -m 0644 /opt/chesstrainer/src/deploy/chesstrainer-cloudflare-ranges.timer \
/etc/systemd/system/chesstrainer-cloudflare-ranges.timer
sudo systemctl daemon-reload
sudo systemctl enable --now chesstrainer-cloudflare-ranges.timer
sudo systemctl start chesstrainer-cloudflare-ranges.service
```
If `/opt/chesstrainer/src/deploy` is not present on the VPS, create the same
four files directly with `sudo tee` from the canonical contents in `deploy/`.
The timer only uses the installed copies.
Check the timer and last run:
```sh
systemctl list-timers chesstrainer-cloudflare-ranges.timer
systemctl status chesstrainer-cloudflare-ranges.service
journalctl -u chesstrainer-cloudflare-ranges.service --since "24 hours ago"
```
Apply the site block by hand on the shared Caddy host, then validate and
reload:
```sh
sudo caddy validate --config /etc/caddy/Caddyfile
sudo systemctl reload caddy
```
Direct requests to the origin with a spoofed `CF-Connecting-IP` must receive
`403 Access Denied`; only Cloudflare's ranges should reach the Phoenix app. A
host firewall allowlist for Cloudflare on ports 80 and 443 is a useful
defence-in-depth addition.
## 3. Cloudflare edge rate limiting
This is for connection and request floods, not credential guessing. The
application already stops password attempts cheaply.
The production rule is the free-plan version:
| Setting | Value |
|---|---|
| Name | Login POST flood |
| Expression | `(http.request.method eq "POST" and http.request.uri.path in {"/admin/log-in" "/users/log-in"})` |
| Characteristic | IP |
| Period | 10 seconds |
| Requests | 10 |
| Action | Block |
| Duration | 10 seconds |
Because the free plan only offers a 10-second period and a 10-second block, this
is a burst limiter rather than a lasting ban. An attacker can retry after ten
seconds, but the application still stops that login after five failures and that
address after ten failures within fifteen minutes. A slow attacker staying under
10 requests per 10 seconds never gets to make useful guesses because of the app
throttle.
Bot Fight Mode is enabled as the plan-level bot control. If the plan later gains
longer rate-limit windows or managed WAF rules, raise the block duration and
consider a broader site-wide rule, such as 100 requests per 10 seconds per IP
with a managed challenge. Use Under Attack Mode during an active incident.
### Registration cannot be limited this way
`/users/register` is a LiveView. The form submit is a LiveView event sent over
the shared `/live/websocket` connection, not a `POST /users/register` request.
Cloudflare therefore cannot count account creations with a rule on the
registration path.
A Cloudflare rule on `GET /users/register` only limits page opens; a bot can
open one page and submit many registrations over the socket. If registration
spam becomes a problem, add an application-level registration throttle keyed by
`ChesstrainerWeb.ClientAddress.from_socket/1`, and/or add Cloudflare Turnstile
to the form.
While `PRELAUNCH=true`, registration is blocked entirely by the prelaunch plug
and LiveView mount redirect.
## 4. Why not fail2ban for HTTP?
fail2ban needs the raw client address to build a firewall rule. The application
deliberately logs only a boot-scoped HMAC, and this deployment sits behind
Cloudflare. Banning the address that reaches the origin would ban Cloudflare
edges, not attackers.
fail2ban remains useful for services that terminate connections directly on the
VPS, such as SSH. It is not part of the HTTP login defence.
+306 -1
View File
@@ -4,11 +4,14 @@ defmodule Chesstrainer.Accounts do
"""
import Ecto.Query, warn: false
require Logger
alias Chesstrainer.Repo
alias Chesstrainer.Accounts.{User, UserToken, UserNotifier}
alias Chesstrainer.Accounts.{Policy, Role, Scope, User, UserToken, UserNotifier}
alias Chesstrainer.MailingList
@admin_users_per_page 25
## Database getters
@doc """
@@ -165,6 +168,308 @@ defmodule Chesstrainer.Accounts do
|> Repo.update()
end
## Admin user management
@doc """
Returns a page of users the scope may administer, newest first.
Options:
* `:search` - case-insensitive match on email or username
* `:page` - 1-based page number (defaults to 1)
* `:per_page` - page size (defaults to 25, capped at 100)
Admins only see members and moderators; super admins see every role.
Returns `{:error, :unauthorized}` when the scope lacks user management.
"""
def list_users_for_admin(scope, opts \\ []) do
with :ok <- ensure_manage_users(scope) do
page = normalize_page(Keyword.get(opts, :page, 1))
per_page = normalize_per_page(Keyword.get(opts, :per_page, @admin_users_per_page))
offset = (page - 1) * per_page
users =
scope
|> admin_users_query(opts)
|> order_by([u], desc: u.inserted_at, desc: u.id)
|> limit(^per_page)
|> offset(^offset)
|> Repo.all()
{:ok, users}
end
end
@doc """
Counts the users visible to the scope, using the same filters as
`list_users_for_admin/2`.
"""
def count_users_for_admin(scope, opts \\ []) do
with :ok <- ensure_manage_users(scope) do
count =
scope
|> admin_users_query(opts)
|> select([u], count(u.id))
|> Repo.one()
{:ok, count}
end
end
@doc """
Fetches a user for the admin detail page.
Returns `{:error, :unauthorized}` when the scope may not view the target and
`{:error, :not_found}` for an unknown id.
"""
def get_user_for_admin(scope, id) do
with :ok <- ensure_manage_users(scope) do
case fetch_user(id) do
nil ->
{:error, :not_found}
%User{} = user ->
if Policy.can_view_user?(scope, user) do
{:ok, user}
else
{:error, :unauthorized}
end
end
end
end
@doc """
Returns an `%Ecto.Changeset{}` for the admin-editable fields (role and plan).
"""
def change_user_as_admin(%User{} = user, attrs \\ %{}) do
User.admin_changeset(user, attrs)
end
@doc """
Updates a user's role and plan after enforcing the admin capability matrix.
The last-super-admin check runs inside the update transaction with a row lock,
so concurrent demotions cannot remove the final super admin.
Returns `{:error, :unauthorized}`, `{:error, :own_role}`,
`{:error, :last_super_admin}` or `{:error, %Ecto.Changeset{}}` instead of
raising.
"""
def update_user_as_admin(scope, %User{} = user, attrs) do
changeset = User.admin_changeset(user, attrs)
role_change = Ecto.Changeset.get_change(changeset, :role)
with :ok <- ensure_manage_users(scope),
:ok <- ensure_not_own_role_change(scope, user, role_change),
:ok <- ensure_can_manage_user(scope, user),
:ok <- ensure_can_assign_role(scope, role_change),
{:ok, updated} <- persist_user_changes(user, changeset) do
log_user_update(scope, user, changeset)
{:ok, updated}
end
end
@doc """
Creates an invitation and emails the recipient a link to choose a password.
The account is confirmed but has no password until the invitee follows the
link. `invite_url_fun` receives the encoded token and must return a URL.
"""
def invite_user_as_admin(scope, attrs, invite_url_fun)
when is_function(invite_url_fun, 1) do
role = normalize_role(role_param(attrs) || :member)
with :ok <- ensure_manage_users(scope),
:ok <- ensure_can_assign_role(scope, role) do
changeset =
%User{}
|> User.invite_changeset(attrs)
|> User.admin_changeset(attrs)
case Repo.insert(changeset) do
{:ok, user} ->
Logger.info("admin.user.invited",
actor_id: scope.user.id,
target_id: user.id,
fields: [:invite]
)
case deliver_invite_instructions(user, invite_url_fun) do
{:ok, _email} -> {:ok, user}
{:error, reason} -> {:error, reason}
end
{:error, changeset} ->
{:error, changeset}
end
end
end
@doc """
Sends a password-reset email on behalf of an administrator.
Uses the same policy as the editable user screen: an admin cannot trigger a
reset for another admin or a super admin.
"""
def send_user_reset_password_instructions_as_admin(scope, %User{} = user, reset_url_fun)
when is_function(reset_url_fun, 1) do
with :ok <- ensure_manage_users(scope),
:ok <- ensure_can_manage_user(scope, user) do
case deliver_user_reset_password_instructions(user, reset_url_fun) do
{:ok, email} ->
Logger.info("admin.user.password_reset_sent",
actor_id: scope.user.id,
target_id: user.id
)
{:ok, email}
error ->
error
end
end
end
@doc """
Resends the account-confirmation email on behalf of an administrator.
"""
def resend_user_confirmation_instructions_as_admin(scope, %User{} = user, confirmation_url_fun)
when is_function(confirmation_url_fun, 1) do
with :ok <- ensure_manage_users(scope),
:ok <- ensure_can_manage_user(scope, user) do
case deliver_user_confirmation_instructions(user, confirmation_url_fun) do
{:ok, email} ->
Logger.info("admin.user.confirmation_resent",
actor_id: scope.user.id,
target_id: user.id
)
{:ok, email}
error ->
error
end
end
end
defp admin_users_query(scope, opts) do
roles = Policy.visible_roles(scope)
search = opts |> Keyword.get(:search, "") |> to_string() |> String.trim()
query = from(u in User, where: u.role in ^roles)
if search == "" do
query
else
pattern = "%#{search}%"
where(
query,
[u],
ilike(u.email, ^pattern) or ilike(u.username, ^pattern)
)
end
end
defp persist_user_changes(user, changeset) do
Repo.transact(fn ->
with :ok <- ensure_not_last_super_admin(user, changeset),
{:ok, updated} <- Repo.update(changeset) do
{:ok, updated}
end
end)
end
defp ensure_not_last_super_admin(%User{role: :super_admin}, changeset) do
case Ecto.Changeset.get_change(changeset, :role) do
role when role in [nil, :super_admin] ->
:ok
_role ->
super_admins =
Repo.all(from(u in User, where: u.role == :super_admin, lock: "FOR UPDATE"))
if length(super_admins) <= 1 do
{:error, :last_super_admin}
else
:ok
end
end
end
defp ensure_not_last_super_admin(_user, _changeset), do: :ok
defp log_user_update(scope, user, changeset) do
fields = changeset.changes |> Map.keys() |> Enum.sort()
if fields != [] do
Logger.info("admin.user.updated",
actor_id: scope.user.id,
target_id: user.id,
fields: fields
)
end
end
defp deliver_invite_instructions(user, invite_url_fun) do
{encoded_token, user_token} = UserToken.build_email_token(user, "reset_password")
Repo.insert!(user_token)
UserNotifier.deliver_invite_instructions(user, invite_url_fun.(encoded_token))
end
defp ensure_manage_users(scope) do
if Policy.can?(scope, :manage_users), do: :ok, else: {:error, :unauthorized}
end
defp ensure_can_manage_user(scope, user) do
if Policy.can_manage_user?(scope, user), do: :ok, else: {:error, :unauthorized}
end
defp ensure_can_assign_role(_scope, nil), do: :ok
defp ensure_can_assign_role(scope, role) do
if Policy.can_assign_role?(scope, role), do: :ok, else: {:error, :unauthorized}
end
defp ensure_not_own_role_change(%Scope{user: %User{id: id}}, %User{id: id}, role)
when not is_nil(role),
do: {:error, :own_role}
defp ensure_not_own_role_change(_scope, _user, _role), do: :ok
defp fetch_user(id) do
Repo.get(User, id)
rescue
Ecto.Query.CastError -> nil
end
defp role_param(attrs), do: Map.get(attrs, "role") || Map.get(attrs, :role)
defp normalize_role(role) do
cond do
role in Role.values() -> role
is_binary(role) -> Enum.find(Role.values(), &(Atom.to_string(&1) == role))
true -> nil
end
end
defp normalize_page(page) when is_integer(page) and page > 0, do: page
defp normalize_page(page) when is_binary(page) do
case Integer.parse(page) do
{number, ""} when number > 0 -> number
_ -> 1
end
end
defp normalize_page(_page), do: 1
defp normalize_per_page(per_page) when is_integer(per_page) and per_page > 0 do
min(per_page, 100)
end
defp normalize_per_page(_per_page), do: @admin_users_per_page
## Settings
@doc """
+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
+2
View File
@@ -6,6 +6,8 @@ defmodule Chesstrainer.Accounts.Role do
should ask for the minimum tier they need via `at_least?/2`.
"""
@type value :: :member | :moderator | :admin | :super_admin
@values [:member, :moderator, :admin, :super_admin]
@ranks %{
+2
View File
@@ -20,6 +20,8 @@ defmodule Chesstrainer.Accounts.Scope do
defstruct user: nil
@type t :: %__MODULE__{user: User.t() | nil}
@doc """
Creates a scope for the given user.
+28
View File
@@ -20,6 +20,8 @@ defmodule Chesstrainer.Accounts.User do
timestamps(type: :utc_datetime)
end
@type t :: %__MODULE__{}
@doc """
A user changeset for registration.
@@ -53,6 +55,32 @@ defmodule Chesstrainer.Accounts.User do
|> validate_required([:role])
end
@doc """
A user changeset for an admin-created invitation.
The account is created without a password and marked confirmed, so the
recipient can choose a password from the emailed invitation link and log in
immediately afterwards. Role and plan are applied separately by
`admin_changeset/2` after the caller has checked the policy.
"""
def invite_changeset(user, attrs) do
user
|> cast(attrs, [:email, :username])
|> validate_email([])
|> validate_username([])
|> put_change(:confirmed_at, DateTime.utc_now(:second))
end
@doc """
A user changeset for the fields an administrator may edit.
These values are programmatic, so this changeset is only used by the scoped
admin functions in `Chesstrainer.Accounts`.
"""
def admin_changeset(user, attrs) do
cast(user, attrs, [:role, :plan])
end
@doc """
A user changeset for registering or changing the email.
@@ -38,6 +38,31 @@ defmodule Chesstrainer.Accounts.UserNotifier do
""")
end
@doc """
Deliver an invitation to choose a password.
Admins create the account without a password; the invitation link uses the
same reset-password token flow so the recipient can set one.
"""
def deliver_invite_instructions(user, url) do
deliver(user.email, "You're invited to #{Branding.name()}", """
==============================
Hi #{user.username},
An administrator has created an account for you on #{Branding.name()}.
Choose your password by visiting the URL below:
#{url}
If you weren't expecting this invitation, please ignore this email.
==============================
""")
end
@doc """
Deliver instructions to reset a user password.
"""
+1
View File
@@ -17,6 +17,7 @@ defmodule Chesstrainer.Application do
# Start a worker by calling: Chesstrainer.Worker.start_link(arg)
# {Chesstrainer.Worker, arg},
Chesstrainer.GuestLimits,
ChesstrainerWeb.LoginThrottle,
# Start to serve requests, typically the last entry
ChesstrainerWeb.Endpoint,
{Registry, keys: :unique, name: Chesstrainer.CacheRegistry},
+46
View File
@@ -21,6 +21,43 @@ defmodule Chesstrainer.Themes do
Repo.all(Theme)
end
@doc """
Lists themes for the admin index with their endgame usage count.
Options:
* `:search` - case-insensitive match on the theme name
* `:category` - one of `:endgame`, `:opening`, `:tactic`, or blank for all
Returns `{theme, usage_count}` tuples sorted by name.
"""
def list_themes_for_admin(opts \\ []) do
search = opts |> Keyword.get(:search, "") |> to_string() |> String.trim()
category = normalize_category(Keyword.get(opts, :category, ""))
query = from(t in Theme, order_by: [asc: t.name])
query =
if search == "" do
query
else
where(query, [t], ilike(t.name, ^"%#{search}%"))
end
query =
if category do
where(query, [t], t.category == ^category)
else
query
end
query
|> join(:left, [t], j in "endgames_themes", on: j.theme_id == t.id)
|> group_by([t], t.id)
|> select([t, j], {t, count(j.endgame_id)})
|> Repo.all()
end
@doc """
Gets a single theme.
@@ -153,4 +190,13 @@ defmodule Chesstrainer.Themes do
def names(themes) when is_list(themes) do
themes |> Enum.map(& &1.name) |> Enum.sort()
end
defp normalize_category(category) when category in [:endgame, :opening, :tactic],
do: category
defp normalize_category(category) when is_binary(category) do
Enum.find([:endgame, :opening, :tactic], &(Atom.to_string(&1) == category))
end
defp normalize_category(_category), do: nil
end
+84
View File
@@ -0,0 +1,84 @@
defmodule ChesstrainerWeb.ClientAddress do
@moduledoc """
Resolves the client's IP address from either a controller connection or a
LiveView socket.
`X-Forwarded-For` is only read when
`Chesstrainer.GuestLimits.trust_forwarded_for?/0` is enabled. In that case the
rightmost entry is used, because that is the value our own proxy appended.
Invalid or missing headers fall back to the peer address.
Production is Cloudflare -> Caddy -> Phoenix. `deploy/Caddyfile` makes Caddy
overwrite `X-Forwarded-For` with Cloudflare's `CF-Connecting-IP` and rejects
direct-to-origin requests, so the rightmost value is the real visitor rather
than a Cloudflare edge address.
"""
alias Chesstrainer.GuestLimits
@typedoc "An IPv4/IPv6 address, or `nil` when no peer data is available."
@type address :: :inet.ip_address() | nil
@doc "Returns the client address for a controller connection."
@spec from_conn(Plug.Conn.t()) :: address()
def from_conn(conn) do
if GuestLimits.trust_forwarded_for?() do
conn
|> Plug.Conn.get_req_header("x-forwarded-for")
|> parse_forwarded_header()
|> fallback(conn.remote_ip)
else
conn.remote_ip
end
end
@doc "Returns the client address for a connected LiveView socket."
@spec from_socket(Phoenix.LiveView.Socket.t()) :: address()
def from_socket(socket) do
if GuestLimits.trust_forwarded_for?() do
socket
|> Phoenix.LiveView.get_connect_info(:x_headers)
|> parse_x_headers()
|> fallback(peer_address(socket))
else
peer_address(socket)
end
end
defp peer_address(socket) do
case Phoenix.LiveView.get_connect_info(socket, :peer_data) do
%{address: address} -> address
_ -> nil
end
end
defp parse_forwarded_header([value | _]) when is_binary(value), do: parse_address(value)
defp parse_forwarded_header(_headers), do: nil
defp parse_x_headers(headers) when is_list(headers) do
case List.keyfind(headers, "x-forwarded-for", 0) do
{_, value} when is_binary(value) -> parse_address(value)
_ -> nil
end
end
defp parse_x_headers(_headers), do: nil
# The rightmost entry is the one our own proxy appended.
defp parse_address(value) do
value
|> String.split(",")
|> List.last()
|> to_string()
|> String.trim()
|> String.to_charlist()
|> :inet.parse_address()
|> case do
{:ok, address} -> address
{:error, _} -> nil
end
end
defp fallback(nil, fallback), do: fallback
defp fallback(address, _fallback), do: address
end
@@ -5,6 +5,7 @@ defmodule ChesstrainerWeb.Layouts do
"""
use ChesstrainerWeb, :html
alias Chesstrainer.Accounts.Policy
alias Chesstrainer.Accounts.Role
alias Chesstrainer.Accounts.Scope
@@ -133,6 +134,42 @@ defmodule ChesstrainerWeb.Layouts do
"""
end
@doc """
Renders the shared sub-navigation for admin pages.
Items are filtered by capability, so the same component is safe to render on
every admin screen.
"""
attr :current_scope, :map, default: nil
def admin_nav(assigns) do
links =
for {capability, label, href} <- [
{:manage_endgames, "Endgames", ~p"/admin/endgames"},
{:manage_themes, "Themes", ~p"/admin/themes"},
{:manage_users, "Users", ~p"/admin/users"}
],
Policy.can?(assigns.current_scope, capability),
do: %{label: label, href: href}
assigns = assign(assigns, :links, links)
~H"""
<nav
aria-label="Admin"
class="mb-6 flex flex-wrap items-center gap-1 border-b border-base-200 pb-3 text-sm font-semibold"
>
<.link
:for={link <- @links}
navigate={link.href}
class="rounded-md px-3 py-1.5 text-base-content/70 hover:bg-base-200 hover:text-base-content"
>
{link.label}
</.link>
</nav>
"""
end
defp nav_links(scope) do
marketing =
if Scope.premium?(scope) do
@@ -187,6 +224,7 @@ defmodule ChesstrainerWeb.Layouts do
<a href="/privacy">Privacy Policy</a>
<a href="/terms-conditions">Terms & Conditions</a>
<a href="/mentions-legales">Mentions légales</a>
<a href="/sitemap.xml">Sitemap</a>
</nav>
<small>© {@year} {Branding.name()}</small>
@@ -1,7 +1,11 @@
defmodule ChesstrainerWeb.UserSessionController do
use ChesstrainerWeb, :controller
require Logger
alias Chesstrainer.Accounts
alias ChesstrainerWeb.ClientAddress
alias ChesstrainerWeb.LoginThrottle
alias ChesstrainerWeb.UserAuth
def create(conn, %{"user" => user_params}) do
@@ -17,32 +21,78 @@ defmodule ChesstrainerWeb.UserSessionController do
end
defp authenticate(conn, user_params, failure_path, success_path) do
%{"email" => login} = user_params
address = ClientAddress.from_conn(conn)
case LoginThrottle.check(address, login) do
:ok ->
attempt_login(conn, address, user_params, failure_path, success_path)
{:throttled, bucket, retry_in_ms} ->
log_auth_event("auth.login.throttled", address, reason: bucket)
conn
|> put_flash(:error, throttle_message(retry_in_ms))
|> redirect(to: failure_path)
end
end
defp attempt_login(conn, address, user_params, failure_path, success_path) do
%{"email" => login, "password" => password} = user_params
case Accounts.get_user_by_login_and_password(login, password) do
nil ->
invalid_credentials(conn, login, failure_path)
authentication_failed(conn, address, login, :invalid_credentials, failure_path)
user ->
if user.confirmed_at do
LoginThrottle.record_success(login)
conn
|> maybe_put_return_to(success_path)
|> put_flash(:info, "Welcome back!")
|> UserAuth.log_in_user(user, user_params)
else
{:ok, _} =
Accounts.deliver_user_confirmation_instructions(
user,
&url(~p"/users/confirm/#{&1}")
)
# In order to prevent user enumeration attacks, report the same error
# as invalid credentials.
invalid_credentials(conn, login, failure_path)
maybe_resend_confirmation(user, login)
authentication_failed(conn, address, login, :unconfirmed, failure_path)
end
end
end
defp maybe_resend_confirmation(user, login) do
if LoginThrottle.claim_confirmation_resend(login) do
case Accounts.deliver_user_confirmation_instructions(
user,
&url(~p"/users/confirm/#{&1}")
) do
{:ok, _email} -> :ok
{:error, _reason} -> Logger.warning("auth.confirmation.resend_failed")
end
end
:ok
end
defp authentication_failed(conn, address, login, reason, failure_path) do
LoginThrottle.record_failure(address, login)
log_auth_event("auth.login.failed", address, reason: reason)
# In order to prevent user enumeration attacks, report the same error as
# invalid credentials.
invalid_credentials(conn, login, failure_path)
end
defp log_auth_event(message, address, metadata) do
Logger.warning(message, Keyword.put(metadata, :ip, LoginThrottle.fingerprint(address)))
end
defp throttle_message(retry_in_ms) do
minutes = max(div(retry_in_ms + 59_999, 60_000), 1)
unit = if minutes == 1, do: "minute", else: "minutes"
"Too many attempts. Try again in #{minutes} #{unit}."
end
defp invalid_credentials(conn, login, path) do
conn
|> put_flash(:error, "Invalid email, username or password")
@@ -0,0 +1,114 @@
defmodule ChesstrainerWeb.Admin.ThemeLive.Form do
use ChesstrainerWeb, :live_view
alias Chesstrainer.Accounts.Policy
alias Chesstrainer.Themes
alias Chesstrainer.Themes.Theme
@category_options [
{"Endgame", "endgame"},
{"Opening", "opening"},
{"Tactic", "tactic"}
]
@impl true
def render(assigns) do
~H"""
<Layouts.app flash={@flash}>
<Layouts.admin_nav current_scope={@current_scope} />
<.header>
{@page_title}
<:subtitle>
Themes group endgames for filtering. Names must be unique within a category,
ignoring case.
</:subtitle>
</.header>
<.form for={@form} id="theme-form" phx-change="validate" phx-submit="save">
<.input field={@form[:name]} type="text" label="Name" autocomplete="off" required />
<.input
field={@form[:category]}
type="select"
label="Category"
options={@category_options}
/>
<footer>
<.button phx-disable-with="Saving..." variant="primary">Save theme</.button>
<.button navigate={~p"/admin/themes"}>Cancel</.button>
</footer>
</.form>
</Layouts.app>
"""
end
@impl true
def mount(params, _session, socket) do
{:ok, apply_action(socket, socket.assigns.live_action, params)}
end
defp apply_action(socket, :new, _params) do
theme = %Theme{}
socket
|> assign(:page_title, "New theme")
|> assign(:theme, theme)
|> assign(:category_options, @category_options)
|> assign(:form, to_form(Themes.change_theme(theme)))
end
defp apply_action(socket, :edit, %{"id" => id}) do
theme = Themes.get_theme!(id)
socket
|> assign(:page_title, "Edit theme")
|> assign(:theme, theme)
|> assign(:category_options, @category_options)
|> assign(:form, to_form(Themes.change_theme(theme)))
end
@impl true
def handle_event("validate", %{"theme" => theme_params}, socket) do
changeset =
socket.assigns.theme
|> Themes.change_theme(theme_params)
|> Map.put(:action, :validate)
{:noreply, assign(socket, :form, to_form(changeset, action: :validate))}
end
def handle_event("save", %{"theme" => theme_params}, socket) do
if Policy.can?(socket.assigns.current_scope, :manage_themes) do
save_theme(socket, socket.assigns.live_action, theme_params)
else
{:noreply, put_flash(socket, :error, "You are not authorized to manage themes.")}
end
end
defp save_theme(socket, :new, theme_params) do
case Themes.create_theme(theme_params) do
{:ok, _theme} ->
{:noreply,
socket
|> put_flash(:info, "Theme created successfully.")
|> push_navigate(to: ~p"/admin/themes")}
{:error, %Ecto.Changeset{} = changeset} ->
{:noreply, assign(socket, :form, to_form(changeset, action: :insert))}
end
end
defp save_theme(socket, :edit, theme_params) do
case Themes.update_theme(socket.assigns.theme, theme_params) do
{:ok, _theme} ->
{:noreply,
socket
|> put_flash(:info, "Theme updated successfully.")
|> push_navigate(to: ~p"/admin/themes")}
{:error, %Ecto.Changeset{} = changeset} ->
{:noreply, assign(socket, :form, to_form(changeset, action: :insert))}
end
end
end
@@ -0,0 +1,160 @@
defmodule ChesstrainerWeb.Admin.ThemeLive.Index do
use ChesstrainerWeb, :live_view
alias Chesstrainer.Accounts.Policy
alias Chesstrainer.Themes
@category_options [
{"All categories", ""},
{"Endgame", "endgame"},
{"Opening", "opening"},
{"Tactic", "tactic"}
]
@impl true
def render(assigns) do
~H"""
<Layouts.app flash={@flash} wide>
<Layouts.admin_nav current_scope={@current_scope} />
<.header>
Themes
<:subtitle>
Themes group endgames for filtering and puzzle selection. Deleting a theme detaches
it from every endgame and leaves the endgames intact.
</:subtitle>
<:actions>
<.button variant="primary" navigate={~p"/admin/themes/new"}>
<.icon name="hero-plus" /> New theme
</.button>
</:actions>
</.header>
<.form
for={@filter_form}
id="theme-admin-filter-form"
phx-change="filter"
class="mb-6 flex flex-col gap-3 sm:flex-row sm:items-end"
>
<div class="flex-1 [&>div]:mb-0">
<.input
field={@filter_form[:search]}
type="text"
label="Search by name"
autocomplete="off"
phx-debounce="200"
placeholder="Theme name…"
/>
</div>
<div class="[&>div]:mb-0 sm:w-56">
<.input
field={@filter_form[:category]}
type="select"
label="Category"
options={@category_options}
/>
</div>
</.form>
<p :if={@themes == []} class="text-base-content/70">
<%= if @has_filters do %>
No themes match these filters.
<% else %>
No themes yet. Themes power endgame filtering and puzzle selection, so start by
creating one and attaching it to an endgame.
<% end %>
</p>
<table :if={@themes != []} class={table_class()}>
<thead>
<tr>
<th>Name</th>
<th>Category</th>
<th>Used by</th>
<th><span class="sr-only">Actions</span></th>
</tr>
</thead>
<tbody id="themes">
<tr :for={{theme, usage_count} <- @themes} id={"theme-#{theme.id}"}>
<td>{theme.name}</td>
<td>{theme.category}</td>
<td>
<span id={"theme-usage-#{theme.id}"}>{usage_label(usage_count)}</span>
</td>
<td class="w-0 font-semibold">
<div class="flex gap-4">
<.link navigate={~p"/admin/themes/#{theme.id}/edit"}>Edit</.link>
<.link
phx-click="delete"
phx-value-id={theme.id}
data-confirm={
"Delete #{theme.name}? Used by #{usage_label(usage_count)}. " <>
"The endgames will be kept and simply detached."
}
>
Delete
</.link>
</div>
</td>
</tr>
</tbody>
</table>
</Layouts.app>
"""
end
@impl true
def mount(_params, _session, socket) do
{:ok,
socket
|> assign(:page_title, "Themes")
|> assign(:search, "")
|> assign(:category, "")
|> assign(:has_filters, false)
|> assign(:category_options, @category_options)
|> assign(:filter_form, to_form(%{"search" => "", "category" => ""}))
|> load_themes()}
end
@impl true
def handle_event("filter", params, socket) do
search = Map.get(params, "search", socket.assigns.search)
category = Map.get(params, "category", socket.assigns.category)
{:noreply,
socket
|> assign(:search, search)
|> assign(:category, category)
|> assign(:has_filters, String.trim(search) != "" or category != "")
|> load_themes()}
end
def handle_event("delete", %{"id" => id}, socket) do
if Policy.can?(socket.assigns.current_scope, :manage_themes) do
theme = Themes.get_theme!(id)
{:ok, _theme} = Themes.delete_theme(theme)
socket =
socket
|> put_flash(:info, "Theme deleted. Attached endgames were kept.")
|> load_themes()
{:noreply, socket}
else
{:noreply, put_flash(socket, :error, "You are not authorized to manage themes.")}
end
end
defp load_themes(socket) do
themes =
Themes.list_themes_for_admin(
search: socket.assigns.search,
category: socket.assigns.category
)
assign(socket, :themes, themes)
end
defp usage_label(1), do: "1 endgame"
defp usage_label(count), do: "#{count} endgames"
end
@@ -0,0 +1,177 @@
defmodule ChesstrainerWeb.Admin.UserLive.Index do
use ChesstrainerWeb, :live_view
alias Chesstrainer.Accounts
@per_page 25
@impl true
def render(assigns) do
~H"""
<Layouts.app flash={@flash} wide>
<Layouts.admin_nav current_scope={@current_scope} />
<.header>
Users
<:subtitle>
Search accounts, review their roles and plans, and open a user to edit them.
Admins only see members and moderators.
</:subtitle>
<:actions>
<.button variant="primary" navigate={~p"/admin/users/new"}>
<.icon name="hero-plus" /> Invite user
</.button>
</:actions>
</.header>
<.form for={@filter_form} id="admin-user-search-form" phx-change="search" class="mb-6">
<.input
field={@filter_form[:search]}
type="search"
label="Search by email or username"
autocomplete="off"
phx-debounce="200"
placeholder="email or username…"
/>
</.form>
<p :if={@users == []} class="text-base-content/70">
<%= if @search == "" do %>
No users are visible to you yet.
<% else %>
No users match “{@search}”.
<% end %>
</p>
<table :if={@users != []} class={table_class()}>
<thead>
<tr>
<th>Username</th>
<th>Email</th>
<th>Role</th>
<th>Plan</th>
<th>Confirmed</th>
<th>Created</th>
<th><span class="sr-only">Actions</span></th>
</tr>
</thead>
<tbody id="admin-users">
<tr :for={user <- @users} id={"user-" <> user.id}>
<td>{user.username}</td>
<td>{user.email}</td>
<td>{user.role}</td>
<td>{user.plan}</td>
<td>{confirmed_label(user)}</td>
<td>{format_date(user.inserted_at)}</td>
<td class="w-0 font-semibold">
<.link navigate={~p"/admin/users/#{user.id}"}>View</.link>
</td>
</tr>
</tbody>
</table>
<div class="mt-4 flex flex-wrap items-center justify-between gap-3 text-sm text-base-content/70">
<p>
Page {@page} of {@total_pages} · {@count} {if @count == 1, do: "user", else: "users"}
</p>
<div class="flex gap-2">
<.button
:if={@page > 1}
variant="secondary"
phx-click="previous_page"
id="previous-page"
>
Previous
</.button>
<.button
:if={@page < @total_pages}
variant="secondary"
phx-click="next_page"
id="next-page"
>
Next
</.button>
</div>
</div>
</Layouts.app>
"""
end
@impl true
def mount(_params, _session, socket) do
socket =
socket
|> assign(:page_title, "Users")
|> assign(:search, "")
|> assign(:page, 1)
|> assign(:users, [])
|> assign(:count, 0)
|> assign(:total_pages, 1)
|> assign(:filter_form, to_form(%{"search" => ""}))
case load_users(socket) do
{:ok, socket} -> {:ok, socket}
{:error, :unauthorized} -> {:ok, redirect_unauthorized(socket)}
end
end
@impl true
def handle_event("search", %{"search" => search}, socket) do
case load_users(assign(socket, search: search, page: 1)) do
{:ok, socket} -> {:noreply, socket}
{:error, :unauthorized} -> {:noreply, redirect_unauthorized(socket)}
end
end
def handle_event("previous_page", _params, socket) do
case load_users(assign(socket, :page, max(socket.assigns.page - 1, 1))) do
{:ok, socket} -> {:noreply, socket}
{:error, :unauthorized} -> {:noreply, redirect_unauthorized(socket)}
end
end
def handle_event("next_page", _params, socket) do
case load_users(assign(socket, :page, socket.assigns.page + 1)) do
{:ok, socket} -> {:noreply, socket}
{:error, :unauthorized} -> {:noreply, redirect_unauthorized(socket)}
end
end
defp load_users(socket) do
scope = socket.assigns.current_scope
search = socket.assigns.search
case Accounts.count_users_for_admin(scope, search: search) do
{:ok, count} ->
total_pages = max(div(count + @per_page - 1, @per_page), 1)
page = min(socket.assigns.page, total_pages)
case Accounts.list_users_for_admin(scope, search: search, page: page) do
{:ok, users} ->
{:ok,
assign(socket, users: users, count: count, total_pages: total_pages, page: page)}
{:error, :unauthorized} ->
{:error, :unauthorized}
end
{:error, :unauthorized} ->
{:error, :unauthorized}
end
end
defp redirect_unauthorized(socket) do
socket
|> put_flash(:error, "You are not authorized to manage users.")
|> push_navigate(to: ~p"/")
end
defp confirmed_label(%{confirmed_at: nil}), do: "No"
defp confirmed_label(_user), do: "Yes"
defp format_date(nil), do: ""
defp format_date(%DateTime{} = datetime) do
Calendar.strftime(datetime, "%Y-%m-%d")
end
end
@@ -0,0 +1,120 @@
defmodule ChesstrainerWeb.Admin.UserLive.New do
use ChesstrainerWeb, :live_view
alias Chesstrainer.Accounts
alias Chesstrainer.Accounts.Policy
alias Chesstrainer.Accounts.Role
alias Chesstrainer.Accounts.User
@plan_options [{"Free", "free"}, {"Premium", "premium"}]
@impl true
def render(assigns) do
~H"""
<Layouts.app flash={@flash}>
<Layouts.admin_nav current_scope={@current_scope} />
<.header>
Invite user
<:subtitle>
We create the account and email a link so the recipient can choose a password.
The invite is confirmed immediately, so no separate confirmation step is needed.
</:subtitle>
</.header>
<.form for={@form} id="invite-user-form" phx-change="validate" phx-submit="save">
<.input
field={@form[:email]}
type="email"
label="Email"
autocomplete="off"
required
/>
<.input
field={@form[:username]}
type="text"
label="Username"
autocomplete="off"
required
/>
<.input
field={@form[:role]}
type="select"
label="Role"
options={@role_options}
/>
<.input
field={@form[:plan]}
type="select"
label="Plan"
options={@plan_options}
/>
<footer>
<.button phx-disable-with="Sending..." variant="primary">Send invitation</.button>
<.button navigate={~p"/admin/users"}>Cancel</.button>
</footer>
</.form>
</Layouts.app>
"""
end
@impl true
def mount(_params, _session, socket) do
{:ok,
socket
|> assign(:page_title, "Invite user")
|> assign(:role_options, role_options(socket.assigns.current_scope))
|> assign(:plan_options, @plan_options)
|> assign(
:form,
to_form(%{"email" => "", "username" => "", "role" => "member", "plan" => "free"},
as: :user
)
)}
end
@impl true
def handle_event("validate", %{"user" => user_params}, socket) do
changeset =
%User{}
|> User.invite_changeset(user_params)
|> User.admin_changeset(user_params)
|> Map.put(:action, :validate)
{:noreply, assign(socket, :form, to_form(changeset, action: :validate))}
end
def handle_event("save", %{"user" => user_params}, socket) do
case Accounts.invite_user_as_admin(
socket.assigns.current_scope,
user_params,
&url(~p"/users/reset-password/#{&1}")
) do
{:ok, user} ->
{:noreply,
socket
|> put_flash(:info, "Invitation sent to #{user.email}.")
|> push_navigate(to: ~p"/admin/users")}
{:error, %Ecto.Changeset{} = changeset} ->
{:noreply, assign(socket, :form, to_form(changeset, action: :insert))}
{:error, :unauthorized} ->
{:noreply, put_flash(socket, :error, "You are not authorized to assign that role.")}
{:error, _reason} ->
{:noreply,
put_flash(socket, :error, "The invitation could not be sent. Please try again.")}
end
end
defp role_options(scope) do
for role <- Role.values(),
Policy.can_assign_role?(scope, role),
do: {role_label(role), role}
end
defp role_label(:super_admin), do: "Super admin"
defp role_label(role), do: role |> Atom.to_string() |> String.capitalize()
end
@@ -0,0 +1,228 @@
defmodule ChesstrainerWeb.Admin.UserLive.Show do
use ChesstrainerWeb, :live_view
alias Chesstrainer.Accounts
alias Chesstrainer.Accounts.Policy
alias Chesstrainer.Accounts.Role
@plan_options [{"Free", "free"}, {"Premium", "premium"}]
@impl true
def render(assigns) do
~H"""
<Layouts.app flash={@flash} wide>
<Layouts.admin_nav current_scope={@current_scope} />
<div id="admin-user-page">
<.header>
{@user.username}
<:subtitle>Account details and administrator controls.</:subtitle>
<:actions>
<.button navigate={~p"/admin/users"}>
<.icon name="hero-arrow-left" /> All users
</.button>
</:actions>
</.header>
<.list>
<:item title="Email">{@user.email}</:item>
<:item title="Username">{@user.username}</:item>
<:item title="Role">{@user.role}</:item>
<:item title="Plan">{@user.plan}</:item>
<:item title="Confirmed">{confirmed_label(@user)}</:item>
<:item title="Rating">{round(@user.rating)}</:item>
<:item title="Created">{format_datetime(@user.inserted_at)}</:item>
<:item title="Last updated">{format_datetime(@user.updated_at)}</:item>
</.list>
<section class="mt-8">
<h2 class="text-lg font-semibold">Role and plan</h2>
<.form
:if={@can_manage}
for={@form}
id="admin-user-form"
phx-change="validate"
phx-submit="save"
class="mt-4"
>
<.input
field={@form[:role]}
type="select"
label="Role"
options={@role_options}
/>
<.input
field={@form[:plan]}
type="select"
label="Plan"
options={@plan_options}
/>
<footer>
<.button phx-disable-with="Saving..." variant="primary">Save changes</.button>
</footer>
</.form>
<p :if={!@can_manage} class="mt-4 text-sm text-base-content/70">
You can view this account but not change its role or plan.
</p>
</section>
<section :if={@can_manage} class="mt-8 border-t border-base-200 pt-6">
<h2 class="text-lg font-semibold">Account emails</h2>
<p class="mt-1 text-sm text-base-content/70">
These actions send email through the configured mailer. In development the messages
appear in the Swoosh mailbox at <code>/dev/mailbox</code>.
</p>
<div class="mt-4 flex flex-wrap gap-2">
<.button
:if={is_nil(@user.confirmed_at)}
variant="secondary"
phx-click="resend_confirmation"
id="resend-confirmation"
>
Resend confirmation email
</.button>
<.button
variant="secondary"
phx-click="send_password_reset"
id="send-password-reset"
>
Send password reset email
</.button>
</div>
</section>
</div>
</Layouts.app>
"""
end
@impl true
def mount(%{"id" => id}, _session, socket) do
case Accounts.get_user_for_admin(socket.assigns.current_scope, id) do
{:ok, user} ->
{:ok, assign_user(socket, user)}
{:error, :unauthorized} ->
{:ok,
socket
|> put_flash(:error, "You are not authorized to view that user.")
|> push_navigate(to: ~p"/admin/users")}
{:error, :not_found} ->
{:ok,
socket
|> put_flash(:error, "User not found.")
|> push_navigate(to: ~p"/admin/users")}
end
end
@impl true
def handle_event("validate", %{"user" => user_params}, socket) do
if socket.assigns.can_manage do
changeset =
socket.assigns.user
|> Accounts.change_user_as_admin(user_params)
|> Map.put(:action, :validate)
{:noreply, assign(socket, :form, to_form(changeset, action: :validate))}
else
{:noreply, put_flash(socket, :error, "You are not authorized to modify this user.")}
end
end
def handle_event("save", %{"user" => user_params}, socket) do
case Accounts.update_user_as_admin(
socket.assigns.current_scope,
socket.assigns.user,
user_params
) do
{:ok, user} ->
{:noreply,
socket
|> assign_user(user)
|> put_flash(:info, "User updated successfully.")}
{:error, :unauthorized} ->
{:noreply, put_flash(socket, :error, "You are not authorized to modify this user.")}
{:error, :own_role} ->
{:noreply, put_flash(socket, :error, "You cannot change your own role.")}
{:error, :last_super_admin} ->
{:noreply, put_flash(socket, :error, "You cannot demote the last super admin.")}
{:error, %Ecto.Changeset{} = changeset} ->
{:noreply, assign(socket, :form, to_form(changeset, action: :insert))}
end
end
def handle_event("resend_confirmation", _params, socket) do
case Accounts.resend_user_confirmation_instructions_as_admin(
socket.assigns.current_scope,
socket.assigns.user,
&url(~p"/users/confirm/#{&1}")
) do
{:ok, _email} ->
{:noreply, put_flash(socket, :info, "Confirmation email sent.")}
{:error, :already_confirmed} ->
{:noreply, put_flash(socket, :error, "That account is already confirmed.")}
{:error, :unauthorized} ->
{:noreply, put_flash(socket, :error, "You are not authorized to email this user.")}
{:error, _reason} ->
{:noreply, put_flash(socket, :error, "The confirmation email could not be sent.")}
end
end
def handle_event("send_password_reset", _params, socket) do
case Accounts.send_user_reset_password_instructions_as_admin(
socket.assigns.current_scope,
socket.assigns.user,
&url(~p"/users/reset-password/#{&1}")
) do
{:ok, _email} ->
{:noreply, put_flash(socket, :info, "Password reset email sent.")}
{:error, :unauthorized} ->
{:noreply, put_flash(socket, :error, "You are not authorized to email this user.")}
{:error, _reason} ->
{:noreply, put_flash(socket, :error, "The password reset email could not be sent.")}
end
end
defp assign_user(socket, user) do
can_manage = Policy.can_manage_user?(socket.assigns.current_scope, user)
socket
|> assign(:page_title, user.username)
|> assign(:user, user)
|> assign(:can_manage, can_manage)
|> assign(:plan_options, @plan_options)
|> assign(:role_options, role_options(socket.assigns.current_scope))
|> assign(:form, to_form(Accounts.change_user_as_admin(user)))
end
defp role_options(scope) do
for role <- Role.values(),
Policy.can_assign_role?(scope, role),
do: {role_label(role), role}
end
defp role_label(:super_admin), do: "Super admin"
defp role_label(role), do: role |> Atom.to_string() |> String.capitalize()
defp confirmed_label(%{confirmed_at: nil}), do: "No"
defp confirmed_label(_user), do: "Yes"
defp format_datetime(nil), do: "—"
defp format_datetime(%DateTime{} = datetime) do
Calendar.strftime(datetime, "%Y-%m-%d %H:%M UTC")
end
end
@@ -13,6 +13,8 @@ defmodule ChesstrainerWeb.EndgameLive.Form do
def render(assigns) do
~H"""
<Layouts.app flash={@flash}>
<Layouts.admin_nav current_scope={@current_scope} />
<.header>
{@page_title}
<:subtitle>Use this form to manage endgame records in your database.</:subtitle>
@@ -48,7 +50,7 @@ defmodule ChesstrainerWeb.EndgameLive.Form do
placeholder="Search or create a theme…"
/>
<ul class="mt-2 w-full rounded-md border border-base-300 bg-base-100 p-1 shadow-sm">
<ul>
<li :for={theme <- @theme_results}>
<button
type="button"
@@ -14,6 +14,7 @@ defmodule ChesstrainerWeb.EndgameLive.GuestTrain do
alias Chesstrainer.Endgames
alias Chesstrainer.GuestLimits
alias ChesstrainerWeb.ClientAddress
alias ChesstrainerWeb.EndgameLive.PlayCore
alias ChesstrainerWeb.PlayComponents
@@ -112,7 +113,7 @@ defmodule ChesstrainerWeb.EndgameLive.GuestTrain do
{:ok, redirect(socket, to: ~p"/train")}
connected?(socket) ->
take_puzzle(socket, client_address(socket))
take_puzzle(socket, ClientAddress.from_socket(socket))
true ->
{:ok,
@@ -222,46 +223,6 @@ defmodule ChesstrainerWeb.EndgameLive.GuestTrain do
end
end
defp client_address(socket) do
if GuestLimits.trust_forwarded_for?() do
forwarded_address(socket) || peer_address(socket)
else
peer_address(socket)
end
end
defp peer_address(socket) do
case get_connect_info(socket, :peer_data) do
%{address: address} -> address
_ -> nil
end
end
defp forwarded_address(socket) do
with headers when is_list(headers) <- get_connect_info(socket, :x_headers),
{_, value} <- List.keyfind(headers, "x-forwarded-for", 0),
address when address != nil <- parse_address(value) do
address
else
_ -> nil
end
end
# The rightmost entry is the one our own proxy appended.
defp parse_address(value) do
value
|> String.split(",")
|> List.last()
|> to_string()
|> String.trim()
|> String.to_charlist()
|> :inet.parse_address()
|> case do
{:ok, address} -> address
{:error, _} -> nil
end
end
defp signed_in?(socket) do
case socket.assigns.current_scope do
%{user: %{}} -> true
@@ -9,6 +9,8 @@ defmodule ChesstrainerWeb.EndgameLive.Index do
def render(assigns) do
~H"""
<Layouts.app flash={@flash} wide>
<Layouts.admin_nav current_scope={@current_scope} />
<.header>
Listing Endgames
<:actions>
@@ -26,6 +26,8 @@ defmodule ChesstrainerWeb.EndgameLive.Show do
~H"""
<Layouts.app flash={@flash} wide>
<Layouts.admin_nav current_scope={@current_scope} />
<.header>
Endgame {@endgame.id}
<:subtitle>This is a endgame record from your database.</:subtitle>
+236
View File
@@ -0,0 +1,236 @@
defmodule ChesstrainerWeb.LoginThrottle do
@moduledoc """
In-memory failure throttle for password logins.
Failures are counted in two independent fixed windows: one per client address
and one per normalised login (email or username). A successful login clears
the login bucket only, so one account stays protected from distributed
guessing while one address stays protected from spraying many accounts.
Addresses and logins are HMACed with a per-boot secret before they reach ETS;
raw values are never stored or logged. The table is per node and is cleared on
restart, which is acceptable for the current single-node deployment.
"""
use GenServer
@table :login_throttle
@sweep_interval :timer.minutes(1)
@default_window_ms :timer.minutes(15)
@default_max_per_ip 10
@default_max_per_login 5
@typedoc "An IPv4/IPv6 address, or `nil` when the socket has no peer data."
@type address :: :inet.ip_address() | nil
@typedoc "Which bucket blocked the attempt."
@type bucket :: :ip | :login
@doc "Starts the throttle."
def start_link(opts \\ []), do: GenServer.start_link(__MODULE__, opts, name: __MODULE__)
@doc """
Checks both buckets without recording anything.
Returns `:ok`, or `{:throttled, bucket, retry_in_ms}` when that bucket is
already at its limit.
"""
@spec check(address, String.t() | nil) :: :ok | {:throttled, bucket(), non_neg_integer()}
def check(address, login), do: GenServer.call(__MODULE__, {:check, address, login})
@doc "Records one failed authentication in both buckets."
@spec record_failure(address, String.t() | nil) :: :ok
def record_failure(address, login) do
GenServer.call(__MODULE__, {:record_failure, address, login})
end
@doc "Clears the login bucket. The address bucket deliberately stays."
@spec record_success(String.t() | nil) :: :ok
def record_success(login), do: GenServer.call(__MODULE__, {:record_success, login})
@doc """
Claims a confirmation-email resend for `login`.
Returns true at most once per cooldown window, so repeated unconfirmed login
attempts cannot send a fresh confirmation email on every try.
"""
@spec claim_confirmation_resend(String.t() | nil) :: boolean()
def claim_confirmation_resend(login) do
GenServer.call(__MODULE__, {:claim_confirmation_resend, login})
end
@doc """
Returns a stable, non-reversible fingerprint of an address for log metadata.
The digest is scoped to this boot, matching the throttle keys.
"""
@spec fingerprint(address) :: String.t() | nil
def fingerprint(address), do: GenServer.call(__MODULE__, {:fingerprint, address})
@doc "Clears every bucket. Intended for tests."
def reset, do: GenServer.call(__MODULE__, :reset)
@doc "Failures allowed per address before the next attempt is blocked."
def max_per_ip, do: config() |> Keyword.get(:max_per_ip, @default_max_per_ip)
@doc "Failures allowed per login before the next attempt is blocked."
def max_per_login, do: config() |> Keyword.get(:max_per_login, @default_max_per_login)
@doc "How long a bucket stays active, in milliseconds."
def window_ms, do: config() |> Keyword.get(:window_ms, @default_window_ms)
defp config, do: Application.get_env(:chesstrainer, __MODULE__, [])
@impl true
def init(opts) do
:ets.new(@table, [:named_table, :set])
Process.send_after(self(), :sweep, @sweep_interval)
{:ok,
%{
secret: :crypto.strong_rand_bytes(32),
window_ms: Keyword.get(opts, :window_ms, window_ms()),
max_per_ip: Keyword.get(opts, :max_per_ip, max_per_ip()),
max_per_login: Keyword.get(opts, :max_per_login, max_per_login()),
confirmation_cooldown_ms: Keyword.get(opts, :confirmation_cooldown_ms, window_ms())
}}
end
@impl true
def handle_call({:check, address, login}, _from, state) do
now = now_ms()
result =
case blocked(:ip, address, state, now) do
nil -> blocked(:login, normalize_login(login), state, now) || :ok
blocked -> blocked
end
{:reply, result, state}
end
def handle_call({:record_failure, address, login}, _from, state) do
now = now_ms()
bump(:ip, address, state, now)
bump(:login, normalize_login(login), state, now)
{:reply, :ok, state}
end
def handle_call({:record_success, login}, _from, state) do
case normalize_login(login) do
nil -> :ok
login -> :ets.delete(@table, key(state.secret, :login, login))
end
{:reply, :ok, state}
end
def handle_call({:claim_confirmation_resend, login}, _from, state) do
normalized = normalize_login(login)
now = now_ms()
case normalized do
nil ->
{:reply, true, state}
login ->
key = key(state.secret, :confirmation, login)
case count(key, now) do
nil ->
:ets.insert(@table, {key, now + state.confirmation_cooldown_ms, 1})
{:reply, true, state}
_active ->
{:reply, false, state}
end
end
end
def handle_call({:fingerprint, nil}, _from, state), do: {:reply, nil, state}
def handle_call({:fingerprint, address}, _from, state) do
fingerprint =
state.secret
|> key(:ip, address)
|> Base.encode16(case: :lower)
{:reply, fingerprint, state}
end
def handle_call(:reset, _from, state) do
:ets.delete_all_objects(@table)
{:reply, :ok, state}
end
@impl true
def handle_info(:sweep, state) do
:ets.select_delete(@table, [{{:_, :"$1", :_}, [{:"=<", :"$1", now_ms()}], [true]}])
Process.send_after(self(), :sweep, @sweep_interval)
{:noreply, state}
end
defp blocked(_bucket, nil, _state, _now), do: nil
defp blocked(bucket, value, state, now) do
key = key(state.secret, bucket, value)
limit = limit(bucket, state)
case count(key, now) do
{count, expires_at} when count >= limit ->
{:throttled, bucket, max(expires_at - now, 0)}
_ ->
nil
end
end
defp bump(_bucket, nil, _state, _now), do: :ok
defp bump(bucket, value, state, now) do
key = key(state.secret, bucket, value)
case count(key, now) do
{count, expires_at} ->
:ets.insert(@table, {key, expires_at, count + 1})
nil ->
:ets.insert(@table, {key, now + state.window_ms, 1})
end
end
defp count(key, now) do
case :ets.lookup(@table, key) do
[{^key, expires_at, count}] when expires_at > now ->
{count, expires_at}
[{^key, _expires_at, _count}] ->
:ets.delete(@table, key)
nil
[] ->
nil
end
end
defp limit(:ip, state), do: state.max_per_ip
defp limit(:login, state), do: state.max_per_login
defp key(secret, bucket, value) do
:crypto.mac(:hmac, :sha256, secret, [Atom.to_string(bucket), "|", value_binary(value)])
end
defp value_binary(value) when is_binary(value), do: value
defp value_binary(value) when is_tuple(value), do: :erlang.term_to_binary(value)
defp normalize_login(login) when is_binary(login) do
case login |> String.trim() |> String.downcase() do
"" -> nil
login -> login
end
end
defp normalize_login(_login), do: nil
defp now_ms, do: System.system_time(:millisecond)
end
+9 -1
View File
@@ -43,7 +43,7 @@ defmodule ChesstrainerWeb.Router do
scope "/admin", ChesstrainerWeb do
pipe_through [:browser, :noindex, :require_admin_user]
live_session :endgames,
live_session :admin,
on_mount: [
{ChesstrainerWeb.UserAuth, :enforce_prelaunch},
{ChesstrainerWeb.UserAuth, :require_admin}
@@ -52,6 +52,14 @@ defmodule ChesstrainerWeb.Router do
live "/endgames/new", EndgameLive.Form, :new
live "/endgames/:id", EndgameLive.Show, :show
live "/endgames/:id/edit", EndgameLive.Form, :edit
live "/themes", Admin.ThemeLive.Index, :index
live "/themes/new", Admin.ThemeLive.Form, :new
live "/themes/:id/edit", Admin.ThemeLive.Form, :edit
live "/users", Admin.UserLive.Index, :index
live "/users/new", Admin.UserLive.New, :new
live "/users/:id", Admin.UserLive.Show, :show
end
end
+6 -1
View File
@@ -218,7 +218,12 @@ defmodule ChesstrainerWeb.UserAuth do
ChesstrainerWeb.UserLive.Profile,
ChesstrainerWeb.EndgameLive.Index,
ChesstrainerWeb.EndgameLive.Form,
ChesstrainerWeb.EndgameLive.Show
ChesstrainerWeb.EndgameLive.Show,
ChesstrainerWeb.Admin.ThemeLive.Index,
ChesstrainerWeb.Admin.ThemeLive.Form,
ChesstrainerWeb.Admin.UserLive.Index,
ChesstrainerWeb.Admin.UserLive.New,
ChesstrainerWeb.Admin.UserLive.Show
]
def on_mount(:enforce_prelaunch, _params, _session, socket) do
+2 -1
View File
@@ -11,7 +11,8 @@ defmodule Mix.Tasks.Accounts.Promote do
Roles, from least to most authority: `member`, `moderator`, `admin`,
`super_admin`.
Role changes are deliberately CLI-only for now; there is no admin UI.
This task remains the CLI fallback for bootstrapping a role. Once an admin
exists, roles and plans can also be managed at `/admin/users`.
"""
@impl Mix.Task
+137
View File
@@ -0,0 +1,137 @@
defmodule Chesstrainer.Accounts.PolicyTest do
use Chesstrainer.DataCase, async: true
import Chesstrainer.AccountsFixtures
alias Chesstrainer.Accounts
alias Chesstrainer.Accounts.Policy
alias Chesstrainer.Accounts.Scope
describe "can?/2" do
test "members and moderators have no admin capabilities" do
for role <- [:member, :moderator], capability <- Policy.capabilities() do
refute Policy.can?(scope_for(role), capability)
end
end
test "admins and super admins have every admin capability" do
for role <- [:admin, :super_admin], capability <- Policy.capabilities() do
assert Policy.can?(scope_for(role), capability)
end
end
test "a nil scope has no capabilities" do
refute Policy.can?(nil, :manage_users)
end
end
describe "can_manage_user?/2" do
test "an admin can manage members and moderators" do
scope = scope_for(:admin)
assert Policy.can_manage_user?(scope, user_with_role(:member))
assert Policy.can_manage_user?(scope, user_with_role(:moderator))
end
test "an admin cannot manage admins, super admins, or themselves" do
admin = user_with_role(:admin)
scope = Scope.for_user(admin)
refute Policy.can_manage_user?(scope, admin)
refute Policy.can_manage_user?(scope, user_with_role(:admin))
refute Policy.can_manage_user?(scope, user_with_role(:super_admin))
end
test "a super admin can manage everyone except themselves" do
super = user_with_role(:super_admin)
scope = Scope.for_user(super)
refute Policy.can_manage_user?(scope, super)
assert Policy.can_manage_user?(scope, user_with_role(:member))
assert Policy.can_manage_user?(scope, user_with_role(:moderator))
assert Policy.can_manage_user?(scope, user_with_role(:admin))
assert Policy.can_manage_user?(scope, user_with_role(:super_admin))
end
test "moderators and members cannot manage anyone" do
for role <- [:member, :moderator] do
scope = scope_for(role)
refute Policy.can_manage_user?(scope, user_with_role(:member))
refute Policy.can_manage_user?(scope, user_with_role(:moderator))
end
end
end
describe "can_view_user?/2" do
test "an admin can view lower-ranked users and themselves" do
admin = user_with_role(:admin)
scope = Scope.for_user(admin)
assert Policy.can_view_user?(scope, admin)
assert Policy.can_view_user?(scope, user_with_role(:member))
assert Policy.can_view_user?(scope, user_with_role(:moderator))
refute Policy.can_view_user?(scope, user_with_role(:admin))
refute Policy.can_view_user?(scope, user_with_role(:super_admin))
end
test "a super admin can view everyone" do
super = user_with_role(:super_admin)
scope = Scope.for_user(super)
assert Policy.can_view_user?(scope, super)
assert Policy.can_view_user?(scope, user_with_role(:member))
assert Policy.can_view_user?(scope, user_with_role(:moderator))
assert Policy.can_view_user?(scope, user_with_role(:admin))
assert Policy.can_view_user?(scope, user_with_role(:super_admin))
end
end
describe "can_assign_role?/2" do
test "admins can assign member and moderator only" do
scope = scope_for(:admin)
assert Policy.can_assign_role?(scope, :member)
assert Policy.can_assign_role?(scope, :moderator)
refute Policy.can_assign_role?(scope, :admin)
refute Policy.can_assign_role?(scope, :super_admin)
end
test "super admins can assign every role" do
scope = scope_for(:super_admin)
for role <- [:member, :moderator, :admin, :super_admin] do
assert Policy.can_assign_role?(scope, role)
end
end
end
describe "visible_roles/1" do
test "admins only see members and moderators" do
assert Policy.visible_roles(scope_for(:admin)) == [:member, :moderator]
end
test "super admins see every role" do
assert Policy.visible_roles(scope_for(:super_admin)) ==
[:member, :moderator, :admin, :super_admin]
end
test "members and moderators see no users" do
assert Policy.visible_roles(scope_for(:member)) == []
assert Policy.visible_roles(scope_for(:moderator)) == []
end
end
defp scope_for(role) do
role
|> user_with_role()
|> Scope.for_user()
end
defp user_with_role(:member), do: user_fixture()
defp user_with_role(role) do
{:ok, user} = Accounts.update_user_role(user_fixture(), role)
user
end
end
+387
View File
@@ -0,0 +1,387 @@
defmodule Chesstrainer.AccountsAdminTest do
use Chesstrainer.DataCase, async: false
require Logger
import Chesstrainer.AccountsFixtures
import ExUnit.CaptureLog
import Swoosh.TestAssertions
alias Chesstrainer.Accounts
alias Chesstrainer.Accounts.Scope
describe "list_users_for_admin/2" do
test "an admin only sees members and moderators" do
admin = user_with_role(:admin)
member = user_fixture()
moderator = user_with_role(:moderator)
other_admin = user_with_role(:admin)
super_admin = user_with_role(:super_admin)
assert {:ok, users} = Accounts.list_users_for_admin(Scope.for_user(admin))
ids = users |> Enum.map(& &1.id) |> MapSet.new()
assert ids == MapSet.new([member.id, moderator.id])
refute MapSet.member?(ids, other_admin.id)
refute MapSet.member?(ids, super_admin.id)
assert {:ok, 2} = Accounts.count_users_for_admin(Scope.for_user(admin))
end
test "a super admin sees every role, including themselves" do
super_admin = user_with_role(:super_admin)
member = user_fixture()
moderator = user_with_role(:moderator)
admin = user_with_role(:admin)
assert {:ok, users} = Accounts.list_users_for_admin(Scope.for_user(super_admin))
ids = users |> Enum.map(& &1.id) |> MapSet.new()
assert MapSet.new([super_admin.id, member.id, moderator.id, admin.id]) == ids
end
test "search matches email and username case-insensitively" do
admin = user_with_role(:admin)
target = user_fixture(%{email: "FindMe@Example.com", username: "searchable_name"})
user_fixture()
assert {:ok, [found]} =
Accounts.list_users_for_admin(Scope.for_user(admin), search: "findme")
assert found.id == target.id
assert {:ok, [found]} =
Accounts.list_users_for_admin(Scope.for_user(admin), search: "SEARCHABLE")
assert found.id == target.id
assert {:ok, []} = Accounts.list_users_for_admin(Scope.for_user(admin), search: "no-match")
end
test "paginates 25 users per page" do
admin = user_with_role(:admin)
for _ <- 1..26 do
user_fixture()
end
assert {:ok, 26} = Accounts.count_users_for_admin(Scope.for_user(admin))
assert {:ok, page_one} = Accounts.list_users_for_admin(Scope.for_user(admin), page: 1)
assert length(page_one) == 25
assert {:ok, page_two} = Accounts.list_users_for_admin(Scope.for_user(admin), page: 2)
assert length(page_two) == 1
end
test "members and moderators are rejected" do
for role <- [:member, :moderator] do
scope = scope_for(role)
assert {:error, :unauthorized} = Accounts.list_users_for_admin(scope)
assert {:error, :unauthorized} = Accounts.count_users_for_admin(scope)
assert {:error, :unauthorized} = Accounts.get_user_for_admin(scope, user_fixture().id)
end
end
end
describe "update_user_as_admin/3" do
test "an admin can change a member's role and plan" do
admin = user_with_role(:admin)
member = user_fixture()
previous_level = Logger.level()
Logger.configure(level: :info)
log =
try do
capture_log(
[format: "$message $metadata\n", metadata: [:actor_id, :target_id, :fields]],
fn ->
assert {:ok, updated} =
Accounts.update_user_as_admin(Scope.for_user(admin), member, %{
"role" => "moderator",
"plan" => "premium"
})
assert updated.role == :moderator
assert updated.plan == :premium
end
)
after
Logger.configure(level: previous_level)
end
assert log =~ "admin.user.updated"
assert log =~ admin.id
assert log =~ member.id
refute log =~ member.email
end
test "an admin can change a moderator" do
admin = user_with_role(:admin)
moderator = user_with_role(:moderator)
assert {:ok, updated} =
Accounts.update_user_as_admin(Scope.for_user(admin), moderator, %{
"role" => "member"
})
assert updated.role == :member
end
test "an admin cannot change another admin or a super admin" do
admin = user_with_role(:admin)
for target <- [user_with_role(:admin), user_with_role(:super_admin)] do
assert {:error, :unauthorized} =
Accounts.update_user_as_admin(Scope.for_user(admin), target, %{
"plan" => "premium"
})
assert Accounts.get_user!(target.id).plan == :free
end
end
test "an admin cannot promote a member above their own rank" do
admin = user_with_role(:admin)
member = user_fixture()
assert {:error, :unauthorized} =
Accounts.update_user_as_admin(Scope.for_user(admin), member, %{"role" => "admin"})
assert Accounts.get_user!(member.id).role == :member
end
test "a super admin can change an admin's role and plan" do
super_admin = user_with_role(:super_admin)
admin = user_with_role(:admin)
assert {:ok, updated} =
Accounts.update_user_as_admin(Scope.for_user(super_admin), admin, %{
"role" => "moderator",
"plan" => "premium"
})
assert updated.role == :moderator
assert updated.plan == :premium
end
test "a super admin can change another super admin's plan" do
super_admin = user_with_role(:super_admin)
other_super_admin = user_with_role(:super_admin)
assert {:ok, updated} =
Accounts.update_user_as_admin(
Scope.for_user(super_admin),
other_super_admin,
%{"plan" => "premium"}
)
assert updated.plan == :premium
end
test "a super admin cannot change their own role" do
super_admin = user_with_role(:super_admin)
assert {:error, :own_role} =
Accounts.update_user_as_admin(
Scope.for_user(super_admin),
super_admin,
%{"role" => "admin"}
)
assert Accounts.get_user!(super_admin.id).role == :super_admin
end
test "the last super admin cannot be demoted" do
# The actor has the super-admin capability but is not persisted, leaving
# exactly one super admin in the database.
actor = %{user_fixture() | role: :super_admin}
target = user_with_role(:super_admin)
assert {:error, :last_super_admin} =
Accounts.update_user_as_admin(Scope.for_user(actor), target, %{
"role" => "admin"
})
assert Accounts.get_user!(target.id).role == :super_admin
end
test "members and moderators are rejected" do
for role <- [:member, :moderator] do
target = user_fixture()
assert {:error, :unauthorized} =
Accounts.update_user_as_admin(scope_for(role), target, %{"plan" => "premium"})
end
end
end
describe "invite_user_as_admin/3" do
test "an admin can invite a member and an email is sent" do
admin = user_with_role(:admin)
attrs = invite_attrs()
assert {:ok, invited} =
Accounts.invite_user_as_admin(Scope.for_user(admin), attrs, &password_reset_url/1)
assert invited.email == attrs["email"]
assert invited.username == attrs["username"]
assert invited.role == :member
assert invited.plan == :free
assert invited.confirmed_at
assert_email_sent(
to: invited.email,
subject: "You're invited to Inner Square Chess"
)
end
test "a super admin can invite an admin" do
super_admin = user_with_role(:super_admin)
assert {:ok, invited} =
Accounts.invite_user_as_admin(
Scope.for_user(super_admin),
Map.put(invite_attrs(), "role", "admin"),
&password_reset_url/1
)
assert invited.role == :admin
end
test "an admin cannot invite an admin or super admin" do
admin = user_with_role(:admin)
for role <- ["admin", "super_admin"] do
attrs = Map.put(invite_attrs(), "role", role)
assert {:error, :unauthorized} =
Accounts.invite_user_as_admin(
Scope.for_user(admin),
attrs,
&password_reset_url/1
)
refute Accounts.get_user_by_email(attrs["email"])
end
end
test "duplicate emails return the changeset error" do
admin = user_with_role(:admin)
existing = user_fixture()
attrs = Map.put(invite_attrs(), "email", existing.email)
assert {:error, changeset} =
Accounts.invite_user_as_admin(
Scope.for_user(admin),
attrs,
&password_reset_url/1
)
assert changeset.errors[:email]
end
test "moderators and members are rejected" do
for role <- [:member, :moderator] do
assert {:error, :unauthorized} =
Accounts.invite_user_as_admin(
scope_for(role),
invite_attrs(),
&password_reset_url/1
)
end
end
end
describe "admin-initiated account emails" do
test "an admin can send a password reset to a member" do
admin = user_with_role(:admin)
member = user_fixture()
assert {:ok, _email} =
Accounts.send_user_reset_password_instructions_as_admin(
Scope.for_user(admin),
member,
&password_reset_url/1
)
assert_email_sent(to: member.email, subject: "Reset password instructions")
end
test "an admin cannot send a password reset to another admin" do
admin = user_with_role(:admin)
other_admin = user_with_role(:admin)
assert {:error, :unauthorized} =
Accounts.send_user_reset_password_instructions_as_admin(
Scope.for_user(admin),
other_admin,
&password_reset_url/1
)
refute_email_sent()
end
test "a super admin can send a password reset to an admin" do
super_admin = user_with_role(:super_admin)
admin = user_with_role(:admin)
assert {:ok, _email} =
Accounts.send_user_reset_password_instructions_as_admin(
Scope.for_user(super_admin),
admin,
&password_reset_url/1
)
assert_email_sent(to: admin.email, subject: "Reset password instructions")
end
test "an admin can resend confirmation to an unconfirmed member" do
admin = user_with_role(:admin)
member = unconfirmed_user_fixture()
assert {:ok, _email} =
Accounts.resend_user_confirmation_instructions_as_admin(
Scope.for_user(admin),
member,
&confirmation_url/1
)
assert_email_sent(to: member.email, subject: "Confirmation instructions")
end
test "resending confirmation to a confirmed user reports the error" do
admin = user_with_role(:admin)
member = user_fixture()
assert {:error, :already_confirmed} =
Accounts.resend_user_confirmation_instructions_as_admin(
Scope.for_user(admin),
member,
&confirmation_url/1
)
end
end
defp password_reset_url(token), do: "http://localhost/users/reset-password/#{token}"
defp confirmation_url(token), do: "http://localhost/users/confirm/#{token}"
defp invite_attrs do
%{
"email" => unique_user_email(),
"username" => unique_username(),
"role" => "member",
"plan" => "free"
}
end
defp scope_for(role), do: role |> user_with_role() |> Scope.for_user()
defp user_with_role(:member), do: user_fixture()
defp user_with_role(role) do
{:ok, user} = Accounts.update_user_role(user_fixture(), role)
user
end
end
@@ -37,6 +37,22 @@ defmodule ChesstrainerWeb.AdminGatingTest do
assert redirected_to(conn) == ~p"/"
end
test "members and moderators are redirected from themes and users", _context do
for role <- [:member, :moderator] do
{:ok, user} = Accounts.update_user_role(user_fixture(), role)
conn = log_in_user(build_conn(), user)
for path <- [
~p"/admin/themes",
~p"/admin/themes/new",
~p"/admin/users",
~p"/admin/users/new"
] do
assert redirected_to(get(conn, path)) == ~p"/"
end
end
end
test "admins are admitted", %{conn: conn} do
{:ok, user} = Accounts.update_user_role(user_fixture(), :admin)
@@ -0,0 +1,83 @@
defmodule ChesstrainerWeb.ClientAddressTest do
use ExUnit.Case, async: false
import Plug.Test
alias Chesstrainer.GuestLimits
alias ChesstrainerWeb.ClientAddress
@peer {10, 0, 0, 1}
@forwarded {203, 0, 113, 9}
setup do
previous = Application.get_env(:chesstrainer, GuestLimits, [])
on_exit(fn -> Application.put_env(:chesstrainer, GuestLimits, previous) end)
:ok
end
test "ignores X-Forwarded-For when trust is off" do
trust_forwarded_for(false)
conn =
conn(:post, "/users/log-in")
|> Map.put(:remote_ip, @peer)
|> Map.put(:req_headers, [{"x-forwarded-for", "203.0.113.9"}])
assert ClientAddress.from_conn(conn) == @peer
end
test "honours the rightmost X-Forwarded-For entry when trust is on" do
trust_forwarded_for(true)
conn =
conn(:post, "/users/log-in")
|> Map.put(:remote_ip, @peer)
|> Map.put(:req_headers, [{"x-forwarded-for", "198.51.100.2, 203.0.113.9"}])
assert ClientAddress.from_conn(conn) == @forwarded
end
test "falls back to the peer address for an invalid forwarded header" do
trust_forwarded_for(true)
conn =
conn(:post, "/users/log-in")
|> Map.put(:remote_ip, @peer)
|> Map.put(:req_headers, [{"x-forwarded-for", "not-an-address"}])
assert ClientAddress.from_conn(conn) == @peer
end
test "ignores socket X-Forwarded-For when trust is off" do
trust_forwarded_for(false)
assert ClientAddress.from_socket(socket()) == @peer
end
test "honours socket X-Forwarded-For when trust is on" do
trust_forwarded_for(true)
assert ClientAddress.from_socket(socket()) == @forwarded
end
defp socket do
%Phoenix.LiveView.Socket{
private: %{
connect_info: %{
peer_data: %{address: @peer},
x_headers: [{"x-forwarded-for", "203.0.113.9"}]
}
}
}
end
defp trust_forwarded_for(enabled?) do
config = Application.get_env(:chesstrainer, GuestLimits, [])
Application.put_env(
:chesstrainer,
GuestLimits,
Keyword.put(config, :trust_forwarded_for, enabled?)
)
end
end
@@ -1,10 +1,16 @@
defmodule ChesstrainerWeb.UserSessionControllerTest do
use ChesstrainerWeb.ConnCase, async: true
use ChesstrainerWeb.ConnCase, async: false
@moduletag :capture_log
import Chesstrainer.AccountsFixtures
import ExUnit.CaptureLog
import Swoosh.TestAssertions
alias ChesstrainerWeb.LoginThrottle
setup do
LoginThrottle.reset()
%{user: user_fixture()}
end
@@ -77,7 +83,7 @@ defmodule ChesstrainerWeb.UserSessionControllerTest do
assert redirected_to(conn) == ~p"/users/log-in"
end
test "does not log in an unconfirmed user and resends confirmation instructions", %{
test "does not log in an unconfirmed user and resends confirmation instructions once", %{
conn: conn
} do
user = unconfirmed_user_fixture()
@@ -94,6 +100,146 @@ defmodule ChesstrainerWeb.UserSessionControllerTest do
assert redirected_to(conn) == ~p"/users/log-in"
assert_email_sent(subject: "Confirmation instructions")
second =
post(build_conn(), ~p"/users/log-in", %{
"user" => %{"email" => user.email, "password" => valid_user_password()}
})
refute get_session(second, :user_token)
refute_email_sent()
end
test "blocks further attempts after the login limit is reached", %{
conn: conn,
user: user
} do
for _ <- 1..LoginThrottle.max_per_login() do
blocked =
post(conn, ~p"/users/log-in", %{
"user" => %{"email" => user.email, "password" => "wrong password"}
})
assert Phoenix.Flash.get(blocked.assigns.flash, :error) ==
"Invalid email, username or password"
end
conn =
post(conn, ~p"/users/log-in", %{
"user" => %{"email" => user.email, "password" => valid_user_password()}
})
refute get_session(conn, :user_token)
assert Phoenix.Flash.get(conn.assigns.flash, :error) ==
"Too many attempts. Try again in 15 minutes."
assert redirected_to(conn) == ~p"/users/log-in"
end
test "the address bucket blocks spraying many logins", %{conn: conn, user: user} do
for index <- 1..LoginThrottle.max_per_ip() do
blocked =
post(conn, ~p"/users/log-in", %{
"user" => %{
"email" => "unknown#{index}@example.com",
"password" => "wrong password"
}
})
assert Phoenix.Flash.get(blocked.assigns.flash, :error) ==
"Invalid email, username or password"
end
conn =
post(conn, ~p"/users/log-in", %{
"user" => %{"email" => user.email, "password" => valid_user_password()}
})
refute get_session(conn, :user_token)
assert Phoenix.Flash.get(conn.assigns.flash, :error) =~ "Too many attempts."
end
test "a successful login clears the login bucket", %{conn: conn, user: user} do
for _ <- 1..(LoginThrottle.max_per_login() - 1) do
post(conn, ~p"/users/log-in", %{
"user" => %{"email" => user.email, "password" => "wrong password"}
})
end
conn =
post(conn, ~p"/users/log-in", %{
"user" => %{"email" => user.email, "password" => valid_user_password()}
})
assert get_session(conn, :user_token)
post(build_conn(), ~p"/users/log-in", %{
"user" => %{"email" => user.email, "password" => "wrong password"}
})
conn =
post(build_conn(), ~p"/users/log-in", %{
"user" => %{"email" => user.email, "password" => valid_user_password()}
})
assert get_session(conn, :user_token)
end
test "the admin login uses the same throttle", %{conn: conn, user: user} do
for _ <- 1..LoginThrottle.max_per_login() do
post(conn, ~p"/admin/log-in", %{
"user" => %{"email" => user.email, "password" => "wrong password"}
})
end
conn =
post(conn, ~p"/admin/log-in", %{
"user" => %{"email" => user.email, "password" => valid_user_password()}
})
refute get_session(conn, :user_token)
assert Phoenix.Flash.get(conn.assigns.flash, :error) =~ "Too many attempts."
end
test "log events contain no raw address or password", %{conn: conn, user: user} do
log =
capture_log(
[format: "$message $metadata\n", metadata: [:ip, :reason]],
fn ->
post(conn, ~p"/users/log-in", %{
"user" => %{"email" => user.email, "password" => "secret-wrong-password"}
})
end
)
assert log =~ "auth.login.failed"
assert log =~ "invalid_credentials"
refute log =~ "127.0.0.1"
refute log =~ "secret-wrong-password"
refute log =~ user.email
end
test "a throttled request logs auth.login.throttled", %{conn: conn, user: user} do
for _ <- 1..LoginThrottle.max_per_login() do
post(conn, ~p"/users/log-in", %{
"user" => %{"email" => user.email, "password" => "wrong password"}
})
end
log =
capture_log(
[format: "$message $metadata\n", metadata: [:ip, :reason]],
fn ->
post(conn, ~p"/users/log-in", %{
"user" => %{"email" => user.email, "password" => valid_user_password()}
})
end
)
assert log =~ "auth.login.throttled"
assert log =~ "login"
refute log =~ "127.0.0.1"
end
end
@@ -0,0 +1,71 @@
defmodule ChesstrainerWeb.Admin.ThemeLive.FormTest do
use ChesstrainerWeb.ConnCase
import Phoenix.LiveViewTest
import Chesstrainer.ThemesFixtures
alias Chesstrainer.Themes
setup :register_and_log_in_admin
test "creates a theme", %{conn: conn} do
{:ok, view, _html} = live(conn, ~p"/admin/themes/new")
view
|> form("#theme-form", theme: %{name: " Lucena ", category: "endgame"})
|> render_submit()
assert_redirect(view, ~p"/admin/themes")
assert [%{name: "Lucena", category: :endgame}] = Themes.search("Lucena", "endgame")
end
test "renames and recategorises a theme", %{conn: conn} do
theme = theme_fixture(%{name: "Lucena", category: :endgame})
{:ok, view, _html} = live(conn, ~p"/admin/themes/#{theme.id}/edit")
view
|> form("#theme-form", theme: %{name: "Lucena", category: "opening"})
|> render_submit()
assert_redirect(view, ~p"/admin/themes")
updated = Themes.get_theme!(theme.id)
assert updated.name == "Lucena"
assert updated.category == :opening
end
test "shows the existing duplicate-name validation error", %{conn: conn} do
theme_fixture(%{name: "Lucena", category: :endgame})
{:ok, view, _html} = live(conn, ~p"/admin/themes/new")
html =
view
|> form("#theme-form", theme: %{name: "lucena", category: "endgame"})
|> render_submit()
assert html =~ "already exists"
assert length(Themes.list_themes()) == 1
end
test "validates a blank name", %{conn: conn} do
{:ok, view, _html} = live(conn, ~p"/admin/themes/new")
html =
view
|> form("#theme-form", theme: %{name: "", category: "endgame"})
|> render_submit()
assert html =~ "can&#39;t be blank"
end
test "shows the admin sub-navigation", %{conn: conn} do
{:ok, _view, html} = live(conn, ~p"/admin/themes/new")
assert html =~ ~p"/admin/endgames"
assert html =~ ~p"/admin/themes"
assert html =~ ~p"/admin/users"
end
end
@@ -0,0 +1,72 @@
defmodule ChesstrainerWeb.Admin.ThemeLive.IndexTest do
use ChesstrainerWeb.ConnCase
import Phoenix.LiveViewTest
import Chesstrainer.EndgamesFixtures
import Chesstrainer.ThemesFixtures
alias Chesstrainer.Endgames
alias Chesstrainer.Repo
alias Chesstrainer.Themes
setup :register_and_log_in_admin
test "lists themes with their usage count", %{conn: conn} do
used_theme = theme_fixture(%{name: "Lucena"})
unused_theme = theme_fixture(%{name: "Philidor"})
endgame = endgame_fixture()
{:ok, _} = Endgames.update_endgame(endgame, %{}, [used_theme])
{:ok, view, _html} = live(conn, ~p"/admin/themes")
assert has_element?(view, "#theme-#{used_theme.id}")
assert has_element?(view, "#theme-usage-#{used_theme.id}", "1 endgame")
assert has_element?(view, "#theme-usage-#{unused_theme.id}", "0 endgames")
end
test "filters by name and category", %{conn: conn} do
theme_fixture(%{name: "Lucena", category: :endgame})
theme_fixture(%{name: "Philidor", category: :endgame})
theme_fixture(%{name: "Pin", category: :tactic})
{:ok, view, _html} = live(conn, ~p"/admin/themes")
view |> form("#theme-admin-filter-form", %{search: "Luc"}) |> render_change()
assert has_element?(view, "td", "Lucena")
refute has_element?(view, "td", "Philidor")
refute has_element?(view, "td", "Pin")
view |> form("#theme-admin-filter-form", %{search: "", category: "tactic"}) |> render_change()
assert has_element?(view, "td", "Pin")
refute has_element?(view, "td", "Lucena")
end
test "shows an empty state that explains what themes do", %{conn: conn} do
{:ok, _view, html} = live(conn, ~p"/admin/themes")
assert html =~ "No themes yet"
assert html =~ "Themes power endgame filtering"
end
test "deleting a theme detaches it from endgames and keeps the endgame", %{conn: conn} do
theme = theme_fixture(%{name: "Lucena"})
endgame = endgame_fixture()
{:ok, _} = Endgames.update_endgame(endgame, %{}, [theme])
{:ok, view, html} = live(conn, ~p"/admin/themes")
assert html =~ "Used by 1 endgame"
assert html =~ "The endgames will be kept"
view |> element("#theme-#{theme.id} a", "Delete") |> render_click()
assert_raise Ecto.NoResultsError, fn -> Themes.get_theme!(theme.id) end
assert Endgames.get_endgame!(endgame.id)
endgame = Endgames.get_endgame!(endgame.id) |> Repo.preload(:themes)
assert endgame.themes == []
end
end
@@ -0,0 +1,77 @@
defmodule ChesstrainerWeb.Admin.UserLive.IndexTest do
use ChesstrainerWeb.ConnCase
import Phoenix.LiveViewTest
import Chesstrainer.AccountsFixtures
alias Chesstrainer.Accounts
setup :register_and_log_in_admin
test "lists the users an admin may manage", %{conn: conn} do
member = user_fixture()
moderator = user_with_role(:moderator)
other_admin = user_with_role(:admin)
super_admin = user_with_role(:super_admin)
{:ok, view, _html} = live(conn, ~p"/admin/users")
assert has_element?(view, "#user-" <> member.id)
assert has_element?(view, "#user-" <> moderator.id)
refute has_element?(view, "#user-" <> other_admin.id)
refute has_element?(view, "#user-" <> super_admin.id)
end
test "searches by email or username", %{conn: conn} do
target = user_fixture(%{email: "FindMe@Example.com", username: "searchable_name"})
user_fixture()
{:ok, view, _html} = live(conn, ~p"/admin/users")
view |> form("#admin-user-search-form", %{search: "findme"}) |> render_change()
assert has_element?(view, "#user-" <> target.id)
assert has_element?(view, "td", target.email)
view |> form("#admin-user-search-form", %{search: "searchable"}) |> render_change()
assert has_element?(view, "#user-" <> target.id)
view |> form("#admin-user-search-form", %{search: "nobody"}) |> render_change()
assert render(view) =~ "No users match"
end
test "paginates 25 users per page", %{conn: conn} do
for _ <- 1..26 do
user_fixture()
end
{:ok, view, _html} = live(conn, ~p"/admin/users")
assert row_count(view) == 25
assert render(view) =~ "Page 1 of 2"
view |> element("#next-page") |> render_click()
assert row_count(view) == 1
assert render(view) =~ "Page 2 of 2"
end
test "shows the admin navigation and invite action", %{conn: conn} do
{:ok, view, html} = live(conn, ~p"/admin/users")
assert html =~ ~p"/admin/endgames"
assert html =~ ~p"/admin/themes"
assert html =~ ~p"/admin/users/new"
assert has_element?(view, "#admin-user-search-form")
end
defp row_count(view) do
document = LazyHTML.from_fragment(render(view))
document |> LazyHTML.query("#admin-users tr") |> LazyHTML.to_tree() |> length()
end
defp user_with_role(role) do
{:ok, user} = Accounts.update_user_role(user_fixture(), role)
user
end
end
@@ -0,0 +1,87 @@
defmodule ChesstrainerWeb.Admin.UserLive.NewTest do
use ChesstrainerWeb.ConnCase
import Phoenix.LiveViewTest
import Chesstrainer.AccountsFixtures
import Swoosh.TestAssertions
alias Chesstrainer.Accounts
setup :register_and_log_in_admin
test "invites a new member", %{conn: conn} do
email = unique_user_email()
username = unique_username()
{:ok, view, _html} = live(conn, ~p"/admin/users/new")
{:ok, _view, html} =
view
|> form("#invite-user-form", user: %{email: email, username: username, role: "member"})
|> render_submit()
|> follow_redirect(conn, ~p"/admin/users")
assert html =~ "Invitation sent to #{email}."
invited = Accounts.get_user_by_email(email)
assert invited.username == username
assert invited.confirmed_at
assert_email_sent(to: email, subject: "You're invited to Inner Square Chess")
end
test "does not offer admin roles to an admin", %{conn: conn} do
{:ok, view, _html} = live(conn, ~p"/admin/users/new")
html = render(view)
assert html =~ "Moderator"
refute html =~ ~s(value="admin")
refute html =~ ~s(value="super_admin")
end
test "rejects a direct attempt to invite an admin", %{conn: conn} do
email = unique_user_email()
{:ok, view, _html} = live(conn, ~p"/admin/users/new")
html =
render_click(view, "save", %{
"user" => %{
"email" => email,
"username" => unique_username(),
"role" => "admin"
}
})
assert html =~ "You are not authorized to assign that role."
refute Accounts.get_user_by_email(email)
end
test "shows duplicate email errors", %{conn: conn} do
existing = user_fixture()
{:ok, view, _html} = live(conn, ~p"/admin/users/new")
html =
view
|> form("#invite-user-form",
user: %{
email: existing.email,
username: unique_username(),
role: "member"
}
)
|> render_submit()
assert html =~ "has already been taken"
end
test "shows the admin sub-navigation", %{conn: conn} do
{:ok, _view, html} = live(conn, ~p"/admin/users/new")
assert html =~ ~p"/admin/endgames"
assert html =~ ~p"/admin/themes"
assert html =~ ~p"/admin/users"
end
end
@@ -0,0 +1,126 @@
defmodule ChesstrainerWeb.Admin.UserLive.ShowTest do
use ChesstrainerWeb.ConnCase
import Phoenix.LiveViewTest
import Chesstrainer.AccountsFixtures
import Swoosh.TestAssertions
alias Chesstrainer.Accounts
setup :register_and_log_in_admin
test "shows the user's identity and editable fields", %{conn: conn} do
member = user_fixture()
{:ok, view, html} = live(conn, ~p"/admin/users/#{member.id}")
assert html =~ member.email
assert html =~ member.username
assert has_element?(view, "#admin-user-form")
assert has_element?(view, "#send-password-reset")
refute has_element?(view, "#resend-confirmation")
end
test "an admin can change a member's role and plan", %{conn: conn} do
member = user_fixture()
{:ok, view, _html} = live(conn, ~p"/admin/users/#{member.id}")
html =
view
|> form("#admin-user-form", user: %{role: "moderator", plan: "premium"})
|> render_submit()
assert html =~ "User updated successfully"
assert Accounts.get_user!(member.id).role == :moderator
assert Accounts.get_user!(member.id).plan == :premium
end
test "an admin cannot promote a member through a direct event", %{conn: conn} do
member = user_fixture()
{:ok, view, _html} = live(conn, ~p"/admin/users/#{member.id}")
html = render_click(view, "save", %{"user" => %{"role" => "admin"}})
assert html =~ "You are not authorized to modify this user."
assert Accounts.get_user!(member.id).role == :member
end
test "an admin can view themselves read-only but has no editable form", %{
conn: conn,
user: admin
} do
{:ok, view, html} = live(conn, ~p"/admin/users/#{admin.id}")
assert html =~ "You can view this account but not change its role or plan."
refute has_element?(view, "#admin-user-form")
end
test "an admin is redirected away from another admin's detail page", %{conn: conn} do
other_admin = user_with_role(:admin)
{:ok, _view, html} =
live(conn, ~p"/admin/users/#{other_admin.id}")
|> follow_redirect(conn, ~p"/admin/users")
assert html =~ "You are not authorized to view that user."
end
test "a super admin can change an admin's role and plan" do
super_admin = user_with_role(:super_admin)
admin = user_with_role(:admin)
conn = build_conn() |> log_in_user(super_admin)
{:ok, view, _html} = live(conn, ~p"/admin/users/#{admin.id}")
html =
view
|> form("#admin-user-form", user: %{role: "moderator", plan: "premium"})
|> render_submit()
assert html =~ "User updated successfully"
assert Accounts.get_user!(admin.id).role == :moderator
assert Accounts.get_user!(admin.id).plan == :premium
end
test "a super admin cannot change their own role, even through a direct event" do
super_admin = user_with_role(:super_admin)
conn = build_conn() |> log_in_user(super_admin)
{:ok, view, _html} = live(conn, ~p"/admin/users/#{super_admin.id}")
html = render_click(view, "save", %{"user" => %{"role" => "admin"}})
assert html =~ "You cannot change your own role."
assert Accounts.get_user!(super_admin.id).role == :super_admin
end
test "resends a confirmation email to an unconfirmed member", %{conn: conn} do
member = unconfirmed_user_fixture()
{:ok, view, _html} = live(conn, ~p"/admin/users/#{member.id}")
html = view |> element("#resend-confirmation") |> render_click()
assert html =~ "Confirmation email sent."
assert_email_sent(to: member.email, subject: "Confirmation instructions")
end
test "sends a password reset email to a member", %{conn: conn} do
member = user_fixture()
{:ok, view, _html} = live(conn, ~p"/admin/users/#{member.id}")
html = view |> element("#send-password-reset") |> render_click()
assert html =~ "Password reset email sent."
assert_email_sent(to: member.email, subject: "Reset password instructions")
end
defp user_with_role(role) do
{:ok, user} = Accounts.update_user_role(user_fixture(), role)
user
end
end
@@ -1,6 +1,8 @@
defmodule ChesstrainerWeb.UserLive.LoginTest do
use ChesstrainerWeb.ConnCase, async: true
@moduletag :capture_log
import Phoenix.LiveViewTest
import Chesstrainer.AccountsFixtures
@@ -0,0 +1,93 @@
defmodule ChesstrainerWeb.LoginThrottleTest do
use ExUnit.Case, async: false
alias ChesstrainerWeb.LoginThrottle
@address {203, 0, 113, 7}
@other_address {198, 51, 100, 9}
@login "someone@example.com"
setup do
LoginThrottle.reset()
:ok
end
test "uses the tightened limits and a 15 minute window" do
assert LoginThrottle.max_per_login() == 5
assert LoginThrottle.max_per_ip() == 10
assert LoginThrottle.window_ms() == :timer.minutes(15)
end
test "blocks the next attempt after the login limit is reached" do
for _ <- 1..(LoginThrottle.max_per_login() - 1) do
assert :ok = LoginThrottle.record_failure(@address, @login)
end
assert :ok = LoginThrottle.check(@address, @login)
assert :ok = LoginThrottle.record_failure(@address, @login)
assert {:throttled, :login, retry_in_ms} = LoginThrottle.check(@address, @login)
assert retry_in_ms > 0
end
test "blocks the next attempt after the address limit is reached across logins" do
for index <- 1..LoginThrottle.max_per_ip() do
assert :ok = LoginThrottle.record_failure(@address, "user#{index}@example.com")
end
assert {:throttled, :ip, retry_in_ms} =
LoginThrottle.check(@address, "fresh@example.com")
assert retry_in_ms > 0
end
test "a successful login clears only the login bucket" do
for _ <- 1..(LoginThrottle.max_per_login() - 1) do
LoginThrottle.record_failure(@address, @login)
end
assert :ok = LoginThrottle.record_success(@login)
for _ <- 1..(LoginThrottle.max_per_login() - 1) do
LoginThrottle.record_failure(@address, @login)
end
assert :ok = LoginThrottle.check(@address, @login)
end
test "addresses are independent" do
for index <- 1..LoginThrottle.max_per_ip() do
LoginThrottle.record_failure(@address, "user#{index}@example.com")
end
assert {:throttled, :ip, _} = LoginThrottle.check(@address, "fresh@example.com")
assert :ok = LoginThrottle.check(@other_address, "fresh@example.com")
end
test "log fingerprints are stable and do not expose the address" do
fingerprint = LoginThrottle.fingerprint(@address)
assert is_binary(fingerprint)
assert fingerprint == LoginThrottle.fingerprint(@address)
refute fingerprint =~ "203.0.113.7"
end
test "confirmation resends are claimed at most once per cooldown" do
assert LoginThrottle.claim_confirmation_resend(@login)
refute LoginThrottle.claim_confirmation_resend(@login)
assert LoginThrottle.claim_confirmation_resend("another@example.com")
end
test "reset clears every bucket" do
for index <- 1..LoginThrottle.max_per_ip() do
LoginThrottle.record_failure(@address, "user#{index}@example.com")
end
assert {:throttled, :ip, _} = LoginThrottle.check(@address, "fresh@example.com")
LoginThrottle.reset()
assert :ok = LoginThrottle.check(@address, "fresh@example.com")
end
end