ParlorNet
Turn-based game server for any computer, old or new
Clients | Protocols | Browsers | Telnet programs | Docs | Source

Identity, sign-in, sessions and the extension channel (security design)

This is the design the code follows. docs/accounts.md describes sign-in for operators and players, docs/protocol.md the wire.

Assets

  1. A player's ability to act as themselves: move, resign, invite, chat, change their password. Taking it over is the main thing to prevent.
  2. Credentials: passwords (sign-in password), TOTP secrets (sign-in totp), mailed codes (sign-up email and recovery), the operator's one-time passwords, the admin password.
  3. Sessions: proof that a sign-in happened, held by a server extension for a player.
  4. Extension keys: proof that a program is one of this parlor's server extensions (and, with the admin role, its admin adapter).
  5. Availability of sign-in for honest players.

Attackers

WhoCanMust not be able to
Anyone on the internet, at the public ports (6500-6507)open connections, send anything, guesssign in without the credential; resume a session; reach the extension channel or the admin socket
A curious or malicious playereverything a player can; read their own pages, URLs, cookiesact as another player
Someone who sees a URL, a log, a screenshot or browser historyread whatever was therefind a credential in it; find a working session id in it (cookie browsers; see Accepted risks for browsers without cookies)
A compromised server extension (its key stolen, or code execution in its process)speak the protocol on the extension channel as that server extension; with code execution in the default single-user container, read what that user reads (see Containment)resume sessions issued to other server extensions; sign in as a player without that player's credential (except under none); make admin requests; with a stolen key alone, or with code execution under either opt-in containment, read the database or another extension's key
An impersonated core or server extension (no key)answer or open connections on the server extension portcomplete a TLS handshake
Someone holding a copy of the databaseread it offlineuse passwords or session ids from it (they are hashed); see Data at rest for TOTP secrets
An operator mistake: publishing the server extension port (6590) or the admin socket (6599)-turn that into player takeover or admin access: both need a key

In code the extension channel is --frontend-port, parlord/frontends.py, --key and the key role frontend, names from before the project settled on "server extension" (docs/architecture.md); in this document a frontend is the program a player uses.

Trust boundaries

 8-bit / native clients --plain text, 6501--------------------------> core: public listener
 browsers --HTTP 6500--> web          \
 terminals --telnet 6502--> telnet     |
 Eclipse --IOS 6503--> ios             > TLS 1.3, PSK per extension, 6590 --> core: extension listener
 FIBS clients --6505--> fibs           |
 Outland Gateway --6506--> outland     |
 (no port) bot ------------------------/
 operator --telnet 6510--> admin adapter --TLS 1.3, admin-role PSK, 6599--> core: admin socket
                                                   |
                       accounts component (parlord/accounts.py): players, sessions, lockouts
                       sign-in methods (parlord/auth.py): none, password, totp
                       sign-up methods (parlord/auth.py): none, password, email

The auth abstraction

parlord/accounts.py, class Accounts. The core calls nothing else for identity; server extensions call nothing but the protocol.

CallDoes
greeting()AUTH=method LABEL=...
begin(conn, name, given, mode)HELO (mode any), USER (signin: an unknown name is refused), REG (signup: a taken or reserved name is refused); given is the second word, handed to the method
answer(conn, field, value)AUT
resume(conn, sid)SES: server extension connections only, sessions issued to that server extension only
current(conn)on every request: the signed-in player, or None; signs out a connection whose session was ended or grew past its absolute age; touches the session
sign_out(conn, everywhere)OUT, OUT all
change(conn)PWD (sign-in password only): the change steps; ends the player's other sessions
suspend, reset, deletefor the admin: each ends every session of the player
sweep()drops expired sessions

Behind it, parlord/auth.py has two registries, run as one dialogue (class Auth): sign-in methods (none, password, totp), which check a credential at every sign-in and own recovery, and sign-up methods (none, password, email), which make the account and set up what the sign-in method needs. Pairs that work: none+none, password+password, password+email, totp+email; others are refused (combo_problem). Each step is generic: info lines, ask (text, secret or yes/no, maybe flagged cred), then ok player or err code text. A method never issues anything that outlives the flow except the credential it sets up (a password hash, a TOTP secret). Out-of-band artefacts (the QR code) go by mail, never through a server extension; verification is always a typed code. After ok, Accounts refuses suspended players and creates the session; this holds for none too.

Sign-inCredentialHELO name xRecovery
nonethe nameignored-
passworda password the player chose (8 to 64 printable ASCII)refused: the password is asked foraddress on file: reset at the question (also while locked), a mailed 8-digit code, a new password; else the operator's one-time password (24 hours)
totpthe current 6-digit codex is a code (6 digits; anything else refused without counting), same lockouts and no replay; for direct 8-bit clients onlyreset at the question (also while locked): a new setup mailed to the address on file with an 8-digit code, typed first, then a code from the new setup

There is no other way in: no token, no resume credential, no "remember me". A session id is never accepted where a credential is.

**Sign in and sign up apart (USER, REG).** USER signs in only and REG signs up only, so a mistyped name at a sign-in never becomes an account; HELO still does either, for older clients. What they disclose is what HELO always did: whether a name has an account (HELO for a free name starts a sign-up). Names are not secret here (the lobby, LST, who and invitations show them; INV to an unknown name is ERR NOPLAYER), so the design does not hide them; it limits how fast they can be listed: USER for a name with no account counts against the client address in a budget the size of the sign-up one (20 in 10 minutes, ERR BUSY wait=N after), so it lists names no faster than HELO could. Email addresses stay undisclosed exactly as before (finding 5): REG reaches the same email dialogue. The web's and telnet's messages for an unknown name ("There is no account named x here") and a taken one ("The name x is taken") say what the core's codes say and nothing more; they never say whether a name has an address or is locked. The words new and guest are reserved in the core (auth.RESERVED_NAMES, checked when any sign-up starts and again when the account is made), so no account can stand behind a frontend's keyword.

Never volunteered. Server extensions sign in with the name alone. A password their client already supplied answers only an ASK flagged cred (the first one, or every one for a client that cannot be prompted), and is dropped if none comes: under none, and for every step of an email sign-up except choosing the password. Tests assert this on the lines the core receives (tests/test_ios.py, tests/test_fibs.py).

**Step kinds and CAN.** A server extension declares the kinds it can show (text, secret, yn, info). A step outside them is refused with ERR CANNOT; the method's state for that sign-in is dropped. Notes (optional info) are sent but not required.

Sessions

Extension channel

What each server extension may and must do

Data kept per extension and player

PRF (docs/protocol.md) lets each server extension keep a little data with a player, such as a display setting.

The bot

The bot (docs/bot.md, bot/) is a player program, run as a server extension of its own with no port: it serves no clients, so it has no gate, no SRC and no credentials to relay.

Lockouts and rate limits

Logging

Never logged: passwords, codes, AUT values, session ids, extension keys, the admin password, request lines of failed requests (the core logs the verb and the exception type only; the web logs the exception type and line), what players say to each other (IOS and FIBS log a typed command as typed, but only the verb of tell, say and the other chat commands, and nothing of a line that is not a command). The mail transport log logs address and subject only; test (the test suite) also prints bodies. Logged: server extension names, enrolments, counts of failed SES, sessions ended by a key change, wrong admin passwords (with the client address).

Data at rest

WhatHow
passwordsscrypt (n=16384, r=8, p=1), 16-byte salt; parameters stored with the hash
operator's one-time passwordsPBKDF2-SHA256, 100,000 rounds, 16-byte salt; used once, within 24 hours
session idsSHA-256 (128-bit random ids need no slow hash)
TOTP secretsin the clear (the server must compute codes)
admin passwordscrypt (parlord/admin.py)
extension keyskey files beside the database: mode 600, or in the container 640 with the server extension's own group
names; an account's email addressin the clear (the player row)
email addresses in the mail tables (log, blocked, sign-up cooldown)HMAC-SHA256 under a random 256-bit key kept in the database (meta addr:key), so no list of addresses that never became accounts is kept; with a copy of the database one can test an address one guesses, not list them. Rows from before are hashed when the database is opened. An address the operator types to clear its cooldown is hashed for the lookup and not stored or logged
SMTP passwordin the clear: in the settings file (preferred: mounted read-only, readable by the core's user only, never in the database), or, if set in the admin menus, in the database's meta table
email log (address, name, kind, client address)in the clear, 3 days
data kept with PRF (per extension and player)in the clear; never secrets; deleted with the account
email log (address hash, name, kind, client address)3 days
pending sign-ups (name, address hash, the mailed code or setup)in memory only, until they finish or reach their time

The old design's plaintext tokens are wiped when the database is first opened by this version (players.token is emptied when the cred column is added); the token method is gone. A player from before who is not a TOTP player needs an operator reset (a one-time password); TOTP players keep signing in with their authenticator.

Where the security-critical code is

FileWhat
parlord/accounts.pysessions (create, resume, validity, end, sweep), finish (step-kind check, suspended check, session creation), account actions
parlord/auth.pythe two registries and Auth, password hashing, the choose-and-confirm steps, TOTP check and replay, recovery, lockouts, MailOut (caps, setup and code mail, held mail, the blocked file), Signups and EmailSignUp.mail_step (the address cooldown, pending sign-ups, indistinguishable answers)
parlord/frontends.pykey files, the per-connection server context and PSK callback, accept, the client context
parlord/native.pythe public port's start (the client's newline first, its line ending) and line reading
parlord/core.pycmd_prf (namespace from the key name, the signed-in player only, limits), dispatch (identity on every request), cmd_helo, cmd_aut, cmd_ses, cmd_out, cmd_pwd, cmd_can, signed, handle_frontend, the sweep that closes connections of rotated keys
parlord/admin.pythe admin socket handshake and the account actions it forwards
parlord/store.pyaddr_hash (the mail tables' keyed hashes)
adapters/common.pyCoreClient.connect (TLS checks), CoreClient.req (no control characters), Gate (connections before and after sign-in), sign_in_lines
adapters/web.pysession_of, route (resume, CSRF check), login, make_room, signed_in, location_host, cookie handling, POST parsing
deploy/start.py, Dockerfile, deploy/install.sh, deploy/install-split.shusers and file modes in /data; the default and the two opt-in containments

Attack surface

Assumptions

Containment

The default: one container, one unprivileged user. The container runs as parlord (uid 10042, the image's USER; deploy/install.sh also says --user 10042:10042) with --cap-drop ALL, no capability added, no-new-privileges, a read-only root, on the isolated parlor bridge network (no host networking). Every process (start.py, parlord, the game plugins, every server extension) is that user. /data and the key directory are 700, the database and the keys 600 (umask 077). start.py logs start: per-extension users are off: every process runs as uid 10042. Started as root without the SETUID and SETGID capabilities it cannot switch to an unprivileged user and refuses to start (it would otherwise run everything as root), saying to use --user 10042.

What this protects: the host (no privileges, no host network, nothing writable but /data and /tmp), and the keys and database against everyone outside the container. What it leaves shared: inside the container every process can read the database (every TOTP secret, admin:pw's hash, the SMTP password if set in the menus) and every key, including admin.key. Code execution in any server extension therefore reaches every account and the admin socket. The key roles still hold against a stolen key file, not against a compromised process.

Two alternatives, both opt-in; a proposal for the operator to decide.

(a) One container per process (deploy/install-split.sh, deploy/README.md). The core runs in its own container (uid 10042) holding the database. Each server extension runs in a container of its own under its own uid (10043-10049), with only its own key, mounted read-only from a host copy owned by that uid (mode 400), and no /data. Every container gets the same flags as the default: --cap-drop ALL, no capability added, no-new-privileges, read-only root, --user; no host networking. Networks: parlor-int, created --internal (no way out), carries only the extension channel (6590) and the admin socket (6599), bound to the core's address on it; the core and the extensions join it. The core's native port (6501) is bound to its address on parlor, which also gives it its way out to the SMTP relay. Each extension's published port sits on a network of its own (parlor-NAME) without NAT, bound to the extension's address there. So an extension reaches the core's 6590 and 6599 (which want its key, and the admin-role key) but not the core's 6501 or the other extensions over the internal network. Protects: a compromised server extension cannot read the database or another key and shares no process, filesystem or loopback with the core; it is left with its own sessions; one extension's idle sockets cannot hold the core's handshake slots (per-address slots). Costs: seven containers and eight networks instead of one; the admin menus' choice of server extensions is not used (the script lists them); keys are copied by the host script. Left open (tested on Docker Desktop): Docker forwards to published ports by container address from other bridges, so an extension can reach the other containers' published ports (the ones any client reaches; 6510 among them, guarded by the admin password, locked per address); and "without NAT" stops a way out on a Linux host (replies to a private source address never come back) but not inside Docker Desktop's VM. The host firewall should drop forwarding from the parlor-NAME bridges to settle both.

(b) One container, a user per process (built; needs extra capabilities, so it is not the default). Start the image as root with --user 0 --cap-add SETUID --cap-add SETGID --cap-add KILL. start.py keeps root (with only those three capabilities) to start, watch and stop the others, and reads no network input:

ProcessUserCan read in /data
start.py (supervisor, PID 1)root, only SETUID, SETGID and KILLnothing (it cannot even list /data)
parlord, the game pluginsparlord (10042)everything: the database (600), every key
each server extensionpn-web, pn-telnet, pn-ios, pn-ggs, pn-fibs, pn-outland, pn-admin, pn-bot (10043-10050)its own key file only (640, group pn-<name>); /data and the key directory are 711, so it reaches its key by name and lists nothing

A first step run as parlord (start.py --prepare per-user) sets these modes on every start, and the default mode sets them back to 700 and 600. parlord is a member of every pn- group, so python -m parlord.frontends run as parlord gives a new or rotated key to its extension's group in this layout. Protects: the database and other keys against code execution in a server extension. Leaves shared: one kernel, one network namespace and loopback (a compromised extension can connect to 6590 and 6599 like anyone, without their keys), the others' command lines in /proc (no secrets are on a command line); and it needs the three capabilities, which the default does without.

In every mode the SMTP settings file is mounted read-only and must be readable by uid 10042 only; a kernel or Python sandbox escape is out of scope.

Residuals, after the re-tests

Out of scope (accepted)

Review findings and fixes

An adversarial review of this design and its code (branch sessions at 3dbbf5d) found the items below. Its reproductions are in review/ (python3.13 review/r1_extension_exhaustion.py and so on; R1 needs ulimit -n 8192); tests/test_review_fixes.py has a test class for each item (F01... to F15...).

#SeverityFindingWhat changed
1HighIOS and FIBS opened a core connection for every TCP connect, before any login, and counted only signed-in players, so about 400 idle connects from one address filled the core's single extension-channel cap and shut out every server extension.IOS, FIBS, telnet and Outland open their core connection only once the client has sent a login line (telnet fetches the message of the day over a short shared connection, at most once a minute). common.Gate counts each adapter's clients that have not signed in: at most 20, 4 from one address, 2 minutes to send the login line and 10 to finish signing in; signed-in players have their own cap. The web caps requests per address (20) and sign-in dialogues (finding 6). The core gives each server extension its own share of the extension channel (250 connections per key name, 1200 in all, 32 in the TLS handshake), so a flood through one cannot starve the others.
2HighSMTP STARTTLS without certificate verification: anyone on the path to the relay (or answering for its name) got the relay credentials and every mail, so any TOTP account could be taken over through reset.ssl.create_default_context() for STARTTLS (and implicit TLS on port 465 or with email.smtp_tls=tls): the chain is verified against the system's CA certificates and the relay host (email.smtp_host) is the TLS server name. A relay without STARTTLS, or whose certificate does not verify, gets nothing; the step is refused (ERR NOMAIL). email.smtp_ca_file adds a CA of the operator's own. The image checks at build time that the CA bundle is there.
3MediumWrong codes at the recovery steps (the mailed password-reset code, the TOTP re-enrolment) did not count toward the lockout; each mail gave 5 free guesses.Every code check counts toward the name's lockout. Mailed codes are 8 digits, 3 tries each. A TOTP reset mails the new setup with an 8-digit code that is typed first (proving the mailbox), then a code from the new setup. Mails per name are 2 an hour and 4 a day. The numbers, with the +-1 TOTP window, are under Lockouts and rate limits.
4MediumLockouts never decayed (one guess a day kept a name locked for good) and blocked the player's own recovery.The count halves after each 8 hours without a wrong answer; the longest wait is 4 hours (was a day). While a name with an address on file is locked, the question is still asked with a note, and only reset (recovery by mail, with its own limits) is accepted.
5MediumEmail sign-up said which name owns an address (ERR EMAILINUSE ... alice).An address that already has a name gets a notice mail to its owner, and the dialogue goes on exactly as for a free address (the same lines, the same caps; no code can finish it), so it never tells whether or to whom an address belongs. The notice counts as sign-up mail; recovery mail to an address counts only recovery mail to it, so notices cannot use up the owner's recovery.
6Medium100 anonymous POSTs filled the web's 100 sign-in slots for 15 minutes.At most 4 sign-in dialogues per client address; a dialogue waits 5 minutes for its next answer (was 15); when full, the oldest is ended instead of refusing new ones. The core also limits sign-ups per client address (finding 13).
7MediumEmail availability: one shared server-wide budget for sign-up and recovery, no per-source caps, and 4 bounced addresses held every new sign-up until the operator acted.Per-client-address caps (4 an hour, 10 a day; the web and every adapter pass the address with SRC, the public port uses its own). Separate server-wide budgets for sign-up and for recovery. Bounces are counted by who asked for the mail: a client address with 2 bounced addresses in a day gets no more sign-up mail that day; the hold on all sign-ups needs bounces from more than 3 requesters; recovery mail to addresses on file is never held.
8MediumContainment existed only on paper: every process in the container ran as one user, so code execution in any adapter could read the admin key, every key and the database.Written down honestly under Containment. The default stays one unprivileged user with no capabilities (database and keys 600, directories 700), and says so in the log. Two opt-in alternatives are offered for the operator to decide: one container per process (deploy/install-split.sh, no extra privileges) and a user per process in one container (needs SETUID, SETGID and KILL).
9LowA newline in a web form answer became a second protocol line on the extension channel.CoreClient.req refuses any request with a control character (CR, LF, NUL, DEL and the rest), for every adapter; the web shows "That has characters that cannot be used". Validation regexes end in \Z, not $.
10LowRotating or removing an extension's key did not end the sessions it was issued.Sessions store the issuing key's fingerprint; SES with another key fails and ends the session, and every sweep ends the sessions of a rotated or removed key (also after a restart). Sessions stored before this change have no fingerprint and end at their first resume.
11LowThe web's per-address resume limit deleted the cookies of everyone behind the same address.Past the limit, a session id that has resumed through this web before is still tried, and the cookie is no longer cleared when the limit stops a resume.
12LowA deleted player's seats, running games and private tables passed to the next account with the same name.Deleting an account ends its running games (END abandoned), gives up its seats at open tables (a table left empty goes), clears its ownership, and removes finished private tables it played at, besides withdrawing its invitations.
13LowUnlimited scrypt work during sign-up.A chosen password is held as a keyed HMAC until its confirmation matches and is hashed once then; at most 2 scrypt hashes run at once; one client address may start at most 20 sign-ups in 10 minutes.
14LowThe raw Host header went into Location (a bare LF split the header).A request with a bare CR or LF (or NUL) in any line is refused (400). Redirects use the Host header only if it is a well-formed host name or address with an optional port, else the default name.
15InfoSmaller items.Non-ASCII in a code or the admin setup password is a wrong answer, not an internal error (auth.same compares bytes). The greeting shortens or drops LABEL to fit 80 bytes; MOTD lines are at most 73 characters and long words are cut. The SMTP password is listed under Data at rest (the settings file is preferred). IOS and FIBS log commands but not chat text or non-command lines. The IOS docstring now says the password answers only a cred question. The image no longer EXPOSEs 6510 (the admin adapter listens on 0.0.0.0 inside the container so Docker can forward the host's loopback to it; see Assumptions). Wrong admin passwords lock the client address they come from, with the same decay, not everyone. The operator's one-time password works for 24 hours. python -m parlord.frontends refuses names that are not extension names (no paths).

The default deploy (deploy/install.sh) adds no capability: --user 10042:10042 --cap-drop ALL --security-opt no-new-privileges, as before.

Re-test (round 2)

The reviewer re-tested at e0a6283 (review/r14_accounts_retest.py, r1b_gate_retest.py, r16_web_and_cpu_retest.py, split_probe.py and the others in review/). Tests: tests/test_retest_fixes.py.

#SeverityFindingWhat changed
N1MediumWith the 4-hour cap a guesser got about 6 TOTP guesses per name per day, and wrong answers were counted only per name (40 names from one connection, all checked).Wrong-answer budgets per client address (12 a day) and for the server (48 a day) for addresses not trusted for the name, checked before the credential, with wait= reasons; trusted addresses (signed in as that name in the last 30 days) are exempt. The arithmetic is under Lockouts and rate limits: at most 48 untrusted guesses a day server-wide, about 5% a year that some TOTP account falls, under one guess per name per day past 48 players.
N2MediumOne address could keep a named player out of sign-in and recovery (the per-name reset mail cap was shared by anyone).Recovery mail is counted per requesting address first (2 a day for a name). A trusted address (the owner's) has its own allowance, held up by none of the shared caps. Untrusted requests share the name's 4 a day, with no hourly cap per name, so one stranger address can no longer use up the name's hour or day. The trade-off is written down under Lockouts and rate limits.
N3Medium32 idle connections to 6590 blocked every extension (a global handshake cap).Handshake slots per client address (8; the admin socket 2) and in all (64; the admin socket 8), 3 seconds to finish; a new socket over a limit ends the oldest handshake of its address (or of the busiest) instead of being refused. In the split mode an extension container holding 64 idle sockets to 6590 no longer affects the web (tested locally).
N4Low-MediumFive addresses filled the 20 pre-login places of a line adapter; IPv6 was not grouped by /64 in the adapters and the web.The gate and the web's per-address limits group IPv6 by its /64 as the core does; the gate's pending places grow with the adapter's size (max(20, its signed-in cap)); a newcomer is never refused for want of pending places: the least recently active pending connection of its own address, or of the busiest, is closed ("Server is full") instead.
N5LowA newcomer who signed in from an address over the web's resume limit could not reach the lobby.A session id issued by the web is known good at once.
N6LowWhen the web's 100 dialogues were full, the globally oldest was ended (a player waiting for a mailed code).The oldest dialogue of the address holding the most is ended.
N7LowThe split mode put 6590, 6599 and every port on one ordinary bridge, with a way out; admin socket handshakes were uncapped.--internal network for 6590 and 6599 (bound there only), the core's 6501 on its public network, each extension on a network of its own without NAT, bound to its address there; admin socket handshakes capped (N3). What remains open is under Containment.
N8LowBlocked addresses never mailed by ParlorNet (another sender's suppressions, a first import of a list) counted toward the hold on sign-ups.Only blocked addresses that parlord mailed in the day before count.
N9LowPassword sign-in work (scrypt) was unbounded per address.At most 30 password checks a minute from one client address.
F14LowA well-formed foreign Host was reflected in redirects.Optional setting web.hosts (admin menus, or PARLOR_WEB_HOSTS; the web gets it at start): the names (name or name:port) the site answers to; any other Host header falls back to the first. Empty by default; for parlornet.org see deploy/README.md.
Info-A key file made unreadable or malformed by hand ended its extension's sessions at the next sweep.Only a key that is gone or replaced ends sessions.
Info-A long server name drops the label from the greeting; a compromised extension can claim any SRC.Written down under Residuals.

Re-test (round 3)

The reviewer re-tested at 1f5d0bd and judged the branch fit to merge with conditions (review/r17_round2_accounts.py, r17b_recovery_budget.py, r18_round2_slots.py, split2_probe.py, split2_check.py). Tests: the R21... and R2... classes in tests/test_retest_fixes.py, and test_r2_2_... in tests/test_review_fixes.py.

#SeverityFindingWhat changed
R2-1MediumFrom about 10 addresses, players on new addresses lost sign-in and recovery for as long as the attack lasted; strangers' resets used up the server recovery budget the owners' own recovery shared; only a restart freed the budgets.Owners' own recovery (asked from a trusted address, or finished with the right mailed code) has a server budget of its own (own_recovery_per_hour 20, own_recovery_per_day 60); strangers' resets count only against theirs. The admin Status screen shows the wrong-answer and mail budgets with an alarm, and "Clear budgets" frees them (not the per-name lockouts or caps). The Residuals say exactly what still holds.
R2-2Low-MediumEvicting the busiest address broke ties toward the oldest waiter: 40 addresses with one pending connection each closed a waiting player; IPv6 /64s each counted apart.The gate and the web's dialogues close a connection only at an address holding more than the newcomer's would, the newest arrival there on a tie; otherwise the newcomer waits outside. IPv6 counts by its /48 everywhere (one key for counting and for eviction, which is simpler and stricter).
R2-3LowIn one container a compromised extension makes the others' new core connections fail, not just slow.The Residuals say so.
R2-4LowSplit-mode isolation was weaker than stated under Docker Desktop; Linux unverified.The Residuals give the measured reach and require a re-run on a Linux Docker host before the split mode is recommended.
--web.hosts for the live site.install.sh passes PARLOR_WEB_HOSTS through from the operator's environment and start.py reads web.hosts from the settings file; nothing is hard-coded. deploy/README.md gives parlornet.org's value, parlornet.org,parlornet.org:6500,www.parlornet.org.

Final review

The reviewer cleared the branch at 32d5806. Tests: R3FutureClearTimes in tests/test_retest_fixes.py.

#SeverityFindingWhat changed
R3-1LowOne IPv6 /48 can hold many unrelated subscribers.Written down under Residuals.
-InfoA budget-clear time in the future (budgets.cleared, written into the settings file by hand) switched off the server-wide mail limits.A clear time that is not in the past is ignored (auth.past_time); so is a future email.new_ok_since, which would otherwise lift the hold on sign-up mail.

Sign-up limits (after the reviews)

Rules for sign-up mail added after the reviews (Lockouts and rate limits: Sign-up email per address, Sign-ups waiting for their code, Indistinguishable answers). Tests: tests/test_signup_limits.py.

Earlier itemWhat the sign-up rules change
Finding 5 (who owns an address)Kept: the notice to an owner is the address's one sign-up email like any other, and every case at the address step (mail sent, notice, mail held back, taken up again) answers alike, passes the same caps and is counted the same.
Finding 7 (email availability)The per-client-address caps, the separate sign-up and recovery budgets and the bounce holds stay as they were, as defence in depth. The one-mail rule makes most of the per-address sign-up caps moot (one a week), and the cap on waiting sign-ups bounds names and memory held by half-done sign-ups.
R2-1 (budgets under attack)Unchanged: recovery mail keeps its own budgets and rules, outside the cooldown and the places; Clear budgets does not touch either.
ResidualsThe way to have the server mail someone repeatedly through sign-up (6 a day per address, notices included) is closed: one a week. New residuals for the rule's cost are listed there.

This doc on GitHub


 These pages cover every ParlorNet server. | Source code | ParlorNet is free software.